gitnexus 1.6.5-rc.2 → 1.6.5-rc.21

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

@@ -29,7 +29,8 @@ import { getLanguageFromFilename, SupportedLanguages } from '../../_shared/index
 import { isRegistryPrimary } from './registry-primary-flag.js';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
-import { FUNCTION_NODE_TYPES, findEnclosingClassId, findEnclosingClassInfo, genericFuncName, inferFunctionLabel, } from './utils/ast-helpers.js';
+import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
+import { CLASS_CONTAINER_TYPES, FUNCTION_NODE_TYPES, findEnclosingClassInfo, genericFuncName, inferFunctionLabel, } from './utils/ast-helpers.js';
 import { typeTagForId, constTagForId, buildCollisionGroups } from './utils/method-props.js';
 import { countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, extractCallArgTypes, } from './utils/call-analysis.js';
 import { buildTypeEnv, isSubclassOf } from './type-env.js';
@@ -38,6 +39,57 @@ import { normalizeFetchURL, routeMatches } from './route-extractors/nextjs.js';
 import { extractTemplateComponents } from './vue-sfc-extractor.js';
 import { extractReturnTypeName, stripNullable } from './type-extractors/shared.js';
 import { logger } from '../logger.js';
+// ── Property-prepass helpers (parity with parse-worker.ts) ──
+// These mirror the sequential-path equivalents in parse-worker.ts so the main-
+// thread `processCalls` pre-pass produces byte-identical Property nodes/symbols
+// to the worker pool. Drift between the two paths breaks the
+// `incremental ≡ --force` invariant the moment a repo crosses the worker
+// threshold between runs.
+/** Walk up to the nearest enclosing class/struct/interface AST node. */
+const findEnclosingClassNode = (node) => {
+    let current = node.parent;
+    while (current) {
+        if (CLASS_CONTAINER_TYPES.has(current.type))
+            return current;
+        current = current.parent;
+    }
+    return null;
+};
+/** No-op SymbolTable stub for FieldExtractorContext — matches parse-worker. */
+const NOOP_SYMBOL_TABLE = {
+    lookupExact: () => undefined,
+    lookupExactFull: () => undefined,
+    lookupExactAll: () => [],
+    lookupCallableByName: () => [],
+    getFiles: () => [][Symbol.iterator](),
+    getStats: () => ({ fileCount: 0 }),
+};
+/**
+ * Extract (and cache) field info for a class node. Cache is passed in so it
+ * stays scoped to a single `processCalls` invocation rather than leaking
+ * across analyze runs (worker uses module-level caching because each worker
+ * process is short-lived; the main thread is not).
+ *
+ * Cache key is `${filePath}:${classNode.startIndex}` — startIndex alone is a
+ * per-file byte offset, so almost every Ruby/Python file's leading class lands
+ * at byte 0 and would collide across files in the shared map.
+ */
+const getFieldInfo = (classNode, provider, context, cache) => {
+    if (!provider.fieldExtractor)
+        return undefined;
+    const cacheKey = `${context.filePath}:${classNode.startIndex}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    const result = provider.fieldExtractor.extract(classNode, context);
+    if (!result?.fields?.length)
+        return undefined;
+    const map = new Map();
+    for (const field of result.fields)
+        map.set(field.name, field);
+    cache.set(cacheKey, map);
+    return map;
+};
 /**
  * Type labels treated as class-like **method-dispatch receivers** by the call
  * resolver — the set walked by the MRO / heritage path for member and static
@@ -614,7 +666,7 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
         if (!tree) {
             const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
             try {
-                tree = parser.parse(parseContent, undefined, {
+                tree = parseSourceSafe(parser, parseContent, undefined, {
                     bufferSize: getTreeSitterBufferSize(parseContent),
                 });
             }
@@ -701,6 +753,111 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
         }
         prepared.push({ file, language, provider, tree, matches, parentMap, typeEnv });
     }
+    // ── Property-registration pre-pass ──
+    // Register all routed properties (e.g. Ruby attr_accessor) BEFORE the
+    // resolution loop so cross-file field-type lookups (e.g.
+    // `user.address.save → Address#save`) succeed regardless of file
+    // processing order. This MUST stay in lockstep with the equivalent
+    // worker-path block in parse-worker.ts (kind === 'properties') — any
+    // divergence between the two paths breaks the `incremental ≡ --force`
+    // invariant once a repo crosses the worker threshold between runs.
+    const fieldInfoCache = new Map();
+    for (const { file, language, provider, matches, typeEnv } of prepared) {
+        const callRouter = provider.callRouter;
+        if (!callRouter)
+            continue;
+        matches.forEach((match) => {
+            const captureMap = {};
+            match.captures.forEach((c) => (captureMap[c.name] = c.node));
+            if (!captureMap['call'])
+                return;
+            const callNameNode = captureMap['call.name'];
+            if (!callNameNode)
+                return;
+            const routed = callRouter(callNameNode.text, captureMap['call']);
+            if (!routed || routed.kind !== 'properties')
+                return;
+            const propEnclosingInfo = findEnclosingClassInfo(captureMap['call'], file.path, provider.resolveEnclosingOwner);
+            const propEnclosingClassId = propEnclosingInfo?.classId ?? null;
+            // Enrich routed properties with FieldExtractor metadata so types
+            // discovered from constructor assignments (e.g. `@address = Address.new`)
+            // are propagated even when the routing payload itself lacks declaredType.
+            let routedFieldMap;
+            if (provider.fieldExtractor && typeEnv) {
+                const classNode = findEnclosingClassNode(captureMap['call']);
+                if (classNode) {
+                    routedFieldMap = getFieldInfo(classNode, provider, {
+                        typeEnv,
+                        symbolTable: NOOP_SYMBOL_TABLE,
+                        filePath: file.path,
+                        language,
+                    }, fieldInfoCache);
+                }
+            }
+            const fileId = generateId('File', file.path);
+            for (const item of routed.items) {
+                const routedFieldInfo = routedFieldMap?.get(item.propName);
+                const propQualifiedName = propEnclosingInfo
+                    ? `${propEnclosingInfo.className}.${item.propName}`
+                    : item.propName;
+                const nodeId = generateId('Property', `${file.path}:${propQualifiedName}`);
+                graph.addNode({
+                    id: nodeId,
+                    label: 'Property',
+                    properties: {
+                        name: item.propName,
+                        filePath: file.path,
+                        startLine: item.startLine,
+                        endLine: item.endLine,
+                        language,
+                        isExported: true,
+                        description: item.accessorType,
+                        ...(item.declaredType
+                            ? { declaredType: item.declaredType }
+                            : routedFieldInfo?.type
+                                ? { declaredType: routedFieldInfo.type }
+                                : {}),
+                        ...(routedFieldInfo?.visibility !== undefined
+                            ? { visibility: routedFieldInfo.visibility }
+                            : {}),
+                        ...(routedFieldInfo?.isStatic !== undefined
+                            ? { isStatic: routedFieldInfo.isStatic }
+                            : {}),
+                        ...(routedFieldInfo?.isReadonly !== undefined
+                            ? { isReadonly: routedFieldInfo.isReadonly }
+                            : {}),
+                    },
+                });
+                ctx.model.symbols.add(file.path, item.propName, nodeId, 'Property', {
+                    ...(propEnclosingClassId ? { ownerId: propEnclosingClassId } : {}),
+                    ...(item.declaredType
+                        ? { declaredType: item.declaredType }
+                        : routedFieldInfo?.type
+                            ? { declaredType: routedFieldInfo.type }
+                            : {}),
+                });
+                const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
+                graph.addRelationship({
+                    id: relId,
+                    sourceId: fileId,
+                    targetId: nodeId,
+                    type: 'DEFINES',
+                    confidence: 1.0,
+                    reason: '',
+                });
+                if (propEnclosingClassId) {
+                    graph.addRelationship({
+                        id: generateId('HAS_PROPERTY', `${propEnclosingClassId}->${nodeId}`),
+                        sourceId: propEnclosingClassId,
+                        targetId: nodeId,
+                        type: 'HAS_PROPERTY',
+                        confidence: 1.0,
+                        reason: '',
+                    });
+                }
+            }
+        });
+    }
     // ── Resolution loop: verify constructor bindings and resolve calls ──
     // The accumulator (if present) is now fully populated from the preparation
     // loop above, so verifyConstructorBindings sees all provider bindings
@@ -749,9 +906,10 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
                 if (receiverTypeName) {
                     const enclosing = findEnclosingFunction(captureMap['assignment'], file.path, ctx, provider);
                     const srcId = enclosing || generateId('File', file.path);
-                    // Defer resolution: Ruby attr_accessor properties are registered during
-                    // this same loop, so cross-file lookups fail if the declaring file hasn't
-                    // been processed yet. Collect now, resolve after all files are done.
+                    // Defer resolution so write-access tracking sees the FINAL graph
+                    // state — properties from the pre-pass are present, but receiver-type
+                    // resolution can still depend on inference that completes during the
+                    // main loop. Resolve after all files have been processed.
                     pendingWrites.push({ receiverTypeName, propertyName, filePath: file.path, srcId });
                 }
                 // Assignment-only capture (no @call sibling): skip the rest of this
@@ -841,47 +999,8 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
                     case 'import':
                         return;
                     case 'properties': {
-                        const fileId = generateId('File', file.path);
-                        const propEnclosingClassId = findEnclosingClassId(captureMap['call'], file.path);
-                        for (const item of routed.items) {
-                            const nodeId = generateId('Property', `${file.path}:${item.propName}`);
-                            graph.addNode({
-                                id: nodeId,
-                                label: 'Property',
-                                properties: {
-                                    name: item.propName,
-                                    filePath: file.path,
-                                    startLine: item.startLine,
-                                    endLine: item.endLine,
-                                    language,
-                                    isExported: true,
-                                    description: item.accessorType,
-                                },
-                            });
-                            ctx.model.symbols.add(file.path, item.propName, nodeId, 'Property', {
-                                ...(propEnclosingClassId ? { ownerId: propEnclosingClassId } : {}),
-                                ...(item.declaredType ? { declaredType: item.declaredType } : {}),
-                            });
-                            const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
-                            graph.addRelationship({
-                                id: relId,
-                                sourceId: fileId,
-                                targetId: nodeId,
-                                type: 'DEFINES',
-                                confidence: 1.0,
-                                reason: '',
-                            });
-                            if (propEnclosingClassId) {
-                                graph.addRelationship({
-                                    id: generateId('HAS_PROPERTY', `${propEnclosingClassId}->${nodeId}`),
-                                    sourceId: propEnclosingClassId,
-                                    targetId: nodeId,
-                                    type: 'HAS_PROPERTY',
-                                    confidence: 1.0,
-                                    reason: '',
-                                });
-                            }
-                        }
+                        // Properties already registered in the pre-pass above.
+                        // Skip to avoid duplicate nodes/edges.
                         return;
                     }
                     case 'call':
@@ -2586,7 +2705,7 @@ export const extractFetchCallsFromFiles = async (files, astCache) => {
         if (!tree) {
             const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
             try {
-                tree = parser.parse(parseContent, undefined, {
+                tree = parseSourceSafe(parser, parseContent, undefined, {
                     bufferSize: getTreeSitterBufferSize(parseContent),
                 });
             }

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

@@ -20,6 +20,23 @@ const __dirname = dirname(__filename);
 const leidenPath = resolve(__dirname, '..', '..', '..', 'vendor', 'leiden', 'index.cjs');
 const _require = createRequire(import.meta.url);
 const leiden = _require(leidenPath);
+/**
+ * Deterministic PRNG (mulberry32) seed for the vendored Leiden algorithm.
+ * Vendored Leiden defaults `rng: Math.random`, which makes community
+ * assignment non-deterministic across runs. Passing a seeded RNG gives us
+ * reproducible community/modularity output, which is required for the
+ * incremental-indexing equivalence test (incremental ≡ full rebuild).
+ */
+const LEIDEN_SEED = 0xc0de;
+function createSeededRng(seed) {
+    let s = seed >>> 0;
+    return () => {
+        s = (s + 0x6d2b79f5) >>> 0;
+        let t = Math.imul(s ^ (s >>> 15), 1 | s);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
 // ============================================================================
 // COMMUNITY COLORS (for visualization)
 // ============================================================================
@@ -83,6 +100,7 @@ export const processCommunities = async (knowledgeGraph, onProgress) => {
             Promise.resolve(leiden.detailed(graph, {
                 resolution: isLarge ? 2.0 : 1.0,
                 maxIterations: isLarge ? 3 : 0,
+                rng: createSeededRng(LEIDEN_SEED),
             })),
             new Promise((_, reject) => setTimeout(() => reject(new Error('Leiden timeout')), LEIDEN_TIMEOUT_MS)),
         ]);

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

@@ -19,6 +19,7 @@ import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename } from '../../_shared/index.js';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
+import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
 import { getProvider } from './languages/index.js';
 import { getTreeSitterBufferSize } from './constants.js';
 import { resolveExtendsType } from './model/heritage-map.js';
@@ -152,7 +153,7 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
             // re-parses see the same input as the cached AST.
             const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
             try {
-                tree = parser.parse(parseContent, undefined, {
+                tree = parseSourceSafe(parser, parseContent, undefined, {
                     bufferSize: getTreeSitterBufferSize(parseContent),
                 });
             }
@@ -300,7 +301,7 @@ export async function extractExtractedHeritageFromFiles(files, astCache) {
         if (!tree) {
             const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
             try {
-                tree = parser.parse(parseContent, undefined, {
+                tree = parseSourceSafe(parser, parseContent, undefined, {
                     bufferSize: getTreeSitterBufferSize(parseContent),
                 });
             }

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

@@ -5,6 +5,7 @@ import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename } from '../../_shared/index.js';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
+import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
 import { getTreeSitterBufferSize } from './constants.js';
 import { loadImportConfigs } from './language-config.js';
 import { buildSuffixIndex } from './import-resolvers/utils.js';
@@ -243,7 +244,7 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
         if (!tree) {
             const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
             try {
-                tree = parser.parse(parseContent, undefined, {
+                tree = parseSourceSafe(parser, parseContent, undefined, {
                     bufferSize: getTreeSitterBufferSize(parseContent),
                 });
             }

package/dist/core/ingestion/import-resolvers/standard.d.ts

@@ -28,3 +28,8 @@ export declare const resolveImportPath: (currentFile: string, importPath: string
 export declare function resolveStandard(rawImportPath: string, filePath: string, ctx: ResolveCtx, language: SupportedLanguages): ImportResult;
 /** Create a reusable standard-resolution strategy for a given language. */
 export declare function createStandardStrategy(language: SupportedLanguages): ImportResolverStrategy;
+/**
+ * Strip a JS-family extension from a path, returning the stem.
+ * Returns `null` if the path does not end with a JS-family extension.
+ */
+export declare function stripJsExtension(path: string): string | null;

package/dist/core/ingestion/import-resolvers/standard.js

@@ -108,7 +108,20 @@ export const resolveImportPath = (currentFile, importPath, allFiles, allFileList
     const basePath = currentDir.join('/');
     if (importPath.startsWith('.')) {
         const resolved = tryResolveWithExtensions(basePath, allFiles);
-        return cache(resolved);
+        if (resolved)
+            return cache(resolved);
+        // TypeScript ESM: imports use .js/.jsx/.mjs/.cjs but source files are
+        // .ts/.tsx/.mts/.cts. Strip the JS-family extension and re-resolve.
+        // NOTE: This fallback only applies to relative imports. Path alias imports
+        // (e.g. @/utils.js via tsconfig paths) do not yet strip .js extensions —
+        // that is a known limitation tracked for follow-up.
+        if (language === SupportedLanguages.TypeScript || language === SupportedLanguages.JavaScript) {
+            const stripped = stripJsExtension(basePath);
+            if (stripped !== null) {
+                return cache(tryResolveWithExtensions(stripped, allFiles));
+            }
+        }
+        return cache(null);
     }
     // ---- Generic package/absolute import resolution (suffix matching) ----
     // Java wildcards are handled in processImports, not here
@@ -140,3 +153,16 @@ export function resolveStandard(rawImportPath, filePath, ctx, language) {
 export function createStandardStrategy(language) {
     return (raw, fp, ctx) => resolveStandard(raw, fp, ctx, language);
 }
+// ============================================================================
+// ESM extension helpers
+// ============================================================================
+/** JS-family extensions that TypeScript ESM maps to TS equivalents. */
+const JS_EXTENSION_PATTERN = /\.(js|jsx|mjs|cjs)$/;
+/**
+ * Strip a JS-family extension from a path, returning the stem.
+ * Returns `null` if the path does not end with a JS-family extension.
+ */
+export function stripJsExtension(path) {
+    const match = JS_EXTENSION_PATTERN.exec(path);
+    return match ? path.slice(0, -match[0].length) : null;
+}

package/dist/core/ingestion/import-resolvers/utils.js

@@ -8,8 +8,12 @@ export const EXTENSIONS = [
     // TypeScript/JavaScript
     '.tsx',
     '.ts',
+    '.mts',
+    '.cts',
     '.jsx',
     '.js',
+    '.mjs',
+    '.cjs',
     '.vue',
     '/index.tsx',
     '/index.ts',

package/dist/core/ingestion/languages/c/arity-metadata.d.ts

@@ -0,0 +1,14 @@
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+export interface CArityInfo {
+    parameterCount?: number;
+    requiredParameterCount?: number;
+    parameterTypes?: string[];
+}
+/**
+ * Compute declaration arity from a C function definition or declaration node.
+ */
+export declare function computeCDeclarationArity(node: SyntaxNode): CArityInfo;
+/**
+ * Compute call-site arity from a call_expression node.
+ */
+export declare function computeCCallArity(node: SyntaxNode): number;

package/dist/core/ingestion/languages/c/arity-metadata.js

@@ -0,0 +1,94 @@
+/**
+ * Compute declaration arity from a C function definition or declaration node.
+ */
+export function computeCDeclarationArity(node) {
+    // Find the function_declarator child (may be wrapped in pointer_declarator)
+    const funcDecl = findFuncDeclarator(node);
+    if (funcDecl === null)
+        return {};
+    const paramList = funcDecl.childForFieldName('parameters');
+    if (paramList === null)
+        return {};
+    const params = [];
+    for (let i = 0; i < paramList.childCount; i++) {
+        const child = paramList.child(i);
+        if (child === null)
+            continue;
+        if (child.type === 'parameter_declaration' || child.type === 'variadic_parameter') {
+            params.push(child);
+        }
+    }
+    // K&R old-style declaration: `int foo()` has an empty parameter_list with
+    // no parameter_declaration or variadic_parameter children. Per C89/C99,
+    // this means the function accepts an unspecified number/types of arguments —
+    // NOT zero arguments. Return unknown arity to avoid false 'incompatible'.
+    // `int foo(void)` is the explicit zero-parameter form and is handled below.
+    if (params.length === 0)
+        return {};
+    // (void) means zero parameters
+    if (params.length === 1 && params[0].type === 'parameter_declaration') {
+        const typeNode = params[0].childForFieldName('type');
+        const hasDeclarator = params[0].childForFieldName('declarator') !== null;
+        if (typeNode !== null && typeNode.text === 'void' && !hasDeclarator) {
+            return { parameterCount: 0, requiredParameterCount: 0, parameterTypes: [] };
+        }
+    }
+    const isVariadic = params.some((p) => p.type === 'variadic_parameter');
+    const nonVariadicCount = params.filter((p) => p.type !== 'variadic_parameter').length;
+    const types = [];
+    for (const p of params) {
+        if (p.type === 'variadic_parameter') {
+            types.push('...');
+        }
+        else {
+            const typeNode = p.childForFieldName('type');
+            types.push(typeNode?.text ?? 'unknown');
+        }
+    }
+    return {
+        parameterCount: isVariadic ? undefined : nonVariadicCount,
+        requiredParameterCount: nonVariadicCount,
+        parameterTypes: types,
+    };
+}
+/**
+ * Compute call-site arity from a call_expression node.
+ */
+export function computeCCallArity(node) {
+    const argList = node.childForFieldName('arguments');
+    if (argList === null)
+        return 0;
+    let count = 0;
+    for (let i = 0; i < argList.childCount; i++) {
+        const child = argList.child(i);
+        if (child === null)
+            continue;
+        // Skip punctuation (commas, parens)
+        if (child.type !== ',' && child.type !== '(' && child.type !== ')') {
+            count++;
+        }
+    }
+    return count;
+}
+function findFuncDeclarator(node) {
+    // Direct child
+    let decl = node.childForFieldName('declarator');
+    if (decl === null) {
+        for (let i = 0; i < node.childCount; i++) {
+            const c = node.child(i);
+            if (c?.type === 'function_declarator')
+                return c;
+        }
+        return null;
+    }
+    // Unwrap pointer_declarator
+    while (decl.type === 'pointer_declarator') {
+        const next = decl.childForFieldName('declarator');
+        if (next === null)
+            break;
+        decl = next;
+    }
+    if (decl.type === 'function_declarator')
+        return decl;
+    return null;
+}

package/dist/core/ingestion/languages/c/arity.d.ts

@@ -0,0 +1,6 @@
+import type { Callsite, SymbolDefinition } from '../../../../_shared/index.js';
+/**
+ * C arity compatibility: no overloading. Variadic functions detected
+ * via '...' in parameterTypes. Otherwise exact match or unknown.
+ */
+export declare function cArityCompatibility(def: SymbolDefinition, callsite: Callsite): 'compatible' | 'unknown' | 'incompatible';

package/dist/core/ingestion/languages/c/arity.js

@@ -0,0 +1,18 @@
+/**
+ * C arity compatibility: no overloading. Variadic functions detected
+ * via '...' in parameterTypes. Otherwise exact match or unknown.
+ */
+export function cArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    if (!Number.isFinite(callsite.arity) || callsite.arity < 0)
+        return 'unknown';
+    const variadic = def.parameterTypes?.some((t) => t === '...') ?? false;
+    if (min !== undefined && callsite.arity < min)
+        return 'incompatible';
+    if (max !== undefined && callsite.arity > max && !variadic)
+        return 'incompatible';
+    return 'compatible';
+}

package/dist/core/ingestion/languages/c/captures.d.ts

@@ -0,0 +1,2 @@
+import type { CaptureMatch } from '../../../../_shared/index.js';
+export declare function emitCScopeCaptures(sourceText: string, filePath: string, cachedTree?: unknown): readonly CaptureMatch[];

package/dist/core/ingestion/languages/c/captures.js

@@ -0,0 +1,105 @@
+import { findNodeAtRange, nodeToCapture, syntheticCapture, } from '../../utils/ast-helpers.js';
+import { getCParser, getCScopeQuery } from './query.js';
+import { getTreeSitterBufferSize } from '../../constants.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { splitCInclude } from './import-decomposer.js';
+import { computeCDeclarationArity, computeCCallArity } from './arity-metadata.js';
+import { markStaticName } from './static-linkage.js';
+export function emitCScopeCaptures(sourceText, filePath, cachedTree) {
+    let tree = cachedTree;
+    if (tree === undefined) {
+        tree = parseSourceSafe(getCParser(), sourceText, undefined, {
+            bufferSize: getTreeSitterBufferSize(sourceText),
+        });
+    }
+    const rawMatches = getCScopeQuery().matches(tree.rootNode);
+    const out = [];
+    // Track ranges where typedef-struct/union was captured as @declaration.struct/union
+    // so we can suppress the duplicate @declaration.typedef match at the same range.
+    const structTypedefRanges = new Set();
+    for (const m of rawMatches) {
+        const grouped = {};
+        for (const c of m.captures) {
+            const tag = '@' + c.name;
+            if (tag.startsWith('@_'))
+                continue;
+            grouped[tag] = nodeToCapture(tag, c.node);
+        }
+        if (Object.keys(grouped).length === 0)
+            continue;
+        // Handle #include statements
+        if (grouped['@import.statement'] !== undefined) {
+            const anchor = grouped['@import.statement'];
+            const includeNode = findNodeAtRange(tree.rootNode, anchor.range, 'preproc_include');
+            if (includeNode !== null) {
+                const split = splitCInclude(includeNode);
+                if (split !== null) {
+                    out.push(split);
+                    continue;
+                }
+            }
+        }
+        // Track typedef-struct ranges to suppress duplicate typedef declarations
+        const structAnchor = grouped['@declaration.struct'] ?? grouped['@declaration.union'];
+        if (structAnchor !== undefined) {
+            const r = structAnchor.range;
+            structTypedefRanges.add(`${r.startLine}:${r.startCol}:${r.endLine}:${r.endCol}`);
+        }
+        // Suppress @declaration.typedef if the same range was already captured as struct/union
+        const typedefAnchor = grouped['@declaration.typedef'];
+        if (typedefAnchor !== undefined) {
+            const r = typedefAnchor.range;
+            const key = `${r.startLine}:${r.startCol}:${r.endLine}:${r.endCol}`;
+            if (structTypedefRanges.has(key))
+                continue;
+        }
+        // Enrich function declarations with arity metadata and detect static linkage
+        const declAnchor = grouped['@declaration.function'];
+        if (declAnchor !== undefined) {
+            const fnNode = findNodeAtRange(tree.rootNode, declAnchor.range, 'function_definition') ??
+                findNodeAtRange(tree.rootNode, declAnchor.range, 'declaration');
+            if (fnNode !== null) {
+                const arity = computeCDeclarationArity(fnNode);
+                if (arity.parameterCount !== undefined) {
+                    grouped['@declaration.parameter-count'] = syntheticCapture('@declaration.parameter-count', fnNode, String(arity.parameterCount));
+                }
+                if (arity.requiredParameterCount !== undefined) {
+                    grouped['@declaration.required-parameter-count'] = syntheticCapture('@declaration.required-parameter-count', fnNode, String(arity.requiredParameterCount));
+                }
+                if (arity.parameterTypes !== undefined) {
+                    grouped['@declaration.parameter-types'] = syntheticCapture('@declaration.parameter-types', fnNode, JSON.stringify(arity.parameterTypes));
+                }
+                // Detect static storage class (file-local linkage)
+                if (hasStaticStorageClass(fnNode)) {
+                    const nameText = grouped['@declaration.name']?.text;
+                    if (nameText !== undefined) {
+                        markStaticName(filePath, nameText);
+                    }
+                }
+            }
+        }
+        // Enrich call references with arity
+        const callAnchor = grouped['@reference.call.free'] ?? grouped['@reference.call.member'];
+        if (callAnchor !== undefined && grouped['@reference.arity'] === undefined) {
+            const callNode = findNodeAtRange(tree.rootNode, callAnchor.range, 'call_expression');
+            if (callNode !== null) {
+                grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(computeCCallArity(callNode)));
+            }
+        }
+        out.push(grouped);
+    }
+    return out;
+}
+/**
+ * Check if a C function_definition or declaration has `static` storage class.
+ * Walks direct children for a `storage_class_specifier` node with text `static`.
+ */
+function hasStaticStorageClass(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child !== null && child.type === 'storage_class_specifier' && child.text === 'static') {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/core/ingestion/languages/c/header-scan.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Walk `repoPath` recursively and return relative paths of all `.h` files.
+ * Used by `loadResolutionConfig` so the C resolver can resolve `#include`
+ * targets that live in `.h` files (classified as C++ by language detection
+ * but importable from `.c` files).
+ */
+export declare function scanHeaderFiles(repoPath: string): ReadonlySet<string>;