neuro-cli 4.1.0

package/dist/core/extended-thinking.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Extended Thinking System for NeuroCLI
+ *
+ * Handles thinking/reasoning blocks in AI responses, providing configurable
+ * thinking modes, budget management, streaming support, and statistics tracking.
+ */
+export type ThinkingMode = 'none' | 'brief' | 'full' | 'ultrathink';
+export interface ThinkingConfig {
+    mode: ThinkingMode;
+    maxThinkingTokens: number;
+    showThinking: boolean;
+    effortBudget: Record<ThinkingMode, number>;
+}
+export interface ThinkingBlock {
+    content: string;
+    tokenCount: number;
+    duration?: number;
+}
+export interface ThinkingResult {
+    thinkingBlocks: ThinkingBlock[];
+    totalThinkingTokens: number;
+    cleanedResponse: string;
+    hadThinking: boolean;
+}
+export declare class ExtendedThinking {
+    private config;
+    private totalThinkingTokens;
+    private thinkingHistory;
+    static readonly DEFAULT_CONFIG: ThinkingConfig;
+    constructor(config?: Partial<ThinkingConfig>);
+    /**
+     * Parse an AI response, extracting any <thinking> blocks and returning
+     * the cleaned response text together with extracted thinking data.
+     */
+    parseResponse(response: string): ThinkingResult;
+    /** Switch to a different thinking mode and update the token budget. */
+    setMode(mode: ThinkingMode): void;
+    /** Return the current thinking mode. */
+    getMode(): ThinkingMode;
+    /** Toggle the display of thinking blocks. Returns the new state. */
+    toggleDisplay(): boolean;
+    /** Whether thinking blocks should be shown to the user. */
+    isDisplayEnabled(): boolean;
+    /** Return the token budget for the current mode. */
+    getEffortBudget(): number;
+    /**
+     * Return a system-prompt fragment that instructs the model to use
+     * <thinking> tags for its internal reasoning process, scoped to the
+     * current mode and token budget.
+     */
+    getSystemPromptAddition(): string;
+    /** Return aggregate statistics across all parsed responses. */
+    getStats(): {
+        totalThinkingTokens: number;
+        totalBlocks: number;
+        avgBlockLength: number;
+    };
+    /** Reset accumulated statistics and history. */
+    resetStats(): void;
+    /**
+     * Check whether a partial streaming buffer currently contains an open
+     * thinking tag that has not yet been closed. Useful for deciding whether
+     * incoming tokens belong to a thinking region.
+     */
+    static isInThinkingBlock(buffer: string): boolean;
+    /**
+     * Attempt to extract any complete thinking blocks from a streaming buffer
+     * without mutating it. Returns completed blocks and leaves partial blocks
+     * untouched (they remain in the buffer for subsequent chunks).
+     */
+    static extractStreamingBlocks(buffer: string): {
+        completedBlocks: ThinkingBlock[];
+        remaining: string;
+    };
+    /**
+     * Extract all <thinking>...</thinking> blocks from a complete response
+     * string, returning the parsed blocks and the cleaned response with the
+     * thinking tags removed.
+     */
+    private extractThinkingBlocks;
+    /** Estimate the number of tokens in a piece of text. */
+    private estimateTokens;
+    /** Static version for use without an instance. */
+    private static estimateTokensStatic;
+    /**
+     * Serialize the display preference and mode so it can be persisted
+     * (e.g. to a config file or localStorage).
+     */
+    serializePreferences(): {
+        mode: ThinkingMode;
+        showThinking: boolean;
+    };
+    /**
+     * Restore a previously serialized preference. Only mode and display
+     * toggle are restored; statistics remain untouched.
+     */
+    restorePreferences(prefs: {
+        mode?: ThinkingMode;
+        showThinking?: boolean;
+    }): void;
+}
+export default ExtendedThinking;
+//# sourceMappingURL=extended-thinking.d.ts.map

package/dist/core/extended-thinking.js

@@ -0,0 +1,269 @@
+/**
+ * Extended Thinking System for NeuroCLI
+ *
+ * Handles thinking/reasoning blocks in AI responses, providing configurable
+ * thinking modes, budget management, streaming support, and statistics tracking.
+ */
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const THINKING_OPEN_TAG = '<thinking>';
+const THINKING_CLOSE_TAG = '</thinking>';
+const OPEN_TAG_LEN = THINKING_OPEN_TAG.length;
+const CLOSE_TAG_LEN = THINKING_CLOSE_TAG.length;
+// Rough heuristic: 1 token ~ 4 characters for English text
+const CHARS_PER_TOKEN = 4;
+// ---------------------------------------------------------------------------
+// ExtendedThinking
+// ---------------------------------------------------------------------------
+export class ExtendedThinking {
+    config;
+    totalThinkingTokens;
+    thinkingHistory;
+    static DEFAULT_CONFIG = {
+        mode: 'none',
+        maxThinkingTokens: 0,
+        showThinking: false,
+        effortBudget: {
+            none: 0,
+            brief: 1000,
+            full: 4000,
+            ultrathink: 16000,
+        },
+    };
+    constructor(config) {
+        this.config = {
+            ...ExtendedThinking.DEFAULT_CONFIG,
+            ...config,
+            effortBudget: {
+                ...ExtendedThinking.DEFAULT_CONFIG.effortBudget,
+                ...(config?.effortBudget ?? {}),
+            },
+        };
+        // Sync maxThinkingTokens with the budget for the chosen mode
+        this.config.maxThinkingTokens = this.config.effortBudget[this.config.mode];
+        this.totalThinkingTokens = 0;
+        this.thinkingHistory = [];
+    }
+    // -------------------------------------------------------------------------
+    // Public API
+    // -------------------------------------------------------------------------
+    /**
+     * Parse an AI response, extracting any <thinking> blocks and returning
+     * the cleaned response text together with extracted thinking data.
+     */
+    parseResponse(response) {
+        const { blocks, cleaned } = this.extractThinkingBlocks(response);
+        const blockTokenTotal = blocks.reduce((sum, block) => sum + block.tokenCount, 0);
+        // Accumulate history and stats
+        for (const block of blocks) {
+            this.thinkingHistory.push(block);
+            this.totalThinkingTokens += block.tokenCount;
+        }
+        return {
+            thinkingBlocks: blocks,
+            totalThinkingTokens: blockTokenTotal,
+            cleanedResponse: cleaned,
+            hadThinking: blocks.length > 0,
+        };
+    }
+    /** Switch to a different thinking mode and update the token budget. */
+    setMode(mode) {
+        this.config.mode = mode;
+        this.config.maxThinkingTokens = this.config.effortBudget[mode];
+    }
+    /** Return the current thinking mode. */
+    getMode() {
+        return this.config.mode;
+    }
+    /** Toggle the display of thinking blocks. Returns the new state. */
+    toggleDisplay() {
+        this.config.showThinking = !this.config.showThinking;
+        return this.config.showThinking;
+    }
+    /** Whether thinking blocks should be shown to the user. */
+    isDisplayEnabled() {
+        return this.config.showThinking;
+    }
+    /** Return the token budget for the current mode. */
+    getEffortBudget() {
+        return this.config.effortBudget[this.config.mode];
+    }
+    /**
+     * Return a system-prompt fragment that instructs the model to use
+     * <thinking> tags for its internal reasoning process, scoped to the
+     * current mode and token budget.
+     */
+    getSystemPromptAddition() {
+        if (this.config.mode === 'none') {
+            return '';
+        }
+        const budget = this.config.effortBudget[this.config.mode];
+        const modeDescriptions = {
+            none: '',
+            brief: 'Provide condensed, focused reasoning highlighting only the key decision points.',
+            full: 'Provide thorough, step-by-step reasoning that walks through your entire thought process.',
+            ultrathink: 'Provide exhaustive, maximum-depth reasoning. Explore every angle, consider alternatives, verify logic at each step, and leave no stone unturned. This is the highest reasoning effort mode.',
+        };
+        const description = modeDescriptions[this.config.mode];
+        return [
+            'You have an extended thinking capability. When you need to reason through a problem, enclose your reasoning inside <thinking>...</thinking> tags.',
+            `Current thinking mode: ${this.config.mode}.`,
+            `Maximum thinking token budget: ${budget} tokens.`,
+            description,
+            'Place your thinking blocks BEFORE the visible response content. You may include multiple thinking blocks if needed, but stay within the token budget.',
+            'Do NOT include <thinking> tags in the final visible output -- they are only for internal reasoning.',
+        ].join('\n');
+    }
+    /** Return aggregate statistics across all parsed responses. */
+    getStats() {
+        const totalBlocks = this.thinkingHistory.length;
+        return {
+            totalThinkingTokens: this.totalThinkingTokens,
+            totalBlocks,
+            avgBlockLength: totalBlocks > 0
+                ? Math.round(this.totalThinkingTokens / totalBlocks)
+                : 0,
+        };
+    }
+    /** Reset accumulated statistics and history. */
+    resetStats() {
+        this.totalThinkingTokens = 0;
+        this.thinkingHistory = [];
+    }
+    // -------------------------------------------------------------------------
+    // Streaming helpers (static utilities for use during streaming)
+    // -------------------------------------------------------------------------
+    /**
+     * Check whether a partial streaming buffer currently contains an open
+     * thinking tag that has not yet been closed. Useful for deciding whether
+     * incoming tokens belong to a thinking region.
+     */
+    static isInThinkingBlock(buffer) {
+        const lastOpen = buffer.lastIndexOf(THINKING_OPEN_TAG);
+        if (lastOpen === -1)
+            return false;
+        const lastClose = buffer.lastIndexOf(THINKING_CLOSE_TAG);
+        return lastClose < lastOpen;
+    }
+    /**
+     * Attempt to extract any complete thinking blocks from a streaming buffer
+     * without mutating it. Returns completed blocks and leaves partial blocks
+     * untouched (they remain in the buffer for subsequent chunks).
+     */
+    static extractStreamingBlocks(buffer) {
+        const completedBlocks = [];
+        let remaining = buffer;
+        let searchStart = 0;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const openIdx = remaining.indexOf(THINKING_OPEN_TAG, searchStart);
+            if (openIdx === -1)
+                break;
+            const closeIdx = remaining.indexOf(THINKING_CLOSE_TAG, openIdx + OPEN_TAG_LEN);
+            if (closeIdx === -1) {
+                // Partial block -- still streaming; leave it in remaining
+                break;
+            }
+            const content = remaining.slice(openIdx + OPEN_TAG_LEN, closeIdx).trim();
+            completedBlocks.push({
+                content,
+                tokenCount: ExtendedThinking.estimateTokensStatic(content),
+            });
+            // Remove the parsed block from remaining
+            const before = remaining.slice(0, openIdx);
+            const after = remaining.slice(closeIdx + CLOSE_TAG_LEN);
+            remaining = before + after;
+            searchStart = before.length;
+        }
+        return { completedBlocks, remaining };
+    }
+    // -------------------------------------------------------------------------
+    // Private helpers
+    // -------------------------------------------------------------------------
+    /**
+     * Extract all <thinking>...</thinking> blocks from a complete response
+     * string, returning the parsed blocks and the cleaned response with the
+     * thinking tags removed.
+     */
+    extractThinkingBlocks(response) {
+        const blocks = [];
+        let cleaned = response;
+        let searchStart = 0;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const openIdx = cleaned.indexOf(THINKING_OPEN_TAG, searchStart);
+            if (openIdx === -1)
+                break;
+            const closeIdx = cleaned.indexOf(THINKING_CLOSE_TAG, openIdx + OPEN_TAG_LEN);
+            if (closeIdx === -1) {
+                // Malformed -- unclosed tag; treat the rest as thinking content
+                const content = cleaned
+                    .slice(openIdx + OPEN_TAG_LEN)
+                    .trim();
+                if (content.length > 0) {
+                    blocks.push({
+                        content,
+                        tokenCount: this.estimateTokens(content),
+                    });
+                }
+                cleaned = cleaned.slice(0, openIdx);
+                break;
+            }
+            const content = cleaned
+                .slice(openIdx + OPEN_TAG_LEN, closeIdx)
+                .trim();
+            if (content.length > 0) {
+                blocks.push({
+                    content,
+                    tokenCount: this.estimateTokens(content),
+                });
+            }
+            // Splice out the thinking block
+            const before = cleaned.slice(0, openIdx);
+            const after = cleaned.slice(closeIdx + CLOSE_TAG_LEN);
+            cleaned = before + after;
+            searchStart = before.length;
+        }
+        // Collapse excessive whitespace left behind after removal
+        cleaned = cleaned.replace(/\n{3,}/g, '\n\n').trim();
+        return { blocks, cleaned };
+    }
+    /** Estimate the number of tokens in a piece of text. */
+    estimateTokens(text) {
+        return ExtendedThinking.estimateTokensStatic(text);
+    }
+    /** Static version for use without an instance. */
+    static estimateTokensStatic(text) {
+        if (text.length === 0)
+            return 0;
+        return Math.ceil(text.length / CHARS_PER_TOKEN);
+    }
+    // -------------------------------------------------------------------------
+    // Persistence helpers
+    // -------------------------------------------------------------------------
+    /**
+     * Serialize the display preference and mode so it can be persisted
+     * (e.g. to a config file or localStorage).
+     */
+    serializePreferences() {
+        return {
+            mode: this.config.mode,
+            showThinking: this.config.showThinking,
+        };
+    }
+    /**
+     * Restore a previously serialized preference. Only mode and display
+     * toggle are restored; statistics remain untouched.
+     */
+    restorePreferences(prefs) {
+        if (prefs.mode !== undefined) {
+            this.setMode(prefs.mode);
+        }
+        if (prefs.showThinking !== undefined) {
+            this.config.showThinking = prefs.showThinking;
+        }
+    }
+}
+export default ExtendedThinking;
+//# sourceMappingURL=extended-thinking.js.map

package/dist/core/fallback.d.ts

@@ -0,0 +1,54 @@
+import { OpenRouterClient, TokenUsage } from '../api/openrouter.js';
+import { Message } from './types.js';
+export interface FallbackConfig {
+    models: string[];
+    maxRetries: number;
+    retryDelayMs: number;
+    fallbackOnErrors: string[];
+}
+export interface FallbackResult {
+    content: string;
+    modelUsed: string;
+    attempts: Array<{
+        model: string;
+        success: boolean;
+        error?: string;
+    }>;
+    usage: TokenUsage;
+    toolCalls: Array<{
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+}
+export declare class FallbackChain {
+    private config;
+    private client;
+    constructor(client: OpenRouterClient, config?: Partial<FallbackConfig>);
+    /**
+     * Execute a chat request with fallback chain
+     */
+    chatWithFallback(primaryModel: string, messages: Message[], options: {
+        tools?: unknown[];
+        temperature?: number;
+        maxTokens?: number;
+        stream?: boolean;
+    }, onModelSwitch?: (from: string, to: string) => void): Promise<FallbackResult>;
+    /**
+     * Set fallback models
+     */
+    setFallbackModels(models: string[]): void;
+    /**
+     * Add a fallback model
+     */
+    addFallbackModel(model: string): void;
+    /**
+     * Get current fallback chain
+     */
+    getFallbackChain(): string[];
+    private sleep;
+}
+//# sourceMappingURL=fallback.d.ts.map

package/dist/core/fallback.js

@@ -0,0 +1,104 @@
+// ============================================================
+// NeuroCLI - Fallback Model Chain
+// Automatic model fallback on failure
+// ============================================================
+import { MODELS } from '../api/models.js';
+import chalk from 'chalk';
+export class FallbackChain {
+    config;
+    client;
+    constructor(client, config) {
+        this.client = client;
+        this.config = {
+            models: [],
+            maxRetries: 2,
+            retryDelayMs: 3000,
+            fallbackOnErrors: ['rate_limit', 'overloaded', 'context_length_exceeded', 'timeout', 'server_error'],
+            ...config,
+        };
+    }
+    /**
+     * Execute a chat request with fallback chain
+     */
+    async chatWithFallback(primaryModel, messages, options, onModelSwitch) {
+        const chain = [primaryModel, ...this.config.models.filter(m => m !== primaryModel)];
+        const attempts = [];
+        let totalUsage = { inputTokens: 0, outputTokens: 0, cost: 0 };
+        for (const model of chain) {
+            for (let retry = 0; retry <= this.config.maxRetries; retry++) {
+                try {
+                    const modelInfo = MODELS[model];
+                    console.log(chalk.gray(`  → Trying ${modelInfo?.name || model}${retry > 0 ? ` (retry ${retry})` : ''}...`));
+                    const response = await this.client.chat({
+                        model,
+                        messages,
+                        tools: options.tools,
+                        temperature: options.temperature,
+                        maxTokens: options.maxTokens,
+                        stream: options.stream ?? false,
+                    });
+                    totalUsage.inputTokens += response.usage.inputTokens;
+                    totalUsage.outputTokens += response.usage.outputTokens;
+                    totalUsage.cost += response.usage.cost;
+                    attempts.push({ model, success: true });
+                    // If we used a fallback model, notify
+                    if (model !== primaryModel && onModelSwitch) {
+                        onModelSwitch(primaryModel, model);
+                    }
+                    return {
+                        content: response.content,
+                        modelUsed: model,
+                        attempts,
+                        usage: totalUsage,
+                        toolCalls: response.toolCalls || [],
+                    };
+                }
+                catch (error) {
+                    const errMsg = error instanceof Error ? error.message : String(error);
+                    attempts.push({ model, success: false, error: errMsg });
+                    // Check if this error should trigger fallback
+                    const shouldFallback = this.config.fallbackOnErrors.some(pattern => errMsg.toLowerCase().includes(pattern.toLowerCase()) ||
+                        errMsg.includes('429') ||
+                        errMsg.includes('503') ||
+                        errMsg.includes('500'));
+                    if (shouldFallback) {
+                        console.log(chalk.yellow(`  ⚠ ${model} failed: ${errMsg.slice(0, 80)}`));
+                        break; // Try next model in chain
+                    }
+                    // For other errors, retry on same model
+                    if (retry < this.config.maxRetries) {
+                        const delay = this.config.retryDelayMs * (retry + 1);
+                        console.log(chalk.gray(`  ↻ Retrying in ${delay / 1000}s...`));
+                        await this.sleep(delay);
+                    }
+                }
+            }
+        }
+        // All models failed
+        throw new Error(`All models in fallback chain failed. Attempts: ${JSON.stringify(attempts)}`);
+    }
+    /**
+     * Set fallback models
+     */
+    setFallbackModels(models) {
+        this.config.models = models;
+    }
+    /**
+     * Add a fallback model
+     */
+    addFallbackModel(model) {
+        if (!this.config.models.includes(model)) {
+            this.config.models.push(model);
+        }
+    }
+    /**
+     * Get current fallback chain
+     */
+    getFallbackChain() {
+        return [...this.config.models];
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+//# sourceMappingURL=fallback.js.map

package/dist/core/git-worktree.d.ts

@@ -0,0 +1,139 @@
+import { EventEmitter } from 'events';
+export interface WorktreeInfo {
+    name: string;
+    path: string;
+    branch: string;
+    isCurrent: boolean;
+    isBare: boolean;
+    /** The commit hash the worktree is on */
+    head: string;
+}
+export interface ConflictInfo {
+    filePath: string;
+    type: 'content' | 'delete_modify' | 'rename' | 'add_add';
+    worktreeA: string;
+    worktreeB: string;
+    /** Lines with conflicts (approximate) */
+    conflictingLines: number;
+    /** Whether this conflict can be auto-resolved */
+    autoResolvable: boolean;
+}
+export interface MergeResult {
+    success: boolean;
+    targetBranch: string;
+    sourceWorktree: string;
+    mergedFiles: string[];
+    conflictFiles: string[];
+    message: string;
+    /** If there were conflicts, the raw conflict output */
+    conflictOutput?: string;
+}
+export interface WorktreeStatus {
+    name: string;
+    branch: string;
+    modified: number;
+    added: number;
+    deleted: number;
+    untracked: number;
+    staged: number;
+    isClean: boolean;
+    /** List of modified file paths */
+    modifiedFiles: string[];
+}
+export declare class GitWorktreeManager extends EventEmitter {
+    private repoRoot;
+    private agentBindings;
+    constructor(repoRoot?: string);
+    /**
+     * Create a new git worktree for parallel development.
+     * If no branch is specified, creates a new branch named after the worktree.
+     */
+    createWorktree(name: string, branch?: string): Promise<WorktreeInfo>;
+    /**
+     * Remove a git worktree. If merge is true, attempt to merge the branch first.
+     */
+    removeWorktree(name: string, options?: {
+        force?: boolean;
+        merge?: boolean;
+    }): Promise<void>;
+    /**
+     * List all git worktrees in the repository.
+     */
+    listWorktrees(): Promise<WorktreeInfo[]>;
+    /**
+     * Bind an agent to a specific worktree. The agent will operate
+     * within that worktree's directory.
+     */
+    bindAgentToWorktree(agentId: string, worktreeName: string): void;
+    /**
+     * Unbind an agent from its worktree.
+     */
+    unbindAgent(agentId: string): void;
+    /**
+     * Get the worktree name bound to an agent, or null if unbound.
+     */
+    getWorktreeForAgent(agentId: string): string | null;
+    /**
+     * Get all agent bindings.
+     */
+    getAgentBindings(): Array<{
+        agentId: string;
+        worktreeName: string;
+    }>;
+    /**
+     * Detect potential conflicts between two worktrees by comparing
+     * their modified files and checking for overlaps.
+     */
+    detectConflicts(worktreeA: string, worktreeB: string): Promise<ConflictInfo[]>;
+    /**
+     * Attempt to automatically merge a worktree's branch into the target branch.
+     * Defaults to merging into the main branch.
+     */
+    autoMerge(worktreeName: string, targetBranch?: string): Promise<MergeResult>;
+    /**
+     * Get the status of a worktree (modified, added, deleted files, etc.).
+     */
+    getWorktreeStatus(name: string): Promise<WorktreeStatus>;
+    /**
+     * Remove all worktrees (except the main one) and optionally delete branches.
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Execute a git command and return its output.
+     */
+    private execGit;
+    /**
+     * Parse the porcelain output of `git worktree list`.
+     */
+    private parseWorktreeList;
+    /**
+     * Derive a human-readable name from the worktree path or branch.
+     */
+    private worktreeNameFromPath;
+    /**
+     * Check whether a branch exists in the repository.
+     */
+    private branchExists;
+    /**
+     * Get the list of modified files in a worktree.
+     */
+    private getModifiedFiles;
+    /**
+     * Determine the type of conflict between two file modifications.
+     */
+    private determineConflictType;
+    /**
+     * Analyze the diff between the same file in two worktrees to estimate
+     * conflict severity.
+     */
+    private analyzeFileDiff;
+    /**
+     * Extract changed line ranges from a unified diff output.
+     */
+    private extractChangedLineRanges;
+    /**
+     * Get the list of files changed in the last merge.
+     */
+    private getChangedFilesInMerge;
+}
+//# sourceMappingURL=git-worktree.d.ts.map