neuro-cli 4.1.0

package/dist/core/diff-preview.js

@@ -0,0 +1,173 @@
+// ============================================================
+// NeuroCLI - Diff Preview System
+// Shows file changes before applying them
+// ============================================================
+import { readFileSync, existsSync } from 'fs';
+import chalk from 'chalk';
+export class DiffPreview {
+    /**
+     * Create a diff preview between old content and new content
+     */
+    static createDiff(oldContent, newContent, filePath) {
+        const oldLines = oldContent.split('\n');
+        const newLines = newContent.split('\n');
+        const diffLines = [];
+        // Simple LCS-based diff
+        const lcs = DiffPreview.lcs(oldLines, newLines);
+        let oi = 0, ni = 0, li = 0;
+        let added = 0, removed = 0;
+        while (oi < oldLines.length || ni < newLines.length) {
+            if (li < lcs.length && oi < oldLines.length && ni < newLines.length &&
+                oldLines[oi] === lcs[li] && newLines[ni] === lcs[li]) {
+                diffLines.push({ type: 'context', content: oldLines[oi], lineNumber: oi + 1 });
+                oi++;
+                ni++;
+                li++;
+            }
+            else {
+                // Check for removals
+                while (oi < oldLines.length && (li >= lcs.length || oldLines[oi] !== lcs[li])) {
+                    diffLines.push({ type: 'remove', content: oldLines[oi], lineNumber: oi + 1 });
+                    removed++;
+                    oi++;
+                }
+                // Check for additions
+                while (ni < newLines.length && (li >= lcs.length || newLines[ni] !== lcs[li])) {
+                    diffLines.push({ type: 'add', content: newLines[ni], lineNumber: ni + 1 });
+                    added++;
+                    ni++;
+                }
+            }
+        }
+        return { filePath, added, removed, lines: diffLines };
+    }
+    /**
+     * Create diff for edit_file operation (old_text -> new_text replacement)
+     */
+    static createEditDiff(filePath, oldText, newText) {
+        let content = '';
+        if (existsSync(filePath)) {
+            content = readFileSync(filePath, 'utf-8');
+        }
+        else {
+            return null;
+        }
+        // Find the old text in the file
+        const idx = content.indexOf(oldText);
+        if (idx === -1)
+            return null;
+        const newContent = content.slice(0, idx) + newText + content.slice(idx + oldText.length);
+        return DiffPreview.createDiff(content, newContent, filePath);
+    }
+    /**
+     * Render diff to terminal with colors
+     */
+    static renderDiff(diff, contextLines = 3) {
+        const { filePath, added, removed, lines } = diff;
+        console.log();
+        console.log(`  ${chalk.bold.cyan('━━━ Diff Preview ━━━')}`);
+        console.log(`  ${chalk.white(filePath)} ${chalk.green(`+${added}`)} ${chalk.red(`-${removed}`)}`);
+        console.log(`  ${chalk.gray('─'.repeat(50))}`);
+        let inChange = false;
+        let contextCount = 0;
+        for (const line of lines) {
+            switch (line.type) {
+                case 'add':
+                    contextCount = 0;
+                    inChange = true;
+                    console.log(`  ${chalk.green('+')} ${chalk.green(line.content)}`);
+                    break;
+                case 'remove':
+                    contextCount = 0;
+                    inChange = true;
+                    console.log(`  ${chalk.red('-')} ${chalk.red(line.content)}`);
+                    break;
+                case 'context':
+                    contextCount++;
+                    if (inChange) {
+                        // Show a few context lines after a change
+                        if (contextCount <= contextLines) {
+                            console.log(`  ${chalk.gray(' ')} ${chalk.gray(line.content)}`);
+                        }
+                        else {
+                            inChange = false;
+                            console.log(`  ${chalk.gray('  ...')}`);
+                        }
+                    }
+                    else if (contextCount <= 1) {
+                        // Show one context line before a change
+                        console.log(`  ${chalk.gray(' ')} ${chalk.gray(line.content)}`);
+                    }
+                    break;
+            }
+        }
+        console.log(`  ${chalk.gray('─'.repeat(50))}`);
+        console.log(`  ${chalk.green(`+${added} additions`)}  ${chalk.red(`-${removed} deletions`)}`);
+        console.log();
+    }
+    /**
+     * Render a compact summary of multiple diffs
+     */
+    static renderSummary(diffs) {
+        console.log();
+        console.log(`  ${chalk.bold.cyan('━━━ Changes Summary ━━━')}`);
+        for (const diff of diffs) {
+            const statusLabel = diff.added > 0 && diff.removed === 0 ? chalk.green('created') :
+                diff.added === 0 && diff.removed > 0 ? chalk.red('deleted') :
+                    chalk.yellow('modified');
+            console.log(`  ${statusLabel} ${diff.filePath.padEnd(40)} ${chalk.green(`+${diff.added}`)} ${chalk.red(`-${diff.removed}`)}`);
+        }
+        const totalAdded = diffs.reduce((s, d) => s + d.added, 0);
+        const totalRemoved = diffs.reduce((s, d) => s + d.removed, 0);
+        console.log(`  ${chalk.gray('─'.repeat(50))}`);
+        console.log(`  ${chalk.bold('Total:')} ${chalk.green(`+${totalAdded}`)} ${chalk.red(`-${totalRemoved}`)}`);
+        console.log();
+    }
+    /**
+     * Ask user to confirm diff changes
+     */
+    static async confirmDiff(diff) {
+        DiffPreview.renderDiff(diff);
+        const rl = require('readline').createInterface({ input: process.stdin, output: process.stdout });
+        return new Promise((resolve) => {
+            rl.question(chalk.cyan('  Apply these changes? [y/n]: '), (answer) => {
+                rl.close();
+                resolve(answer.toLowerCase().trim() === 'y' || answer.toLowerCase().trim() === 'yes');
+            });
+        });
+    }
+    // Simple Longest Common Subsequence
+    static lcs(a, b) {
+        const m = a.length;
+        const n = b.length;
+        const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+        for (let i = 1; i <= m; i++) {
+            for (let j = 1; j <= n; j++) {
+                if (a[i - 1] === b[j - 1]) {
+                    dp[i][j] = dp[i - 1][j - 1] + 1;
+                }
+                else {
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+                }
+            }
+        }
+        // Backtrack
+        const result = [];
+        let i = m, j = n;
+        while (i > 0 && j > 0) {
+            if (a[i - 1] === b[j - 1]) {
+                result.unshift(a[i - 1]);
+                i--;
+                j--;
+            }
+            else if (dp[i - 1][j] > dp[i][j - 1]) {
+                i--;
+            }
+            else {
+                j--;
+            }
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=diff-preview.js.map

package/dist/core/doom-loop.d.ts

@@ -0,0 +1,51 @@
+export interface DoomLoopConfig {
+    maxConsecutiveErrors: number;
+    maxRepetitiveActions: number;
+    similarityThreshold: number;
+    cooldownMs: number;
+    autoBreak: boolean;
+}
+export interface DoomLoopState {
+    consecutiveErrors: number;
+    lastActions: Array<{
+        tool: string;
+        args: string;
+        result: string;
+        timestamp: number;
+    }>;
+    isPaused: boolean;
+    pauseReason?: string;
+    totalLoopsDetected: number;
+}
+export declare class DoomLoopProtection {
+    private config;
+    private state;
+    private onLoopDetected?;
+    constructor(config?: Partial<DoomLoopConfig>, onLoopDetected?: (reason: string, state: DoomLoopState) => Promise<boolean>);
+    /**
+     * Record a tool execution and check for doom loops
+     * Returns true if the action should proceed, false if blocked
+     */
+    recordAction(toolName: string, args: Record<string, unknown>, result: string, isError: boolean): Promise<boolean>;
+    /**
+     * Reset the state (e.g., after user intervention)
+     */
+    reset(): void;
+    /**
+     * Unpause after user intervention
+     */
+    unpause(): void;
+    /**
+     * Get current state
+     */
+    getState(): DoomLoopState;
+    /**
+     * Check if currently paused
+     */
+    isPaused(): boolean;
+    private handleLoop;
+    private countRepetitiveActions;
+    private calculateErrorSimilarity;
+    private summarizeArgs;
+}
+//# sourceMappingURL=doom-loop.d.ts.map

package/dist/core/doom-loop.js

@@ -0,0 +1,179 @@
+// ============================================================
+// NeuroCLI - Doom Loop Protection
+// Detects and prevents agent stuck loops
+// ============================================================
+import chalk from 'chalk';
+const DEFAULT_CONFIG = {
+    maxConsecutiveErrors: 3,
+    maxRepetitiveActions: 3,
+    similarityThreshold: 0.7,
+    cooldownMs: 5000,
+    autoBreak: true,
+};
+export class DoomLoopProtection {
+    config;
+    state;
+    onLoopDetected;
+    constructor(config, onLoopDetected) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.onLoopDetected = onLoopDetected;
+        this.state = {
+            consecutiveErrors: 0,
+            lastActions: [],
+            isPaused: false,
+            totalLoopsDetected: 0,
+        };
+    }
+    /**
+     * Record a tool execution and check for doom loops
+     * Returns true if the action should proceed, false if blocked
+     */
+    async recordAction(toolName, args, result, isError) {
+        if (this.state.isPaused) {
+            console.log(chalk.yellow(`\n  ⚠ Doom loop protection: Agent is paused. Reason: ${this.state.pauseReason}`));
+            return false;
+        }
+        // Track errors
+        if (isError) {
+            this.state.consecutiveErrors++;
+        }
+        else {
+            this.state.consecutiveErrors = 0;
+        }
+        // Record action
+        const actionStr = JSON.stringify({ tool: toolName, args: this.summarizeArgs(args) });
+        this.state.lastActions.push({
+            tool: toolName,
+            args: actionStr,
+            result: isError ? 'error' : 'success',
+            timestamp: Date.now(),
+        });
+        // Keep only last 20 actions
+        if (this.state.lastActions.length > 20) {
+            this.state.lastActions = this.state.lastActions.slice(-20);
+        }
+        // Check for consecutive errors
+        if (this.state.consecutiveErrors >= this.config.maxConsecutiveErrors) {
+            const reason = `${this.state.consecutiveErrors} consecutive errors detected`;
+            return this.handleLoop(reason);
+        }
+        // Check for repetitive actions
+        const recentActions = this.state.lastActions.slice(-this.config.maxRepetitiveActions * 2);
+        const repetitiveCount = this.countRepetitiveActions(recentActions, toolName, args);
+        if (repetitiveCount >= this.config.maxRepetitiveActions) {
+            const reason = `${repetitiveCount} repetitive actions detected for ${toolName}`;
+            return this.handleLoop(reason);
+        }
+        // Check for similar error patterns
+        const recentErrors = this.state.lastActions.filter(a => a.result === 'error').slice(-5);
+        if (recentErrors.length >= 3) {
+            const similarity = this.calculateErrorSimilarity(recentErrors);
+            if (similarity >= this.config.similarityThreshold) {
+                const reason = `Similar errors detected (${(similarity * 100).toFixed(0)}% similarity)`;
+                return this.handleLoop(reason);
+            }
+        }
+        return true;
+    }
+    /**
+     * Reset the state (e.g., after user intervention)
+     */
+    reset() {
+        this.state = {
+            consecutiveErrors: 0,
+            lastActions: [],
+            isPaused: false,
+            totalLoopsDetected: 0,
+        };
+    }
+    /**
+     * Unpause after user intervention
+     */
+    unpause() {
+        this.state.isPaused = false;
+        this.state.pauseReason = undefined;
+        this.state.consecutiveErrors = 0;
+        this.state.lastActions = [];
+        console.log(chalk.green('  ✓ Doom loop protection: Resumed'));
+    }
+    /**
+     * Get current state
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Check if currently paused
+     */
+    isPaused() {
+        return this.state.isPaused;
+    }
+    async handleLoop(reason) {
+        this.state.totalLoopsDetected++;
+        this.state.isPaused = true;
+        this.state.pauseReason = reason;
+        console.log(chalk.red.bold(`\n  🚨 Doom Loop Detected: ${reason}`));
+        console.log(chalk.yellow('  The agent appears to be stuck in a loop.'));
+        console.log(chalk.gray('  Use /unpause to resume or /reset to start fresh.'));
+        if (this.onLoopDetected) {
+            const shouldContinue = await this.onLoopDetected(reason, this.state);
+            if (shouldContinue) {
+                this.unpause();
+                return true;
+            }
+        }
+        return false;
+    }
+    countRepetitiveActions(actions, toolName, args) {
+        const currentArgs = this.summarizeArgs(args);
+        let count = 0;
+        for (const action of actions) {
+            if (action.tool === toolName) {
+                try {
+                    const parsed = JSON.parse(action.args);
+                    if (parsed.args === currentArgs) {
+                        count++;
+                    }
+                }
+                catch { }
+            }
+        }
+        return count;
+    }
+    calculateErrorSimilarity(errors) {
+        if (errors.length < 2)
+            return 0;
+        // Simple word-overlap similarity
+        const allWords = errors.map(e => {
+            try {
+                const parsed = JSON.parse(e.args);
+                return new Set((parsed.args || '').split(/\s+/));
+            }
+            catch {
+                return new Set();
+            }
+        });
+        let totalSimilarity = 0;
+        let comparisons = 0;
+        for (let i = 0; i < allWords.length - 1; i++) {
+            for (let j = i + 1; j < allWords.length; j++) {
+                const intersection = new Set([...allWords[i]].filter(x => allWords[j].has(x)));
+                const union = new Set([...allWords[i], ...allWords[j]]);
+                const similarity = union.size > 0 ? intersection.size / union.size : 0;
+                totalSimilarity += similarity;
+                comparisons++;
+            }
+        }
+        return comparisons > 0 ? totalSimilarity / comparisons : 0;
+    }
+    summarizeArgs(args) {
+        const entries = Object.entries(args);
+        if (entries.length === 0)
+            return '';
+        return entries.map(([k, v]) => {
+            const val = typeof v === 'string' ? v.slice(0, 100) : JSON.stringify(v).slice(0, 100);
+            return `${k}=${val}`;
+        }).join(' ');
+    }
+}
+//# sourceMappingURL=doom-loop.js.map

package/dist/core/engine.d.ts

@@ -0,0 +1,183 @@
+import { NeuroConfig, AgentExecution } from '../core/types.js';
+import { OpenRouterClient, TokenUsage } from '../api/openrouter.js';
+import { ToolRegistry } from '../tools/registry.js';
+import { BaseAgent } from '../agents/base.js';
+import { Orchestrator } from '../agents/orchestrator.js';
+import { ContextManager } from '../core/context.js';
+import { SessionManager } from '../core/session.js';
+import { TerminalUI } from '../ui/renderer.js';
+import { ApprovalSystem } from '../core/approval.js';
+import { MCPClient } from '../mcp/client.js';
+import { DoomLoopProtection } from '../core/doom-loop.js';
+import { FallbackChain } from '../core/fallback.js';
+import { Sandbox } from '../core/sandbox.js';
+import { PluginManager } from '../core/plugin-sdk.js';
+import { UndoRedoSystem } from './undo-redo.js';
+import { PromptCache } from './prompt-cache.js';
+import { ModelRouter } from './model-router.js';
+import { StyleManager } from './output-styles.js';
+import { ExtendedThinking } from './extended-thinking.js';
+import { SpendingMonitor } from './spending-warnings.js';
+import { SkillSystem } from '../context/skill-system.js';
+import { CustomAgentLoader } from '../context/custom-agents.js';
+import { CustomToolLoader } from '../context/custom-tools.js';
+import { NeuroIgnore } from '../context/neuroignore.js';
+import { OllamaProvider } from '../api/ollama.js';
+import { TelemetrySystem } from './telemetry.js';
+import { VimModeManager } from './vim-mode.js';
+import { I18nSystem } from './i18n.js';
+import { MultimodalSupport } from './multimodal.js';
+import { VoiceIO } from './voice.js';
+import { APIServer } from './api-server.js';
+import { CloudSync } from './cloud-sync.js';
+import { WebDashboard } from './web-dashboard.js';
+import { SkillStandard } from '../context/skill-standard.js';
+import { AutoMode } from './auto-mode.js';
+import { ScheduledTaskManager } from './scheduled-tasks.js';
+import { ParallelAgentManager } from './parallel-agents.js';
+import { BackgroundSessionManager } from './background-session.js';
+import { TreeSitterIntegration } from '../context/tree-sitter.js';
+import { LintingIntegration } from './linting.js';
+import { TestingIntegration } from './testing.js';
+import { CodeReviewSystem } from './code-review.js';
+import { SecurityScanner } from './security-scanner.js';
+import { PluginBundleManager } from './plugin-bundle.js';
+import { SubAgentManager } from './sub-agent.js';
+import { ACPServer } from './acp.js';
+import { OSSandboxManager } from './os-sandbox.js';
+import { SpecDrivenPipeline } from './spec-driven.js';
+import { LLMEvaluatorManager } from '../hooks/llm-evaluator.js';
+import { MCPAppManager } from '../mcp/mcp-apps.js';
+import { MultiModelOrchestrator } from './multi-model.js';
+import { SmartMonitor } from './smart-monitor.js';
+import { OutcomeGrader } from './outcome-grading.js';
+import { ObservabilityManager } from './observability.js';
+import { AutoCompactManager } from './auto-compact.js';
+import { TerminalUX } from './terminal-ux.js';
+import { MultiSessionManager } from './multi-session.js';
+import { GitWorktreeManager } from './git-worktree.js';
+import { AutoUpdater } from './updater.js';
+export declare class NeuroEngine {
+    config: NeuroConfig;
+    client: OpenRouterClient;
+    registry: ToolRegistry;
+    orchestrator: Orchestrator;
+    contextManager: ContextManager;
+    sessionManager: SessionManager;
+    ui: TerminalUI;
+    agents: Map<string, BaseAgent>;
+    mcpClient: MCPClient;
+    approval: ApprovalSystem;
+    doomLoop: DoomLoopProtection;
+    fallback: FallbackChain;
+    sandbox: Sandbox;
+    pluginManager: PluginManager;
+    undoRedo: UndoRedoSystem;
+    promptCache: PromptCache;
+    modelRouter: ModelRouter;
+    styleManager: StyleManager;
+    extendedThinking: ExtendedThinking;
+    spendingMonitor: SpendingMonitor;
+    skillSystem: SkillSystem;
+    customAgentLoader: CustomAgentLoader;
+    customToolLoader: CustomToolLoader;
+    neuroIgnore: NeuroIgnore;
+    ollamaProvider: OllamaProvider;
+    telemetry: TelemetrySystem;
+    vimMode: VimModeManager;
+    i18n: I18nSystem;
+    multimodal: MultimodalSupport;
+    voice: VoiceIO;
+    apiServer: APIServer;
+    cloudSync: CloudSync;
+    dashboard: WebDashboard;
+    skillStandard: SkillStandard;
+    autoMode: AutoMode;
+    scheduledTasks: ScheduledTaskManager;
+    parallelAgents: ParallelAgentManager;
+    backgroundSessions: BackgroundSessionManager;
+    treeSitter: TreeSitterIntegration;
+    linting: LintingIntegration;
+    testing: TestingIntegration;
+    codeReview: CodeReviewSystem;
+    securityScanner: SecurityScanner;
+    pluginBundles: PluginBundleManager;
+    subAgentSpawner: SubAgentManager;
+    acp: ACPServer;
+    osSandbox: OSSandboxManager;
+    specDriven: SpecDrivenPipeline;
+    llmEvaluator: LLMEvaluatorManager;
+    mcpApps: MCPAppManager;
+    multiModelOrchestrator: MultiModelOrchestrator;
+    smartMonitor: SmartMonitor;
+    outcomeGrading: OutcomeGrader;
+    observability: ObservabilityManager;
+    autoCompact: AutoCompactManager;
+    terminalUX: TerminalUX;
+    multiSession: MultiSessionManager;
+    gitWorktree: GitWorktreeManager;
+    updater: AutoUpdater;
+    private autoApproveSet;
+    private requireApprovalSet;
+    constructor(config: NeuroConfig);
+    /**
+     * Register plugin tools with the tool registry
+     */
+    private registerPluginTools;
+    /**
+     * Register custom tools from .neuro/tools/
+     */
+    private registerCustomTools;
+    /**
+     * Load custom agents from .neuro/agents/
+     */
+    private loadCustomAgents;
+    /**
+     * Initialize all agents from config
+     */
+    private initializeAgents;
+    /**
+     * Process a user message
+     */
+    processMessage(message: string, mode?: 'auto' | 'agent' | 'direct', targetAgent?: string): Promise<{
+        content: string;
+        usage: TokenUsage;
+        execution?: AgentExecution;
+    }>;
+    /**
+     * Check sandbox permissions for a tool call
+     */
+    private checkSandboxForTool;
+    /**
+     * Handle tool approval using the enhanced ApprovalSystem
+     */
+    private handleApproval;
+    /**
+     * Assess task complexity to decide execution mode
+     * Now delegates to ModelRouter for more sophisticated analysis
+     */
+    private assessComplexity;
+    /**
+     * Switch the active model
+     */
+    switchModel(modelId: string): boolean;
+    /**
+     * Get current session stats
+     */
+    getSessionStats(): {
+        inputTokens: number;
+        outputTokens: number;
+        cost: number;
+        messages: number;
+    };
+    /**
+     * Register a custom agent
+     */
+    registerCustomAgent(name: string, config: {
+        description: string;
+        systemPrompt: string;
+        tools?: string[];
+        maxIterations?: number;
+    }): void;
+}
+//# sourceMappingURL=engine.d.ts.map