@kentwynn/kgraph 0.1.26 → 0.2.0

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

@@ -1,14 +1,19 @@
+import { parseSource } from './tree-sitter-parser.js';
+const CPP_EXTS = new Set(['.cpp', '.cc', '.cxx', '.hpp', '.hxx']);
 // Handles C (.c, .h) and C++ (.cpp, .cc, .cxx, .hpp, .hxx)
-export function extractCSymbols(sourceText, filePath) {
-    const lines = sourceText.split('\n');
+export async function extractCSymbols(sourceText, filePath) {
     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]
+    if (!sourceText.trim()) {
+        return { symbols, dependencies, relationships, warnings };
+    }
+    const ext = filePath.substring(filePath.lastIndexOf('.'));
+    const grammar = CPP_EXTS.has(ext) ? 'cpp' : 'c';
+    const tree = await parseSource(sourceText, grammar);
+    const addSymbol = (name, kind, startLine, endLine, parentName) => {
+        const id = [filePath, kind, parentName, name, startLine]
             .filter(Boolean)
             .join('#');
         symbols.push({
@@ -16,8 +21,8 @@ export function extractCSymbols(sourceText, filePath) {
             name,
             kind,
             filePath,
-            startLine: lineNum,
-            endLine: lineNum,
+            startLine,
+            endLine,
             exported: false,
             parentName,
         });
@@ -30,67 +35,105 @@ export function extractCSymbols(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();
-        }
-        // #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;
+    function getFuncName(node) {
+        // function_definition has a function_declarator child which contains the identifier
+        const declarator = node.childForFieldName('declarator');
+        if (!declarator)
+            return null;
+        if (declarator.type === 'function_declarator') {
+            const nameNode = declarator.childForFieldName('declarator');
+            return nameNode?.text ?? null;
         }
-        // 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;
+        // For pointer_declarator wrapping function_declarator
+        const funcDecl = declarator.descendantsOfType('function_declarator')[0];
+        if (funcDecl) {
+            const nameNode = funcDecl.childForFieldName('declarator');
+            return nameNode?.text ?? null;
         }
-        // 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 null;
+    }
+    function walk(node, parentClassName) {
+        switch (node.type) {
+            case 'preproc_include': {
+                // #include <...> or #include "..."
+                const pathNode = node.namedChildren.find((c) => c.type === 'system_lib_string') ??
+                    node.namedChildren.find((c) => c.type === 'string_literal');
+                if (pathNode) {
+                    let specifier;
+                    let kind;
+                    if (pathNode.type === 'system_lib_string') {
+                        // <iostream> — strip angle brackets
+                        specifier = pathNode.text.replace(/^<|>$/g, '');
+                        kind = 'package';
+                    }
+                    else {
+                        // "myheader.h" — extract string content
+                        const content = pathNode.namedChildren.find((c) => c.type === 'string_content');
+                        specifier = content?.text ?? pathNode.text.replace(/^"|"$/g, '');
+                        kind = 'local';
+                    }
+                    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 'class_specifier':
+            case 'struct_specifier': {
+                const nameNode = node.childForFieldName('name');
+                if (nameNode) {
+                    addSymbol(nameNode.text, 'class', node.startPosition.row + 1, node.endPosition.row + 1, parentClassName);
+                    // Walk body for methods
+                    const body = node.childForFieldName('body');
+                    if (body) {
+                        for (const child of body.namedChildren) {
+                            walk(child, nameNode.text);
+                        }
+                    }
+                }
+                return;
             }
+            case 'function_definition': {
+                const name = getFuncName(node);
+                if (name) {
+                    const kind = parentClassName
+                        ? 'method'
+                        : 'function';
+                    addSymbol(name, kind, node.startPosition.row + 1, node.endPosition.row + 1, parentClassName);
+                }
+                return;
+            }
+            case 'declaration': {
+                // Could be a function declaration (prototype) inside a class
+                if (parentClassName) {
+                    const declarator = node.childForFieldName('declarator');
+                    if (declarator) {
+                        const funcDecl = declarator.type === 'function_declarator'
+                            ? declarator
+                            : declarator.descendantsOfType('function_declarator')[0];
+                        if (funcDecl) {
+                            const nameNode = funcDecl.childForFieldName('declarator');
+                            if (nameNode) {
+                                addSymbol(nameNode.text, 'method', node.startPosition.row + 1, node.endPosition.row + 1, parentClassName);
+                            }
+                            return;
+                        }
+                    }
+                }
+                break;
+            }
+        }
+        for (const child of node.namedChildren) {
+            walk(child, parentClassName);
         }
     }
+    walk(tree.rootNode);
+    tree.delete();
     return { symbols, dependencies, relationships, warnings };
 }

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

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

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>;