@aroman22/codegraph-vba 1.11.0 → 1.13.0

package/README.md

@@ -574,6 +574,7 @@ codegraph-vba daemon                  # Manage background daemons — pick one t
 codegraph-vba telemetry [on|off]      # Show or change anonymous usage telemetry
 codegraph-vba upgrade [version]       # Update to the latest release (--check, --force)
 codegraph-vba version                 # Print the installed version (also -v, --version)
+codegraph-vba stats vba-rules [--json] # List every VBA extractor rule (concern, id, description, pattern, counts)
 codegraph-vba help [command]          # Show help, optionally for one command
 ```
 

package/dist/cli/stats-vba-rules.d.ts

@@ -0,0 +1,64 @@
+/**
+ * `codegraph stats vba-rules` — issue #168.
+ *
+ * Pure shape function over `VBA_RULE_TABLES` (the orchestrator's
+ * aggregated view of every per-concern classifier's declarative
+ * rule table, declared in `src/extraction/vba-extractor.ts`).
+ *
+ * The output reports **static rule counts** (the size of each
+ * classifier's `RULES` array), NOT per-rule runtime emission counts.
+ * The orchestrator does NOT track per-rule emission counts at the
+ * rule-table level today — the only instrumentation in the VBA
+ * pipeline is `vba-timing.ts` (per-stage wall-clock timings, gated
+ * by `CODEGRAPH_VBA_TIMING`) and the `VbaClassifier.count`
+ * per-classifier total. Neither attribute "rule X fired N times",
+ * so the field name `ruleCount` keeps the static-only semantics
+ * explicit. Anything resembling a runtime emission count would be
+ * fabricated — keep it that way until the orchestrator actually
+ * records it.
+ *
+ * Pattern serialization:
+ *  - single `RegExp` → its `.source` (a string)
+ *  - `RegExp[]` (alternatives) → `string[]` of `.source`, preserving
+ *    declaration order. Matches `defineRuleAlternatives` semantics:
+ *    a rule matches when ANY alternative matches, in array order.
+ *
+ * Concern order follows the insertion order of the `VBA_RULE_TABLES`
+ * object literal — the orchestrator exports it as `{ implements,
+ * procedures, declarations, dims, 'enums-consts', 'call-sweep' }`.
+ * The CLI command surfaces that exact order so the JSON output is
+ * stable run-to-run (no JSON-key sorting surprises) and matches the
+ * dispatch order the orchestrator documents in
+ * `src/extraction/vba-extractor.ts:REQUIRED_DISPATCH_TABLES`.
+ */
+/**
+ * One rule as serialized for `codegraph stats vba-rules`.
+ *
+ * `pattern` is intentionally a `string | string[]` (NOT a `RegExp`):
+ * `JSON.stringify` would reduce a `RegExp` to `{}`. Serializing the
+ * `.source` keeps the output copy-pasteable for debugging
+ * ("what does this rule actually match against?") without losing
+ * the structure that distinguishes single-RegExp rules from
+ * alternatives.
+ */
+export interface StatsVbaRule {
+    readonly id: string;
+    readonly description: string;
+    /** Single RegExp → its `.source`. RegExp[] → array of `.source`s in order. */
+    readonly pattern: string | string[];
+    /** Optional structural gate from the rule (e.g. `'class'`, `'module'`). */
+    readonly requires?: string;
+    /** Optional scan mode (e.g. `'masked'`, `'unmasked'`, `'both'`). */
+    readonly scan?: string;
+}
+export interface StatsVbaConcern {
+    readonly concern: string;
+    readonly ruleCount: number;
+    readonly rules: readonly StatsVbaRule[];
+}
+export interface StatsVbaRulesOutput {
+    readonly concerns: readonly StatsVbaConcern[];
+    readonly totalRules: number;
+}
+export declare function buildStatsVbaRules(): StatsVbaRulesOutput;
+//# sourceMappingURL=stats-vba-rules.d.ts.map

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/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

@@ -120,6 +120,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/rules.d.ts

@@ -60,8 +60,8 @@ import type { VbaExtractorContext } from './context';
  *  - `scan?`     `'masked'` = run on the string-literal-masked line
  *                (so call patterns inside `"..."` are ignored), the
  *                default. `'unmasked'` = run on the original line (so
- *                SQL patterns inside `"..."` are caught). `'both'` =
- *                dispatcher calls the rule twice, once with each line.
+ *                SQL patterns inside `"..."` are caught). `'both'` tries
+ *                the masked line first, then the original line if needed.
  *  - `emit`      The per-match side effect. Receives the
  *                `RegExpExecArray` from the pattern, the shared
  *                `VbaExtractorContext`, the original (or masked) line,
@@ -122,4 +122,8 @@ export declare function defineRuleAlternatives<T = unknown>(spec: Omit<VbaExtrac
  * each classifier re-implementing the same boilerplate.
  */
 export declare function matchRule(pattern: RegExp | RegExp[], line: string): RegExpMatchArray | null;
+export declare function matchRuleForScan(rule: VbaExtractionRule, line: string, maskedLine: string): {
+    match: RegExpMatchArray;
+    line: string;
+} | null;
 //# sourceMappingURL=rules.d.ts.map

package/dist/extraction/vba/text-utils.d.ts

@@ -23,6 +23,7 @@ export declare function maskStringContent(line: string): string;
 export declare function escapeRegExpLiteral(value: string): string;
 export declare function parseConstDeclarations(body: string): Array<{
     name: string;
+    asType: string;
     value: string | null;
 }>;
 export declare function splitOutsideVbaStrings(value: string, separator: string): string[];

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

@@ -37,4 +37,7 @@ 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;
 //# 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)
@@ -190,12 +190,13 @@ export interface ExtractionError {
  *   - `dao-query`        `DoCmd.OpenQuery "X"` argument
  * `dao-field-get` / `dao-field-set` are deliberately deferred to round-4.
  */
-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.11.0",
+  "version": "1.13.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.11.0",
-    "@aroman22/codegraph-vba-darwin-x64": "1.11.0",
-    "@aroman22/codegraph-vba-linux-arm64": "1.11.0",
-    "@aroman22/codegraph-vba-linux-x64": "1.11.0",
-    "@aroman22/codegraph-vba-win32-arm64": "1.11.0",
-    "@aroman22/codegraph-vba-win32-x64": "1.11.0"
+    "@aroman22/codegraph-vba-darwin-arm64": "1.13.0",
+    "@aroman22/codegraph-vba-darwin-x64": "1.13.0",
+    "@aroman22/codegraph-vba-linux-arm64": "1.13.0",
+    "@aroman22/codegraph-vba-linux-x64": "1.13.0",
+    "@aroman22/codegraph-vba-win32-arm64": "1.13.0",
+    "@aroman22/codegraph-vba-win32-x64": "1.13.0"
   },
   "files": [
     "npm-shim.js",