token-pilot 0.9.0 → 0.12.0

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

package/dist/handlers/smart-diff.js

@@ -0,0 +1,269 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { resolve } from 'node:path';
+import { estimateTokens } from '../core/token-estimator.js';
+const execFileAsync = promisify(execFile);
+// ──────────────────────────────────────────────
+// Handler
+// ──────────────────────────────────────────────
+const SMALL_DIFF_THRESHOLD = 30;
+const MAX_FILES = 50;
+const MAX_OUTPUT_LINES = 500;
+export async function handleSmartDiff(args, projectRoot, astIndex) {
+    // 1. Build git command
+    const gitArgs = buildGitArgs(args);
+    // 2. Execute git diff
+    let rawDiff;
+    try {
+        const { stdout } = await execFileAsync('git', gitArgs, {
+            cwd: projectRoot,
+            timeout: 10000,
+            maxBuffer: 5 * 1024 * 1024,
+        });
+        rawDiff = stdout;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('not a git repository') || msg.includes('fatal:')) {
+            return { content: [{ type: 'text', text: 'Not a git repository. smart_diff requires git.' }], rawTokens: 0 };
+        }
+        return { content: [{ type: 'text', text: `git diff failed: ${msg}` }], rawTokens: 0 };
+    }
+    const rawTokens = estimateTokens(rawDiff);
+    if (!rawDiff.trim()) {
+        const scopeLabel = args.scope ?? 'unstaged';
+        return {
+            content: [{ type: 'text', text: `NO CHANGES (${scopeLabel}): working tree is clean.` }],
+            rawTokens: 0,
+        };
+    }
+    // 3. Parse unified diff
+    const fileDiffs = parseUnifiedDiff(rawDiff);
+    if (fileDiffs.length === 0) {
+        return {
+            content: [{ type: 'text', text: 'NO CHANGES: diff parsed but no file changes found.' }],
+            rawTokens,
+        };
+    }
+    // 4. Map hunks to symbols (parallel, capped)
+    const filesToProcess = fileDiffs.slice(0, MAX_FILES);
+    const symbolChanges = new Map();
+    const outlineResults = await Promise.allSettled(filesToProcess
+        .filter(f => !f.isBinary && !f.isDeleted)
+        .map(async (f) => {
+        const absPath = resolve(projectRoot, f.path);
+        const structure = await astIndex.outline(absPath);
+        return { path: f.path, structure };
+    }));
+    for (const result of outlineResults) {
+        if (result.status === 'fulfilled' && result.value.structure) {
+            const { path, structure } = result.value;
+            const fd = filesToProcess.find(f => f.path === path);
+            if (fd) {
+                symbolChanges.set(path, mapHunksToSymbols(fd.hunks, structure));
+            }
+        }
+    }
+    // 5. Format output
+    const output = formatSmartDiff(fileDiffs, filesToProcess, symbolChanges, args, rawTokens);
+    return { content: [{ type: 'text', text: output }], rawTokens };
+}
+// ──────────────────────────────────────────────
+// Git command builder
+// ──────────────────────────────────────────────
+function buildGitArgs(args) {
+    const base = [];
+    switch (args.scope) {
+        case 'staged':
+            base.push('diff', '--cached', '--no-color');
+            break;
+        case 'commit':
+            base.push('show', '--format=', '--no-color', args.ref);
+            break;
+        case 'branch':
+            base.push('diff', '--no-color', `${args.ref}...HEAD`);
+            break;
+        case 'unstaged':
+        default:
+            base.push('diff', '--no-color');
+            break;
+    }
+    if (args.path) {
+        base.push('--', args.path);
+    }
+    return base;
+}
+// ──────────────────────────────────────────────
+// Unified diff parser
+// ──────────────────────────────────────────────
+export function parseUnifiedDiff(raw) {
+    const files = [];
+    let current = null;
+    let currentHunk = null;
+    for (const line of raw.split('\n')) {
+        // New file
+        if (line.startsWith('diff --git ')) {
+            if (current)
+                files.push(current);
+            const match = line.match(/diff --git a\/(.+?) b\/(.+)/);
+            current = {
+                path: match?.[2] ?? '',
+                oldPath: match?.[1] !== match?.[2] ? match?.[1] : undefined,
+                addedLines: 0,
+                removedLines: 0,
+                hunks: [],
+                isBinary: false,
+                isNew: false,
+                isDeleted: false,
+            };
+            currentHunk = null;
+            continue;
+        }
+        if (!current)
+            continue;
+        if (line.startsWith('new file mode')) {
+            current.isNew = true;
+        }
+        else if (line.startsWith('deleted file mode')) {
+            current.isDeleted = true;
+        }
+        else if (line.startsWith('Binary files')) {
+            current.isBinary = true;
+        }
+        else if (line.startsWith('rename from ')) {
+            current.oldPath = line.slice(12);
+        }
+        else if (line.startsWith('@@ ')) {
+            const match = line.match(/@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+            currentHunk = {
+                newStart: match ? parseInt(match[1], 10) : 0,
+                newCount: match?.[2] ? parseInt(match[2], 10) : 1,
+                lines: [],
+            };
+            current.hunks.push(currentHunk);
+        }
+        else if (currentHunk) {
+            if (line.startsWith('+') && !line.startsWith('+++')) {
+                current.addedLines++;
+                currentHunk.lines.push(line);
+            }
+            else if (line.startsWith('-') && !line.startsWith('---')) {
+                current.removedLines++;
+                currentHunk.lines.push(line);
+            }
+            else if (line.startsWith(' ')) {
+                currentHunk.lines.push(line);
+            }
+        }
+    }
+    if (current)
+        files.push(current);
+    return files;
+}
+// ──────────────────────────────────────────────
+// Symbol mapping
+// ──────────────────────────────────────────────
+function flattenSymbols(symbols, prefix = '') {
+    const result = [];
+    for (const sym of symbols) {
+        const name = prefix ? `${prefix}.${sym.name}` : sym.name;
+        result.push({
+            name,
+            kind: sym.kind,
+            start: sym.location.startLine,
+            end: sym.location.endLine,
+        });
+        if (sym.children.length > 0) {
+            result.push(...flattenSymbols(sym.children, sym.kind === 'class' || sym.kind === 'interface' ? sym.name : ''));
+        }
+    }
+    return result;
+}
+export function mapHunksToSymbols(hunks, structure) {
+    const allSymbols = flattenSymbols(structure.symbols);
+    const changedSymbols = new Map();
+    // Classify hunks: all-added, all-removed, or mixed
+    const hasAdded = hunks.some(h => h.lines.some(l => l.startsWith('+')));
+    const hasRemoved = hunks.some(h => h.lines.some(l => l.startsWith('-')));
+    for (const hunk of hunks) {
+        const hunkStart = hunk.newStart;
+        const hunkEnd = hunk.newCount > 0
+            ? hunk.newStart + hunk.newCount - 1
+            : hunk.newStart; // pure deletion: use newStart as point
+        for (const sym of allSymbols) {
+            if (hunkStart <= sym.end && hunkEnd >= sym.start) {
+                if (!changedSymbols.has(sym.name)) {
+                    // Determine changeType from hunk content
+                    let changeType = 'MODIFIED';
+                    if (hasAdded && !hasRemoved)
+                        changeType = 'ADDED';
+                    else if (hasRemoved && !hasAdded)
+                        changeType = 'REMOVED';
+                    changedSymbols.set(sym.name, {
+                        name: sym.name,
+                        kind: sym.kind,
+                        changeType,
+                        lineRange: `[L${sym.start}-${sym.end}]`,
+                    });
+                }
+            }
+        }
+    }
+    return Array.from(changedSymbols.values());
+}
+// ──────────────────────────────────────────────
+// Output formatter
+// ──────────────────────────────────────────────
+function formatSmartDiff(allFiles, processedFiles, symbolChanges, args, rawTokens) {
+    const totalAdded = allFiles.reduce((s, f) => s + f.addedLines, 0);
+    const totalRemoved = allFiles.reduce((s, f) => s + f.removedLines, 0);
+    const scopeLabel = args.scope ?? 'unstaged';
+    const lines = [];
+    lines.push(`CHANGES: ${allFiles.length} file${allFiles.length !== 1 ? 's' : ''}, +${totalAdded} -${totalRemoved} (${scopeLabel})`);
+    lines.push('');
+    for (const fd of processedFiles) {
+        if (lines.length >= MAX_OUTPUT_LINES) {
+            lines.push(`... truncated (${allFiles.length - processedFiles.indexOf(fd)} more files)`);
+            break;
+        }
+        // File header
+        const changeLabel = fd.isNew ? ' [NEW]' : fd.isDeleted ? ' [DELETED]' : '';
+        const renameLabel = fd.oldPath ? ` (renamed from ${fd.oldPath})` : '';
+        const binaryLabel = fd.isBinary ? ' [BINARY]' : '';
+        lines.push(`${fd.path} (+${fd.addedLines} -${fd.removedLines})${changeLabel}${renameLabel}${binaryLabel}`);
+        if (fd.isBinary) {
+            lines.push('');
+            continue;
+        }
+        // Symbol changes
+        const symbols = symbolChanges.get(fd.path);
+        if (symbols && symbols.length > 0) {
+            for (const sc of symbols) {
+                const parens = ['function', 'method'].includes(sc.kind) ? '()' : '';
+                lines.push(`  ${sc.changeType}: ${sc.name}${parens} ${sc.lineRange}`);
+            }
+        }
+        // Small diff: include actual hunks
+        const totalHunkLines = fd.hunks.reduce((s, h) => s + h.lines.length, 0);
+        if (totalHunkLines <= SMALL_DIFF_THRESHOLD && totalHunkLines > 0) {
+            for (const hunk of fd.hunks) {
+                lines.push(`    @@ L${hunk.newStart}`);
+                for (const hl of hunk.lines) {
+                    lines.push(`    ${hl}`);
+                }
+            }
+        }
+        else if (totalHunkLines > SMALL_DIFF_THRESHOLD) {
+            lines.push(`  (${totalHunkLines} lines changed — use read_symbol for details)`);
+        }
+        lines.push('');
+    }
+    if (allFiles.length > MAX_FILES) {
+        lines.push(`Showing ${MAX_FILES} of ${allFiles.length} changed files. Use path filter to narrow.`);
+        lines.push('');
+    }
+    lines.push(`HINT: Use read_symbol(path, symbol) to see full changed code, read_diff(path) for line-level diff.`);
+    lines.push(`RAW DIFF: ~${rawTokens} tokens → smart_diff: ~${estimateTokens(lines.join('\n'))} tokens`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=smart-diff.js.map

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

@@ -0,0 +1,21 @@
+import type { SmartLogArgs } from '../core/validation.js';
+export interface LogEntry {
+    hash: string;
+    date: string;
+    author: string;
+    message: string;
+    category: 'feat' | 'fix' | 'refactor' | 'docs' | 'test' | 'chore' | 'style' | 'perf' | 'other';
+    files: string[];
+    insertions: number;
+    deletions: number;
+}
+export declare function handleSmartLog(args: SmartLogArgs, projectRoot: string): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    rawTokens: number;
+}>;
+export declare function parseGitLog(raw: string): LogEntry[];
+export declare function categorizeCommit(message: string): LogEntry['category'];
+//# sourceMappingURL=smart-log.d.ts.map

package/dist/handlers/smart-log.js

@@ -0,0 +1,200 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { estimateTokens } from '../core/token-estimator.js';
+const execFileAsync = promisify(execFile);
+// ──────────────────────────────────────────────
+// Constants
+// ──────────────────────────────────────────────
+const RECORD_SEPARATOR = '<<<SEP>>>';
+const FIELD_SEPARATOR = '<<<F>>>';
+const MAX_COUNT = 50;
+// ──────────────────────────────────────────────
+// Handler
+// ──────────────────────────────────────────────
+export async function handleSmartLog(args, projectRoot) {
+    const count = Math.min(args.count ?? 10, MAX_COUNT);
+    const ref = args.ref ?? 'HEAD';
+    // Build git log command with --numstat for file stats
+    const gitArgs = [
+        'log',
+        `--format=${RECORD_SEPARATOR}%h${FIELD_SEPARATOR}%ad${FIELD_SEPARATOR}%an${FIELD_SEPARATOR}%s`,
+        '--date=short',
+        '--numstat',
+        `-n`, `${count}`,
+        '--', ref,
+    ];
+    if (args.path) {
+        gitArgs.push('--', args.path);
+    }
+    let rawOutput;
+    try {
+        const { stdout } = await execFileAsync('git', gitArgs, {
+            cwd: projectRoot,
+            timeout: 10000,
+            maxBuffer: 5 * 1024 * 1024,
+        });
+        rawOutput = stdout;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: `git log failed: ${msg}` }],
+            rawTokens: 0,
+        };
+    }
+    if (!rawOutput.trim()) {
+        return {
+            content: [{ type: 'text', text: 'No commits found.' }],
+            rawTokens: 0,
+        };
+    }
+    const rawTokens = estimateTokens(rawOutput);
+    const entries = parseGitLog(rawOutput);
+    const formatted = formatSmartLog(entries, args.path);
+    return {
+        content: [{ type: 'text', text: formatted }],
+        rawTokens,
+    };
+}
+// ──────────────────────────────────────────────
+// Parser
+// ──────────────────────────────────────────────
+export function parseGitLog(raw) {
+    const records = raw.split(RECORD_SEPARATOR).filter(r => r.trim());
+    const entries = [];
+    for (const record of records) {
+        const lines = record.trim().split('\n');
+        if (lines.length === 0)
+            continue;
+        const headerLine = lines[0];
+        const fields = headerLine.split(FIELD_SEPARATOR);
+        if (fields.length < 4)
+            continue;
+        const [hash, date, author, message] = fields;
+        // Parse numstat lines (insertions\tdeletions\tfile)
+        const files = [];
+        let insertions = 0;
+        let deletions = 0;
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            const parts = line.split('\t');
+            if (parts.length >= 3) {
+                const ins = parts[0] === '-' ? 0 : parseInt(parts[0], 10) || 0;
+                const del = parts[1] === '-' ? 0 : parseInt(parts[1], 10) || 0;
+                insertions += ins;
+                deletions += del;
+                files.push(parts.slice(2).join('\t'));
+            }
+        }
+        entries.push({
+            hash,
+            date,
+            author,
+            message,
+            category: categorizeCommit(message),
+            files,
+            insertions,
+            deletions,
+        });
+    }
+    return entries;
+}
+// ──────────────────────────────────────────────
+// Categorizer
+// ──────────────────────────────────────────────
+export function categorizeCommit(message) {
+    const lower = message.toLowerCase();
+    // Conventional commits prefix
+    if (/^feat[:(!\s]/.test(lower))
+        return 'feat';
+    if (/^fix[:(!\s]/.test(lower))
+        return 'fix';
+    if (/^refactor[:(!\s]/.test(lower))
+        return 'refactor';
+    if (/^docs?[:(!\s]/.test(lower))
+        return 'docs';
+    if (/^tests?[:(!\s]/.test(lower))
+        return 'test';
+    if (/^chore[:(!\s]/.test(lower))
+        return 'chore';
+    if (/^style[:(!\s]/.test(lower))
+        return 'style';
+    if (/^perf[:(!\s]/.test(lower))
+        return 'perf';
+    // Version bumps
+    if (/^v?\d+\.\d+/.test(lower))
+        return 'feat';
+    // Keyword heuristics with word boundaries (order matters — more specific first)
+    if (/\b(fix|bug|hotfix)\b/.test(lower) || /\bpatch\b/.test(lower))
+        return 'fix';
+    if (/\b(tests?|specs?|coverage)\b/.test(lower))
+        return 'test';
+    if (/\b(refactor|restructure|rename|extract)\b/.test(lower) || /\bmove\b/.test(lower))
+        return 'refactor';
+    if (/\b(docs?|documentation|readme|changelog)\b/.test(lower))
+        return 'docs';
+    if (/\b(add|new|implement|feature)\b/.test(lower))
+        return 'feat';
+    if (/\b(style|format|lint)\b/.test(lower))
+        return 'style';
+    if (/\b(perf|optimiz\w*|speed|faster?)\b/.test(lower))
+        return 'perf';
+    if (/\b(chore|bump|deps)\b/.test(lower) || /\bci\b/.test(lower) || /\bbuild\b/.test(lower))
+        return 'chore';
+    return 'other';
+}
+// ──────────────────────────────────────────────
+// Formatter
+// ──────────────────────────────────────────────
+function formatSmartLog(entries, pathFilter) {
+    if (entries.length === 0)
+        return 'No commits found.';
+    const lines = [];
+    // Header
+    const filterInfo = pathFilter ? ` (filtered: ${pathFilter})` : '';
+    lines.push(`GIT LOG: ${entries.length} commits${filterInfo}`);
+    lines.push('');
+    // Summary stats
+    const authors = new Map();
+    const categories = new Map();
+    let totalIns = 0;
+    let totalDel = 0;
+    for (const e of entries) {
+        authors.set(e.author, (authors.get(e.author) ?? 0) + 1);
+        categories.set(e.category, (categories.get(e.category) ?? 0) + 1);
+        totalIns += e.insertions;
+        totalDel += e.deletions;
+    }
+    // Category summary
+    const catParts = [];
+    for (const [cat, count] of Array.from(categories.entries()).sort((a, b) => b[1] - a[1])) {
+        catParts.push(`${cat}:${count}`);
+    }
+    lines.push(`BREAKDOWN: ${catParts.join(', ')} | +${totalIns}/-${totalDel} lines`);
+    // Authors
+    const authorParts = Array.from(authors.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([name, cnt]) => authors.size > 1 ? `${name} (${cnt})` : name);
+    lines.push(`AUTHORS: ${authorParts.join(', ')}`);
+    lines.push('');
+    // Entries
+    for (const e of entries) {
+        const filesSummary = e.files.length <= 3
+            ? e.files.join(', ')
+            : `${e.files.slice(0, 3).join(', ')} +${e.files.length - 3} more`;
+        const stats = e.insertions + e.deletions > 0
+            ? ` (+${e.insertions}/-${e.deletions})`
+            : '';
+        lines.push(`${e.hash} ${e.date} [${e.category}] ${e.message}${stats}`);
+        if (e.files.length > 0) {
+            lines.push(`  → ${filesSummary}`);
+        }
+    }
+    lines.push('');
+    lines.push('HINT: Use smart_diff(scope="commit", ref="<hash>") to see structural changes for a specific commit.');
+    return lines.join('\n');
+}
+//# sourceMappingURL=smart-log.js.map

package/dist/handlers/test-summary.d.ts

@@ -0,0 +1,25 @@
+import type { TestSummaryArgs } from '../core/validation.js';
+export interface TestResult {
+    total: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    duration?: string;
+    failures: FailedTest[];
+    suites?: number;
+}
+export interface FailedTest {
+    name: string;
+    file?: string;
+    error: string;
+}
+export declare function handleTestSummary(args: TestSummaryArgs, projectRoot: string): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    rawTokens: number;
+}>;
+export declare function detectRunner(command: string, output: string): string;
+export declare function parseTestOutput(output: string, runner: string): TestResult;
+//# sourceMappingURL=test-summary.d.ts.map