@lucern/graph-sync 0.3.0-alpha.10

package/dist/neo4jSync.js

@@ -0,0 +1,1000 @@
+"use node";
+import { v } from 'convex/values';
+import { NODE_TYPE_TO_LABEL, EDGE_TYPE_TO_REL } from '@lucern/graph-primitives/graphTypes';
+import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
+import { componentsGeneric, anyApi, internalActionGeneric } from 'convex/server';
+import neo4j from 'neo4j-driver';
+
+componentsGeneric();
+var internal = anyApi;
+var internalAction = internalActionGeneric;
+var VALID_NODE_LABELS = /* @__PURE__ */ new Set([
+  // Ontological
+  "ValueChain",
+  "Function",
+  "FinSector",
+  "Company",
+  "Person",
+  "Investor",
+  // Epistemic
+  "Theme",
+  "Belief",
+  "Question",
+  "Evidence",
+  "Source",
+  "Decision",
+  "Sprint",
+  "Claim",
+  "Synthesis",
+  "Answer"
+]);
+var VALID_RELATIONSHIP_TYPES = /* @__PURE__ */ new Set([
+  // Cross-layer edges
+  "EXTRACTED_FROM",
+  "ANSWERS",
+  "RESPONDS_TO",
+  "INFORMS",
+  "QUALIFIES",
+  "TESTS",
+  "EXPLORES",
+  "BASED_ON",
+  "RELATES_TO_THESIS",
+  "BELONGS_TO",
+  "PLAYS_THEME",
+  // Same-layer edges
+  "SUPERSEDES",
+  "SAME_AS",
+  "DEPENDS_ON",
+  "REINFORCES",
+  "PARENT_OF",
+  "CHILD_OF",
+  "FALSIFIED_BY",
+  "EXCLUSIVE_WITH",
+  "COLLAPSES_IF",
+  "CASCADE_FROM",
+  "STRENGTHENED_BY",
+  "WEAKENED_BY",
+  "ALTERNATIVE_TO",
+  "SUBSUMES",
+  "VALIDATED_BY",
+  "REQUIRED_FOR",
+  "PREREQUISITE_FOR",
+  "PARALLEL_TO",
+  "CORROBORATES",
+  "EXTENDS",
+  "SAME_SOURCE_AS",
+  "SAME_THEME_AS",
+  // Ontological
+  "EVALUATES",
+  "PERSPECTIVE_ON",
+  "WORKS_AT",
+  "PARTICIPATES_IN",
+  "PERFORMS",
+  "FUNCTION_IN",
+  "IMPACTS",
+  "INVESTED_IN",
+  "RAISED_FROM",
+  "BASED_ON_BELIEF",
+  "BASED_ON_QUESTION",
+  "BLOCKED_BY_CONTRADICTION",
+  "INFORMED_BY_THEME"
+]);
+function validateLabel(label) {
+  if (!VALID_NODE_LABELS.has(label)) {
+    throw new Error(
+      `[Neo4j Security] Invalid node label: ${label}. Must be one of: ${Array.from(VALID_NODE_LABELS).join(", ")}`
+    );
+  }
+}
+function validateRelType(relType) {
+  if (!VALID_RELATIONSHIP_TYPES.has(relType)) {
+    throw new Error(
+      `[Neo4j Security] Invalid relationship type: ${relType}. Must be one of: ${Array.from(VALID_RELATIONSHIP_TYPES).join(", ")}`
+    );
+  }
+}
+var driver = null;
+function getDriver() {
+  if (!driver) {
+    const uri = process.env.NEO4J_URI;
+    const user = process.env.NEO4J_USER;
+    const password = process.env.NEO4J_PASSWORD;
+    if (!uri || !user || !password) {
+      throw new Error(
+        "[Neo4j Driver] Missing credentials. Set NEO4J_URI, NEO4J_USER, NEO4J_PASSWORD via `npx convex env set`"
+      );
+    }
+    driver = neo4j.driver(uri, neo4j.auth.basic(user, password), {
+      // Connection pool settings
+      maxConnectionPoolSize: 50,
+      connectionAcquisitionTimeout: 3e4,
+      // Logging
+      logging: {
+        level: "warn",
+        logger: (level, message) => console.log(`[Neo4j ${level}] ${message}`)
+      }
+    });
+  }
+  return driver;
+}
+var DEFAULT_QUERY_TIMEOUT_MS = 3e4;
+var COMPLEX_QUERY_TIMEOUT_MS = 6e4;
+function toNeo4jParams(params) {
+  const result = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (typeof value === "number" && Number.isInteger(value)) {
+      result[key] = neo4j.int(value);
+    } else if (Array.isArray(value)) {
+      result[key] = value.map(
+        (v2) => typeof v2 === "number" && Number.isInteger(v2) ? neo4j.int(v2) : v2
+      );
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+async function runCypher(query, params = {}, timeoutMs = DEFAULT_QUERY_TIMEOUT_MS) {
+  const neo4jDriver = getDriver();
+  const session = neo4jDriver.session();
+  try {
+    const neo4jParams = toNeo4jParams(params);
+    const result = await session.run(query, neo4jParams, {
+      timeout: neo4j.int(timeoutMs)
+    });
+    return result.records.map((record) => {
+      const obj = {};
+      for (const key of record.keys) {
+        const field = String(key);
+        obj[field] = convertNeo4jValue(record.get(field));
+      }
+      return obj;
+    });
+  } finally {
+    await session.close();
+  }
+}
+async function runWriteTransaction(query, params = {}, timeoutMs = DEFAULT_QUERY_TIMEOUT_MS) {
+  const neo4jDriver = getDriver();
+  const session = neo4jDriver.session();
+  try {
+    const neo4jParams = toNeo4jParams(params);
+    const result = await session.executeWrite(
+      async (tx) => {
+        return await tx.run(query, neo4jParams);
+      },
+      { timeout: timeoutMs }
+    );
+    return result.records.map((record) => {
+      const obj = {};
+      for (const key of record.keys) {
+        const field = String(key);
+        obj[field] = convertNeo4jValue(record.get(field));
+      }
+      return obj;
+    });
+  } finally {
+    await session.close();
+  }
+}
+async function runBatchTransaction(queries, timeoutMs = COMPLEX_QUERY_TIMEOUT_MS) {
+  const neo4jDriver = getDriver();
+  const session = neo4jDriver.session();
+  try {
+    await session.executeWrite(
+      async (tx) => {
+        for (const { query, params } of queries) {
+          await tx.run(query, params);
+        }
+      },
+      { timeout: timeoutMs }
+    );
+  } finally {
+    await session.close();
+  }
+}
+async function upsertNode(label, globalId, properties) {
+  validateLabel(label);
+  await runWriteTransaction(
+    `
+    MERGE (n:${label} {globalId: $globalId})
+    SET n += $properties
+    SET n.updatedAt = timestamp()
+    `,
+    { globalId, properties }
+  );
+}
+async function deleteNode(globalId) {
+  await runWriteTransaction(
+    `
+    MATCH (n {globalId: $globalId})
+    DETACH DELETE n
+    `,
+    { globalId }
+  );
+}
+async function batchUpsertNodes(label, nodes) {
+  if (nodes.length === 0) {
+    return;
+  }
+  validateLabel(label);
+  await runWriteTransaction(
+    `
+    UNWIND $nodes as node
+    MERGE (n:${label} {globalId: node.globalId})
+    SET n += node.properties
+    SET n.updatedAt = timestamp()
+    `,
+    { nodes }
+  );
+}
+async function upsertEdge(relType, globalId, fromGlobalId, toGlobalId, properties = {}) {
+  validateRelType(relType);
+  await runWriteTransaction(
+    `
+    MATCH (from {globalId: $fromGlobalId})
+    MATCH (to {globalId: $toGlobalId})
+    MERGE (from)-[r:${relType} {globalId: $globalId}]->(to)
+    SET r += $properties
+    SET r.updatedAt = timestamp()
+    `,
+    { globalId, fromGlobalId, toGlobalId, properties }
+  );
+}
+async function deleteEdge(globalId) {
+  await runWriteTransaction(
+    `
+    MATCH ()-[r {globalId: $globalId}]->()
+    DELETE r
+    `,
+    { globalId }
+  );
+}
+async function batchUpsertEdges(edges) {
+  if (edges.length === 0) {
+    return;
+  }
+  const byType = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const existing = byType.get(edge.relType) || [];
+    existing.push(edge);
+    byType.set(edge.relType, existing);
+  }
+  const queries = [];
+  for (const [relType, typeEdges] of byType) {
+    queries.push({
+      query: `
+        UNWIND $edges as edge
+        MATCH (from {globalId: edge.fromGlobalId})
+        MATCH (to {globalId: edge.toGlobalId})
+        MERGE (from)-[r:${relType} {globalId: edge.globalId}]->(to)
+        SET r += edge.properties
+        SET r.updatedAt = timestamp()
+      `,
+      params: {
+        edges: typeEdges.map((e) => ({
+          globalId: e.globalId,
+          fromGlobalId: e.fromGlobalId,
+          toGlobalId: e.toGlobalId,
+          properties: e.properties || {}
+        }))
+      }
+    });
+  }
+  await runBatchTransaction(queries);
+}
+async function healthCheck() {
+  try {
+    const result = await runCypher(
+      "MATCH (n) RETURN count(n) as count LIMIT 1"
+    );
+    return {
+      healthy: true,
+      nodeCount: result[0]?.count || 0
+    };
+  } catch (error) {
+    return {
+      healthy: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+function getConnectionInfo() {
+  return {
+    uri: process.env.NEO4J_URI,
+    user: process.env.NEO4J_USER,
+    configured: Boolean(
+      process.env.NEO4J_URI && process.env.NEO4J_USER && process.env.NEO4J_PASSWORD
+    )
+  };
+}
+function convertNeo4jValue(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (neo4j.isInt(value)) {
+    return neo4j.integer.toNumber(value);
+  }
+  if (neo4j.isDate(value) || neo4j.isDateTime(value) || neo4j.isTime(value)) {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return value.map(convertNeo4jValue);
+  }
+  if (value && typeof value === "object" && "properties" in value) {
+    const nodeObj = value;
+    const result = {};
+    for (const [k, v2] of Object.entries(nodeObj.properties)) {
+      result[k] = convertNeo4jValue(v2);
+    }
+    return result;
+  }
+  if (typeof value === "object") {
+    const result = {};
+    for (const [k, v2] of Object.entries(value)) {
+      result[k] = convertNeo4jValue(v2);
+    }
+    return result;
+  }
+  return value;
+}
+
+// src/neo4jSync.ts
+function buildSyncResponse(entityType, operation, fields) {
+  return {
+    entityType,
+    operation,
+    ...fields
+  };
+}
+function buildSyncSuccess(entityType, operation, fields) {
+  return buildSyncResponse(entityType, operation, {
+    success: true,
+    ...fields
+  });
+}
+function buildSyncFailure(entityType, operation, error, fields) {
+  return buildSyncResponse(entityType, operation, {
+    success: false,
+    error,
+    ...fields
+  });
+}
+function buildNodeProperties(node) {
+  const metadata = node.metadata || {};
+  const pillar = metadata.pillar || metadata.topic || "";
+  const stage = metadata.stage || metadata.beliefStage || "";
+  const criticality = metadata.criticality || "";
+  const synthesizedFrom = metadata.synthesizedFrom || [];
+  const epistemicStatus = node.epistemicStatus || "";
+  const methodology = node.methodology || "";
+  const informationAsymmetry = node.informationAsymmetry || "";
+  const questionType = node.questionType || "";
+  const questionPriority = node.questionPriority || "";
+  const answerQuality = node.answerQuality || "";
+  const reversibility = node.reversibility || "";
+  const predictionMeta = node.predictionMeta;
+  return {
+    convexId: node._id,
+    canonicalText: node.canonicalText || "",
+    title: node.title || "",
+    status: node.status || "active",
+    subtype: node.subtype || "",
+    domain: node.domain || "",
+    confidence: node.confidence || 0,
+    verificationStatus: node.verificationStatus || "unverified",
+    sourceType: node.sourceType || "unknown",
+    createdAt: node.createdAt,
+    updatedAt: node.updatedAt || Date.now(),
+    createdBy: node.createdBy || "",
+    nodeType: node.nodeType,
+    epistemicLayer: node.epistemicLayer || "",
+    // Project and metadata fields
+    projectId: node.projectId || "",
+    tenantId: node.tenantId || "",
+    workspaceId: node.workspaceId || "",
+    pillar,
+    stage,
+    criticality,
+    synthesizedFromCount: synthesizedFrom.length,
+    // Classification fields (Logic Machine)
+    epistemicStatus,
+    methodology,
+    informationAsymmetry,
+    questionType,
+    questionPriority,
+    answerQuality,
+    reversibility,
+    isPrediction: predictionMeta?.isPrediction ? "true" : "false",
+    expectedBy: predictionMeta?.expectedBy ? String(predictionMeta.expectedBy) : ""
+  };
+}
+function buildEdgeProperties(edge) {
+  return {
+    convexId: edge._id,
+    weight: edge.weight || 1,
+    confidence: edge.confidence || 0,
+    context: edge.context || "",
+    derivationType: edge.derivationType || "",
+    createdAt: edge.createdAt,
+    createdBy: edge.createdBy || "",
+    edgeType: edge.edgeType,
+    fromLayer: edge.fromLayer || "",
+    toLayer: edge.toLayer || "",
+    projectId: edge.projectId || "",
+    tenantId: edge.tenantId || "",
+    workspaceId: edge.workspaceId || "",
+    // Classification fields (Logic Machine)
+    reasoningMethod: edge.reasoningMethod || "",
+    logicalRole: edge.logicalRole || "",
+    temporalClass: edge.temporalClass || ""
+  };
+}
+var syncNodeToNeo4j = internalAction({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    operation: v.union(v.literal("upsert"), v.literal("delete"))
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const connInfo = getConnectionInfo();
+    if (!connInfo.configured) {
+      console.warn(
+        "[Neo4j Sync] Missing Neo4j credentials, skipping sync. Set via `npx convex env set`"
+      );
+      return buildSyncFailure("node", args.operation, "Missing credentials", {
+        skippedReason: "credentials_missing"
+      });
+    }
+    const node = await ctx.runQuery(internal.neo4jSyncHelpers.getNodeForSync, {
+      nodeId: args.nodeId
+    });
+    if (!node) {
+      if (args.operation === "upsert") {
+        return buildSyncFailure("node", args.operation, "Node not found", {
+          skippedReason: "source_node_missing"
+        });
+      }
+      console.log("[Neo4j Sync] Node not found for delete, skipping");
+      return buildSyncSuccess("node", args.operation, {
+        skipped: true,
+        skippedReason: "source_node_missing"
+      });
+    }
+    const label = NODE_TYPE_TO_LABEL[node.nodeType] || "Node";
+    try {
+      if (args.operation === "delete") {
+        await deleteNode(node.globalId);
+        console.log(`[Neo4j Sync] Deleted node ${node.globalId}`);
+      } else {
+        const props = buildNodeProperties(node);
+        const embedding = await ctx.runQuery(
+          internal.neo4jSyncHelpers.getEmbeddingForSync,
+          { nodeId: args.nodeId }
+        );
+        if (embedding) {
+          props.embedding = embedding;
+        }
+        await upsertNode(label, node.globalId, props);
+        console.log(
+          `[Neo4j Sync] Upserted node ${node.globalId} as ${label} with projectId=${node.projectId}` + (embedding ? ` (with ${embedding.length}-dim embedding)` : "")
+        );
+      }
+      await ctx.runMutation(internal.neo4jSyncHelpers.logSyncEvent, {
+        eventType: args.operation === "delete" ? "node_deleted" : node ? "node_updated" : "node_created",
+        entityId: args.nodeId,
+        entityType: node.nodeType,
+        status: "success"
+      });
+      return buildSyncSuccess("node", args.operation);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      console.error("[Neo4j Sync] Node sync error:", errorMsg);
+      await ctx.runMutation(internal.neo4jSyncHelpers.logSyncEvent, {
+        eventType: args.operation === "delete" ? "node_deleted" : "node_updated",
+        entityId: args.nodeId,
+        entityType: node.nodeType,
+        status: "failed",
+        error: errorMsg
+      });
+      await ctx.runMutation(internal.neo4jSyncHelpers.queueForRetry, {
+        entityType: "node",
+        entityId: args.nodeId,
+        operation: args.operation,
+        error: errorMsg
+      });
+      return buildSyncFailure("node", args.operation, errorMsg);
+    }
+  }
+});
+var syncEdgeToNeo4j = internalAction({
+  args: {
+    edgeId: v.id("epistemicEdges"),
+    operation: v.union(v.literal("upsert"), v.literal("delete"))
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const connInfo = getConnectionInfo();
+    if (!connInfo.configured) {
+      console.warn(
+        "[Neo4j Sync] Missing Neo4j credentials, skipping sync. Set via `npx convex env set`"
+      );
+      return buildSyncFailure("edge", args.operation, "Missing credentials", {
+        skippedReason: "credentials_missing"
+      });
+    }
+    const edge = await ctx.runQuery(internal.neo4jSyncHelpers.getEdgeForSync, {
+      edgeId: args.edgeId
+    });
+    if (!edge) {
+      if (args.operation === "upsert") {
+        return buildSyncFailure("edge", args.operation, "Edge not found", {
+          skippedReason: "source_edge_missing"
+        });
+      }
+      console.log("[Neo4j Sync] Edge not found for delete, skipping");
+      return buildSyncSuccess("edge", args.operation, {
+        skipped: true,
+        skippedReason: "source_edge_missing"
+      });
+    }
+    if (!edge.fromGlobalId || !edge.toGlobalId) {
+      console.warn(
+        "[Neo4j Sync] Edge missing fromGlobalId or toGlobalId, skipping"
+      );
+      return buildSyncFailure(
+        "edge",
+        args.operation,
+        "Edge missing connected node globalIds",
+        {
+          skippedReason: "edge_endpoint_missing"
+        }
+      );
+    }
+    const relType = EDGE_TYPE_TO_REL[edge.edgeType] || edge.edgeType.toUpperCase();
+    try {
+      if (args.operation === "delete") {
+        await deleteEdge(edge.globalId);
+        console.log(`[Neo4j Sync] Deleted edge ${edge.globalId}`);
+      } else {
+        await upsertEdge(
+          relType,
+          edge.globalId,
+          edge.fromGlobalId,
+          edge.toGlobalId,
+          {
+            convexId: args.edgeId,
+            weight: edge.weight || 1,
+            confidence: edge.confidence || 0,
+            context: edge.context || "",
+            derivationType: edge.derivationType || "",
+            createdAt: edge.createdAt,
+            createdBy: edge.createdBy || "",
+            edgeType: edge.edgeType,
+            fromLayer: edge.fromLayer || "",
+            toLayer: edge.toLayer || "",
+            // Classification fields (Logic Machine)
+            reasoningMethod: edge.reasoningMethod || "",
+            logicalRole: edge.logicalRole || "",
+            temporalClass: edge.temporalClass || ""
+          }
+        );
+        console.log(
+          `[Neo4j Sync] Upserted edge ${edge.globalId} as ${relType}`
+        );
+      }
+      await ctx.runMutation(internal.neo4jSyncHelpers.logSyncEvent, {
+        eventType: args.operation === "delete" ? "edge_deleted" : "edge_created",
+        entityId: args.edgeId,
+        entityType: edge.edgeType,
+        status: "success"
+      });
+      return buildSyncSuccess("edge", args.operation);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      console.error("[Neo4j Sync] Edge sync error:", errorMsg);
+      await ctx.runMutation(internal.neo4jSyncHelpers.logSyncEvent, {
+        eventType: args.operation === "delete" ? "edge_deleted" : "edge_created",
+        entityId: args.edgeId,
+        entityType: edge.edgeType,
+        status: "failed",
+        error: errorMsg
+      });
+      await ctx.runMutation(internal.neo4jSyncHelpers.queueForRetry, {
+        entityType: "edge",
+        entityId: args.edgeId,
+        operation: args.operation,
+        error: errorMsg
+      });
+      return buildSyncFailure("edge", args.operation, errorMsg);
+    }
+  }
+});
+var syncAllNodesToNeo4j = internalAction({
+  args: {
+    batchSize: v.optional(v.number()),
+    cursor: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const batchSize = args.batchSize ?? 100;
+    const result = await ctx.runQuery(
+      internal.neo4jSyncHelpers.getNodeBatchForSync,
+      {
+        limit: batchSize,
+        cursor: args.cursor
+      }
+    );
+    if (result.nodes.length === 0) {
+      return { synced: 0, failed: 0, hasMore: false };
+    }
+    const nodesByLabel = /* @__PURE__ */ new Map();
+    for (const node of result.nodes) {
+      const label = NODE_TYPE_TO_LABEL[node.nodeType] || "Node";
+      if (!nodesByLabel.has(label)) {
+        nodesByLabel.set(label, []);
+      }
+      nodesByLabel.get(label)?.push({
+        globalId: node.globalId,
+        properties: buildNodeProperties(node)
+      });
+    }
+    let synced = 0;
+    let failed = 0;
+    for (const [label, nodes] of nodesByLabel) {
+      try {
+        await batchUpsertNodes(label, nodes);
+        synced += nodes.length;
+        console.log(
+          `[Neo4j Sync] Batch upserted ${nodes.length} ${label} nodes`
+        );
+      } catch (error) {
+        console.error(`[Neo4j Sync] Batch upsert failed for ${label}:`, error);
+        failed += nodes.length;
+      }
+    }
+    return {
+      synced,
+      failed,
+      hasMore: result.hasMore,
+      nextCursor: result.nextCursor
+    };
+  }
+});
+var syncAllEdgesToNeo4j = internalAction({
+  args: {
+    batchSize: v.optional(v.number()),
+    cursor: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const batchSize = args.batchSize ?? 100;
+    const result = await ctx.runQuery(
+      internal.neo4jSyncHelpers.getEdgeBatchForSync,
+      {
+        limit: batchSize,
+        cursor: args.cursor
+      }
+    );
+    if (result.edges.length === 0) {
+      return { synced: 0, failed: 0, hasMore: false };
+    }
+    const edgesToSync = [];
+    for (const edge of result.edges) {
+      if (!edge.fromGlobalId || !edge.toGlobalId) {
+        console.warn(
+          `[Neo4j Sync] Skipping edge ${edge.globalId} - missing globalIds`
+        );
+        continue;
+      }
+      const relType = EDGE_TYPE_TO_REL[edge.edgeType] || edge.edgeType.toUpperCase();
+      edgesToSync.push({
+        relType,
+        globalId: edge.globalId,
+        fromGlobalId: edge.fromGlobalId,
+        toGlobalId: edge.toGlobalId,
+        properties: buildEdgeProperties(edge)
+      });
+    }
+    let synced = 0;
+    let failed = 0;
+    try {
+      await batchUpsertEdges(edgesToSync);
+      synced = edgesToSync.length;
+      console.log(`[Neo4j Sync] Batch upserted ${synced} edges`);
+    } catch (error) {
+      console.error("[Neo4j Sync] Batch edge upsert failed:", error);
+      failed = edgesToSync.length;
+    }
+    return {
+      synced,
+      failed,
+      hasMore: result.hasMore,
+      nextCursor: result.nextCursor
+    };
+  }
+});
+var backfillAllToNeo4j = internalAction({
+  args: {
+    batchSize: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const batchSize = args.batchSize ?? 100;
+    let totalNodes = 0;
+    let totalEdges = 0;
+    let totalFailed = 0;
+    console.log("[Neo4j Sync] Starting full backfill...");
+    let nodeCursor;
+    do {
+      const result = await ctx.runAction(
+        internal.neo4jSync.syncAllNodesToNeo4j,
+        {
+          batchSize,
+          cursor: nodeCursor
+        }
+      );
+      totalNodes += result.synced;
+      totalFailed += result.failed;
+      nodeCursor = result.hasMore ? result.nextCursor : void 0;
+      console.log(
+        `[Neo4j Sync] Nodes progress: ${totalNodes} synced, ${totalFailed} failed`
+      );
+    } while (nodeCursor);
+    console.log(`[Neo4j Sync] Finished nodes: ${totalNodes} synced`);
+    let edgeCursor;
+    do {
+      const result = await ctx.runAction(
+        internal.neo4jSync.syncAllEdgesToNeo4j,
+        {
+          batchSize,
+          cursor: edgeCursor
+        }
+      );
+      totalEdges += result.synced;
+      totalFailed += result.failed;
+      edgeCursor = result.hasMore ? result.nextCursor : void 0;
+      console.log(
+        `[Neo4j Sync] Edges progress: ${totalEdges} synced, ${totalFailed} failed`
+      );
+    } while (edgeCursor);
+    console.log(
+      `[Neo4j Sync] Backfill complete: ${totalNodes} nodes, ${totalEdges} edges, ${totalFailed} failed`
+    );
+    return {
+      totalNodes,
+      totalEdges,
+      totalFailed
+    };
+  }
+});
+var processRetryQueue = internalAction({
+  args: {
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 10;
+    const pendingItems = await ctx.runQuery(
+      internal.neo4jSyncHelpers.getPendingRetries,
+      { limit }
+    );
+    if (pendingItems.length === 0) {
+      return { processed: 0, succeeded: 0, failed: 0 };
+    }
+    let succeeded = 0;
+    let failed = 0;
+    for (const item of pendingItems) {
+      await ctx.runMutation(internal.neo4jSyncHelpers.updateQueueStatus, {
+        queueId: item._id,
+        status: "in_progress"
+      });
+      let result;
+      if (item.entityType === "node") {
+        result = await ctx.runAction(internal.neo4jSync.syncNodeToNeo4j, {
+          nodeId: item.entityId,
+          operation: item.operation
+        });
+      } else {
+        const resolved = await ctx.runQuery(
+          internal.neo4jSyncHelpers.resolveEdgeRetryTarget,
+          {
+            entityId: item.entityId
+          }
+        );
+        if (resolved.mode === "convex_id" || resolved.mode === "global_id_in_convex") {
+          result = await ctx.runAction(internal.neo4jSync.syncEdgeToNeo4j, {
+            edgeId: resolved.edgeId,
+            operation: item.operation
+          });
+        } else {
+          result = await ctx.runAction(
+            internal.neo4jEdgeAPI.retryProjectionByGlobalId,
+            {
+              globalId: resolved.edgeGlobalId
+            }
+          );
+        }
+      }
+      if (result.success) {
+        await ctx.runMutation(internal.neo4jSyncHelpers.updateQueueStatus, {
+          queueId: item._id,
+          status: "succeeded"
+        });
+        succeeded++;
+      } else {
+        const updated = await ctx.runMutation(
+          internal.neo4jSyncHelpers.incrementAttempts,
+          {
+            queueId: item._id,
+            error: result.error || "Unknown error"
+          }
+        );
+        if (updated.failed) {
+          failed++;
+        }
+      }
+    }
+    return { processed: pendingItems.length, succeeded, failed };
+  }
+});
+var syncEmbeddingToNeo4j = internalAction({
+  args: {
+    nodeId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const connInfo = getConnectionInfo();
+    if (!connInfo.configured) {
+      return buildSyncFailure("embedding", "sync", "Missing credentials", {
+        skippedReason: "credentials_missing"
+      });
+    }
+    const node = await ctx.runQuery(internal.neo4jSyncHelpers.getNodeForSync, {
+      nodeId: args.nodeId
+    });
+    if (!node?.globalId) {
+      return buildSyncFailure("embedding", "sync", "Node not found", {
+        skippedReason: "source_node_missing"
+      });
+    }
+    const embedding = await ctx.runQuery(
+      internal.neo4jSyncHelpers.getEmbeddingForSync,
+      { nodeId: args.nodeId }
+    );
+    if (!embedding) {
+      return buildSyncFailure("embedding", "sync", "Embedding not found", {
+        skippedReason: "embedding_missing"
+      });
+    }
+    try {
+      await runWriteTransaction(
+        "MATCH (n {globalId: $globalId}) SET n.embedding = $embedding",
+        { globalId: node.globalId, embedding }
+      );
+      console.log(
+        `[Neo4j Sync] Synced ${embedding.length}-dim embedding for node ${node.globalId}`
+      );
+      return buildSyncSuccess("embedding", "sync");
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      console.error("[Neo4j Sync] Embedding sync error:", errorMsg);
+      return buildSyncFailure("embedding", "sync", errorMsg);
+    }
+  }
+});
+var checkNeo4jHealth = internalAction({
+  args: {},
+  returns: permissiveReturn,
+  handler: async () => {
+    const connInfo = getConnectionInfo();
+    if (!connInfo.configured) {
+      return {
+        healthy: false,
+        error: "Neo4j not configured",
+        uri: connInfo.uri
+      };
+    }
+    const health = await healthCheck();
+    return {
+      ...health,
+      uri: connInfo.uri
+    };
+  }
+});
+var resyncAllNodes = internalAction({
+  args: {
+    batchSize: v.optional(v.number()),
+    nodeType: v.optional(v.string()),
+    cursor: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const batchSize = args.batchSize ?? 50;
+    const result = await ctx.runQuery(
+      internal.neo4jSyncHelpers.getAllNodesForResync,
+      {
+        nodeType: args.nodeType,
+        limit: batchSize,
+        cursor: args.cursor
+      }
+    );
+    let synced = 0;
+    let failed = 0;
+    for (const node of result.nodes) {
+      try {
+        const syncResult = await ctx.runAction(
+          internal.neo4jSync.syncNodeToNeo4j,
+          {
+            nodeId: node._id,
+            operation: "upsert"
+          }
+        );
+        if (syncResult.success) {
+          synced++;
+        } else {
+          failed++;
+        }
+      } catch (error) {
+        console.error(`[Neo4j Resync] Failed to sync node ${node._id}:`, error);
+        failed++;
+      }
+    }
+    return {
+      synced,
+      failed,
+      total: result.nodes.length,
+      hasMore: result.hasMore,
+      nextCursor: result.nextCursor
+    };
+  }
+});
+var resyncAllEdges = internalAction({
+  args: {
+    batchSize: v.optional(v.number()),
+    cursor: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const batchSize = args.batchSize ?? 50;
+    const result = await ctx.runQuery(
+      internal.neo4jSyncHelpers.getAllEdgesForResync,
+      {
+        limit: batchSize,
+        cursor: args.cursor
+      }
+    );
+    let synced = 0;
+    let failed = 0;
+    for (const edge of result.edges) {
+      try {
+        const syncResult = await ctx.runAction(
+          internal.neo4jSync.syncEdgeToNeo4j,
+          {
+            edgeId: edge._id,
+            operation: "upsert"
+          }
+        );
+        if (syncResult.success) {
+          synced++;
+        } else {
+          failed++;
+        }
+      } catch (error) {
+        console.error(`[Neo4j Resync] Failed to sync edge ${edge._id}:`, error);
+        failed++;
+      }
+    }
+    return {
+      synced,
+      failed,
+      total: result.edges.length,
+      hasMore: result.hasMore,
+      nextCursor: result.nextCursor
+    };
+  }
+});
+
+export { backfillAllToNeo4j, checkNeo4jHealth, processRetryQueue, resyncAllEdges, resyncAllNodes, syncAllEdgesToNeo4j, syncAllNodesToNeo4j, syncEdgeToNeo4j, syncEmbeddingToNeo4j, syncNodeToNeo4j };
+//# sourceMappingURL=neo4jSync.js.map
+//# sourceMappingURL=neo4jSync.js.map