@kentwynn/kgraph 0.2.22 → 0.2.24

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

@@ -0,0 +1,292 @@
+import { parseSource } from './tree-sitter-parser.js';
+const TREE_SITTER_GRAMMAR_BY_LANGUAGE = {
+    yaml: 'yaml',
+    json: 'json',
+    html: 'html',
+    css: 'css',
+    lua: 'lua',
+    dart: 'dart',
+    elixir: 'elixir',
+    scala: 'scala',
+};
+export async function extractBroadSymbols(sourceText, filePath, language) {
+    const result = createExtractionResult();
+    if (!sourceText.trim()) {
+        return result;
+    }
+    const broadLanguage = language;
+    const grammar = TREE_SITTER_GRAMMAR_BY_LANGUAGE[broadLanguage];
+    if (grammar) {
+        try {
+            const tree = await parseSource(sourceText, grammar);
+            tree.delete();
+        }
+        catch (error) {
+            result.warnings.push(`tree-sitter ${grammar} parse failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const lines = sourceText.split(/\r?\n/);
+    switch (broadLanguage) {
+        case 'swift':
+            collectSwift(lines, filePath, result);
+            break;
+        case 'terraform':
+            collectTerraform(lines, filePath, result);
+            break;
+        case 'graphql':
+            collectGraphql(lines, filePath, result);
+            break;
+        case 'protobuf':
+            collectProtobuf(lines, filePath, result);
+            break;
+        case 'lua':
+            collectLua(lines, filePath, result);
+            break;
+        case 'dart':
+            collectDart(lines, filePath, result);
+            break;
+        case 'elixir':
+            collectElixir(lines, filePath, result);
+            break;
+        case 'scala':
+            collectScala(lines, filePath, result);
+            break;
+        case 'r':
+            collectR(lines, filePath, result);
+            break;
+        case 'yaml':
+        case 'json':
+        case 'toml':
+        case 'dockerfile':
+            collectConfig(lines, filePath, result, broadLanguage);
+            break;
+        case 'markdown':
+            collectMarkdown(lines, filePath, result);
+            break;
+        case 'html':
+        case 'xml':
+            collectMarkup(lines, filePath, result);
+            break;
+        case 'css':
+        case 'scss':
+        case 'sass':
+        case 'less':
+            collectStylesheet(lines, filePath, result);
+            break;
+    }
+    return result;
+}
+export function supportsBroadExtraction(language) {
+    return [
+        'swift',
+        'terraform',
+        'graphql',
+        'protobuf',
+        'lua',
+        'dart',
+        'elixir',
+        'scala',
+        'r',
+        'yaml',
+        'json',
+        'toml',
+        'dockerfile',
+        'markdown',
+        'html',
+        'css',
+        'scss',
+        'sass',
+        'less',
+        'xml',
+    ].includes(language);
+}
+function createExtractionResult() {
+    return { symbols: [], dependencies: [], relationships: [], warnings: [] };
+}
+function addSymbol(result, filePath, name, kind, line, exported = false, parentName) {
+    const id = [filePath, kind, parentName, name, line].filter(Boolean).join('#');
+    const symbol = {
+        id,
+        name,
+        kind,
+        filePath,
+        startLine: line,
+        endLine: line,
+        exported,
+        parentName,
+    };
+    result.symbols.push(symbol);
+    result.relationships.push({
+        sourceType: 'file',
+        sourceId: filePath,
+        targetType: 'symbol',
+        targetId: id,
+        relationshipType: 'contains',
+        confidence: 'high',
+    });
+    return symbol;
+}
+function addDependency(result, filePath, specifier, kind = specifier.startsWith('.') ? 'local' : 'package') {
+    result.dependencies.push({ fromFile: filePath, specifier, kind });
+}
+function collectSwift(lines, filePath, result) {
+    forEachLine(lines, (line, lineNumber) => {
+        const importMatch = line.match(/^\s*import\s+([A-Za-z_][\w.]*)/);
+        if (importMatch?.[1])
+            addDependency(result, filePath, importMatch[1]);
+        const typeMatch = line.match(/^\s*(?:public|private|internal|open|final|\s)*(class|struct|enum|protocol)\s+([A-Za-z_][\w]*)/);
+        if (typeMatch?.[2]) {
+            addSymbol(result, filePath, typeMatch[2], typeMatch[1] === 'protocol' ? 'interface' : 'class', lineNumber, true);
+        }
+        const functionMatch = line.match(/^\s*(?:public|private|internal|open|static|\s)*func\s+([A-Za-z_][\w]*)/);
+        if (functionMatch?.[1]) {
+            addSymbol(result, filePath, functionMatch[1], 'function', lineNumber, true);
+        }
+    });
+}
+function collectTerraform(lines, filePath, result) {
+    forEachLine(lines, (line, lineNumber) => {
+        const blockMatch = line.match(/^\s*(resource|data|module|variable|output|provider)\s+"([^"]+)"(?:\s+"([^"]+)")?/);
+        if (blockMatch?.[1] && blockMatch[2]) {
+            addSymbol(result, filePath, [blockMatch[1], blockMatch[2], blockMatch[3]].filter(Boolean).join('.'), 'type', lineNumber, true);
+        }
+    });
+}
+function collectGraphql(lines, filePath, result) {
+    forEachLine(lines, (line, lineNumber) => {
+        const typeMatch = line.match(/^\s*(type|interface|enum|input|union|scalar)\s+([A-Za-z_][\w]*)/);
+        if (typeMatch?.[2]) {
+            addSymbol(result, filePath, typeMatch[2], typeMatch[1] === 'interface' ? 'interface' : 'type', lineNumber, true);
+        }
+    });
+}
+function collectProtobuf(lines, filePath, result) {
+    forEachLine(lines, (line, lineNumber) => {
+        const importMatch = line.match(/^\s*import\s+"([^"]+)"/);
+        if (importMatch?.[1])
+            addDependency(result, filePath, importMatch[1], 'local');
+        const typeMatch = line.match(/^\s*(message|service|enum)\s+([A-Za-z_][\w]*)/);
+        if (typeMatch?.[2]) {
+            addSymbol(result, filePath, typeMatch[2], 'type', lineNumber, true);
+        }
+    });
+}
+function collectLua(lines, filePath, result) {
+    forEachLine(lines, (line, lineNumber) => {
+        const requireMatch = line.match(/require\s*\(?\s*['"]([^'"]+)['"]/);
+        if (requireMatch?.[1])
+            addDependency(result, filePath, requireMatch[1]);
+        const functionMatch = line.match(/^\s*(?:local\s+)?function\s+([A-Za-z_][\w.:]*)/);
+        if (functionMatch?.[1]) {
+            addSymbol(result, filePath, functionMatch[1], 'function', lineNumber, true);
+        }
+    });
+}
+function collectDart(lines, filePath, result) {
+    forEachLine(lines, (line, lineNumber) => {
+        const importMatch = line.match(/^\s*import\s+['"]([^'"]+)['"]/);
+        if (importMatch?.[1])
+            addDependency(result, filePath, importMatch[1]);
+        const classMatch = line.match(/^\s*(?:abstract\s+)?class\s+([A-Za-z_][\w]*)/);
+        if (classMatch?.[1])
+            addSymbol(result, filePath, classMatch[1], 'class', lineNumber, true);
+        const functionMatch = line.match(/^\s*(?:[A-Za-z_<>,?]+\s+)+([A-Za-z_][\w]*)\s*\([^;]*\)\s*(?:async\s*)?\{/);
+        if (functionMatch?.[1] && !['if', 'for', 'while', 'switch'].includes(functionMatch[1])) {
+            addSymbol(result, filePath, functionMatch[1], 'function', lineNumber, true);
+        }
+    });
+}
+function collectElixir(lines, filePath, result) {
+    forEachLine(lines, (line, lineNumber) => {
+        const moduleMatch = line.match(/^\s*defmodule\s+([A-Z][\w.]+)/);
+        if (moduleMatch?.[1])
+            addSymbol(result, filePath, moduleMatch[1], 'class', lineNumber, true);
+        const functionMatch = line.match(/^\s*defp?\s+([a-z_][\w!?]*)/);
+        if (functionMatch?.[1])
+            addSymbol(result, filePath, functionMatch[1], 'function', lineNumber, true);
+    });
+}
+function collectScala(lines, filePath, result) {
+    forEachLine(lines, (line, lineNumber) => {
+        const importMatch = line.match(/^\s*import\s+(.+)/);
+        if (importMatch?.[1])
+            addDependency(result, filePath, importMatch[1].trim());
+        const typeMatch = line.match(/^\s*(?:case\s+)?(class|object|trait|enum)\s+([A-Za-z_][\w]*)/);
+        if (typeMatch?.[2]) {
+            addSymbol(result, filePath, typeMatch[2], typeMatch[1] === 'trait' ? 'interface' : 'class', lineNumber, true);
+        }
+        const functionMatch = line.match(/^\s*def\s+([A-Za-z_][\w]*)/);
+        if (functionMatch?.[1])
+            addSymbol(result, filePath, functionMatch[1], 'function', lineNumber, true);
+    });
+}
+function collectR(lines, filePath, result) {
+    forEachLine(lines, (line, lineNumber) => {
+        const libraryMatch = line.match(/^\s*(?:library|require)\s*\(\s*([A-Za-z.][\w.]*)/);
+        if (libraryMatch?.[1])
+            addDependency(result, filePath, libraryMatch[1]);
+        const functionMatch = line.match(/^\s*([A-Za-z.][\w.]*)\s*(?:<-|=)\s*function\s*\(/);
+        if (functionMatch?.[1])
+            addSymbol(result, filePath, functionMatch[1], 'function', lineNumber, true);
+    });
+}
+function collectConfig(lines, filePath, result, language) {
+    forEachLine(lines, (line, lineNumber) => {
+        if (language === 'dockerfile') {
+            const stageMatch = line.match(/^\s*FROM\s+\S+(?:\s+AS\s+([A-Za-z_][\w-]*))?/i);
+            if (stageMatch?.[1])
+                addSymbol(result, filePath, stageMatch[1], 'type', lineNumber, true);
+            return;
+        }
+        const keyMatch = language === 'json'
+            ? line.match(/^\s*"([^"]+)"\s*:/)
+            : line.match(/^\s*([A-Za-z_][\w.-]*)\s*[:=]/);
+        if (keyMatch?.[1]) {
+            addSymbol(result, filePath, keyMatch[1], 'type', lineNumber);
+        }
+    });
+}
+function collectMarkdown(lines, filePath, result) {
+    forEachLine(lines, (line, lineNumber) => {
+        const headingMatch = line.match(/^(#{1,6})\s+(.+)/);
+        if (headingMatch?.[2]) {
+            addSymbol(result, filePath, headingMatch[2].trim(), 'type', lineNumber);
+        }
+    });
+}
+function collectMarkup(lines, filePath, result) {
+    forEachLine(lines, (line, lineNumber) => {
+        for (const idMatch of line.matchAll(/\bid=["']([^"']+)["']/g)) {
+            if (idMatch[1])
+                addSymbol(result, filePath, `#${idMatch[1]}`, 'type', lineNumber);
+        }
+        for (const classMatch of line.matchAll(/\bclass=["']([^"']+)["']/g)) {
+            for (const className of classMatch[1]?.split(/\s+/) ?? []) {
+                if (className)
+                    addSymbol(result, filePath, `.${className}`, 'type', lineNumber);
+            }
+        }
+    });
+}
+function collectStylesheet(lines, filePath, result) {
+    forEachLine(lines, (line, lineNumber) => {
+        const importMatch = line.match(/^\s*@(import|use|forward)\s+["']([^"']+)["']/);
+        if (importMatch?.[2])
+            addDependency(result, filePath, importMatch[2]);
+        for (const variableMatch of line.matchAll(/(--[A-Za-z_][\w-]*|\$[A-Za-z_][\w-]*)\s*:/g)) {
+            if (variableMatch[1])
+                addSymbol(result, filePath, variableMatch[1], 'type', lineNumber);
+        }
+        const mixinMatch = line.match(/^\s*@(mixin|function|keyframes)\s+([A-Za-z_][\w-]*)/);
+        if (mixinMatch?.[2]) {
+            addSymbol(result, filePath, mixinMatch[2], mixinMatch[1] === 'function' ? 'function' : 'type', lineNumber);
+        }
+        for (const selectorMatch of line.matchAll(/([.#][A-Za-z_][\w-]*)/g)) {
+            if (selectorMatch[1])
+                addSymbol(result, filePath, selectorMatch[1], 'type', lineNumber);
+        }
+    });
+}
+function forEachLine(lines, callback) {
+    lines.forEach((line, index) => callback(line, index + 1));
+}

package/dist/scanner/extraction-context.d.ts

@@ -0,0 +1,23 @@
+import type { CodeSymbol, Dependency, Relationship } from '../types/maps.js';
+import type { SymbolExtractionResult } from './ts-symbol-extractor.js';
+export declare class ExtractionContext {
+    private readonly filePath;
+    readonly symbols: CodeSymbol[];
+    readonly dependencies: Dependency[];
+    readonly relationships: Relationship[];
+    readonly warnings: string[];
+    constructor(filePath: string);
+    addSymbol(options: {
+        name: string;
+        kind: CodeSymbol['kind'];
+        startLine: number;
+        endLine?: number;
+        exported?: boolean;
+        parentName?: string;
+    }): CodeSymbol;
+    addDependency(specifier: string, kind?: Dependency['kind'], confidence?: Relationship['confidence']): void;
+    addSymbolContains(parent: CodeSymbol, child: CodeSymbol): void;
+    addWarning(message: string): void;
+    toResult(): SymbolExtractionResult;
+}
+export declare function emptyExtractionResult(): SymbolExtractionResult;

package/dist/scanner/extraction-context.js

@@ -0,0 +1,77 @@
+export class ExtractionContext {
+    filePath;
+    symbols = [];
+    dependencies = [];
+    relationships = [];
+    warnings = [];
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    addSymbol(options) {
+        const id = [
+            this.filePath,
+            options.kind,
+            options.parentName,
+            options.name,
+            options.startLine,
+            options.endLine ?? options.startLine,
+        ]
+            .filter(Boolean)
+            .join('#');
+        const symbol = {
+            id,
+            name: options.name,
+            kind: options.kind,
+            filePath: this.filePath,
+            startLine: options.startLine,
+            endLine: options.endLine ?? options.startLine,
+            exported: options.exported ?? false,
+            parentName: options.parentName,
+        };
+        this.symbols.push(symbol);
+        this.relationships.push({
+            sourceType: 'file',
+            sourceId: this.filePath,
+            targetType: 'symbol',
+            targetId: id,
+            relationshipType: 'contains',
+            confidence: 'high',
+        });
+        return symbol;
+    }
+    addDependency(specifier, kind = specifier.startsWith('.') ? 'local' : 'package', confidence = 'high') {
+        this.dependencies.push({ fromFile: this.filePath, specifier, kind });
+        this.relationships.push({
+            sourceType: 'file',
+            sourceId: this.filePath,
+            targetType: kind === 'local' ? 'file' : 'package',
+            targetId: specifier,
+            relationshipType: 'import',
+            confidence,
+        });
+    }
+    addSymbolContains(parent, child) {
+        this.relationships.push({
+            sourceType: 'symbol',
+            sourceId: parent.id,
+            targetType: 'symbol',
+            targetId: child.id,
+            relationshipType: 'symbol-contains',
+            confidence: 'high',
+        });
+    }
+    addWarning(message) {
+        this.warnings.push(message);
+    }
+    toResult() {
+        return {
+            symbols: this.symbols,
+            dependencies: this.dependencies,
+            relationships: this.relationships,
+            warnings: this.warnings,
+        };
+    }
+}
+export function emptyExtractionResult() {
+    return { symbols: [], dependencies: [], relationships: [], warnings: [] };
+}

package/dist/scanner/file-classifier.js

@@ -53,6 +53,7 @@ const LANGUAGE_BY_EXTENSION = {
     '.scss': 'scss',
     '.sass': 'sass',
     '.less': 'less',
+    '.dockerfile': 'dockerfile',
     '.vue': 'vue',
     '.svelte': 'svelte',
     // Data / Config
@@ -84,6 +85,13 @@ const LANGUAGE_BY_EXTENSION = {
     '.proto': 'protobuf',
     '.sql': 'sql',
 };
+const LANGUAGE_BY_BASENAME = {
+    Dockerfile: 'dockerfile',
+    Containerfile: 'dockerfile',
+    Makefile: 'shell',
+    Rakefile: 'ruby',
+    Gemfile: 'ruby',
+};
 export function shouldExclude(repoPath, config) {
     const normalizedPath = normalizeRepoPath(repoPath);
     return config.exclude.some((pattern) => matchesExcludePattern(normalizedPath, pattern));
@@ -120,10 +128,15 @@ export async function readGitignorePatterns(rootPath) {
     }
 }
 export function detectLanguage(filePath) {
-    return LANGUAGE_BY_EXTENSION[path.extname(filePath)] ?? 'unknown';
+    const basename = path.basename(filePath);
+    return (LANGUAGE_BY_BASENAME[basename] ??
+        LANGUAGE_BY_EXTENSION[path.extname(filePath)] ??
+        'unknown');
 }
 export function isPreciseLanguage(filePath, config) {
-    return config.languages.precise.includes(path.extname(filePath));
+    const basename = path.basename(filePath);
+    return (config.languages.precise.includes(path.extname(filePath)) ||
+        Object.hasOwn(LANGUAGE_BY_BASENAME, basename));
 }
 function matchesExcludePattern(repoPath, pattern) {
     const normalized = normalizeRepoPath(pattern).replace(/\/$/, '');

package/dist/scanner/git-utils.d.ts

@@ -12,6 +12,11 @@ export declare function getCurrentCommit(rootPath: string): Promise<string | nul
  * Returns an empty array if git is unavailable or the ref is unknown.
  */
 export declare function getChangedFilesSince(rootPath: string, ref: string): Promise<string[]>;
+/**
+ * Returns the subset of paths ignored by Git, including nested .gitignore rules.
+ * Falls back to an empty set when Git is unavailable or the directory is not a repo.
+ */
+export declare function getGitIgnoredFiles(rootPath: string, paths: string[]): Promise<Set<string>>;
 /**
  * Returns paths of files with uncommitted changes (staged or unstaged)
  * relative to HEAD. Returns an empty array if git is unavailable.

package/dist/scanner/git-utils.js

@@ -1,4 +1,4 @@
-import { execFile } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
 import { access } from 'node:fs/promises';
 import path from 'node:path';
 import { promisify } from 'node:util';
@@ -47,6 +47,38 @@ export async function getChangedFilesSince(rootPath, ref) {
         return [];
     }
 }
+/**
+ * Returns the subset of paths ignored by Git, including nested .gitignore rules.
+ * Falls back to an empty set when Git is unavailable or the directory is not a repo.
+ */
+export async function getGitIgnoredFiles(rootPath, paths) {
+    if (paths.length === 0) {
+        return new Set();
+    }
+    return new Promise((resolve) => {
+        const child = spawn('git', ['check-ignore', '--stdin'], {
+            cwd: rootPath,
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+        let stdout = '';
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.on('error', () => resolve(new Set()));
+        child.on('close', (code) => {
+            if (code !== 0 && code !== 1) {
+                resolve(new Set());
+                return;
+            }
+            resolve(new Set(stdout
+                .split('\n')
+                .map((line) => line.trim())
+                .filter(Boolean)));
+        });
+        child.stdin.end(`${paths.join('\n')}\n`);
+    });
+}
 /**
  * Returns paths of files with uncommitted changes (staged or unstaged)
  * relative to HEAD. Returns an empty array if git is unavailable.

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

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

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

@@ -0,0 +1,79 @@
+import { emptyExtractionResult, ExtractionContext, } from './extraction-context.js';
+import { parseSource } from './tree-sitter-parser.js';
+export async function extractPhpSymbols(sourceText, filePath) {
+    if (!sourceText.trim()) {
+        return emptyExtractionResult();
+    }
+    const tree = await parseSource(sourceText, 'php');
+    const context = new ExtractionContext(filePath);
+    function addNamedSymbol(node, kind, parentName) {
+        const nameNode = findNameNode(node);
+        if (!nameNode)
+            return undefined;
+        return context.addSymbol({
+            name: nameNode.text,
+            kind,
+            startLine: node.startPosition.row + 1,
+            endLine: node.endPosition.row + 1,
+            exported: true,
+            parentName,
+        });
+    }
+    function walk(node, parentClassName) {
+        switch (node.type) {
+            case 'namespace_definition':
+            case 'namespace_name': {
+                if (node.type === 'namespace_name' && !parentClassName) {
+                    context.addSymbol({
+                        name: node.text,
+                        kind: 'type',
+                        startLine: node.startPosition.row + 1,
+                        endLine: node.endPosition.row + 1,
+                        exported: true,
+                    });
+                    return;
+                }
+                break;
+            }
+            case 'namespace_use_declaration': {
+                for (const nameNode of node.descendantsOfType('qualified_name')) {
+                    context.addDependency(nameNode.text, 'package');
+                }
+                return;
+            }
+            case 'class_declaration':
+            case 'interface_declaration':
+            case 'trait_declaration':
+            case 'enum_declaration': {
+                const classSymbol = addNamedSymbol(node, node.type === 'interface_declaration' ? 'interface' : 'class', parentClassName);
+                const className = classSymbol?.name ?? parentClassName;
+                for (const child of node.namedChildren) {
+                    walk(child, className);
+                }
+                return;
+            }
+            case 'function_definition':
+            case 'method_declaration': {
+                const symbol = addNamedSymbol(node, parentClassName ? 'method' : 'function', parentClassName);
+                if (symbol && parentClassName) {
+                    const parent = context.symbols.find((candidate) => candidate.name === parentClassName && candidate.kind === 'class');
+                    if (parent)
+                        context.addSymbolContains(parent, symbol);
+                }
+                return;
+            }
+        }
+        for (const child of node.namedChildren) {
+            walk(child, parentClassName);
+        }
+    }
+    walk(tree.rootNode);
+    tree.delete();
+    return context.toResult();
+}
+function findNameNode(node) {
+    return (node.childForFieldName('name') ??
+        node.namedChildren.find((child) => child.type === 'name') ??
+        node.namedChildren.find((child) => child.type === 'variable_name') ??
+        node.namedChildren.find((child) => child.type === 'identifier'));
+}