neuro-cli 4.1.0

package/dist/config/config.js

@@ -0,0 +1,311 @@
+// ============================================================
+// NeuroCLI - Configuration System
+// ============================================================
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const CONFIG_DIR = join(homedir(), '.neuro');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+export const DEFAULT_CONFIG = {
+    apiKey: '',
+    baseUrl: 'https://openrouter.ai/api/v1',
+    defaultModel: 'qwen/qwen3-coder:free',
+    agents: {
+        planner: {
+            name: 'Planner',
+            description: 'Task decomposition and planning specialist',
+            systemPrompt: `You are an expert software architect and planner. Your job is to break down complex tasks into clear, actionable steps. For each step, specify which agent should handle it and what tools they should use. Be thorough but concise.`,
+            model: 'qwen/qwen3-coder:free',
+            temperature: 0.7,
+            maxTokens: 4096,
+            tools: ['read_file', 'search_files', 'list_directory'],
+            maxIterations: 3,
+        },
+        coder: {
+            name: 'Coder',
+            description: 'Code generation and modification specialist',
+            systemPrompt: `You are an expert software developer. You write clean, efficient, well-documented code. You understand design patterns, best practices, and can work with any programming language or framework. When modifying existing code, you make minimal, targeted changes. Always consider edge cases and error handling.`,
+            model: 'qwen/qwen3-coder:free',
+            temperature: 0.4,
+            maxTokens: 16384,
+            tools: ['read_file', 'write_file', 'edit_file', 'search_files', 'list_directory', 'run_command', 'apply_diff'],
+            maxIterations: 15,
+        },
+        reviewer: {
+            name: 'Reviewer',
+            description: 'Code review and quality assurance specialist',
+            systemPrompt: `You are an expert code reviewer. You analyze code for bugs, security vulnerabilities, performance issues, and adherence to best practices. You provide specific, actionable feedback with line references. You categorize issues by severity (critical, warning, suggestion). You also check for test coverage and documentation.`,
+            model: 'nvidia/nemotron-3-super-120b-a12b:free',
+            temperature: 0.3,
+            maxTokens: 8192,
+            tools: ['read_file', 'search_files', 'list_directory'],
+            maxIterations: 5,
+        },
+        researcher: {
+            name: 'Researcher',
+            description: 'Information gathering and analysis specialist',
+            systemPrompt: `You are an expert researcher and analyst. You gather information from files, web resources, and codebases. You synthesize findings into clear, structured reports. You can explain complex technical concepts and find relevant examples or documentation.`,
+            model: 'google/gemma-4-31b-it:free',
+            temperature: 0.5,
+            maxTokens: 8192,
+            tools: ['read_file', 'search_files', 'list_directory', 'web_search', 'web_fetch'],
+            maxIterations: 8,
+        },
+        tester: {
+            name: 'Tester',
+            description: 'Test generation and execution specialist',
+            systemPrompt: `You are an expert QA engineer. You write comprehensive test suites covering unit tests, integration tests, and edge cases. You run tests and analyze failures to identify root causes. You ensure code meets quality standards before it's considered complete.`,
+            model: 'qwen/qwen3-coder:free',
+            temperature: 0.3,
+            maxTokens: 8192,
+            tools: ['read_file', 'write_file', 'search_files', 'run_command', 'list_directory'],
+            maxIterations: 10,
+        },
+        debugger: {
+            name: 'Debugger',
+            description: 'Bug investigation and fixing specialist',
+            systemPrompt: `You are an expert debugger. You systematically investigate bugs by reading code, running diagnostic commands, analyzing error messages and stack traces. You identify root causes and implement targeted fixes. You verify fixes work before reporting completion.`,
+            model: 'qwen/qwen3-coder:free',
+            temperature: 0.2,
+            maxTokens: 8192,
+            tools: ['read_file', 'edit_file', 'search_files', 'run_command', 'list_directory', 'apply_diff'],
+            maxIterations: 12,
+        },
+        architect: {
+            name: 'Architect',
+            description: 'System design and architecture specialist',
+            systemPrompt: `You are an expert software architect. You design scalable, maintainable system architectures. You make technology stack decisions, define component boundaries, and establish coding standards. You create detailed technical specifications that other agents can implement.`,
+            model: 'nvidia/nemotron-3-ultra-550b-a55b:free',
+            temperature: 0.7,
+            maxTokens: 8192,
+            tools: ['read_file', 'search_files', 'list_directory'],
+            maxIterations: 5,
+        },
+        devops: {
+            name: 'DevOps',
+            description: 'Deployment and infrastructure specialist',
+            systemPrompt: `You are an expert DevOps engineer. You handle CI/CD pipelines, Docker configurations, cloud deployments, and infrastructure as code. You optimize build processes and ensure reliable deployments.`,
+            model: 'cohere/north-mini-code:free',
+            temperature: 0.3,
+            maxTokens: 8192,
+            tools: ['read_file', 'write_file', 'edit_file', 'run_command', 'search_files', 'list_directory'],
+            maxIterations: 10,
+        },
+    },
+    tools: {
+        autoApprove: ['read_file', 'search_files', 'list_directory', 'web_search'],
+        requireApproval: ['write_file', 'edit_file', 'apply_diff', 'run_command', 'delete_file'],
+        denied: [],
+    },
+    context: {
+        maxTokens: 180000,
+        systemPromptRatio: 0.15,
+    },
+    session: {
+        autoSave: true,
+        maxHistory: 100,
+    },
+    ui: {
+        theme: 'dracula',
+        showTokenCount: true,
+        showCost: true,
+        streaming: true,
+        syntaxHighlight: true,
+    },
+    permissionMode: 'auto',
+    fallbackChain: {
+        models: ['qwen/qwen3-coder:free', 'nvidia/nemotron-3-super-120b-a12b:free', 'google/gemma-4-31b-it:free', 'cohere/north-mini-code:free'],
+        maxRetries: 2,
+        retryDelayMs: 3000,
+    },
+    doomLoop: {
+        maxConsecutiveErrors: 3,
+        maxRepetitiveActions: 3,
+        similarityThreshold: 0.7,
+        autoBreak: true,
+    },
+    mcp: {
+        servers: {},
+        autoConnect: true,
+    },
+    diffPreview: true,
+    sandbox: {
+        enabled: false,
+        rootDir: process.cwd(),
+        allowedDirs: [],
+        deniedDirs: ['node_modules', '.git', '__pycache__', '.env'],
+        deniedPatterns: ['**/.env', '**/.env.*', '**/*.pem', '**/*.key', '**/credentials.json'],
+        allowCommands: true,
+        allowedCommands: [],
+        deniedCommands: ['rm -rf /', 'sudo rm', 'mkfs', 'dd if='],
+        backupOnModify: true,
+        backupDir: '.neuro/backups',
+        maxFileSize: 10 * 1024 * 1024,
+        allowNetwork: true,
+        allowEnvAccess: false,
+        readOnly: false,
+    },
+    spendingLimit: 0,
+    promptCache: {
+        enabled: false,
+        cacheDir: join(homedir(), '.neuro', 'cache'),
+        maxEntries: 100,
+        ttlMs: 3600000,
+        similarityThreshold: 0.9,
+    },
+    customAgents: {},
+    // P2/P3 new config sections
+    telemetry: {
+        enabled: false,
+        trackModelPerformance: true,
+        trackToolUsage: true,
+        trackSessionMetrics: true,
+        retentionDays: 90,
+    },
+    vimMode: {
+        enabled: false,
+        showModeIndicator: true,
+        bellOnError: true,
+    },
+    i18n: {
+        locale: 'en',
+        fallbackLocale: 'en',
+        autoDetect: true,
+    },
+    multimodal: {
+        enabled: true,
+        maxImageSize: 20 * 1024 * 1024,
+        autoDetectImages: true,
+    },
+    voice: {
+        enabled: false,
+        ttsEngine: 'auto',
+        sttEngine: 'auto',
+        autoSpeak: false,
+        language: 'en',
+    },
+    apiServer: {
+        enabled: false,
+        host: '127.0.0.1',
+        port: 3141,
+        requireAuth: true,
+        enableWebSocket: true,
+    },
+    cloudSync: {
+        enabled: false,
+        backend: 'gist',
+        autoSync: false,
+        includeContent: true,
+    },
+    dashboard: {
+        enabled: false,
+        host: '127.0.0.1',
+        port: 3142,
+        autoOpen: true,
+        refreshInterval: 5000,
+    },
+    // v4.0 new configs
+    autoMode: {
+        enabled: false,
+        safetyLevel: 'conservative',
+        maxIterations: 50,
+        maxCost: 0,
+        maxTimeMs: 0,
+        blockedCommands: ['rm -rf /', 'mkfs', 'dd if=/dev/zero'],
+        blockedPatterns: ['/etc/passwd', '/etc/shadow'],
+        autoCommit: false,
+        autoTest: false,
+        pauseOnError: true,
+    },
+    scheduledTasks: {
+        enabled: true,
+        maxConcurrent: 5,
+        defaultIntervalUnit: 'hours',
+        persistTasks: true,
+        tasksDir: '',
+    },
+    linting: {
+        enabled: true,
+        autoRunOnChange: false,
+        autoFix: false,
+        failOnError: false,
+        timeout: 30000,
+        excludePatterns: ['node_modules', '.git', 'dist'],
+    },
+    testing: {
+        enabled: true,
+        autoRunOnChange: false,
+        runOnSave: false,
+        coverageThreshold: 80,
+        timeout: 60000,
+        relatedTestsOnly: false,
+    },
+    codeReview: {
+        enabled: true,
+        autoReviewOnChange: false,
+        focusAreas: ['security', 'performance', 'correctness', 'style'],
+        severityThreshold: 'minor',
+        excludePatterns: ['node_modules', '.git', 'dist'],
+    },
+    securityScanner: {
+        enabled: true,
+        autoScanOnChange: false,
+        failOnSeverity: 'high',
+        excludePatterns: ['node_modules', '.git', 'dist', 'coverage'],
+        customRules: [],
+    },
+};
+export function loadConfig() {
+    if (existsSync(CONFIG_FILE)) {
+        try {
+            const data = readFileSync(CONFIG_FILE, 'utf-8');
+            const saved = JSON.parse(data);
+            return { ...DEFAULT_CONFIG, ...saved };
+        }
+        catch {
+            return { ...DEFAULT_CONFIG };
+        }
+    }
+    return { ...DEFAULT_CONFIG };
+}
+export function saveConfig(config) {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+}
+export function getProjectConfigPath() {
+    return join(process.cwd(), '.neuro.json');
+}
+export function loadProjectConfig() {
+    const projectConfigPath = getProjectConfigPath();
+    if (existsSync(projectConfigPath)) {
+        try {
+            const data = readFileSync(projectConfigPath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+export function initConfig(apiKey) {
+    const config = loadConfig();
+    if (apiKey) {
+        config.apiKey = apiKey;
+    }
+    if (!config.apiKey) {
+        const envKey = process.env.OPENROUTER_API_KEY;
+        if (envKey) {
+            config.apiKey = envKey;
+        }
+    }
+    // Merge project-level config
+    const projectConfig = loadProjectConfig();
+    if (projectConfig) {
+        Object.assign(config, projectConfig);
+    }
+    return config;
+}
+//# sourceMappingURL=config.js.map

package/dist/context/compaction.d.ts

@@ -0,0 +1,54 @@
+import { Message } from '../core/types.js';
+import { ContextManager } from '../core/context.js';
+import { OpenRouterClient } from '../api/openrouter.js';
+export type CompactionLayer = 'tool_budget' | 'snip' | 'micro' | 'session_memory' | 'full_collapse';
+export interface CompactionResult {
+    messages: Message[];
+    layer: CompactionLayer;
+    originalTokens: number;
+    compactedTokens: number;
+    savings: number;
+    memories?: string[];
+}
+export declare class ContextCompactor {
+    private contextManager;
+    private client;
+    private model;
+    private maxToolOutputTokens;
+    private compactionThreshold;
+    constructor(contextManager: ContextManager, client: OpenRouterClient, model: string);
+    /**
+     * Check if compaction is needed
+     */
+    needsCompaction(messages: Message[]): boolean;
+    /**
+     * Apply 5-layer compaction strategy
+     */
+    compact(messages: Message[]): Promise<CompactionResult>;
+    /**
+     * Layer 1: Tool Budget
+     * Limit the size of tool outputs to prevent context bloat
+     */
+    private layerToolBudget;
+    /**
+     * Layer 2: Snip
+     * Remove old conversation turns, keeping system + recent messages
+     */
+    private layerSnip;
+    /**
+     * Layer 3: Micro-compaction
+     * Compress each message to its essential content
+     */
+    private layerMicroCompact;
+    /**
+     * Layer 4: Session Memory Compaction
+     * Extract key memories from conversation, replace with summary
+     */
+    private layerSessionMemory;
+    /**
+     * Layer 5: Full Collapse
+     * Nuclear option - completely summarize the conversation
+     */
+    private layerFullCollapse;
+}
+//# sourceMappingURL=compaction.d.ts.map

package/dist/context/compaction.js

@@ -0,0 +1,251 @@
+// ============================================================
+// NeuroCLI - 5-Layer Context Compaction
+// (Like Claude Code's sophisticated context management)
+// ============================================================
+export class ContextCompactor {
+    contextManager;
+    client;
+    model;
+    maxToolOutputTokens = 5000;
+    compactionThreshold = 0.85; // 85% of context window
+    constructor(contextManager, client, model) {
+        this.contextManager = contextManager;
+        this.client = client;
+        this.model = model;
+    }
+    /**
+     * Check if compaction is needed
+     */
+    needsCompaction(messages) {
+        const summary = this.contextManager.analyze(messages);
+        const ratio = summary.totalTokens / this.contextManager.maxInputTokens;
+        return ratio >= this.compactionThreshold;
+    }
+    /**
+     * Apply 5-layer compaction strategy
+     */
+    async compact(messages) {
+        const originalTokens = this.contextManager.countTokens(messages);
+        // Layer 1: Tool Budget - Limit tool output sizes
+        let result = this.layerToolBudget(messages);
+        if (this.contextManager.countTokens(result.messages) < this.contextManager.maxInputTokens * 0.9) {
+            return { ...result, originalTokens };
+        }
+        // Layer 2: Snip - Remove old conversation turns
+        result = this.layerSnip(result.messages);
+        if (this.contextManager.countTokens(result.messages) < this.contextManager.maxInputTokens * 0.9) {
+            return { ...result, originalTokens };
+        }
+        // Layer 3: Micro-compaction - Compress each turn
+        result = this.layerMicroCompact(result.messages);
+        if (this.contextManager.countTokens(result.messages) < this.contextManager.maxInputTokens * 0.9) {
+            return { ...result, originalTokens };
+        }
+        // Layer 4: Session Memory - Extract key memories
+        result = await this.layerSessionMemory(result.messages);
+        if (this.contextManager.countTokens(result.messages) < this.contextManager.maxInputTokens * 0.9) {
+            return { ...result, originalTokens };
+        }
+        // Layer 5: Full Collapse - Nuclear option
+        result = await this.layerFullCollapse(result.messages);
+        return { ...result, originalTokens };
+    }
+    /**
+     * Layer 1: Tool Budget
+     * Limit the size of tool outputs to prevent context bloat
+     */
+    layerToolBudget(messages) {
+        const maxOutput = this.maxToolOutputTokens * 4; // ~4 chars per token
+        const compacted = messages.map(msg => {
+            if (msg.role === 'tool' && msg.content.length > maxOutput) {
+                const truncated = msg.content.slice(0, maxOutput) +
+                    `\n\n... [output truncated, ${msg.content.length - maxOutput} chars removed]`;
+                return { ...msg, content: truncated };
+            }
+            return msg;
+        });
+        const compactedTokens = this.contextManager.countTokens(compacted);
+        return {
+            messages: compacted,
+            layer: 'tool_budget',
+            originalTokens: compactedTokens,
+            compactedTokens,
+            savings: 0,
+        };
+    }
+    /**
+     * Layer 2: Snip
+     * Remove old conversation turns, keeping system + recent messages
+     */
+    layerSnip(messages) {
+        const systemMessages = messages.filter(m => m.role === 'system');
+        const nonSystemMessages = messages.filter(m => m.role !== 'system');
+        // Keep last N messages (roughly last 20 turns)
+        const keepCount = Math.min(40, nonSystemMessages.length);
+        const kept = nonSystemMessages.slice(-keepCount);
+        const removed = nonSystemMessages.slice(0, -keepCount);
+        // Create a summary of removed messages
+        const summaryParts = [];
+        for (const msg of removed) {
+            const preview = msg.content.slice(0, 100);
+            switch (msg.role) {
+                case 'user':
+                    summaryParts.push(`[User asked]: ${preview}`);
+                    break;
+                case 'assistant':
+                    if (msg.toolCalls?.length) {
+                        summaryParts.push(`[AI called: ${msg.toolCalls.map(tc => tc.function.name).join(', ')}]`);
+                    }
+                    else {
+                        summaryParts.push(`[AI responded]: ${preview}`);
+                    }
+                    break;
+                case 'tool':
+                    summaryParts.push(`[Tool result]: ${preview.slice(0, 50)}`);
+                    break;
+            }
+        }
+        const contextSummary = {
+            role: 'system',
+            content: `## Earlier Conversation Summary\n${summaryParts.join('\n')}`,
+            timestamp: Date.now(),
+        };
+        const compacted = [...systemMessages, contextSummary, ...kept];
+        const compactedTokens = this.contextManager.countTokens(compacted);
+        const originalTokens = this.contextManager.countTokens(messages);
+        return {
+            messages: compacted,
+            layer: 'snip',
+            originalTokens,
+            compactedTokens,
+            savings: originalTokens - compactedTokens,
+        };
+    }
+    /**
+     * Layer 3: Micro-compaction
+     * Compress each message to its essential content
+     */
+    layerMicroCompact(messages) {
+        const compacted = messages.map(msg => {
+            // Only compress long messages
+            if (msg.content.length < 500)
+                return msg;
+            // For tool results, keep first and last portions
+            if (msg.role === 'tool') {
+                const half = Math.floor(1000 / 2);
+                const compressed = msg.content.slice(0, half) +
+                    '\n...[compressed]...\n' +
+                    msg.content.slice(-half);
+                return { ...msg, content: compressed };
+            }
+            // For assistant messages, keep first part
+            if (msg.role === 'assistant' && msg.content.length > 1000) {
+                return { ...msg, content: msg.content.slice(0, 800) + '\n...[compressed]' };
+            }
+            return msg;
+        });
+        const compactedTokens = this.contextManager.countTokens(compacted);
+        const originalTokens = this.contextManager.countTokens(messages);
+        return {
+            messages: compacted,
+            layer: 'micro',
+            originalTokens,
+            compactedTokens,
+            savings: originalTokens - compactedTokens,
+        };
+    }
+    /**
+     * Layer 4: Session Memory Compaction
+     * Extract key memories from conversation, replace with summary
+     */
+    async layerSessionMemory(messages) {
+        // Build a prompt to extract key information
+        const conversation = messages
+            .filter(m => m.role !== 'system')
+            .map(m => `[${m.role}]: ${m.content.slice(0, 200)}`)
+            .join('\n');
+        try {
+            const response = await this.client.quickChat(this.model, [
+                { role: 'system', content: 'Extract the key facts, decisions, and context from this conversation. Return a concise list of important points.', timestamp: Date.now() },
+                { role: 'user', content: conversation, timestamp: Date.now() },
+            ]);
+            const memories = response.content.split('\n').filter(l => l.trim());
+            // Keep system messages + memory summary + last 10 messages
+            const systemMessages = messages.filter(m => m.role === 'system');
+            const recentMessages = messages.slice(-10);
+            const memoryMessage = {
+                role: 'system',
+                content: `## Session Memories\n${response.content}`,
+                timestamp: Date.now(),
+            };
+            const compacted = [...systemMessages, memoryMessage, ...recentMessages];
+            const compactedTokens = this.contextManager.countTokens(compacted);
+            const originalTokens = this.contextManager.countTokens(messages);
+            return {
+                messages: compacted,
+                layer: 'session_memory',
+                originalTokens,
+                compactedTokens,
+                savings: originalTokens - compactedTokens,
+                memories,
+            };
+        }
+        catch {
+            // Fallback to snip
+            return this.layerSnip(messages);
+        }
+    }
+    /**
+     * Layer 5: Full Collapse
+     * Nuclear option - completely summarize the conversation
+     */
+    async layerFullCollapse(messages) {
+        const systemMessages = messages.filter(m => m.role === 'system');
+        // Get the user's original request
+        const userMessages = messages.filter(m => m.role === 'user');
+        const originalRequest = userMessages[0]?.content || '';
+        // Get the latest state
+        const lastAssistant = [...messages].reverse().find(m => m.role === 'assistant');
+        const latestState = lastAssistant?.content || '';
+        try {
+            const response = await this.client.quickChat(this.model, [
+                {
+                    role: 'system',
+                    content: 'You are a context compactor. Create a comprehensive but concise summary of the conversation that preserves all critical context for continuing the task.',
+                    timestamp: Date.now(),
+                },
+                {
+                    role: 'user',
+                    content: `Original request: ${originalRequest}\n\nCurrent state: ${latestState}\n\nFull conversation:\n${messages.map(m => `[${m.role}]: ${m.content.slice(0, 300)}`).join('\n')}`,
+                    timestamp: Date.now(),
+                },
+            ]);
+            const collapsedMessage = {
+                role: 'system',
+                content: `## Collapsed Context\n${response.content}`,
+                timestamp: Date.now(),
+            };
+            // Keep system + collapsed context + last user message + last assistant message
+            const compacted = [
+                ...systemMessages,
+                collapsedMessage,
+                ...(userMessages.length > 0 ? [userMessages[userMessages.length - 1]] : []),
+                ...(lastAssistant ? [lastAssistant] : []),
+            ];
+            const compactedTokens = this.contextManager.countTokens(compacted);
+            const originalTokens = this.contextManager.countTokens(messages);
+            return {
+                messages: compacted,
+                layer: 'full_collapse',
+                originalTokens,
+                compactedTokens,
+                savings: originalTokens - compactedTokens,
+            };
+        }
+        catch {
+            // Ultimate fallback
+            return this.layerSnip(messages);
+        }
+    }
+}
+//# sourceMappingURL=compaction.js.map