@aroman22/codegraph-vba 1.3.3 → 1.3.4

package/dist/db/queries.d.ts

@@ -240,6 +240,51 @@ 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).
+     *
+     * Design deviation note: the design's `getVbaCallStubs()` was specified as
+     * `SELECT * FROM nodes WHERE ... metadata LIKE '%"stub":true%'`, mirroring
+     * the JSON-in-JS convention used elsewhere (F2). That assumes a
+     * `nodes.metadata` column — but `nodes` has NO `metadata` column (only
+     * `edges` does; see schema.sql). `Node.metadata` is genuinely never
+     * persisted anywhere in this codebase today (the pre-existing
+     * `DoCmd.OpenForm` stub's `metadata:{stub:true}` on its `form-layout`
+     * node has the same characteristic — decorative at extraction time only).
+     * Adding a nodes-wide schema column is out of scope for this targeted fix.
+     *
+     * Equivalent-semantics fix: a VBA call-stub node is, BY DEFINITION,
+     * exactly a node that is the TARGET of a `calls` edge whose OWN metadata
+     * (which DOES persist) carries `stub: true`. So this queries via a JOIN
+     * against `edges.metadata` instead of a `nodes.metadata` column — same
+     * LIKE-prefilter-then-correctness-check shape as the JSON-in-JS
+     * convention, just anchored on the table that actually stores metadata
+     * for this row type.
+     */
+    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

@@ -57,6 +57,8 @@ export declare class VbaExtractor {
     private createModuleOrClassNode;
     /** Sub/Function/Property regex — captures visibility prefix, kind, and name. */
     private static readonly PROC_RE;
+    /** `[visibility] Declare [PtrSafe] Sub|Function <Name> ...` DLL/API declaration. */
+    private static readonly DLL_DECLARE_RE;
     /**
      * Walk the (uncommented, line-joined) source and emit one `function` node
      * per `Sub` / `Function` / `Property` declaration. Also records the proc
@@ -112,13 +114,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 +159,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 +176,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,6 +239,19 @@ 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 scanCallSites;
     /** Cache so we don't re-emit the same proc function node per call site. */
@@ -348,11 +355,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 +379,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 +408,7 @@ 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;
 }
 //# 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

@@ -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.4",
   "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.4",
+    "@aroman22/codegraph-vba-darwin-x64": "1.3.4",
+    "@aroman22/codegraph-vba-linux-arm64": "1.3.4",
+    "@aroman22/codegraph-vba-linux-x64": "1.3.4",
+    "@aroman22/codegraph-vba-win32-arm64": "1.3.4",
+    "@aroman22/codegraph-vba-win32-x64": "1.3.4"
   },
   "files": [
     "npm-shim.js",