@aroman22/codegraph-vba 1.3.3 → 1.3.5

package/README.md

@@ -386,13 +386,31 @@ The two are **sibling tools**: Dysflow owns the Access binary round-trip (sync,
 | **`Implements IFoo`** | `.cls` declares `Implements IFoo` | — | Emits an `implements` edge from the class to `IFoo` |
 | **`Dim x As Foo.Bar`** | `.bas`/`.cls` qualified type reference | — | `references` edge to `Foo` with `synthesizedBy: 'vba-name-resolution'`; silent when unresolvable |
 | **`WithEvents m_X As Form_Foo`** | `.cls` listener declaration | — | `references` edge to `Form_Foo` with `synthesizedBy: 'vba-withevents'` — closes the event-driven form flow |
+| **`Event Foo(...)` / `RaiseEvent Foo(...)`** | `.cls` custom event declaration + raise site | — | `event` node plus `raises-event` edges from the raising procedure; `WithEvents` also emits `subscribes-event` edges with the listener variable name |
+| **`Type T ... End Type`** | `.bas`/`.cls` user-defined type declaration | — | `type` node plus `type_member` child nodes linked by `type-member` edges and member type metadata |
+| **`Declare PtrSafe Function X Lib "dll"`** | `.bas`/`.cls` Win32/API declaration | — | `declare` node with DLL, alias, kind, and PtrSafe metadata; VBA call sites still emit `calls` edges to it |
+| **`Enum` / `Const` domain dictionaries** | `.bas`/`.cls` enum blocks and module constants | — | `enum`, `enum_member`, and `constant` nodes linked to their module/class; constant string values are preserved in metadata for local resolution |
+| **Saved Access QueryDefs** | `queries/<Name>.sql` | — | `query` node per Dysflow-exported `.sql` file with `references` edges to tables named by `FROM` / `JOIN` / `INTO` / `UPDATE` |
 | **`New Clase(...)`** | `.bas`/`.cls` instantiation | — | `references` edge with `synthesizedBy: 'vba-new-binding'` |
 | **SQL in VBA strings** | `.bas`/`.cls` SQL inside `DoCmd.RunSQL` / `CurrentDb.OpenRecordset` / `CurrentDb.Execute` / `db.Execute` | — | Table names extracted from `FROM`/`INTO`/`UPDATE <table>` → `references` edges with `synthesizedBy: 'vba-sql-table'` |
 
 **Hard invariants** enforced by the extractor and verified by tests:
 
 - **`.cls` is the canonical source for form code.** `.form.txt` emits **zero** `function` / `sub` / `class` nodes — only the form-level `module` node and `property` nodes per control. Dysflow overwrites `.form.txt`'s embedded code on the next import, so emitting code from there would be both wrong and ephemeral.
-- **A `.bas` with only `Public Const` declarations** (no Subs, Functions, Properties, Implements, or Dim) emits the `file` node only — no `module` / `class` per REQ-CODE-10.
+- **Option-only files stay silent.** A `.bas` containing only `Option ...` directives emits zero symbol nodes; a `.bas` with only `Enum`, `Const`, `Event`, `Type`, or `Declare` declarations DOES emit its module node because those declarations are real graph symbols.
+
+**VBA / Access node kinds added by the fork:**
+
+| Node kind | Meaning |
+|---|---|
+| `enum` / `enum_member` | VBA `Enum` block and its members |
+| `constant` | VBA `Const` declaration; string values are kept in metadata when available |
+| `query` | Dysflow-exported saved Access query (`queries/<Name>.sql`) |
+| `event` | VBA custom `Event` declaration |
+| `type` / `type_member` | VBA user-defined `Type ... End Type` and each declared member |
+| `declare` | Win32/API `Declare` / `Declare PtrSafe` statement |
+| `form-layout` | `.form.txt` / `.report.txt` form/report container |
+| `form-instance-control` | Access control instance from form/report UI text |
 
 **Scope:** Dysflow-managed projects only (Dysflow's `.form.txt` / `.report.txt` SaveAsText format). Legacy `.frm` / `.dsr` Access binary formats are not in scope.
 

package/dist/bin/node-version-check.d.ts

@@ -18,13 +18,16 @@
  */
 export declare function buildNode25BlockBanner(nodeVersion: string): string;
 /**
- * Lowest supported Node.js major version. Matches the `engines` floor in
- * package.json. Below this, CodeGraph relies on language features / native APIs
- * that aren't present, and the combination is untested. `engines` alone only
- * *warns* on install (unless the user set `engine-strict`), so the CLI bootstrap
- * also hard-blocks here to actually enforce the floor.
+ * Lowest supported Node.js version. Matches the `engines` floor in package.json.
+ * Node.js 22.5.0 is the first version with the built-in `node:sqlite` API used
+ * by CodeGraph. `engines` alone only *warns* on install (unless the user set
+ * `engine-strict`), so the CLI bootstrap also hard-blocks here to actually
+ * enforce the floor.
  */
-export declare const MIN_NODE_MAJOR = 20;
+export declare const MIN_NODE_MAJOR = 22;
+export declare const MIN_NODE_MINOR = 5;
+export declare const MIN_NODE_VERSION = "22.5";
+export declare function isBelowMinimumNodeVersion(nodeVersion: string): boolean;
 /**
  * Build the bordered banner shown when CodeGraph detects a Node.js major below
  * {@link MIN_NODE_MAJOR}. Pinned via unit test so the recovery commands and the

package/dist/db/migrations.d.ts

@@ -7,7 +7,7 @@ import { SqliteDatabase } from './sqlite-adapter';
 /**
  * Current schema version
  */
-export declare const CURRENT_SCHEMA_VERSION = 5;
+export declare const CURRENT_SCHEMA_VERSION = 6;
 /**
  * Migration definition
  */

package/dist/db/queries.d.ts

@@ -240,6 +240,39 @@ export declare class QueryBuilder {
      * Get incoming edges to a node
      */
     getIncomingEdges(targetId: string, kinds?: EdgeKind[]): Edge[];
+    /**
+     * Find VBA call-stub candidate nodes for `resolveVbaCallStubs` (vba-graph-
+     * connectivity-fixes, #12).
+     *
+     * A VBA call-stub node is, BY DEFINITION, a node targeted by a `calls`
+     * edge whose OWN metadata carries `stub: true`. Keep this anchored on
+     * `edges.metadata` even though `nodes.metadata` now exists: the stub flag
+     * is a relationship fact about an unresolved call, not an intrinsic fact
+     * about the target symbol.
+     */
+    getVbaCallStubs(): Node[];
+    /**
+     * Repoint an edge's `target` + `metadata` in place, leaving all other
+     * columns (source, kind, line, col, provenance) untouched. Used by
+     * `resolveVbaCallStubs` to redirect a stub `calls` edge to its resolved
+     * real node (#12). `metadataJson` is the caller's already-serialized JSON
+     * text (or null to clear it) — mirrors `insertEdge`'s convention of
+     * storing edge metadata as TEXT.
+     */
+    repointEdgeTarget(edgeId: number, newTargetId: string, metadataJson: string | null): void;
+    /**
+     * Delete a single edge row by its AUTOINCREMENT id. Used by
+     * `resolveVbaCallStubs` to collapse a duplicate `(source,target,kind)`
+     * edge onto an already-repointed one (F1) instead of leaving two
+     * identical rows.
+     */
+    deleteEdgeById(id: number): void;
+    /**
+     * True iff a `(source, target, kind)` edge row already exists. Used by
+     * `resolveVbaCallStubs` to detect a would-be duplicate before repointing
+     * a second stub edge onto the same real target (F1 duplicate-collapse).
+     */
+    edgeExists(source: string, target: string, kind: EdgeKind): boolean;
     /**
      * Find all edges where both source and target are in the given node set.
      * Useful for recovering inter-node connectivity after BFS.

package/dist/extraction/vba-extractor.d.ts

@@ -64,6 +64,24 @@ export declare class VbaExtractor {
      * cross-module calls.
      */
     private sweepProcedures;
+    /** `[visibility] Event <Name>(...)` custom event declaration. */
+    private static readonly EVENT_DECL_RE;
+    /** `[visibility] Type <Name>` user-defined type block start. */
+    private static readonly TYPE_START_RE;
+    /** `End Type` user-defined type block end. */
+    private static readonly TYPE_END_RE;
+    /** `<MemberName> As <Type>` inside a user-defined type block. */
+    private static readonly TYPE_MEMBER_RE;
+    /** `[visibility] Declare [PtrSafe] Sub|Function <Name> Lib "dll" [Alias "x"] ...` */
+    private static readonly DLL_DECLARE_RE;
+    /**
+     * Roadmap #26 declaration sweep:
+     * - Event declarations become `event` nodes and `RaiseEvent` can point to them.
+     * - Type...End Type blocks become `type` + `type_member` nodes.
+     * - Win32 API Declare statements become `declare` nodes, while still being
+     *   cached by name so normal call-site scanning can emit `calls` edges.
+     */
+    private sweepEventsTypesAndDeclares;
     /** Implements regex. */
     private static readonly IMPLEMENTS_RE;
     /** Edges whose source needs to be set to the module/class id once it exists. */
@@ -112,13 +130,6 @@ export declare class VbaExtractor {
     private static readonly ENUM_MEMBER_RE;
     /** `[visibility] Const <decls>` — captures visibility (1) and the rest (2). */
     private static readonly CONST_DECL_RE;
-    /**
-     * One declared name inside a `Const` body. A name sits at a declaration
-     * boundary (start-of-body or after a comma), optionally followed by
-     * `As <Type>`, then `=`. Run with /g over the CONST_DECL_RE group 2 so
-     * multi-name lines (`Const A = 1, B = 2`) emit one node per name.
-     */
-    private static readonly CONST_NAME_RE;
     /**
      * Fold a VBA visibility keyword to the canonical lowercase enum, matching
      * the procedure convention: `Private` → 'private'; `Public`, `Global`,
@@ -164,16 +175,15 @@ export declare class VbaExtractor {
     /**
      * `DoCmd.OpenForm "<FormName>"` modelling regex — B4 (hueco 6).
      *
-     * Real VBA idiom (matches both forms):
+     * Real VBA idiom (matches literal and bare-identifier forms):
      *   `DoCmd.OpenForm "MyForm"`
+     *   `DoCmd.OpenForm FORM_MY_FORM`
      *   `DoCmd.OpenForm "MyForm", acNormal, , , acFormEdit`
      *
-     * Captures the form NAME (group 1) so the extractor can synthesize an
-     * `opens-form` heuristic edge from the calling Sub to a stub for the
-     * target form. The trailing positional args (`acNormal`, `acFormEdit`,
-     * etc.) are intentionally NOT captured — the orchestrator's scope decision
-     * was to cover ONLY `OpenForm` for this commit; `OpenReport`, `OpenQuery`,
-     * `OpenTable`, … are flagged in the commit body as follow-up work.
+     * Captures the first argument (group 1). String literals are unwrapped;
+     * bare identifiers resolve against local Const declarations, falling back
+     * to the identifier name when unknown. The trailing positional args
+     * (`acNormal`, `acFormEdit`, etc.) are intentionally NOT captured.
      *
      * Why a separate dispatch: `DoCmd` is in `RUNTIME_RECEIVER_BLACKLIST`
      * (R4 invariant), so `DoCmd.OpenForm` is intentionally SKIPPED by the
@@ -182,7 +192,7 @@ export declare class VbaExtractor {
      * matches BEFORE the call-site scan and uses its own dispatch to emit
      * the `opens-form` edge instead — sharing no logic with CALL_RE.
      */
-    private static readonly OPEN_FORM_RE;
+    private static readonly OPEN_FORM_ARG_RE;
     /** SQL assigned to a local variable, e.g. `m_SQL = "SELECT ..." & ...`. */
     private static readonly SQL_VAR_ASSIGN_RE;
     /** SQL wrapper called with a variable, e.g. `getdb().Execute m_SQL`. */
@@ -245,7 +255,22 @@ export declare class VbaExtractor {
      * return false so runtime/DAO calls are suppressed.
      */
     private isLocalProjectClassVar;
+    /**
+     * #12a: resolve the "receiver type" used to build a qualified call-stub's
+     * name/qualifiedName. When `receiverName` is a file-local variable typed
+     * as a candidate project class (`isLocalProjectClassVar`), returns the
+     * RESOLVED CLASS NAME from `localVarTypeMap` (e.g. `m_NCOp` typed
+     * `As NCOperaciones` → `'NCOperaciones'`) so the stub's qualifiedName
+     * matches the real `.cls` method's `${className}.${proc}` shape and the
+     * post-extraction resolver (#12b) can find it via an exact qualifiedName
+     * match. Otherwise returns `receiverName` unchanged — this is the case
+     * for `.bas`-qualified module calls (`modUtils.Foo`), where the receiver
+     * IS already the target module's name and no resolution is needed.
+     */
+    private resolveReceiverType;
     private sweepCallsAndSql;
+    private static readonly RAISE_EVENT_RE;
+    private scanRaiseEvents;
     private scanCallSites;
     /** Cache so we don't re-emit the same proc function node per call site. */
     private procNodeIdCache;
@@ -348,11 +373,9 @@ export declare class VbaExtractor {
      * flagged this as acceptable for B4 — only `OpenForm` is in scope.
      * `OpenReport`, `OpenQuery`, `OpenTable`, … are follow-up work.
      *
-     * Scope note: this regex matches ONLY the literal-string form
-     * `DoCmd.OpenForm "X"`. Variable-form calls like
-     * `DoCmd.OpenForm m_FormName` are intentionally NOT captured here
-     * because resolving the variable to a concrete form name would
-     * require data-flow analysis that is out of scope.
+     * Scope note: this regex matches literal-string and bare-identifier forms.
+     * Bare identifiers are resolved only through local `Const` declarations;
+     * arbitrary variable data-flow remains intentionally out of scope.
      */
     private scanOpenFormCalls;
     /**
@@ -374,6 +397,19 @@ export declare class VbaExtractor {
      */
     private emitOpensFormEdge;
     private scanSqlInLine;
+    /**
+     * #13 fix: `sql = sql & "..."` (self-referential concatenation) must
+     * ACCUMULATE the new fragment onto whatever was already tracked for
+     * `varName`, not overwrite it. Overwriting silently dropped earlier
+     * fragments' tables — typically the initial `FROM <table>` in
+     * `sql = "SELECT * FROM tblA"` followed by `sql = sql & " WHERE x=1"`.
+     *
+     * Detection: the RHS (`m[2]`, trimmed) starts with `<varName> &`,
+     * case-insensitively — matching VBA's case-insensitive identifiers (`Sql`
+     * and `sql` are the same variable). A genuine fresh assignment (RHS does
+     * NOT start with the self-reference) still RESETS tracking — that
+     * behavior is unchanged.
+     */
     private trackSqlVariableAssignment;
     private collectStringLiteralText;
     private emitSqlTableReferences;
@@ -390,5 +426,9 @@ export declare class VbaExtractor {
      * typed as a SIMPLE (non-qualified, non-primitive) identifier emit edges.
      */
     private localVarTypeMap;
+    /** Local constant name (lowercase) → simple literal value for OpenForm resolution. */
+    private localConstants;
+    /** Local event name (lowercase) → event node for `RaiseEvent` edge emission. */
+    private localEvents;
 }
 //# sourceMappingURL=vba-extractor.d.ts.map

package/dist/extraction/vba-preprocess.d.ts

@@ -16,7 +16,11 @@
  *      Both are STRIPPED only when outside double-quoted strings. We walk
  *      character-by-character so a `'` inside `"..."` is preserved.
  *
- *   3. extractStringLiterals(src)
+ *   3. preprocessConditionalCompilation(src)
+ *      Blanks inactive VBA conditional-compilation branches (`#If`, `#ElseIf`,
+ *      `#Else`, `#End If`) while preserving line count.
+ *
+ *   4. extractStringLiterals(src)
  *      Used by SQL-variable tracking to read literal fragments from assignments
  *      such as `m_SQL = "SELECT ..." & ...`. It returns every `"..."` span
  *      with its 1-based line and 0-based column. VBA doubles `"` inside literals
@@ -62,6 +66,18 @@ export declare function joinLineContinuations(src: string): string;
  * Source is treated as read-only.
  */
 export declare function stripVbaComments(src: string): string;
+/**
+ * Evaluate VBA conditional-compilation directives for the modern Windows
+ * Access/VBA target this extractor is designed around:
+ *   - VBA7 = true
+ *   - Win64 = true
+ *   - Mac = false
+ *
+ * Directives and inactive branch lines are replaced with empty strings so
+ * downstream extraction keeps source-line parity. Unsupported/unsafe
+ * expressions evaluate to false rather than throwing.
+ */
+export declare function preprocessConditionalCompilation(src: string): string;
 export interface StringLiteralSpan {
     /** The literal content (no surrounding quotes; `""` collapsed to `"`). */
     text: string;

package/dist/resolution/index.d.ts

@@ -173,6 +173,44 @@ export declare class ReferenceResolver {
      * of newly-created edges.
      */
     resolveDeferredThisMemberRefs(): number;
+    /**
+     * VBA #12b — post-extraction resolver pass (vba-graph-connectivity-fixes,
+     * issue #12). Repoints qualified call-stub `calls` edges (tagged
+     * `metadata.stub === true` by the extractor's #12a stub-tagging) to their
+     * REAL cross-file target node when uniquely resolvable:
+     *  - **Class-typed**: exact `qualifiedName` match. #12a already renamed
+     *    the stub's name/qualifiedName to `${resolvedClassType}.${member}`
+     *    (via `localVarTypeMap`), matching a real `.cls` method's own
+     *    `${className}.${proc}` qualifiedName shape exactly.
+     *  - **`.bas`-qualified fallback**: when the exact match finds nothing
+     *    (the common case for `modUtils.Foo` — real `.bas` function
+     *    qualifiedNames are bare, no module prefix), narrow bare-member
+     *    candidates in `.bas` files to the ones whose containing module's
+     *    identity equals the stub's receiver text (case-insensitive).
+     * Zero or ambiguous (2+) candidates at either step DECLINE — the stub
+     * (and its edges, whose `metadata.stub` stays `true`) is left untouched;
+     * never a crash.
+     *
+     * Duplicate `(source,target,'calls')` rows — e.g. two call sites in one
+     * Sub targeting the same real method — are collapsed to ONE surviving
+     * edge (F1): `edges` has an AUTOINCREMENT PK and no unique constraint, so
+     * blindly repointing every incoming edge would leave duplicate rows that
+     * make `codegraph_node`/explore double-count the caller.
+     *
+     * Invoked at the `resolveChainedCallsViaConformance()` lifecycle slot in
+     * both `indexAll()` and `sync()` (src/index.ts). Idempotent: a stub that
+     * was already resolved in a prior pass no longer exists (its node was
+     * deleted), so `getVbaCallStubs()` won't return it again; re-running with
+     * no new stubs is a no-op.
+     */
+    resolveVbaCallStubs(): number;
+    /**
+     * Resolve a single VBA call-stub node to its real target, or `null` when
+     * unresolvable/ambiguous. See `resolveVbaCallStubs` for the two-step
+     * strategy (exact qualifiedName match, then `.bas` module-scoped
+     * fallback).
+     */
+    private resolveVbaCallStubTarget;
     private gateLanguage;
     /**
      * Drop a FRAMEWORK-strategy resolution that crosses two *known* language

package/dist/types.d.ts

@@ -10,12 +10,12 @@
  * of truth backs both the TS type and any runtime validation
  * (e.g. the search query parser).
  */
-export declare const NODE_KINDS: readonly ["file", "module", "class", "struct", "interface", "trait", "protocol", "function", "method", "property", "field", "variable", "constant", "enum", "enum_member", "type_alias", "namespace", "parameter", "import", "export", "route", "component", "query", "form-layout", "form-instance-control"];
+export declare const NODE_KINDS: readonly ["file", "module", "class", "struct", "interface", "trait", "protocol", "function", "method", "property", "field", "variable", "constant", "enum", "enum_member", "event", "type", "type_member", "declare", "type_alias", "namespace", "parameter", "import", "export", "route", "component", "query", "form-layout", "form-instance-control"];
 export type NodeKind = (typeof NODE_KINDS)[number];
 /**
  * Types of edges (relationships) between nodes
  */
-export type EdgeKind = 'contains' | 'calls' | 'imports' | 'exports' | 'extends' | 'implements' | 'references' | 'type_of' | 'returns' | 'instantiates' | 'overrides' | 'decorates' | 'event-handler' | 'opens-form';
+export type EdgeKind = 'contains' | 'calls' | 'imports' | 'exports' | 'extends' | 'implements' | 'references' | 'type_of' | 'returns' | 'instantiates' | 'overrides' | 'decorates' | 'event-handler' | 'opens-form' | 'raises-event' | 'subscribes-event' | 'type-member';
 /**
  * Supported programming languages. See NODE_KINDS for why this is a
  * runtime-iterable const array.
@@ -87,6 +87,15 @@ export interface Node {
  * An edge representing a relationship between two nodes
  */
 export interface Edge {
+    /**
+     * Database row id (AUTOINCREMENT PK on the `edges` table). Only populated
+     * when the edge was read back from the DB (e.g. via `getIncomingEdges`);
+     * undefined for edges constructed in-memory by an extractor/resolver
+     * before insertion. Needed by `resolveVbaCallStubs` to target a specific
+     * row for `repointEdgeTarget`/`deleteEdgeById` (vba-graph-connectivity-
+     * fixes, #12) since `edges` has no natural unique key.
+     */
+    id?: number;
     /** Source node ID */
     source: string;
     /** Target node ID */

package/package.json

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