Deploy from GitHub Actions 2025-12-15_23-41-14

apps/backend/package.json

@@ -13,7 +13,12 @@
     "lint": "eslint .",
     "neural-bridge": "tsx src/mcp/servers/NeuralBridgeServer.ts",
     "neural-bridge:build": "tsc && node dist/mcp/servers/NeuralBridgeServer.js",
-    "ingest-drive": "tsx src/scripts/ingest-drive.ts"
+    "ingest-drive": "tsx src/scripts/ingest-drive.ts",
+    "sync-neo4j": "tsx src/scripts/sync-neo4j-to-cloud.ts",
+    "sync:start": "tsx src/scripts/neo4j-auto-sync.ts start",
+    "sync:now": "tsx src/scripts/neo4j-auto-sync.ts sync",
+    "sync:full": "tsx src/scripts/neo4j-auto-sync.ts full",
+    "sync:status": "tsx src/scripts/neo4j-auto-sync.ts status"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.71.0",

apps/backend/src/index.ts

@@ -615,6 +615,11 @@ async function startServer() {
     app.use('/api/email', emailRoutes);
     console.log('📧 Email API mounted at /api/email');
 
+    // Neo4j Sync API - Auto-sync between local and cloud
+    const neo4jSyncRoutes = (await import('./routes/neo4j-sync.js')).default;
+    app.use('/api/neo4j-sync', neo4jSyncRoutes);
+    console.log('🔄 Neo4j Sync API mounted at /api/neo4j-sync');
+
     // Start KnowledgeCompiler auto-compilation (every 60 seconds)
     const { knowledgeCompiler } = await import('./services/Knowledge/index.js');
     knowledgeCompiler.startAutoCompilation(60000);

apps/backend/src/routes/neo4j-sync.ts

@@ -0,0 +1,102 @@
+/**
+ * Neo4j Sync API Routes
+ *
+ * Provides REST endpoints for Neo4j sync status and control.
+ */
+
+import { Router, Request, Response } from 'express';
+import { getNeo4jAutoSync } from '../services/Neo4jAutoSync.js';
+
+const router = Router();
+
+/**
+ * GET /api/neo4j-sync/status
+ * Get current sync status
+ */
+router.get('/status', (_req: Request, res: Response) => {
+  try {
+    const syncService = getNeo4jAutoSync();
+    const status = syncService.getStatus();
+    res.json({
+      success: true,
+      data: status
+    });
+  } catch (error: any) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * POST /api/neo4j-sync/sync
+ * Trigger a sync (incremental by default)
+ */
+router.post('/sync', async (req: Request, res: Response) => {
+  try {
+    const { full = false } = req.body || {};
+    const syncService = getNeo4jAutoSync();
+
+    // Return immediately, sync runs in background
+    res.json({
+      success: true,
+      message: `${full ? 'Full' : 'Incremental'} sync started`,
+      data: { type: full ? 'full' : 'incremental' }
+    });
+
+    // Run sync in background
+    syncService.sync(full).catch(err => {
+      console.error('Background sync failed:', err);
+    });
+
+  } catch (error: any) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * POST /api/neo4j-sync/scheduler/start
+ * Start the scheduler
+ */
+router.post('/scheduler/start', (_req: Request, res: Response) => {
+  try {
+    const syncService = getNeo4jAutoSync();
+    syncService.startScheduler();
+    res.json({
+      success: true,
+      message: 'Scheduler started',
+      data: syncService.getStatus()
+    });
+  } catch (error: any) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * POST /api/neo4j-sync/scheduler/stop
+ * Stop the scheduler
+ */
+router.post('/scheduler/stop', (_req: Request, res: Response) => {
+  try {
+    const syncService = getNeo4jAutoSync();
+    syncService.stopScheduler();
+    res.json({
+      success: true,
+      message: 'Scheduler stopped'
+    });
+  } catch (error: any) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+export default router;

apps/backend/src/scripts/neo4j-auto-sync.ts

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+/**
+ * Neo4j Auto-Sync Runner
+ *
+ * Runs as a standalone service for automated Neo4j synchronization.
+ *
+ * Usage:
+ *   npx tsx apps/backend/src/scripts/neo4j-auto-sync.ts [command]
+ *
+ * Commands:
+ *   start     - Start scheduler (default)
+ *   sync      - Run single sync now
+ *   full      - Run full sync (ignores checkpoint)
+ *   status    - Show sync status
+ *   help      - Show this help
+ *
+ * Environment Variables:
+ *   NEO4J_LOCAL_URI        - Local Neo4j URI (default: bolt://localhost:7687)
+ *   NEO4J_LOCAL_USER       - Local Neo4j user (default: neo4j)
+ *   NEO4J_LOCAL_PASSWORD   - Local Neo4j password (default: password)
+ *   NEO4J_URI              - Cloud Neo4j URI
+ *   NEO4J_USER             - Cloud Neo4j user
+ *   NEO4J_PASSWORD         - Cloud Neo4j password
+ *   NEO4J_SYNC_SCHEDULE    - Cron schedule (default: "0 *\/6 * * *" = every 6 hours)
+ */
+
+import dotenv from 'dotenv';
+import path from 'path';
+import fs from 'fs';
+import { Neo4jAutoSync } from '../services/Neo4jAutoSync.js';
+
+// Load environment
+dotenv.config({ path: path.resolve(process.cwd(), '.env.production') });
+dotenv.config({ path: path.resolve(process.cwd(), '.env') });
+
+const STATUS_FILE = path.join(process.cwd(), '.neo4j-sync-status.json');
+
+async function main() {
+  const command = process.argv[2] || 'start';
+
+  console.log('═'.repeat(60));
+  console.log('🔄 Neo4j Auto-Sync Service');
+  console.log('═'.repeat(60));
+  console.log('');
+
+  switch (command) {
+    case 'start':
+      await startScheduler();
+      break;
+
+    case 'sync':
+      await runSync(false);
+      break;
+
+    case 'full':
+      await runSync(true);
+      break;
+
+    case 'status':
+      showStatus();
+      break;
+
+    case 'help':
+    default:
+      showHelp();
+      break;
+  }
+}
+
+async function startScheduler() {
+  const syncService = new Neo4jAutoSync();
+  const schedule = process.env.NEO4J_SYNC_SCHEDULE || '0 */6 * * *';
+
+  console.log('Configuration:');
+  console.log(`  Local:    ${process.env.NEO4J_LOCAL_URI || 'bolt://localhost:7687'}`);
+  console.log(`  Cloud:    ${process.env.NEO4J_URI || '(not configured)'}`);
+  console.log(`  Schedule: ${schedule}`);
+  console.log('');
+
+  // Run initial sync
+  console.log('Running initial sync...\n');
+  await syncService.sync();
+
+  // Start scheduler
+  syncService.startScheduler();
+
+  console.log('\n✅ Auto-sync service running. Press Ctrl+C to stop.\n');
+
+  // Keep process alive
+  process.on('SIGINT', () => {
+    console.log('\n⏹️  Shutting down...');
+    syncService.stopScheduler();
+    process.exit(0);
+  });
+
+  // Keep alive
+  setInterval(() => {
+    // Heartbeat
+  }, 60000);
+}
+
+async function runSync(forceFullSync: boolean) {
+  const syncService = new Neo4jAutoSync();
+
+  console.log(`Running ${forceFullSync ? 'FULL' : 'incremental'} sync...\n`);
+
+  const status = await syncService.sync(forceFullSync);
+
+  console.log('\n' + '═'.repeat(60));
+  console.log('Sync Result:');
+  console.log(`  Status:        ${status.status}`);
+  console.log(`  Type:          ${status.lastSyncType}`);
+  console.log(`  Nodes:         ${status.nodesSync}`);
+  console.log(`  Relationships: ${status.relationshipsSync}`);
+  console.log(`  Duration:      ${status.lastSyncDuration}ms`);
+  if (status.error) {
+    console.log(`  Error:         ${status.error}`);
+  }
+  console.log('═'.repeat(60));
+}
+
+function showStatus() {
+  if (fs.existsSync(STATUS_FILE)) {
+    const status = JSON.parse(fs.readFileSync(STATUS_FILE, 'utf-8'));
+    console.log('Current Sync Status:');
+    console.log('');
+    console.log(`  Status:           ${status.status}`);
+    console.log(`  Last Sync:        ${status.lastSyncTime || 'Never'}`);
+    console.log(`  Sync Type:        ${status.lastSyncType || 'N/A'}`);
+    console.log(`  Nodes Synced:     ${status.nodesSync || 0}`);
+    console.log(`  Rels Synced:      ${status.relationshipsSync || 0}`);
+    console.log(`  Duration:         ${status.lastSyncDuration ? status.lastSyncDuration + 'ms' : 'N/A'}`);
+    console.log(`  Next Scheduled:   ${status.nextScheduledSync || 'N/A'}`);
+    if (status.error) {
+      console.log(`  Error:            ${status.error}`);
+    }
+  } else {
+    console.log('No sync status found. Run a sync first.');
+  }
+}
+
+function showHelp() {
+  console.log(`
+Usage: npx tsx apps/backend/src/scripts/neo4j-auto-sync.ts [command]
+
+Commands:
+  start     Start the scheduler service (runs continuously)
+  sync      Run a single sync (incremental if checkpoint exists)
+  full      Run a full sync (ignores checkpoint, replaces all data)
+  status    Show current sync status
+  help      Show this help message
+
+Environment Variables:
+  NEO4J_LOCAL_URI        Local Neo4j URI (default: bolt://localhost:7687)
+  NEO4J_LOCAL_USER       Local Neo4j user (default: neo4j)
+  NEO4J_LOCAL_PASSWORD   Local Neo4j password (default: password)
+  NEO4J_URI              Cloud Neo4j URI (required)
+  NEO4J_USER             Cloud Neo4j user (default: neo4j)
+  NEO4J_PASSWORD         Cloud Neo4j password (required)
+  NEO4J_SYNC_SCHEDULE    Cron schedule (default: 0 */6 * * * = every 6 hours)
+
+Schedule Examples:
+  0 */6 * * *     Every 6 hours
+  0 */2 * * *     Every 2 hours
+  0 0 * * *       Daily at midnight
+  */30 * * * *    Every 30 minutes
+  0 9,18 * * *    At 9am and 6pm
+
+Examples:
+  # Start auto-sync service (runs continuously)
+  npx tsx apps/backend/src/scripts/neo4j-auto-sync.ts start
+
+  # Run single sync
+  npx tsx apps/backend/src/scripts/neo4j-auto-sync.ts sync
+
+  # Force full sync
+  npx tsx apps/backend/src/scripts/neo4j-auto-sync.ts full
+
+  # Check status
+  npx tsx apps/backend/src/scripts/neo4j-auto-sync.ts status
+`);
+}
+
+main().catch(console.error);

apps/backend/src/scripts/sync-neo4j-to-cloud.ts

@@ -0,0 +1,470 @@
+/**
+ * Neo4j Local to Cloud Sync Script
+ *
+ * Syncs data from local Neo4j (bruttopuljen/master) to AuraDB cloud
+ * Run: npx tsx apps/backend/src/scripts/sync-neo4j-to-cloud.ts
+ */
+
+import neo4j, { Driver, Session, Record as Neo4jRecord, isNode, isRelationship } from 'neo4j-driver';
+import dotenv from 'dotenv';
+import path from 'path';
+
+// Load environment
+dotenv.config({ path: path.resolve(process.cwd(), '.env.production') });
+
+interface SyncConfig {
+  local: {
+    uri: string;
+    user: string;
+    password: string;
+    database: string;
+  };
+  cloud: {
+    uri: string;
+    user: string;
+    password: string;
+    database: string;
+  };
+}
+
+interface NodeData {
+  labels: string[];
+  properties: Record<string, any>;
+  elementId: string;
+}
+
+interface RelationshipData {
+  type: string;
+  properties: Record<string, any>;
+  startElementId: string;
+  endElementId: string;
+}
+
+interface SchemaItem {
+  type: 'constraint' | 'index';
+  name: string;
+  definition: string;
+}
+
+const config: SyncConfig = {
+  local: {
+    uri: 'bolt://localhost:7687',
+    user: 'neo4j',
+    password: 'password',  // Update if different
+    database: 'neo4j'
+  },
+  cloud: {
+    uri: process.env.NEO4J_URI || 'neo4j+s://054eff27.databases.neo4j.io',
+    user: process.env.NEO4J_USER || 'neo4j',
+    password: process.env.NEO4J_PASSWORD || '',
+    database: process.env.NEO4J_DATABASE || 'neo4j'
+  }
+};
+
+async function createDriver(connectionConfig: SyncConfig['local'] | SyncConfig['cloud']): Promise<Driver> {
+  return neo4j.driver(
+    connectionConfig.uri,
+    neo4j.auth.basic(connectionConfig.user, connectionConfig.password),
+    {
+      maxConnectionLifetime: 3 * 60 * 60 * 1000,
+      connectionAcquisitionTimeout: 2 * 60 * 1000,
+    }
+  );
+}
+
+async function exportSchema(session: Session): Promise<SchemaItem[]> {
+  console.log('📋 Exporting schema from local...');
+  const schema: SchemaItem[] = [];
+
+  // Export constraints
+  const constraintResult = await session.run('SHOW CONSTRAINTS');
+  for (const record of constraintResult.records) {
+    const name = record.get('name');
+    const type = record.get('type');
+    const entityType = record.get('entityType');
+    const labelsOrTypes = record.get('labelsOrTypes');
+    const properties = record.get('properties');
+
+    let definition = '';
+    if (type === 'UNIQUENESS' && entityType === 'NODE') {
+      const label = labelsOrTypes?.[0] || 'Unknown';
+      const prop = properties?.[0] || 'id';
+      definition = `CREATE CONSTRAINT ${name} IF NOT EXISTS FOR (n:${label}) REQUIRE n.${prop} IS UNIQUE`;
+    }
+
+    if (definition) {
+      schema.push({ type: 'constraint', name, definition });
+      console.log(`  ✓ Constraint: ${name}`);
+    }
+  }
+
+  // Export indexes (excluding auto-generated and constraint-backed)
+  const indexResult = await session.run('SHOW INDEXES');
+  for (const record of indexResult.records) {
+    const name = record.get('name');
+    const type = record.get('type');
+    const entityType = record.get('entityType');
+    const labelsOrTypes = record.get('labelsOrTypes');
+    const properties = record.get('properties');
+    const owningConstraint = record.get('owningConstraint');
+
+    // Skip constraint-backed indexes
+    if (owningConstraint) continue;
+
+    let definition = '';
+    if (type === 'RANGE' && entityType === 'NODE') {
+      const label = labelsOrTypes?.[0] || 'Unknown';
+      const props = properties?.join(', ') || 'id';
+      definition = `CREATE INDEX ${name} IF NOT EXISTS FOR (n:${label}) ON (n.${props.split(',')[0].trim()})`;
+    } else if (type === 'FULLTEXT' && entityType === 'NODE') {
+      const label = labelsOrTypes?.[0] || 'Unknown';
+      const props = (properties || []).map((p: string) => `n.${p}`).join(', ');
+      definition = `CREATE FULLTEXT INDEX ${name} IF NOT EXISTS FOR (n:${label}) ON EACH [${props}]`;
+    } else if (type === 'VECTOR') {
+      const label = labelsOrTypes?.[0] || 'Unknown';
+      const prop = properties?.[0] || 'embedding';
+      definition = `CREATE VECTOR INDEX ${name} IF NOT EXISTS FOR (n:${label}) ON (n.${prop}) OPTIONS {indexConfig: {\`vector.dimensions\`: 384, \`vector.similarity_function\`: 'cosine'}}`;
+    }
+
+    if (definition) {
+      schema.push({ type: 'index', name, definition });
+      console.log(`  ✓ Index: ${name} (${type})`);
+    }
+  }
+
+  console.log(`  Total: ${schema.length} schema items`);
+  return schema;
+}
+
+async function exportNodes(session: Session): Promise<NodeData[]> {
+  console.log('\n📦 Exporting nodes from local...');
+  const nodes: NodeData[] = [];
+
+  const result = await session.run('MATCH (n) RETURN n, elementId(n) as elementId');
+
+  for (const record of result.records) {
+    const node = record.get('n');
+    const elementId = record.get('elementId');
+
+    if (isNode(node)) {
+      // Clone properties and convert Neo4j types to JS types
+      const properties: Record<string, any> = {};
+      for (const [key, value] of Object.entries(node.properties)) {
+        properties[key] = convertNeo4jValue(value);
+      }
+
+      nodes.push({
+        labels: [...node.labels],
+        properties,
+        elementId
+      });
+    }
+  }
+
+  console.log(`  ✓ Exported ${nodes.length} nodes`);
+
+  // Show label distribution
+  const labelCounts: Record<string, number> = {};
+  for (const node of nodes) {
+    for (const label of node.labels) {
+      labelCounts[label] = (labelCounts[label] || 0) + 1;
+    }
+  }
+  for (const [label, count] of Object.entries(labelCounts)) {
+    console.log(`    - ${label}: ${count}`);
+  }
+
+  return nodes;
+}
+
+async function exportRelationships(session: Session): Promise<RelationshipData[]> {
+  console.log('\n🔗 Exporting relationships from local...');
+  const relationships: RelationshipData[] = [];
+
+  const result = await session.run(`
+    MATCH (a)-[r]->(b)
+    RETURN r, type(r) as type, elementId(a) as startId, elementId(b) as endId
+  `);
+
+  for (const record of result.records) {
+    const rel = record.get('r');
+    const type = record.get('type');
+    const startId = record.get('startId');
+    const endId = record.get('endId');
+
+    // Clone properties and convert Neo4j types
+    const properties: Record<string, any> = {};
+    if (isRelationship(rel)) {
+      for (const [key, value] of Object.entries(rel.properties)) {
+        properties[key] = convertNeo4jValue(value);
+      }
+    }
+
+    relationships.push({
+      type,
+      properties,
+      startElementId: startId,
+      endElementId: endId
+    });
+  }
+
+  console.log(`  ✓ Exported ${relationships.length} relationships`);
+
+  // Show relationship type distribution
+  const typeCounts: Record<string, number> = {};
+  for (const rel of relationships) {
+    typeCounts[rel.type] = (typeCounts[rel.type] || 0) + 1;
+  }
+  for (const [type, count] of Object.entries(typeCounts)) {
+    console.log(`    - ${type}: ${count}`);
+  }
+
+  return relationships;
+}
+
+function convertNeo4jValue(value: any): any {
+  if (value === null || value === undefined) return value;
+
+  // Handle Neo4j Integer
+  if (typeof value === 'object' && value.constructor?.name === 'Integer') {
+    return value.toNumber();
+  }
+
+  // Handle Neo4j DateTime
+  if (typeof value === 'object' && value.constructor?.name === 'DateTime') {
+    return value.toString();
+  }
+
+  // Handle Neo4j Date
+  if (typeof value === 'object' && value.constructor?.name === 'Date') {
+    return value.toString();
+  }
+
+  // Handle arrays
+  if (Array.isArray(value)) {
+    return value.map(convertNeo4jValue);
+  }
+
+  // Handle Float arrays (embeddings)
+  if (typeof value === 'object' && value.constructor?.name === 'Float64Array') {
+    return Array.from(value);
+  }
+
+  return value;
+}
+
+async function clearCloud(session: Session): Promise<void> {
+  console.log('\n🗑️  Clearing cloud database...');
+
+  // Delete in batches to avoid memory issues
+  let deleted = 0;
+  do {
+    const result = await session.run(`
+      MATCH (n)
+      WITH n LIMIT 1000
+      DETACH DELETE n
+      RETURN count(*) as deleted
+    `);
+    deleted = result.records[0]?.get('deleted')?.toNumber() || 0;
+    if (deleted > 0) {
+      console.log(`  Deleted batch of ${deleted} nodes...`);
+    }
+  } while (deleted > 0);
+
+  console.log('  ✓ Cloud database cleared');
+}
+
+async function applySchema(session: Session, schema: SchemaItem[]): Promise<void> {
+  console.log('\n📋 Applying schema to cloud...');
+
+  for (const item of schema) {
+    try {
+      await session.run(item.definition);
+      console.log(`  ✓ ${item.type}: ${item.name}`);
+    } catch (error: any) {
+      if (error.message?.includes('already exists') || error.message?.includes('equivalent')) {
+        console.log(`  ⚠ ${item.type} ${item.name} already exists`);
+      } else {
+        console.error(`  ✗ Failed to create ${item.type} ${item.name}: ${error.message}`);
+      }
+    }
+  }
+}
+
+async function importNodes(session: Session, nodes: NodeData[], elementIdMap: Map<string, string>): Promise<void> {
+  console.log('\n📦 Importing nodes to cloud...');
+
+  let imported = 0;
+  const batchSize = 100;
+
+  for (let i = 0; i < nodes.length; i += batchSize) {
+    const batch = nodes.slice(i, i + batchSize);
+
+    for (const node of batch) {
+      try {
+        // Create node with labels and properties
+        const labelStr = node.labels.join(':');
+
+        // Generate a unique ID if not present
+        const nodeId = node.properties.id || `node_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        node.properties.id = nodeId;
+
+        const query = `
+          MERGE (n:${labelStr} {id: $nodeId})
+          SET n = $props
+          RETURN elementId(n) as newElementId
+        `;
+
+        const result = await session.run(query, {
+          nodeId,
+          props: node.properties
+        });
+
+        const newElementId = result.records[0]?.get('newElementId');
+        if (newElementId) {
+          elementIdMap.set(node.elementId, newElementId);
+        }
+
+        imported++;
+      } catch (error: any) {
+        console.error(`  ✗ Failed to import node: ${error.message?.slice(0, 100)}`);
+      }
+    }
+
+    console.log(`  Progress: ${imported}/${nodes.length} nodes`);
+  }
+
+  console.log(`  ✓ Imported ${imported} nodes`);
+}
+
+async function importRelationships(
+  session: Session,
+  relationships: RelationshipData[],
+  elementIdMap: Map<string, string>,
+  nodes: NodeData[]
+): Promise<void> {
+  console.log('\n🔗 Importing relationships to cloud...');
+
+  // Create a map from old elementId to node id (for relationship matching)
+  const elementIdToNodeId = new Map<string, string>();
+  for (const node of nodes) {
+    elementIdToNodeId.set(node.elementId, node.properties.id);
+  }
+
+  let imported = 0;
+  let skipped = 0;
+
+  for (const rel of relationships) {
+    try {
+      const startNodeId = elementIdToNodeId.get(rel.startElementId);
+      const endNodeId = elementIdToNodeId.get(rel.endElementId);
+
+      if (!startNodeId || !endNodeId) {
+        skipped++;
+        continue;
+      }
+
+      const query = `
+        MATCH (a {id: $startId})
+        MATCH (b {id: $endId})
+        MERGE (a)-[r:${rel.type}]->(b)
+        SET r = $props
+      `;
+
+      await session.run(query, {
+        startId: startNodeId,
+        endId: endNodeId,
+        props: rel.properties
+      });
+
+      imported++;
+    } catch (error: any) {
+      console.error(`  ✗ Failed to import relationship: ${error.message?.slice(0, 100)}`);
+    }
+  }
+
+  console.log(`  ✓ Imported ${imported} relationships (skipped ${skipped})`);
+}
+
+async function syncNeo4jToCloud() {
+  console.log('═'.repeat(60));
+  console.log('🔄 Neo4j Local → Cloud Sync');
+  console.log('═'.repeat(60));
+  console.log(`\nLocal:  ${config.local.uri}`);
+  console.log(`Cloud:  ${config.cloud.uri}`);
+  console.log('');
+
+  let localDriver: Driver | null = null;
+  let cloudDriver: Driver | null = null;
+
+  try {
+    // Connect to local
+    console.log('📡 Connecting to local Neo4j...');
+    localDriver = await createDriver(config.local);
+    await localDriver.verifyConnectivity();
+    console.log('  ✓ Connected to local');
+
+    // Connect to cloud
+    console.log('☁️  Connecting to AuraDB cloud...');
+    cloudDriver = await createDriver(config.cloud);
+    await cloudDriver.verifyConnectivity();
+    console.log('  ✓ Connected to cloud');
+
+    // Export from local
+    const localSession = localDriver.session({ database: config.local.database });
+
+    const schema = await exportSchema(localSession);
+    const nodes = await exportNodes(localSession);
+    const relationships = await exportRelationships(localSession);
+
+    await localSession.close();
+
+    // Confirm before clearing cloud
+    console.log('\n⚠️  This will REPLACE all data in cloud with local data!');
+    console.log(`    Nodes to sync: ${nodes.length}`);
+    console.log(`    Relationships to sync: ${relationships.length}`);
+
+    // Import to cloud
+    const cloudSession = cloudDriver.session({ database: config.cloud.database });
+
+    await clearCloud(cloudSession);
+    await applySchema(cloudSession, schema);
+
+    const elementIdMap = new Map<string, string>();
+    await importNodes(cloudSession, nodes, elementIdMap);
+    await importRelationships(cloudSession, relationships, elementIdMap, nodes);
+
+    await cloudSession.close();
+
+    // Verify sync
+    console.log('\n✅ Verifying sync...');
+    const verifySession = cloudDriver.session({ database: config.cloud.database });
+
+    const nodeCountResult = await verifySession.run('MATCH (n) RETURN count(n) as count');
+    const cloudNodeCount = nodeCountResult.records[0]?.get('count')?.toNumber() || 0;
+
+    const relCountResult = await verifySession.run('MATCH ()-[r]->() RETURN count(r) as count');
+    const cloudRelCount = relCountResult.records[0]?.get('count')?.toNumber() || 0;
+
+    await verifySession.close();
+
+    console.log(`  Cloud nodes: ${cloudNodeCount} (expected: ${nodes.length})`);
+    console.log(`  Cloud relationships: ${cloudRelCount} (expected: ${relationships.length})`);
+
+    console.log('\n' + '═'.repeat(60));
+    console.log('✅ SYNC COMPLETE');
+    console.log('═'.repeat(60));
+
+  } catch (error: any) {
+    console.error('\n❌ Sync failed:', error.message);
+    throw error;
+  } finally {
+    if (localDriver) await localDriver.close();
+    if (cloudDriver) await cloudDriver.close();
+  }
+}
+
+// Run
+syncNeo4jToCloud()
+  .then(() => process.exit(0))
+  .catch(() => process.exit(1));

apps/backend/src/services/Neo4jAutoSync.ts

@@ -0,0 +1,637 @@
+/**
+ * Neo4j Auto-Sync Service
+ *
+ * Automated synchronization between local Neo4j and AuraDB cloud.
+ * Supports full sync, incremental sync, and scheduled execution.
+ */
+
+import neo4j, { Driver, Session } from 'neo4j-driver';
+import cron from 'node-cron';
+import fs from 'fs';
+import path from 'path';
+
+export interface SyncConfig {
+  local: {
+    uri: string;
+    user: string;
+    password: string;
+    database: string;
+  };
+  cloud: {
+    uri: string;
+    user: string;
+    password: string;
+    database: string;
+  };
+  schedule?: string; // Cron expression
+  incrementalEnabled?: boolean;
+  batchSize?: number;
+}
+
+export interface SyncStatus {
+  lastSyncTime: string | null;
+  lastSyncType: 'full' | 'incremental' | null;
+  lastSyncDuration: number | null;
+  nodesSync: number;
+  relationshipsSync: number;
+  status: 'idle' | 'running' | 'success' | 'error';
+  error?: string;
+  nextScheduledSync?: string;
+}
+
+export interface SyncCheckpoint {
+  timestamp: string;
+  nodeCount: number;
+  relationshipCount: number;
+  lastNodeIds: string[];
+}
+
+const CHECKPOINT_FILE = path.join(process.cwd(), '.neo4j-sync-checkpoint.json');
+const STATUS_FILE = path.join(process.cwd(), '.neo4j-sync-status.json');
+
+export class Neo4jAutoSync {
+  private config: SyncConfig;
+  private localDriver: Driver | null = null;
+  private cloudDriver: Driver | null = null;
+  private cronJob: cron.ScheduledTask | null = null;
+  private status: SyncStatus = {
+    lastSyncTime: null,
+    lastSyncType: null,
+    lastSyncDuration: null,
+    nodesSync: 0,
+    relationshipsSync: 0,
+    status: 'idle'
+  };
+
+  constructor(config?: Partial<SyncConfig>) {
+    this.config = {
+      local: {
+        uri: config?.local?.uri || process.env.NEO4J_LOCAL_URI || 'bolt://localhost:7687',
+        user: config?.local?.user || process.env.NEO4J_LOCAL_USER || 'neo4j',
+        password: config?.local?.password || process.env.NEO4J_LOCAL_PASSWORD || 'password',
+        database: config?.local?.database || process.env.NEO4J_LOCAL_DATABASE || 'neo4j'
+      },
+      cloud: {
+        uri: config?.cloud?.uri || process.env.NEO4J_URI || '',
+        user: config?.cloud?.user || process.env.NEO4J_USER || 'neo4j',
+        password: config?.cloud?.password || process.env.NEO4J_PASSWORD || '',
+        database: config?.cloud?.database || process.env.NEO4J_DATABASE || 'neo4j'
+      },
+      schedule: config?.schedule || process.env.NEO4J_SYNC_SCHEDULE || '0 */6 * * *', // Every 6 hours
+      incrementalEnabled: config?.incrementalEnabled ?? true,
+      batchSize: config?.batchSize || 500
+    };
+
+    this.loadStatus();
+  }
+
+  private loadStatus(): void {
+    try {
+      if (fs.existsSync(STATUS_FILE)) {
+        const data = fs.readFileSync(STATUS_FILE, 'utf-8');
+        this.status = JSON.parse(data);
+        this.status.status = 'idle'; // Reset running status on restart
+      }
+    } catch {
+      // Ignore errors, use default status
+    }
+  }
+
+  private saveStatus(): void {
+    try {
+      fs.writeFileSync(STATUS_FILE, JSON.stringify(this.status, null, 2));
+    } catch (error) {
+      console.error('Failed to save sync status:', error);
+    }
+  }
+
+  private loadCheckpoint(): SyncCheckpoint | null {
+    try {
+      if (fs.existsSync(CHECKPOINT_FILE)) {
+        const data = fs.readFileSync(CHECKPOINT_FILE, 'utf-8');
+        return JSON.parse(data);
+      }
+    } catch {
+      // Ignore errors
+    }
+    return null;
+  }
+
+  private saveCheckpoint(checkpoint: SyncCheckpoint): void {
+    try {
+      fs.writeFileSync(CHECKPOINT_FILE, JSON.stringify(checkpoint, null, 2));
+    } catch (error) {
+      console.error('Failed to save checkpoint:', error);
+    }
+  }
+
+  async connect(): Promise<void> {
+    console.log('📡 Connecting to Neo4j instances...');
+
+    this.localDriver = neo4j.driver(
+      this.config.local.uri,
+      neo4j.auth.basic(this.config.local.user, this.config.local.password),
+      { maxConnectionLifetime: 3 * 60 * 60 * 1000 }
+    );
+    await this.localDriver.verifyConnectivity();
+    console.log('  ✓ Connected to local Neo4j');
+
+    this.cloudDriver = neo4j.driver(
+      this.config.cloud.uri,
+      neo4j.auth.basic(this.config.cloud.user, this.config.cloud.password),
+      { maxConnectionLifetime: 3 * 60 * 60 * 1000 }
+    );
+    await this.cloudDriver.verifyConnectivity();
+    console.log('  ✓ Connected to AuraDB cloud');
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.localDriver) await this.localDriver.close();
+    if (this.cloudDriver) await this.cloudDriver.close();
+    this.localDriver = null;
+    this.cloudDriver = null;
+  }
+
+  /**
+   * Start scheduled auto-sync
+   */
+  startScheduler(): void {
+    if (this.cronJob) {
+      this.cronJob.stop();
+    }
+
+    console.log(`⏰ Starting Neo4j auto-sync scheduler: ${this.config.schedule}`);
+
+    this.cronJob = cron.schedule(this.config.schedule!, async () => {
+      console.log(`\n🔄 [${new Date().toISOString()}] Scheduled sync starting...`);
+      try {
+        await this.sync();
+      } catch (error) {
+        console.error('Scheduled sync failed:', error);
+      }
+    });
+
+    // Calculate next run time
+    const nextRun = this.getNextScheduledTime();
+    this.status.nextScheduledSync = nextRun;
+    this.saveStatus();
+
+    console.log(`  Next sync: ${nextRun}`);
+  }
+
+  stopScheduler(): void {
+    if (this.cronJob) {
+      this.cronJob.stop();
+      this.cronJob = null;
+      console.log('⏹️  Scheduler stopped');
+    }
+  }
+
+  private getNextScheduledTime(): string {
+    // Simple calculation for common cron patterns
+    const now = new Date();
+    const schedule = this.config.schedule!;
+
+    if (schedule.includes('*/6')) {
+      // Every 6 hours
+      const nextHour = Math.ceil(now.getHours() / 6) * 6;
+      const next = new Date(now);
+      next.setHours(nextHour, 0, 0, 0);
+      if (next <= now) next.setHours(next.getHours() + 6);
+      return next.toISOString();
+    }
+
+    return 'See cron expression: ' + schedule;
+  }
+
+  /**
+   * Perform sync (auto-detects full vs incremental)
+   */
+  async sync(forceFullSync: boolean = false): Promise<SyncStatus> {
+    const startTime = Date.now();
+    this.status.status = 'running';
+    this.saveStatus();
+
+    try {
+      await this.connect();
+
+      const checkpoint = this.loadCheckpoint();
+      const shouldDoFullSync = forceFullSync || !checkpoint || !this.config.incrementalEnabled;
+
+      if (shouldDoFullSync) {
+        await this.fullSync();
+        this.status.lastSyncType = 'full';
+      } else {
+        const hasChanges = await this.checkForChanges(checkpoint);
+        if (hasChanges) {
+          await this.incrementalSync(checkpoint);
+          this.status.lastSyncType = 'incremental';
+        } else {
+          console.log('✓ No changes detected, skipping sync');
+          this.status.lastSyncType = 'incremental';
+        }
+      }
+
+      this.status.status = 'success';
+      this.status.lastSyncTime = new Date().toISOString();
+      this.status.lastSyncDuration = Date.now() - startTime;
+      delete this.status.error;
+
+    } catch (error: any) {
+      this.status.status = 'error';
+      this.status.error = error.message;
+      console.error('❌ Sync failed:', error.message);
+    } finally {
+      await this.disconnect();
+      this.saveStatus();
+    }
+
+    return this.status;
+  }
+
+  private async checkForChanges(checkpoint: SyncCheckpoint): Promise<boolean> {
+    const session = this.localDriver!.session({ database: this.config.local.database });
+    try {
+      // Check node count
+      const nodeResult = await session.run('MATCH (n) RETURN count(n) as count');
+      const currentNodeCount = nodeResult.records[0].get('count').toNumber();
+
+      // Check relationship count
+      const relResult = await session.run('MATCH ()-[r]->() RETURN count(r) as count');
+      const currentRelCount = relResult.records[0].get('count').toNumber();
+
+      const hasChanges = currentNodeCount !== checkpoint.nodeCount ||
+                        currentRelCount !== checkpoint.relationshipCount;
+
+      if (hasChanges) {
+        console.log(`📊 Changes detected: nodes ${checkpoint.nodeCount} → ${currentNodeCount}, rels ${checkpoint.relationshipCount} → ${currentRelCount}`);
+      }
+
+      return hasChanges;
+    } finally {
+      await session.close();
+    }
+  }
+
+  private async fullSync(): Promise<void> {
+    console.log('\n🔄 Starting FULL sync...');
+
+    const localSession = this.localDriver!.session({ database: this.config.local.database });
+    const cloudSession = this.cloudDriver!.session({ database: this.config.cloud.database });
+
+    try {
+      // Export schema
+      const schema = await this.exportSchema(localSession);
+
+      // Export nodes
+      const nodes = await this.exportNodes(localSession);
+
+      // Export relationships
+      const relationships = await this.exportRelationships(localSession);
+
+      // Clear cloud
+      await this.clearCloud(cloudSession);
+
+      // Apply schema
+      await this.applySchema(cloudSession, schema);
+
+      // Import nodes
+      const elementIdMap = new Map<string, string>();
+      await this.importNodes(cloudSession, nodes, elementIdMap);
+
+      // Import relationships
+      await this.importRelationships(cloudSession, relationships, elementIdMap, nodes);
+
+      // Save checkpoint
+      this.saveCheckpoint({
+        timestamp: new Date().toISOString(),
+        nodeCount: nodes.length,
+        relationshipCount: relationships.length,
+        lastNodeIds: nodes.slice(-100).map(n => n.properties.id)
+      });
+
+      this.status.nodesSync = nodes.length;
+      this.status.relationshipsSync = relationships.length;
+
+      console.log(`\n✅ Full sync complete: ${nodes.length} nodes, ${relationships.length} relationships`);
+
+    } finally {
+      await localSession.close();
+      await cloudSession.close();
+    }
+  }
+
+  private async incrementalSync(checkpoint: SyncCheckpoint): Promise<void> {
+    console.log('\n🔄 Starting INCREMENTAL sync...');
+
+    const localSession = this.localDriver!.session({ database: this.config.local.database });
+    const cloudSession = this.cloudDriver!.session({ database: this.config.cloud.database });
+
+    try {
+      // Find new/modified nodes since checkpoint
+      const checkpointTime = new Date(checkpoint.timestamp);
+
+      // Get nodes created/modified after checkpoint
+      // This requires nodes to have a 'updatedAt' or 'createdAt' property
+      const newNodesResult = await localSession.run(`
+        MATCH (n)
+        WHERE n.createdAt > datetime($checkpointTime)
+           OR n.updatedAt > datetime($checkpointTime)
+           OR NOT n.id IN $existingIds
+        RETURN n, elementId(n) as elementId
+        LIMIT 10000
+      `, {
+        checkpointTime: checkpointTime.toISOString(),
+        existingIds: checkpoint.lastNodeIds
+      });
+
+      const newNodes: any[] = [];
+      for (const record of newNodesResult.records) {
+        const node = record.get('n');
+        newNodes.push({
+          labels: [...node.labels],
+          properties: this.convertProperties(node.properties),
+          elementId: record.get('elementId')
+        });
+      }
+
+      if (newNodes.length === 0) {
+        console.log('  No new nodes to sync');
+        return;
+      }
+
+      console.log(`  Found ${newNodes.length} new/modified nodes`);
+
+      // Import new nodes
+      const elementIdMap = new Map<string, string>();
+      await this.importNodes(cloudSession, newNodes, elementIdMap);
+
+      // Get new relationships for these nodes
+      const nodeIds = newNodes.map(n => n.properties.id).filter(Boolean);
+      if (nodeIds.length > 0) {
+        const newRelsResult = await localSession.run(`
+          MATCH (a)-[r]->(b)
+          WHERE a.id IN $nodeIds OR b.id IN $nodeIds
+          RETURN r, type(r) as type, elementId(a) as startId, elementId(b) as endId
+        `, { nodeIds });
+
+        const newRels: any[] = [];
+        for (const record of newRelsResult.records) {
+          const rel = record.get('r');
+          newRels.push({
+            type: record.get('type'),
+            properties: this.convertProperties(rel.properties),
+            startElementId: record.get('startId'),
+            endElementId: record.get('endId')
+          });
+        }
+
+        if (newRels.length > 0) {
+          await this.importRelationships(cloudSession, newRels, elementIdMap, newNodes);
+        }
+      }
+
+      // Update checkpoint
+      const nodeCountResult = await localSession.run('MATCH (n) RETURN count(n) as count');
+      const relCountResult = await localSession.run('MATCH ()-[r]->() RETURN count(r) as count');
+
+      this.saveCheckpoint({
+        timestamp: new Date().toISOString(),
+        nodeCount: nodeCountResult.records[0].get('count').toNumber(),
+        relationshipCount: relCountResult.records[0].get('count').toNumber(),
+        lastNodeIds: [...checkpoint.lastNodeIds, ...nodeIds].slice(-100)
+      });
+
+      this.status.nodesSync = newNodes.length;
+      this.status.relationshipsSync = 0;
+
+      console.log(`✅ Incremental sync complete: ${newNodes.length} nodes`);
+
+    } finally {
+      await localSession.close();
+      await cloudSession.close();
+    }
+  }
+
+  private convertProperties(props: Record<string, any>): Record<string, any> {
+    const result: Record<string, any> = {};
+    for (const [key, value] of Object.entries(props)) {
+      if (value === null || value === undefined) {
+        result[key] = value;
+      } else if (typeof value === 'object' && value.constructor?.name === 'Integer') {
+        result[key] = value.toNumber();
+      } else if (typeof value === 'object' && (value.constructor?.name === 'DateTime' || value.constructor?.name === 'Date')) {
+        result[key] = value.toString();
+      } else if (Array.isArray(value)) {
+        result[key] = value.map(v => this.convertProperties({ v }).v);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+
+  private async exportSchema(session: Session): Promise<any[]> {
+    const schema: any[] = [];
+
+    const constraintResult = await session.run('SHOW CONSTRAINTS');
+    for (const record of constraintResult.records) {
+      const name = record.get('name');
+      const type = record.get('type');
+      const entityType = record.get('entityType');
+      const labelsOrTypes = record.get('labelsOrTypes');
+      const properties = record.get('properties');
+
+      if (type === 'UNIQUENESS' && entityType === 'NODE') {
+        const label = labelsOrTypes?.[0];
+        const prop = properties?.[0];
+        if (label && prop) {
+          schema.push({
+            type: 'constraint',
+            name,
+            definition: `CREATE CONSTRAINT ${name} IF NOT EXISTS FOR (n:${label}) REQUIRE n.${prop} IS UNIQUE`
+          });
+        }
+      }
+    }
+
+    const indexResult = await session.run('SHOW INDEXES');
+    for (const record of indexResult.records) {
+      const name = record.get('name');
+      const type = record.get('type');
+      const entityType = record.get('entityType');
+      const labelsOrTypes = record.get('labelsOrTypes');
+      const properties = record.get('properties');
+      const owningConstraint = record.get('owningConstraint');
+
+      if (owningConstraint) continue;
+
+      if (type === 'RANGE' && entityType === 'NODE') {
+        const label = labelsOrTypes?.[0];
+        const prop = properties?.[0];
+        if (label && prop) {
+          schema.push({
+            type: 'index',
+            name,
+            definition: `CREATE INDEX ${name} IF NOT EXISTS FOR (n:${label}) ON (n.${prop})`
+          });
+        }
+      }
+    }
+
+    return schema;
+  }
+
+  private async exportNodes(session: Session): Promise<any[]> {
+    console.log('📦 Exporting nodes...');
+    const result = await session.run('MATCH (n) RETURN n, elementId(n) as elementId');
+    const nodes = result.records.map(record => ({
+      labels: [...record.get('n').labels],
+      properties: this.convertProperties(record.get('n').properties),
+      elementId: record.get('elementId')
+    }));
+    console.log(`  ✓ Exported ${nodes.length} nodes`);
+    return nodes;
+  }
+
+  private async exportRelationships(session: Session): Promise<any[]> {
+    console.log('🔗 Exporting relationships...');
+    const result = await session.run(`
+      MATCH (a)-[r]->(b)
+      RETURN r, type(r) as type, elementId(a) as startId, elementId(b) as endId
+    `);
+    const rels = result.records.map(record => ({
+      type: record.get('type'),
+      properties: this.convertProperties(record.get('r').properties),
+      startElementId: record.get('startId'),
+      endElementId: record.get('endId')
+    }));
+    console.log(`  ✓ Exported ${rels.length} relationships`);
+    return rels;
+  }
+
+  private async clearCloud(session: Session): Promise<void> {
+    console.log('🗑️  Clearing cloud database...');
+    let deleted = 0;
+    do {
+      const result = await session.run(`
+        MATCH (n) WITH n LIMIT 1000 DETACH DELETE n RETURN count(*) as deleted
+      `);
+      deleted = result.records[0]?.get('deleted')?.toNumber() || 0;
+    } while (deleted > 0);
+    console.log('  ✓ Cloud cleared');
+  }
+
+  private async applySchema(session: Session, schema: any[]): Promise<void> {
+    console.log('📋 Applying schema...');
+    for (const item of schema) {
+      try {
+        await session.run(item.definition);
+      } catch (error: any) {
+        if (!error.message?.includes('already exists')) {
+          console.warn(`  ⚠ ${item.name}: ${error.message?.slice(0, 50)}`);
+        }
+      }
+    }
+    console.log(`  ✓ Applied ${schema.length} schema items`);
+  }
+
+  private async importNodes(session: Session, nodes: any[], elementIdMap: Map<string, string>): Promise<void> {
+    console.log('📦 Importing nodes...');
+    let imported = 0;
+    const batchSize = this.config.batchSize!;
+
+    for (let i = 0; i < nodes.length; i += batchSize) {
+      const batch = nodes.slice(i, i + batchSize);
+
+      for (const node of batch) {
+        try {
+          const labelStr = node.labels.join(':');
+          const nodeId = node.properties.id || `node_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+          node.properties.id = nodeId;
+
+          const result = await session.run(`
+            MERGE (n:${labelStr} {id: $nodeId})
+            SET n = $props
+            RETURN elementId(n) as newElementId
+          `, { nodeId, props: node.properties });
+
+          const newElementId = result.records[0]?.get('newElementId');
+          if (newElementId) {
+            elementIdMap.set(node.elementId, newElementId);
+          }
+          imported++;
+        } catch (error: any) {
+          // Continue on error
+        }
+      }
+
+      if ((i + batchSize) % 5000 === 0 || i + batchSize >= nodes.length) {
+        console.log(`  Progress: ${Math.min(i + batchSize, nodes.length)}/${nodes.length} nodes`);
+      }
+    }
+
+    console.log(`  ✓ Imported ${imported} nodes`);
+  }
+
+  private async importRelationships(
+    session: Session,
+    relationships: any[],
+    elementIdMap: Map<string, string>,
+    nodes: any[]
+  ): Promise<void> {
+    console.log('🔗 Importing relationships...');
+
+    const elementIdToNodeId = new Map<string, string>();
+    for (const node of nodes) {
+      elementIdToNodeId.set(node.elementId, node.properties.id);
+    }
+
+    let imported = 0;
+    const batchSize = this.config.batchSize!;
+
+    for (let i = 0; i < relationships.length; i += batchSize) {
+      const batch = relationships.slice(i, i + batchSize);
+
+      for (const rel of batch) {
+        try {
+          const startNodeId = elementIdToNodeId.get(rel.startElementId);
+          const endNodeId = elementIdToNodeId.get(rel.endElementId);
+
+          if (!startNodeId || !endNodeId) continue;
+
+          await session.run(`
+            MATCH (a {id: $startId})
+            MATCH (b {id: $endId})
+            MERGE (a)-[r:${rel.type}]->(b)
+            SET r = $props
+          `, { startId: startNodeId, endId: endNodeId, props: rel.properties });
+
+          imported++;
+        } catch (error: any) {
+          // Continue on error
+        }
+      }
+
+      if ((i + batchSize) % 50000 === 0 || i + batchSize >= relationships.length) {
+        console.log(`  Progress: ${Math.min(i + batchSize, relationships.length)}/${relationships.length} relationships`);
+      }
+    }
+
+    console.log(`  ✓ Imported ${imported} relationships`);
+  }
+
+  getStatus(): SyncStatus {
+    return { ...this.status };
+  }
+}
+
+// Singleton instance
+let autoSyncInstance: Neo4jAutoSync | null = null;
+
+export function getNeo4jAutoSync(): Neo4jAutoSync {
+  if (!autoSyncInstance) {
+    autoSyncInstance = new Neo4jAutoSync();
+  }
+  return autoSyncInstance;
+}