@kentwynn/kgraph 0.1.25 → 0.1.27

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

@@ -1,13 +1,15 @@
-export function extractPythonSymbols(sourceText, filePath) {
-    const lines = sourceText.split('\n');
+import { parseSource } from './tree-sitter-parser.js';
+export async function extractPythonSymbols(sourceText, filePath) {
     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]
+    if (!sourceText.trim()) {
+        return { symbols, dependencies, relationships, warnings };
+    }
+    const tree = await parseSource(sourceText, 'python');
+    const addSymbol = (name, kind, startLine, endLine, exported, parentName) => {
+        const id = [filePath, kind, parentName, name, startLine]
             .filter(Boolean)
             .join('#');
         symbols.push({
@@ -15,9 +17,9 @@ export function extractPythonSymbols(sourceText, filePath) {
             name,
             kind,
             filePath,
-            startLine: lineNum,
-            endLine: lineNum,
-            exported: false,
+            startLine,
+            endLine,
+            exported,
             parentName,
         });
         relationships.push({
@@ -29,70 +31,89 @@ export function extractPythonSymbols(sourceText, filePath) {
             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;
+    function walk(node, parentClassName) {
+        switch (node.type) {
+            case 'class_definition': {
+                const nameNode = node.childForFieldName('name');
+                if (nameNode) {
+                    const startLine = node.startPosition.row + 1;
+                    const endLine = node.endPosition.row + 1;
+                    addSymbol(nameNode.text, 'class', startLine, endLine, false, parentClassName);
+                    // Walk children for nested classes/methods
+                    const body = node.childForFieldName('body');
+                    if (body) {
+                        for (const child of body.namedChildren) {
+                            walk(child, nameNode.text);
+                        }
+                    }
+                }
+                return; // Don't recurse further from here
+            }
+            case 'function_definition': {
+                const nameNode = node.childForFieldName('name');
+                if (nameNode) {
+                    const startLine = node.startPosition.row + 1;
+                    const endLine = node.endPosition.row + 1;
+                    const kind = parentClassName
+                        ? 'method'
+                        : 'function';
+                    addSymbol(nameNode.text, kind, startLine, endLine, false, parentClassName);
+                }
+                return; // Don't recurse into function bodies
+            }
+            case 'import_statement': {
+                // import os / import os.path
+                const startLine = node.startPosition.row + 1;
+                for (const child of node.namedChildren) {
+                    if (child.type === 'dotted_name' || child.type === 'aliased_import') {
+                        const specifier = child.type === 'aliased_import'
+                            ? (child.childForFieldName('name')?.text ?? child.text)
+                            : child.text;
+                        dependencies.push({
+                            fromFile: filePath,
+                            specifier,
+                            kind: 'package',
+                        });
+                        addSymbol(specifier, 'import', startLine, startLine, false);
+                        relationships.push({
+                            sourceType: 'file',
+                            sourceId: filePath,
+                            targetType: 'package',
+                            targetId: specifier,
+                            relationshipType: 'import',
+                            confidence: 'high',
+                        });
+                    }
+                }
+                return;
+            }
+            case 'import_from_statement': {
+                // from X import Y
+                const moduleNode = node.childForFieldName('module_name');
+                if (moduleNode) {
+                    const specifier = moduleNode.text;
+                    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;
+            }
         }
-        // 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',
-            });
+        // Recurse into children for top-level statements
+        for (const child of node.namedChildren) {
+            walk(child, parentClassName);
         }
     }
+    walk(tree.rootNode);
+    tree.delete();
     return { symbols, dependencies, relationships, warnings };
 }

package/dist/scanner/repo-scanner.js

@@ -2,6 +2,7 @@ import fg from 'fast-glob';
 import crypto from 'node:crypto';
 import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
+import { estimateTokens } from '../session/token-estimator.js';
 import { extractCSymbols } from './c-symbol-extractor.js';
 import { extractCSharpSymbols } from './csharp-symbol-extractor.js';
 import { buildFastGlobIgnore, detectLanguage, isPreciseLanguage, readGitignorePatterns, shouldExclude, } from './file-classifier.js';
@@ -10,10 +11,9 @@ 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';
-import { estimateTokens } from '../session/token-estimator.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) {
+async function extractSymbols(text, repoPath) {
     const ext = path.extname(repoPath);
     if (ext === '.py' || ext === '.pyw' || ext === '.pyi') {
         return extractPythonSymbols(text, repoPath);
@@ -79,7 +79,7 @@ export async function scanRepository(rootPath, config, previous) {
                 warnings: [],
             };
             if (isPreciseLanguage(repoPath, config)) {
-                const extracted = extractSymbols(text, repoPath);
+                const extracted = await extractSymbols(text, repoPath);
                 symbols.push(...extracted.symbols);
                 dependencies.push(...extracted.dependencies);
                 relationships.push(...extracted.relationships.filter((relationship) => relationship.relationshipType !== 'import'));

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

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

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

@@ -1,38 +1,15 @@
-export function extractRustSymbols(sourceText, filePath) {
-    const lines = sourceText.split('\n');
+import { parseSource } from './tree-sitter-parser.js';
+export async function extractRustSymbols(sourceText, filePath) {
     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]
+    if (!sourceText.trim()) {
+        return { symbols, dependencies, relationships, warnings };
+    }
+    const tree = await parseSource(sourceText, 'rust');
+    const addSymbol = (name, kind, startLine, endLine, exported, parentName) => {
+        const id = [filePath, kind, parentName, name, startLine]
             .filter(Boolean)
             .join('#');
         symbols.push({
@@ -40,8 +17,8 @@ export function extractRustSymbols(sourceText, filePath) {
             name,
             kind,
             filePath,
-            startLine: lineNum,
-            endLine: lineNum,
+            startLine,
+            endLine,
             exported,
             parentName,
         });
@@ -54,66 +31,94 @@ export function extractRustSymbols(sourceText, filePath) {
             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;
+    function hasPub(node) {
+        return node.namedChildren.some((c) => c.type === 'visibility_modifier');
+    }
+    function extractUseSpecifier(node) {
+        // use_declaration has a child tree of scoped_identifier / scoped_use_list / use_wildcard
+        // We want the text without 'use' and ';'
+        for (const child of node.namedChildren) {
+            if (child.type !== 'visibility_modifier') {
+                return child.text;
+            }
         }
-        // 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);
+        return '';
+    }
+    function walk(node, implTypeName) {
+        switch (node.type) {
+            case 'use_declaration': {
+                const specifier = extractUseSpecifier(node);
+                if (specifier) {
+                    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',
+                    });
+                }
+                return;
+            }
+            case 'struct_item':
+            case 'enum_item':
+            case 'trait_item': {
+                const nameNode = node.childForFieldName('name');
+                if (nameNode) {
+                    addSymbol(nameNode.text, 'class', node.startPosition.row + 1, node.endPosition.row + 1, hasPub(node));
+                }
+                return;
             }
-            else {
-                addSymbolExported(name, 'function', lineNum, exported);
+            case 'impl_item': {
+                // impl TypeName { ... } or impl Trait for TypeName { ... }
+                const typeNode = node.childForFieldName('type');
+                const typeName = typeNode?.type === 'type_identifier' ? typeNode.text : typeNode?.text;
+                const body = node.childForFieldName('body') ??
+                    node.namedChildren.find((c) => c.type === 'declaration_list');
+                if (body && typeName) {
+                    for (const child of body.namedChildren) {
+                        walk(child, typeName);
+                    }
+                }
+                return;
             }
-            continue;
+            case 'function_item': {
+                const nameNode = node.childForFieldName('name');
+                if (nameNode) {
+                    const exported = hasPub(node);
+                    if (implTypeName) {
+                        addSymbol(nameNode.text, 'method', node.startPosition.row + 1, node.endPosition.row + 1, exported, implTypeName);
+                    }
+                    else {
+                        addSymbol(nameNode.text, 'function', node.startPosition.row + 1, node.endPosition.row + 1, exported);
+                    }
+                }
+                return;
+            }
+            case 'function_signature_item': {
+                // trait method signatures
+                const nameNode = node.childForFieldName('name');
+                if (nameNode && implTypeName) {
+                    addSymbol(nameNode.text, 'method', node.startPosition.row + 1, node.endPosition.row + 1, false, implTypeName);
+                }
+                return;
+            }
+        }
+        for (const child of node.namedChildren) {
+            walk(child, implTypeName);
         }
     }
+    walk(tree.rootNode);
+    tree.delete();
     return { symbols, dependencies, relationships, warnings };
 }

package/dist/scanner/tree-sitter-parser.d.ts

@@ -0,0 +1,5 @@
+import { Language, Tree } from 'web-tree-sitter';
+type GrammarKey = 'python' | 'java' | 'kotlin' | 'go' | 'rust' | 'c' | 'cpp' | 'c_sharp';
+export declare function loadLanguage(grammarKey: GrammarKey): Promise<Language>;
+export declare function parseSource(sourceText: string, grammarKey: GrammarKey): Promise<Tree>;
+export {};

package/dist/scanner/tree-sitter-parser.js

@@ -0,0 +1,55 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { Language, Parser } from 'web-tree-sitter';
+const require = createRequire(import.meta.url);
+let initPromise = null;
+const languageCache = new Map();
+const GRAMMAR_PACKAGES = {
+    python: { pkg: 'tree-sitter-python', wasm: 'tree-sitter-python.wasm' },
+    java: { pkg: 'tree-sitter-java', wasm: 'tree-sitter-java.wasm' },
+    kotlin: {
+        pkg: '@tree-sitter-grammars/tree-sitter-kotlin',
+        wasm: 'tree-sitter-kotlin.wasm',
+    },
+    go: { pkg: 'tree-sitter-go', wasm: 'tree-sitter-go.wasm' },
+    rust: { pkg: 'tree-sitter-rust', wasm: 'tree-sitter-rust.wasm' },
+    c: { pkg: 'tree-sitter-c', wasm: 'tree-sitter-c.wasm' },
+    cpp: { pkg: 'tree-sitter-cpp', wasm: 'tree-sitter-cpp.wasm' },
+    c_sharp: {
+        pkg: 'tree-sitter-c-sharp',
+        wasm: 'tree-sitter-c_sharp.wasm',
+    },
+};
+async function ensureInit() {
+    if (!initPromise) {
+        initPromise = Parser.init();
+    }
+    return initPromise;
+}
+function resolveWasmPath(grammarKey) {
+    const { pkg, wasm } = GRAMMAR_PACKAGES[grammarKey];
+    const pkgDir = path.dirname(require.resolve(`${pkg}/package.json`));
+    return path.join(pkgDir, wasm);
+}
+export async function loadLanguage(grammarKey) {
+    const cached = languageCache.get(grammarKey);
+    if (cached)
+        return cached;
+    await ensureInit();
+    const wasmPath = resolveWasmPath(grammarKey);
+    const language = await Language.load(wasmPath);
+    languageCache.set(grammarKey, language);
+    return language;
+}
+export async function parseSource(sourceText, grammarKey) {
+    await ensureInit();
+    const language = await loadLanguage(grammarKey);
+    const parser = new Parser();
+    parser.setLanguage(language);
+    const tree = parser.parse(sourceText);
+    parser.delete();
+    if (!tree) {
+        throw new Error(`Failed to parse source with grammar ${grammarKey}`);
+    }
+    return tree;
+}

package/dist/types/config.d.ts

@@ -12,8 +12,8 @@ export interface DomainHint {
     paths?: string[];
     tags?: string[];
 }
-export type IntegrationName = "claude-code" | "cline" | "codex" | "copilot" | "cursor" | "gemini" | "windsurf";
-export type IntegrationMode = "smart" | "always" | "manual" | "off";
+export type IntegrationName = 'claude-code' | 'cline' | 'codex' | 'copilot' | 'cursor' | 'gemini' | 'windsurf';
+export type IntegrationMode = 'smart' | 'always' | 'manual' | 'off';
 export interface IntegrationConfig {
     name: IntegrationName;
     enabled: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kentwynn/kgraph",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "description": "Persistent repo intelligence for AI coding assistants.",
   "type": "module",
   "bin": {
@@ -39,11 +39,21 @@
   },
   "homepage": "https://github.com/kentwynn/KGraph#readme",
   "dependencies": {
+    "@clack/prompts": "^1.3.0",
+    "@tree-sitter-grammars/tree-sitter-kotlin": "^1.1.0",
     "chalk": "^5.6.2",
     "commander": "^12.1.0",
     "fast-glob": "^3.3.2",
     "figlet": "^1.11.0",
+    "tree-sitter-c": "^0.24.1",
+    "tree-sitter-c-sharp": "^0.23.5",
+    "tree-sitter-cpp": "^0.23.4",
+    "tree-sitter-go": "^0.25.0",
+    "tree-sitter-java": "^0.23.5",
+    "tree-sitter-python": "^0.25.0",
+    "tree-sitter-rust": "^0.24.0",
     "typescript": "^5.9.3",
+    "web-tree-sitter": "^0.26.8",
     "yaml": "^2.5.1"
   },
   "devDependencies": {