token-pilot 0.8.3 → 0.10.0

package/dist/handlers/outline.js

@@ -1,7 +1,7 @@
 import { readdir, stat } from 'node:fs/promises';
 import { resolve, basename, relative } from 'node:path';
 import { resolveSafePath } from '../core/validation.js';
-const CODE_EXTENSIONS = new Set([
+export const CODE_EXTENSIONS = new Set([
     'ts', 'tsx', 'js', 'jsx', 'mjs', 'py', 'go', 'rs', 'java', 'kt', 'kts',
     'swift', 'cs', 'cpp', 'cc', 'cxx', 'hpp', 'c', 'h', 'php', 'rb', 'scala',
     'dart', 'lua', 'sh', 'bash', 'sql', 'r', 'vue', 'svelte', 'pl', 'pm',
@@ -22,7 +22,28 @@ export async function handleOutline(args, projectRoot, astIndex) {
                 }],
         };
     }
-    // List code files and subdirectories (1 level)
+    const recursive = args.recursive ?? false;
+    const maxDepth = args.max_depth ?? 2;
+    const sections = [];
+    await outlineDir(absPath, sections, 0, recursive ? maxDepth : 0, projectRoot, astIndex);
+    sections.push('HINT: Use outline(path) on subdirs, smart_read(path) for file structure, read_symbol(path, symbol) for source code.');
+    return { content: [{ type: 'text', text: sections.join('\n') }] };
+}
+/** Max output lines to prevent runaway recursive outlines */
+const MAX_OUTLINE_LINES = 500;
+/**
+ * Outline a single directory. When depth < maxDepth and recursive,
+ * recurse into subdirectories. Otherwise show file counts only.
+ */
+export async function outlineDir(absPath, sections, depth, maxDepth, projectRoot, astIndex) {
+    // Guard: stop if output is already too large
+    if (sections.length >= MAX_OUTLINE_LINES) {
+        if (!sections[sections.length - 1]?.startsWith('⚠')) {
+            sections.push(`⚠ Output truncated at ${MAX_OUTLINE_LINES} lines. Use outline() on specific subdirectories for details.`);
+        }
+        return;
+    }
+    // List code files and subdirectories
     const entries = await readdir(absPath, { withFileTypes: true });
     const codeFiles = [];
     const subdirs = [];
@@ -38,53 +59,63 @@ export async function handleOutline(args, projectRoot, astIndex) {
         }
     }
     if (codeFiles.length === 0 && subdirs.length === 0) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `No code files or subdirectories found in "${args.path}".`,
-                }],
-        };
+        if (depth === 0) {
+            sections.push(`No code files or subdirectories found in "${relative(projectRoot, absPath) || '.'}".`);
+        }
+        return;
     }
     // Sort
     codeFiles.sort();
     subdirs.sort();
     const relDir = relative(projectRoot, absPath) || '.';
+    const indent = '  '.repeat(depth);
     const totalLabel = codeFiles.length > 0 ? `${codeFiles.length} files` : '';
     const subLabel = subdirs.length > 0 ? `${subdirs.length} subdirs` : '';
     const countLabel = [totalLabel, subLabel].filter(Boolean).join(', ');
-    const sections = [`OUTLINE: ${relDir}/ (${countLabel})`, ''];
-    // Show subdirectories with file counts (recursive scan)
+    sections.push(`${indent}OUTLINE: ${relDir}/ (${countLabel})`);
+    sections.push('');
+    // Show subdirectories
     if (subdirs.length > 0) {
-        for (const sub of subdirs) {
-            const subPath = resolve(absPath, sub);
-            const fileCount = await countCodeFiles(subPath);
-            sections.push(`  ${sub}/ (${fileCount} code files)`);
+        if (depth < maxDepth) {
+            // Recursive: outline each subdir
+            for (const sub of subdirs) {
+                const subPath = resolve(absPath, sub);
+                await outlineDir(subPath, sections, depth + 1, maxDepth, projectRoot, astIndex);
+            }
+        }
+        else {
+            // Non-recursive: show file counts only
+            for (const sub of subdirs) {
+                const subPath = resolve(absPath, sub);
+                const fileCount = await countCodeFiles(subPath);
+                sections.push(`${indent}  ${sub}/ (${fileCount} code files)`);
+            }
+            sections.push('');
         }
-        sections.push('');
     }
     // Show code files at this level with AST outline
+    const fileIndent = '  '.repeat(depth + 1);
+    const symbolIndent = depth + 2;
     for (const filePath of codeFiles) {
         const name = basename(filePath);
         try {
             const structure = await astIndex.outline(filePath);
             if (!structure) {
-                sections.push(`${name} (no AST)`);
+                sections.push(`${fileIndent}${name} (no AST)`);
                 sections.push('');
                 continue;
             }
-            sections.push(`${name} (${structure.meta.lines} lines)`);
+            sections.push(`${fileIndent}${name} (${structure.meta.lines} lines)`);
             for (const sym of structure.symbols) {
-                formatCompactSymbol(sym, sections, 1);
+                formatCompactSymbol(sym, sections, symbolIndent);
             }
             sections.push('');
         }
         catch {
-            sections.push(`${name} (outline failed)`);
+            sections.push(`${fileIndent}${name} (outline failed)`);
             sections.push('');
         }
     }
-    sections.push('HINT: Use outline(path) on subdirs, smart_read(path) for file structure, read_symbol(path, symbol) for source code.');
-    return { content: [{ type: 'text', text: sections.join('\n') }] };
 }
 /**
  * Format a symbol in compact outline form.

package/dist/handlers/project-overview.d.ts

@@ -1,5 +1,6 @@
 import type { AstIndexClient } from '../ast-index/client.js';
-export declare function handleProjectOverview(projectRoot: string, astIndex: AstIndexClient): Promise<{
+import type { ProjectOverviewArgs } from '../core/validation.js';
+export declare function handleProjectOverview(args: ProjectOverviewArgs, projectRoot: string, astIndex: AstIndexClient): Promise<{
     content: Array<{
         type: 'text';
         text: string;

package/dist/handlers/project-overview.js

@@ -1,78 +1,109 @@
-import { readFile } from 'node:fs/promises';
-import { resolve, basename } from 'node:path';
-export async function handleProjectOverview(projectRoot, astIndex) {
+import { detectProject } from '../core/project-detector.js';
+export async function handleProjectOverview(args, projectRoot, astIndex) {
     const lines = [];
-    // 1. Project info from package.json / Cargo.toml etc.
-    const projectInfo = await detectProjectInfo(projectRoot);
-    if (projectInfo) {
-        lines.push(`PROJECT: ${projectInfo.name} v${projectInfo.version}`);
-        if (projectInfo.description)
-            lines.push(`  ${projectInfo.description}`);
-        lines.push('');
-    }
-    else {
-        lines.push(`PROJECT: ${basename(projectRoot)}`);
-        lines.push('');
-    }
-    // 2. ast-index map — directory structure with file counts and symbol kinds
+    // 1. Dual detection: ast-index + config scanner
+    let astIndexType;
+    let mapData = null;
+    let convData = null;
     if (astIndex.isAvailable() && !astIndex.isOversized() && !astIndex.isDisabled()) {
-        const [mapData, convData] = await Promise.all([
+        [mapData, convData] = await Promise.all([
             astIndex.map(),
             astIndex.conventions(),
         ]);
         if (mapData) {
-            lines.push(`TYPE: ${mapData.project_type} (${mapData.file_count} files)`);
-            lines.push('');
-            // Conventions
-            if (convData) {
-                if (convData.architecture.length > 0) {
-                    lines.push(`ARCHITECTURE: ${convData.architecture.join(', ')}`);
-                }
-                const fwList = [];
-                for (const [category, frameworks] of Object.entries(convData.frameworks)) {
-                    for (const fw of frameworks) {
-                        fwList.push(`${fw.name} (${category})`);
-                    }
-                }
-                if (fwList.length > 0) {
-                    lines.push(`FRAMEWORKS: ${fwList.join(', ')}`);
-                }
-                if (convData.naming_patterns.length > 0) {
-                    const patterns = convData.naming_patterns
-                        .slice(0, 8)
-                        .map(p => `${p.suffix}(${p.count})`)
-                        .join(', ');
-                    lines.push(`PATTERNS: ${patterns}`);
-                }
-                lines.push('');
-            }
-            // Directory map
-            lines.push('MAP:');
-            for (const group of mapData.groups) {
-                const kinds = group.kinds
-                    ? ' — ' + Object.entries(group.kinds).map(([k, v]) => `${v} ${k}`).join(', ')
-                    : '';
-                lines.push(`  ${group.path} (${group.file_count} files${kinds})`);
-            }
-            lines.push('');
+            astIndexType = mapData.project_type;
+        }
+    }
+    const detection = await detectProject(projectRoot, astIndexType);
+    // Determine which sections to include
+    const include = args.include ?? ['stack', 'ci', 'quality', 'architecture'];
+    const showStack = include.includes('stack');
+    const showCI = include.includes('ci');
+    const showQuality = include.includes('quality');
+    const showArch = include.includes('architecture');
+    // 2. Project identity
+    lines.push(`PROJECT: ${detection.projectName} v${detection.projectVersion}`);
+    if (detection.projectDescription)
+        lines.push(`  ${detection.projectDescription}`);
+    lines.push('');
+    // 3. TYPE — dual detection
+    if (showStack) {
+        if (astIndexType) {
+            lines.push(`TYPE (ast-index): ${astIndexType}${mapData ? ` (${mapData.file_count} files)` : ''}`);
+        }
+        if (detection.configStacks.length > 0) {
+            const configLine = formatConfigStacks(detection);
+            lines.push(`TYPE (config): ${configLine}`);
+        }
+        if (detection.configStacks.length === 0 && !astIndexType) {
+            lines.push('TYPE: unknown (no config files found)');
+        }
+        // Confidence
+        lines.push(`CONFIDENCE: ${detection.confidence}${getConfidenceHint(detection)}`);
+        lines.push('');
+    }
+    // 4. Architecture & frameworks (from ast-index conventions)
+    if (showArch && convData) {
+        if (convData.architecture.length > 0) {
+            lines.push(`ARCHITECTURE: ${convData.architecture.join(', ')}`);
+        }
+        // Merge framework info: ast-index conventions + config detection
+        const fwList = buildFrameworkList(convData, detection);
+        if (fwList.length > 0) {
+            lines.push(`FRAMEWORKS: ${fwList.join(', ')}`);
+        }
+        if (convData.naming_patterns.length > 0) {
+            const patterns = convData.naming_patterns
+                .slice(0, 8)
+                .map(p => `${p.suffix}(${p.count})`)
+                .join(', ');
+            lines.push(`PATTERNS: ${patterns}`);
+        }
+        lines.push('');
+    }
+    // 5. Quality tools
+    if (showQuality && detection.qualityTools.length > 0) {
+        lines.push(`QUALITY: ${detection.qualityTools.join(', ')}`);
+    }
+    // 6. CI pipelines
+    if (showCI && detection.ciPipelines.length > 0) {
+        lines.push(`CI: ${detection.ciPipelines.join(', ')}`);
+    }
+    // Docker
+    if (showCI && detection.hasDocker) {
+        lines.push('DOCKER: yes');
+    }
+    if ((showQuality && detection.qualityTools.length > 0) || (showCI && detection.ciPipelines.length > 0)) {
+        lines.push('');
+    }
+    // 7. Directory map (from ast-index)
+    if (showArch && mapData) {
+        lines.push('MAP:');
+        for (const group of mapData.groups) {
+            const kinds = group.kinds
+                ? ' — ' + Object.entries(group.kinds).map(([k, v]) => `${v} ${k}`).join(', ')
+                : '';
+            lines.push(`  ${group.path} (${group.file_count} files${kinds})`);
         }
-        else {
-            // Fallback to stats
-            try {
-                const statsText = await astIndex.stats();
-                if (statsText) {
-                    const filesMatch = statsText.match(/Files:\s*(\d+)/);
-                    const symbolsMatch = statsText.match(/Symbols:\s*(\d+)/);
-                    if (filesMatch)
-                        lines.push(`Files indexed: ${filesMatch[1]}`);
-                    if (symbolsMatch)
-                        lines.push(`Symbols: ${symbolsMatch[1]}`);
-                    lines.push('');
-                }
+        lines.push('');
+    }
+    else if (showArch && !mapData && astIndex.isAvailable() && !astIndex.isDisabled() && !astIndex.isOversized()) {
+        // Fallback to stats
+        try {
+            const statsText = await astIndex.stats();
+            if (statsText) {
+                const filesMatch = statsText.match(/Files:\s*(\d+)/);
+                const symbolsMatch = statsText.match(/Symbols:\s*(\d+)/);
+                if (filesMatch)
+                    lines.push(`Files indexed: ${filesMatch[1]}`);
+                if (symbolsMatch)
+                    lines.push(`Symbols: ${symbolsMatch[1]}`);
+                lines.push('');
             }
-            catch { /* ignore */ }
         }
+        catch { /* ignore */ }
     }
+    // 8. Degradation warnings
     if (astIndex.isDisabled()) {
         lines.push('⚠ ast-index: project root not detected. Call smart_read() on any project file first.');
         lines.push('  Working tools: smart_read, smart_read_many, outline, read_symbol, read_range');
@@ -88,47 +119,55 @@ export async function handleProjectOverview(projectRoot, astIndex) {
     lines.push('HINT: Use smart_read() on files, find_usages() for symbol references, outline() for directory overview.');
     return { content: [{ type: 'text', text: lines.join('\n') }] };
 }
-async function detectProjectInfo(projectRoot) {
-    try {
-        const pkg = JSON.parse(await readFile(resolve(projectRoot, 'package.json'), 'utf-8'));
-        return {
-            name: pkg.name ?? basename(projectRoot),
-            version: pkg.version ?? '0.0.0',
-            description: pkg.description,
-            type: 'Node.js/TypeScript',
-        };
-    }
-    catch { /* not a node project */ }
-    try {
-        const composer = JSON.parse(await readFile(resolve(projectRoot, 'composer.json'), 'utf-8'));
-        return {
-            name: composer.name ?? 'unknown',
-            version: composer.version ?? '0.0.0',
-            description: composer.description,
-            type: 'PHP',
-        };
-    }
-    catch { /* not a php project */ }
-    try {
-        const cargo = await readFile(resolve(projectRoot, 'Cargo.toml'), 'utf-8');
-        const name = cargo.match(/^name\s*=\s*"(.+?)"/m)?.[1] ?? 'unknown';
-        const version = cargo.match(/^version\s*=\s*"(.+?)"/m)?.[1] ?? '0.0.0';
-        return { name, version, type: 'Rust' };
-    }
-    catch { /* not a rust project */ }
-    try {
-        const pyproject = await readFile(resolve(projectRoot, 'pyproject.toml'), 'utf-8');
-        const name = pyproject.match(/^name\s*=\s*"(.+?)"/m)?.[1] ?? 'unknown';
-        const version = pyproject.match(/^version\s*=\s*"(.+?)"/m)?.[1] ?? '0.0.0';
-        return { name, version, type: 'Python' };
-    }
-    catch { /* not a python project */ }
-    try {
-        const gomod = await readFile(resolve(projectRoot, 'go.mod'), 'utf-8');
-        const name = gomod.match(/^module\s+(.+)/m)?.[1] ?? 'unknown';
-        return { name, version: '0.0.0', type: 'Go' };
-    }
-    catch { /* not a go project */ }
-    return null;
+// ──────────────────────────────────────────────
+// Formatters
+// ──────────────────────────────────────────────
+function formatConfigStacks(detection) {
+    if (detection.configStacks.length === 0)
+        return 'unknown';
+    const parts = [];
+    for (const stack of detection.configStacks) {
+        let part = stack.type;
+        if (stack.langVersion)
+            part = stack.langVersion;
+        if (stack.framework)
+            part += ` (${stack.framework})`;
+        parts.push(part);
+    }
+    if (detection.primaryStack && detection.configStacks.length > 1) {
+        // Put primary first, mark others
+        const primaryIdx = detection.configStacks.indexOf(detection.primaryStack);
+        if (primaryIdx > 0) {
+            const [primary] = parts.splice(primaryIdx, 1);
+            parts.unshift(primary);
+        }
+        return parts[0] + (parts.length > 1 ? ` + ${parts.slice(1).join(', ')}` : '');
+    }
+    return parts.join(', ');
+}
+function getConfidenceHint(detection) {
+    if (detection.confidence === 'low') {
+        return ` — ast-index and config files disagree on project type`;
+    }
+    if (detection.confidence === 'medium' && detection.configStacks.length > 1) {
+        return ` — multi-stack project detected`;
+    }
+    return '';
+}
+function buildFrameworkList(convData, detection) {
+    const fwSet = new Set();
+    // From ast-index conventions
+    for (const [category, frameworks] of Object.entries(convData.frameworks)) {
+        for (const fw of frameworks) {
+            fwSet.add(`${fw.name} (${category})`);
+        }
+    }
+    // From config detection (may have version info that conventions don't)
+    for (const stack of detection.configStacks) {
+        if (stack.framework && !Array.from(fwSet).some(f => f.includes(stack.framework.split(' ')[0]))) {
+            fwSet.add(stack.framework);
+        }
+    }
+    return Array.from(fwSet);
 }
 //# sourceMappingURL=project-overview.js.map

package/dist/handlers/smart-diff.d.ts

@@ -0,0 +1,35 @@
+import type { AstIndexClient } from '../ast-index/client.js';
+import type { SmartDiffArgs } from '../core/validation.js';
+import type { FileStructure } from '../types.js';
+interface FileDiff {
+    path: string;
+    oldPath?: string;
+    addedLines: number;
+    removedLines: number;
+    hunks: DiffHunk[];
+    isBinary: boolean;
+    isNew: boolean;
+    isDeleted: boolean;
+}
+interface DiffHunk {
+    newStart: number;
+    newCount: number;
+    lines: string[];
+}
+interface SymbolChange {
+    name: string;
+    kind: string;
+    changeType: 'MODIFIED' | 'ADDED' | 'REMOVED';
+    lineRange: string;
+}
+export declare function handleSmartDiff(args: SmartDiffArgs, projectRoot: string, astIndex: AstIndexClient): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    rawTokens: number;
+}>;
+export declare function parseUnifiedDiff(raw: string): FileDiff[];
+export declare function mapHunksToSymbols(hunks: DiffHunk[], structure: FileStructure): SymbolChange[];
+export {};
+//# sourceMappingURL=smart-diff.d.ts.map