@kentwynn/kgraph 0.1.26 → 0.2.0

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/cognition.d.ts

@@ -1,5 +1,5 @@
-import type { CodeSymbol, Relationship, RepositoryFile } from "./maps.js";
-export type ReferenceStatus = "current" | "stale" | "unresolved" | "mixed";
+import type { CodeSymbol, Relationship, RepositoryFile } from './maps.js';
+export type ReferenceStatus = 'current' | 'stale' | 'unresolved' | 'mixed';
 export interface ParsedCognitionNote {
     title: string;
     domain?: string;
@@ -38,6 +38,7 @@ export interface ContextResponse {
     relevantSymbols: RankedItem<CodeSymbol>[];
     relevantCognition: RankedItem<CognitionNote>[];
     relationships: Relationship[];
+    nearbySymbols?: CodeSymbol[];
     staleReferences: string[];
     warnings: string[];
 }

package/dist/types/config.d.ts

@@ -7,7 +7,6 @@ export interface KGraphConfig {
     maxContextItems: number;
     domainHints: Record<string, DomainHint>;
     integrations: IntegrationConfig[];
-    extractors: ExtractorConfig[];
 }
 export interface DomainHint {
     paths?: string[];
@@ -15,18 +14,12 @@ export interface DomainHint {
 }
 export type IntegrationName = 'claude-code' | 'cline' | 'codex' | 'copilot' | 'cursor' | 'gemini' | 'windsurf';
 export type IntegrationMode = 'smart' | 'always' | 'manual' | 'off';
-export type ExtractorName = 'c-family' | 'csharp' | 'go' | 'jvm' | 'python' | 'rust';
 export interface IntegrationConfig {
     name: IntegrationName;
     enabled: boolean;
     mode: IntegrationMode;
     targetPath: string;
 }
-export interface ExtractorConfig {
-    name: ExtractorName;
-    enabled: boolean;
-    packageName: string;
-}
 export interface KGraphWorkspace {
     rootPath: string;
     kgraphPath: string;

package/dist/types/maps.d.ts

@@ -1,7 +1,7 @@
-export type ScanStatus = "mapped" | "generic" | "failed";
-export type DependencyKind = "local" | "package" | "unknown";
-export type SymbolKind = "function" | "class" | "method" | "type" | "interface" | "export" | "import";
-export type RelationshipType = "import" | "contains" | "symbol-contains" | "calls" | "mentions" | "belongs-to-domain" | "stale-reference" | "moved-from";
+export type ScanStatus = 'mapped' | 'generic' | 'failed';
+export type DependencyKind = 'local' | 'package' | 'unknown';
+export type SymbolKind = 'function' | 'class' | 'method' | 'type' | 'interface' | 'export' | 'import';
+export type RelationshipType = 'import' | 'contains' | 'symbol-contains' | 'calls' | 'mentions' | 'belongs-to-domain' | 'stale-reference' | 'moved-from';
 export interface RepositoryFile {
     id: string;
     path: string;
@@ -36,7 +36,7 @@ export interface Relationship {
     targetType: string;
     targetId: string;
     relationshipType: RelationshipType;
-    confidence: "high" | "medium" | "low";
+    confidence: 'high' | 'medium' | 'low';
 }
 export interface FileMap {
     generatedAt: string;
@@ -60,4 +60,5 @@ export interface ScanResult {
     dependencies: Dependency[];
     relationships: Relationship[];
     warnings: string[];
+    skippedFiles?: number;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kentwynn/kgraph",
-  "version": "0.1.26",
+  "version": "0.2.0",
   "description": "Persistent repo intelligence for AI coding assistants.",
   "type": "module",
   "bin": {
@@ -40,11 +40,20 @@
   "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": {

package/dist/cli/commands/extractor.d.ts

@@ -1,2 +0,0 @@
-import type { Command } from 'commander';
-export declare function registerExtractorCommand(program: Command): void;

package/dist/cli/commands/extractor.js

@@ -1,50 +0,0 @@
-import { installCommandForExtractors, normalizeExtractorNames, } from '../../extractors/extractor-registry.js';
-import { addExtractors, listExtractors, removeExtractors, } from '../../extractors/extractor-store.js';
-import { assertWorkspace } from '../../storage/kgraph-paths.js';
-import { KGraphError, runCommand } from '../errors.js';
-export function registerExtractorCommand(program) {
-    const extractor = program
-        .command('extractor')
-        .description('Manage optional deep language extractors');
-    extractor
-        .command('list')
-        .description('List configured optional extractors')
-        .action(() => runCommand(async () => {
-        const workspace = await assertWorkspace(process.cwd());
-        const extractors = await listExtractors(workspace);
-        if (extractors.length === 0) {
-            console.log('No extractors configured.');
-            return;
-        }
-        for (const item of extractors) {
-            console.log(`${item.name} ${item.enabled ? 'enabled' : 'disabled'} ${item.packageName} ${item.packageInstalled ? 'present' : 'missing'}`);
-        }
-    }));
-    extractor
-        .command('add')
-        .description('Configure optional deep extractors')
-        .argument('<names...>')
-        .action((names) => runCommand(async () => {
-        const workspace = await assertWorkspace(process.cwd());
-        const normalized = normalizeExtractorNames(names);
-        if (normalized.length === 0) {
-            throw new KGraphError('Provide at least one extractor name.');
-        }
-        const changed = await addExtractors(workspace, normalized);
-        console.log(`Configured extractors: ${changed.map((item) => item.name).join(', ')}`);
-        console.log(`Install packages: ${installCommandForExtractors(changed.map((item) => item.packageName))}`);
-    }));
-    extractor
-        .command('remove')
-        .description('Remove optional deep extractors')
-        .argument('<names...>')
-        .action((names) => runCommand(async () => {
-        const workspace = await assertWorkspace(process.cwd());
-        const normalized = normalizeExtractorNames(names);
-        if (normalized.length === 0) {
-            throw new KGraphError('Provide at least one extractor name.');
-        }
-        const removed = await removeExtractors(workspace, normalized);
-        console.log(`Removed extractors: ${removed.join(', ')}`);
-    }));
-}

package/dist/extractors/extractor-registry.d.ts

@@ -1,11 +0,0 @@
-import type { ExtractorName } from '../types/config.js';
-export interface ExtractorAdapter {
-    name: ExtractorName;
-    label: string;
-    packageName: string;
-    languages: string[];
-}
-export declare function listExtractorAdapters(): ExtractorAdapter[];
-export declare function getExtractorAdapter(name: string): ExtractorAdapter;
-export declare function normalizeExtractorNames(values: string[] | undefined): ExtractorName[];
-export declare function installCommandForExtractors(packageNames: string[]): string;

package/dist/extractors/extractor-registry.js

@@ -1,70 +0,0 @@
-const ADAPTERS = [
-    {
-        name: 'python',
-        label: 'Python deep extractor',
-        packageName: '@kentwynn/kgraph-extractor-python',
-        languages: ['python'],
-    },
-    {
-        name: 'jvm',
-        label: 'JVM deep extractor',
-        packageName: '@kentwynn/kgraph-extractor-jvm',
-        languages: ['java', 'kotlin'],
-    },
-    {
-        name: 'go',
-        label: 'Go deep extractor',
-        packageName: '@kentwynn/kgraph-extractor-go',
-        languages: ['go'],
-    },
-    {
-        name: 'rust',
-        label: 'Rust deep extractor',
-        packageName: '@kentwynn/kgraph-extractor-rust',
-        languages: ['rust'],
-    },
-    {
-        name: 'c-family',
-        label: 'C/C++ deep extractor',
-        packageName: '@kentwynn/kgraph-extractor-c-family',
-        languages: ['c', 'cpp'],
-    },
-    {
-        name: 'csharp',
-        label: 'C# deep extractor',
-        packageName: '@kentwynn/kgraph-extractor-csharp',
-        languages: ['csharp'],
-    },
-].sort((left, right) => left.name.localeCompare(right.name));
-export function listExtractorAdapters() {
-    return ADAPTERS;
-}
-export function getExtractorAdapter(name) {
-    const adapter = ADAPTERS.find((item) => item.name === name);
-    if (!adapter) {
-        throw new Error(`Unsupported extractor "${name}". Supported extractors: ${ADAPTERS.map((item) => item.name).join(', ')}`);
-    }
-    return adapter;
-}
-export function normalizeExtractorNames(values) {
-    if (!values || values.length === 0) {
-        return [];
-    }
-    const names = [];
-    const seen = new Set();
-    for (const value of values) {
-        for (const raw of value.split(/[\s,]+/)) {
-            const name = raw.trim();
-            if (!name || seen.has(name)) {
-                continue;
-            }
-            const adapter = getExtractorAdapter(name);
-            seen.add(adapter.name);
-            names.push(adapter.name);
-        }
-    }
-    return names;
-}
-export function installCommandForExtractors(packageNames) {
-    return `npm install -D ${packageNames.join(' ')}`;
-}

package/dist/extractors/extractor-store.d.ts

@@ -1,10 +0,0 @@
-import type { ExtractorConfig, ExtractorName, KGraphWorkspace } from '../types/config.js';
-export interface ExtractorStatus {
-    name: ExtractorName;
-    enabled: boolean;
-    packageName: string;
-    packageInstalled: boolean;
-}
-export declare function listExtractors(workspace: KGraphWorkspace): Promise<ExtractorStatus[]>;
-export declare function addExtractors(workspace: KGraphWorkspace, names: ExtractorName[]): Promise<ExtractorConfig[]>;
-export declare function removeExtractors(workspace: KGraphWorkspace, names: ExtractorName[]): Promise<ExtractorName[]>;

package/dist/extractors/extractor-store.js

@@ -1,58 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { loadConfig, saveConfig } from '../config/config.js';
-import { pathExists } from '../storage/kgraph-paths.js';
-import { getExtractorAdapter } from './extractor-registry.js';
-export async function listExtractors(workspace) {
-    const config = await loadConfig(workspace);
-    const statuses = await Promise.all(config.extractors.map(async (extractor) => ({
-        name: extractor.name,
-        enabled: extractor.enabled,
-        packageName: extractor.packageName,
-        packageInstalled: await isExtractorInstalled(workspace.rootPath, extractor.packageName),
-    })));
-    return statuses.sort((left, right) => left.name.localeCompare(right.name));
-}
-export async function addExtractors(workspace, names) {
-    const config = await loadConfig(workspace);
-    const byName = new Map(config.extractors.map((extractor) => [extractor.name, extractor]));
-    const changed = [];
-    for (const name of names) {
-        const adapter = getExtractorAdapter(name);
-        const next = {
-            name: adapter.name,
-            enabled: true,
-            packageName: adapter.packageName,
-        };
-        byName.set(adapter.name, next);
-        changed.push(next);
-    }
-    config.extractors = [...byName.values()].sort((left, right) => left.name.localeCompare(right.name));
-    await saveConfig(workspace, config);
-    return changed;
-}
-export async function removeExtractors(workspace, names) {
-    const config = await loadConfig(workspace);
-    const removeNames = new Set(names);
-    config.extractors = config.extractors.filter((extractor) => !removeNames.has(extractor.name));
-    await saveConfig(workspace, config);
-    return [...removeNames].sort((left, right) => left.localeCompare(right));
-}
-async function isExtractorInstalled(rootPath, packageName) {
-    const packageJsonPath = path.join(rootPath, 'package.json');
-    if (await pathExists(packageJsonPath)) {
-        try {
-            const raw = await readFile(packageJsonPath, 'utf8');
-            const pkg = JSON.parse(raw);
-            if (pkg.dependencies?.[packageName] ||
-                pkg.devDependencies?.[packageName] ||
-                pkg.optionalDependencies?.[packageName]) {
-                return true;
-            }
-        }
-        catch {
-            return false;
-        }
-    }
-    return pathExists(path.join(rootPath, 'node_modules', ...packageName.split('/'), 'package.json'));
-}