token-pilot 0.14.2 → 0.16.0

package/dist/ast-index/enricher.d.ts

@@ -0,0 +1,10 @@
+/**
+ * File structure enrichment functions.
+ * Reads file content and adds Python/PHP method extraction, signatures, etc.
+ */
+import type { FileStructure } from '../types.js';
+import type { AstIndexOutlineEntry } from './types.js';
+export declare function buildFileStructure(filePath: string, entries: AstIndexOutlineEntry[]): Promise<FileStructure>;
+/** Fix the last entry's end_line to use actual file line count */
+export declare function fixLastEndLine(entries: AstIndexOutlineEntry[], totalLines: number): void;
+//# sourceMappingURL=enricher.d.ts.map

package/dist/ast-index/enricher.js

@@ -0,0 +1,202 @@
+/**
+ * File structure enrichment functions.
+ * Reads file content and adds Python/PHP method extraction, signatures, etc.
+ */
+import { stat, readFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { detectLanguage, mapOutlineEntry } from './parser.js';
+export async function buildFileStructure(filePath, entries) {
+    const content = await readFile(filePath, 'utf-8');
+    const lines = content.split('\n');
+    const fileStat = await stat(filePath);
+    fixLastEndLine(entries, lines.length);
+    const lang = detectLanguage(filePath);
+    if (lang === 'Python') {
+        enrichPythonClassMethods(entries, lines);
+    }
+    else if (lang === 'PHP') {
+        enrichPHPClassMethods(entries, lines);
+    }
+    enrichSignatures(entries, lines);
+    return {
+        path: filePath,
+        language: lang,
+        meta: {
+            lines: lines.length,
+            bytes: fileStat.size,
+            lastModified: fileStat.mtimeMs,
+            contentHash: createHash('sha256').update(content).digest('hex'),
+        },
+        imports: [],
+        exports: [],
+        symbols: entries.map(e => mapOutlineEntry(e)),
+    };
+}
+/**
+ * Python: ast-index doesn't return methods inside classes.
+ * Parse file content to extract `def` methods for classes without children.
+ */
+function enrichPythonClassMethods(entries, lines) {
+    for (const entry of entries) {
+        if (entry.kind.toLowerCase() !== 'class')
+            continue;
+        if (entry.children && entry.children.length > 0)
+            continue;
+        const classStartIdx = entry.start_line - 1; // 0-based
+        const classEndIdx = entry.end_line - 1;
+        // Detect class body indent: look for first `def ` inside class range
+        let bodyIndent = -1;
+        for (let i = classStartIdx + 1; i <= classEndIdx && i < lines.length; i++) {
+            const defMatch = lines[i].match(/^(\s+)def\s/);
+            if (defMatch) {
+                bodyIndent = defMatch[1].length;
+                break;
+            }
+        }
+        if (bodyIndent < 0)
+            continue; // no methods found
+        const methods = [];
+        for (let i = classStartIdx + 1; i <= classEndIdx && i < lines.length; i++) {
+            const line = lines[i];
+            // Match `def method_name(` at the detected indent level
+            const match = line.match(new RegExp(`^\\s{${bodyIndent}}def\\s+(\\w+)\\s*\\(`));
+            if (!match)
+                continue;
+            const methodName = match[1];
+            const methodLine = i + 1; // 1-based
+            const isAsync = line.includes('async def');
+            const isStatic = i > 0 && /^\s*@staticmethod/.test(lines[i - 1]);
+            const isClassMethod = i > 0 && /^\s*@classmethod/.test(lines[i - 1]);
+            // Collect decorators above
+            const decorators = [];
+            for (let d = i - 1; d >= classStartIdx; d--) {
+                const decMatch = lines[d].match(new RegExp(`^\\s{${bodyIndent}}@(\\w+)`));
+                if (decMatch) {
+                    decorators.unshift(`@${decMatch[1]}`);
+                }
+                else {
+                    break;
+                }
+            }
+            // Determine visibility from name
+            const visibility = methodName.startsWith('__') && !methodName.endsWith('__')
+                ? 'private'
+                : methodName.startsWith('_')
+                    ? 'protected'
+                    : 'public';
+            methods.push({
+                name: methodName,
+                kind: isStatic || isClassMethod ? 'function' : 'method',
+                start_line: methodLine,
+                end_line: 0, // computed below
+                signature: line.trim(),
+                visibility,
+                is_async: isAsync,
+                is_static: isStatic,
+                decorators: decorators.length > 0 ? decorators : undefined,
+            });
+        }
+        // Compute end_lines for methods
+        for (let m = 0; m < methods.length; m++) {
+            if (m < methods.length - 1) {
+                const nextStart = methods[m + 1].start_line;
+                let endLine = nextStart - 1;
+                for (let k = nextStart - 2; k >= methods[m].start_line; k--) {
+                    const l = lines[k];
+                    if (l.trim() === '' || new RegExp(`^\\s{${bodyIndent}}@`).test(l)) {
+                        endLine = k;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                methods[m].end_line = endLine;
+            }
+            else {
+                methods[m].end_line = entry.end_line;
+            }
+        }
+        entry.children = methods;
+    }
+}
+/**
+ * PHP: ast-index doesn't return methods inside classes.
+ * Parse file content to extract `function` methods for classes without children.
+ */
+function enrichPHPClassMethods(entries, lines) {
+    for (const entry of entries) {
+        if (entry.kind.toLowerCase() !== 'class')
+            continue;
+        if (entry.children && entry.children.length > 0)
+            continue;
+        const classStartIdx = entry.start_line - 1;
+        const classEndIdx = entry.end_line - 1;
+        // Detect class body indent: look for first `function ` inside class range
+        let bodyIndent = -1;
+        for (let i = classStartIdx + 1; i <= classEndIdx && i < lines.length; i++) {
+            const fnMatch = lines[i].match(/^(\s+)(?:public|private|protected|static|\s)*function\s/);
+            if (fnMatch) {
+                bodyIndent = fnMatch[1].length;
+                break;
+            }
+        }
+        if (bodyIndent < 0)
+            continue;
+        const methods = [];
+        for (let i = classStartIdx + 1; i <= classEndIdx && i < lines.length; i++) {
+            const line = lines[i];
+            // Match PHP method: [visibility] [static] function name(
+            const match = line.match(new RegExp(`^\\s{${bodyIndent}}(?:(public|private|protected)\\s+)?(?:(static)\\s+)?function\\s+(\\w+)\\s*\\(`));
+            if (!match)
+                continue;
+            const visibility = match[1] ?? 'public';
+            const isStatic = !!match[2];
+            const methodName = match[3];
+            const methodLine = i + 1;
+            methods.push({
+                name: methodName,
+                kind: isStatic ? 'function' : 'method',
+                start_line: methodLine,
+                end_line: 0,
+                signature: line.trim(),
+                visibility,
+                is_static: isStatic,
+            });
+        }
+        // Compute end_lines
+        for (let m = 0; m < methods.length; m++) {
+            if (m < methods.length - 1) {
+                methods[m].end_line = methods[m + 1].start_line - 1;
+            }
+            else {
+                methods[m].end_line = entry.end_line;
+            }
+        }
+        entry.children = methods;
+    }
+}
+/** Fix the last entry's end_line to use actual file line count */
+export function fixLastEndLine(entries, totalLines) {
+    if (entries.length === 0)
+        return;
+    const last = entries[entries.length - 1];
+    last.end_line = totalLines;
+    if (last.children?.length) {
+        fixLastEndLine(last.children, last.end_line - 1);
+    }
+}
+/** Read actual signature lines from file content */
+function enrichSignatures(entries, lines) {
+    for (const entry of entries) {
+        if (!entry.signature) {
+            const lineIdx = entry.start_line - 1;
+            if (lineIdx >= 0 && lineIdx < lines.length) {
+                entry.signature = lines[lineIdx].trim();
+            }
+        }
+        if (entry.children?.length) {
+            enrichSignatures(entry.children, lines);
+        }
+    }
+}
+//# sourceMappingURL=enricher.js.map

package/dist/ast-index/parser.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Pure parsing functions for ast-index text/JSON output.
+ * No state, no side effects — safe to import anywhere.
+ */
+import type { SymbolInfo, SymbolKind, Visibility } from '../types.js';
+import type { AstIndexOutlineEntry, AstIndexImplementation, AstIndexHierarchyNode, AstIndexImportEntry, AstIndexAgrepMatch, AstIndexTodoEntry, AstIndexDeprecatedEntry, AstIndexAnnotationEntry, AstIndexModuleEntry, AstIndexModuleDep, AstIndexUnusedDep, AstIndexModuleApi } from './types.js';
+export declare function parseFileCount(statsText: string): number;
+/**
+ * Parse text output from `ast-index outline`:
+ *   Outline of src/file.ts:
+ *     :10 ClassName [class]
+ *     :11 propName [property]
+ *     :14 methodName [function]
+ */
+export declare function parseOutlineText(text: string): AstIndexOutlineEntry[];
+export declare function parseImplementationsText(text: string): AstIndexImplementation[];
+export declare function parseHierarchyText(text: string, rootName: string): AstIndexHierarchyNode | null;
+export declare function parseImportsText(text: string): AstIndexImportEntry[];
+export declare function parseAgrepText(text: string): AstIndexAgrepMatch[];
+export declare function parseTodoText(text: string): AstIndexTodoEntry[];
+export declare function parseDeprecatedText(text: string): AstIndexDeprecatedEntry[];
+export declare function parseAnnotationsText(text: string, annotationName: string): AstIndexAnnotationEntry[];
+export declare function parseModuleListText(text: string): AstIndexModuleEntry[];
+export declare function parseModuleDepText(text: string): AstIndexModuleDep[];
+export declare function parseUnusedDepsText(text: string): AstIndexUnusedDep[];
+export declare function parseModuleApiText(text: string): AstIndexModuleApi[];
+export declare function mapKind(kind: string): SymbolKind;
+export declare function mapVisibility(vis?: string): Visibility;
+export declare function detectLanguage(filePath: string): string;
+export declare function mapOutlineEntry(entry: AstIndexOutlineEntry): SymbolInfo;
+//# sourceMappingURL=parser.d.ts.map

package/dist/ast-index/parser.js

@@ -0,0 +1,340 @@
+/**
+ * Pure parsing functions for ast-index text/JSON output.
+ * No state, no side effects — safe to import anywhere.
+ */
+export function parseFileCount(statsText) {
+    try {
+        const json = JSON.parse(statsText);
+        if (json?.stats?.file_count !== undefined)
+            return json.stats.file_count;
+    }
+    catch { /* not JSON, fall through */ }
+    const match = statsText.match(/Files:\s*(\d+)/);
+    return match ? parseInt(match[1], 10) : 0;
+}
+/**
+ * Parse text output from `ast-index outline`:
+ *   Outline of src/file.ts:
+ *     :10 ClassName [class]
+ *     :11 propName [property]
+ *     :14 methodName [function]
+ */
+export function parseOutlineText(text) {
+    const lines = text.split('\n');
+    const entries = [];
+    const classStack = [];
+    for (const line of lines) {
+        const match = line.match(/^(\s*):(\d+)\s+(\S+)\s+\[(\w+)\]/);
+        if (!match)
+            continue;
+        const indent = match[1].length;
+        const entry = {
+            name: match[3],
+            kind: match[4],
+            start_line: parseInt(match[2], 10),
+            end_line: 0,
+        };
+        while (classStack.length > 0 && classStack[classStack.length - 1].indent >= indent) {
+            classStack.pop();
+        }
+        if (classStack.length > 0) {
+            const parent = classStack[classStack.length - 1].entry;
+            if (!parent.children)
+                parent.children = [];
+            parent.children.push(entry);
+        }
+        else {
+            entries.push(entry);
+        }
+        if (['class', 'interface', 'struct', 'enum', 'impl', 'trait', 'namespace', 'module'].includes(entry.kind.toLowerCase())) {
+            classStack.push({ entry, indent });
+        }
+    }
+    computeEndLines(entries);
+    return entries;
+}
+function computeEndLines(entries) {
+    for (let i = 0; i < entries.length; i++) {
+        if (entries[i].children?.length) {
+            computeEndLines(entries[i].children);
+        }
+        if (i < entries.length - 1) {
+            entries[i].end_line = entries[i + 1].start_line - 1;
+        }
+        else {
+            const children = entries[i].children;
+            if (children?.length) {
+                entries[i].end_line = children[children.length - 1].end_line + 1;
+            }
+            else {
+                entries[i].end_line = entries[i].start_line + 10; // estimated
+            }
+        }
+    }
+}
+export function parseImplementationsText(text) {
+    const results = [];
+    for (const line of text.split('\n')) {
+        const m = line.match(/^\s*(class|interface|trait|struct|impl)\s+(\S+)\s+\((.+):(\d+)\)/);
+        if (m) {
+            results.push({ kind: m[1], name: m[2], file: m[3], line: parseInt(m[4], 10) });
+        }
+    }
+    return results;
+}
+export function parseHierarchyText(text, rootName) {
+    if (!text.trim())
+        return null;
+    // Parse ast-index hierarchy text output:
+    //   Hierarchy for 'ClassName':
+    //     Parents:
+    //       ParentClass (extends)
+    //     Children:
+    //       ChildClass (implements)  (file.ts:42)
+    const lines = text.split('\n');
+    const parents = [];
+    const childNodes = [];
+    let section = 'none';
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === 'Parents:') {
+            section = 'parents';
+            continue;
+        }
+        if (trimmed === 'Children:') {
+            section = 'children';
+            continue;
+        }
+        if (trimmed.startsWith('Hierarchy for') || !trimmed)
+            continue;
+        // Match: SymbolName (relationship)  (file:line) — file:line is optional
+        const m = trimmed.match(/^(\S+)\s+\((\w+)\)(?:\s+\((.+):(\d+)\))?/);
+        if (m && section !== 'none') {
+            const node = {
+                name: m[1],
+                kind: m[2],
+                children: [],
+                file: m[3],
+                line: m[4] ? parseInt(m[4], 10) : undefined,
+            };
+            if (section === 'parents')
+                parents.push(node);
+            else
+                childNodes.push(node);
+        }
+    }
+    if (parents.length === 0 && childNodes.length === 0)
+        return null;
+    return { name: rootName, kind: 'class', children: childNodes, parents };
+}
+export function parseImportsText(text) {
+    const entries = [];
+    for (const line of text.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('Imports in') || trimmed.startsWith('Total:'))
+            continue;
+        // Match: { X, Y } from 'source'
+        const braceMatch = trimmed.match(/^\{\s*(.+?)\s*\}\s+from\s+['"](.+?)['"]/);
+        if (braceMatch) {
+            entries.push({ specifiers: braceMatch[1].split(',').map(s => s.trim()), source: braceMatch[2] });
+            continue;
+        }
+        // Match: * as X from 'source'
+        const nsMatch = trimmed.match(/^\*\s+as\s+(\S+)\s+from\s+['"](.+?)['"]/);
+        if (nsMatch) {
+            entries.push({ specifiers: [nsMatch[1]], source: nsMatch[2], isNamespace: true });
+            continue;
+        }
+        // Match: X from 'source' (default import)
+        const defaultMatch = trimmed.match(/^(\w+)\s+from\s+['"](.+?)['"]/);
+        if (defaultMatch) {
+            entries.push({ specifiers: [defaultMatch[1]], source: defaultMatch[2], isDefault: true });
+        }
+    }
+    return entries;
+}
+export function parseAgrepText(text) {
+    const results = [];
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        // Format: file:line:matched_text  OR  file:line: matched_text
+        const match = line.match(/^(.+?):(\d+):(.*)$/);
+        if (match) {
+            results.push({ file: match[1], line: parseInt(match[2], 10), text: match[3].trim() });
+        }
+    }
+    return results;
+}
+export function parseTodoText(text) {
+    const results = [];
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        const match = line.match(/^(.+?):(\d+):\s*(TODO|FIXME|HACK|XXX|NOTE|WARN(?:ING)?)[:\s]+(.*)$/i);
+        if (match) {
+            results.push({ file: match[1], line: parseInt(match[2], 10), kind: match[3].toUpperCase(), text: match[4].trim() });
+        }
+    }
+    return results;
+}
+export function parseDeprecatedText(text) {
+    const results = [];
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        // Try format: kind name (file:line) - message  OR  kind name (file:line)
+        const match = line.match(/^(\w+)\s+(\S+)\s+\((.+?):(\d+)\)(?:\s*-\s*(.+))?$/);
+        if (match) {
+            results.push({ kind: match[1], name: match[2], file: match[3], line: parseInt(match[4], 10), message: match[5]?.trim() });
+        }
+    }
+    return results;
+}
+export function parseAnnotationsText(text, annotationName) {
+    const results = [];
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        // Try format: kind name (file:line)  OR  @Annotation kind name (file:line)
+        const match = line.match(/^(?:@\S+\s+)?(\w+)\s+(\S+)\s+\((.+?):(\d+)\)$/);
+        if (match) {
+            results.push({ kind: match[1], name: match[2], file: match[3], line: parseInt(match[4], 10), annotation: annotationName });
+        }
+    }
+    return results;
+}
+export function parseModuleListText(text) {
+    const results = [];
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (Array.isArray(parsed))
+                return parsed;
+        }
+        catch { /* not JSON, parse as text */ }
+        // Format: name (path) — N files  OR  name (path)  OR  path
+        const match = line.match(/^(\S+)\s+\((.+?)\)(?:\s*—\s*(\d+)\s+files?)?$/);
+        if (match) {
+            results.push({ name: match[1], path: match[2], file_count: match[3] ? parseInt(match[3], 10) : undefined });
+        }
+        else {
+            const trimmed = line.trim();
+            if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('─')) {
+                const name = trimmed.split('/').pop() ?? trimmed;
+                results.push({ name, path: trimmed });
+            }
+        }
+    }
+    return results;
+}
+export function parseModuleDepText(text) {
+    const results = [];
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (Array.isArray(parsed))
+                return parsed;
+        }
+        catch { /* not JSON, parse as text */ }
+        // Format: → name (path)  OR  ← name (path)  OR  name (path)  OR  name
+        const match = line.match(/^[→←\-\s]*(\S+)(?:\s+\((.+?)\))?(?:\s+\[(direct|transitive)\])?$/);
+        if (match) {
+            results.push({ name: match[1], path: match[2] ?? match[1], type: match[3] });
+        }
+    }
+    return results;
+}
+export function parseUnusedDepsText(text) {
+    const results = [];
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (Array.isArray(parsed))
+                return parsed;
+        }
+        catch { /* not JSON, parse as text */ }
+        // Format: ⚠ name (path) — reason  OR  name (path)  OR  name — reason
+        const match = line.match(/^[⚠!\s]*(\S+)(?:\s+\((.+?)\))?(?:\s*[—\-]+\s*(.+))?$/);
+        if (match) {
+            results.push({ name: match[1], path: match[2] ?? match[1], reason: match[3]?.trim() });
+        }
+    }
+    return results;
+}
+export function parseModuleApiText(text) {
+    const results = [];
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (Array.isArray(parsed))
+                return parsed;
+        }
+        catch { /* not JSON, parse as text */ }
+        // Format: kind name (file:line)  OR  kind name signature (file:line)
+        const match = line.match(/^(\w+)\s+(\S+)(?:\s+(.*?))?\s+\((.+?):(\d+)\)$/);
+        if (match) {
+            results.push({ kind: match[1], name: match[2], signature: match[3]?.trim() || undefined, file: match[4], line: parseInt(match[5], 10) });
+        }
+    }
+    return results;
+}
+export function mapKind(kind) {
+    const map = {
+        function: 'function', class: 'class', method: 'method', property: 'property',
+        variable: 'variable', type: 'type', interface: 'interface', enum: 'enum',
+        constant: 'constant', namespace: 'namespace', struct: 'class', trait: 'interface',
+        impl: 'class', module: 'namespace',
+    };
+    return map[kind.toLowerCase()] ?? 'function';
+}
+export function mapVisibility(vis) {
+    if (!vis)
+        return 'default';
+    const map = {
+        public: 'public', private: 'private', protected: 'protected', pub: 'public', export: 'public',
+    };
+    return map[vis.toLowerCase()] ?? 'default';
+}
+export function detectLanguage(filePath) {
+    const ext = filePath.split('.').pop()?.toLowerCase() ?? '';
+    const map = {
+        ts: 'TypeScript', tsx: 'TypeScript', js: 'JavaScript', jsx: 'JavaScript', mjs: 'JavaScript',
+        py: 'Python', go: 'Go', rs: 'Rust', java: 'Java', kt: 'Kotlin', kts: 'Kotlin',
+        swift: 'Swift', cs: 'C#', cpp: 'C++', cc: 'C++', cxx: 'C++', hpp: 'C++', c: 'C', h: 'C',
+        php: 'PHP', rb: 'Ruby', scala: 'Scala', dart: 'Dart', lua: 'Lua',
+        sh: 'Bash', bash: 'Bash', sql: 'SQL', r: 'R', vue: 'Vue', svelte: 'Svelte',
+        pl: 'Perl', pm: 'Perl', ex: 'Elixir', exs: 'Elixir', groovy: 'Groovy',
+        m: 'Objective-C', proto: 'Protocol Buffers', bsl: 'BSL',
+    };
+    return map[ext] ?? 'Unknown';
+}
+export function mapOutlineEntry(entry) {
+    return {
+        name: entry.name,
+        qualifiedName: entry.name,
+        kind: mapKind(entry.kind),
+        signature: entry.signature ?? entry.name,
+        location: {
+            startLine: entry.start_line,
+            endLine: entry.end_line,
+            lineCount: entry.end_line - entry.start_line + 1,
+        },
+        visibility: mapVisibility(entry.visibility),
+        async: entry.is_async ?? false,
+        static: entry.is_static ?? false,
+        decorators: entry.decorators ?? [],
+        children: (entry.children ?? []).map(c => mapOutlineEntry(c)),
+        doc: entry.doc ?? null,
+        references: [],
+    };
+}
+//# sourceMappingURL=parser.js.map

package/dist/ast-index/regex-parser-python.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Regex-based fallback parser for Python.
+ * Used when the ast-index binary is unavailable.
+ * Extracts top-level symbols (classes, functions, variables) and class methods.
+ */
+import type { AstIndexOutlineEntry } from './types.js';
+export declare function parsePythonRegex(content: string): AstIndexOutlineEntry[];
+//# sourceMappingURL=regex-parser-python.d.ts.map