neuro-cli 4.1.0

package/dist/core/completion.d.ts

@@ -0,0 +1,49 @@
+import { CompleterResult } from 'readline';
+export declare class CompletionEngine {
+    private slashCommands;
+    private modelIds;
+    private agentNames;
+    private cwd;
+    private commandHistory;
+    private maxHistory;
+    private historyPath;
+    private permissionModes;
+    private themes;
+    private mcpSubcommands;
+    private skillSubcommands;
+    private cacheSubcommands;
+    private ignoreSubcommands;
+    private styleNames;
+    private thinkingModes;
+    private effortLevels;
+    private telemetrySubcommands;
+    private syncSubcommands;
+    private voiceSubcommands;
+    private locales;
+    private serverSubcommands;
+    private dashboardSubcommands;
+    private fileExtensions;
+    constructor(cwd?: string);
+    setAgentNames(names: string[]): void;
+    addHistory(command: string): void;
+    private loadHistory;
+    private saveHistory;
+    getHistory(): string[];
+    searchHistory(prefix: string): string[];
+    complete: (line: string) => CompleterResult;
+    private completeSlashCommand;
+    private completeModel;
+    private completeAgent;
+    private completeFilePath;
+    private completeSessionId;
+    private looksLikeFilePath;
+    /**
+     * Display completion suggestions nicely
+     */
+    static displaySuggestions(suggestions: string[]): void;
+    /**
+     * Get contextual help for a partial command
+     */
+    getContextualHelp(partial: string): string | null;
+}
+//# sourceMappingURL=completion.d.ts.map

package/dist/core/completion.js

@@ -0,0 +1,384 @@
+// ============================================================
+// NeuroCLI - Enhanced Tab Completion System
+// Slash commands, file paths, model names, agent names,
+// command history, context-aware suggestions
+// ============================================================
+import { readdirSync, statSync, existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, basename, dirname } from 'path';
+import { homedir } from 'os';
+import { MODELS } from '../api/models.js';
+export class CompletionEngine {
+    slashCommands = new Map();
+    modelIds = [];
+    agentNames = [];
+    cwd;
+    commandHistory = [];
+    maxHistory = 500;
+    historyPath;
+    permissionModes = ['manual', 'auto', 'plan', 'yolo'];
+    themes = ['dracula', 'dark', 'nord', 'light'];
+    mcpSubcommands = ['list', 'add', 'remove', 'connect', 'disconnect', 'health'];
+    skillSubcommands = ['list', 'activate', 'deactivate', 'clear'];
+    cacheSubcommands = ['on', 'off', 'clear', 'stats'];
+    ignoreSubcommands = ['list', 'add', 'check'];
+    styleNames = ['default', 'concise', 'explanatory', 'learning', 'narrative', 'technical', 'review', 'debug'];
+    thinkingModes = ['none', 'brief', 'full', 'ultrathink'];
+    effortLevels = ['low', 'medium', 'high', 'ultrathink'];
+    // P2/P3 new completion lists
+    telemetrySubcommands = ['on', 'off', 'status', 'export', 'clear'];
+    syncSubcommands = ['push', 'pull', 'status', 'config'];
+    voiceSubcommands = ['on', 'off', 'status', 'speak', 'listen'];
+    locales = ['en', 'tr', 'zh', 'ja', 'es'];
+    serverSubcommands = ['start', 'stop', 'status'];
+    dashboardSubcommands = ['start', 'stop', 'status'];
+    fileExtensions = new Map([
+        ['typescript', ['.ts', '.tsx', '.d.ts']],
+        ['javascript', ['.js', '.jsx', '.mjs', '.cjs']],
+        ['python', ['.py', '.pyi', '.pyw']],
+        ['rust', ['.rs']],
+        ['go', ['.go']],
+        ['java', ['.java']],
+        ['config', ['.json', '.yaml', '.yml', '.toml', '.env']],
+        ['web', ['.html', '.css', '.scss', '.vue', '.svelte']],
+        ['docs', ['.md', '.txt', '.rst']],
+    ]);
+    constructor(cwd) {
+        this.cwd = cwd || process.cwd();
+        this.modelIds = Object.keys(MODELS);
+        this.historyPath = join(homedir(), '.neuro', 'history');
+        // Built-in slash commands with descriptions (v3.0 expanded)
+        const commands = [
+            ['help', 'Show help message'],
+            ['model', 'Switch or list models'],
+            ['agent', 'Switch or list agents'],
+            ['auto', 'Auto mode (smart orchestration)'],
+            ['orchestrate', 'Multi-agent orchestration mode'],
+            ['plan', 'Plan mode (read-only)'],
+            ['direct', 'Direct agent mode'],
+            ['plan-mode', 'Plan mode (read-only, no modifications)'],
+            ['stats', 'Show session statistics'],
+            ['theme', 'Switch UI theme'],
+            ['clear', 'Clear terminal'],
+            ['exit', 'Exit NeuroCLI'],
+            ['quit', 'Exit NeuroCLI'],
+            ['resume', 'Resume a previous session'],
+            ['compact', 'Compact conversation context'],
+            ['undo', 'Undo last change'],
+            ['redo', 'Redo undone change'],
+            ['rewind', 'Rewind n changes'],
+            ['mcp', 'Manage MCP servers'],
+            ['fork', 'Fork current session'],
+            ['init', 'Initialize NEURO.md for this project'],
+            ['permission', 'Cycle or set permission mode'],
+            ['perm', 'Alias for /permission'],
+            ['doctor', 'Health check'],
+            ['export', 'Export current session as JSON'],
+            ['import', 'Import a session from JSON file'],
+            ['sandbox', 'Toggle sandbox mode'],
+            ['whitelist', 'Manage tool whitelist'],
+            ['blacklist', 'Manage tool blacklist'],
+            // v3.0 new commands
+            ['style', 'Switch output style (concise, explanatory, learning, etc.)'],
+            ['thinking', 'Toggle thinking mode (none|brief|full|ultrathink)'],
+            ['effort', 'Set effort level (low|medium|high|ultrathink)'],
+            ['skills', 'Manage skills (list|activate|deactivate|clear)'],
+            ['cache', 'Manage prompt cache (on|off|clear|stats)'],
+            ['spending', 'Show detailed spending report'],
+            ['ignore', 'Manage .neuroignore rules'],
+            ['ollama', 'List Ollama local models'],
+            ['cost', 'Show spending and cache report'],
+            ['commit-push-pr', 'Commit + push + create PR'],
+            ['code-review', 'Multi-agent code review'],
+            ['feedback', 'Give feedback'],
+            // P2 new commands
+            ['telemetry', 'Manage telemetry (on|off|status|export|clear)'],
+            ['vim', 'Toggle vim keybindings mode'],
+            ['lang', 'Switch language (en|tr|zh|ja|es)'],
+            ['voice', 'Manage voice I/O (on|off|status|speak|listen)'],
+            ['image', 'Analyze an image file'],
+            // P3 new commands
+            ['server', 'Manage API server (start|stop|status)'],
+            ['sync', 'Cloud sync (push|pull|status|config)'],
+            ['dashboard', 'Manage web dashboard (start|stop|status)'],
+        ];
+        for (const [cmd, desc] of commands) {
+            this.slashCommands.set(cmd, desc);
+        }
+        this.loadHistory();
+    }
+    setAgentNames(names) {
+        this.agentNames = names;
+    }
+    // --- Command History ---
+    addHistory(command) {
+        if (!command.trim())
+            return;
+        // Don't add duplicates at the end
+        if (this.commandHistory.length > 0 && this.commandHistory[this.commandHistory.length - 1] === command)
+            return;
+        this.commandHistory.push(command);
+        if (this.commandHistory.length > this.maxHistory) {
+            this.commandHistory = this.commandHistory.slice(-this.maxHistory);
+        }
+        this.saveHistory();
+    }
+    loadHistory() {
+        try {
+            if (existsSync(this.historyPath)) {
+                const data = readFileSync(this.historyPath, 'utf-8');
+                this.commandHistory = data.split('\n').filter(Boolean).slice(-this.maxHistory);
+            }
+        }
+        catch { /* Ignore */ }
+    }
+    saveHistory() {
+        try {
+            const dir = dirname(this.historyPath);
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            writeFileSync(this.historyPath, this.commandHistory.join('\n'), 'utf-8');
+        }
+        catch { /* Ignore */ }
+    }
+    getHistory() {
+        return [...this.commandHistory];
+    }
+    searchHistory(prefix) {
+        return this.commandHistory.filter(cmd => cmd.startsWith(prefix)).slice(-10);
+    }
+    // --- Main Completion Handler ---
+    complete = (line) => {
+        // Slash command completion
+        if (line.startsWith('/')) {
+            return this.completeSlashCommand(line);
+        }
+        // File path completion (for paths starting with ./ or / or ~)
+        if (this.looksLikeFilePath(line)) {
+            return this.completeFilePath(line);
+        }
+        // @-mention for agents
+        if (line.startsWith('@')) {
+            return this.completeAgent(line);
+        }
+        // History-based completion (if not empty)
+        if (line.length > 0) {
+            const historyMatches = this.searchHistory(line);
+            if (historyMatches.length > 0) {
+                return [historyMatches, line];
+            }
+        }
+        // Default: try slash commands
+        return this.completeSlashCommand('/' + line);
+    };
+    completeSlashCommand(line) {
+        const partial = line.slice(1).toLowerCase();
+        const parts = partial.split(/\s+/);
+        // First part: command name
+        if (parts.length === 1) {
+            const matches = Array.from(this.slashCommands.keys())
+                .filter(cmd => cmd.startsWith(partial))
+                .map(cmd => '/' + cmd + ' ');
+            if (matches.length === 1) {
+                const cmd = matches[0].trim().slice(1);
+                const desc = this.slashCommands.get(cmd);
+                return [matches, line];
+            }
+            return [matches.length > 0 ? matches : Array.from(this.slashCommands.keys()).map(c => '/' + c + ' '), line];
+        }
+        // Second part: context-specific completion
+        const command = parts[0];
+        const argPartial = parts.slice(1).join(' ');
+        switch (command) {
+            case 'model':
+                return this.completeModel(argPartial, line);
+            case 'agent':
+                return [this.agentNames.filter(a => a.toLowerCase().startsWith(argPartial.toLowerCase())), line];
+            case 'theme':
+                return [this.themes.filter(t => t.startsWith(argPartial)), line];
+            case 'resume':
+                return this.completeSessionId(argPartial, line);
+            case 'mcp':
+                if (parts.length === 2) {
+                    return [this.mcpSubcommands.filter(c => c.startsWith(argPartial)), line];
+                }
+                return [[], line];
+            case 'permission':
+            case 'perm':
+                return [this.permissionModes.filter(m => m.startsWith(argPartial)), line];
+            case 'whitelist':
+            case 'blacklist':
+                return [[], line]; // TODO: complete tool names
+            case 'import':
+                return this.completeFilePath(argPartial || './');
+            // v3.0 new command completions
+            case 'style':
+                return [this.styleNames.filter(s => s.startsWith(argPartial)), line];
+            case 'thinking':
+                if (argPartial === 'toggle')
+                    return [['toggle'], line];
+                return [this.thinkingModes.filter(m => m.startsWith(argPartial)), line];
+            case 'effort':
+                return [this.effortLevels.filter(l => l.startsWith(argPartial)), line];
+            case 'skills':
+                if (parts.length === 2) {
+                    return [this.skillSubcommands.filter(c => c.startsWith(argPartial)), line];
+                }
+                return [[], line];
+            case 'cache':
+                if (parts.length === 2) {
+                    return [this.cacheSubcommands.filter(c => c.startsWith(argPartial)), line];
+                }
+                return [[], line];
+            case 'ignore':
+                if (parts.length === 2) {
+                    return [this.ignoreSubcommands.filter(c => c.startsWith(argPartial)), line];
+                }
+                return [[], line];
+            // P2/P3 new command completions
+            case 'telemetry':
+                if (parts.length === 2) {
+                    return [this.telemetrySubcommands.filter(c => c.startsWith(argPartial)), line];
+                }
+                return [[], line];
+            case 'vim':
+                return [['on', 'off'].filter(v => v.startsWith(argPartial)), line];
+            case 'lang':
+                return [this.locales.filter(l => l.startsWith(argPartial)), line];
+            case 'voice':
+                if (parts.length === 2) {
+                    return [this.voiceSubcommands.filter(c => c.startsWith(argPartial)), line];
+                }
+                return [[], line];
+            case 'image':
+                return this.completeFilePath(argPartial || './');
+            case 'server':
+                if (parts.length === 2) {
+                    return [this.serverSubcommands.filter(c => c.startsWith(argPartial)), line];
+                }
+                return [[], line];
+            case 'sync':
+                if (parts.length === 2) {
+                    return [this.syncSubcommands.filter(c => c.startsWith(argPartial)), line];
+                }
+                return [[], line];
+            case 'dashboard':
+                if (parts.length === 2) {
+                    return [this.dashboardSubcommands.filter(c => c.startsWith(argPartial)), line];
+                }
+                return [[], line];
+            default:
+                return [[], line];
+        }
+    }
+    completeModel(partial, line) {
+        // Match by ID or name
+        const matches = this.modelIds.filter(m => m.startsWith(partial) ||
+            MODELS[m]?.name.toLowerCase().includes(partial.toLowerCase()) ||
+            m.split('/')[1]?.split(':')[0].startsWith(partial));
+        // Also categorize
+        if (partial === 'free' || partial === 'free-') {
+            const freeMatches = this.modelIds.filter(m => m.includes(':free'));
+            return [freeMatches, line];
+        }
+        return [matches.length > 0 ? matches : this.modelIds, line];
+    }
+    completeAgent(line) {
+        const partial = line.slice(1).toLowerCase();
+        return [this.agentNames.filter(a => a.toLowerCase().startsWith(partial)), line];
+    }
+    completeFilePath(line) {
+        let dirPath;
+        let filePrefix;
+        if (line.startsWith('~/')) {
+            dirPath = join(homedir(), dirname(line.slice(2)));
+            filePrefix = basename(line);
+        }
+        else if (line.startsWith('/')) {
+            dirPath = dirname(line);
+            filePrefix = basename(line);
+        }
+        else if (line.startsWith('./')) {
+            dirPath = join(this.cwd, dirname(line.slice(2)));
+            filePrefix = basename(line);
+        }
+        else {
+            dirPath = this.cwd;
+            filePrefix = line;
+        }
+        try {
+            if (!existsSync(dirPath))
+                return [[], line];
+            const entries = readdirSync(dirPath);
+            const matches = entries
+                .filter(e => e.toLowerCase().startsWith(filePrefix.toLowerCase()))
+                .map(e => {
+                const fullPath = join(dirPath, e);
+                try {
+                    const stat = statSync(fullPath);
+                    return stat.isDirectory() ? e + '/' : e;
+                }
+                catch {
+                    return e;
+                }
+            });
+            return [matches, line];
+        }
+        catch {
+            return [[], line];
+        }
+    }
+    completeSessionId(partial, line) {
+        const suggestions = ['latest'];
+        if (partial) {
+            try {
+                const sessionDir = join(homedir(), '.neuro', 'sessions');
+                if (existsSync(sessionDir)) {
+                    const files = readdirSync(sessionDir)
+                        .filter(f => f.endsWith('.json'))
+                        .map(f => f.replace('.json', ''))
+                        .filter(f => f.startsWith(partial));
+                    suggestions.push(...files.slice(0, 5));
+                }
+            }
+            catch { }
+        }
+        return [suggestions.filter(s => s.startsWith(partial)), line];
+    }
+    looksLikeFilePath(line) {
+        return line.startsWith('./') || line.startsWith('/') || line.startsWith('~/') ||
+            (line.includes('/') && !line.startsWith('/'));
+    }
+    /**
+     * Display completion suggestions nicely
+     */
+    static displaySuggestions(suggestions) {
+        if (suggestions.length === 0)
+            return;
+        if (suggestions.length === 1)
+            return;
+        console.log();
+        const cols = Math.min(process.stdout.columns || 80, 100);
+        const maxLen = Math.max(...suggestions.map(s => s.length)) + 2;
+        const perRow = Math.floor(cols / maxLen) || 1;
+        let row = '';
+        for (let i = 0; i < suggestions.length; i++) {
+            row += suggestions[i].padEnd(maxLen);
+            if ((i + 1) % perRow === 0) {
+                console.log(row);
+                row = '';
+            }
+        }
+        if (row)
+            console.log(row);
+    }
+    /**
+     * Get contextual help for a partial command
+     */
+    getContextualHelp(partial) {
+        if (!partial.startsWith('/'))
+            return null;
+        const cmd = partial.slice(1).split(' ')[0];
+        return this.slashCommands.get(cmd) || null;
+    }
+}
+//# sourceMappingURL=completion.js.map

package/dist/core/context.d.ts

@@ -0,0 +1,38 @@
+import { Message } from '../core/types.js';
+export interface ContextSummary {
+    totalMessages: number;
+    totalTokens: number;
+    systemTokens: number;
+    conversationTokens: number;
+    availableTokens: number;
+    truncationNeeded: boolean;
+}
+export declare class ContextManager {
+    private modelId;
+    private maxContextTokens;
+    private systemPromptRatio;
+    private reservedOutputTokens;
+    constructor(modelId: string, maxContextTokens?: number, systemPromptRatio?: number, reservedOutputRatio?: number);
+    get maxInputTokens(): number;
+    /**
+     * Analyze the current context
+     */
+    analyze(messages: Message[]): ContextSummary;
+    /**
+     * Count total tokens in messages
+     */
+    countTokens(messages: Message[]): number;
+    /**
+     * Manage context window - truncate if needed
+     */
+    manage(messages: Message[]): Message[];
+    /**
+     * Create a summary of old messages
+     */
+    private createSummary;
+    /**
+     * Build the final message array for an API call
+     */
+    buildMessages(systemPrompt: string, conversation: Message[], injectedContext?: string): Message[];
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/core/context.js

@@ -0,0 +1,144 @@
+// ============================================================
+// NeuroCLI - Context Manager
+// Smart context window management
+// ============================================================
+import { MODELS } from '../api/models.js';
+// Simple token estimation (≈4 chars per token for English, ≈2 for CJK)
+function estimateTokens(text) {
+    const cjkChars = (text.match(/[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g) || []).length;
+    const otherChars = text.length - cjkChars;
+    return Math.ceil(cjkChars / 2 + otherChars / 4);
+}
+export class ContextManager {
+    modelId;
+    maxContextTokens;
+    systemPromptRatio;
+    reservedOutputTokens;
+    constructor(modelId, maxContextTokens, systemPromptRatio = 0.15, reservedOutputRatio = 0.3) {
+        this.modelId = modelId;
+        const model = MODELS[modelId];
+        this.maxContextTokens = maxContextTokens || (model?.contextWindow || 128000);
+        this.systemPromptRatio = systemPromptRatio;
+        this.reservedOutputTokens = Math.floor(this.maxContextTokens * reservedOutputRatio);
+    }
+    get maxInputTokens() {
+        return this.maxContextTokens - this.reservedOutputTokens;
+    }
+    /**
+     * Analyze the current context
+     */
+    analyze(messages) {
+        const totalTokens = this.countTokens(messages);
+        const systemTokens = messages
+            .filter(m => m.role === 'system')
+            .reduce((sum, m) => sum + estimateTokens(m.content), 0);
+        return {
+            totalMessages: messages.length,
+            totalTokens,
+            systemTokens,
+            conversationTokens: totalTokens - systemTokens,
+            availableTokens: this.maxInputTokens - totalTokens,
+            truncationNeeded: totalTokens > this.maxInputTokens,
+        };
+    }
+    /**
+     * Count total tokens in messages
+     */
+    countTokens(messages) {
+        return messages.reduce((sum, m) => {
+            let msgTokens = estimateTokens(m.content);
+            if (m.toolCalls) {
+                for (const tc of m.toolCalls) {
+                    msgTokens += estimateTokens(tc.function.name + tc.function.arguments);
+                }
+            }
+            return sum + msgTokens;
+        }, 0);
+    }
+    /**
+     * Manage context window - truncate if needed
+     */
+    manage(messages) {
+        const summary = this.analyze(messages);
+        if (!summary.truncationNeeded) {
+            return messages;
+        }
+        // Strategy: Keep system prompt + recent messages, summarize older ones
+        const result = [];
+        const systemMessages = messages.filter(m => m.role === 'system');
+        result.push(...systemMessages);
+        // Calculate how many tokens we need to remove
+        const tokensToRemove = summary.totalTokens - this.maxInputTokens + 500; // buffer
+        // Add a context summary of removed messages
+        const nonSystemMessages = messages.filter(m => m.role !== 'system');
+        let removedTokens = 0;
+        let cutoffIndex = 0;
+        for (let i = 0; i < nonSystemMessages.length; i++) {
+            const msgTokens = estimateTokens(nonSystemMessages[i].content);
+            if (removedTokens + msgTokens > tokensToRemove) {
+                cutoffIndex = i;
+                break;
+            }
+            removedTokens += msgTokens;
+        }
+        if (cutoffIndex > 0) {
+            // Create a summary of the removed messages
+            const removedMessages = nonSystemMessages.slice(0, cutoffIndex);
+            const summaryContent = this.createSummary(removedMessages);
+            result.push({
+                role: 'system',
+                content: `## Previous Context Summary\n${summaryContent}`,
+                timestamp: Date.now(),
+            });
+        }
+        // Add remaining messages
+        result.push(...nonSystemMessages.slice(cutoffIndex));
+        return result;
+    }
+    /**
+     * Create a summary of old messages
+     */
+    createSummary(messages) {
+        const parts = [];
+        for (const msg of messages) {
+            const preview = msg.content.length > 200
+                ? msg.content.slice(0, 200) + '...'
+                : msg.content;
+            switch (msg.role) {
+                case 'user':
+                    parts.push(`[User asked]: ${preview}`);
+                    break;
+                case 'assistant':
+                    if (msg.toolCalls?.length) {
+                        parts.push(`[Assistant called tools: ${msg.toolCalls.map(tc => tc.function.name).join(', ')}]`);
+                    }
+                    else {
+                        parts.push(`[Assistant responded]: ${preview}`);
+                    }
+                    break;
+                case 'tool':
+                    parts.push(`[Tool result]: ${preview}`);
+                    break;
+            }
+        }
+        return parts.join('\n');
+    }
+    /**
+     * Build the final message array for an API call
+     */
+    buildMessages(systemPrompt, conversation, injectedContext) {
+        const messages = [
+            { role: 'system', content: systemPrompt, timestamp: Date.now() },
+        ];
+        if (injectedContext) {
+            messages.push({
+                role: 'system',
+                content: `## Project Context\n${injectedContext}`,
+                timestamp: Date.now(),
+            });
+        }
+        messages.push(...conversation);
+        return this.manage(messages);
+    }
+}
+//# sourceMappingURL=context.js.map

package/dist/core/diff-preview.d.ts

@@ -0,0 +1,35 @@
+export interface DiffLine {
+    type: 'add' | 'remove' | 'context';
+    content: string;
+    lineNumber?: number;
+}
+export interface FileDiff {
+    filePath: string;
+    added: number;
+    removed: number;
+    lines: DiffLine[];
+}
+export declare class DiffPreview {
+    /**
+     * Create a diff preview between old content and new content
+     */
+    static createDiff(oldContent: string, newContent: string, filePath: string): FileDiff;
+    /**
+     * Create diff for edit_file operation (old_text -> new_text replacement)
+     */
+    static createEditDiff(filePath: string, oldText: string, newText: string): FileDiff | null;
+    /**
+     * Render diff to terminal with colors
+     */
+    static renderDiff(diff: FileDiff, contextLines?: number): void;
+    /**
+     * Render a compact summary of multiple diffs
+     */
+    static renderSummary(diffs: FileDiff[]): void;
+    /**
+     * Ask user to confirm diff changes
+     */
+    static confirmDiff(diff: FileDiff): Promise<boolean>;
+    private static lcs;
+}
+//# sourceMappingURL=diff-preview.d.ts.map