@kentwynn/kgraph 0.1.11 → 0.1.12

package/README.md

@@ -149,12 +149,12 @@ kgraph integrate add codex copilot cursor claude-code
 kgraph integrate list
 ```
 
-| Tool           | Always-on instruction             | Skills / commands                                                   |
-| -------------- | --------------------------------- | ------------------------------------------------------------------- |
-| GitHub Copilot | `.github/copilot-instructions.md` | `/kgraph-scan` · `/kgraph-update` · `/kgraph-visualize`             |
-| Codex          | `AGENTS.md`                       | `.agents/skills/kgraph/SKILL.md` (VS Code Agent Skills standard)    |
-| Cursor         | `.cursor/rules/kgraph.mdc`        | Built into the rule                                                 |
-| Claude Code    | `CLAUDE.md`                       | `/kgraph` · `/kgraph-scan` · `/kgraph-update` · `/kgraph-visualize` |
+| Tool           | Always-on instruction             | Skills / commands                                                                               |
+| -------------- | --------------------------------- | ----------------------------------------------------------------------------------------------- |
+| GitHub Copilot | `.github/copilot-instructions.md` | `/kgraph-scan` · `/kgraph-update` · `/kgraph-visualize` · `/kgraph-history` · `/kgraph-capture` |
+| Codex          | `AGENTS.md`                       | `.agents/skills/kgraph/SKILL.md` (VS Code Agent Skills standard)                                |
+| Cursor         | `.cursor/rules/kgraph.mdc`        | Built into the rule                                                                             |
+| Claude Code    | `CLAUDE.md`                       | `/kgraph` · `/kgraph-scan` · `/kgraph-update` · `/kgraph-visualize` · `/kgraph-history`         |
 
 Each integration installs a `/kgraph` skill or command that handles the full workflow automatically: load context → work → capture findings → update cognition. `/kgraph-scan`, `/kgraph-update`, and `/kgraph-visualize` are available for manual maintenance.
 
@@ -198,7 +198,9 @@ kgraph history --json                           # machine-readable output
 | **Relationships** | call sites, re-exports, shared types                                   |
 | **Cognition**     | past decisions, architectural constraints, debugging insights, gotchas |
 
-Supported languages: TypeScript, JavaScript, Python, Go, Rust, Java, Kotlin, C/C++, C#, Ruby, PHP, Swift, and 30+ more — detected by file extension, no configuration needed.
+**Deep scan** (symbols, functions, classes, methods, imports): TypeScript, JavaScript, Python, Go, Rust, Java, Kotlin, C, C++, C#
+
+**Generic scan** (file path, language, size — contributes to context): Ruby, PHP, Swift, Shell, HTML, CSS, SQL, YAML, TOML, and 20+ more — detected by file extension, no configuration needed.
 
 ---
 

package/dist/config/config.js

@@ -35,7 +35,35 @@ export const DEFAULT_CONFIG = {
         '.DS_Store',
     ],
     languages: {
-        precise: ['.js', '.jsx', '.ts', '.tsx'],
+        precise: [
+            // JavaScript / TypeScript
+            '.js',
+            '.jsx',
+            '.ts',
+            '.tsx',
+            // Python
+            '.py',
+            '.pyw',
+            '.pyi',
+            // Go
+            '.go',
+            // Rust
+            '.rs',
+            // Java / Kotlin
+            '.java',
+            '.kt',
+            '.kts',
+            // C / C++
+            '.c',
+            '.h',
+            '.cpp',
+            '.cc',
+            '.cxx',
+            '.hpp',
+            '.hxx',
+            // C#
+            '.cs',
+        ],
     },
     maxContextItems: 8,
     domainHints: {},

package/dist/context/ranking.js

@@ -14,11 +14,14 @@ export function rankByFields(query, items, fields) {
         for (const field of fields) {
             const value = field.value(item);
             const values = Array.isArray(value) ? value : value ? [value] : [];
-            const haystack = values.join(" ").toLowerCase();
+            const haystack = values.join(' ').toLowerCase();
             for (const token of tokens) {
                 if (haystack.includes(token)) {
-                    score += field.name === "path" || field.name === "name" ? 3 : 1;
-                    reasons.push(`${field.name} matched "${token}"`);
+                    const baseScore = field.name === 'path' || field.name === 'name' ? 3 : 1;
+                    const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                    const wordBoundary = new RegExp(`\\b${escaped}\\b`).test(haystack);
+                    score += baseScore + (wordBoundary ? 2 : 0);
+                    reasons.push(`${field.name} matched "${token}"${wordBoundary ? ' (exact)' : ''}`);
                 }
             }
         }

package/dist/scanner/c-symbol-extractor.d.ts

@@ -0,0 +1,2 @@
+import type { SymbolExtractionResult } from './ts-symbol-extractor.js';
+export declare function extractCSymbols(sourceText: string, filePath: string): SymbolExtractionResult;

package/dist/scanner/c-symbol-extractor.js

@@ -0,0 +1,96 @@
+// Handles C (.c, .h) and C++ (.cpp, .cc, .cxx, .hpp, .hxx)
+export function extractCSymbols(sourceText, filePath) {
+    const lines = sourceText.split('\n');
+    const symbols = [];
+    const dependencies = [];
+    const relationships = [];
+    const warnings = [];
+    const typeStack = [];
+    let braceDepth = 0;
+    const addSymbol = (name, kind, lineNum, parentName) => {
+        const id = [filePath, kind, parentName, name, lineNum]
+            .filter(Boolean)
+            .join('#');
+        symbols.push({
+            id,
+            name,
+            kind,
+            filePath,
+            startLine: lineNum,
+            endLine: lineNum,
+            exported: false,
+            parentName,
+        });
+        relationships.push({
+            sourceType: 'file',
+            sourceId: filePath,
+            targetType: 'symbol',
+            targetId: id,
+            relationshipType: 'contains',
+            confidence: 'high',
+        });
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNum = i + 1;
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('*'))
+            continue;
+        braceDepth +=
+            (line.match(/\{/g) ?? []).length - (line.match(/\}/g) ?? []).length;
+        while (typeStack.length > 0 &&
+            braceDepth < typeStack[typeStack.length - 1].braceDepth) {
+            typeStack.pop();
+        }
+        // #include <...> or #include "..."
+        const includeMatch = trimmed.match(/^#include\s+[<"]([^>"]+)[>"]/);
+        if (includeMatch) {
+            const specifier = includeMatch[1];
+            const kind = trimmed.includes('"') ? 'local' : 'package';
+            dependencies.push({ fromFile: filePath, specifier, kind });
+            relationships.push({
+                sourceType: 'file',
+                sourceId: filePath,
+                targetType: kind === 'local' ? 'file' : 'package',
+                targetId: specifier,
+                relationshipType: 'import',
+                confidence: 'high',
+            });
+            continue;
+        }
+        // class / struct (C++ with body — has name before {)
+        const classMatch = trimmed.match(/\b(?:class|struct)\s+(\w+)\s*(?::[^{]*)?\s*\{/);
+        if (classMatch) {
+            addSymbol(classMatch[1], 'class', lineNum, typeStack[typeStack.length - 1]?.name);
+            typeStack.push({ name: classMatch[1], braceDepth });
+            continue;
+        }
+        // Function definition: returnType funcName( — must have ( and no ; on same line
+        // Exclude preprocessor, declarations without body
+        if (!trimmed.endsWith(';') && !trimmed.startsWith('#')) {
+            const funcMatch = trimmed.match(/\b(\w+)\s*\((?:[^)]*)?\)\s*(?:const\s*)?(?:noexcept\s*)?(?:override\s*)?(?:final\s*)?\{?$/);
+            // Filter out common false positives: if/for/while/switch/catch/else
+            const CONTROL_FLOW = new Set([
+                'if',
+                'for',
+                'while',
+                'switch',
+                'catch',
+                'else',
+                'return',
+                'sizeof',
+                'typeof',
+            ]);
+            if (funcMatch &&
+                !CONTROL_FLOW.has(funcMatch[1]) &&
+                funcMatch[1] !== 'class' &&
+                funcMatch[1] !== 'struct') {
+                const parent = typeStack[typeStack.length - 1];
+                const kind = parent ? 'method' : 'function';
+                addSymbol(funcMatch[1], kind, lineNum, parent?.name);
+                continue;
+            }
+        }
+    }
+    return { symbols, dependencies, relationships, warnings };
+}

package/dist/scanner/csharp-symbol-extractor.d.ts

@@ -0,0 +1,2 @@
+import type { SymbolExtractionResult } from './ts-symbol-extractor.js';
+export declare function extractCSharpSymbols(sourceText: string, filePath: string): SymbolExtractionResult;

package/dist/scanner/csharp-symbol-extractor.js

@@ -0,0 +1,96 @@
+export function extractCSharpSymbols(sourceText, filePath) {
+    const lines = sourceText.split('\n');
+    const symbols = [];
+    const dependencies = [];
+    const relationships = [];
+    const warnings = [];
+    const typeStack = [];
+    let braceDepth = 0;
+    const addSymbol = (name, kind, lineNum, exported, parentName) => {
+        const id = [filePath, kind, parentName, name, lineNum]
+            .filter(Boolean)
+            .join('#');
+        symbols.push({
+            id,
+            name,
+            kind,
+            filePath,
+            startLine: lineNum,
+            endLine: lineNum,
+            exported,
+            parentName,
+        });
+        relationships.push({
+            sourceType: 'file',
+            sourceId: filePath,
+            targetType: 'symbol',
+            targetId: id,
+            relationshipType: 'contains',
+            confidence: 'high',
+        });
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNum = i + 1;
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('*'))
+            continue;
+        braceDepth +=
+            (line.match(/\{/g) ?? []).length - (line.match(/\}/g) ?? []).length;
+        while (typeStack.length > 0 &&
+            braceDepth < typeStack[typeStack.length - 1].braceDepth) {
+            typeStack.pop();
+        }
+        // using statement
+        const usingMatch = trimmed.match(/^using\s+([\w.]+)\s*;/);
+        if (usingMatch) {
+            const specifier = usingMatch[1];
+            dependencies.push({ fromFile: filePath, specifier, kind: 'package' });
+            relationships.push({
+                sourceType: 'file',
+                sourceId: filePath,
+                targetType: 'package',
+                targetId: specifier,
+                relationshipType: 'import',
+                confidence: 'high',
+            });
+            continue;
+        }
+        // class / interface / struct / enum / record
+        const typeMatch = trimmed.match(/\b(?:public|private|protected|internal|static|abstract|sealed|partial|readonly)?\s*(?:public|private|protected|internal|static|abstract|sealed|partial|readonly)?\s*(?:class|interface|struct|enum|record)\s+(\w+)/);
+        if (typeMatch && typeMatch[1]) {
+            const parent = typeStack[typeStack.length - 1];
+            const exported = trimmed.includes('public') || trimmed.includes('internal');
+            addSymbol(typeMatch[1], 'class', lineNum, exported, parent?.name);
+            typeStack.push({ name: typeMatch[1], braceDepth });
+            continue;
+        }
+        // method: visibility [modifiers] returnType MethodName(
+        // Must have parens, no semicolon (not a field), not a control-flow keyword
+        const CONTROL_FLOW = new Set([
+            'if',
+            'for',
+            'foreach',
+            'while',
+            'switch',
+            'catch',
+            'else',
+            'using',
+            'lock',
+            'return',
+        ]);
+        if (!trimmed.endsWith(';')) {
+            // Strip generic type parameters (e.g. Task<string> → Task) before matching method name
+            const normalizedForMethod = trimmed.replace(/<[^>]*>/g, '');
+            const methodMatch = normalizedForMethod.match(/\b(?:public|private|protected|internal|static|virtual|override|abstract|async|new|sealed)[\w\s]*\s+(\w+)\s*\(/);
+            if (methodMatch && !CONTROL_FLOW.has(methodMatch[1])) {
+                const parent = typeStack[typeStack.length - 1];
+                const exported = trimmed.includes('public') || trimmed.includes('internal');
+                const kind = parent ? 'method' : 'function';
+                addSymbol(methodMatch[1], kind, lineNum, exported, parent?.name);
+                continue;
+            }
+        }
+    }
+    return { symbols, dependencies, relationships, warnings };
+}

package/dist/scanner/go-symbol-extractor.d.ts

@@ -0,0 +1,2 @@
+import type { SymbolExtractionResult } from './ts-symbol-extractor.js';
+export declare function extractGoSymbols(sourceText: string, filePath: string): SymbolExtractionResult;

package/dist/scanner/go-symbol-extractor.js

@@ -0,0 +1,98 @@
+export function extractGoSymbols(sourceText, filePath) {
+    const lines = sourceText.split('\n');
+    const symbols = [];
+    const dependencies = [];
+    const relationships = [];
+    const warnings = [];
+    const addSymbol = (name, kind, lineNum, parentName) => {
+        const id = [filePath, kind, parentName, name, lineNum]
+            .filter(Boolean)
+            .join('#');
+        symbols.push({
+            id,
+            name,
+            kind,
+            filePath,
+            startLine: lineNum,
+            endLine: lineNum,
+            exported: /^[A-Z]/.test(name), // Go: exported = starts with uppercase
+            parentName,
+        });
+        relationships.push({
+            sourceType: 'file',
+            sourceId: filePath,
+            targetType: 'symbol',
+            targetId: id,
+            relationshipType: 'contains',
+            confidence: 'high',
+        });
+    };
+    let inImportBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNum = i + 1;
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('//'))
+            continue;
+        // import block: import ( ... )
+        if (trimmed === 'import (') {
+            inImportBlock = true;
+            continue;
+        }
+        if (inImportBlock) {
+            if (trimmed === ')') {
+                inImportBlock = false;
+                continue;
+            }
+            // e.g. "fmt" or aliased: log "log/slog"
+            const specMatch = trimmed.match(/"([^"]+)"/);
+            if (specMatch) {
+                const specifier = specMatch[1];
+                dependencies.push({ fromFile: filePath, specifier, kind: 'package' });
+                relationships.push({
+                    sourceType: 'file',
+                    sourceId: filePath,
+                    targetType: 'package',
+                    targetId: specifier,
+                    relationshipType: 'import',
+                    confidence: 'high',
+                });
+            }
+            continue;
+        }
+        // single import: import "fmt"
+        const singleImport = trimmed.match(/^import\s+"([^"]+)"/);
+        if (singleImport) {
+            const specifier = singleImport[1];
+            dependencies.push({ fromFile: filePath, specifier, kind: 'package' });
+            relationships.push({
+                sourceType: 'file',
+                sourceId: filePath,
+                targetType: 'package',
+                targetId: specifier,
+                relationshipType: 'import',
+                confidence: 'high',
+            });
+            continue;
+        }
+        // method with receiver: func (r ReceiverType) MethodName(
+        const methodMatch = trimmed.match(/^func\s+\(\s*\w+\s+\*?(\w+)\s*\)\s+(\w+)\s*\(/);
+        if (methodMatch) {
+            addSymbol(methodMatch[2], 'method', lineNum, methodMatch[1]);
+            continue;
+        }
+        // top-level function: func FuncName(
+        const funcMatch = trimmed.match(/^func\s+(\w+)\s*\(/);
+        if (funcMatch) {
+            addSymbol(funcMatch[1], 'function', lineNum);
+            continue;
+        }
+        // type declaration: type Name struct / type Name interface / type Name ...
+        const typeMatch = trimmed.match(/^type\s+(\w+)\s+/);
+        if (typeMatch) {
+            addSymbol(typeMatch[1], 'class', lineNum); // 'class' is closest kind for struct/interface
+            continue;
+        }
+    }
+    return { symbols, dependencies, relationships, warnings };
+}

package/dist/scanner/jvm-symbol-extractor.d.ts

@@ -0,0 +1,2 @@
+import type { SymbolExtractionResult } from './ts-symbol-extractor.js';
+export declare function extractJvmSymbols(sourceText: string, filePath: string): SymbolExtractionResult;

package/dist/scanner/jvm-symbol-extractor.js

@@ -0,0 +1,105 @@
+// Handles Java (.java) and Kotlin (.kt, .kts)
+export function extractJvmSymbols(sourceText, filePath) {
+    const ext = filePath.endsWith('.kt') || filePath.endsWith('.kts') ? 'kotlin' : 'java';
+    const lines = sourceText.split('\n');
+    const symbols = [];
+    const dependencies = [];
+    const relationships = [];
+    const warnings = [];
+    // Stack tracks class/object/interface scope
+    const typeStack = [];
+    let braceDepth = 0;
+    const addSymbol = (name, kind, lineNum, exported, parentName) => {
+        const id = [filePath, kind, parentName, name, lineNum]
+            .filter(Boolean)
+            .join('#');
+        symbols.push({
+            id,
+            name,
+            kind,
+            filePath,
+            startLine: lineNum,
+            endLine: lineNum,
+            exported,
+            parentName,
+        });
+        relationships.push({
+            sourceType: 'file',
+            sourceId: filePath,
+            targetType: 'symbol',
+            targetId: id,
+            relationshipType: 'contains',
+            confidence: 'high',
+        });
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNum = i + 1;
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('*'))
+            continue;
+        braceDepth +=
+            (line.match(/\{/g) ?? []).length - (line.match(/\}/g) ?? []).length;
+        while (typeStack.length > 0 &&
+            braceDepth < typeStack[typeStack.length - 1].braceDepth) {
+            typeStack.pop();
+        }
+        // import statement
+        const importMatch = trimmed.match(/^import\s+([\w.]+(?:\.\*)?)/);
+        if (importMatch) {
+            const specifier = importMatch[1].replace(/\.\*$/, '');
+            dependencies.push({ fromFile: filePath, specifier, kind: 'package' });
+            relationships.push({
+                sourceType: 'file',
+                sourceId: filePath,
+                targetType: 'package',
+                targetId: specifier,
+                relationshipType: 'import',
+                confidence: 'high',
+            });
+            continue;
+        }
+        if (ext === 'java') {
+            // class / interface / enum / @interface
+            const typeMatch = trimmed.match(/\b(?:public\s+|private\s+|protected\s+|abstract\s+|final\s+)*(?:class|interface|enum|@interface)\s+(\w+)/);
+            if (typeMatch) {
+                const parent = typeStack[typeStack.length - 1];
+                const exported = trimmed.includes('public');
+                addSymbol(typeMatch[1], 'class', lineNum, exported, parent?.name);
+                typeStack.push({ name: typeMatch[1], braceDepth });
+                continue;
+            }
+            // method: visibility returnType methodName(
+            // Avoid matching field declarations (no parenthesis)
+            const methodMatch = trimmed.match(/\b(?:public|private|protected|static|final|synchronized|abstract|native|default|void|@Override\s+(?:public|protected))\b.*\s+(\w+)\s*\(/);
+            if (methodMatch && !trimmed.startsWith('//')) {
+                const parent = typeStack[typeStack.length - 1];
+                const exported = trimmed.includes('public');
+                const kind = parent ? 'method' : 'function';
+                addSymbol(methodMatch[1], kind, lineNum, exported, parent?.name);
+                continue;
+            }
+        }
+        if (ext === 'kotlin') {
+            // class / interface / object / data class / sealed class
+            const typeMatch = trimmed.match(/\b(?:data\s+|sealed\s+|abstract\s+|open\s+|inner\s+)?(?:class|interface|object|enum\s+class)\s+(\w+)/);
+            if (typeMatch) {
+                const parent = typeStack[typeStack.length - 1];
+                const exported = !trimmed.startsWith('private') && !trimmed.startsWith('internal');
+                addSymbol(typeMatch[1], 'class', lineNum, exported, parent?.name);
+                typeStack.push({ name: typeMatch[1], braceDepth });
+                continue;
+            }
+            // fun
+            const funcMatch = trimmed.match(/\bfun\s+(\w+)\s*[(<]/);
+            if (funcMatch) {
+                const parent = typeStack[typeStack.length - 1];
+                const exported = !trimmed.startsWith('private') && !trimmed.startsWith('internal');
+                const kind = parent ? 'method' : 'function';
+                addSymbol(funcMatch[1], kind, lineNum, exported, parent?.name);
+                continue;
+            }
+        }
+    }
+    return { symbols, dependencies, relationships, warnings };
+}

package/dist/scanner/python-symbol-extractor.d.ts

@@ -0,0 +1,2 @@
+import type { SymbolExtractionResult } from './ts-symbol-extractor.js';
+export declare function extractPythonSymbols(sourceText: string, filePath: string): SymbolExtractionResult;

package/dist/scanner/python-symbol-extractor.js

@@ -0,0 +1,98 @@
+export function extractPythonSymbols(sourceText, filePath) {
+    const lines = sourceText.split('\n');
+    const symbols = [];
+    const dependencies = [];
+    const relationships = [];
+    const warnings = [];
+    // Stack tracks nested class scope: [{name, indent}]
+    const classStack = [];
+    const addSymbol = (name, kind, lineNum, parentName) => {
+        const id = [filePath, kind, parentName, name, lineNum]
+            .filter(Boolean)
+            .join('#');
+        symbols.push({
+            id,
+            name,
+            kind,
+            filePath,
+            startLine: lineNum,
+            endLine: lineNum,
+            exported: false,
+            parentName,
+        });
+        relationships.push({
+            sourceType: 'file',
+            sourceId: filePath,
+            targetType: 'symbol',
+            targetId: id,
+            relationshipType: 'contains',
+            confidence: 'high',
+        });
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNum = i + 1;
+        const trimmed = line.trimStart();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const indent = line.length - trimmed.length;
+        // Pop classes we've exited: any class whose indent >= current line's indent
+        // (unless this line IS the class that opened at that indent — handled by re-pushing below)
+        while (classStack.length > 0 &&
+            classStack[classStack.length - 1].indent >= indent) {
+            classStack.pop();
+        }
+        // class definition
+        const classMatch = trimmed.match(/^class\s+([A-Za-z_]\w*)/);
+        if (classMatch) {
+            const name = classMatch[1];
+            const parent = classStack[classStack.length - 1];
+            addSymbol(name, 'class', lineNum, parent?.name);
+            classStack.push({ name, indent });
+            continue;
+        }
+        // function / method definition (sync or async)
+        const funcMatch = trimmed.match(/^(?:async\s+)?def\s+([A-Za-z_]\w*)/);
+        if (funcMatch) {
+            const name = funcMatch[1];
+            const parent = classStack[classStack.length - 1];
+            const kind = parent !== undefined ? 'method' : 'function';
+            addSymbol(name, kind, lineNum, parent?.name);
+            continue;
+        }
+        // import module
+        const importMatch = trimmed.match(/^import\s+([\w.]+)/);
+        if (importMatch) {
+            const specifier = importMatch[1];
+            dependencies.push({ fromFile: filePath, specifier, kind: 'package' });
+            addSymbol(specifier, 'import', lineNum);
+            relationships.push({
+                sourceType: 'file',
+                sourceId: filePath,
+                targetType: 'package',
+                targetId: specifier,
+                relationshipType: 'import',
+                confidence: 'high',
+            });
+            continue;
+        }
+        // from X import Y
+        const fromMatch = trimmed.match(/^from\s+(\S+)\s+import/);
+        if (fromMatch) {
+            const specifier = fromMatch[1];
+            const kind = specifier.startsWith('.')
+                ? 'local'
+                : 'package';
+            dependencies.push({ fromFile: filePath, specifier, kind });
+            relationships.push({
+                sourceType: 'file',
+                sourceId: filePath,
+                targetType: kind === 'local' ? 'file' : 'package',
+                targetId: specifier,
+                relationshipType: 'import',
+                confidence: kind === 'local' ? 'medium' : 'high',
+            });
+        }
+    }
+    return { symbols, dependencies, relationships, warnings };
+}

package/dist/scanner/repo-scanner.js

@@ -2,8 +2,38 @@ import fg from 'fast-glob';
 import crypto from 'node:crypto';
 import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
+import { extractCSymbols } from './c-symbol-extractor.js';
+import { extractCSharpSymbols } from './csharp-symbol-extractor.js';
 import { buildFastGlobIgnore, detectLanguage, isPreciseLanguage, readGitignorePatterns, shouldExclude, } from './file-classifier.js';
+import { extractGoSymbols } from './go-symbol-extractor.js';
+import { extractJvmSymbols } from './jvm-symbol-extractor.js';
+import { extractPythonSymbols } from './python-symbol-extractor.js';
+import { extractRustSymbols } from './rust-symbol-extractor.js';
 import { extractTsSymbols } from './ts-symbol-extractor.js';
+const C_EXTS = new Set(['.c', '.h', '.cpp', '.cc', '.cxx', '.hpp', '.hxx']);
+const JVM_EXTS = new Set(['.java', '.kt', '.kts']);
+function extractSymbols(text, repoPath) {
+    const ext = path.extname(repoPath);
+    if (ext === '.py' || ext === '.pyw' || ext === '.pyi') {
+        return extractPythonSymbols(text, repoPath);
+    }
+    if (ext === '.go') {
+        return extractGoSymbols(text, repoPath);
+    }
+    if (ext === '.rs') {
+        return extractRustSymbols(text, repoPath);
+    }
+    if (JVM_EXTS.has(ext)) {
+        return extractJvmSymbols(text, repoPath);
+    }
+    if (C_EXTS.has(ext)) {
+        return extractCSymbols(text, repoPath);
+    }
+    if (ext === '.cs') {
+        return extractCSharpSymbols(text, repoPath);
+    }
+    return extractTsSymbols(text, repoPath);
+}
 export async function scanRepository(rootPath, config, previous) {
     const gitignorePatterns = await readGitignorePatterns(rootPath);
     const allExcludes = [...config.exclude, ...gitignorePatterns];
@@ -47,7 +77,7 @@ export async function scanRepository(rootPath, config, previous) {
                 warnings: [],
             };
             if (isPreciseLanguage(repoPath, config)) {
-                const extracted = extractTsSymbols(text, repoPath);
+                const extracted = extractSymbols(text, repoPath);
                 symbols.push(...extracted.symbols);
                 dependencies.push(...extracted.dependencies);
                 relationships.push(...extracted.relationships);

package/dist/scanner/rust-symbol-extractor.d.ts

@@ -0,0 +1,2 @@
+import type { SymbolExtractionResult } from './ts-symbol-extractor.js';
+export declare function extractRustSymbols(sourceText: string, filePath: string): SymbolExtractionResult;

package/dist/scanner/rust-symbol-extractor.js

@@ -0,0 +1,119 @@
+export function extractRustSymbols(sourceText, filePath) {
+    const lines = sourceText.split('\n');
+    const symbols = [];
+    const dependencies = [];
+    const relationships = [];
+    const warnings = [];
+    // Track current impl block: { typeName, indent }
+    const implStack = [];
+    let braceDepth = 0;
+    const addSymbol = (name, kind, lineNum, parentName) => {
+        const id = [filePath, kind, parentName, name, lineNum]
+            .filter(Boolean)
+            .join('#');
+        // Rust: pub = exported
+        symbols.push({
+            id,
+            name,
+            kind,
+            filePath,
+            startLine: lineNum,
+            endLine: lineNum,
+            exported: false, // set by caller
+            parentName,
+        });
+        relationships.push({
+            sourceType: 'file',
+            sourceId: filePath,
+            targetType: 'symbol',
+            targetId: id,
+            relationshipType: 'contains',
+            confidence: 'high',
+        });
+    };
+    const addSymbolExported = (name, kind, lineNum, exported, parentName) => {
+        const id = [filePath, kind, parentName, name, lineNum]
+            .filter(Boolean)
+            .join('#');
+        symbols.push({
+            id,
+            name,
+            kind,
+            filePath,
+            startLine: lineNum,
+            endLine: lineNum,
+            exported,
+            parentName,
+        });
+        relationships.push({
+            sourceType: 'file',
+            sourceId: filePath,
+            targetType: 'symbol',
+            targetId: id,
+            relationshipType: 'contains',
+            confidence: 'high',
+        });
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNum = i + 1;
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('//'))
+            continue;
+        // Track brace depth for impl block scoping
+        braceDepth +=
+            (line.match(/\{/g) ?? []).length - (line.match(/\}/g) ?? []).length;
+        // Pop impl blocks we've exited
+        while (implStack.length > 0 &&
+            braceDepth < implStack[implStack.length - 1].braceDepth) {
+            implStack.pop();
+        }
+        // use statement: use crate::path or use external::path
+        const useMatch = trimmed.match(/^use\s+([\w:]+)/);
+        if (useMatch) {
+            const specifier = useMatch[1];
+            const kind = specifier.startsWith('crate::') ||
+                specifier.startsWith('super::') ||
+                specifier.startsWith('self::')
+                ? 'local'
+                : 'package';
+            dependencies.push({ fromFile: filePath, specifier, kind });
+            relationships.push({
+                sourceType: 'file',
+                sourceId: filePath,
+                targetType: kind === 'local' ? 'file' : 'package',
+                targetId: specifier,
+                relationshipType: 'import',
+                confidence: 'high',
+            });
+            continue;
+        }
+        // impl block: impl TypeName or impl Trait for TypeName
+        const implMatch = trimmed.match(/^impl(?:<[^>]*>)?\s+(?:\w+\s+for\s+)?(\w+)/);
+        if (implMatch) {
+            implStack.push({ typeName: implMatch[1], braceDepth });
+            continue;
+        }
+        // struct / enum / trait definition
+        const typeMatch = trimmed.match(/^(pub\s+)?(?:struct|enum|trait)\s+(\w+)/);
+        if (typeMatch) {
+            addSymbolExported(typeMatch[2], 'class', lineNum, !!typeMatch[1]);
+            continue;
+        }
+        // fn definition (inside or outside impl)
+        const fnMatch = trimmed.match(/^(pub\s+)?(?:async\s+)?fn\s+(\w+)/);
+        if (fnMatch) {
+            const exported = !!fnMatch[1];
+            const name = fnMatch[2];
+            const parent = implStack[implStack.length - 1];
+            if (parent) {
+                addSymbolExported(name, 'method', lineNum, exported, parent.typeName);
+            }
+            else {
+                addSymbolExported(name, 'function', lineNum, exported);
+            }
+            continue;
+        }
+    }
+    return { symbols, dependencies, relationships, warnings };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kentwynn/kgraph",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "Persistent repo intelligence for AI coding assistants.",
   "type": "module",
   "bin": {