gitnexus 1.6.12-rc.4 → 1.6.12-rc.5

package/dist/core/ingestion/call-extractors/zig-static-gating.d.ts

@@ -11,17 +11,14 @@
  * Conservative by design: we only tag an edge when we can prove the
  * gating expression evaluates to `false`.  Anything ambiguous → live.
  *
- * Scope of v1:
+ * Supported scope:
  *
  *   (a) **File-local** consts (`pub const FOO = false;`, plus const-to-const
  *       aliases up to 5 hops), built once per file by `buildZigBoolConstMap`.
- *   (b) **Cross-file** (`const cfg = @import("./cfg.zig"); if (cfg.FOO)`) is
- *       NOT resolved yet. The evaluator keeps the seam for it (`importAliases`
- *       + `lookupBoolsForPath`, consumed by the `field_expression` case), but
- *       the only caller passes an empty alias map and a lookup that always
- *       returns `undefined`, because the capture emitter runs in the parse
- *       worker and sees only the current file. Tracked in #3162. Until then
- *       every `cfg.FOO` condition folds to unknown, i.e. live.
+ *   (b) **Cross-file** direct imports (`const cfg = @import("./cfg.zig");
+ *       if (cfg.FOO)`) are enriched after per-file extraction. The workspace
+ *       caller supplies `importAliases` and `lookupBoolsForPath`; the parse
+ *       worker still uses empty/undefined inputs and remains file-local.
  *
  * Also out of scope: multi-hop member access (`cfg.sub.FOO`), re-exported
  * consts, runtime-evaluated bools (`const FOO = computeIt();`), and

package/dist/core/ingestion/languages/zig/scope-resolver.js

@@ -16,6 +16,7 @@ import { resolveZigImportInternal } from '../../import-resolvers/zig.js';
 import { zigProvider } from '../zig.js';
 import { expandZigWildcardNames, zigArityCompatibility, zigMergeBindings } from './index.js';
 import { populateZigRangeBindings } from './range-binding.js';
+import { populateZigWorkspaceStaticGating } from './workspace-static-gating.js';
 export const zigScopeResolver = {
     language: SupportedLanguages.Zig,
     languageProvider: zigProvider,
@@ -48,6 +49,7 @@ export const zigScopeResolver = {
     arityCompatibility: zigArityCompatibility,
     buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
     populateOwners: (parsed) => populateClassOwnedMembers(parsed),
+    populateWorkspaceReferences: populateZigWorkspaceStaticGating,
     // Payload captures — `for (items) |it|`, `if (opt) |v|`, `while (it.next())
     // |x|` — typed from the subject's binding after finalize (F6).
     populateRangeBindings: populateZigRangeBindings,

package/dist/core/ingestion/languages/zig/workspace-static-gating.d.ts

@@ -0,0 +1,8 @@
+import type { ParsedFile } from '../../../../_shared/index.js';
+export declare function populateZigWorkspaceStaticGating(parsedFiles: ParsedFile[], ctx: {
+    readonly fileContents: ReadonlyMap<string, string>;
+    readonly treeCache?: {
+        get(filePath: string): unknown;
+    };
+    readonly resolutionConfig?: unknown;
+}): void;

package/dist/core/ingestion/languages/zig/workspace-static-gating.js

@@ -0,0 +1,76 @@
+import { getTreeSitterBufferSize } from '../../constants.js';
+import { resolveZigImportInternal } from '../../import-resolvers/zig.js';
+import { buildZigBoolConstMap, collectZigStaticGatedRanges, isPositionStaticGated, } from '../../call-extractors/zig-static-gating.js';
+import { parseSourceSafe, ParseTimeoutError } from '../../../tree-sitter/safe-parse.js';
+import { getZigParser } from './query.js';
+export function populateZigWorkspaceStaticGating(parsedFiles, ctx) {
+    const parser = getZigParser();
+    const trees = new Map();
+    const bools = new Map();
+    for (const parsed of parsedFiles) {
+        const source = ctx.fileContents.get(parsed.filePath);
+        if (source === undefined)
+            continue;
+        let tree = ctx.treeCache?.get(parsed.filePath);
+        if (tree === undefined) {
+            try {
+                tree = parseSourceSafe(parser, source, undefined, {
+                    bufferSize: getTreeSitterBufferSize(source),
+                });
+            }
+            catch (err) {
+                if (err instanceof ParseTimeoutError)
+                    continue;
+                throw err;
+            }
+        }
+        trees.set(parsed.filePath, tree);
+        bools.set(parsed.filePath, buildZigBoolConstMap(tree.rootNode));
+    }
+    const knownPaths = new Set(trees.keys());
+    for (const [index, parsed] of parsedFiles.entries()) {
+        const tree = trees.get(parsed.filePath);
+        if (tree === undefined)
+            continue;
+        const aliases = collectImportAliases(tree, parsed.filePath, knownPaths, ctx.resolutionConfig);
+        if (aliases.size === 0)
+            continue;
+        const ranges = collectZigStaticGatedRanges(tree.rootNode, bools.get(parsed.filePath) ?? new Map(), aliases, (filePath) => bools.get(filePath));
+        if (ranges.length === 0)
+            continue;
+        const next = parsed.referenceSites.map((site) => site.kind === 'call' &&
+            site.staticGated !== true &&
+            isPositionStaticGated(site.atRange.startLine, site.atRange.startCol, ranges)
+            ? { ...site, staticGated: true }
+            : site);
+        parsedFiles[index] = Object.freeze({ ...parsed, referenceSites: Object.freeze(next) });
+    }
+}
+function collectImportAliases(tree, fromFile, knownPaths, resolutionConfig) {
+    const candidates = new Map();
+    const declarationCounts = new Map();
+    for (const decl of tree.rootNode.descendantsOfType('variable_declaration')) {
+        const names = decl.namedChildren.filter((node) => node.type === 'identifier');
+        const binding = names[0]?.text;
+        if (binding === undefined)
+            continue;
+        declarationCounts.set(binding, (declarationCounts.get(binding) ?? 0) + 1);
+        const builtin = decl.namedChildren.find((node) => node.type === 'builtin_function' && node.text.startsWith('@import('));
+        const raw = builtin?.descendantsOfType('string').at(0)?.text;
+        if (raw === undefined)
+            continue;
+        const specifier = raw.replace(/^['"]|['"]$/g, '');
+        const target = resolveZigImportInternal(fromFile, specifier, knownPaths, resolutionConfig);
+        if (target !== null)
+            candidates.set(binding, target);
+    }
+    const aliases = new Map();
+    for (const [binding, target] of candidates) {
+        // Alias lookup below is name-based rather than position-aware. If a name
+        // is redeclared in another lexical scope, fail open instead of applying
+        // either module's constants to every use of that spelling.
+        if (declarationCounts.get(binding) === 1)
+            aliases.set(binding, target);
+    }
+    return aliases;
+}

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -615,6 +615,19 @@ export interface ScopeResolver {
     readonly populateWorkspaceOwners?: (parsedFiles: readonly ParsedFile[], ctx: {
         readonly fileContents: ReadonlyMap<string, string>;
     }) => void;
+    /**
+     * Optional workspace-wide enrichment of extracted reference sites. Runs
+     * after all files have been extracted and before reference finalization.
+     * Use this when a per-file capture needs conservative facts from an
+     * imported sibling (for example a compile-time branch constant).
+     */
+    readonly populateWorkspaceReferences?: (parsedFiles: ParsedFile[], ctx: {
+        readonly fileContents: ReadonlyMap<string, string>;
+        readonly treeCache?: {
+            get(filePath: string): unknown;
+        };
+        readonly resolutionConfig?: unknown;
+    }) => void;
     /**
      * Recognize a `super(...)`-style receiver text. Python returns
      * `/^super\s*\(/.test(t)`. Java returns `t === 'super'`. C++ may

package/dist/core/ingestion/scope-resolution/pipeline/phase.js

@@ -55,6 +55,7 @@ const NOOP_OUTPUT = Object.freeze({
 /** Select source files that must be materialized for one resolver pass. */
 export function selectScopeSourcePathsToRead(provider, primaryFilePaths, preExtractedByPath) {
     const hasPostExtractHooks = provider.populateWorkspaceOwners !== undefined ||
+        provider.populateWorkspaceReferences !== undefined ||
         provider.populateNamespaceSiblings !== undefined ||
         provider.populateRangeBindings !== undefined ||
         provider.emitPostResolutionEdges !== undefined;

package/dist/core/ingestion/scope-resolution/pipeline/run.js

@@ -312,6 +312,11 @@ export function runScopeResolution(input, provider) {
     }
     logHeapProbe('sr-extract-end', `lang=${provider.language} parsedFiles=${parsedFiles.length} preExtractedHits=${preExtractedHits} skipped=${filesSkipped}`);
     provider.populateWorkspaceOwners?.(parsedFiles, { fileContents: getFileContents() });
+    provider.populateWorkspaceReferences?.(parsedFiles, {
+        fileContents: getFileContents(),
+        treeCache,
+        resolutionConfig: input.resolutionConfig,
+    });
     // A callable-flow-only provider has no reason to build the whole-graph
     // lookup or finalize ordinary references when none of its files emitted a
     // callable fact. This keeps the opt-in path proportional to source scanning

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.12-rc.4",
+  "version": "1.6.12-rc.5",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",