@openez-graph/cli 0.11.0 → 0.11.1

package/dist/CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to OpenEZ Graph are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.11.1] - 2026-08-06
+
+### Fixed
+
+- Writing phase performance bottleneck: symbol, import, and wikilink node upserts batched per file instead of N individual queries
+- Embedding provider and model now logged at indexing startup for visibility
+- Progress logs added for post-writing phases (embedding batches, FTS rebuild, call edge resolution)
+
 ## [0.11.0] - 2026-08-06
 
 ### Added
@@ -146,6 +154,7 @@ Remediation release — index/graph correctness, data protection, and web flow f
 - Error handling and validation for import path extraction
 - CLI npm packaging
 
+[0.11.1]: https://github.com/asta-nguyen/openez-graph/compare/v0.11.0...v0.11.1
 [0.11.0]: https://github.com/asta-nguyen/openez-graph/compare/v0.10.0...v0.11.0
 [0.10.0]: https://github.com/asta-nguyen/openez-graph/compare/fbcad4f...HEAD
 [0.9.1]: https://github.com/asta-nguyen/openez-graph/compare/fbcad4f...HEAD

package/dist/cli.cjs

@@ -12594,6 +12594,36 @@ function createWorkspaceRepository(rootPath) {
       }
       return ids;
     },
+    async upsertGraphNodesBatch(inputs) {
+      if (inputs.length === 0) return [];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const BATCH = 500;
+      const results = [];
+      for (let i = 0; i < inputs.length; i += BATCH) {
+        const batch = inputs.slice(i, i + BATCH);
+        const placeholders = batch.map(() => "(?, ?, ?, ?, ?, ?, ?)").join(",");
+        const params = [];
+        for (const item of batch) {
+          const id = import_node_crypto2.default.randomUUID();
+          params.push(
+            id,
+            item.type,
+            item.label,
+            item.refId ?? null,
+            item.metadata ?? "{}",
+            now,
+            now
+          );
+        }
+        const rows = native.prepare(
+          `INSERT INTO graph_nodes (id, type, label, ref_id, metadata, created_at, updated_at) VALUES ${placeholders}
+             ON CONFLICT(type, label) WHERE type != 'symbol' DO UPDATE SET ref_id = COALESCE(excluded.ref_id, graph_nodes.ref_id), metadata = excluded.metadata, updated_at = excluded.updated_at
+             RETURNING id, label`
+        ).all(...params);
+        results.push(...rows.map((r) => ({ label: r.label, id: String(r.id) })));
+      }
+      return results;
+    },
     async getGraphNode(id) {
       const row = native.prepare("SELECT * FROM graph_nodes WHERE id = ?").get(id);
       return row ? mapNodeRow(row) : null;
@@ -30293,13 +30323,7 @@ function walkTree(root, config2, lines) {
           endLine: endRow,
           ...receiver ? { receiver } : {}
         });
-        extractCallsInNode(
-          node,
-          config2,
-          fullName,
-          calledIdentifiers,
-          callExpressions
-        );
+        extractCallsInNode(node, config2, fullName, calledIdentifiers, callExpressions);
         const isContextNode = symbolRule.establishesContext || config2.contextNodeTypes.has(node.type);
         if (isContextNode) {
           const contextName = symbolRule.extractContextName ? symbolRule.extractContextName(node) ?? fullName : fullName;
@@ -30324,9 +30348,7 @@ function walkTree(root, config2, lines) {
 }
 function extractCallsInNode(symbolNode, config2, callerName, calledIdentifiers, callExpressions) {
   const nestedSymbolTypes = config2.symbolRules.map((r) => r.nodeType);
-  const nestedSymbols = symbolNode.descendantsOfType(nestedSymbolTypes).filter(
-    (n) => !(n.startIndex === symbolNode.startIndex && n.endIndex === symbolNode.endIndex)
-  );
+  const nestedSymbols = symbolNode.descendantsOfType(nestedSymbolTypes).filter((n) => !(n.startIndex === symbolNode.startIndex && n.endIndex === symbolNode.endIndex));
   const callNodes = symbolNode.descendantsOfType(config2.callRule.nodeType);
   for (const callNode of callNodes) {
     const insideNested = nestedSymbols.some(
@@ -281073,7 +281095,12 @@ async function writeEmbeddingsToRepo(repo, chunkRows, provider) {
   const BATCH_SIZE = 50;
   let totalWritten = 0;
   let failedBatches = 0;
+  const totalBatches = Math.ceil(toEmbed.length / BATCH_SIZE);
   for (let i = 0; i < toEmbed.length; i += BATCH_SIZE) {
+    const batchNum = Math.floor(i / BATCH_SIZE) + 1;
+    if (batchNum % 10 === 0 || batchNum === totalBatches) {
+      process.stdout.write(`\r[embedding] batch ${batchNum}/${totalBatches} (${totalWritten} written)`);
+    }
     const batch = toEmbed.slice(i, i + BATCH_SIZE);
     try {
       const vectors = await provider.embed(
@@ -281118,6 +281145,9 @@ async function writeEmbeddingsToRepo(repo, chunkRows, provider) {
       );
     }
   }
+  if (totalBatches > 0) {
+    process.stdout.write("\n");
+  }
   return { written: totalWritten + reusedWritten, failedBatches };
 }
 async function parseInline(tasks, onProgress) {
@@ -281161,6 +281191,15 @@ async function indexWorkspace(input) {
   const excludeGlobs = workspace.excludeGlobs || configuredWorkspace?.exclude.join("\n") || "";
   const embeddingProvider = await getEmbeddingProvider();
   const runMode = input.mode ?? "incremental";
+  if (embeddingProvider) {
+    process.stdout.write(
+      `[embedding] provider=${embeddingProvider.provider} model=${embeddingProvider.model}
+`
+    );
+  } else {
+    process.stdout.write(`[embedding] disabled (no provider configured)
+`);
+  }
   const reportProgress = async (message, progress) => {
     await input.onProgress?.({ message, progress });
   };
@@ -281358,6 +281397,8 @@ async function indexWorkspace(input) {
         const chunkNodeIds = await repo.insertGraphNodesBatch(chunkNodeInputs);
         const edges = [];
         const reusedSymbolIds = /* @__PURE__ */ new Set();
+        const newSymbolInputs = [];
+        const pendingSymbolEdges = [];
         for (const [ci, chunkId] of chunkIds.entries()) {
           const chunkNodeId = chunkNodeIds[ci];
           edges.push({ fromNodeId: fileNodeId, toNodeId: chunkNodeId, type: "contains" });
@@ -281366,7 +281407,7 @@ async function indexWorkspace(input) {
           if (symbolName) {
             const fileSymbolKey = `${file.relativePath}\0${symbolName}`;
             let symbolNodeId = symbolNodeIdsByFileAndName.get(fileSymbolKey);
-            if (!symbolNodeId) {
+            if (symbolNodeIdsByFileAndName.has(fileSymbolKey) === false) {
               const existingSymbolId = fileExistingSymbols.get(symbolName);
               if (existingSymbolId) {
                 repo.updateSymbolNode(
@@ -281381,7 +281422,7 @@ async function indexWorkspace(input) {
                 );
                 symbolNodeId = existingSymbolId;
               } else {
-                symbolNodeId = await repo.upsertGraphNode({
+                newSymbolInputs.push({
                   type: "symbol",
                   label: symbolName,
                   refId: chunkId,
@@ -281390,14 +281431,43 @@ async function indexWorkspace(input) {
                     filePath: file.relativePath,
                     language: indexed.language,
                     parser: indexed.parser
-                  })
+                  }),
+                  _chunkIndex: ci
                 });
+                symbolNodeId = "";
               }
               symbolNodeIdsByFileAndName.set(fileSymbolKey, symbolNodeId);
+            } else {
+              symbolNodeId = symbolNodeIdsByFileAndName.get(fileSymbolKey) ?? "";
             }
             reusedSymbolIds.add(symbolNodeId);
+            const definesEdgeIdx = edges.length;
             edges.push({ fromNodeId: fileNodeId, toNodeId: symbolNodeId, type: "defines" });
+            const representedByEdgeIdx = edges.length;
             edges.push({ fromNodeId: symbolNodeId, toNodeId: chunkNodeId, type: "represented_by" });
+            if (symbolNodeId === "") {
+              pendingSymbolEdges.push({ label: symbolName, definesEdgeIdx, representedByEdgeIdx });
+            }
+          }
+        }
+        if (newSymbolInputs.length > 0) {
+          const symbolIds = await repo.insertGraphNodesBatch(
+            newSymbolInputs.map(({ _chunkIndex, ...rest }) => rest)
+          );
+          for (let si = 0; si < newSymbolInputs.length; si++) {
+            const input2 = newSymbolInputs[si];
+            const fileSymbolKey = `${file.relativePath}\0${input2.label}`;
+            const newId = symbolIds[si];
+            symbolNodeIdsByFileAndName.set(fileSymbolKey, newId);
+            reusedSymbolIds.add(newId);
+          }
+          for (const pending of pendingSymbolEdges) {
+            const newId = symbolNodeIdsByFileAndName.get(
+              `${file.relativePath}\0${pending.label}`
+            );
+            if (!newId) continue;
+            edges[pending.definesEdgeIdx].toNodeId = newId;
+            edges[pending.representedByEdgeIdx].fromNodeId = newId;
           }
         }
         const staleSymbolIds = [];
@@ -281409,6 +281479,8 @@ async function indexWorkspace(input) {
         if (staleSymbolIds.length > 0) {
           repo.deleteGraphNodesByIds(staleSymbolIds);
         }
+        const batchNodeInputs = [];
+        const importEdgeInputs = [];
         for (const importPath of indexed.importPaths) {
           if (typeof importPath !== "string" || importPath.length === 0) continue;
           const resolvedImportPath = workspaceFileResolver?.resolveImport(
@@ -281417,25 +281489,43 @@ async function indexWorkspace(input) {
             indexed.language ?? void 0
           );
           if (!resolvedImportPath) continue;
-          const targetNodeId = await repo.upsertGraphNode({
+          batchNodeInputs.push({
             type: "file",
             label: resolvedImportPath,
             metadata: JSON.stringify({ path: resolvedImportPath })
           });
-          edges.push({
-            fromNodeId: fileNodeId,
-            toNodeId: targetNodeId,
-            type: "imports",
-            metadata: JSON.stringify({ importPath })
-          });
+          importEdgeInputs.push({ importPath, resolvedImportPath });
         }
         for (const link of indexed.wikilinks) {
-          const entityNodeId = await repo.upsertGraphNode({
+          batchNodeInputs.push({
             type: "entity",
             label: link,
             metadata: "{}"
           });
-          edges.push({ fromNodeId: fileNodeId, toNodeId: entityNodeId, type: "mentions" });
+        }
+        if (batchNodeInputs.length > 0) {
+          const upsertedNodes = await repo.upsertGraphNodesBatch(batchNodeInputs);
+          const nodeByLabel = /* @__PURE__ */ new Map();
+          for (const node of upsertedNodes) {
+            nodeByLabel.set(node.label, node.id);
+          }
+          for (const { importPath, resolvedImportPath } of importEdgeInputs) {
+            const targetNodeId = nodeByLabel.get(resolvedImportPath);
+            if (targetNodeId) {
+              edges.push({
+                fromNodeId: fileNodeId,
+                toNodeId: targetNodeId,
+                type: "imports",
+                metadata: JSON.stringify({ importPath })
+              });
+            }
+          }
+          for (const link of indexed.wikilinks) {
+            const entityNodeId = nodeByLabel.get(link);
+            if (entityNodeId) {
+              edges.push({ fromNodeId: fileNodeId, toNodeId: entityNodeId, type: "mentions" });
+            }
+          }
         }
         const edgeSet = /* @__PURE__ */ new Set();
         const dedupedEdges = edges.filter((e) => {
@@ -281463,7 +281553,11 @@ async function indexWorkspace(input) {
         filesUpdated += 1;
       }
     });
-    if (allChunkRowsForEmbeddings.length > 0) {
+    if (allChunkRowsForEmbeddings.length > 0 && embeddingProvider) {
+      await reportProgress(
+        `Embedding ${allChunkRowsForEmbeddings.length} chunks via ${embeddingProvider.provider}/${embeddingProvider.model}...`,
+        90
+      );
       const embeddingResult = await writeEmbeddingsToRepo(
         repo,
         allChunkRowsForEmbeddings,
@@ -281473,10 +281567,12 @@ async function indexWorkspace(input) {
       embeddingFailures += embeddingResult.failedBatches;
     }
     if (bulkWriteMode) {
+      await reportProgress("Rebuilding FTS index...", 93);
       repo.restoreFtsTriggers();
       repo.setOptimizedWriteMode(false);
       bulkWriteMode = false;
     }
+    await reportProgress("Resolving call edges...", 95);
     const globalSymbolNodes = await repo.loadAllSymbolNodes();
     const insertedCallEdges = /* @__PURE__ */ new Set();
     const callEdges = [];
@@ -296995,7 +297091,7 @@ __export(mcp_bridge_exports, {
   startMcpServer: () => startMcpServer
 });
 async function startMcpServer(defaultPath, version4) {
-  await createAndStartMcpServer({ defaultPath, version: version4, build: "cc56c89-dirty" });
+  await createAndStartMcpServer({ defaultPath, version: version4, build: "ebc5064-dirty" });
 }
 var init_mcp_bridge = __esm({
   "src/mcp-bridge.ts"() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openez-graph/cli",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Local-first code intelligence engine — index, query, and graph your codebase with zero config. SQLite-only, MCP-first.",
   "license": "MIT",
   "author": "Asta Nguyen",