gitnexus 1.6.11-rc.8 → 1.6.11

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

@@ -0,0 +1,319 @@
+// gitnexus/src/core/ingestion/call-extractors/zig-static-gating.ts
+/** Maximum recursion depth when evaluating a boolean condition expression. */
+const MAX_COND_DEPTH = 4;
+// ---------------------------------------------------------------------------
+// Phase 2: per-file extraction
+// ---------------------------------------------------------------------------
+/** Cap on alias-chain hops walked when resolving `const A = B; const B = C; ...`. */
+const MAX_ALIAS_HOPS = 5;
+/**
+ * Walk the top-level of a Zig source file and collect known-bool
+ * constants.  Two passes:
+ *
+ *   Pass 1: collect every top-level `const X = <expr>` where the RHS
+ *           is either a `boolean` literal (recorded in `literals`) or
+ *           a single `identifier` (recorded in `aliases`).
+ *   Pass 2: walk each alias entry up to `MAX_ALIAS_HOPS` hops; if the
+ *           chain terminates at a known-bool literal, record `X` with
+ *           the literal's value. Cycles, chains exceeding the cap, and
+ *           chains exiting file scope (unknown identifier at the root)
+ *           bail to "unknown".
+ *
+ * Only `const` decls qualify (not `var`). The function is permissive
+ * about modifier tokens (`pub`, type annotation) — it reads only the
+ * identifier name and the RHS expression shape.
+ */
+export function buildZigBoolConstMap(rootNode) {
+    const literals = new Map();
+    const aliases = new Map();
+    for (const child of rootNode.namedChildren) {
+        if (child.type !== 'variable_declaration')
+            continue;
+        const entry = extractBoolConstOrAlias(child);
+        if (!entry)
+            continue;
+        if (entry.kind === 'literal') {
+            literals.set(entry.name, entry.value);
+        }
+        else {
+            aliases.set(entry.name, entry.aliasOf);
+        }
+    }
+    // Pass 2: resolve alias chains.
+    for (const [name, target] of aliases) {
+        const resolved = resolveAliasChain(name, target, literals, aliases);
+        if (resolved !== undefined) {
+            literals.set(name, resolved);
+        }
+    }
+    return literals;
+}
+function resolveAliasChain(start, firstTarget, literals, aliases) {
+    // Walk: start → firstTarget → aliases.get(firstTarget) → ... up to MAX_ALIAS_HOPS.
+    // Cycle protection via a visited set seeded with `start` itself.
+    const visited = new Set();
+    visited.add(start);
+    let current = firstTarget;
+    for (let hop = 0; hop < MAX_ALIAS_HOPS; hop++) {
+        if (visited.has(current))
+            return undefined; // cycle
+        visited.add(current);
+        const lit = literals.get(current);
+        if (lit !== undefined)
+            return lit;
+        const next = aliases.get(current);
+        if (next === undefined)
+            return undefined; // chain exits file scope or hits unknown
+        current = next;
+    }
+    return undefined; // hop cap exceeded
+}
+function extractBoolConstOrAlias(decl) {
+    // Require `const` and exclude `var`. tree-sitter-zig parses both with
+    // the same `variable_declaration` shape; the qualifier is an anonymous
+    // child token. A `pub var FOO = false;` is mutable global state — its
+    // initial value is NOT a comptime constant and must not feed gating.
+    let isConst = false;
+    let isVar = false;
+    for (let i = 0; i < decl.childCount; i++) {
+        const c = decl.child(i);
+        if (!c || c.isNamed)
+            continue;
+        if (c.type === 'const')
+            isConst = true;
+        else if (c.type === 'var')
+            isVar = true;
+    }
+    if (!isConst || isVar)
+        return null;
+    let name;
+    let value;
+    let aliasOf;
+    for (const c of decl.namedChildren) {
+        if (c.type === 'identifier' && name === undefined) {
+            name = c.text;
+            continue;
+        }
+        if (c.type === 'boolean') {
+            const t = c.text;
+            if (t === 'true')
+                value = true;
+            else if (t === 'false')
+                value = false;
+        }
+        else if (c.type === 'identifier' && name !== undefined && aliasOf === undefined) {
+            // Second `identifier` child is the RHS alias target:
+            //   `const B = A;`  → name='B', aliasOf='A'.
+            aliasOf = c.text;
+        }
+    }
+    if (name === undefined)
+        return null;
+    if (value !== undefined)
+        return { kind: 'literal', name, value };
+    if (aliasOf !== undefined)
+        return { kind: 'alias', name, aliasOf };
+    return null;
+}
+export function collectZigStaticGatedRanges(rootNode, localBools, importAliases, lookupBoolsForPath) {
+    const out = [];
+    for (const node of rootNode.descendantsOfType(['if_statement', 'if_expression'])) {
+        const cond = findIfCondition(node);
+        const result = cond
+            ? evalCond(cond, localBools, importAliases, lookupBoolsForPath, 0)
+            : undefined;
+        let dead = null;
+        if (node.type === 'if_statement') {
+            if (result === false)
+                dead = node.childForFieldName('body');
+            if (result === true)
+                dead = node.namedChildren.find((c) => c.type === 'else_clause') ?? null;
+        }
+        else {
+            const arms = ifExpressionArms(node);
+            if (result === false)
+                dead = arms.consequence;
+            if (result === true)
+                dead = arms.alternative;
+        }
+        if (dead) {
+            out.push({
+                startLine: dead.startPosition.row + 1,
+                startCol: dead.startPosition.column,
+                endLine: dead.endPosition.row + 1,
+                endCol: dead.endPosition.column,
+            });
+        }
+    }
+    return out;
+}
+/**
+ * The two arms of an `if_expression` (`const x = if (c) a else b;`). Unlike
+ * `if_statement` the grammar gives them no field names and no `else_clause`
+ * wrapper: the consequence is the first named child after the closing `)`
+ * of the condition, the alternative is the first named child after the
+ * anonymous `else` token. Either may be absent.
+ */
+function ifExpressionArms(node) {
+    let consequence = null;
+    let alternative = null;
+    let slot = 'none';
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (!c)
+            continue;
+        if (!c.isNamed) {
+            if (c.type === ')' && slot === 'none')
+                slot = 'consequence';
+            else if (c.type === 'else')
+                slot = 'alternative';
+            continue;
+        }
+        if (slot === 'consequence' && !consequence)
+            consequence = c;
+        else if (slot === 'alternative' && !alternative)
+            alternative = c;
+    }
+    return { consequence, alternative };
+}
+/** Is a (1-based line, 0-based col) position inside one of `ranges`? */
+export function isPositionStaticGated(line, col, ranges) {
+    for (const r of ranges) {
+        if (line < r.startLine || line > r.endLine)
+            continue;
+        if (line === r.startLine && col < r.startCol)
+            continue;
+        if (line === r.endLine && col >= r.endCol)
+            continue;
+        return true;
+    }
+    return false;
+}
+/** Pick the condition node out of an `if_statement`. The condition is
+ * the first named child (the body / else branches come after). */
+function findIfCondition(ifNode) {
+    return ifNode.namedChildren[0] ?? null;
+}
+/**
+ * Evaluate a boolean condition expression to a tribool.
+ *
+ * Handles only the shapes we can resolve symbolically; everything else
+ * returns `undefined` ("unknown — treat as live").
+ */
+function evalCond(node, localBools, importAliases, lookupBoolsForPath, depth) {
+    if (depth > MAX_COND_DEPTH)
+        return undefined;
+    switch (node.type) {
+        case 'boolean': {
+            // Bare literal: `if (false)`.
+            if (node.text === 'true')
+                return true;
+            if (node.text === 'false')
+                return false;
+            return undefined;
+        }
+        case 'identifier': {
+            // Bare flag check: `if (FOO)`.
+            const v = localBools.get(node.text);
+            return v === undefined ? undefined : v;
+        }
+        case 'field_expression': {
+            // `cfg.FOO` — alias hop.
+            const obj = node.namedChildren[0];
+            const member = node.namedChildren[1];
+            if (obj?.type !== 'identifier' || member?.type !== 'identifier') {
+                return undefined;
+            }
+            const targetFile = importAliases.get(obj.text);
+            if (!targetFile)
+                return undefined;
+            const targetBools = lookupBoolsForPath(targetFile);
+            if (!targetBools)
+                return undefined;
+            const v = targetBools.get(member.text);
+            return v === undefined ? undefined : v;
+        }
+        case 'binary_expression': {
+            // `lhs and rhs` / `lhs or rhs` / `lhs == rhs` / `lhs != rhs`.
+            const op = findOperatorToken(node);
+            const lhs = node.namedChildren[0];
+            const rhs = node.namedChildren[1];
+            if (!lhs || !rhs)
+                return undefined;
+            const l = evalCond(lhs, localBools, importAliases, lookupBoolsForPath, depth + 1);
+            const r = evalCond(rhs, localBools, importAliases, lookupBoolsForPath, depth + 1);
+            if (op === 'and') {
+                // `false and *` = false; `* and false` = false.
+                if (l === false || r === false)
+                    return false;
+                if (l === true && r === true)
+                    return true;
+                return undefined;
+            }
+            if (op === 'or') {
+                // Only `false or false` is provably false.
+                if (l === false && r === false)
+                    return false;
+                if (l === true || r === true)
+                    return true;
+                return undefined;
+            }
+            if (op === '==') {
+                // Equality folds when both sides are known booleans.
+                // `FOO == false` ↔ `!FOO`; `FOO == true` ↔ `FOO`.
+                if (l === undefined || r === undefined)
+                    return undefined;
+                return l === r;
+            }
+            if (op === '!=') {
+                if (l === undefined || r === undefined)
+                    return undefined;
+                return l !== r;
+            }
+            // Other comparison ops (<, >, …) — not booleans we can prove.
+            return undefined;
+        }
+        case 'parenthesized_expression': {
+            // `(cond)`: transparent.
+            const inner = node.namedChildren[0];
+            if (!inner)
+                return undefined;
+            return evalCond(inner, localBools, importAliases, lookupBoolsForPath, depth + 1);
+        }
+        case 'error_union_type': {
+            // tree-sitter-zig has no unary `!` node: prefix `!cond` (boolean
+            // negation) parses as `error_union_type` because the same `!` token
+            // introduces error-union types. In condition position that reading is
+            // never a type, so negate whatever the operand folds to: an
+            // identifier, a literal, or a parenthesized compound like `!(A and B)`.
+            const inner = node.namedChildren[0];
+            if (!inner)
+                return undefined;
+            const v = evalCond(inner, localBools, importAliases, lookupBoolsForPath, depth + 1);
+            if (v === undefined)
+                return undefined;
+            return !v;
+        }
+        default:
+            return undefined;
+    }
+}
+/**
+ * Pull the textual operator (e.g. "and", "or") out of a
+ * `binary_expression`.  In tree-sitter-zig, the operator is an
+ * anonymous child token whose `type` equals the operator string.
+ */
+function findOperatorToken(binExpr) {
+    for (let i = 0; i < binExpr.childCount; i++) {
+        const c = binExpr.child(i);
+        if (!c)
+            continue;
+        if (!c.isNamed) {
+            // Anonymous tokens for these ops carry their text as the type.
+            if (c.type === 'and' || c.type === 'or' || c.type === '==' || c.type === '!=') {
+                return c.type;
+            }
+        }
+    }
+    return undefined;
+}

package/dist/core/ingestion/call-processor.js

@@ -324,7 +324,9 @@ export function resolveRouteHandlerSymbols(model, extractedRoutes, decoratorRout
             : uniqueById(model.methods.lookupAllByOwner(owner.nodeId, member))?.nodeId;
     };
     const claim = (routePath, prefix, httpMethod, symbolId) => {
-        if (!routePath)
+        // An empty path is a valid, pathless mapping and normalizes to either `/`
+        // or its class/router prefix. Only null means the extractor had no route.
+        if (routePath === null)
             return;
         const url = normalizeExtractedRoutePath(routePath, prefix);
         const key = routeNodeKey(normalizeRouteMethod(httpMethod), url);

package/dist/core/ingestion/class-extractors/configs/zig.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const zigClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/zig.js

@@ -0,0 +1,32 @@
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { isZigFileStruct, ZIG_CONTAINER_TYPES, zigContainerLabel, zigContainerName, } from '../../languages/zig/captures.js';
+/**
+ * Zig containers (struct/enum/union/opaque) are anonymous in the grammar:
+ *
+ *   const Point = struct { ... };
+ *   pub fn List(comptime T: type) type { return struct { ... }; }
+ *   fn build() void { const R = struct { ... }; sort(struct { fn lt … }.lt); }
+ *
+ * The identity is the binding name (first identifier of the parent
+ * variable_declaration), the generic type constructor's name, or — for a
+ * FUNCTION-LOCAL or ANONYMOUS container — a synthesized `host$Name` /
+ * `host$N` (F8). `zigContainerName` is the single source shared with the
+ * field/method extractors and the owner walk, so owner ids and node ids
+ * agree by construction. Which of the (up to three) ZIG_QUERIES rules that
+ * match one container gets to mint it is decided by the provider's
+ * `shouldSkipDefinitionCapture` (`isZigRedundantContainerCapture`).
+ */
+const extractZigContainerName = (node, filePath) => zigContainerName(node, filePath);
+const extractZigContainerType = (node) => {
+    // The file itself, when it declares top-level fields (file-struct); a
+    // namespace-only file is not a type — `extract` then yields no symbol.
+    if (node.type === 'source_file')
+        return isZigFileStruct(node) ? 'Struct' : undefined;
+    return zigContainerLabel(node);
+};
+export const zigClassConfig = {
+    language: SupportedLanguages.Zig,
+    typeDeclarationNodes: [...ZIG_CONTAINER_TYPES, 'source_file'],
+    extractName: extractZigContainerName,
+    extractType: extractZigContainerType,
+};

package/dist/core/ingestion/class-extractors/generic.js

@@ -45,6 +45,7 @@ const CLASS_LIKE_LABELS = new Set([
     'Interface',
     'Enum',
     'Record',
+    'Union',
 ]);
 const extractScopeSegmentsFromNode = (scopeNode, scopeNameNodeTypes) => {
     const nameNode = scopeNode.childForFieldName?.('name') ??
@@ -100,7 +101,9 @@ export function createClassExtractor(config) {
     const extract = (node, fallback) => {
         if (!typeDeclarationSet.has(node.type))
             return null;
-        const name = config.extractName?.(node) ?? extractTypeNameFromNode(node) ?? fallback?.name;
+        const name = config.extractName?.(node, fallback?.filePath) ??
+            extractTypeNameFromNode(node) ??
+            fallback?.name;
         const type = config.extractType?.(node) ??
             DEFAULT_LABEL_BY_NODE_TYPE[node.type] ??
             (isClassLikeLabel(fallback?.type) ? fallback.type : undefined);

package/dist/core/ingestion/class-types.d.ts

@@ -1,6 +1,6 @@
 import type { NodeLabel, SupportedLanguages } from '../../_shared/index.js';
 import type { SyntaxNode } from './utils/ast-helpers.js';
-export type ClassLikeNodeLabel = Extract<NodeLabel, 'Class' | 'Struct' | 'Interface' | 'Enum' | 'Record'>;
+export type ClassLikeNodeLabel = Extract<NodeLabel, 'Class' | 'Struct' | 'Interface' | 'Enum' | 'Record' | 'Union'>;
 export interface ExtractedClassSymbol {
     name: string;
     type: ClassLikeNodeLabel;
@@ -32,6 +32,8 @@ export interface ClassExtractor {
     extract(node: SyntaxNode, fallback?: {
         name?: string;
         type?: NodeLabel | null;
+        /** Repo-relative path of the file being extracted, when known. */
+        filePath?: string;
     }): ExtractedClassSymbol | null;
     extractQualifiedName(node: SyntaxNode, simpleName: string): string | null;
     /**
@@ -61,7 +63,9 @@ export interface ClassExtractionConfig {
      */
     qualifiedNodeId?: boolean;
     scopeNameNodeTypes?: string[];
-    extractName?: (node: SyntaxNode) => string | undefined;
+    /** `filePath` is supplied when known (definition-phase extraction) — a
+     *  language whose file IS a type names it from the path. */
+    extractName?: (node: SyntaxNode, filePath?: string) => string | undefined;
     extractType?: (node: SyntaxNode) => ClassLikeNodeLabel | undefined;
     extractScopeSegments?: (node: SyntaxNode) => string[] | null | undefined;
     extractTemplateArguments?: (node: SyntaxNode) => string[] | undefined;

package/dist/core/ingestion/destination-key.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Shared destination-identity keying — the async counterpart of `routeNodeKey`
+ * in `route-extractors/route-path.ts`.
+ *
+ * Deliberately OUTSIDE `frameworks/spring/`, and for the same reason
+ * `routeNodeKey` sits outside the routes phase: the identity has to be mintable
+ * by anything that names a broker address, so a Node Kafka client or a Celery
+ * task queue can land on the very node a Spring publisher minted. A key that
+ * lived in the Spring module would force every other producer to import Spring,
+ * or — worse — let each one invent its own spelling, and two spellings of one
+ * address is precisely the missed connection this overlay exists to make.
+ *
+ * `broker` is a plain `string`, NOT the Spring `SpringDestinationBroker` union.
+ * Importing that union here is the dependency this module exists to avoid, and
+ * widening it costs nothing that matters: the union is a subtype of `string`,
+ * so a Spring caller passes its own values unchanged, while a future
+ * non-Spring caller stays free to attest to a broker Spring has no name for.
+ * The trade is real but small — this signature cannot reject a misspelled
+ * broker — and it is the same trade `routeNodeKey` makes by taking `method` as
+ * a `string` rather than an HTTP-verb union. Pure string logic, no
+ * dependencies.
+ */
+/**
+ * The `Destination` node identity: `(broker, address)` when the broker is
+ * known, falling back to the address alone when it is not.
+ *
+ * The broker belongs IN the key, exactly as the HTTP verb belongs in
+ * `routeNodeKey`. `GET /x` and `POST /x` are two nodes, both fully joinable,
+ * and neither is punished for the other's existence; `kafka orders` and
+ * `rabbit orders` are two nodes on the same terms. A Kafka topic and a Rabbit
+ * queue that happen to share a name are two places, and one node for both would
+ * report a publisher and a subscriber as connected when nothing connects them.
+ *
+ * The known objection is that the broker is INFERRED — from a receiver's name,
+ * from an annotation table — so a wrong guess splits a pair that is really one.
+ * That is true and it is the cost. It is worth paying because the alternative
+ * tried first was worse: withdrawing the address from every site that named it
+ * split the pair even when the guess was RIGHT, since one unrelated third party
+ * writing the same word anywhere in the repository was enough to disconnect
+ * everybody on that spelling. Putting the broker in the key bounds the damage
+ * of a wrong guess to the one pair it was wrong about, instead of spreading it
+ * to every pair that shares an address with a stranger.
+ *
+ * ── THE ADDRESS-ONLY FALLBACK IS UNREACHABLE TODAY ──────────────────────
+ *
+ * `SpringDestinationCandidate.broker` is REQUIRED, and every annotation rule
+ * and every producer template supplies one, so no Spring caller can reach the
+ * `undefined` branch. It is written anyway, and on purpose: the parameter shape
+ * is the contract this module offers the next language, and the next language
+ * may well capture an address without being able to attest to a broker (a bare
+ * `queue.publish(name)` in a dynamic language, a binding that names only a
+ * channel). Degrading to address-only is the right answer there — silence about
+ * the broker is not a claim about it, and refusing to key such a site at all
+ * would lose a real destination over a value nobody disagreed about.
+ *
+ * Because the branch is dead, it is covered by testing THIS function directly
+ * rather than by a pipeline test staged to look as though a phase reached it.
+ */
+export declare function destinationNodeKey(broker: string | undefined, address: string): string;

package/dist/core/ingestion/destination-key.js

@@ -0,0 +1,61 @@
+/**
+ * Shared destination-identity keying — the async counterpart of `routeNodeKey`
+ * in `route-extractors/route-path.ts`.
+ *
+ * Deliberately OUTSIDE `frameworks/spring/`, and for the same reason
+ * `routeNodeKey` sits outside the routes phase: the identity has to be mintable
+ * by anything that names a broker address, so a Node Kafka client or a Celery
+ * task queue can land on the very node a Spring publisher minted. A key that
+ * lived in the Spring module would force every other producer to import Spring,
+ * or — worse — let each one invent its own spelling, and two spellings of one
+ * address is precisely the missed connection this overlay exists to make.
+ *
+ * `broker` is a plain `string`, NOT the Spring `SpringDestinationBroker` union.
+ * Importing that union here is the dependency this module exists to avoid, and
+ * widening it costs nothing that matters: the union is a subtype of `string`,
+ * so a Spring caller passes its own values unchanged, while a future
+ * non-Spring caller stays free to attest to a broker Spring has no name for.
+ * The trade is real but small — this signature cannot reject a misspelled
+ * broker — and it is the same trade `routeNodeKey` makes by taking `method` as
+ * a `string` rather than an HTTP-verb union. Pure string logic, no
+ * dependencies.
+ */
+/**
+ * The `Destination` node identity: `(broker, address)` when the broker is
+ * known, falling back to the address alone when it is not.
+ *
+ * The broker belongs IN the key, exactly as the HTTP verb belongs in
+ * `routeNodeKey`. `GET /x` and `POST /x` are two nodes, both fully joinable,
+ * and neither is punished for the other's existence; `kafka orders` and
+ * `rabbit orders` are two nodes on the same terms. A Kafka topic and a Rabbit
+ * queue that happen to share a name are two places, and one node for both would
+ * report a publisher and a subscriber as connected when nothing connects them.
+ *
+ * The known objection is that the broker is INFERRED — from a receiver's name,
+ * from an annotation table — so a wrong guess splits a pair that is really one.
+ * That is true and it is the cost. It is worth paying because the alternative
+ * tried first was worse: withdrawing the address from every site that named it
+ * split the pair even when the guess was RIGHT, since one unrelated third party
+ * writing the same word anywhere in the repository was enough to disconnect
+ * everybody on that spelling. Putting the broker in the key bounds the damage
+ * of a wrong guess to the one pair it was wrong about, instead of spreading it
+ * to every pair that shares an address with a stranger.
+ *
+ * ── THE ADDRESS-ONLY FALLBACK IS UNREACHABLE TODAY ──────────────────────
+ *
+ * `SpringDestinationCandidate.broker` is REQUIRED, and every annotation rule
+ * and every producer template supplies one, so no Spring caller can reach the
+ * `undefined` branch. It is written anyway, and on purpose: the parameter shape
+ * is the contract this module offers the next language, and the next language
+ * may well capture an address without being able to attest to a broker (a bare
+ * `queue.publish(name)` in a dynamic language, a binding that names only a
+ * channel). Degrading to address-only is the right answer there — silence about
+ * the broker is not a claim about it, and refusing to key such a site at all
+ * would lose a real destination over a value nobody disagreed about.
+ *
+ * Because the branch is dead, it is covered by testing THIS function directly
+ * rather than by a pipeline test staged to look as though a phase reached it.
+ */
+export function destinationNodeKey(broker, address) {
+    return broker ? `${broker} ${address}` : address;
+}

package/dist/core/ingestion/entry-point-scoring.d.ts

@@ -29,8 +29,12 @@ export interface EntryPointScoreResult {
  */
 export declare function calculateEntryPointScore(name: string, language: SupportedLanguages, isExported: boolean, callerCount: number, calleeCount: number, filePath?: string): EntryPointScoreResult;
 /**
- * Check if a file path is a test file (should be excluded from entry points)
- * Covers common test file patterns across all supported languages
+ * Check if a file path is a test file (should be excluded from entry points).
+ *
+ * Delegates to the shared predicate in `utils/test-file-path.ts`. This used to be
+ * a second, hand-maintained copy that had drifted from the one backing the MCP
+ * `includeTests` flag — see that module's header. Re-exported under this name so
+ * existing importers are unaffected.
  */
 export declare function isTestFile(filePath: string): boolean;
 /**

package/dist/core/ingestion/entry-point-scoring.js

@@ -11,6 +11,7 @@
  */
 import { detectFrameworkFromPath } from './framework-detection.js';
 import { providers } from './languages/index.js';
+import { isTestFilePath } from './utils/test-file-path.js';
 // ============================================================================
 // NAME PATTERNS
 // ============================================================================
@@ -127,52 +128,15 @@ export function calculateEntryPointScore(name, language, isExported, callerCount
 // HELPER FUNCTIONS
 // ============================================================================
 /**
- * Check if a file path is a test file (should be excluded from entry points)
- * Covers common test file patterns across all supported languages
+ * Check if a file path is a test file (should be excluded from entry points).
+ *
+ * Delegates to the shared predicate in `utils/test-file-path.ts`. This used to be
+ * a second, hand-maintained copy that had drifted from the one backing the MCP
+ * `includeTests` flag — see that module's header. Re-exported under this name so
+ * existing importers are unaffected.
  */
 export function isTestFile(filePath) {
-    const p = filePath.toLowerCase().replace(/\\/g, '/');
-    return (
-    // JavaScript/TypeScript test patterns
-    p.includes('.test.') ||
-        p.includes('.spec.') ||
-        p.includes('__tests__/') ||
-        p.includes('__mocks__/') ||
-        // Generic test folders
-        p.includes('/test/') ||
-        p.includes('/tests/') ||
-        p.includes('/testing/') ||
-        // Python test patterns
-        p.endsWith('_test.py') ||
-        p.includes('/test_') ||
-        // Go test patterns
-        p.endsWith('_test.go') ||
-        // Java test patterns
-        p.includes('/src/test/') ||
-        // Rust test patterns (inline tests are different, but test files)
-        p.includes('/tests/') ||
-        // Swift/iOS test patterns
-        p.endsWith('tests.swift') ||
-        p.endsWith('test.swift') ||
-        p.includes('uitests/') ||
-        // C# test patterns
-        p.endsWith('tests.cs') ||
-        p.endsWith('test.cs') ||
-        p.includes('.tests/') ||
-        p.includes('.test/') ||
-        p.includes('.integrationtests/') ||
-        p.includes('.unittests/') ||
-        p.includes('/testproject/') ||
-        // PHP/Laravel test patterns
-        p.endsWith('test.php') ||
-        p.endsWith('spec.php') ||
-        p.includes('/tests/feature/') ||
-        p.includes('/tests/unit/') ||
-        // Ruby test patterns
-        p.endsWith('_spec.rb') ||
-        p.endsWith('_test.rb') ||
-        p.includes('/spec/') ||
-        p.includes('/test/fixtures/'));
+    return isTestFilePath(filePath);
 }
 /**
  * Check if a file path is likely a utility/helper file

package/dist/core/ingestion/export-detection.d.ts

@@ -56,3 +56,40 @@ export declare const swiftExportChecker: ExportChecker;
 export declare const rubyExportChecker: ExportChecker;
 /** Dart: public if no leading underscore (convention, same as Python). */
 export declare const dartExportChecker: ExportChecker;
+/**
+ * Zig: walk to the enclosing decl, scan its direct children for an unnamed `pub`
+ * or `export` keyword token (tree-sitter-zig models both as anonymous keyword
+ * children of function_declaration / variable_declaration). Two different
+ * facts share this one flag, on purpose:
+ *   - `pub` is Zig-module visibility — reachable from another `.zig` file
+ *     through `@import`;
+ *   - `export` is C-ABI linkage (`export fn add(...)`) — the symbol lands in
+ *     the object file for FFI callers, and it never carries `pub`.
+ * `isExported` means "visible outside this compilation unit" graph-wide (C uses
+ * external linkage for the same flag), so both qualify. The `visibility`
+ * property is the Zig-only fact and is `pub`-only — see `hasZigPubKeyword`:
+ * an `export fn` without `pub` is public to C and PRIVATE to other Zig files.
+ * Container fields (struct/enum variants) are public if their enclosing
+ * variable_declaration is public.
+ *
+ * The walk stops at the FIRST declaration it reaches: a `fn` inside
+ * `pub const T = struct { … }` carries its own `pub` (or not), independent of
+ * the container's. Continuing up to the wrapper marked every private method of
+ * a public container as exported.
+ */
+export declare const zigExportChecker: ExportChecker;
+/**
+ * Does this Zig declaration carry a `pub` or `export` keyword child? Feeds
+ * `isExported` (visible outside the compilation unit — to Zig importers OR to
+ * C callers).
+ */
+export declare function hasZigVisibilityKeyword(declNode: SyntaxNode): boolean;
+/**
+ * Does this Zig declaration carry a `pub` keyword child? Feeds `visibility`,
+ * the Zig-module fact: per the language reference, only `pub` declarations are
+ * accessible from another file via `@import`; `export` alone gives C linkage
+ * and leaves the declaration private to Zig code. So `export fn c_add` reports
+ * `isExported: true` (FFI surface) with `visibility: 'private'` (Zig surface)
+ * — two facts, two properties, deliberately not one.
+ */
+export declare function hasZigPubKeyword(declNode: SyntaxNode): boolean;