@kentwynn/kgraph 0.2.22 → 0.2.23

package/README.md

@@ -41,22 +41,33 @@ The CLI presents this as **Atom Core**: lightweight local atoms plus determinist
 
 ## The Workflow
 
-Use KGraph in two steps:
+Use KGraph with one setup command and one normal daily command:
 
 ```bash
-# Required once per repository
-kgraph init --integrations codex,copilot,cursor,claude-code,gemini,windsurf,cline
+# Required once per repository.
+# Creates .kgraph/, runs the first scan, and detects likely AI tools.
+kgraph init
 
-# Normal daily command
+# Normal daily command.
+# Refreshes maps, processes pending capture notes, and returns focused context.
 kgraph "auth token refresh"
 ```
 
-That second command runs the full practical workflow:
+AI tool integrations are optional. During `kgraph init`, KGraph detects likely local tools such as Codex, Copilot, Claude Code, and Gemini, then prompts or prints a suggested `kgraph integrate add ...` command. You can accept the recommendation, choose custom integrations, skip the step, or configure them later.
+
+If you already know exactly which integrations you want, you can pass them during init:
+
+```bash
+kgraph init --integrations codex,copilot,cursor,claude-code,gemini,windsurf,cline
+```
+
+The daily command runs the full practical workflow:
 
 1. Refreshes the repository scan.
 2. Updates file, symbol, import, and relationship maps.
 3. Processes any Markdown capture notes waiting in `.kgraph/inbox/` into knowledge atoms.
-4. Returns compact context for the topic you asked about.
+4. Reports memory health and actionable next steps.
+5. Returns compact context for the topic you asked about.
 
 You can also run just:
 
@@ -134,10 +145,11 @@ KGraph's core functionality is free and local-first. It does not require account
 From the root of a repository:
 
 ```bash
-# 1. Create the local KGraph workspace
+# 1. Create the local KGraph workspace and run the first scan
 kgraph init
 
-# 2. Optional: connect AI tools so they know the KGraph workflow
+# 2. Optional: accept detected AI tool recommendations during init,
+# or add integrations later when you want KGraph-managed instructions
 kgraph integrate add codex copilot cursor claude-code gemini windsurf cline
 
 # 3. Run the normal workflow for a topic
@@ -147,7 +159,7 @@ kgraph "auth token refresh"
 kgraph doctor
 ```
 
-`kgraph init` now scans once, then prints relevant next steps. When KGraph can detect likely AI tools on the machine, it recommends matching integrations.
+`kgraph init` scans once, prints repo language coverage, detects likely local AI tools, and recommends matching integrations. Integrations are still optional: they only write local instruction files so tools know when to run KGraph. They do not start background agents or call AI providers.
 
 After useful AI work, assistants save durable runtime-capture notes into `.kgraph/inbox/`. These notes are not project documentation; they are KGraph input files that the next `kgraph` run processes automatically. You can also process them directly with `kgraph update`.
 
@@ -183,13 +195,13 @@ This is optional. Claude Code can use generated hook scripts for automatic captu
 kgraph init
 ```
 
-Required once per repo. Creates `.kgraph/`, writes the local config, runs the first scan, and prints suggested next actions based on the detected repo languages and likely local AI tools.
+Required once per repo. Creates `.kgraph/`, writes the local config, initializes the knowledge store, runs the first scan, detects likely local AI tools, and prints suggested next actions based on repo languages and detected tools.
 
 ```bash
 kgraph init --integrations codex,copilot,cursor,claude-code,gemini,windsurf,cline
 ```
 
-Initializes KGraph and writes local instruction files for supported AI tools.
+Initializes KGraph and immediately writes local instruction files for the named AI tools. This is optional; plain `kgraph init` can detect likely tools and recommend or prompt for integrations instead.
 
 ```bash
 kgraph "some topic"
@@ -356,6 +368,10 @@ Show processed capture history. Add a query to find historical work by title, su
 
 KGraph integrations are local files. They do not start background agents, call AI providers, or send data anywhere.
 
+You do not need integrations to use KGraph manually. They are useful when you want Codex, Copilot, Cursor, Claude Code, Gemini, Windsurf, or Cline to see repo-local KGraph workflow instructions automatically.
+
+`kgraph init` detects likely local tools and recommends integrations when possible. You can also manage them explicitly:
+
 ```bash
 kgraph integrate add codex copilot cursor claude-code gemini windsurf cline
 kgraph integrate add copilot --mode smart
@@ -424,9 +440,17 @@ KGraph deeply scans:
 - Java and Kotlin
 - C and C++
 - C#
+- PHP
+- Ruby
+- Shell
+- SQL
 
 Other languages keep practical file, import, and symbol depth without full call graph analysis. Common file types still appear in the file map with generic metadata, so context queries can still point to docs, config, SQL, CSS, HTML, YAML, and similar files.
 
+KGraph also extracts basic symbols/imports for Swift, Terraform/HCL,
+GraphQL, Protocol Buffers, Lua, Dart, Elixir, Scala, and R. Structured file extraction covers
+YAML, JSON, TOML, Dockerfile/Containerfile, Markdown/MDX, HTML, CSS, SCSS, Sass, Less, and XML.
+
 ## Visualization
 
 ```bash

package/dist/cli/help.js

@@ -20,7 +20,7 @@ export function renderRootHelp(useColor = supportsColor()) {
         '',
         sectionTitle(theme, `${accent} Start`),
         command('init', 'Required once: create .kgraph/ workspace'),
-        command('init --integrations codex,gemini', 'Initialize and connect AI tools'),
+        command('init --integrations codex,gemini', 'Optional: initialize and connect named AI tools'),
         '',
         sectionTitle(theme, `${accent} Daily workflow`),
         command('kgraph', 'Refresh scan maps and process pending capture notes'),
@@ -68,7 +68,8 @@ export function renderRootHelp(useColor = supportsColor()) {
         command('--capture-symbol <name>', 'Attach symbol evidence to root capture'),
         '',
         sectionTitle(theme, `${accent} Examples`),
-        '  kgraph init --integrations codex,copilot,cursor,claude-code,gemini,windsurf,cline',
+        '  kgraph init',
+        '  kgraph integrate add codex copilot cursor claude-code gemini windsurf cline',
         '  kgraph "blog admin token usage"',
         '  kgraph "blog admin token usage" --final',
         '  kgraph "blog admin token usage" --capture "Author filter now uses display names" --capture-file www/app/blog/page.tsx',

package/dist/cli/init-summary.d.ts

@@ -1,7 +1,7 @@
 import type { IntegrationConfig } from '../types/config.js';
 import type { RepositoryFile } from '../types/maps.js';
 import { type InitIntegrationRecommendation } from './init-recommendations.js';
-type CoverageLevel = 'deep' | 'basic' | 'generic';
+type CoverageLevel = 'deep' | 'basic' | 'structured' | 'generic';
 export interface InitLanguageSummary {
     language: string;
     label: string;

package/dist/cli/init-summary.js

@@ -12,15 +12,32 @@ const LANGUAGE_PRESENTATION = {
     c: { label: 'C', coverage: 'deep' },
     cpp: { label: 'C++', coverage: 'deep' },
     csharp: { label: 'C#', coverage: 'deep' },
-    yaml: { label: 'YAML', coverage: 'generic' },
-    json: { label: 'JSON', coverage: 'generic' },
-    toml: { label: 'TOML', coverage: 'generic' },
-    xml: { label: 'XML', coverage: 'generic' },
-    graphql: { label: 'GraphQL', coverage: 'generic' },
-    sql: { label: 'SQL', coverage: 'generic' },
-    shell: { label: 'Shell', coverage: 'generic' },
+    php: { label: 'PHP', coverage: 'deep' },
+    swift: { label: 'Swift', coverage: 'basic' },
+    ruby: { label: 'Ruby', coverage: 'deep' },
+    shell: { label: 'Shell', coverage: 'deep' },
+    lua: { label: 'Lua', coverage: 'basic' },
+    dart: { label: 'Dart', coverage: 'basic' },
+    elixir: { label: 'Elixir', coverage: 'basic' },
+    scala: { label: 'Scala', coverage: 'basic' },
+    r: { label: 'R', coverage: 'basic' },
+    sql: { label: 'SQL', coverage: 'deep' },
+    terraform: { label: 'Terraform/HCL', coverage: 'basic' },
+    graphql: { label: 'GraphQL', coverage: 'basic' },
+    protobuf: { label: 'Protocol Buffers', coverage: 'basic' },
+    yaml: { label: 'YAML', coverage: 'structured' },
+    json: { label: 'JSON', coverage: 'structured' },
+    toml: { label: 'TOML', coverage: 'structured' },
+    dockerfile: { label: 'Dockerfile', coverage: 'structured' },
+    markdown: { label: 'Markdown', coverage: 'structured' },
+    html: { label: 'HTML', coverage: 'structured' },
+    css: { label: 'CSS', coverage: 'structured' },
+    scss: { label: 'SCSS', coverage: 'structured' },
+    sass: { label: 'Sass', coverage: 'structured' },
+    less: { label: 'Less', coverage: 'structured' },
+    xml: { label: 'XML', coverage: 'structured' },
 };
-const EXCLUDED_LANGUAGES = new Set(['unknown', 'markdown', 'restructuredtext']);
+const EXCLUDED_LANGUAGES = new Set(['unknown', 'restructuredtext']);
 export function summarizeInitLanguages(files) {
     const byLabel = new Map();
     for (const file of files) {
@@ -103,6 +120,7 @@ function moreDetailedCoverage(left, right) {
     const rank = {
         deep: 3,
         basic: 2,
+        structured: 2,
         generic: 1,
     };
     return rank[left] >= rank[right] ? left : right;
@@ -113,6 +131,8 @@ function coverageDescription(coverage) {
             return 'deep built-in extraction';
         case 'basic':
             return 'basic built-in extraction';
+        case 'structured':
+            return 'structured file extraction';
         default:
             return 'generic file coverage';
     }

package/dist/config/config.js

@@ -67,6 +67,47 @@ export const DEFAULT_CONFIG = {
             '.hxx',
             // C#
             '.cs',
+            // PHP / Swift / Ruby
+            '.php',
+            '.swift',
+            '.rb',
+            '.rake',
+            // Shell
+            '.sh',
+            '.bash',
+            '.zsh',
+            '.fish',
+            // Web / styles
+            '.html',
+            '.htm',
+            '.css',
+            '.scss',
+            '.sass',
+            '.less',
+            // Data / config / schema
+            '.json',
+            '.jsonc',
+            '.yaml',
+            '.yml',
+            '.toml',
+            '.dockerfile',
+            '.xml',
+            '.graphql',
+            '.gql',
+            '.sql',
+            '.tf',
+            '.proto',
+            // Docs
+            '.md',
+            '.mdx',
+            // Additional app languages
+            '.lua',
+            '.r',
+            '.R',
+            '.dart',
+            '.ex',
+            '.exs',
+            '.scala',
         ],
     },
     maxContextItems: 8,

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

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

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kentwynn/kgraph",
-  "version": "0.2.22",
+  "version": "0.2.23",
   "description": "Persistent repo intelligence for AI coding assistants.",
   "type": "module",
   "bin": {
@@ -45,16 +45,27 @@
   "dependencies": {
     "@clack/prompts": "^1.3.0",
     "@tree-sitter-grammars/tree-sitter-kotlin": "^1.1.0",
+    "@tree-sitter-grammars/tree-sitter-yaml": "^0.7.1",
     "chalk": "^5.6.2",
     "commander": "^12.1.0",
     "fast-glob": "^3.3.2",
+    "tree-sitter-bash": "^0.25.1",
     "tree-sitter-c": "^0.24.1",
     "tree-sitter-c-sharp": "^0.23.5",
     "tree-sitter-cpp": "^0.23.4",
+    "tree-sitter-css": "^0.25.0",
+    "tree-sitter-dart": "^1.0.0",
+    "tree-sitter-elixir": "^0.3.5",
     "tree-sitter-go": "^0.25.0",
+    "tree-sitter-html": "^0.23.2",
     "tree-sitter-java": "^0.23.5",
+    "tree-sitter-json": "^0.24.8",
+    "tree-sitter-lua": "^2.1.3",
+    "tree-sitter-php": "^0.24.2",
     "tree-sitter-python": "^0.25.0",
+    "tree-sitter-ruby": "^0.23.1",
     "tree-sitter-rust": "^0.24.0",
+    "tree-sitter-scala": "^0.24.0",
     "typescript": "^5.9.3",
     "web-tree-sitter": "^0.26.8",
     "yaml": "^2.5.1"