@kentwynn/kgraph 0.1.26 → 0.1.27

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

@@ -1,13 +1,15 @@
-export function extractCSharpSymbols(sourceText, filePath) {
-    const lines = sourceText.split('\n');
+import { parseSource } from './tree-sitter-parser.js';
+export async function extractCSharpSymbols(sourceText, filePath) {
     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]
+    if (!sourceText.trim()) {
+        return { symbols, dependencies, relationships, warnings };
+    }
+    const tree = await parseSource(sourceText, 'c_sharp');
+    const addSymbol = (name, kind, startLine, endLine, exported, parentName) => {
+        const id = [filePath, kind, parentName, name, startLine]
             .filter(Boolean)
             .join('#');
         symbols.push({
@@ -15,8 +17,8 @@ export function extractCSharpSymbols(sourceText, filePath) {
             name,
             kind,
             filePath,
-            startLine: lineNum,
-            endLine: lineNum,
+            startLine,
+            endLine,
             exported,
             parentName,
         });
@@ -29,68 +31,92 @@ export function extractCSharpSymbols(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('//') || 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;
+    function hasVisibility(node, vis) {
+        for (const child of node.children) {
+            if (child.type === 'modifier' && child.text === vis)
+                return true;
         }
-        // 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 false;
+    }
+    function isExported(node) {
+        return hasVisibility(node, 'public') || hasVisibility(node, 'internal');
+    }
+    function walk(node, parentClassName) {
+        switch (node.type) {
+            case 'using_directive': {
+                // using System; or using System.Collections.Generic;
+                const nameNode = node.namedChildren.find((c) => c.type === 'qualified_name') ??
+                    node.namedChildren.find((c) => c.type === 'identifier');
+                if (nameNode) {
+                    const specifier = nameNode.text;
+                    dependencies.push({ fromFile: filePath, specifier, kind: 'package' });
+                    relationships.push({
+                        sourceType: 'file',
+                        sourceId: filePath,
+                        targetType: 'package',
+                        targetId: specifier,
+                        relationshipType: 'import',
+                        confidence: 'high',
+                    });
+                }
+                return;
             }
+            case 'namespace_declaration':
+            case 'file_scoped_namespace_declaration': {
+                // Recurse into namespace body
+                const body = node.childForFieldName('body') ??
+                    node.namedChildren.find((c) => c.type === 'declaration_list');
+                if (body) {
+                    for (const child of body.namedChildren) {
+                        walk(child, parentClassName);
+                    }
+                }
+                else {
+                    // file-scoped namespace: declarations are siblings
+                    for (const child of node.namedChildren) {
+                        walk(child, parentClassName);
+                    }
+                }
+                return;
+            }
+            case 'class_declaration':
+            case 'interface_declaration':
+            case 'struct_declaration':
+            case 'enum_declaration':
+            case 'record_declaration': {
+                const nameNode = node.childForFieldName('name');
+                if (nameNode) {
+                    const exported = isExported(node);
+                    addSymbol(nameNode.text, 'class', node.startPosition.row + 1, node.endPosition.row + 1, exported, parentClassName);
+                    // Walk body for methods and nested types
+                    const body = node.childForFieldName('body') ??
+                        node.namedChildren.find((c) => c.type === 'declaration_list');
+                    if (body) {
+                        for (const child of body.namedChildren) {
+                            walk(child, nameNode.text);
+                        }
+                    }
+                }
+                return;
+            }
+            case 'method_declaration':
+            case 'constructor_declaration': {
+                const nameNode = node.childForFieldName('name');
+                if (nameNode) {
+                    const exported = isExported(node);
+                    const kind = parentClassName
+                        ? 'method'
+                        : 'function';
+                    addSymbol(nameNode.text, kind, node.startPosition.row + 1, node.endPosition.row + 1, exported, parentClassName);
+                }
+                return;
+            }
+        }
+        for (const child of node.namedChildren) {
+            walk(child, parentClassName);
         }
     }
+    walk(tree.rootNode);
+    tree.delete();
     return { symbols, dependencies, relationships, warnings };
 }

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

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

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

@@ -1,11 +1,15 @@
-export function extractGoSymbols(sourceText, filePath) {
-    const lines = sourceText.split('\n');
+import { parseSource } from './tree-sitter-parser.js';
+export async function extractGoSymbols(sourceText, filePath) {
     const symbols = [];
     const dependencies = [];
     const relationships = [];
     const warnings = [];
-    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, 'go');
+    const addSymbol = (name, kind, startLine, endLine, parentName) => {
+        const id = [filePath, kind, parentName, name, startLine]
             .filter(Boolean)
             .join('#');
         symbols.push({
@@ -13,8 +17,8 @@ export function extractGoSymbols(sourceText, filePath) {
             name,
             kind,
             filePath,
-            startLine: lineNum,
-            endLine: lineNum,
+            startLine,
+            endLine,
             exported: /^[A-Z]/.test(name), // Go: exported = starts with uppercase
             parentName,
         });
@@ -27,43 +31,12 @@ export function extractGoSymbols(sourceText, filePath) {
             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];
+    function extractImportSpec(node) {
+        // import_spec contains an interpreted_string_literal with the path
+        const pathNode = node.namedChildren.find((c) => c.type === 'interpreted_string_literal');
+        if (pathNode) {
+            // Strip quotes from the string literal
+            const specifier = pathNode.text.replace(/^"|"$/g, '');
             dependencies.push({ fromFile: filePath, specifier, kind: 'package' });
             relationships.push({
                 sourceType: 'file',
@@ -73,26 +46,68 @@ export function extractGoSymbols(sourceText, filePath) {
                 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;
+    }
+    function walk(node) {
+        switch (node.type) {
+            case 'import_declaration': {
+                // Could contain import_spec_list or a single import_spec
+                for (const child of node.namedChildren) {
+                    if (child.type === 'import_spec_list') {
+                        for (const spec of child.namedChildren) {
+                            if (spec.type === 'import_spec') {
+                                extractImportSpec(spec);
+                            }
+                        }
+                    }
+                    else if (child.type === 'import_spec') {
+                        extractImportSpec(child);
+                    }
+                }
+                return;
+            }
+            case 'type_declaration': {
+                // type_declaration contains type_spec children
+                for (const child of node.namedChildren) {
+                    if (child.type === 'type_spec') {
+                        const nameNode = child.childForFieldName('name');
+                        if (nameNode) {
+                            addSymbol(nameNode.text, 'class', node.startPosition.row + 1, node.endPosition.row + 1);
+                        }
+                    }
+                }
+                return;
+            }
+            case 'function_declaration': {
+                const nameNode = node.childForFieldName('name');
+                if (nameNode) {
+                    addSymbol(nameNode.text, 'function', node.startPosition.row + 1, node.endPosition.row + 1);
+                }
+                return;
+            }
+            case 'method_declaration': {
+                const nameNode = node.childForFieldName('name');
+                const receiverNode = node.childForFieldName('receiver');
+                let parentName;
+                if (receiverNode) {
+                    // receiver is a parameter_list with a parameter_declaration inside
+                    // that contains the type (possibly pointer_type wrapping type_identifier)
+                    const typeNode = receiverNode.descendantsOfType('type_identifier')[0];
+                    if (typeNode) {
+                        parentName = typeNode.text;
+                    }
+                }
+                if (nameNode) {
+                    addSymbol(nameNode.text, 'method', node.startPosition.row + 1, node.endPosition.row + 1, parentName);
+                }
+                return;
+            }
         }
-        // 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;
+        for (const child of node.namedChildren) {
+            walk(child);
         }
     }
+    walk(tree.rootNode);
+    tree.delete();
     return { symbols, dependencies, relationships, warnings };
 }

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

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

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

@@ -1,16 +1,17 @@
+import { parseSource } from './tree-sitter-parser.js';
 // 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');
+export async function extractJvmSymbols(sourceText, filePath) {
     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]
+    if (!sourceText.trim()) {
+        return { symbols, dependencies, relationships, warnings };
+    }
+    const lang = filePath.endsWith('.kt') || filePath.endsWith('.kts') ? 'kotlin' : 'java';
+    const tree = await parseSource(sourceText, lang);
+    const addSymbol = (name, kind, startLine, endLine, exported, parentName) => {
+        const id = [filePath, kind, parentName, name, startLine]
             .filter(Boolean)
             .join('#');
         symbols.push({
@@ -18,8 +19,8 @@ export function extractJvmSymbols(sourceText, filePath) {
             name,
             kind,
             filePath,
-            startLine: lineNum,
-            endLine: lineNum,
+            startLine,
+            endLine,
             exported,
             parentName,
         });
@@ -32,74 +33,141 @@ export function extractJvmSymbols(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('//') || trimmed.startsWith('*'))
-            continue;
-        braceDepth +=
-            (line.match(/\{/g) ?? []).length - (line.match(/\}/g) ?? []).length;
-        while (typeStack.length > 0 &&
-            braceDepth < typeStack[typeStack.length - 1].braceDepth) {
-            typeStack.pop();
+    function hasModifier(node, modifier) {
+        const mods = node.childForFieldName('modifiers') ??
+            node.namedChildren.find((c) => c.type === 'modifiers');
+        if (!mods)
+            return false;
+        return mods.text.includes(modifier);
+    }
+    function walkJava(node, parentClassName) {
+        switch (node.type) {
+            case 'import_declaration': {
+                // Java import: scoped_identifier child
+                const scopedId = node.namedChildren.find((c) => c.type === 'scoped_identifier' || c.type === 'identifier');
+                if (scopedId) {
+                    const specifier = scopedId.text.replace(/\.\*$/, '');
+                    dependencies.push({ fromFile: filePath, specifier, kind: 'package' });
+                    relationships.push({
+                        sourceType: 'file',
+                        sourceId: filePath,
+                        targetType: 'package',
+                        targetId: specifier,
+                        relationshipType: 'import',
+                        confidence: 'high',
+                    });
+                }
+                return;
+            }
+            case 'class_declaration':
+            case 'interface_declaration':
+            case 'enum_declaration':
+            case 'annotation_type_declaration': {
+                const nameNode = node.childForFieldName('name');
+                if (nameNode) {
+                    const exported = hasModifier(node, 'public');
+                    addSymbol(nameNode.text, 'class', node.startPosition.row + 1, node.endPosition.row + 1, exported, parentClassName);
+                    // Walk class body for methods and nested types
+                    const body = node.childForFieldName('body') ??
+                        node.namedChildren.find((c) => c.type === 'class_body' ||
+                            c.type === 'interface_body' ||
+                            c.type === 'enum_body');
+                    if (body) {
+                        for (const child of body.namedChildren) {
+                            walkJava(child, nameNode.text);
+                        }
+                    }
+                }
+                return;
+            }
+            case 'method_declaration':
+            case 'constructor_declaration': {
+                const nameNode = node.childForFieldName('name');
+                if (nameNode) {
+                    const exported = hasModifier(node, 'public');
+                    const kind = parentClassName
+                        ? 'method'
+                        : 'function';
+                    addSymbol(nameNode.text, kind, node.startPosition.row + 1, node.endPosition.row + 1, exported, parentClassName);
+                }
+                return;
+            }
         }
-        // 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;
+        for (const child of node.namedChildren) {
+            walkJava(child, parentClassName);
         }
-        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;
+    }
+    function walkKotlin(node, parentClassName) {
+        switch (node.type) {
+            case 'import': {
+                // Kotlin import: qualified_identifier child
+                const qualId = node.namedChildren.find((c) => c.type === 'qualified_identifier' || c.type === 'identifier');
+                if (qualId) {
+                    const specifier = qualId.text;
+                    dependencies.push({ fromFile: filePath, specifier, kind: 'package' });
+                    relationships.push({
+                        sourceType: 'file',
+                        sourceId: filePath,
+                        targetType: 'package',
+                        targetId: specifier,
+                        relationshipType: 'import',
+                        confidence: 'high',
+                    });
+                }
+                return;
             }
-            // 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;
+            case 'class_declaration': {
+                const nameNode = node.childForFieldName('name') ??
+                    node.namedChildren.find((c) => c.type === 'identifier');
+                if (nameNode) {
+                    const exported = !hasModifier(node, 'private') && !hasModifier(node, 'internal');
+                    addSymbol(nameNode.text, 'class', node.startPosition.row + 1, node.endPosition.row + 1, exported, parentClassName);
+                    // Walk class body
+                    const body = node.namedChildren.find((c) => c.type === 'class_body');
+                    if (body) {
+                        for (const child of body.namedChildren) {
+                            walkKotlin(child, nameNode.text);
+                        }
+                    }
+                }
+                return;
             }
-        }
-        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;
+            case 'object_declaration': {
+                const nameNode = node.namedChildren.find((c) => c.type === 'identifier');
+                if (nameNode) {
+                    const exported = !hasModifier(node, 'private') && !hasModifier(node, 'internal');
+                    addSymbol(nameNode.text, 'class', node.startPosition.row + 1, node.endPosition.row + 1, exported, parentClassName);
+                    const body = node.namedChildren.find((c) => c.type === 'class_body');
+                    if (body) {
+                        for (const child of body.namedChildren) {
+                            walkKotlin(child, nameNode.text);
+                        }
+                    }
+                }
+                return;
             }
-            // 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;
+            case 'function_declaration': {
+                const nameNode = node.namedChildren.find((c) => c.type === 'identifier');
+                if (nameNode) {
+                    const exported = !hasModifier(node, 'private') && !hasModifier(node, 'internal');
+                    const kind = parentClassName
+                        ? 'method'
+                        : 'function';
+                    addSymbol(nameNode.text, kind, node.startPosition.row + 1, node.endPosition.row + 1, exported, parentClassName);
+                }
+                return;
             }
         }
+        for (const child of node.namedChildren) {
+            walkKotlin(child, parentClassName);
+        }
+    }
+    if (lang === 'java') {
+        walkJava(tree.rootNode);
+    }
+    else {
+        walkKotlin(tree.rootNode);
     }
+    tree.delete();
     return { symbols, dependencies, relationships, warnings };
 }

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

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