@shrkcrft/graph 0.1.0-alpha.10

package/dist/indexer/extract-kotlin-file.js

@@ -0,0 +1,158 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { EdgeKind } from "../schema/edge-kind.js";
+import { NodeKind } from "../schema/node-kind.js";
+export const EXTRACT_KOTLIN_FILE_SOURCE = 'extract-kotlin-file@v1';
+/**
+ * Regex-based Kotlin extractor.
+ *
+ * Top-level constructs only. Captured:
+ *   - `fun name(...)`, `inline fun`, `suspend fun` → function
+ *   - `class Name`, `data class Name`, `value class Name`, `inline class Name`, `sealed class Name`, `abstract class Name`, `open class Name` → class
+ *   - `interface Name`, `sealed interface Name` → interface
+ *   - `object Name` → object (rendered as `class`)
+ *   - `enum class Name` → enum
+ *   - `typealias Name = ...` → type-alias
+ *   - `val NAME: T`, `var NAME: T`, `const val NAME` → const
+ *
+ * Visibility: Kotlin's default is `public`. `private`, `internal`,
+ * and `protected` mark a symbol as local; everything else is exported.
+ */
+export function extractKotlinFile(fingerprint, absPath, content) {
+    const text = content ?? readFileSync(absPath, 'utf8');
+    const fileNode = makeFileNode(fingerprint, text);
+    const symbolNodes = [];
+    const edges = [];
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i += 1) {
+        const raw = lines[i];
+        if (raw.length === 0)
+            continue;
+        if (raw.startsWith(' ') || raw.startsWith('\t'))
+            continue;
+        if (raw.trimStart().startsWith('//'))
+            continue;
+        // Strip leading annotations (e.g. `@Suppress("...")`, `@JvmStatic`).
+        const stripped = raw.replace(/^(?:@\w+(?:\([^)]*\))?\s+)+/, '');
+        // Detect visibility (default to exported).
+        const visMatch = /^(public|private|internal|protected)\s+/.exec(stripped);
+        const isExported = !visMatch || visMatch[1] === 'public';
+        const afterVis = visMatch ? stripped.slice(visMatch[0].length) : stripped;
+        // Strip declaration modifiers that don't affect the symbol shape.
+        const trimmed = afterVis.replace(/^(?:inline\s+|suspend\s+|tailrec\s+|infix\s+|operator\s+|external\s+|open\s+|abstract\s+|final\s+|sealed\s+|data\s+|value\s+|enum\s+|annotation\s+|inner\s+|companion\s+|expect\s+|actual\s+|override\s+)+/, '');
+        let m = /^fun(?:\s*<[^>]+>)?\s+([A-Za-z_][\w]*)\s*[<(]/.exec(trimmed);
+        if (m) {
+            pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, m[1], 'function', i + 1, isExported);
+            continue;
+        }
+        m = /^class\s+([A-Za-z_][\w]*)/.exec(trimmed);
+        if (m) {
+            pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, m[1], 'class', i + 1, isExported);
+            continue;
+        }
+        m = /^interface\s+([A-Za-z_][\w]*)/.exec(trimmed);
+        if (m) {
+            pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, m[1], 'interface', i + 1, isExported);
+            continue;
+        }
+        m = /^object\s+([A-Za-z_][\w]*)/.exec(trimmed);
+        if (m) {
+            pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, m[1], 'class', i + 1, isExported);
+            continue;
+        }
+        m = /^typealias\s+([A-Za-z_][\w]*)/.exec(trimmed);
+        if (m) {
+            pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, m[1], 'type-alias', i + 1, isExported);
+            continue;
+        }
+        m = /^(?:const\s+)?(?:val|var)\s+([A-Za-z_][\w]*)\s*[:=]/.exec(trimmed);
+        if (m) {
+            pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, m[1], 'const', i + 1, isExported);
+        }
+    }
+    return {
+        fileNode,
+        symbolNodes,
+        edges,
+        rawImportSpecifiers: scanKotlinImports(text),
+        importBindings: [],
+        identifierReferences: [],
+    };
+}
+function pushSymbol(fp, nodes, edges, fileId, name, declKind, line, isExported) {
+    const sym = {
+        id: `symbol:${fp.path}#${name}`,
+        kind: NodeKind.Symbol,
+        label: name,
+        path: fp.path,
+        line,
+        data: { declKind, visibility: isExported ? 'export' : 'local', isExported, language: 'kotlin' },
+    };
+    nodes.push(sym);
+    edges.push({
+        id: createHash('sha1').update(`${fileId}|${sym.id}|${EdgeKind.DeclaresSymbol}`).digest('hex'),
+        from: fileId,
+        to: sym.id,
+        kind: EdgeKind.DeclaresSymbol,
+        source: EXTRACT_KOTLIN_FILE_SOURCE,
+        data: { visibility: isExported ? 'export' : 'local', declKind, line },
+    });
+}
+function makeFileNode(fp, text) {
+    const label = fp.path.split('/').pop() ?? fp.path;
+    const tags = ['kotlin'];
+    if (isKotlinTestPath(fp.path))
+        tags.push('test');
+    const packageMatch = /^package\s+([\w.]+)/m.exec(text);
+    return {
+        id: fp.nodeId,
+        kind: NodeKind.File,
+        label,
+        path: fp.path,
+        tags,
+        data: {
+            language: 'kotlin',
+            sizeBytes: fp.sizeBytes,
+            sha1: fp.sha1,
+            hasDefaultExport: false,
+            exportCount: 0,
+            localCount: 0,
+            reExportCount: 0,
+            ...(packageMatch ? { kotlinPackage: packageMatch[1] } : {}),
+        },
+    };
+}
+function isKotlinTestPath(rel) {
+    return (/(?:^|\/)src\/test\//.test(rel) ||
+        /(?:^|\/)src\/.*Test\//.test(rel) ||
+        /(?:^|\/)[\w-]+Test\.kts?$/.test(rel));
+}
+function scanKotlinImports(text) {
+    const out = [];
+    // Matches `import a.b.C`, `import a.b.*`, `import a.b.C as D`.
+    const re = /^import\s+([\w.]+(?:\.\*)?)(?:\s+as\s+\w+)?\s*$/gm;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const line = lineFromOffset(text, m.index);
+        out.push({ specifier: m[1], line, kind: 'kotlin-import' });
+    }
+    // De-dupe.
+    const seen = new Set();
+    const deduped = [];
+    for (const it of out) {
+        const k = `${it.specifier}|${it.line}`;
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        deduped.push(it);
+    }
+    return deduped;
+}
+function lineFromOffset(text, offset) {
+    let line = 1;
+    for (let i = 0; i < offset && i < text.length; i++) {
+        if (text.charCodeAt(i) === 10)
+            line += 1;
+    }
+    return line;
+}

package/dist/indexer/extract-php-file.d.ts

@@ -0,0 +1,26 @@
+import type { IFileFingerprint } from '../schema/file-fingerprint.js';
+import type { IExtractedFile } from './extract-ts-file.js';
+export declare const EXTRACT_PHP_FILE_SOURCE = "extract-php-file@v1";
+/**
+ * Regex-based PHP extractor.
+ *
+ * Top-level declarations only (after `namespace … {` or at the file's
+ * top level). Detected:
+ *   - `namespace Path\Sub`             → namespace symbol
+ *   - `[abstract|final|readonly] class Name` → class
+ *   - `interface Name`                 → interface
+ *   - `trait Name`                     → class (treated like a mixin)
+ *   - `enum Name`                      → enum
+ *   - `function name(…)`               → function (file-scope)
+ *
+ * Imports: `use Path\To\Class;`, `use Path\To\{A, B as C};`,
+ * `use function Foo\bar`, `use const Foo\BAR`.
+ *
+ * Visibility: PHP requires `class` modifiers on declarations; we
+ * derive `isExported` from the absence of `private`/`protected`.
+ * Class-internal methods are NOT walked here — those live in their
+ * class's body, which the framework-scanner can inspect when it
+ * needs to.
+ */
+export declare function extractPhpFile(fingerprint: IFileFingerprint, absPath: string, content?: string): IExtractedFile;
+//# sourceMappingURL=extract-php-file.d.ts.map

package/dist/indexer/extract-php-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-php-file.d.ts","sourceRoot":"","sources":["../../src/indexer/extract-php-file.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,OAAO,KAAK,EACV,cAAc,EAEf,MAAM,sBAAsB,CAAC;AAE9B,eAAO,MAAM,uBAAuB,wBAAwB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,gBAAgB,EAC7B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,GACf,cAAc,CA+ChB"}

package/dist/indexer/extract-php-file.js

@@ -0,0 +1,161 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { EdgeKind } from "../schema/edge-kind.js";
+import { NodeKind } from "../schema/node-kind.js";
+export const EXTRACT_PHP_FILE_SOURCE = 'extract-php-file@v1';
+/**
+ * Regex-based PHP extractor.
+ *
+ * Top-level declarations only (after `namespace … {` or at the file's
+ * top level). Detected:
+ *   - `namespace Path\Sub`             → namespace symbol
+ *   - `[abstract|final|readonly] class Name` → class
+ *   - `interface Name`                 → interface
+ *   - `trait Name`                     → class (treated like a mixin)
+ *   - `enum Name`                      → enum
+ *   - `function name(…)`               → function (file-scope)
+ *
+ * Imports: `use Path\To\Class;`, `use Path\To\{A, B as C};`,
+ * `use function Foo\bar`, `use const Foo\BAR`.
+ *
+ * Visibility: PHP requires `class` modifiers on declarations; we
+ * derive `isExported` from the absence of `private`/`protected`.
+ * Class-internal methods are NOT walked here — those live in their
+ * class's body, which the framework-scanner can inspect when it
+ * needs to.
+ */
+export function extractPhpFile(fingerprint, absPath, content) {
+    const text = content ?? readFileSync(absPath, 'utf8');
+    const fileNode = makeFileNode(fingerprint, text);
+    const symbolNodes = [];
+    const edges = [];
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i += 1) {
+        const raw = lines[i];
+        if (raw.length === 0)
+            continue;
+        const trimmed = raw.trimStart();
+        if (trimmed.startsWith('//') || trimmed.startsWith('#') || trimmed.startsWith('/*'))
+            continue;
+        // namespace Path\Sub;  OR  namespace Path\Sub { ... }
+        let m = /^namespace\s+([\w\\]+)/.exec(trimmed);
+        if (m) {
+            pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, m[1], 'namespace', i + 1, true);
+            continue;
+        }
+        // Strip attributes `#[Attr]` (PHP 8 attributes).
+        const stripped = trimmed.replace(/^(?:#\[[^\]]*\]\s*)+/, '');
+        // class / interface / trait / enum, allowing modifiers in any order
+        m = /^(?:abstract\s+|final\s+|readonly\s+)*\s*(class|interface|trait|enum)\s+([A-Za-z_]\w*)/.exec(stripped);
+        if (m) {
+            const declKind = m[1] === 'interface' ? 'interface'
+                : m[1] === 'enum' ? 'enum'
+                    : 'class';
+            pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, m[2], declKind, i + 1, true);
+            continue;
+        }
+        // File-level `function name(...)` (not class methods).
+        if (raw.startsWith('function ') || stripped.startsWith('function ')) {
+            m = /^function\s+([A-Za-z_]\w*)\s*\(/.exec(stripped);
+            if (m && !raw.startsWith(' ') && !raw.startsWith('\t')) {
+                pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, m[1], 'function', i + 1, true);
+            }
+        }
+    }
+    return {
+        fileNode,
+        symbolNodes,
+        edges,
+        rawImportSpecifiers: scanPhpImports(text),
+        importBindings: [],
+        identifierReferences: [],
+    };
+}
+function pushSymbol(fp, nodes, edges, fileId, name, declKind, line, isExported) {
+    const sym = {
+        id: `symbol:${fp.path}#${name}`,
+        kind: NodeKind.Symbol,
+        label: name,
+        path: fp.path,
+        line,
+        data: { declKind, visibility: isExported ? 'export' : 'local', isExported, language: 'php' },
+    };
+    nodes.push(sym);
+    edges.push({
+        id: createHash('sha1').update(`${fileId}|${sym.id}|${EdgeKind.DeclaresSymbol}`).digest('hex'),
+        from: fileId,
+        to: sym.id,
+        kind: EdgeKind.DeclaresSymbol,
+        source: EXTRACT_PHP_FILE_SOURCE,
+        data: { visibility: isExported ? 'export' : 'local', declKind, line },
+    });
+}
+function makeFileNode(fp, text) {
+    const label = fp.path.split('/').pop() ?? fp.path;
+    const tags = ['php'];
+    if (isPhpTestPath(fp.path))
+        tags.push('test');
+    const nsMatch = /^namespace\s+([\w\\]+)/m.exec(text);
+    return {
+        id: fp.nodeId,
+        kind: NodeKind.File,
+        label,
+        path: fp.path,
+        tags,
+        data: {
+            language: 'php',
+            sizeBytes: fp.sizeBytes,
+            sha1: fp.sha1,
+            hasDefaultExport: false,
+            exportCount: 0,
+            localCount: 0,
+            reExportCount: 0,
+            ...(nsMatch ? { phpNamespace: nsMatch[1] } : {}),
+        },
+    };
+}
+function isPhpTestPath(rel) {
+    return (/(?:^|\/)(?:tests|test)\//.test(rel) ||
+        /(?:^|\/)[\w-]+Test\.php$/.test(rel) ||
+        /(?:^|\/)[\w-]+\.test\.php$/.test(rel));
+}
+function scanPhpImports(text) {
+    const out = [];
+    // `use Path\To\Class;`, `use Path\To\Class as Alias;`,
+    // `use function Path\to\fn;`, `use const Path\TO\CONST;`,
+    // `use Path\To\{A, B as C};`
+    const re = /^\s*use\s+(?:function\s+|const\s+)?([\w\\]+)(?:\s*\\?\{([^}]+)\})?(?:\s+as\s+\w+)?\s*;/gm;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const line = lineFromOffset(text, m.index);
+        const base = m[1].replace(/\\$/, '');
+        if (m[2]) {
+            for (const item of m[2].split(',')) {
+                const cleaned = item.trim().split(/\s+as\s+/)[0].trim();
+                if (cleaned)
+                    out.push({ specifier: `${base}\\${cleaned}`, line, kind: 'php-use' });
+            }
+        }
+        else {
+            out.push({ specifier: base, line, kind: 'php-use' });
+        }
+    }
+    const seen = new Set();
+    const deduped = [];
+    for (const it of out) {
+        const k = `${it.specifier}|${it.line}`;
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        deduped.push(it);
+    }
+    return deduped;
+}
+function lineFromOffset(text, offset) {
+    let line = 1;
+    for (let i = 0; i < offset && i < text.length; i++) {
+        if (text.charCodeAt(i) === 10)
+            line += 1;
+    }
+    return line;
+}

package/dist/indexer/extract-python-file.d.ts

@@ -0,0 +1,30 @@
+import type { IFileFingerprint } from '../schema/file-fingerprint.js';
+import type { IExtractedFile } from './extract-ts-file.js';
+export declare const EXTRACT_PYTHON_FILE_SOURCE = "extract-python-file@v1";
+/**
+ * Regex-based Python extractor.
+ *
+ * Module-level constructs only — no class/function body inspection, no
+ * cross-reference resolution. The output matches the TS extractor's
+ * `IExtractedFile` shape so the indexer can dispatch by language
+ * without branching downstream.
+ *
+ * What we extract:
+ *   - `def NAME(...)` at column 0 → symbol (function).
+ *   - `class NAME(...)` at column 0 → symbol (class).
+ *   - Top-level CONSTANT_LIKE assignments → symbol (const-ish). Filter:
+ *     identifier is UPPERCASE and at column 0.
+ *   - `import X` / `import X as Y` / `from X import ...` (including
+ *     relative `.` / `..`) → raw import specifiers. Resolution to a
+ *     project-relative file is deferred — Python's import resolution
+ *     depends on `sys.path`, which we don't model in the MVP.
+ *
+ * What we don't extract (yet):
+ *   - Decorators (FastAPI / Flask / Django routes are framework-scanner
+ *     territory).
+ *   - Async functions vs sync (treated identically — both `def`).
+ *   - Nested defs / classes.
+ *   - Type aliases / TypeVar / NewType.
+ */
+export declare function extractPythonFile(fingerprint: IFileFingerprint, absPath: string, content?: string): IExtractedFile;
+//# sourceMappingURL=extract-python-file.d.ts.map

package/dist/indexer/extract-python-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-python-file.d.ts","sourceRoot":"","sources":["../../src/indexer/extract-python-file.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,OAAO,KAAK,EACV,cAAc,EAEf,MAAM,sBAAsB,CAAC;AAE9B,eAAO,MAAM,0BAA0B,2BAA2B,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,gBAAgB,EAC7B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,GACf,cAAc,CAyEhB"}

package/dist/indexer/extract-python-file.js

@@ -0,0 +1,196 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { EdgeKind } from "../schema/edge-kind.js";
+import { NodeKind } from "../schema/node-kind.js";
+export const EXTRACT_PYTHON_FILE_SOURCE = 'extract-python-file@v1';
+/**
+ * Regex-based Python extractor.
+ *
+ * Module-level constructs only — no class/function body inspection, no
+ * cross-reference resolution. The output matches the TS extractor's
+ * `IExtractedFile` shape so the indexer can dispatch by language
+ * without branching downstream.
+ *
+ * What we extract:
+ *   - `def NAME(...)` at column 0 → symbol (function).
+ *   - `class NAME(...)` at column 0 → symbol (class).
+ *   - Top-level CONSTANT_LIKE assignments → symbol (const-ish). Filter:
+ *     identifier is UPPERCASE and at column 0.
+ *   - `import X` / `import X as Y` / `from X import ...` (including
+ *     relative `.` / `..`) → raw import specifiers. Resolution to a
+ *     project-relative file is deferred — Python's import resolution
+ *     depends on `sys.path`, which we don't model in the MVP.
+ *
+ * What we don't extract (yet):
+ *   - Decorators (FastAPI / Flask / Django routes are framework-scanner
+ *     territory).
+ *   - Async functions vs sync (treated identically — both `def`).
+ *   - Nested defs / classes.
+ *   - Type aliases / TypeVar / NewType.
+ */
+export function extractPythonFile(fingerprint, absPath, content) {
+    const text = content ?? readFileSync(absPath, 'utf8');
+    const fileNode = makeFileNode(fingerprint);
+    const symbolNodes = [];
+    const edges = [];
+    // Strip line-leading `#` comments for symbol/import detection so we
+    // don't pick up `def foo` inside a docstring or comment. (Multi-line
+    // string literals are still a hazard — out of scope for the MVP.)
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i += 1) {
+        const raw = lines[i];
+        const line = i + 1;
+        if (raw.length === 0)
+            continue;
+        if (raw[0] === '#')
+            continue; // full-line comment
+        // Module-level `def NAME(...)`.
+        let m = /^def\s+([A-Za-z_][\w]*)\s*\(/.exec(raw);
+        if (m) {
+            const sym = makeSymbol(fingerprint, m[1], 'function', line);
+            symbolNodes.push(sym);
+            edges.push(buildEdge(fileNode.id, sym.id, EdgeKind.DeclaresSymbol, {
+                visibility: 'export',
+                declKind: 'function',
+                line,
+            }));
+            continue;
+        }
+        m = /^async\s+def\s+([A-Za-z_][\w]*)\s*\(/.exec(raw);
+        if (m) {
+            const sym = makeSymbol(fingerprint, m[1], 'function', line);
+            symbolNodes.push(sym);
+            edges.push(buildEdge(fileNode.id, sym.id, EdgeKind.DeclaresSymbol, {
+                visibility: 'export',
+                declKind: 'function',
+                line,
+            }));
+            continue;
+        }
+        // Module-level `class NAME(...)` or `class NAME:`.
+        m = /^class\s+([A-Za-z_][\w]*)\s*[\(:]/.exec(raw);
+        if (m) {
+            const sym = makeSymbol(fingerprint, m[1], 'class', line);
+            symbolNodes.push(sym);
+            edges.push(buildEdge(fileNode.id, sym.id, EdgeKind.DeclaresSymbol, {
+                visibility: 'export',
+                declKind: 'class',
+                line,
+            }));
+            continue;
+        }
+        // Module-level UPPERCASE constant assignment.
+        m = /^([A-Z][A-Z0-9_]+)\s*(?::[^=]+)?=\s*/.exec(raw);
+        if (m) {
+            const sym = makeSymbol(fingerprint, m[1], 'const', line);
+            symbolNodes.push(sym);
+            edges.push(buildEdge(fileNode.id, sym.id, EdgeKind.DeclaresSymbol, {
+                visibility: 'export',
+                declKind: 'const',
+                line,
+            }));
+        }
+    }
+    const rawImportSpecifiers = scanPythonImports(text);
+    return {
+        fileNode,
+        symbolNodes,
+        edges,
+        rawImportSpecifiers,
+        importBindings: [],
+        identifierReferences: [],
+    };
+}
+function makeFileNode(fp) {
+    const label = fp.path.split('/').pop() ?? fp.path;
+    const tags = ['python'];
+    if (isPythonTestPath(fp.path))
+        tags.push('test');
+    return {
+        id: fp.nodeId,
+        kind: NodeKind.File,
+        label,
+        path: fp.path,
+        tags,
+        data: {
+            language: 'python',
+            sizeBytes: fp.sizeBytes,
+            sha1: fp.sha1,
+            hasDefaultExport: false,
+            exportCount: 0,
+            localCount: 0,
+            reExportCount: 0,
+        },
+    };
+}
+function makeSymbol(fp, name, declKind, line) {
+    return {
+        id: `symbol:${fp.path}#${name}`,
+        kind: NodeKind.Symbol,
+        label: name,
+        path: fp.path,
+        line,
+        data: {
+            declKind,
+            visibility: 'export',
+            isExported: true,
+            language: 'python',
+        },
+    };
+}
+function buildEdge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: EXTRACT_PYTHON_FILE_SOURCE,
+        ...(data ? { data } : {}),
+    };
+}
+function isPythonTestPath(rel) {
+    // Common Python conventions: test_<x>.py, <x>_test.py, files under tests/.
+    return (/(?:^|\/)(?:tests?|test)\//.test(rel) ||
+        /(?:^|\/)test_[\w-]+\.py$/.test(rel) ||
+        /(?:^|\/)[\w-]+_test\.py$/.test(rel));
+}
+function scanPythonImports(text) {
+    const out = [];
+    // `from X import Y, Z` (X may include dots: `.relative`, `..parent`, `pkg.sub`)
+    const fromRe = /^from\s+([.\w]+)\s+import\s+/gm;
+    // `import X` or `import X as Y` or `import X, Y, Z`
+    const importRe = /^import\s+([.\w]+(?:\s*,\s*[.\w]+)*)/gm;
+    let m;
+    while ((m = fromRe.exec(text)) !== null) {
+        const line = lineFromOffset(text, m.index);
+        out.push({ specifier: m[1], line, kind: 'from-import' });
+    }
+    while ((m = importRe.exec(text)) !== null) {
+        const line = lineFromOffset(text, m.index);
+        const list = m[1];
+        for (const single of list.split(',')) {
+            const name = single.trim().split(/\s+/)[0];
+            if (name)
+                out.push({ specifier: name, line, kind: 'import' });
+        }
+    }
+    // De-dupe identical (specifier, line, kind).
+    const seen = new Set();
+    const deduped = [];
+    for (const it of out) {
+        const k = `${it.kind}|${it.specifier}|${it.line}`;
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        deduped.push(it);
+    }
+    return deduped;
+}
+function lineFromOffset(text, offset) {
+    let line = 1;
+    for (let i = 0; i < offset && i < text.length; i++) {
+        if (text.charCodeAt(i) === 10)
+            line += 1;
+    }
+    return line;
+}

package/dist/indexer/extract-ruby-file.d.ts

@@ -0,0 +1,29 @@
+import type { IFileFingerprint } from '../schema/file-fingerprint.js';
+import type { IExtractedFile } from './extract-ts-file.js';
+export declare const EXTRACT_RUBY_FILE_SOURCE = "extract-ruby-file@v1";
+/**
+ * Regex-based Ruby extractor.
+ *
+ * Top-level constructs only (column-0):
+ *   - `class Name` / `class Name < Base` → class symbol
+ *   - `module Name` → module symbol
+ *   - `def name` / `def self.name` → function symbol
+ *   - `NAME = …` (uppercase identifier) → const symbol
+ *
+ * Ruby has no public/private declarations at the top level — every
+ * top-level symbol is reachable. All emitted symbols have
+ * `isExported: true` for graph consumers; the `visibility` data field
+ * preserves the explicit modifier (`private` / `protected`) when one
+ * precedes the def, otherwise defaults to `export`.
+ *
+ * Imports: `require '...'`, `require_relative '...'`, `load '...'`.
+ * Specifiers are stored exactly as written, without quotes.
+ *
+ * Out of scope:
+ *   - Method-body inspection (visibility modifiers inside class bodies
+ *     toggle subsequent defs; we don't track that state here).
+ *   - Mixins (`include`, `extend`, `prepend`).
+ *   - Singleton classes / `class << self` blocks.
+ */
+export declare function extractRubyFile(fingerprint: IFileFingerprint, absPath: string, content?: string): IExtractedFile;
+//# sourceMappingURL=extract-ruby-file.d.ts.map

package/dist/indexer/extract-ruby-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-ruby-file.d.ts","sourceRoot":"","sources":["../../src/indexer/extract-ruby-file.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,OAAO,KAAK,EACV,cAAc,EAEf,MAAM,sBAAsB,CAAC;AAE9B,eAAO,MAAM,wBAAwB,yBAAyB,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,gBAAgB,EAC7B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,GACf,cAAc,CA8ChB"}