@colbymchenry/codegraph 1.1.4 → 1.1.6

package/dist/db/index.d.ts

@@ -119,4 +119,24 @@ export declare const DATABASE_FILENAME = "codegraph.db";
  * Get the default database path for a project
  */
 export declare function getDatabasePath(projectRoot: string): string;
+/**
+ * Delete a database file and its WAL sidecars (`-wal`/`-shm`).
+ *
+ * This is how a FULL re-index discards an existing database — rather than
+ * opening the old graph and DELETE-ing every row. On a large or pre-fix
+ * poisoned index (e.g. an old graph that scanned an ignored gitlink corpus into
+ * ~1.6M nodes with a multi-GB WAL, #1065) the per-row `nodes_fts` delete-trigger
+ * churn blocks the main thread long enough to trip the #850 liveness watchdog
+ * before indexing even starts, so the rebuild could never recover the bad state
+ * (#1067). Unlinking is O(1) regardless of DB size and also reclaims the disk
+ * the bloated WAL would otherwise keep.
+ *
+ * POSIX removes the directory entry even while another process (a daemon/MCP
+ * server) still holds the file open; that holder heals via `reopenIfReplaced`
+ * (#925). On Windows a live holder can make the unlink fail with EBUSY/EPERM —
+ * that is thrown for the caller to surface ("stop the other process and retry").
+ * The `-wal`/`-shm` sidecars are best-effort: SQLite recreates them on the next
+ * open, so a leftover sidecar is harmless.
+ */
+export declare function removeDatabaseFiles(dbPath: string): void;
 //# sourceMappingURL=index.d.ts.map

package/dist/extraction/languages/c-cpp.d.ts

@@ -24,5 +24,28 @@ export declare function normalizeCppReturnType(raw: string): string | undefined;
  */
 export declare function stripCppTemplateArgs(name: string): string;
 export declare const cExtractor: LanguageExtractor;
+/**
+ * Blank an export/visibility macro in a `class/struct EXPORT_MACRO Name …`
+ * *definition* header before parsing. Not knowing the macro, tree-sitter reads
+ * `class EXPORT_MACRO` as an elaborated type specifier and the rest as a
+ * function, so the whole class — its name, base clause, and members — drops out
+ * of the index (#946 catches the resulting phantom function but can't recover
+ * the class), which silently breaks type-hierarchy / inheritance-impact queries
+ * for effectively every Unreal-Engine (`*_API`), Qt/Boost (`*_EXPORT`), LLVM
+ * (`*_ABI`), … class. Replacing the macro with equal-length spaces preserves
+ * every byte offset (and thus line/column), so the declaration then parses as a
+ * normal class_specifier and the existing extraction emits the node, members,
+ * and `extends` edge. (#1061, follow-up to #946.)
+ *
+ * Matched tightly so it can't touch the same macro used as an ordinary value
+ * elsewhere (`int x = SOME_API;`): the macro is the ALL-CAPS token sitting
+ * *between* `class`/`struct` and the type name, and the trailing `[:{]`
+ * definition-guard fires only when a base clause or body follows — the only
+ * shape that misparses. That guard also leaves elaborated-type variable
+ * declarations (`struct FOO var;`, `class FOO obj = …`) untouched, since those
+ * end in `;` / `=` / `[`, never `:` / `{`. C++-only (wired into cppExtractor),
+ * so C's heavier use of `struct TAG var;` never reaches it.
+ */
+export declare function blankCppExportMacros(source: string): string;
 export declare const cppExtractor: LanguageExtractor;
 //# sourceMappingURL=c-cpp.d.ts.map

package/dist/index.d.ts

@@ -110,6 +110,23 @@ export declare class CodeGraph {
      * @returns A CodeGraph instance
      */
     static open(projectRoot: string, options?: OpenOptions): Promise<CodeGraph>;
+    /**
+     * Rebuild the project's database from scratch and return a fresh, empty
+     * instance — the "same result as a fresh init" semantics that `codegraph
+     * index` documents.
+     *
+     * Unlike `open()` followed by `clear()`, this DISCARDS the existing
+     * `.codegraph/codegraph.db` (and its `-wal`/`-shm` sidecars) before
+     * re-initializing, instead of opening the old database and DELETE-ing every
+     * row. On a large or pre-fix poisoned index — e.g. an old graph that scanned
+     * an ignored gitlink corpus (#1065) into ~1.6M nodes with a multi-GB WAL —
+     * the per-row `nodes_fts` delete-trigger churn blocks the main thread long
+     * enough to trip the #850 liveness watchdog before indexing even starts, so a
+     * full re-index could never recover the bad state (#1067). Discarding the
+     * files is O(1) regardless of size, reclaims the disk, and sidesteps opening
+     * (and running migrations against) the poisoned database entirely.
+     */
+    static recreate(projectRoot: string): Promise<CodeGraph>;
     /**
      * Open synchronously (without sync)
      */

package/npm-shim.js

@@ -105,7 +105,7 @@ async function selfHealBundle() {
   // Already downloaded by a previous run? Use it even when downloads are
   // disabled — CODEGRAPH_NO_DOWNLOAD blocks fetching, not a cached bundle.
   var cached = launcherIn(dest);
-  if (cached) return cached;
+  if (cached) { pruneOldBundles(bundlesDir, dest); return cached; }
 
   if (process.env.CODEGRAPH_NO_DOWNLOAD) {
     fail('the network fallback is disabled (CODEGRAPH_NO_DOWNLOAD is set).');
@@ -149,6 +149,7 @@ async function selfHealBundle() {
 
   var ready = launcherIn(dest);
   if (!ready) fail('downloaded bundle is missing its launcher under ' + dest + '.');
+  pruneOldBundles(bundlesDir, dest);
   process.stderr.write('codegraph: bundle ready.\n');
   return ready;
 }
@@ -230,6 +231,27 @@ function rmrf(p) {
   try { fs.rmSync(p, { recursive: true, force: true }); } catch (e) { /* best effort */ }
 }
 
+// Drop sibling bundles for OTHER versions of this same platform target, keeping
+// only keepDir. The self-heal cache otherwise accumulates a full ~50 MB bundle
+// per version forever (issue #1074). Best-effort: a locked/busy dir (a
+// concurrent run still mapping an older node.exe on Windows) just stays — rmrf
+// already swallows its own errors, and the readdir is guarded — so cleanup can
+// never break a working command. Only this target's "<target>-<version>" dirs
+// are touched; other platforms' bundles and the ".dl-*" staging dirs are left
+// alone.
+function pruneOldBundles(bundlesDir, keepDir) {
+  var keep = path.basename(keepDir);
+  try {
+    var names = fs.readdirSync(bundlesDir);
+    for (var i = 0; i < names.length; i++) {
+      var name = names[i];
+      if (name === keep) continue;
+      if (name.indexOf(target + '-') !== 0) continue;
+      rmrf(path.join(bundlesDir, name));
+    }
+  } catch (e) { /* best effort — never break a working run over cleanup */ }
+}
+
 function fail(reason) {
   process.stderr.write(
     'codegraph: no prebuilt bundle for ' + target + '.\n' +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colbymchenry/codegraph",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "Local-first code intelligence for AI agents (MCP). Self-contained — bundles its own runtime.",
   "bin": {
     "codegraph": "npm-shim.js"
@@ -15,12 +15,12 @@
     "./package.json": "./package.json"
   },
   "optionalDependencies": {
-    "@colbymchenry/codegraph-darwin-arm64": "1.1.4",
-    "@colbymchenry/codegraph-darwin-x64": "1.1.4",
-    "@colbymchenry/codegraph-linux-arm64": "1.1.4",
-    "@colbymchenry/codegraph-linux-x64": "1.1.4",
-    "@colbymchenry/codegraph-win32-arm64": "1.1.4",
-    "@colbymchenry/codegraph-win32-x64": "1.1.4"
+    "@colbymchenry/codegraph-darwin-arm64": "1.1.6",
+    "@colbymchenry/codegraph-darwin-x64": "1.1.6",
+    "@colbymchenry/codegraph-linux-arm64": "1.1.6",
+    "@colbymchenry/codegraph-linux-x64": "1.1.6",
+    "@colbymchenry/codegraph-win32-arm64": "1.1.6",
+    "@colbymchenry/codegraph-win32-x64": "1.1.6"
   },
   "files": [
     "npm-shim.js",