winter-super-cli 2026.5.26 → 2026.5.27

package/src/tools/fallback.js

@@ -0,0 +1,123 @@
+/**
+ * Smart Fallback Strategies - Handle tool failures gracefully.
+ * Provides fallback chains, alternative approaches, and recovery strategies.
+ */
+
+export class FallbackManager {
+  constructor(options = {}) {
+    this.fallbacks = new Map();
+    this.maxFallbackDepth = options.maxFallbackDepth || 3;
+    this.logger = options.logger || console;
+  }
+
+  /**
+   * Register a fallback strategy for a tool.
+   */
+  register(toolName, strategies) {
+    this.fallbacks.set(toolName, strategies);
+    return this;
+  }
+
+  /**
+   * Execute a tool with fallback support.
+   */
+  async execute(toolName, input, executor) {
+    const strategies = this.fallbacks.get(toolName) || this._defaultStrategies(toolName);
+    let lastError;
+
+    for (let depth = 0; depth < strategies.length && depth < this.maxFallbackDepth; depth++) {
+      try {
+        const strategy = strategies[depth];
+        const adaptedInput = strategy.adapt ? strategy.adapt(input) : input;
+        const result = await executor(adaptedInput, { fallbackDepth: depth });
+
+        if (result && !result.error) {
+          return {
+            ...result,
+            fallbackDepth: depth,
+            strategyUsed: strategy.name || 'primary',
+          };
+        }
+
+        lastError = result?.error || new Error('Unknown error');
+        this.logger.warn(`[Fallback] ${toolName}: strategy "${strategy.name}" failed, trying next...`);
+      } catch (error) {
+        lastError = error;
+        this.logger.warn(`[Fallback] ${toolName}: strategy threw "${error.message}", trying next...`);
+      }
+    }
+
+    return {
+      error: lastError?.message || `All ${strategies.length} fallbacks exhausted for ${toolName}`,
+      fallbackDepth: this.maxFallbackDepth,
+      strategiesTried: strategies.length,
+    };
+  }
+
+  /**
+   * Default fallback strategies for any tool.
+   */
+  _defaultStrategies(toolName) {
+    return [
+      { name: 'original', adapt: (input) => input },
+      { name: 'simplified', adapt: (input) => this._simplify(input) },
+      { name: 'minimal', adapt: (input) => this._minimize(input) },
+    ];
+  }
+
+  _simplify(input) {
+    if (typeof input === 'object' && input !== null) {
+      const simplified = { ...input };
+      delete simplified.options;
+      delete simplified.verbose;
+      if (simplified.timeout && simplified.timeout > 30000) {
+        simplified.timeout = 30000;
+      }
+      return simplified;
+    }
+    return input;
+  }
+
+  _minimize(input) {
+    if (typeof input === 'object' && input !== null) {
+      const minimized = {};
+      if (input.command) minimized.command = input.command;
+      if (input.path) minimized.path = input.path;
+      if (input.pattern) minimized.pattern = input.pattern;
+      return minimized;
+    }
+    return String(input).substring(0, 200);
+  }
+}
+
+// Pre-configured fallback strategies for common tools
+const BASH_FALLBACK_STRATEGIES = [
+  { name: 'original', adapt: (i) => i },
+  { name: 'with-timeout', adapt: (i) => ({ ...i, timeout: (i.timeout || 30000) }) },
+  { name: 'simplified-cmd', adapt: (i) => ({ ...i, command: String(i.command).substring(0, 500) }) },
+];
+
+const EDIT_FALLBACK_STRATEGIES = [
+  { name: 'original', adapt: (i) => i },
+  { name: 'single-replacement', adapt: (i) => {
+    if (Array.isArray(i.replacements)) {
+      return { ...i, replacements: i.replacements.slice(0, 1) };
+    }
+    return i;
+  }},
+  { name: 'write-full', adapt: (i) => ({
+    path: i.path,
+    content: i.newString || i.content || '',
+    ...(i.instructions ? { instructions: i.instructions } : {}),
+  })},
+];
+
+export function createDefaultFallbackManager() {
+  const manager = new FallbackManager();
+  manager.register('Bash', BASH_FALLBACK_STRATEGIES);
+  manager.register('Edit', EDIT_FALLBACK_STRATEGIES);
+  manager.register('Write', EDIT_FALLBACK_STRATEGIES);
+  return manager;
+}
+
+export default FallbackManager;

package/src/tools/insert-text.js

@@ -0,0 +1,93 @@
+/**
+ * ❄️ INSERT TEXT TOOL ❄️
+ * Insert text at a specific line or position in a file
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { diffLines } from 'diff';
+
+export class InsertTextTool {
+  async insert(filePath, insertData, options = {}) {
+    if (!filePath) {
+      return { success: false, error: 'file_path is required' };
+    }
+    if (!insertData || typeof insertData !== 'string') {
+      return { success: false, error: 'insert_text is required' };
+    }
+
+    try {
+      const resolved = path.resolve(filePath);
+      const content = await fs.readFile(resolved, 'utf8');
+      const lines = content.split('\n');
+      const insertLines = insertData.split('\n');
+      let newContent;
+
+      // Support different insertion modes
+      const mode = options.mode || 'line';
+      const position = (options.position !== undefined) ? options.position : (options.line !== undefined ? options.line : options.at);
+
+      if (mode === 'line' && position !== undefined) {
+        // Insert at specific line number (0-based, or 1-based if specified)
+        const isOneBased = options.lineBased !== false;
+        const lineIndex = isOneBased ? Math.max(0, parseInt(position, 10) - 1) : parseInt(position, 10);
+
+        if (lineIndex < 0 || lineIndex > lines.length) {
+          return {
+            success: false,
+            error: `Line position out of range: ${position}. File has ${lines.length} lines (${isOneBased ? '1-based' : '0-based'})`,
+          };
+        }
+
+        lines.splice(lineIndex, 0, ...insertLines);
+        newContent = lines.join('\n');
+      } else if (mode === 'after' && position !== undefined) {
+        // Insert after the first line containing the search text
+        const searchIndex = lines.findIndex(l => l.includes(position));
+        if (searchIndex === -1) {
+          return { success: false, error: `Search text not found in file: "${position}"` };
+        }
+        lines.splice(searchIndex + 1, 0, ...insertLines);
+        newContent = lines.join('\n');
+      } else if (mode === 'before' && position !== undefined) {
+        // Insert before the first line containing the search text
+        const searchIndex = lines.findIndex(l => l.includes(position));
+        if (searchIndex === -1) {
+          return { success: false, error: `Search text not found in file: "${position}"` };
+        }
+        lines.splice(searchIndex, 0, ...insertLines);
+        newContent = lines.join('\n');
+      } else if (mode === 'end' || position === 'end') {
+        // Append to end of file
+        const trailingNewline = content.endsWith('\n') ? '' : '\n';
+        newContent = content + trailingNewline + insertData;
+      } else if (mode === 'beginning' || position === 'beginning') {
+        // Insert at beginning of file
+        newContent = insertData + '\n' + content;
+      } else {
+        return {
+          success: false,
+          error: 'Invalid insertion mode or position. Use mode: "line" (with line number), "after"/"before" (with search text), "end", or "beginning".',
+        };
+      }
+
+      await fs.writeFile(resolved, newContent, 'utf8');
+
+      const diffOutput = diffLines(content, newContent)
+        .filter(part => part.added)
+        .map(part => part.value.split('\n').filter(l => l.trim()).join('\n'))
+        .filter(Boolean)
+        .join('\n');
+
+      return {
+        success: true,
+        path: resolved,
+        mode,
+        linesInserted: insertLines.length,
+        diff: diffOutput,
+      };
+    } catch (error) {
+      return { success: false, error: error.message, path: filePath };
+    }
+  }
+}

package/src/tools/interactive.js

@@ -0,0 +1,122 @@
+/**
+ * ❄️ INTERACTIVE TOOL ❄️
+ * Ask user questions with multi-select, single-select, and text input support.
+ * Pauses execution and waits for user input.
+ */
+
+import { createInterface } from 'readline';
+
+export class InteractiveTool {
+  constructor(repl) {
+    this.repl = repl;
+  }
+
+  async askQuestion(questions) {
+    if (!questions || (Array.isArray(questions) && questions.length === 0)) {
+      return { success: false, error: 'At least one question is required' };
+    }
+
+    const qList = Array.isArray(questions) ? questions : [questions];
+    const answers = {};
+
+    for (const q of qList) {
+      if (!q.question && !q.message && !q.prompt) {
+        answers[q.id || `q_${qList.indexOf(q)}`] = { error: 'Question text is required' };
+        continue;
+      }
+
+      const questionText = q.question || q.message || q.prompt || '';
+      const type = q.type || (q.options ? 'select' : 'text');
+      const qId = q.id || `q_${qList.indexOf(q)}`;
+
+      if (type === 'select' || type === 'multi-select') {
+        const selected = await this.promptSelect(questionText, q.options || [], type === 'multi-select');
+        answers[qId] = {
+          question: questionText,
+          answer: selected,
+          type,
+        };
+      } else {
+        const text = await this.promptText(questionText, q.default || '', q.validation || {});
+        answers[qId] = {
+          question: questionText,
+          answer: text,
+          type: 'text',
+        };
+      }
+    }
+
+    return {
+      success: true,
+      answers,
+      count: Object.keys(answers).length,
+    };
+  }
+
+  promptSelect(question, options, multiSelect) {
+    return new Promise((resolve) => {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+      // Write question
+      console.log(`\n${multiSelect ? '[Select all that apply]' : '[Select one]'} ${question}`);
+      options.forEach((opt, i) => {
+        const label = typeof opt === 'string' ? opt : (opt.label || opt.name || `Option ${i + 1}`);
+        console.log(`  ${i + 1}. ${label}`);
+      });
+      console.log('  (Enter number, or comma-separated numbers for multi-select)');
+
+      rl.question('> ', (input) => {
+        rl.close();
+        const trimmed = input.trim();
+
+        if (!trimmed) {
+          resolve(multiSelect ? [] : null);
+          return;
+        }
+
+        const indices = trimmed.split(/[,\s]+/).map(s => parseInt(s, 10) - 1).filter(n => !isNaN(n) && n >= 0 && n < options.length);
+
+        if (multiSelect) {
+          resolve(indices.map(i => {
+            const opt = options[i];
+            return typeof opt === 'string' ? opt : (opt.value || opt.label || opt.name || String(opt));
+          }));
+        } else {
+          const idx = indices[0];
+          if (idx === undefined) resolve(null);
+          const opt = options[idx];
+          resolve(typeof opt === 'string' ? opt : (opt.value || opt.label || opt.name || String(opt)));
+        }
+      });
+    });
+  }
+
+  promptText(question, defaultValue, validation) {
+    return new Promise((resolve) => {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const prompt = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
+
+      rl.question(prompt, (input) => {
+        rl.close();
+        const answer = input.trim() || defaultValue || '';
+
+        if (validation?.required && !answer) {
+          console.log('This field is required. Please provide an answer.');
+          resolve(this.promptText(question, defaultValue, validation));
+          return;
+        }
+
+        if (validation?.pattern && answer) {
+          const regex = new RegExp(validation.pattern);
+          if (!regex.test(answer)) {
+            console.log(validation.patternError || 'Invalid format. Please try again.');
+            resolve(this.promptText(question, defaultValue, validation));
+            return;
+          }
+        }
+
+        resolve(answer);
+      });
+    });
+  }
+}

package/src/tools/notebook.js

@@ -0,0 +1,136 @@
+/**
+ * ❄️ NOTEBOOK TOOL ❄️
+ * Jupyter notebook read/edit support (.ipynb files)
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+
+export class NotebookTool {
+  async read(notebookPath) {
+    try {
+      const raw = await fs.readFile(notebookPath, 'utf8');
+      const nb = JSON.parse(raw);
+      const cells = (nb.cells || []).map((cell, index) => ({
+        id: `cell-${index}`,
+        type: cell.cell_type || 'code',
+        source: Array.isArray(cell.source) ? cell.source.join('') : (cell.source || ''),
+        outputs: (cell.outputs || []).map(o => ({
+          output_type: o.output_type,
+          text: o.text ? (Array.isArray(o.text) ? o.text.join('') : o.text) : '',
+          name: o.name,
+          data: o.data,
+        })),
+        execution_count: cell.execution_count || null,
+        metadata: cell.metadata || {},
+      }));
+
+      return {
+        success: true,
+        path: notebookPath,
+        cells,
+        metadata: nb.metadata || {},
+        nbformat: nb.nbformat || 4,
+        nbformat_minor: nb.nbformat_minor || 0,
+        cellCount: cells.length,
+      };
+    } catch (error) {
+      return { success: false, error: error.message, path: notebookPath };
+    }
+  }
+
+  async edit(notebookPath, cellId, newSource) {
+    try {
+      const raw = await fs.readFile(notebookPath, 'utf8');
+      const nb = JSON.parse(raw);
+
+      if (!nb.cells || !Array.isArray(nb.cells)) {
+        return { success: false, error: 'Invalid notebook: no cells array' };
+      }
+
+      const index = parseInt((cellId || '').replace('cell-', ''), 10);
+      if (isNaN(index) || index < 0 || index >= nb.cells.length) {
+        return { success: false, error: `Cell not found: ${cellId}`, validCells: nb.cells.map((_, i) => `cell-${i}`) };
+      }
+
+      const oldSource = (Array.isArray(nb.cells[index].source) ? nb.cells[index].source.join('') : nb.cells[index].source) || '';
+      nb.cells[index].source = Array.isArray(nb.cells[index].source)
+        ? newSource.split('\n')
+        : newSource;
+
+      await fs.writeFile(notebookPath, JSON.stringify(nb, null, 2), 'utf8');
+
+      return {
+        success: true,
+        path: notebookPath,
+        cellId,
+        oldSource,
+        newSource,
+        changes: oldSource !== newSource ? 1 : 0,
+      };
+    } catch (error) {
+      return { success: false, error: error.message, path: notebookPath, cellId };
+    }
+  }
+
+  async execute(notebookPath, cellId) {
+    try {
+      const raw = await fs.readFile(notebookPath, 'utf8');
+      const nb = JSON.parse(raw);
+
+      if (!nb.cells || !Array.isArray(nb.cells)) {
+        return { success: false, error: 'Invalid notebook: no cells array' };
+      }
+
+      const index = parseInt((cellId || '').replace('cell-', ''), 10);
+      if (isNaN(index) || index < 0 || index >= nb.cells.length) {
+        return { success: false, error: `Cell not found: ${cellId}` };
+      }
+
+      const cell = nb.cells[index];
+      if (!cell.outputs) cell.outputs = [];
+
+      return {
+        success: true,
+        path: notebookPath,
+        cellId,
+        cellType: cell.cell_type,
+        source: Array.isArray(cell.source) ? cell.source.join('') : cell.source,
+        outputs: cell.outputs.map(o => ({
+          output_type: o.output_type,
+          text: o.text ? (Array.isArray(o.text) ? o.text.join('') : o.text) : '',
+          name: o.name,
+        })),
+        execution_count: cell.execution_count,
+        note: 'Notebook execution is a simulation. For real execution, use Python kernel.',
+      };
+    } catch (error) {
+      return { success: false, error: error.message, path: notebookPath, cellId };
+    }
+  }
+
+  async listCells(notebookPath) {
+    try {
+      const raw = await fs.readFile(notebookPath, 'utf8');
+      const nb = JSON.parse(raw);
+      const cells = (nb.cells || []).map((cell, index) => ({
+        id: `cell-${index}`,
+        type: cell.cell_type || 'code',
+        summary: (Array.isArray(cell.source) ? cell.source.join('') : (cell.source || '')).split('\n')[0]?.slice(0, 80) || '',
+        execution_count: cell.execution_count || null,
+        hasOutputs: (cell.outputs || []).length > 0,
+      }));
+
+      return {
+        success: true,
+        path: notebookPath,
+        cells,
+        cellCount: cells.length,
+        kernel: nb.metadata?.kernelspec?.display_name || nb.metadata?.kernel_info?.name || 'unknown',
+        language: nb.metadata?.language_info?.name || 'python',
+      };
+    } catch (error) {
+      return { success: false, error: error.message, path: notebookPath };
+    }
+  }
+}

package/src/tools/optimizer.js

@@ -0,0 +1,141 @@
+/**
+ * Tool Optimizer - Analyzes tool usage patterns and suggests improvements.
+ * Uses analytics data to optimize tool selection, timing, and strategies.
+ */
+
+export class ToolOptimizer {
+  constructor(analytics) {
+    this.analytics = analytics;
+    this.optimizations = new Map();
+    this.thresholds = {
+      highFailureRate: 0.3,       // >30% failure = problematic
+      slowExecutionMs: 5000,       // >5s = slow
+      lowUsageCount: 3,            // <3 uses = insufficient data
+    };
+  }
+
+  /**
+   * Analyze tool usage and generate optimization suggestions.
+   */
+  analyze() {
+    const summary = typeof this.analytics.summary === 'function'
+      ? this.analytics.summary()
+      : this.analytics;
+
+    if (!Array.isArray(summary)) return { suggestions: [] };
+
+    const suggestions = [];
+
+    for (const tool of summary) {
+      const name = tool.name || tool.tool;
+      const calls = tool.calls || 0;
+      const failures = tool.failures || 0;
+      const avgMs = tool.avgMs || tool.totalMs / calls || 0;
+
+      if (calls < this.thresholds.lowUsageCount) continue;
+
+      // Check for high failure rate
+      const failureRate = calls > 0 ? failures / calls : 0;
+      if (failureRate > this.thresholds.highFailureRate) {
+        suggestions.push({
+          tool: name,
+          type: 'high-failure',
+          severity: 'warning',
+          message: `${name} has ${(failureRate * 100).toFixed(0)}% failure rate (${failures}/${calls})`,
+          suggestion: 'Consider using fallback strategies or simplifying inputs',
+          metrics: { calls, failures, failureRate },
+        });
+      }
+
+      // Check for slow execution
+      if (avgMs > this.thresholds.slowExecutionMs) {
+        suggestions.push({
+          tool: name,
+          type: 'slow-execution',
+          severity: 'info',
+          message: `${name} averages ${(avgMs / 1000).toFixed(1)}s per call`,
+          suggestion: 'Reduce input size or use faster alternatives',
+          metrics: { calls, avgMs },
+        });
+      }
+    }
+
+    // Cross-tool optimization suggestions
+    if (summary.length >= 2) {
+      const mostCalled = [...summary].sort((a, b) => (b.calls || 0) - (a.calls || 0));
+      if (mostCalled.length > 0 && mostCalled[0].calls > 10) {
+        suggestions.push({
+          tool: mostCalled[0].name || mostCalled[0].tool,
+          type: 'high-usage',
+          severity: 'info',
+          message: `Most used: ${mostCalled[0].name || mostCalled[0].tool} (${mostCalled[0].calls} calls)`,
+          suggestion: 'Consider caching results for repeated calls',
+          metrics: { calls: mostCalled[0].calls },
+        });
+      }
+    }
+
+    return { suggestions, totalTools: summary.length, generatedAt: Date.now() };
+  }
+
+  /**
+   * Get optimization hint for a specific tool.
+   */
+  getHint(toolName) {
+    const analysis = this.analyze();
+    return analysis.suggestions.filter(s => s.tool === toolName);
+  }
+
+  /**
+   * Apply automatic optimization - adjust tool configuration based on patterns.
+   */
+  autoOptimize(executor) {
+    const analysis = this.analyze();
+    const adjustments = [];
+
+    for (const suggestion of analysis.suggestions) {
+      if (suggestion.type === 'high-failure' && suggestion.severity === 'warning') {
+        adjustments.push({
+          tool: suggestion.tool,
+          action: 'add-fallback',
+          reason: suggestion.message,
+        });
+      }
+      if (suggestion.type === 'slow-execution') {
+        adjustments.push({
+          tool: suggestion.tool,
+          action: 'reduce-timeout',
+          reason: suggestion.message,
+        });
+      }
+    }
+
+    return adjustments;
+  }
+
+  /**
+   * Track a successful optimization.
+   */
+  trackOptimization(optimization, result) {
+    const key = `${optimization.tool}:${optimization.action}`;
+    if (!this.optimizations.has(key)) {
+      this.optimizations.set(key, { count: 0, results: [] });
+    }
+    const entry = this.optimizations.get(key);
+    entry.count++;
+    entry.results.push({ result, timestamp: Date.now() });
+  }
+
+  /**
+   * Get optimization history.
+   */
+  getHistory() {
+    const history = [];
+    for (const [key, entry] of this.optimizations) {
+      history.push({ key, count: entry.count, lastResult: entry.results[entry.results.length - 1] });
+    }
+    return history;
+  }
+}
+
+export default ToolOptimizer;