neuro-cli 4.1.0

package/dist/core/auto-compact.js

@@ -0,0 +1,436 @@
+// ============================================================
+// NeuroCLI - GAP-37: Auto-Compact with Model-Aware Context Management
+// Automatic context compaction that adapts to model context windows
+// ============================================================
+import { MODELS } from '../api/models.js';
+import { ContextManager } from './context.js';
+// ---- Token Estimation ----
+const CJK_RANGES = /[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g;
+function estimateTokensForText(text) {
+    const cjkMatches = text.match(CJK_RANGES);
+    const cjkCount = cjkMatches ? cjkMatches.length : 0;
+    const otherCount = text.length - cjkCount;
+    return Math.ceil(cjkCount / 2 + otherCount / 4);
+}
+// ---- Default Config ----
+export const DEFAULT_AUTO_COMPACT_CONFIG = {
+    enabled: true,
+    warningThreshold: 0.7,
+    compactThreshold: 0.85,
+    emergencyThreshold: 0.95,
+    preserveRecentCount: 6,
+    preserveSystemPrompt: true,
+    compactStrategy: 'hybrid',
+    tokenBudget: {
+        systemPrompt: 0.15, // 15% of context window
+        conversation: 0.45, // 45% of context window
+        tools: 0.10, // 10% of context window
+        output: 0.30, // 30% of context window (reserved for output)
+    },
+};
+// ---- Fallback Context Window ----
+const DEFAULT_CONTEXT_WINDOW = 128000;
+export class AutoCompactManager {
+    config;
+    currentModelId;
+    contextManager = null;
+    compactor = null;
+    // Callbacks
+    warningCallbacks = [];
+    compactCallbacks = [];
+    emergencyCallbacks = [];
+    // Track last level to avoid duplicate callbacks
+    lastLevel = 'normal';
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_AUTO_COMPACT_CONFIG, ...config };
+        // Deep merge tokenBudget
+        if (config.tokenBudget) {
+            this.config.tokenBudget = {
+                ...DEFAULT_AUTO_COMPACT_CONFIG.tokenBudget,
+                ...config.tokenBudget,
+            };
+        }
+        this.currentModelId = '';
+    }
+    /**
+     * Update the current model and recalculate model-aware thresholds.
+     * Rebuilds ContextManager and ContextCompactor for the new model.
+     */
+    setModel(modelId) {
+        this.currentModelId = modelId;
+        const model = MODELS[modelId];
+        const contextWindow = model?.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
+        this.contextManager = new ContextManager(modelId, contextWindow);
+        // ContextCompactor requires a ContextManager and an OpenRouterClient.
+        // We keep a null reference because we implement our own compaction logic
+        // that delegates to the ContextManager's token counting and summarization,
+        // falling back to the compactor only when available.
+        this.compactor = null;
+    }
+    /**
+     * Set the ContextCompactor for LLM-backed summarization.
+     * This is optional — without it, auto-compact uses local strategies only.
+     */
+    setCompactor(compactor) {
+        this.compactor = compactor;
+    }
+    // ---- Monitoring ----
+    /**
+     * Compute detailed context usage breakdown for the given messages and model.
+     */
+    getContextUsage(messages, modelId) {
+        const model = MODELS[modelId];
+        const maxTokens = model?.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
+        // Calculate token counts per category
+        let systemPromptTokens = 0;
+        let conversationTokens = 0;
+        let toolsTokens = 0;
+        for (const msg of messages) {
+            const msgTokens = this.estimateMessageTokens(msg);
+            if (msg.role === 'system') {
+                systemPromptTokens += msgTokens;
+            }
+            else if (msg.role === 'tool') {
+                toolsTokens += msgTokens;
+            }
+            else {
+                conversationTokens += msgTokens;
+            }
+            // Tool calls on assistant messages count toward tools budget
+            if (msg.toolCalls) {
+                for (const tc of msg.toolCalls) {
+                    toolsTokens += estimateTokensForText(tc.function.name + tc.function.arguments);
+                }
+            }
+        }
+        const totalTokens = systemPromptTokens + conversationTokens + toolsTokens;
+        const outputReserve = Math.floor(maxTokens * this.config.tokenBudget.output);
+        const availableTokens = Math.max(0, maxTokens - totalTokens - outputReserve);
+        const usagePercent = totalTokens / maxTokens;
+        let level = 'normal';
+        if (usagePercent >= this.config.emergencyThreshold) {
+            level = 'emergency';
+        }
+        else if (usagePercent >= this.config.compactThreshold) {
+            level = 'compact';
+        }
+        else if (usagePercent >= this.config.warningThreshold) {
+            level = 'warning';
+        }
+        return {
+            totalTokens,
+            maxTokens,
+            usagePercent,
+            breakdown: {
+                systemPrompt: systemPromptTokens,
+                conversation: conversationTokens,
+                tools: toolsTokens,
+                available: availableTokens,
+            },
+            level,
+        };
+    }
+    /**
+     * Determine whether compaction is needed and at what level.
+     * Fires callbacks when the level transitions.
+     */
+    shouldCompact(messages, modelId) {
+        const usage = this.getContextUsage(messages, modelId);
+        const needed = usage.level === 'compact' || usage.level === 'emergency';
+        // Fire callbacks on level transitions
+        if (usage.level !== this.lastLevel) {
+            if (usage.level === 'warning') {
+                for (const cb of this.warningCallbacks) {
+                    cb(usage);
+                }
+            }
+            else if (usage.level === 'compact') {
+                // Also fire warning callbacks at compact level if transitioning from normal
+                if (this.lastLevel === 'normal') {
+                    for (const cb of this.warningCallbacks) {
+                        cb(usage);
+                    }
+                }
+            }
+            else if (usage.level === 'emergency') {
+                for (const cb of this.emergencyCallbacks) {
+                    cb(usage);
+                }
+            }
+            this.lastLevel = usage.level;
+        }
+        return { needed, level: usage.level };
+    }
+    // ---- Compaction ----
+    /**
+     * Compact messages according to the configured or specified strategy.
+     * Returns the compacted message list along with usage metrics.
+     */
+    async compact(messages, strategy) {
+        if (!this.config.enabled) {
+            return messages;
+        }
+        const effectiveModelId = this.currentModelId || 'openrouter/free';
+        const usage = this.getContextUsage(messages, effectiveModelId);
+        const effectiveStrategy = strategy ?? this.config.compactStrategy;
+        let result;
+        switch (effectiveStrategy) {
+            case 'summarize':
+                result = await this.compactBySummarize(messages, usage);
+                break;
+            case 'drop-oldest':
+                result = this.compactByDropOldest(messages, usage);
+                break;
+            case 'hybrid':
+                result = await this.compactByHybrid(messages, usage);
+                break;
+            default:
+                result = this.compactByDropOldest(messages, usage);
+        }
+        // Fire compact callbacks
+        const newUsage = this.getContextUsage(result, effectiveModelId);
+        for (const cb of this.compactCallbacks) {
+            cb(newUsage, result);
+        }
+        // Update tracked level
+        this.lastLevel = newUsage.level;
+        return result;
+    }
+    /**
+     * Strategy: Summarize older messages into a single context message.
+     * Keeps last N messages verbatim, summarizes everything else.
+     */
+    async compactBySummarize(messages, usage) {
+        const model = MODELS[this.currentModelId];
+        const maxTokens = model?.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
+        const targetTokens = Math.floor(maxTokens * this.config.compactThreshold * 0.75); // compact to 75% of threshold
+        const { systemMessages, nonSystemMessages } = this.partitionMessages(messages);
+        if (nonSystemMessages.length <= this.config.preserveRecentCount) {
+            // Nothing to summarize
+            return messages;
+        }
+        // Split into "old" and "recent"
+        const preserveCount = this.config.preserveRecentCount;
+        const recentMessages = nonSystemMessages.slice(-preserveCount);
+        const oldMessages = nonSystemMessages.slice(0, -preserveCount);
+        // Build summary of old messages
+        const summaryContent = this.buildSummary(oldMessages);
+        const summaryMessage = {
+            role: 'system',
+            content: `## Earlier Conversation Summary\n${summaryContent}`,
+            timestamp: Date.now(),
+        };
+        let result = [...systemMessages, summaryMessage, ...recentMessages];
+        // If we still exceed the target, try LLM-backed compaction
+        const resultUsage = this.getContextUsage(result, this.currentModelId);
+        if (resultUsage.usagePercent >= this.config.compactThreshold && this.compactor) {
+            try {
+                const compactionResult = await this.compactor.compact(result);
+                result = compactionResult.messages;
+            }
+            catch {
+                // Fall through — keep local summary result
+            }
+        }
+        // If still over budget, progressively drop oldest from the old messages section
+        if (this.getContextUsage(result, this.currentModelId).usagePercent >= this.config.emergencyThreshold) {
+            result = this.emergencyDrop(result);
+        }
+        return result;
+    }
+    /**
+     * Strategy: Drop oldest messages (except system prompt and recent).
+     */
+    compactByDropOldest(messages, usage) {
+        const model = MODELS[this.currentModelId];
+        const maxTokens = model?.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
+        const targetTokens = Math.floor(maxTokens * this.config.compactThreshold * 0.75);
+        const { systemMessages, nonSystemMessages } = this.partitionMessages(messages);
+        if (nonSystemMessages.length <= this.config.preserveRecentCount) {
+            return messages;
+        }
+        // Start by keeping system + recent; progressively add older messages from newest to oldest
+        const preserveCount = this.config.preserveRecentCount;
+        const recentMessages = nonSystemMessages.slice(-preserveCount);
+        const olderMessages = nonSystemMessages.slice(0, -preserveCount);
+        // Work backwards through older messages, adding as many as we can afford
+        const keptOlder = [];
+        let currentTokens = this.estimateMessagesTokens([...systemMessages, ...recentMessages]);
+        for (let i = olderMessages.length - 1; i >= 0; i--) {
+            const msgTokens = this.estimateMessageTokens(olderMessages[i]);
+            if (currentTokens + msgTokens <= targetTokens) {
+                keptOlder.unshift(olderMessages[i]);
+                currentTokens += msgTokens;
+            }
+            else {
+                break;
+            }
+        }
+        // If we dropped some messages, add a brief context note
+        const droppedCount = olderMessages.length - keptOlder.length;
+        let result;
+        if (droppedCount > 0) {
+            const contextNote = {
+                role: 'system',
+                content: `## Context Note\n${droppedCount} earlier message(s) were dropped to fit the context window. Key details may have been lost.`,
+                timestamp: Date.now(),
+            };
+            result = [...systemMessages, contextNote, ...keptOlder, ...recentMessages];
+        }
+        else {
+            result = [...systemMessages, ...keptOlder, ...recentMessages];
+        }
+        return result;
+    }
+    /**
+     * Strategy: Hybrid — summarize first, then drop oldest if still over budget.
+     */
+    async compactByHybrid(messages, usage) {
+        // First pass: summarize
+        const summarized = await this.compactBySummarize(messages, usage);
+        // Check if still over budget
+        const postUsage = this.getContextUsage(summarized, this.currentModelId);
+        if (postUsage.usagePercent < this.config.compactThreshold) {
+            return summarized;
+        }
+        // Second pass: drop oldest from the summarized result
+        return this.compactByDropOldest(summarized, postUsage);
+    }
+    /**
+     * Emergency compaction: keep only system prompt + last 3 exchanges (6 messages).
+     * This is the last resort when everything else fails.
+     */
+    emergencyDrop(messages) {
+        const { systemMessages, nonSystemMessages } = this.partitionMessages(messages);
+        // Keep exactly the last 3 exchanges (6 messages: user/assistant/tool pairs)
+        const emergencyPreserveCount = 6;
+        const recentMessages = nonSystemMessages.slice(-emergencyPreserveCount);
+        const emergencyNote = {
+            role: 'system',
+            content: '## Emergency Compaction\nContext was critically over budget. Older messages were dropped. Only the most recent exchanges are preserved.',
+            timestamp: Date.now(),
+        };
+        return [...systemMessages, emergencyNote, ...recentMessages];
+    }
+    // ---- Token Estimation ----
+    /**
+     * Estimate the number of tokens in a text string for a given model.
+     * Uses ~4 chars/token for English, ~2 chars/token for CJK.
+     */
+    estimateTokens(text, _modelId) {
+        return estimateTokensForText(text);
+    }
+    /**
+     * Estimate total tokens across an array of messages,
+     * including tool calls.
+     */
+    estimateMessagesTokens(messages) {
+        return messages.reduce((sum, msg) => sum + this.estimateMessageTokens(msg), 0);
+    }
+    /**
+     * Estimate tokens for a single message including tool calls.
+     */
+    estimateMessageTokens(msg) {
+        let tokens = estimateTokensForText(msg.content);
+        if (msg.toolCalls) {
+            for (const tc of msg.toolCalls) {
+                tokens += estimateTokensForText(tc.function.name + tc.function.arguments);
+            }
+        }
+        // Overhead per message: role label, formatting, etc. (~4 tokens)
+        tokens += 4;
+        return tokens;
+    }
+    // ---- Callbacks ----
+    onWarning(callback) {
+        this.warningCallbacks.push(callback);
+    }
+    onCompact(callback) {
+        this.compactCallbacks.push(callback);
+    }
+    onEmergency(callback) {
+        this.emergencyCallbacks.push(callback);
+    }
+    // ---- Helpers ----
+    /**
+     * Partition messages into system and non-system buckets.
+     */
+    partitionMessages(messages) {
+        const systemMessages = [];
+        const nonSystemMessages = [];
+        for (const msg of messages) {
+            if (msg.role === 'system') {
+                systemMessages.push(msg);
+            }
+            else {
+                nonSystemMessages.push(msg);
+            }
+        }
+        return { systemMessages, nonSystemMessages };
+    }
+    /**
+     * Build a concise summary from a list of messages.
+     * Prioritizes user intent, tool interactions, and assistant decisions.
+     */
+    buildSummary(messages) {
+        const parts = [];
+        for (const msg of messages) {
+            const preview = msg.content.length > 150
+                ? msg.content.slice(0, 150) + '...'
+                : msg.content;
+            switch (msg.role) {
+                case 'user':
+                    parts.push(`[User]: ${preview}`);
+                    break;
+                case 'assistant':
+                    if (msg.toolCalls?.length) {
+                        const toolNames = msg.toolCalls.map(tc => tc.function.name).join(', ');
+                        parts.push(`[Assistant called: ${toolNames}] ${preview}`);
+                    }
+                    else {
+                        parts.push(`[Assistant]: ${preview}`);
+                    }
+                    break;
+                case 'tool':
+                    parts.push(`[Tool result]: ${preview.slice(0, 80)}`);
+                    break;
+                default:
+                    break;
+            }
+        }
+        return parts.join('\n');
+    }
+}
+// ---- Convenience: Auto-Compact Middleware ----
+/**
+ * Middleware function that can be called before each LLM call.
+ * Checks context usage, auto-compacts if needed, and returns
+ * the (possibly compacted) message list.
+ */
+export async function autoCompactMiddleware(manager, messages, modelId) {
+    if (!manager['config'].enabled) {
+        return messages;
+    }
+    manager.setModel(modelId);
+    const { needed, level } = manager.shouldCompact(messages, modelId);
+    if (!needed) {
+        return messages;
+    }
+    // Choose strategy based on severity
+    let strategy;
+    if (level === 'emergency') {
+        strategy = 'drop-oldest'; // Fastest, most aggressive
+    }
+    else if (level === 'compact') {
+        strategy = manager['config'].compactStrategy;
+    }
+    else {
+        return messages;
+    }
+    return manager.compact(messages, strategy);
+}
+// ---- Convenience: Create a pre-configured AutoCompactManager ----
+export function createAutoCompactManager(overrides) {
+    return new AutoCompactManager(overrides);
+}
+//# sourceMappingURL=auto-compact.js.map

package/dist/core/auto-mode.d.ts

@@ -0,0 +1,232 @@
+export type SafetyLevel = 'conservative' | 'moderate' | 'aggressive';
+export interface AutoModeConfig {
+    /** Whether auto mode is currently enabled */
+    enabled: boolean;
+    /** Safety level controlling what operations are permitted */
+    safetyLevel: SafetyLevel;
+    /** Maximum iterations before auto mode stops (default 50) */
+    maxIterations: number;
+    /** Maximum spend in USD – 0 = unlimited */
+    maxCost: number;
+    /** Maximum execution time in ms – 0 = unlimited */
+    maxTimeMs: number;
+    /** Commands that are ALWAYS blocked, even in auto mode */
+    blockedCommands: string[];
+    /** File glob patterns that can never be modified in auto mode */
+    blockedPatterns: string[];
+    /** Auto git commit after each change */
+    autoCommit: boolean;
+    /** Auto run tests after each change */
+    autoTest: boolean;
+    /** Pause auto mode when an error is encountered */
+    pauseOnError: boolean;
+}
+export interface AutoModeStats {
+    /** Number of iterations completed */
+    iterations: number;
+    /** Number of files changed (created, modified, or deleted) */
+    filesChanged: number;
+    /** Number of commands executed */
+    commandsRun: number;
+    /** Total elapsed time in ms */
+    timeElapsedMs: number;
+    /** Total cost accrued in USD */
+    totalCost: number;
+    /** Number of operations blocked by safety */
+    blockedOperations: number;
+    /** Number of errors encountered */
+    errors: number;
+}
+export interface GoalDefinition {
+    /** Unique identifier */
+    id: string;
+    /** Short human-readable name */
+    name: string;
+    /** High-level goal description */
+    description: string;
+    /** Optional success criteria – when all pass, the goal is considered complete */
+    successCriteria: string[];
+    /** Optional list of sub-goals */
+    subGoals: GoalDefinition[];
+    /** ISO timestamp when the goal was created */
+    createdAt: string;
+    /** ISO timestamp when the goal was completed (if applicable) */
+    completedAt?: string;
+    /** Current status */
+    status: 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
+    /** Progress from 0 to 1 */
+    progress: number;
+}
+export interface RoutineStep {
+    /** Optional label for the step */
+    label?: string;
+    /** The prompt or command to execute */
+    prompt: string;
+    /** Optional model override for this step */
+    model?: string;
+    /** Whether to pause between this step and the next */
+    pauseAfter?: boolean;
+    /** Maximum iterations allowed for this step */
+    maxIterations?: number;
+}
+export interface RoutineDefinition {
+    /** Unique identifier */
+    id: string;
+    /** Short human-readable name */
+    name: string;
+    /** Description of what the routine accomplishes */
+    description: string;
+    /** Ordered list of steps */
+    steps: RoutineStep[];
+    /** ISO timestamp when the routine was created */
+    createdAt: string;
+    /** ISO timestamp of last run */
+    lastRunAt?: string;
+    /** Number of times this routine has been run */
+    runCount: number;
+    /** Tags for categorisation */
+    tags: string[];
+}
+export interface AutoModeCheckpoint {
+    id: string;
+    timestamp: string;
+    iteration: number;
+    goalId?: string;
+    routineId?: string;
+    snapshot: string;
+}
+/**
+ * Minimal interface that any execution engine must satisfy for AutoMode
+ * to orchestrate it.  This avoids a hard import of NeuroEngine while
+ * keeping the two modules loosely coupled.
+ */
+export interface AutoModeEngine {
+    /** Run a single prompt through the engine and return the assistant text */
+    runPrompt(prompt: string, model?: string): Promise<{
+        text: string;
+        inputTokens: number;
+        outputTokens: number;
+        cost: number;
+        filesChanged: number;
+        commandsRun: number;
+        error?: string;
+    }>;
+}
+export declare class AutoMode {
+    private config;
+    private stats;
+    private goals;
+    private routines;
+    private checkpoints;
+    private startTime;
+    private running;
+    private abortController;
+    private onStatusChange?;
+    constructor(config?: Partial<AutoModeConfig>, onStatusChange?: (status: AutoModeStatus) => void);
+    /** Enable auto mode – skip all approval prompts, run safety checks in background */
+    enable(): void;
+    /** Disable auto mode, return to interactive */
+    disable(): void;
+    /** Check whether auto mode is currently enabled */
+    isEnabled(): boolean;
+    /** Check whether auto mode is currently running a task */
+    isRunning(): boolean;
+    getConfig(): Readonly<AutoModeConfig>;
+    updateConfig(updates: Partial<AutoModeConfig>): void;
+    setSafetyLevel(level: SafetyLevel): void;
+    /**
+     * Run a task fully autonomously.
+     *
+     * The engine will be called repeatedly until:
+     * - maxIterations is reached
+     * - maxCost is exceeded
+     * - maxTimeMs is exceeded
+     * - The task appears complete (engine signals no further action needed)
+     * - An error occurs and pauseOnError is true
+     * - The user aborts
+     */
+    executeAuto(prompt: string, engine: AutoModeEngine, maxIterations?: number): Promise<AutoModeResult>;
+    /** Abort the currently running auto execution */
+    abort(): void;
+    /** Set a high-level goal and let the agent work towards it autonomously */
+    setGoal(name: string, description: string, successCriteria?: string[]): GoalDefinition;
+    /** Get a goal by ID */
+    getGoal(goalId: string): GoalDefinition | undefined;
+    /** List all goals */
+    listGoals(): GoalDefinition[];
+    /** Update goal progress */
+    updateGoalProgress(goalId: string, progress: number, status?: GoalDefinition['status']): void;
+    /** Add a sub-goal */
+    addSubGoal(parentId: string, name: string, description: string): GoalDefinition | null;
+    /** Delete a goal */
+    deleteGoal(goalId: string): boolean;
+    /**
+     * Execute a goal autonomously – will iterate until the goal is reached
+     * or limits are hit
+     */
+    executeGoal(goalId: string, engine: AutoModeEngine): Promise<AutoModeResult>;
+    /** Create a new routine */
+    createRoutine(name: string, description: string, steps: RoutineStep[], tags?: string[]): RoutineDefinition;
+    /** Get a routine by ID */
+    getRoutine(routineId: string): RoutineDefinition | undefined;
+    /** List all routines, optionally filtered by tag */
+    listRoutines(tag?: string): RoutineDefinition[];
+    /** Delete a routine */
+    deleteRoutine(routineId: string): boolean;
+    /** Update a routine's steps */
+    updateRoutineSteps(routineId: string, steps: RoutineStep[]): boolean;
+    /** Replay a saved routine */
+    executeRoutine(routineId: string, engine: AutoModeEngine): Promise<AutoModeResult>;
+    /**
+     * Pre-flight safety check – examines the prompt for dangerous commands
+     * or patterns that should be blocked even in auto mode.
+     */
+    preFlightSafetyCheck(prompt: string): {
+        allowed: boolean;
+        reason?: string;
+    };
+    /**
+     * Runtime safety check for a specific command about to be executed.
+     * This is meant to be called by the engine before running any shell command.
+     */
+    isCommandAllowed(command: string): {
+        allowed: boolean;
+        reason?: string;
+    };
+    /**
+     * Runtime safety check for a file path about to be modified.
+     * This is meant to be called by the engine before any file write.
+     */
+    isFileModificationAllowed(filePath: string): {
+        allowed: boolean;
+        reason?: string;
+    };
+    getStats(): Readonly<AutoModeStats>;
+    resetStats(): void;
+    listCheckpoints(): AutoModeCheckpoint[];
+    getLatestCheckpoint(): AutoModeCheckpoint | undefined;
+    /** Create a checkpoint of the current state */
+    createCheckpoint(iteration: number, goalId?: string, routineId?: string): AutoModeCheckpoint;
+    private freshStats;
+    private emitStatus;
+    private buildBlockedCommands;
+    private buildBlockedPatterns;
+    private detectCompletion;
+    private buildGoalPrompt;
+    private autoGitCommit;
+    private autoRunTests;
+    private matchesGlobPattern;
+    private persistState;
+    private loadState;
+    private persistGoals;
+    private persistRoutines;
+}
+export type AutoModeStatus = 'disabled' | 'enabled' | 'running';
+export interface AutoModeResult {
+    ok: boolean;
+    iterations: number;
+    finalText: string;
+    completed?: boolean;
+    error?: string;
+}
+//# sourceMappingURL=auto-mode.d.ts.map