@kentwynn/kgraph 0.2.21 → 0.2.23

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/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'));
+}

package/dist/scanner/repo-scanner.js

@@ -3,22 +3,44 @@ import crypto from 'node:crypto';
 import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { estimateTokens } from '../session/token-estimator.js';
+import { extractBroadSymbols, supportsBroadExtraction, } from './broad-symbol-extractor.js';
 import { extractCSymbols } from './c-symbol-extractor.js';
 import { extractCSharpSymbols } from './csharp-symbol-extractor.js';
 import { buildFastGlobIgnore, detectLanguage, isPreciseLanguage, readGitignorePatterns, shouldExclude, } from './file-classifier.js';
 import { getChangedFilesSince, isGitRepo } from './git-utils.js';
 import { extractGoSymbols } from './go-symbol-extractor.js';
 import { extractJvmSymbols } from './jvm-symbol-extractor.js';
+import { extractPhpSymbols } from './php-symbol-extractor.js';
 import { extractPythonSymbols } from './python-symbol-extractor.js';
+import { extractRubySymbols } from './ruby-symbol-extractor.js';
 import { extractRustSymbols } from './rust-symbol-extractor.js';
+import { extractShellSymbols } from './shell-symbol-extractor.js';
+import { extractSqlSymbols } from './sql-symbol-extractor.js';
 import { extractTsSymbols } from './ts-symbol-extractor.js';
 const C_EXTS = new Set(['.c', '.h', '.cpp', '.cc', '.cxx', '.hpp', '.hxx']);
 const JVM_EXTS = new Set(['.java', '.kt', '.kts']);
+const TS_EXTS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mts', '.cts']);
 async function extractSymbols(text, repoPath) {
     const ext = path.extname(repoPath);
+    const language = detectLanguage(repoPath);
+    if (supportsBroadExtraction(language)) {
+        return extractBroadSymbols(text, repoPath, language);
+    }
     if (ext === '.py' || ext === '.pyw' || ext === '.pyi') {
         return extractPythonSymbols(text, repoPath);
     }
+    if (ext === '.php') {
+        return extractPhpSymbols(text, repoPath);
+    }
+    if (ext === '.rb' || ext === '.rake' || language === 'ruby') {
+        return extractRubySymbols(text, repoPath);
+    }
+    if (['.sh', '.bash', '.zsh', '.fish'].includes(ext) || language === 'shell') {
+        return extractShellSymbols(text, repoPath);
+    }
+    if (ext === '.sql') {
+        return extractSqlSymbols(text, repoPath);
+    }
     if (ext === '.go') {
         return extractGoSymbols(text, repoPath);
     }
@@ -34,7 +56,10 @@ async function extractSymbols(text, repoPath) {
     if (ext === '.cs') {
         return extractCSharpSymbols(text, repoPath);
     }
-    return extractTsSymbols(text, repoPath);
+    if (TS_EXTS.has(ext)) {
+        return extractTsSymbols(text, repoPath);
+    }
+    return { symbols: [], dependencies: [], relationships: [], warnings: [] };
 }
 export async function scanRepository(rootPath, config, previous) {
     const gitignorePatterns = await readGitignorePatterns(rootPath);
@@ -223,6 +248,15 @@ const SOURCE_EXTENSIONS = [
     '.hpp',
     '.hxx',
     '.cs',
+    '.php',
+    '.swift',
+    '.rb',
+    '.rake',
+    '.lua',
+    '.dart',
+    '.ex',
+    '.exs',
+    '.scala',
 ];
 function resolveLocalDependencies(dependencies, files) {
     const filePaths = new Set(files.map((file) => file.path));

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

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

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

@@ -0,0 +1,75 @@
+import { emptyExtractionResult, ExtractionContext, } from './extraction-context.js';
+import { parseSource } from './tree-sitter-parser.js';
+export async function extractRubySymbols(sourceText, filePath) {
+    if (!sourceText.trim()) {
+        return emptyExtractionResult();
+    }
+    const tree = await parseSource(sourceText, 'ruby');
+    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, parentName) {
+        switch (node.type) {
+            case 'call': {
+                const methodName = findCallMethodName(node);
+                if (methodName === 'require' || methodName === 'require_relative') {
+                    const argument = findFirstStringContent(node);
+                    if (argument) {
+                        context.addDependency(argument, methodName === 'require_relative' ? 'local' : 'package');
+                    }
+                    return;
+                }
+                break;
+            }
+            case 'class':
+            case 'module': {
+                const symbol = addNamedSymbol(node, node.type === 'class' ? 'class' : 'type', parentName);
+                const nextParent = symbol?.name ?? parentName;
+                for (const child of node.namedChildren) {
+                    walk(child, nextParent);
+                }
+                return;
+            }
+            case 'method':
+            case 'singleton_method': {
+                const symbol = addNamedSymbol(node, parentName ? 'method' : 'function', parentName);
+                if (symbol && parentName) {
+                    const parent = context.symbols.find((candidate) => candidate.name === parentName &&
+                        (candidate.kind === 'class' || candidate.kind === 'type'));
+                    if (parent)
+                        context.addSymbolContains(parent, symbol);
+                }
+                return;
+            }
+        }
+        for (const child of node.namedChildren) {
+            walk(child, parentName);
+        }
+    }
+    walk(tree.rootNode);
+    tree.delete();
+    return context.toResult();
+}
+function findNameNode(node) {
+    return (node.childForFieldName('name') ??
+        node.namedChildren.find((child) => child.type === 'constant') ??
+        node.namedChildren.find((child) => child.type === 'identifier'));
+}
+function findCallMethodName(node) {
+    return (node.childForFieldName('method')?.text ??
+        node.namedChildren.find((child) => child.type === 'identifier')?.text);
+}
+function findFirstStringContent(node) {
+    return node.descendantsOfType('string_content')[0]?.text;
+}

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

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

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

@@ -0,0 +1,78 @@
+import { emptyExtractionResult, ExtractionContext, } from './extraction-context.js';
+import { parseSource } from './tree-sitter-parser.js';
+export async function extractShellSymbols(sourceText, filePath) {
+    if (!sourceText.trim()) {
+        return emptyExtractionResult();
+    }
+    const tree = await parseSource(sourceText, 'bash');
+    const context = new ExtractionContext(filePath);
+    function walk(node, currentFunctionId) {
+        switch (node.type) {
+            case 'function_definition': {
+                const name = findFunctionName(node);
+                if (name) {
+                    const symbol = context.addSymbol({
+                        name,
+                        kind: 'function',
+                        startLine: node.startPosition.row + 1,
+                        endLine: node.endPosition.row + 1,
+                        exported: true,
+                    });
+                    for (const child of node.namedChildren) {
+                        walk(child, symbol.id);
+                    }
+                    return;
+                }
+                break;
+            }
+            case 'command': {
+                const commandName = findCommandName(node);
+                const firstArgument = findFirstCommandArgument(node);
+                if ((commandName === 'source' || commandName === '.') &&
+                    firstArgument) {
+                    context.addDependency(firstArgument, 'local');
+                    return;
+                }
+                if (currentFunctionId && commandName && isLocalScriptReference(commandName)) {
+                    context.relationships.push({
+                        sourceType: 'symbol',
+                        sourceId: currentFunctionId,
+                        targetType: 'file',
+                        targetId: commandName,
+                        relationshipType: 'calls',
+                        confidence: 'low',
+                    });
+                }
+                break;
+            }
+        }
+        for (const child of node.namedChildren) {
+            walk(child, currentFunctionId);
+        }
+    }
+    walk(tree.rootNode);
+    tree.delete();
+    return context.toResult();
+}
+function findFunctionName(node) {
+    return (node.childForFieldName('name')?.text ??
+        node.namedChildren.find((child) => child.type === 'word')?.text);
+}
+function findCommandName(node) {
+    return (node.childForFieldName('name')?.text ??
+        node.namedChildren
+            .find((child) => child.type === 'command_name')
+            ?.namedChildren.find((child) => child.type === 'word')?.text ??
+        node.namedChildren.find((child) => child.type === 'command_name')?.text ??
+        node.namedChildren.find((child) => child.type === 'word')?.text);
+}
+function findFirstCommandArgument(node) {
+    return node.namedChildren.find((child) => child.type === 'word')?.text;
+}
+function isLocalScriptReference(value) {
+    return (value.startsWith('./') ||
+        value.startsWith('../') ||
+        value.endsWith('.sh') ||
+        value.endsWith('.bash') ||
+        value.endsWith('.zsh'));
+}

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

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

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

@@ -0,0 +1,166 @@
+import { emptyExtractionResult, ExtractionContext, } from './extraction-context.js';
+export async function extractSqlSymbols(sourceText, filePath) {
+    if (!sourceText.trim()) {
+        return emptyExtractionResult();
+    }
+    const context = new ExtractionContext(filePath);
+    const withoutComments = stripLineComments(sourceText);
+    const statements = splitStatements(withoutComments);
+    for (const statement of statements) {
+        collectCreateStatement(statement, context);
+        collectAlterStatement(statement, context);
+        collectQueryReferences(statement, context);
+    }
+    return context.toResult();
+}
+function collectCreateStatement(statement, context) {
+    const normalized = compact(statement.text);
+    const createMatch = normalized.match(/^CREATE\s+(?:OR\s+REPLACE\s+)?(?:(?:UNIQUE|MATERIALIZED|TEMP|TEMPORARY)\s+)*(TABLE|VIEW|INDEX|FUNCTION|PROCEDURE|TRIGGER|TYPE)\s+(?:IF\s+NOT\s+EXISTS\s+)?("?[\w.]+"?)/i);
+    if (!createMatch?.[1] || !createMatch[2]) {
+        return;
+    }
+    const objectKind = createMatch[1].toLowerCase();
+    const name = normalizeSqlIdentifier(createMatch[2]);
+    const symbol = context.addSymbol({
+        name,
+        kind: objectKind === 'function' || objectKind === 'procedure'
+            ? 'function'
+            : 'type',
+        startLine: statement.startLine,
+        endLine: statement.endLine,
+        exported: true,
+        parentName: objectKind,
+    });
+    const tableForTrigger = normalized.match(/\bON\s+("?[\w.]+"?)/i)?.[1];
+    if (objectKind === 'trigger' && tableForTrigger) {
+        context.relationships.push({
+            sourceType: 'symbol',
+            sourceId: symbol.id,
+            targetType: 'symbol',
+            targetId: normalizeSqlIdentifier(tableForTrigger),
+            relationshipType: 'mentions',
+            confidence: 'high',
+        });
+    }
+    for (const referencedTable of referencedTables(normalized)) {
+        context.relationships.push({
+            sourceType: 'symbol',
+            sourceId: symbol.id,
+            targetType: 'symbol',
+            targetId: referencedTable,
+            relationshipType: 'mentions',
+            confidence: 'medium',
+        });
+    }
+}
+function collectAlterStatement(statement, context) {
+    const normalized = compact(statement.text);
+    const alterMatch = normalized.match(/^ALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?("?[\w.]+"?)/i);
+    if (!alterMatch?.[1]) {
+        return;
+    }
+    const tableName = normalizeSqlIdentifier(alterMatch[1]);
+    const symbol = context.addSymbol({
+        name: `alter ${tableName}`,
+        kind: 'type',
+        startLine: statement.startLine,
+        endLine: statement.endLine,
+        exported: true,
+        parentName: 'table',
+    });
+    context.relationships.push({
+        sourceType: 'symbol',
+        sourceId: symbol.id,
+        targetType: 'symbol',
+        targetId: tableName,
+        relationshipType: 'mentions',
+        confidence: 'high',
+    });
+    for (const referencedTable of referencedTables(normalized)) {
+        context.relationships.push({
+            sourceType: 'symbol',
+            sourceId: symbol.id,
+            targetType: 'symbol',
+            targetId: referencedTable,
+            relationshipType: 'mentions',
+            confidence: 'medium',
+        });
+    }
+}
+function collectQueryReferences(statement, context) {
+    const normalized = compact(statement.text);
+    const queryMatch = normalized.match(/^(SELECT|INSERT|UPDATE|DELETE)\b/i);
+    if (!queryMatch?.[1]) {
+        return;
+    }
+    const symbol = context.addSymbol({
+        name: `${queryMatch[1].toLowerCase()} statement ${statement.startLine}`,
+        kind: 'type',
+        startLine: statement.startLine,
+        endLine: statement.endLine,
+    });
+    for (const table of referencedTables(normalized)) {
+        context.relationships.push({
+            sourceType: 'symbol',
+            sourceId: symbol.id,
+            targetType: 'symbol',
+            targetId: table,
+            relationshipType: 'mentions',
+            confidence: 'medium',
+        });
+    }
+}
+function stripLineComments(sourceText) {
+    return sourceText
+        .split(/\r?\n/)
+        .map((line) => line.replace(/--.*$/, ''))
+        .join('\n');
+}
+function splitStatements(sourceText) {
+    const statements = [];
+    let current = '';
+    let startLine = 1;
+    let lineNumber = 1;
+    for (const line of sourceText.split(/\r?\n/)) {
+        if (!current.trim()) {
+            startLine = lineNumber;
+        }
+        current += `${line}\n`;
+        if (line.includes(';')) {
+            statements.push({
+                text: current,
+                startLine,
+                endLine: lineNumber,
+            });
+            current = '';
+        }
+        lineNumber += 1;
+    }
+    if (current.trim()) {
+        statements.push({ text: current, startLine, endLine: lineNumber - 1 });
+    }
+    return statements;
+}
+function compact(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function normalizeSqlIdentifier(value) {
+    return value.replace(/^"+|"+$/g, '').replace(/[;,)]$/, '');
+}
+function referencedTables(statement) {
+    const names = new Set();
+    const patterns = [
+        /\bREFERENCES\s+("?[\w.]+"?)/gi,
+        /\bFROM\s+("?[\w.]+"?)/gi,
+        /\bJOIN\s+("?[\w.]+"?)/gi,
+        /\bUPDATE\s+("?[\w.]+"?)/gi,
+        /\bINTO\s+("?[\w.]+"?)/gi,
+    ];
+    for (const pattern of patterns) {
+        for (const match of statement.matchAll(pattern)) {
+            if (match[1])
+                names.add(normalizeSqlIdentifier(match[1]));
+        }
+    }
+    return [...names];
+}

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

@@ -1,5 +1,4 @@
 import { Language, Tree } from 'web-tree-sitter';
-type GrammarKey = 'python' | 'java' | 'kotlin' | 'go' | 'rust' | 'c' | 'cpp' | 'c_sharp';
+export type GrammarKey = 'python' | 'java' | 'kotlin' | 'go' | 'rust' | 'c' | 'cpp' | 'c_sharp' | 'php' | 'ruby' | 'bash' | 'yaml' | 'json' | 'html' | 'css' | 'lua' | 'dart' | 'elixir' | 'scala';
 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

@@ -19,6 +19,20 @@ const GRAMMAR_PACKAGES = {
         pkg: 'tree-sitter-c-sharp',
         wasm: 'tree-sitter-c_sharp.wasm',
     },
+    php: { pkg: 'tree-sitter-php', wasm: 'tree-sitter-php.wasm' },
+    ruby: { pkg: 'tree-sitter-ruby', wasm: 'tree-sitter-ruby.wasm' },
+    bash: { pkg: 'tree-sitter-bash', wasm: 'tree-sitter-bash.wasm' },
+    yaml: {
+        pkg: '@tree-sitter-grammars/tree-sitter-yaml',
+        wasm: 'tree-sitter-yaml.wasm',
+    },
+    json: { pkg: 'tree-sitter-json', wasm: 'tree-sitter-json.wasm' },
+    html: { pkg: 'tree-sitter-html', wasm: 'tree-sitter-html.wasm' },
+    css: { pkg: 'tree-sitter-css', wasm: 'tree-sitter-css.wasm' },
+    lua: { pkg: 'tree-sitter-lua', wasm: 'tree-sitter-lua.wasm' },
+    dart: { pkg: 'tree-sitter-dart', wasm: 'tree-sitter-dart.wasm' },
+    elixir: { pkg: 'tree-sitter-elixir', wasm: 'tree-sitter-elixir.wasm' },
+    scala: { pkg: 'tree-sitter-scala', wasm: 'tree-sitter-scala.wasm' },
 };
 async function ensureInit() {
     if (!initPromise) {

package/media/logo.svg

@@ -0,0 +1,29 @@
+<svg width="220" height="220" viewBox="0 0 220 220" fill="none" xmlns="http://www.w3.org/2000/svg" role="img" aria-labelledby="title desc">
+  <title id="title">KGraph Atom Core Logo</title>
+  <desc id="desc">Atom Core logo for KGraph, persistent repository intelligence for AI coding tools.</desc>
+  <defs>
+    <radialGradient id="core" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(110 104) rotate(90) scale(88)">
+      <stop offset="0" stop-color="#22D3EE"/>
+      <stop offset="0.58" stop-color="#38BDF8"/>
+      <stop offset="1" stop-color="#A78BFA"/>
+    </radialGradient>
+    <linearGradient id="orbit" x1="36" y1="56" x2="184" y2="164" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#22D3EE"/>
+      <stop offset="1" stop-color="#C084FC"/>
+    </linearGradient>
+    <filter id="glow" x="12" y="12" width="196" height="196" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+      <feGaussianBlur stdDeviation="6" result="blur"/>
+      <feColorMatrix in="blur" type="matrix" values="0 0 0 0 0.133 0 0 0 0 0.827 0 0 0 0 0.933 0 0 0 0.42 0"/>
+      <feBlend in="SourceGraphic"/>
+    </filter>
+  </defs>
+  <circle cx="110" cy="110" r="78" fill="#0F172A" fill-opacity="0.82" stroke="#1E293B" stroke-width="2"/>
+  <g filter="url(#glow)" stroke="url(#orbit)" stroke-width="6" stroke-linecap="round">
+    <ellipse cx="110" cy="110" rx="76" ry="28" transform="rotate(-23 110 110)"/>
+    <ellipse cx="110" cy="110" rx="76" ry="28" transform="rotate(23 110 110)"/>
+    <ellipse cx="110" cy="110" rx="28" ry="76"/>
+  </g>
+  <circle cx="110" cy="110" r="19" fill="url(#core)"/>
+  <circle cx="164" cy="70" r="7" fill="#22D3EE"/>
+  <circle cx="62" cy="148" r="6" fill="#C084FC"/>
+</svg>