@aroman22/codegraph-vba 1.12.0 → 1.14.0

package/dist/db/queries.d.ts

@@ -534,8 +534,9 @@ export declare class QueryBuilder {
         referenceKind: string;
     }>): void;
     /**
-     * Mark refs a completed resolution pass could not resolve as status='failed'
-     * instead of deleting them (#1240). Failed rows are invisible to the pending
+     * Park refs a completed resolution pass could not resolve as `failed`, or
+     * as `declined-runtime` when the resolver recognizes built-in runtime noise.
+     * Parked rows are invisible to the pending
      * count/batch readers (so drain loops and the #1187 orphan sweep still
      * terminate) but stay queryable by name_tail so a later sync can retry them
      * when a changed file introduces a symbol that could satisfy them. name_tail
@@ -546,6 +547,7 @@ export declare class QueryBuilder {
         fromNodeId: string;
         referenceName: string;
         referenceKind: string;
+        status?: 'failed' | 'declined-runtime';
     }>): void;
     /**
      * Failed refs whose name tail matches one of the given symbol names — the

package/dist/extraction/extraction-version.d.ts

@@ -21,5 +21,5 @@
  * turns the re-index hint into noise — keep it honest (see CLAUDE.md, "Honesty
  * in the product is load-bearing").
  */
-export declare const EXTRACTION_VERSION = 24;
+export declare const EXTRACTION_VERSION = 25;
 //# sourceMappingURL=extraction-version.d.ts.map

package/dist/extraction/vba/constants.d.ts

@@ -25,6 +25,12 @@ export declare const PROCEDURE_END_RE: RegExp;
 export declare const PRIMITIVE_TYPES: Set<string>;
 /** Keywords we never want to match as call receivers. */
 export declare const CALL_KEYWORD_BLACKLIST: Set<string>;
+/**
+ * VBA reserved words that cannot name an unqualified user-code target.
+ * Stored lowercase so source casing cannot change classification.
+ */
+export declare const VBA_KEYWORDS: Set<string>;
+export declare function isVbaKeyword(name: string): boolean;
 /**
  * Access runtime objects and singletons. Calls on these receivers are
  * real VBA calls but the targets are NOT user-defined modules or

package/dist/extraction/vba/context.d.ts

@@ -18,6 +18,20 @@ export interface ProcInfo {
     kind: 'sub' | 'function' | 'property';
     visibility: 'public' | 'private' | 'protected' | 'internal';
     startLine: number;
+    /**
+     * Issue #190: lowercase parameter names declared as arrays on this
+     * procedure's signature (e.g. `ByRef logs() As String` or
+     * `ByVal p_Logs() As Long`). Used by the call-site scan to suppress
+     * `name(index)` accesses INSIDE this procedure body — the receiver
+     * is a known array bound at the parameter boundary, not an
+     * unresolved function call.
+     *
+     * Scoped to this procedure on purpose: a `logs` parameter on one Sub
+     * does NOT make `logs` an array inside another Sub, and a module-level
+     * `Dim logs As String` (not an array) must not be polluted by a
+     * different procedure's `ByRef logs()` declaration.
+     */
+    arrayParameters?: string[];
 }
 /**
  * Issue #83: the per-concern classifier shape. The single walker in
@@ -120,6 +134,7 @@ export declare class VbaExtractorContext {
         withEvents?: boolean;
         variableName?: string;
         assignedWithSet?: boolean;
+        isArray?: boolean;
     }>;
     /**
      * Issue #52: Const resolution buckets, scoped per procedure. Key is

package/dist/extraction/vba/procedures.d.ts

@@ -16,13 +16,6 @@ import { VbaExtractionRule } from './rules';
  * `match` is one emit.
  */
 export declare const RULES: readonly VbaExtractionRule<unknown>[];
-/**
- * Issue #83: factory for the procedures classifier. Closure state: none
- * beyond `count` (the per-concern accumulators live on `ctx`).
- *
- * The body walks the declarative `RULES` table (Issue #153). The
- * inline cascade that used to live here is now one entry in `RULES`.
- */
 export declare function createProceduresClassifier(): VbaClassifier;
 /**
  * Backward-compat wrapper: pre-#83 callers (e.g. legacy test fixtures)

package/dist/index.d.ts

@@ -255,6 +255,16 @@ export declare class CodeGraph {
      * hint and `codegraph upgrade`'s reminder.
      */
     isIndexStale(): boolean;
+    /**
+     * Structured list of reasons the on-disk index should be rebuilt. Each entry
+     * is a stable token CI scripts can switch on without parsing the prose
+     * warning. Currently emits `'extraction-version'` when the on-disk
+     * `indexed_with_extraction_version` stamp is older than the running engine's
+     * `EXTRACTION_VERSION`. Empty when there is no index yet or the stamp is
+     * current. Future reasons (e.g. resolver-version drift) append to the same
+     * list — never replace it.
+     */
+    getReindexReasons(): string[];
     /**
      * Extract nodes and edges from source code (without storing)
      */

package/dist/resolution/vba-runtime-objects.d.ts

@@ -37,4 +37,86 @@ export declare const RUNTIME_OBJECTS: ReadonlySet<string>;
  * defensively so a bracketed receiver (`[DAO]`) still matches.
  */
 export declare function isRuntimeObject(receiver: string | null | undefined): boolean;
+/** Canonical VBA and Access built-in functions that never resolve to project code. */
+export declare const VBA_STDLIB_FUNCTIONS: ReadonlySet<string>;
+export declare function isVbaStdlibFunction(name: string | null | undefined): boolean;
+/**
+ * Issue #188 — VBA intrinsic constants and DAO enum values reach
+ * `unresolved_refs` as `reference_kind='unqualified-ident'` and used to leak
+ * as `failed`. They are bare identifiers (NOT calls), so unlike the stdlib
+ * set they need NO `metadata.synthesizedBy` gate — name membership alone is
+ * the discriminator. The same case-insensitive / lowercased-compare
+ * convention as the stdlib set applies. A user-defined
+ * `Public Const dbFailOnError = 0` or `Public Function vbCrLf() As String`
+ * shadow resolves normally first and never reaches the classifier, so the
+ * name-only gate does not weaken user-symbol resolution.
+ *
+ * The bench corpus flagged ~104 confirmed rows (DAO enum literals in
+ * `Execute` / `OpenArgs` / recordset options; `vbCrLf` / `vbLf` / `vbTab`
+ * in `Debug.Print`; the full `vbMsgBoxStyle` + `vbMsgBoxHelpButton` +
+ * `vbApplicationModal` / `vbSystemModal` matrix in `MsgBox` calls).
+ */
+export declare const DAO_ENUM_VALUES: ReadonlySet<string>;
+export declare function isDaoEnumValue(name: string | null | undefined): boolean;
+/**
+ * Issue #188 — VBA intrinsic constants. Lowercased so matching is
+ * case-insensitive. Covers the constants listed in the issue's explicit SQL
+ * set plus the rest of the `vbMsgBoxStyle` family and the
+ * `vbApplicationModal` / `vbSystemModal` modal flags.
+ */
+export declare const VBA_INTRINSIC_CONSTANTS: ReadonlySet<string>;
+export declare function isVbaIntrinsicConstant(name: string | null | undefined): boolean;
+/**
+ * Issue #192 — central decision: should this unresolved reference be parked
+ * as `declined-runtime` instead of `failed`?
+ *
+ * VBA stdlib calls reach `unresolved_refs` under three shapes:
+ *
+ *   1. **paren-form call** — `MsgBox("hi")` is emitted by the call-site sweep
+ *      as `reference_kind='calls'` with `metadata.synthesizedBy` either
+ *      absent or set to `vba-paren-call-unresolved` (the post-sweep
+ *      unifier). The classic PR #185 / issue #181 path.
+ *
+ *   2. **statement-form call** — `MsgBox "hi"`, `DoEvents`, `Shell "calc"`
+ *      are emitted by the statement-call sweep as
+ *      `reference_kind='unqualified-ident'` with
+ *      `metadata.synthesizedBy='vba-statement-call-unresolved'`. Without
+ *      this classifier, those 49+ rows from the bench corpus (MsgBox=44,
+ *      DoEvents=4, Shell=1) leak as `failed`, polluting actionable
+ *      failed-reference reports.
+ *
+ *   3. **NOT a call at all** — a bare `Public Const SomePublicConst = 1`
+ *      read inside a procedure (e.g. `SomePublicConst` on its own line,
+ *      same shape the const-first disambiguation rule checks) ALSO reaches
+ *      `unresolved_refs` as `reference_kind='unqualified-ident'`. The
+ *      resolver first attempts normal `matchFunctionRef` / matchConstRef
+ *      resolution; for genuine misses this row will be deleted from
+ *      unresolved_refs. When a Const cannot be resolved but still produces
+ *      a row, classifying its status purely by name is wrong — a
+ *      user-defined `Public Sub ProjectHelper s` and a public Const that
+ *      elude resolution must NOT be marked `declined-runtime`.
+ *
+ * Issue #188 extends the contract with two new name-only branches for
+ * bare DAO enum values and VBA intrinsic constants — these are emitted as
+ * `reference_kind='unqualified-ident'` WITHOUT a `synthesizedBy` flag
+ * because they are identifiers, not calls. Name membership alone is the
+ * discriminator; the metadata gate does NOT apply. Normal user-symbol
+ * resolution runs first, so a user-defined `Public Const dbFailOnError`
+ * or `Public Function vbCrLf` shadow never reaches this classifier.
+ *
+ * The stdlib branch keeps its original tight gate: name match AND one of
+ * the two real call shapes (paren-form `calls`, or statement-form
+ * `unqualified-ident` stamped with `vba-statement-call-unresolved`).
+ * Name-only matching for the stdlib set is still intentionally rejected —
+ * a row like `MsgBox` on its own line without the statement-call stamp is
+ * a user-defined reference, not a runtime call.
+ */
+export declare function classifyVbaReferenceAsRuntime(ref: {
+    language?: string | null;
+    referenceKind?: string | null;
+    referenceName?: string | null;
+    metadata?: {
+        synthesizedBy?: unknown;
+    } | null;
+}): boolean;
 //# sourceMappingURL=vba-runtime-objects.d.ts.map

package/dist/types.d.ts

@@ -175,7 +175,7 @@ export interface ExtractionError {
  * layer. The legacy `EdgeKind` literal `'references'` is preserved as
  * `references` here via `EdgeKind` — back-compat for any push site this
  * round does not reclassify (e.g. the Implements emitter). New literals:
- *   - `call`             paren-form `Name(...)` or statement-form Sub call
+ *   - `calls`            paren-form `Name(...)` or statement-form Sub call
  *   - `qualified-call`   `Receiver.Member(...)` (qualified-paren) or
  *                        `Receiver.Member args` (qualified-statement)
  *   - `property-get`     `Me.Name` (dot access, read)
@@ -189,13 +189,16 @@ export interface ExtractionError {
  *   - `member-with`      `.Member` inside a `With <receiver>` block
  *   - `dao-query`        `DoCmd.OpenQuery "X"` argument
  * `dao-field-get` / `dao-field-set` are deliberately deferred to round-4.
+ *
+ * See `docs/vba-reference-kinds.md` for the full taxonomy, noise ratios, and consumer-side SQL queries.
  */
-export type ReferenceKind = EdgeKind | 'function_ref' | 'call' | 'qualified-call' | 'property-get' | 'property-set' | 'bang-get' | 'bang-set' | 'unqualified-ident' | 'member-with' | 'dao-query';
+/** `calls` is the canonical kind for unresolved procedure and function calls. */
+export type ReferenceKind = EdgeKind | 'function_ref' | 'qualified-call' | 'property-get' | 'property-set' | 'bang-get' | 'bang-set' | 'unqualified-ident' | 'member-with' | 'dao-query';
 /**
  * Runtime guard for whether a `ReferenceKind` literal is also an `EdgeKind`
  * literal (i.e. the value flows from an unresolved-ref row straight onto the
  * kind column of a resolved edge without remapping). Round-3 (issue #108)
- * introduced shape-based classifier literals (`call`, `qualified-call`,
+ * introduced shape-based classifier literals (`qualified-call`,
  * `property-get`, …) that are valid as a `ReferenceKind` but are NOT valid
  * edge kinds — edges still use the `calls`/`references` family of literals.
  * The resolver uses this guard to fall back to `'references'` for the edge

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aroman22/codegraph-vba",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "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.12.0",
-    "@aroman22/codegraph-vba-darwin-x64": "1.12.0",
-    "@aroman22/codegraph-vba-linux-arm64": "1.12.0",
-    "@aroman22/codegraph-vba-linux-x64": "1.12.0",
-    "@aroman22/codegraph-vba-win32-arm64": "1.12.0",
-    "@aroman22/codegraph-vba-win32-x64": "1.12.0"
+    "@aroman22/codegraph-vba-darwin-arm64": "1.14.0",
+    "@aroman22/codegraph-vba-darwin-x64": "1.14.0",
+    "@aroman22/codegraph-vba-linux-arm64": "1.14.0",
+    "@aroman22/codegraph-vba-linux-x64": "1.14.0",
+    "@aroman22/codegraph-vba-win32-arm64": "1.14.0",
+    "@aroman22/codegraph-vba-win32-x64": "1.14.0"
   },
   "files": [
     "npm-shim.js",