scip-query 0.4.1 → 0.4.3

package/dist/reindex-worker.js

@@ -11,8 +11,8 @@ import {
 
 // src/reindex/index.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync3, renameSync } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, renameSync, rmSync } from "fs";
+import { basename, dirname, extname as extname2, join as join3 } from "path";
 
 // src/reindex/detect.ts
 import { existsSync, readdirSync } from "fs";
@@ -390,6 +390,128 @@ function resolveDotnetProject(projectRoot2, suffixes) {
   return null;
 }
 
+// src/reindex/merge.ts
+import { readFileSync, writeFileSync } from "fs";
+import { create } from "@bufbuild/protobuf";
+import {
+  deserializeSCIP,
+  serializeSCIP,
+  DocumentSchema,
+  IndexSchema,
+  SymbolInformationSchema
+} from "@c4312/scip";
+function mergeScipIndexes(indexes) {
+  if (indexes.length === 0) {
+    throw new Error("Cannot merge zero SCIP indexes");
+  }
+  if (indexes.length === 1) {
+    return indexes[0];
+  }
+  const metadata = mergeMetadata(indexes);
+  const documents = mergeDocuments(indexes.flatMap((index) => index.documents ?? []));
+  const externalSymbols = mergeSymbolInfos(indexes.flatMap((index) => index.externalSymbols ?? []));
+  return create(IndexSchema, {
+    metadata,
+    documents,
+    externalSymbols
+  });
+}
+function mergeScipFiles(inputPaths, outputPath) {
+  if (inputPaths.length === 0) {
+    throw new Error("Cannot merge zero SCIP files");
+  }
+  const indexes = inputPaths.map((path) => deserializeSCIP(readFileSync(path)));
+  const merged = mergeScipIndexes(indexes);
+  writeFileSync(outputPath, Buffer.from(serializeSCIP(merged)));
+  return {
+    documentCount: merged.documents.length,
+    externalSymbolCount: merged.externalSymbols.length,
+    inputCount: inputPaths.length
+  };
+}
+function mergeMetadata(indexes) {
+  const first = indexes[0]?.metadata;
+  if (!first) {
+    return void 0;
+  }
+  const expectedProjectRoot = first.projectRoot;
+  for (const index of indexes.slice(1)) {
+    const actualProjectRoot = index.metadata?.projectRoot;
+    if (expectedProjectRoot && actualProjectRoot && actualProjectRoot !== expectedProjectRoot) {
+      throw new Error(
+        `Cannot merge SCIP indexes with different project roots: ${expectedProjectRoot} vs ${actualProjectRoot}`
+      );
+    }
+  }
+  return first;
+}
+function mergeDocuments(documents) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const document of documents) {
+    const existing = byPath.get(document.relativePath);
+    if (!existing) {
+      byPath.set(document.relativePath, document);
+      continue;
+    }
+    byPath.set(document.relativePath, create(DocumentSchema, {
+      language: existing.language || document.language,
+      relativePath: existing.relativePath || document.relativePath,
+      occurrences: [...existing.occurrences, ...document.occurrences],
+      symbols: mergeSymbolInfos([...existing.symbols, ...document.symbols]),
+      text: chooseText(existing.text, document.text),
+      positionEncoding: existing.positionEncoding || document.positionEncoding
+    }));
+  }
+  return [...byPath.values()];
+}
+function mergeSymbolInfos(symbols) {
+  const bySymbol = /* @__PURE__ */ new Map();
+  for (const symbol of symbols) {
+    const existing = bySymbol.get(symbol.symbol);
+    if (!existing) {
+      bySymbol.set(symbol.symbol, symbol);
+      continue;
+    }
+    bySymbol.set(symbol.symbol, create(SymbolInformationSchema, {
+      symbol: existing.symbol,
+      documentation: uniqueStrings([...existing.documentation, ...symbol.documentation]),
+      relationships: mergeRelationships([...existing.relationships, ...symbol.relationships]),
+      kind: existing.kind || symbol.kind,
+      displayName: existing.displayName || symbol.displayName,
+      enclosingSymbol: existing.enclosingSymbol || symbol.enclosingSymbol,
+      signatureDocumentation: existing.signatureDocumentation ?? symbol.signatureDocumentation
+    }));
+  }
+  return [...bySymbol.values()];
+}
+function mergeRelationships(relationships) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const relationship of relationships) {
+    const key = [
+      relationship.symbol,
+      relationship.isReference ? "1" : "0",
+      relationship.isImplementation ? "1" : "0",
+      relationship.isTypeDefinition ? "1" : "0",
+      relationship.isDefinition ? "1" : "0"
+    ].join("|");
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    merged.push(relationship);
+  }
+  return merged;
+}
+function chooseText(left, right) {
+  if (!left) return right;
+  if (!right) return left;
+  return left.length >= right.length ? left : right;
+}
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
+
 // src/reindex/index.ts
 async function reindex(opts) {
   const {
@@ -425,7 +547,11 @@ async function reindex(opts) {
     ...process.env,
     NODE_OPTIONS: `--max-old-space-size=${maxHeapMb}`
   };
-  for (const lang of languages2) {
+  const languageOutputs = languages2.map((language, index) => ({
+    language,
+    scipPath: languages2.length > 1 ? tempScipPath(outputScip2, language, index) : outputScip2
+  }));
+  for (const { language: lang, scipPath } of languageOutputs) {
     const config = getIndexerConfig(lang);
     const binaryLabel = describeIndexerBinary(config);
     const projectLocalBinary = resolveProjectLocalIndexerBinary(config, projectRoot2);
@@ -455,7 +581,7 @@ async function reindex(opts) {
     const indexerEnv = getIndexerExecutionEnv(config, env, resolvedBinary);
     const { binary, args } = config.indexArgs({
       projectRoot: projectRoot2,
-      outputPath: outputScip2,
+      outputPath: scipPath,
       pnpmWorkspaces: opts.pnpmWorkspaces,
       indexerBinary: resolvedBinary
     });
@@ -474,7 +600,11 @@ Make sure ${binaryLabel} is installed and available on PATH.`,
         { cause: err }
       );
     }
-    moveDefaultOutputIfNeeded(config, projectRoot2, outputScip2);
+    moveDefaultOutputIfNeeded(config, projectRoot2, scipPath);
+  }
+  if (languageOutputs.length > 1) {
+    onStatus(`Merging ${languageOutputs.length} language indexes...`);
+    mergeScipFiles(languageOutputs.map((entry) => entry.scipPath), outputScip2);
   }
   onStatus("Converting to SQLite...");
   if (!existsSync3(outputScip2)) {
@@ -489,6 +619,12 @@ Make sure ${binaryLabel} is installed and available on PATH.`,
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     throw new Error(`Failed to convert SCIP index to SQLite: ${msg}`, { cause: err });
+  } finally {
+    for (const { scipPath } of languageOutputs) {
+      if (scipPath !== outputScip2) {
+        rmSync(scipPath, { force: true });
+      }
+    }
   }
   const durationMs = Date.now() - start;
   onStatus(`Done in ${(durationMs / 1e3).toFixed(1)}s`);
@@ -503,6 +639,11 @@ function moveDefaultOutputIfNeeded(config, projectRoot2, outputScip2) {
     renameSync(defaultOutputPath, outputScip2);
   }
 }
+function tempScipPath(outputScip2, language, index) {
+  const extension = extname2(outputScip2) || ".scip";
+  const stem = basename(outputScip2, extension);
+  return join3(dirname(outputScip2), `${stem}.${index + 1}.${language}${extension}`);
+}
 
 // src/reindex-worker.ts
 var projectRoot = process.env["SCIP_REINDEX_PROJECT_ROOT"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scip-query",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Language-agnostic code intelligence CLI powered by SCIP indexes",
   "type": "module",
   "main": "dist/index.js",
@@ -60,6 +60,8 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
+    "@bufbuild/protobuf": "^2.11.0",
+    "@c4312/scip": "^0.1.0",
     "better-sqlite3": "^11.7.0",
     "commander": "^13.1.0",
     "ignore": "^7.0.3"