@aroman22/codegraph-vba 1.7.0 → 1.7.2

package/dist/mcp/daemon-watchdog.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Daemon liveness watchdog — issue #116.
+ *
+ * The MCP server (or any long-lived host) registers project roots it serves.
+ * Every `intervalMs`, the watchdog checks each root's daemon (via the
+ * {@link listDaemons} discovery index + liveness probe). If a daemon that
+ * SHOULD exist is dead (kill -9, Stop-Process, crash, …), the watchdog
+ * respawns it with the same spawnDetachedDaemon recipe the launcher uses
+ * (`process.execPath` + `process.execArgv` + `scriptPath serve --mcp --path <root>`).
+ *
+ * Why a watchdog (vs. spawn-on-demand at MCP request time): the issue's repro
+ * is `Stop-Process -Id <pid>` while the MCP keeps serving — file edits are
+ * missed until the user manually runs `codegraph-vba sync`. The watchdog
+ * closes that gap in <intervalMs>.
+ *
+ * Spawned detaches (own session/process group) so closing the MCP process
+ * does not take the watchdog down with it.
+ */
+export interface DaemonWatchdogOptions {
+    /** Poll interval (ms). Default 30s. */
+    intervalMs?: number;
+    /** Override the path to the codegraph binary used to spawn the daemon. */
+    scriptPath?: string;
+    /** Override node executable used to spawn the daemon. */
+    nodePath?: string;
+    /**
+     * Override the spawn implementation. Used by tests; production callers
+     * leave this unset to use the real `child_process.spawn`.
+     */
+    spawnFn?: (nodePath: string, args: string[], opts: {
+        detached: boolean;
+        env: NodeJS.ProcessEnv;
+        windowsHide?: boolean;
+        stdio?: 'ignore' | ['ignore', number, number];
+    }) => boolean;
+}
+/**
+ * Per-project daemon liveness watchdog. Registers roots; polls every
+ * `intervalMs`; respawns a daemon if the live one dies.
+ */
+export declare class DaemonWatchdog {
+    private readonly roots;
+    private interval;
+    private readonly intervalMs;
+    private readonly scriptPath;
+    private readonly nodePath;
+    private readonly spawnFn;
+    constructor(opts?: DaemonWatchdogOptions);
+    /** Watch a project root: if its daemon dies, respawn it. Idempotent. */
+    watch(root: string): void;
+    /** Stop watching a root. Idempotent. */
+    unwatch(root: string): void;
+    /** Number of roots currently being watched. */
+    size(): number;
+    /**
+     * Start the polling loop. No-op if already running. Detached from any caller;
+     * safe to call from a request handler.
+     */
+    start(): void;
+    /** Stop the polling loop. Idempotent. */
+    stop(): void;
+    /**
+     * Run one round: for each watched root, check daemon liveness and respawn
+     * if missing. Exposed for tests + manual triggers.
+     */
+    tick(): Promise<void>;
+    /**
+     * If no live daemon serves `root`, spawn one. Exposed for tests + manual
+     * triggers. Resolves to `true` if a daemon was spawned, `false` if one
+     * was already running or no `.codegraph/` is reachable from `root`.
+     */
+    checkAndRespawn(root: string): Promise<boolean>;
+    /** Spawn a fresh daemon for `root`. Detached; safe to call from any context. */
+    spawn(root: string): boolean;
+    /**
+     * Wait for a daemon's socket to appear at one of the candidate paths under
+     * `root`. Used by callers that want a synchronous spawn-then-use flow; not
+     * required by the watchdog itself (which only needs liveness, not binding).
+     */
+    waitForSocket(root: string, maxRetries?: number): Promise<boolean>;
+    /** True if a daemon's pid file at `root` points at a live process. */
+    hasLiveDaemon(root: string): boolean;
+}
+//# sourceMappingURL=daemon-watchdog.d.ts.map

package/dist/mcp/index.d.ts

@@ -51,6 +51,7 @@ export declare class MCPServer {
     private daemon;
     private ppidWatchdog;
     private livenessWatchdog;
+    private daemonWatchdog;
     private originalPpid;
     private hostPpid;
     private stopped;

package/dist/mcp/server-instructions.d.ts

@@ -17,7 +17,7 @@
  * tools (node/search/callers/…) stay defined and are re-enablable via
  * CODEGRAPH_MCP_TOOLS, but they are NOT listed to agents, so don't name them.
  */
-export declare const SERVER_INSTRUCTIONS = "# Codegraph \u2014 code intelligence over an indexed knowledge graph\n\nCodegraph is a SQLite knowledge graph of every symbol, edge, and file in\nthe workspace \u2014 pre-computed structure you would otherwise re-derive by\nreading files (cached intelligence: thousands of parse/trace decisions you\ndon't pay to re-reason each run). Reads are sub-millisecond; the index lags\nwrites by ~1s through the file watcher. Reach for it BEFORE *and* while\nwriting or editing code \u2014 not just for questions: one call returns the\nverbatim source PLUS who calls it and what it affects, so you edit with the\nblast radius in view. More accurate context, in far fewer tokens and\nround-trips than reading files yourself.\n\n## One tool: codegraph_explore \u2014 use it instead of reading files\n\nThere is a single tool, `codegraph_explore`, and it is Read-equivalent. It\ntakes either a natural-language question or a bag of symbol/file names and\nreturns the **verbatim, line-numbered source** of the relevant symbols\ngrouped by file \u2014 the same `<n>\\t<line>` shape `Read` gives you, safe to\n`Edit` from \u2014 PLUS the call path among them (including dynamic-dispatch hops\nlike callbacks, React re-render, and JSX children that grep can't follow) and\na blast-radius summary of what depends on them.\n\nWhether you're answering \"how does X work\" or implementing a change (fixing a\nbug, adding a feature), call `codegraph_explore` before you Read. ONE call\nusually answers the whole question. Codegraph IS the pre-built search index \u2014\nso running your own grep + read loop, or delegating the lookup to a separate\nfile-reading sub-task/agent, repeats work codegraph already did and costs more\nfor the same answer. A direct codegraph answer is typically one to a few\ncalls; a grep/read exploration is dozens.\n\n## How to query\n\n- **Almost any question \u2014 \"how does X work\", architecture, a bug, \"what/where is X\", or surveying an area** \u2192 `codegraph_explore` with a natural-language question or the relevant names. ONE capped call returns the verbatim source grouped by file; most often the ONLY call you need.\n- **\"How does X reach/become Y? / the flow / the path from X to Y\"** \u2192 `codegraph_explore`, naming the symbols that span the flow (e.g. `mutateElement renderScene`) \u2014 it surfaces the call path among them, riding dynamic-dispatch hops, and returns their source.\n- **Reading or editing a file/symbol you can name** \u2192 put its name or file path in the `codegraph_explore` query \u2014 it returns that current line-numbered source (safe to `Edit` from) with the call path and blast radius attached, so you don't Read it separately. For an overloaded name it returns every matching definition's body in one call.\n- **Need more?** Call `codegraph_explore` again with more specific names \u2014 treat the source it returns as already Read.\n\n## Anti-patterns\n\n- **Trust codegraph's results \u2014 don't re-verify them with grep.** They come from a full AST parse; re-checking with grep is slower, less accurate, and wastes context.\n- **Don't grep or Read first** to find or understand indexed code \u2014 ONE `codegraph_explore` returns the relevant symbols' source together in a single round-trip. Reach for raw `Read`/`Grep` only to confirm a specific detail codegraph didn't cover, or for what codegraph doesn't index (configs, docs).\n- **Don't reconstruct a flow by hand** \u2014 name the endpoints in one `codegraph_explore` and it surfaces the path between them, dynamic-dispatch hops included.\n- **After editing, check the staleness banner.** When a tool response starts with \"\u26A0\uFE0F Some files referenced below were edited since the last index sync\u2026\", the listed files are pending re-index \u2014 Read those specific files for accurate content. Every file NOT in that banner is fresh, so still trust codegraph. A different, rarer banner \u2014 \"\u26A0\uFE0F CodeGraph auto-sync is DISABLED\u2026\" \u2014 means live watching stopped entirely (the whole index is frozen, not just a few files); until it's resolved, Read files directly to confirm anything that may have changed.\n\n## Limitations\n\n- If a tool reports a project isn't indexed (no `.codegraph/`), stop calling codegraph tools for that project for the rest of the session and use your built-in tools there instead. Indexing is the user's decision \u2014 mention they can run `codegraph init` if it comes up, but don't run it yourself.\n- Index lags file writes by ~1 second.\n- Cross-file resolution is best-effort name matching; ambiguous calls may return multiple candidates.\n- No live correctness validation \u2014 that's still the TypeScript compiler / test suite / linter's job. Codegraph supplements those with structural context they don't have.\n\n## Supported Languages\n\nThe indexer recognizes a fixed set of languages; if you ask about symbols in a\nfile with an unsupported extension, codegraph will report the project isn't\nindexed for that file and you should fall back to Read/Grep. The fork-specific\naddition beyond upstream codegraph is **VBA / Access** (Dysflow export\nformat):\n\n- **VBA / Access** - Dysflow exports Access/VBA source as `.bas`/`.cls`/\n  `.form.txt`/`.report.txt`. Codegraph extracts `.bas`/`.cls` as `module`/\n  `class`/`function` nodes with `calls`/`implements`/`references` edges\n  (procedural-level; regex-based, not full AST). Cross-module calls, qualified\n  `Dim As`, `WithEvents`, and SQL table references inside string literals\n  emit synthesized edges tagged `metadata.synthesizedBy` (`vba-name-resolution`,\n  `vba-withevents`, `vba-sql-table`). `.form.txt` and `.report.txt` are\n  extracted as a `module` plus one `property` per Access control - **no**\n  `function`/`sub`/`class` nodes come from form files; the canonical code\n  lives in the sibling `.cls`, parsed by the same extractor on that file.\n  Dysflow test manifests (`tests.*.json`) link each registered `Test_*`\n  procedure to its manifest with a `references` edge tagged\n  `vba-test-manifest` carrying the test name + tags, so `getCallers` of a\n  production symbol reaches its covering test atoms with the manifest and tags\n  to run.\n  Pass `projectPath` to a codegraph index that includes VBA files.\n- **VBA unresolved refs carry syntactic shape** (v1.7+). `unresolved_refs.reference_kind` is no longer the literal string `\"references\"` \u2014 it reports what the syntactic shape actually was. Values: `call` (paren-form or statement-form call site), `qualified-call` (`obj.Foo(...)` with runtime receiver), `property-get` / `property-set` (`Me.Name`, `obj.Prop = value`), `bang-get` / `bang-set` (`Me!SubCtl`, `obj!Field = value`), `unqualified-ident` (bare identifier like `HayErrorEnRiesgo` in an `If` condition), `member-with` (`.Member` inside a `With` block), `dao-query` (`DoCmd.OpenQuery \"X\"` argument). The legacy value `references` is retained on any path the round did not reclassify, so older SQL filters that key on it keep working. To find real missing callees, filter `WHERE reference_kind IN ('call','qualified-call','unqualified-ident','member-with','bang-get')` \u2014 that set has <10% false positives (DAO-field accesses, form-property reads, and bang refs no longer pollute the bucket).\n- **Post-extraction stub resolver** (v1.7+). Edges with `metadata.synthesizedBy='vba-name-resolution'` start life pointing at a synthetic function node; the resolver at `src/resolution/index.ts:resolveVbaCallStubs` (invoked from `indexAll` and `sync`) walks them and repoints each `target` to the real `nodes.id` when one exists. Runtime-object calls (`DAO.*`, `fso.*`, `ListBox.*`, `Collection.*`, `err.*`, `VBA.*`, `Application.*`, `Screen.*`, `DoCmd.*`, `CurrentDb.*`, `Forms`, `Reports`, `Debug`, `Modules`, `References`, `CommandBars`, `SysCmd`, `CreateObject`, `GetObject`, `Fields`) are explicitly declined \u2014 they remain `stub:true` because they can never link to user code. Shadow user classes (e.g. a user class actually named `DAO` with an `Execute` method) are preserved and linked normally. Every stub edge carries `metadata.repointDecision` with one of `reponted-to-real`, `declined-runtime`, `declined-ambiguous`, `declined-not-found`, so consumers can tell apart a runtime-object decline from a genuinely-missing callee at the SQL layer.\n";
+export declare const SERVER_INSTRUCTIONS = "# Codegraph \u2014 code intelligence over an indexed knowledge graph\n\nCodegraph is a SQLite knowledge graph of every symbol, edge, and file in\nthe workspace \u2014 pre-computed structure you would otherwise re-derive by\nreading files (cached intelligence: thousands of parse/trace decisions you\ndon't pay to re-reason each run). Reads are sub-millisecond; the index lags\nwrites by ~1s through the file watcher. Reach for it BEFORE *and* while\nwriting or editing code \u2014 not just for questions: one call returns the\nverbatim source PLUS who calls it and what it affects, so you edit with the\nblast radius in view. More accurate context, in far fewer tokens and\nround-trips than reading files yourself.\n\n## One tool: codegraph_explore \u2014 use it instead of reading files\n\nThere is a single tool, `codegraph_explore`, and it is Read-equivalent. It\ntakes either a natural-language question or a bag of symbol/file names and\nreturns the **verbatim, line-numbered source** of the relevant symbols\ngrouped by file \u2014 the same `<n>\\t<line>` shape `Read` gives you, safe to\n`Edit` from \u2014 PLUS the call path among them (including dynamic-dispatch hops\nlike callbacks, React re-render, and JSX children that grep can't follow) and\na blast-radius summary of what depends on them.\n\nWhether you're answering \"how does X work\" or implementing a change (fixing a\nbug, adding a feature), call `codegraph_explore` before you Read. ONE call\nusually answers the whole question. Codegraph IS the pre-built search index \u2014\nso running your own grep + read loop, or delegating the lookup to a separate\nfile-reading sub-task/agent, repeats work codegraph already did and costs more\nfor the same answer. A direct codegraph answer is typically one to a few\ncalls; a grep/read exploration is dozens.\n\n## How to query\n\n- **Almost any question \u2014 \"how does X work\", architecture, a bug, \"what/where is X\", or surveying an area** \u2192 `codegraph_explore` with a natural-language question or the relevant names. ONE capped call returns the verbatim source grouped by file; most often the ONLY call you need.\n- **\"How does X reach/become Y? / the flow / the path from X to Y\"** \u2192 `codegraph_explore`, naming the symbols that span the flow (e.g. `mutateElement renderScene`) \u2014 it surfaces the call path among them, riding dynamic-dispatch hops, and returns their source.\n- **Reading or editing a file/symbol you can name** \u2192 put its name or file path in the `codegraph_explore` query \u2014 it returns that current line-numbered source (safe to `Edit` from) with the call path and blast radius attached, so you don't Read it separately. For an overloaded name it returns every matching definition's body in one call.\n- **Need more?** Call `codegraph_explore` again with more specific names \u2014 treat the source it returns as already Read.\n\n## Anti-patterns\n\n- **Trust codegraph's results \u2014 don't re-verify them with grep.** They come from a full AST parse; re-checking with grep is slower, less accurate, and wastes context.\n- **Don't grep or Read first** to find or understand indexed code \u2014 ONE `codegraph_explore` returns the relevant symbols' source together in a single round-trip. Reach for raw `Read`/`Grep` only to confirm a specific detail codegraph didn't cover, or for what codegraph doesn't index (configs, docs).\n- **Don't reconstruct a flow by hand** \u2014 name the endpoints in one `codegraph_explore` and it surfaces the path between them, dynamic-dispatch hops included.\n- **After editing, check the staleness banner.** When a tool response starts with \"\u26A0\uFE0F Some files referenced below were edited since the last index sync\u2026\", the listed files are pending re-index \u2014 Read those specific files for accurate content. Every file NOT in that banner is fresh, so still trust codegraph. A different, rarer banner \u2014 \"\u26A0\uFE0F CodeGraph auto-sync is DISABLED\u2026\" \u2014 means live watching stopped entirely (the whole index is frozen, not just a few files); until it's resolved, Read files directly to confirm anything that may have changed.\n\n## Limitations\n\n- If a tool reports a project isn't indexed (no `.codegraph/`), stop calling codegraph tools for that project for the rest of the session and use your built-in tools there instead. Indexing is the user's decision \u2014 mention they can run `codegraph init` if it comes up, but don't run it yourself.\n- Index lags file writes by ~1 second.\n- Cross-file resolution is best-effort name matching; ambiguous calls may return multiple candidates.\n- No live correctness validation \u2014 that's still the TypeScript compiler / test suite / linter's job. Codegraph supplements those with structural context they don't have.\n\n## Supported Languages\n\nThe indexer recognizes a fixed set of languages; if you ask about symbols in a\nfile with an unsupported extension, codegraph will report the project isn't\nindexed for that file and you should fall back to Read/Grep. The fork-specific\naddition beyond upstream codegraph is **VBA / Access** (Dysflow export\nformat):\n\n- **VBA / Access** - Dysflow exports Access/VBA source as `.bas`/`.cls`/\n  `.form.txt`/`.report.txt`. Codegraph extracts `.bas`/`.cls` as `module`/\n  `class`/`function` nodes with `calls`/`implements`/`references` edges\n  (procedural-level; regex-based, not full AST). Cross-module calls, qualified\n  `Dim As`, `WithEvents`, and SQL table references inside string literals\n  emit synthesized edges tagged `metadata.synthesizedBy` (`vba-name-resolution`,\n  `vba-withevents`, `vba-sql-table`). `.form.txt` and `.report.txt` are\n  extracted as a `module` plus one `property` per Access control - **no**\n  `function`/`sub`/`class` nodes come from form files; the canonical code\n  lives in the sibling `.cls`, parsed by the same extractor on that file.\n  Dysflow test manifests (`tests.*.json`) link each registered `Test_*`\n  procedure to its manifest with a `references` edge tagged\n  `vba-test-manifest` carrying the test name + tags, so `getCallers` of a\n  production symbol reaches its covering test atoms with the manifest and tags\n  to run.\n  Pass `projectPath` to a codegraph index that includes VBA files.\n- **VBA unresolved refs carry syntactic shape** (v1.7+). `unresolved_refs.reference_kind` is no longer the literal string `\"references\"` \u2014 it reports what the syntactic shape actually was. Values: `call` (paren-form or statement-form call site), `qualified-call` (`obj.Foo(...)` with runtime receiver), `property-get` / `property-set` (`Me.Name`, `obj.Prop = value`), `bang-get` / `bang-set` (`Me!SubCtl`, `obj!Field = value`), `unqualified-ident` (bare identifier like `HayErrorEnRiesgo` in an `If` condition), `member-with` (`.Member` inside a `With` block), `dao-query` (`DoCmd.OpenQuery \"X\"` argument). The legacy value `references` is retained on any path the round did not reclassify, so older SQL filters that key on it keep working. To find real missing callees, filter `WHERE reference_kind IN ('call','qualified-call','unqualified-ident','member-with','bang-get')` \u2014 that set has <10% false positives (DAO-field accesses, form-property reads, and bang refs no longer pollute the bucket).\n- **Post-extraction stub resolver** (v1.7+). Edges with `metadata.synthesizedBy='vba-name-resolution'` start life pointing at a synthetic function node; the resolver at `src/resolution/index.ts:resolveVbaCallStubs` (invoked from `indexAll` and `sync`) walks them and repoints each `target` to the real `nodes.id` when one exists. Runtime-object calls (`DAO.*`, `fso.*`, `ListBox.*`, `Collection.*`, `err.*`, `VBA.*`, `Application.*`, `Screen.*`, `DoCmd.*`, `CurrentDb.*`, `Forms`, `Reports`, `Debug`, `Modules`, `References`, `CommandBars`, `SysCmd`, `CreateObject`, `GetObject`, `Fields`) are explicitly declined \u2014 they remain `stub:true` because they can never link to user code. Shadow user classes (e.g. a user class actually named `DAO` with an `Execute` method) are preserved and linked normally. Every stub edge carries `metadata.repointDecision` with one of `reponted-to-real` (linked to a real `nodes.id`), `declined-runtime` (runtime object \u2014 never user code, filter OUT), `declined-ambiguous` (multiple real candidates \u2014 investigate), or `declined-not-found` (genuinely missing callee \u2014 this is the actionable signal). Consumers detecting \"missing callees\" MUST filter on `repointDecision='declined-not-found'`, NOT on the raw `stub=true` count \u2014 the raw count is dominated by runtime-object noise. See `docs/vba-stub-repoint-decision.md` for the full contract.\n";
 /**
  * Instructions variant sent when the server's own root has NO codegraph index.
  *

package/dist/upgrade/index.d.ts

@@ -116,6 +116,22 @@ export interface UpgradeDeps {
     warn: (msg: string) => void;
     error: (msg: string) => void;
     platform: NodeJS.Platform;
+    /**
+     * Override for the version read from the installed package.json. Used by
+     * the post-install verification: if npm reports success but the on-disk
+     * version differs from the target, the upgrade retries from the registry
+     * tarball URL. `null` simulates "could not read the file" (no retry, no
+     * warning); undefined falls back to actually reading the package.json.
+     * Tests set this to simulate the silent stale-install failure mode without
+     * touching the filesystem.
+     */
+    installedPackageVersion?: string | null;
+    /**
+     * Override for the orphan-staging sweep count. Tests use this to verify
+     * pre-cleanup runs (and is skipped for non-global methods). undefined
+     * triggers a real `readdir` + `rm` against the global node_modules tree.
+     */
+    orphanCleanupOverride?: () => number;
 }
 /** The honest, additive re-index reminder shown after a successful upgrade. */
 export declare function reindexAdvisory(): string;
@@ -147,6 +163,54 @@ export declare function npmInvocation(platform: NodeJS.Platform, npmArgs: string
     cmd: string;
     args: string[];
 };
+/**
+ * Resolve the npm global root for the current install. The upgrade module is
+ * always running from inside its own install — `<root>/node_modules/@scope/pkg/
+ * dist/upgrade/index.js` on both Windows and Unix — so we can derive the root
+ * by walking up `__filename` to the first `node_modules` ancestor and taking
+ * its parent. No need to shell out to `npm root -g` (which would consume a
+ * capture slot in tests and is platform-dependent).
+ *
+ * Returns null when not running from a `node_modules` tree (e.g. source
+ * checkout, npx cache, bundle). Callers treat null as "no globals to scan".
+ */
+export declare function resolveNpmGlobalRoot(_deps?: UpgradeDeps): string | null;
+/**
+ * Find npm orphan staging dirs in the global node_modules tree. An "orphan" is
+ * a directory matching `.codegraph-vba-<HASH>` or `.codegraph-vba-win32-<ARCH>`
+ * next to the live `@aroman22/codegraph-vba` install — npm creates these when
+ * it begins a global upgrade and the previous run was interrupted (EBUSY on
+ * node.exe, EPERM during cleanup, etc.). They block subsequent upgrades and
+ * can hold a partial copy of an older version that confuses `npm view`.
+ *
+ * Returns the list of absolute paths to remove. Pure so it's unit-tested with
+ * an injected fs.
+ */
+export declare function findOrphanStagings(globalRoot: string, exists?: (p: string) => boolean, readdir?: (p: string) => string[]): string[];
+/**
+ * Remove orphan npm staging dirs from the global node_modules tree. Best-effort
+ * — failures are logged but never fatal to the upgrade (a leftover orphan is
+ * annoying; blocking the upgrade over it is worse). Exposed for tests.
+ *
+ * Returns the count successfully removed.
+ */
+export declare function cleanupOrphanStagings(deps: UpgradeDeps, opts?: {
+    rm?: (p: string) => boolean;
+    exists?: (p: string) => boolean;
+    readdir?: (p: string) => string[];
+    globalRoot?: string | null;
+}): number;
+/**
+ * Read the installed package.json and return its `version` field, or null if
+ * the file can't be read or parsed. Used by the post-install verification to
+ * catch silent stale-install failure modes (npm reports success but the
+ * on-disk version is older than the target). Exposed for tests.
+ */
+export declare function readInstalledPackageVersion(deps: UpgradeDeps, opts?: {
+    readFile?: (p: string) => string;
+    exists?: (p: string) => boolean;
+    globalRoot?: string | null;
+}): string | null;
 /**
  * True if `cmd` resolves to an executable on PATH. A pure-Node PATH scan — NOT
  * a spawned `command -v`/`which`: `command` is a shell builtin (no standalone

package/package.json

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