@neuralsea/workspace-indexer 0.3.3 → 0.3.5

package/dist/{chunk-IXKSW7IX.js → chunk-FUUQXFJQ.js}

@@ -1621,6 +1621,16 @@ var RepoFileIndexer = class {
       return;
     }
     this.emit({ type: "repo/index/file/start", repoRoot: this.repoRoot, path: posixRelPath });
+    const stage = (stageName, stageStartedAt) => {
+      this.emit({
+        type: "repo/index/file/stage",
+        repoRoot: this.repoRoot,
+        path: posixRelPath,
+        stage: stageName,
+        ms: Date.now() - stageStartedAt
+      });
+    };
+    const readStartedAt = Date.now();
     const abs = path9.join(this.repoRoot, fromPosixPath(posixRelPath));
     let stat;
     try {
@@ -1644,16 +1654,20 @@ var RepoFileIndexer = class {
     }
     const raw = buf.toString("utf8");
     const redacted = this.applyRedactions(raw);
+    stage("read", readStartedAt);
     const fileHash = sha256Hex(redacted);
     const prev = this.store.getFileHash(posixRelPath);
     if (prev === fileHash) {
       this.emit({ type: "repo/index/file/skip", repoRoot: this.repoRoot, path: posixRelPath, reason: "unchanged" });
       return;
     }
+    const chunkStartedAt = Date.now();
     const { language, chunks } = chunkSource(posixRelPath, redacted, this.config.chunk);
+    stage("chunk", chunkStartedAt);
     let imports = [];
     let exports = [];
     if (language === "typescript" || language === "javascript") {
+      const relationsStartedAt = Date.now();
       const rel = extractTsRelations(posixRelPath, redacted);
       imports = rel.imports;
       exports = rel.exports;
@@ -1661,12 +1675,14 @@ var RepoFileIndexer = class {
       this.store.setEdges(posixRelPath, "export", rel.exports);
       this.workspaceStore?.setEdges(this.repoId, posixRelPath, "import", rel.imports);
       this.workspaceStore?.setEdges(this.repoId, posixRelPath, "export", rel.exports);
+      stage("relations", relationsStartedAt);
     } else {
       this.store.setEdges(posixRelPath, "import", []);
       this.store.setEdges(posixRelPath, "export", []);
       this.workspaceStore?.setEdges(this.repoId, posixRelPath, "import", []);
       this.workspaceStore?.setEdges(this.repoId, posixRelPath, "export", []);
     }
+    const synopsisStartedAt = Date.now();
     const synopsisText = buildSynopsis(posixRelPath, language, redacted);
     const synopsis = synopsisText.trim() ? [
       {
@@ -1691,14 +1707,29 @@ var RepoFileIndexer = class {
       }
     ] : [];
     const combined = [...synopsis, ...headerChunk, ...chunks.map((c) => ({ ...c, kind: "chunk" }))];
+    stage("synopsis", synopsisStartedAt);
+    const embedStartedAt = Date.now();
     const embedTexts = [];
     const embedPlan = [];
     const embeddings = combined.map(() => null);
+    let cached2 = 0;
     for (let i = 0; i < combined.length; i++) {
       const ch = combined[i];
-      const cached2 = this.embeddingCache.get(this.embedder.id, ch.contentHash);
-      if (cached2) {
-        embeddings[i] = cached2;
+      const cachedEmb = this.embeddingCache.get(this.embedder.id, ch.contentHash);
+      if (cachedEmb) {
+        embeddings[i] = cachedEmb;
+        cached2++;
+        this.emit({
+          type: "repo/index/file/embed/chunk",
+          repoRoot: this.repoRoot,
+          path: posixRelPath,
+          chunkIndex: i,
+          chunksTotal: combined.length,
+          kind: ch.kind,
+          startLine: ch.startLine,
+          endLine: ch.endLine,
+          cached: true
+        });
         continue;
       }
       embedTexts.push(
@@ -1710,7 +1741,7 @@ lines:${ch.startLine}-${ch.endLine}
 ---
 ${ch.text}`
       );
-      embedPlan.push({ chunkIdx: i, contentHash: ch.contentHash });
+      embedPlan.push({ chunkIdx: i, contentHash: ch.contentHash, kind: ch.kind, startLine: ch.startLine, endLine: ch.endLine });
     }
     const batchSize = this.config.embed.batchSize;
     for (let start = 0; start < embedTexts.length; start += batchSize) {
@@ -1728,13 +1759,35 @@ ${ch.text}`
         const plan = embedPlan[start + j];
         embeddings[plan.chunkIdx] = vecs[j];
         this.embeddingCache.put(this.embedder.id, plan.contentHash, vecs[j]);
+        this.emit({
+          type: "repo/index/file/embed/chunk",
+          repoRoot: this.repoRoot,
+          path: posixRelPath,
+          chunkIndex: plan.chunkIdx,
+          chunksTotal: combined.length,
+          kind: plan.kind,
+          startLine: plan.startLine,
+          endLine: plan.endLine,
+          cached: false
+        });
       }
     }
+    this.emit({
+      type: "repo/index/file/embed/done",
+      repoRoot: this.repoRoot,
+      path: posixRelPath,
+      chunks: combined.length,
+      cached: cached2,
+      computed: embedTexts.length,
+      ms: Date.now() - embedStartedAt
+    });
+    stage("embed", embedStartedAt);
     const fileMtime = stat.mtimeMs;
     const ftsMode = this.config.storage.ftsMode;
     const storeText = this.config.storage.storeText;
     const oldChunkIds = this.store.listChunksForFile(posixRelPath).map((r) => r.id);
     const points = [];
+    const storeStartedAt = Date.now();
     const rows = combined.map((ch, i) => {
       const id = sha256Hex(
         `${this.repoId}:${posixRelPath}:${ch.kind}:${ch.startLine}:${ch.endLine}:${ch.contentHash}`
@@ -1762,7 +1815,22 @@ ${ch.text}`
     this.store.replaceChunksForFile(posixRelPath, rows);
     this.workspaceStore?.upsertFile(this.repoId, posixRelPath, fileHash, fileMtime, language, stat.size);
     this.workspaceStore?.replaceChunksForFile(this.repoId, this.repoRoot, posixRelPath, rows);
+    stage("store", storeStartedAt);
+    const symbolsStartedAt = Date.now();
+    if (this.symbolGraphProvider && this.symbolGraphProvider.supports(language)) {
+      this.emit({ type: "repo/index/file/symbols/start", repoRoot: this.repoRoot, path: posixRelPath, providerId: this.symbolGraphProvider.id });
+    }
     const symbolOut = await this.indexSymbolsIfEnabled(posixRelPath, language, redacted, fileHash);
+    this.emit({
+      type: "repo/index/file/symbols",
+      repoRoot: this.repoRoot,
+      path: posixRelPath,
+      symbols: symbolOut?.symbols?.length ?? 0,
+      edges: symbolOut?.edges?.length ?? 0,
+      ms: Date.now() - symbolsStartedAt
+    });
+    stage("symbols", symbolsStartedAt);
+    const graphStartedAt = Date.now();
     const head = this.getHead();
     if (this.graphStore && head) {
       await this.graphStore.replaceFileGraph({
@@ -1778,7 +1846,10 @@ ${ch.text}`
         symbolEdges: (symbolOut?.edges ?? []).map((e) => ({ fromId: e.fromId, toId: e.toId, kind: e.kind }))
       }).catch(() => void 0);
     }
+    stage("graph", graphStartedAt);
+    const vectorStartedAt = Date.now();
     await this.ensureVectorUpToDate(points, oldChunkIds);
+    stage("vector", vectorStartedAt);
     this.emit({
       type: "repo/index/file/done",
       repoRoot: this.repoRoot,
@@ -2389,28 +2460,46 @@ var RepoIndexer = class {
     const uniq3 = Array.from(new Set(posixPaths)).slice(0, maxFiles);
     for (const p of uniq3) {
       if (opts?.signal?.aborted) return;
+      const startedAt = Date.now();
+      this.emitProgress({ type: "repo/symbolGraph/expand/start", repoRoot: this.repoRoot, path: p });
       const abs = path12.join(this.repoRoot, p.split("/").join(path12.sep));
       let text = "";
       try {
         text = fs9.readFileSync(abs, "utf8");
       } catch {
+        this.emitProgress({ type: "repo/symbolGraph/expand/done", repoRoot: this.repoRoot, path: p, edges: 0, ms: Date.now() - startedAt });
         continue;
       }
       const contentHash = this.store.getFileHash(p) ?? void 0;
       const lang = languageFromPath(p);
       const edges = await provider.expandDocumentEdges({ repoRoot: this.repoRoot, path: p, language: lang, text, contentHash }, { signal: opts?.signal }).catch(() => []);
       const normalized = (Array.isArray(edges) ? edges : []).map((e) => ({
-        fromId: e.fromId,
-        toId: e.toId,
-        kind: e.kind,
-        toPath: String(e.toPath ?? "")
+        fromId: String(e?.fromId ?? ""),
+        toId: String(e?.toId ?? ""),
+        kind: String(e?.kind ?? ""),
+        toPath: String(e?.toPath ?? "")
       }));
+      const byKind = {};
+      for (const e of normalized) {
+        const kind = e.kind;
+        if (kind === "definition" || kind === "reference" || kind === "implementation" || kind === "typeDefinition") {
+          byKind[kind] = (byKind[kind] ?? 0) + 1;
+        }
+      }
       this.workspaceStore.replaceSymbolEdgesFromFile(this.repoId, p, normalized);
       await this.graphStore?.replaceOutgoingSymbolEdgesFromFile?.({
         repoId: this.repoId,
         fromPath: p,
         edges: normalized.map((e) => ({ fromId: e.fromId, toId: e.toId, kind: e.kind, toPath: e.toPath }))
       }).catch(() => void 0);
+      this.emitProgress({
+        type: "repo/symbolGraph/expand/done",
+        repoRoot: this.repoRoot,
+        path: p,
+        edges: normalized.length,
+        byKind,
+        ms: Date.now() - startedAt
+      });
     }
   }
   async watch() {
@@ -3308,10 +3397,24 @@ var Neo4jGraphStore = class {
     this.driver = driver;
     this.cfg = cfg;
     this.labelPrefix = cfg.labelPrefix ?? "Petri";
+    this.emitProgress = cfg.emit ?? null;
   }
   id = "neo4j";
   labelPrefix;
   schemaVersionLatest = 2;
+  emitProgress;
+  opStart(op, args) {
+    try {
+      this.emitProgress?.({ type: "graph/neo4j/op/start", op, repoId: args?.repoId, path: args?.path });
+    } catch {
+    }
+  }
+  opDone(op, startedAt, args) {
+    try {
+      this.emitProgress?.({ type: "graph/neo4j/op/done", op, repoId: args?.repoId, path: args?.path, ms: Date.now() - startedAt });
+    } catch {
+    }
+  }
   labels() {
     return {
       Repo: lp(this.labelPrefix, "Repo"),
@@ -3322,6 +3425,8 @@ var Neo4jGraphStore = class {
     };
   }
   async init() {
+    const startedAt = Date.now();
+    this.opStart("init");
     const { Schema } = this.labels();
     await runSession(this.driver, this.cfg.database, async (s) => {
       await s.run(
@@ -3332,6 +3437,7 @@ var Neo4jGraphStore = class {
       );
     });
     await this.runMigrations().catch(() => void 0);
+    this.opDone("init", startedAt);
   }
   async getSchemaVersion() {
     const { Schema } = this.labels();
@@ -3355,6 +3461,8 @@ var Neo4jGraphStore = class {
     });
   }
   async runMigrations() {
+    const startedAt = Date.now();
+    this.opStart("migrations");
     const { Repo, File, Symbol, External } = this.labels();
     let v = await this.getSchemaVersion();
     if (v < 1) {
@@ -3395,8 +3503,11 @@ var Neo4jGraphStore = class {
     if (v !== this.schemaVersionLatest) {
       await this.setSchemaVersion(this.schemaVersionLatest);
     }
+    this.opDone("migrations", startedAt);
   }
   async setRepoHead(args) {
+    const startedAt = Date.now();
+    this.opStart("setRepoHead", { repoId: args.repoId });
     const { Repo, File, Symbol, External } = this.labels();
     const { repoId, repoRoot, commit, branch } = args;
     await runSession(this.driver, this.cfg.database, async (s) => {
@@ -3427,15 +3538,21 @@ var Neo4jGraphStore = class {
         await s.run(`MATCH (r:${Repo} {repo_id:$repoId}) SET r.commit=$commit`, { repoId, commit });
       }
     });
+    this.opDone("setRepoHead", startedAt, { repoId: args.repoId });
   }
   async deleteFile(args) {
+    const startedAt = Date.now();
+    this.opStart("deleteFile", { repoId: args.repoId, path: args.path });
     const { File, Symbol } = this.labels();
     await runSession(this.driver, this.cfg.database, async (s) => {
       await s.run(`MATCH (s:${Symbol} {repo_id:$repoId, path:$path}) DETACH DELETE s`, args);
       await s.run(`MATCH (f:${File} {repo_id:$repoId, path:$path}) DETACH DELETE f`, args);
     });
+    this.opDone("deleteFile", startedAt, { repoId: args.repoId, path: args.path });
   }
   async replaceOutgoingSymbolEdgesFromFile(args) {
+    const startedAt = Date.now();
+    this.opStart("replaceOutgoingSymbolEdgesFromFile", { repoId: args.repoId, path: args.fromPath });
     const { Symbol } = this.labels();
     const kinds = args.edges.length > 0 ? Array.from(new Set(args.edges.map((e) => e.kind))) : ["definition", "reference", "implementation", "typeDefinition"];
     const keep = args.edges.map((e) => `${e.fromId}|${e.kind}|${e.toId}`);
@@ -3467,8 +3584,11 @@ var Neo4jGraphStore = class {
         { repoId: args.repoId, fromPath: args.fromPath, kinds, keep }
       ).catch(() => void 0);
     });
+    this.opDone("replaceOutgoingSymbolEdgesFromFile", startedAt, { repoId: args.repoId, path: args.fromPath });
   }
   async replaceFileGraph(update) {
+    const startedAt = Date.now();
+    this.opStart("replaceFileGraph", { repoId: update.repoId, path: update.path });
     const { Repo, File, Symbol, External } = this.labels();
     const symbols = update.symbols.map((s) => ({
       id: s.id,
@@ -3580,8 +3700,11 @@ var Neo4jGraphStore = class {
         }
       }
     });
+    this.opDone("replaceFileGraph", startedAt, { repoId: update.repoId, path: update.path });
   }
   async replaceRepoLinks(args) {
+    const startedAt = Date.now();
+    this.opStart("replaceRepoLinks");
     const { Repo } = this.labels();
     const byFrom = /* @__PURE__ */ new Map();
     for (const l of args.links) {
@@ -3612,8 +3735,11 @@ var Neo4jGraphStore = class {
         ).catch(() => void 0);
       });
     }
+    this.opDone("replaceRepoLinks", startedAt);
   }
   async neighborFiles(args) {
+    const startedAt = Date.now();
+    this.opStart("neighborFiles");
     const { File, Symbol } = this.labels();
     const limit = args.limit ?? 20;
     const kinds = args.kinds && args.kinds.length > 0 ? args.kinds : null;
@@ -3637,9 +3763,12 @@ var Neo4jGraphStore = class {
         rows.push({ repoId, path: p, weight: Number.isFinite(w) ? w : 0 });
       }
     });
+    this.opDone("neighborFiles", startedAt);
     return rows;
   }
   async shortestFilePath(args) {
+    const startedAt = Date.now();
+    this.opStart("shortestFilePath");
     const { File } = this.labels();
     const maxRels = args.maxRels ?? 16;
     let out = null;
@@ -3655,9 +3784,12 @@ var Neo4jGraphStore = class {
       if (!Array.isArray(files)) return;
       out = files.map((x) => ({ repoId: String(x.repoId), path: String(x.path) }));
     });
+    this.opDone("shortestFilePath", startedAt);
     return out;
   }
   async extractFileSubgraph(args) {
+    const startedAt = Date.now();
+    this.opStart("extractFileSubgraph");
     const { File, Symbol } = this.labels();
     const limitEdges = args.limitEdges ?? 200;
     const nodes = /* @__PURE__ */ new Map();
@@ -3679,6 +3811,7 @@ var Neo4jGraphStore = class {
         edges.push({ from, to, kind });
       }
     });
+    this.opDone("extractFileSubgraph", startedAt);
     return { nodes: Array.from(nodes.values()), edges };
   }
   async close() {
@@ -4039,7 +4172,8 @@ var WorkspaceIndexer = class {
           user: n.user,
           password: n.password,
           database: n.database,
-          labelPrefix: n.labelPrefix
+          labelPrefix: n.labelPrefix,
+          emit: (e) => this.emitProgress(e)
         });
       } catch (e) {
         this.emitProgress({
@@ -4236,11 +4370,14 @@ var WorkspaceIndexer = class {
           if (seeds.length >= 4) break;
         }
         if (seeds.length > 0) {
+          const gs = Date.now();
+          this.emitProgress({ type: "workspace/retrieve/graph/start", workspaceRoot: this.workspaceRoot, seeds: seeds.length });
           graphNeighborFiles = await this.graphStore.neighborFiles({
             seeds,
             limit: profile.name === "architecture" ? 16 : 10,
             kinds: ["definition", "reference", "implementation", "typeDefinition"]
           });
+          this.emitProgress({ type: "workspace/retrieve/graph/done", workspaceRoot: this.workspaceRoot, neighbors: graphNeighborFiles.length, ms: Date.now() - gs });
         }
       }
     } catch {