@kentwynn/kgraph 0.2.21 → 0.2.23

package/README.md

@@ -1,6 +1,39 @@
-# KGraph
-
-Persistent repository intelligence for AI coding tools.
+<div align="center">
+
+<img src="media/logo.svg" alt="KGraph Atom Core Logo" width="140" height="140">
+
+# KGraph: Persistent repository intelligence for AI coding tools.
+
+<strong>atoms · evidence · context packs</strong>
+
+<p>
+  <a href="https://www.npmjs.com/package/@kentwynn/kgraph">
+    <img src="https://img.shields.io/npm/v/@kentwynn/kgraph?label=npm" alt="npm version">
+  </a>
+  <a href="https://github.com/kentwynn/KGraph/releases/latest">
+    <img src="https://img.shields.io/github/v/release/kentwynn/KGraph?label=release" alt="Latest release">
+  </a>
+  <a href="https://github.com/kentwynn/KGraph/actions/workflows/ci.yml">
+    <img src="https://img.shields.io/github/actions/workflow/status/kentwynn/KGraph/ci.yml?branch=main&label=ci" alt="CI">
+  </a>
+  <a href="https://github.com/kentwynn/KGraph/blob/main/LICENSE">
+    <img src="https://img.shields.io/github/license/kentwynn/KGraph" alt="License">
+  </a>
+  <a href="https://nodejs.org/">
+    <img src="https://img.shields.io/badge/node-%3E%3D20-339933?logo=node.js&logoColor=white" alt="Node.js >=20">
+  </a>
+  <a href="https://github.com/kentwynn/KGraph/security/policy">
+    <img src="https://img.shields.io/badge/security-policy-0f766e" alt="Security policy">
+  </a>
+  <a href="https://github.com/kentwynn/KGraph/wiki">
+    <img src="https://img.shields.io/badge/docs-wiki-blue" alt="Documentation">
+  </a>
+  <a href="https://github.com/kentwynn/KGraph/stargazers">
+    <img src="https://img.shields.io/github/stars/kentwynn/KGraph?style=social" alt="GitHub stars">
+  </a>
+</p>
+
+</div>
 
 KGraph gives Codex, GitHub Copilot, Cursor, Claude Code, Gemini CLI, Windsurf, and Cline a local knowledge layer for your repo: file maps, symbols, imports, relationships, and durable knowledge atoms from previous AI sessions. The goal is simple: your assistant should not spend every session re-learning the same codebase.
 
@@ -8,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:
 
@@ -101,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
@@ -114,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`.
 
@@ -150,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"
@@ -323,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
@@ -391,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;