@codragraph/cli 1.6.2

package/dist/core/ingestion/languages/swift.js

@@ -0,0 +1,244 @@
+/**
+ * Swift Language Provider
+ *
+ * Assembles all Swift-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Swift traits:
+ *   - importSemantics: 'wildcard-leaf' (Swift imports entire modules)
+ *   - heritageDefaultEdge: 'IMPLEMENTS' (protocols are more common than class inheritance)
+ *   - implicitImportWirer: all files in the same SPM target see each other
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
+import { swiftClassConfig } from '../class-extractors/configs/swift.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as swiftConfig } from '../type-extractors/swift.js';
+import { swiftExportChecker } from '../export-detection.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { swiftImportConfig } from '../import-resolvers/configs/swift.js';
+import { SWIFT_QUERIES } from '../tree-sitter-queries.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { swiftConfig as swiftFieldConfig } from '../field-extractors/configs/swift.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { swiftMethodConfig } from '../method-extractors/configs/swift.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { swiftVariableConfig } from '../variable-extractors/configs/swift.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { swiftCallConfig } from '../call-extractors/configs/swift.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+/**
+ * Group Swift files by SPM target for implicit module visibility.
+ * If SwiftPackageConfig is available, use target -> directory mappings.
+ * Otherwise, group all Swift files under a single "default" target
+ * (assumes a single-module Xcode project).
+ */
+function groupSwiftFilesByTarget(swiftFiles, swiftPackageConfig) {
+    // No SPM config -> single target (common for Xcode projects)
+    if (!swiftPackageConfig || swiftPackageConfig.targets.size === 0) {
+        return new Map([['__default__', swiftFiles]]);
+    }
+    // Pre-convert target dirs to normalized prefix format once
+    const targets = [...swiftPackageConfig.targets.entries()].map(([name, dir]) => ({
+        name,
+        prefix: dir.replace(/\\/g, '/') + '/',
+    }));
+    const groups = new Map();
+    const defaultGroup = [];
+    for (const file of swiftFiles) {
+        const normalized = file.includes('\\') ? file.replace(/\\/g, '/') : file;
+        let assigned = false;
+        for (const { name, prefix } of targets) {
+            const idx = normalized.indexOf(prefix);
+            if (idx === 0 || (idx > 0 && normalized[idx - 1] === '/')) {
+                let group = groups.get(name);
+                if (!group) {
+                    group = [];
+                    groups.set(name, group);
+                }
+                group.push(file);
+                assigned = true;
+                break;
+            }
+        }
+        if (!assigned)
+            defaultGroup.push(file);
+    }
+    if (defaultGroup.length > 0)
+        groups.set('__default__', defaultGroup);
+    return groups;
+}
+/**
+ * Wire implicit inter-file imports for Swift.
+ * All files in the same SPM target see each other (full module visibility).
+ * Two fast paths avoid unnecessary work:
+ *   1. No existing imports for src -> emit all (m-1) edges without Set.has checks
+ *   2. Existing imports present -> skip already-connected pairs
+ */
+function wireSwiftImplicitImports(swiftFiles, importMap, addImportEdge, projectConfig) {
+    const configs = projectConfig;
+    const targetGroups = groupSwiftFilesByTarget(swiftFiles, configs?.swiftPackageConfig ?? null);
+    for (const group of targetGroups.values()) {
+        const m = group.length;
+        if (m <= 1)
+            continue;
+        // All-pairs implicit edges: O(m²) is inherent for full module visibility.
+        for (let i = 0; i < m; i++) {
+            const src = group[i];
+            const existing = importMap.get(src);
+            if (!existing || existing.size === 0) {
+                // Fast path: no prior imports — emit all peers unconditionally
+                for (let j = 0; j < m; j++) {
+                    if (i !== j)
+                        addImportEdge(src, group[j]);
+                }
+            }
+            else {
+                // Dedup path: skip already-connected pairs
+                for (let j = 0; j < m; j++) {
+                    if (i !== j && !existing.has(group[j])) {
+                        addImportEdge(src, group[j]);
+                    }
+                }
+            }
+        }
+    }
+}
+/** Swift init/deinit declarations have special names and Constructor label. */
+const swiftExtractFunctionName = (node) => {
+    if (node.type === 'init_declaration')
+        return { funcName: 'init', label: 'Constructor' };
+    if (node.type === 'deinit_declaration')
+        return { funcName: 'deinit', label: 'Constructor' };
+    return null; // fall through to generic
+};
+const BUILT_INS = new Set([
+    'print',
+    'debugPrint',
+    'dump',
+    'fatalError',
+    'precondition',
+    'preconditionFailure',
+    'assert',
+    'assertionFailure',
+    'NSLog',
+    'abs',
+    'min',
+    'max',
+    'zip',
+    'stride',
+    'sequence',
+    'repeatElement',
+    'swap',
+    'withUnsafePointer',
+    'withUnsafeMutablePointer',
+    'withUnsafeBytes',
+    'autoreleasepool',
+    'unsafeBitCast',
+    'unsafeDowncast',
+    'numericCast',
+    'type',
+    'MemoryLayout',
+    'map',
+    'flatMap',
+    'compactMap',
+    'filter',
+    'reduce',
+    'forEach',
+    'contains',
+    'first',
+    'last',
+    'prefix',
+    'suffix',
+    'dropFirst',
+    'dropLast',
+    'sorted',
+    'reversed',
+    'enumerated',
+    'joined',
+    'split',
+    'append',
+    'insert',
+    'remove',
+    'removeAll',
+    'removeFirst',
+    'removeLast',
+    'isEmpty',
+    'count',
+    'index',
+    'startIndex',
+    'endIndex',
+    'addSubview',
+    'removeFromSuperview',
+    'layoutSubviews',
+    'setNeedsLayout',
+    'layoutIfNeeded',
+    'setNeedsDisplay',
+    'invalidateIntrinsicContentSize',
+    'addTarget',
+    'removeTarget',
+    'addGestureRecognizer',
+    'addConstraint',
+    'addConstraints',
+    'removeConstraint',
+    'removeConstraints',
+    'NSLocalizedString',
+    'Bundle',
+    'reloadData',
+    'reloadSections',
+    'reloadRows',
+    'performBatchUpdates',
+    'register',
+    'dequeueReusableCell',
+    'dequeueReusableSupplementaryView',
+    'beginUpdates',
+    'endUpdates',
+    'insertRows',
+    'deleteRows',
+    'insertSections',
+    'deleteSections',
+    'present',
+    'dismiss',
+    'pushViewController',
+    'popViewController',
+    'popToRootViewController',
+    'performSegue',
+    'prepare',
+    'DispatchQueue',
+    'async',
+    'sync',
+    'asyncAfter',
+    'Task',
+    'withCheckedContinuation',
+    'withCheckedThrowingContinuation',
+    'sink',
+    'store',
+    'assign',
+    'receive',
+    'subscribe',
+    'addObserver',
+    'removeObserver',
+    'post',
+    'NotificationCenter',
+]);
+export const swiftProvider = defineLanguage({
+    id: SupportedLanguages.Swift,
+    extensions: ['.swift'],
+    treeSitterQueries: SWIFT_QUERIES,
+    typeConfig: swiftConfig,
+    exportChecker: swiftExportChecker,
+    importResolver: createImportResolver(swiftImportConfig),
+    importSemantics: 'wildcard-leaf',
+    heritageDefaultEdge: 'IMPLEMENTS',
+    callExtractor: createCallExtractor(swiftCallConfig),
+    fieldExtractor: createFieldExtractor(swiftFieldConfig),
+    methodExtractor: createMethodExtractor({
+        ...swiftMethodConfig,
+        extractFunctionName: swiftExtractFunctionName,
+    }),
+    variableExtractor: createVariableExtractor(swiftVariableConfig),
+    classExtractor: createClassExtractor(swiftClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Swift),
+    implicitImportWirer: wireSwiftImplicitImports,
+    builtInNames: BUILT_INS,
+});

package/dist/core/ingestion/languages/typescript.d.ts

@@ -0,0 +1,11 @@
+/**
+ * TypeScript and JavaScript language providers.
+ *
+ * Both languages share the same type extraction config (typescriptConfig),
+ * export checker (tsExportChecker), and named binding extractor
+ * (extractTsNamedBindings). They differ in file extensions, tree-sitter
+ * queries (TypeScript grammar has interface/type nodes), and language ID.
+ */
+export declare const BUILT_INS: ReadonlySet<string>;
+export declare const typescriptProvider: import("../language-provider.js").LanguageProvider;
+export declare const javascriptProvider: import("../language-provider.js").LanguageProvider;

package/dist/core/ingestion/languages/typescript.js

@@ -0,0 +1,184 @@
+/**
+ * TypeScript and JavaScript language providers.
+ *
+ * Both languages share the same type extraction config (typescriptConfig),
+ * export checker (tsExportChecker), and named binding extractor
+ * (extractTsNamedBindings). They differ in file extensions, tree-sitter
+ * queries (TypeScript grammar has interface/type nodes), and language ID.
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { defineLanguage } from '../language-provider.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
+import { typescriptClassConfig, javascriptClassConfig, } from '../class-extractors/configs/typescript-javascript.js';
+import { typeConfig as typescriptConfig } from '../type-extractors/typescript.js';
+import { tsExportChecker } from '../export-detection.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { typescriptImportConfig, javascriptImportConfig, } from '../import-resolvers/configs/typescript-javascript.js';
+import { extractTsNamedBindings } from '../named-bindings/typescript.js';
+import { TYPESCRIPT_QUERIES, JAVASCRIPT_QUERIES } from '../tree-sitter-queries.js';
+import { typescriptFieldExtractor } from '../field-extractors/typescript.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { javascriptConfig } from '../field-extractors/configs/typescript-javascript.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { typescriptMethodConfig, javascriptMethodConfig, } from '../method-extractors/configs/typescript-javascript.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { typescriptVariableConfig, javascriptVariableConfig, } from '../variable-extractors/configs/typescript-javascript.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { typescriptCallConfig, javascriptCallConfig, } from '../call-extractors/configs/typescript-javascript.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+/**
+ * TypeScript/JavaScript: arrow_function and function_expression get their name
+ * from the parent variable_declarator (e.g. `const foo = () => {}`).
+ */
+const tsExtractFunctionName = (node) => {
+    if (node.type !== 'arrow_function' && node.type !== 'function_expression')
+        return null;
+    const parent = node.parent;
+    if (parent?.type !== 'variable_declarator')
+        return null;
+    let nameNode = parent.childForFieldName?.('name');
+    if (!nameNode) {
+        for (let i = 0; i < parent.childCount; i++) {
+            const c = parent.child(i);
+            if (c?.type === 'identifier') {
+                nameNode = c;
+                break;
+            }
+        }
+    }
+    return { funcName: nameNode?.text ?? null, label: 'Function' };
+};
+export const BUILT_INS = new Set([
+    'console',
+    'log',
+    'warn',
+    'error',
+    'info',
+    'debug',
+    'setTimeout',
+    'setInterval',
+    'clearTimeout',
+    'clearInterval',
+    'parseInt',
+    'parseFloat',
+    'isNaN',
+    'isFinite',
+    'encodeURI',
+    'decodeURI',
+    'encodeURIComponent',
+    'decodeURIComponent',
+    'JSON',
+    'parse',
+    'stringify',
+    'Object',
+    'Array',
+    'String',
+    'Number',
+    'Boolean',
+    'Symbol',
+    'BigInt',
+    'Map',
+    'Set',
+    'WeakMap',
+    'WeakSet',
+    'Promise',
+    'resolve',
+    'reject',
+    'then',
+    'catch',
+    'finally',
+    'Math',
+    'Date',
+    'RegExp',
+    'Error',
+    'require',
+    'import',
+    'export',
+    'fetch',
+    'Response',
+    'Request',
+    'useState',
+    'useEffect',
+    'useCallback',
+    'useMemo',
+    'useRef',
+    'useContext',
+    'useReducer',
+    'useLayoutEffect',
+    'useImperativeHandle',
+    'useDebugValue',
+    'createElement',
+    'createContext',
+    'createRef',
+    'forwardRef',
+    'memo',
+    'lazy',
+    'map',
+    'filter',
+    'reduce',
+    'forEach',
+    'find',
+    'findIndex',
+    'some',
+    'every',
+    'includes',
+    'indexOf',
+    'slice',
+    'splice',
+    'concat',
+    'join',
+    'split',
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'sort',
+    'reverse',
+    'keys',
+    'values',
+    'entries',
+    'assign',
+    'freeze',
+    'seal',
+    'hasOwnProperty',
+    'toString',
+    'valueOf',
+]);
+export const typescriptProvider = defineLanguage({
+    id: SupportedLanguages.TypeScript,
+    extensions: ['.ts', '.tsx'],
+    treeSitterQueries: TYPESCRIPT_QUERIES,
+    typeConfig: typescriptConfig,
+    exportChecker: tsExportChecker,
+    importResolver: createImportResolver(typescriptImportConfig),
+    namedBindingExtractor: extractTsNamedBindings,
+    callExtractor: createCallExtractor(typescriptCallConfig),
+    fieldExtractor: typescriptFieldExtractor,
+    methodExtractor: createMethodExtractor({
+        ...typescriptMethodConfig,
+        extractFunctionName: tsExtractFunctionName,
+    }),
+    variableExtractor: createVariableExtractor(typescriptVariableConfig),
+    classExtractor: createClassExtractor(typescriptClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.TypeScript),
+    builtInNames: BUILT_INS,
+});
+export const javascriptProvider = defineLanguage({
+    id: SupportedLanguages.JavaScript,
+    extensions: ['.js', '.jsx'],
+    treeSitterQueries: JAVASCRIPT_QUERIES,
+    typeConfig: typescriptConfig,
+    exportChecker: tsExportChecker,
+    importResolver: createImportResolver(javascriptImportConfig),
+    namedBindingExtractor: extractTsNamedBindings,
+    callExtractor: createCallExtractor(javascriptCallConfig),
+    fieldExtractor: createFieldExtractor(javascriptConfig),
+    methodExtractor: createMethodExtractor({
+        ...javascriptMethodConfig,
+        extractFunctionName: tsExtractFunctionName,
+    }),
+    variableExtractor: createVariableExtractor(javascriptVariableConfig),
+    classExtractor: createClassExtractor(javascriptClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.JavaScript),
+    builtInNames: BUILT_INS,
+});

package/dist/core/ingestion/languages/vue.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Vue language provider.
+ *
+ * Vue SFCs are preprocessed by extracting the <script> / <script setup>
+ * block content, which is then parsed as TypeScript. This provider reuses
+ * nearly all TypeScript infrastructure — queries, type config, field
+ * extraction, and named binding extraction.
+ *
+ * Export detection for <script setup> is handled directly in the parse
+ * worker (all top-level bindings are implicitly exported). The export
+ * checker here is used as fallback for non-setup <script> blocks.
+ */
+export declare const vueProvider: import("../language-provider.js").LanguageProvider;

package/dist/core/ingestion/languages/vue.js

@@ -0,0 +1,77 @@
+/**
+ * Vue language provider.
+ *
+ * Vue SFCs are preprocessed by extracting the <script> / <script setup>
+ * block content, which is then parsed as TypeScript. This provider reuses
+ * nearly all TypeScript infrastructure — queries, type config, field
+ * extraction, and named binding extraction.
+ *
+ * Export detection for <script setup> is handled directly in the parse
+ * worker (all top-level bindings are implicitly exported). The export
+ * checker here is used as fallback for non-setup <script> blocks.
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
+import { vueClassConfig } from '../class-extractors/configs/typescript-javascript.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as typescriptConfig } from '../type-extractors/typescript.js';
+import { tsExportChecker } from '../export-detection.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { vueImportConfig } from '../import-resolvers/configs/typescript-javascript.js';
+import { extractTsNamedBindings } from '../named-bindings/typescript.js';
+import { TYPESCRIPT_QUERIES } from '../tree-sitter-queries.js';
+import { typescriptFieldExtractor } from '../field-extractors/typescript.js';
+import { BUILT_INS as TS_BUILT_INS } from './typescript.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { typescriptVariableConfig } from '../variable-extractors/configs/typescript-javascript.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { typescriptCallConfig } from '../call-extractors/configs/typescript-javascript.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+const VUE_SPECIFIC_BUILT_INS = [
+    'ref',
+    'reactive',
+    'computed',
+    'watch',
+    'watchEffect',
+    'onMounted',
+    'onUnmounted',
+    'onBeforeMount',
+    'onBeforeUnmount',
+    'onUpdated',
+    'onBeforeUpdate',
+    'nextTick',
+    'defineProps',
+    'defineEmits',
+    'defineExpose',
+    'defineOptions',
+    'defineSlots',
+    'defineModel',
+    'withDefaults',
+    'toRef',
+    'toRefs',
+    'unref',
+    'isRef',
+    'shallowRef',
+    'triggerRef',
+    'provide',
+    'inject',
+    'useSlots',
+    'useAttrs',
+];
+const VUE_BUILT_INS = new Set([...TS_BUILT_INS, ...VUE_SPECIFIC_BUILT_INS]);
+const vueClassExtractor = createClassExtractor(vueClassConfig);
+export const vueProvider = defineLanguage({
+    id: SupportedLanguages.Vue,
+    extensions: ['.vue'],
+    treeSitterQueries: TYPESCRIPT_QUERIES,
+    typeConfig: typescriptConfig,
+    exportChecker: tsExportChecker,
+    importResolver: createImportResolver(vueImportConfig),
+    namedBindingExtractor: extractTsNamedBindings,
+    callExtractor: createCallExtractor(typescriptCallConfig),
+    fieldExtractor: typescriptFieldExtractor,
+    variableExtractor: createVariableExtractor(typescriptVariableConfig),
+    classExtractor: vueClassExtractor,
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.TypeScript),
+    builtInNames: VUE_BUILT_INS,
+});

package/dist/core/ingestion/markdown-processor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Markdown Processor
+ *
+ * Extracts structure from .md files using regex (no tree-sitter dependency).
+ * Creates Section nodes for headings with hierarchy, and IMPORTS edges for
+ * cross-file links.
+ */
+import { KnowledgeGraph } from '../graph/types.js';
+interface MdFile {
+    path: string;
+    content: string;
+}
+export declare const processMarkdown: (graph: KnowledgeGraph, files: MdFile[], allPathSet: ReadonlySet<string>) => {
+    sections: number;
+    links: number;
+};
+export {};

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

@@ -0,0 +1,124 @@
+/**
+ * Markdown Processor
+ *
+ * Extracts structure from .md files using regex (no tree-sitter dependency).
+ * Creates Section nodes for headings with hierarchy, and IMPORTS edges for
+ * cross-file links.
+ */
+import path from 'node:path';
+import { generateId } from '../../lib/utils.js';
+const HEADING_RE = /^(#{1,6})\s+(.+)$/;
+const LINK_RE = /\[([^\]]*)\]\(([^)]+)\)/g;
+const MD_EXTENSIONS = new Set(['.md', '.mdx']);
+export const processMarkdown = (graph, files, allPathSet) => {
+    let totalSections = 0;
+    let totalLinks = 0;
+    for (const file of files) {
+        const ext = path.extname(file.path).toLowerCase();
+        if (!MD_EXTENSIONS.has(ext))
+            continue;
+        const fileNodeId = generateId('File', file.path);
+        // Skip if file node doesn't exist (shouldn't happen, structure-processor creates it)
+        if (!graph.getNode(fileNodeId))
+            continue;
+        const lines = file.content.split('\n');
+        // --- Extract headings and build hierarchy ---
+        // First pass: collect all heading positions so we can compute endLine spans
+        const headings = [];
+        for (let i = 0; i < lines.length; i++) {
+            const match = lines[i].match(HEADING_RE);
+            if (!match)
+                continue;
+            headings.push({
+                level: match[1].length,
+                heading: match[2].trim(),
+                lineNum: i + 1, // 1-indexed
+            });
+        }
+        // Second pass: create nodes with proper endLine spans
+        const sectionStack = [];
+        for (let h = 0; h < headings.length; h++) {
+            const { level, heading, lineNum } = headings[h];
+            // endLine = line before next heading at same or higher level, or EOF
+            let endLine = lines.length;
+            for (let j = h + 1; j < headings.length; j++) {
+                if (headings[j].level <= level) {
+                    endLine = headings[j].lineNum - 1;
+                    break;
+                }
+            }
+            const sectionId = generateId('Section', `${file.path}:L${lineNum}:${heading}`);
+            const node = {
+                id: sectionId,
+                label: 'Section',
+                properties: {
+                    name: heading,
+                    filePath: file.path,
+                    startLine: lineNum,
+                    endLine,
+                    level,
+                    description: `h${level}`,
+                },
+            };
+            graph.addNode(node);
+            totalSections++;
+            // Find parent: pop stack until we find a level strictly less than current
+            while (sectionStack.length > 0 && sectionStack[sectionStack.length - 1].level >= level) {
+                sectionStack.pop();
+            }
+            const parentId = sectionStack.length > 0 ? sectionStack[sectionStack.length - 1].id : fileNodeId;
+            graph.addRelationship({
+                id: generateId('CONTAINS', `${parentId}->${sectionId}`),
+                type: 'CONTAINS',
+                sourceId: parentId,
+                targetId: sectionId,
+                confidence: 1.0,
+                reason: 'markdown-heading',
+            });
+            sectionStack.push({ level, id: sectionId });
+        }
+        // --- Extract links to other files in the repo ---
+        const fileDir = path.dirname(file.path);
+        const seenLinks = new Set();
+        let linkMatch;
+        LINK_RE.lastIndex = 0;
+        while ((linkMatch = LINK_RE.exec(file.content)) !== null) {
+            const href = linkMatch[2];
+            // Skip external URLs, anchors, and mailto
+            if (href.startsWith('http://') ||
+                href.startsWith('https://') ||
+                href.startsWith('#') ||
+                href.startsWith('mailto:')) {
+                continue;
+            }
+            // Strip anchor fragments from local links
+            const cleanHref = href.split('#')[0];
+            if (!cleanHref)
+                continue;
+            // Resolve relative to the file's directory, then normalize
+            const resolved = path.posix.normalize(path.posix.join(fileDir, cleanHref));
+            if (allPathSet.has(resolved)) {
+                const targetFileId = generateId('File', resolved);
+                // Skip if target file node doesn't exist
+                if (!graph.getNode(targetFileId))
+                    continue;
+                // Dedup: skip if we've already linked this file pair
+                const linkKey = `${fileNodeId}->${targetFileId}`;
+                if (seenLinks.has(linkKey))
+                    continue;
+                seenLinks.add(linkKey);
+                const relId = generateId('IMPORTS', linkKey);
+                graph.addRelationship({
+                    id: relId,
+                    type: 'IMPORTS',
+                    sourceId: fileNodeId,
+                    targetId: targetFileId,
+                    confidence: 0.8,
+                    reason: 'markdown-link',
+                });
+                totalLinks++;
+            }
+        }
+    }
+    return { sections: totalSections, links: totalLinks };
+};

package/dist/core/ingestion/method-extractors/configs/c-cpp.d.ts

@@ -0,0 +1,3 @@
+import type { MethodExtractionConfig } from '../../method-types.js';
+export declare const cppMethodConfig: MethodExtractionConfig;
+export declare const cMethodConfig: MethodExtractionConfig;