winter-super-cli 2026.5.26 → 2026.5.28

package/src/tools/parallel.js

@@ -0,0 +1,159 @@
+/**
+ * Parallel Execution - Run multiple independent tools concurrently.
+ * Includes dependency tracking, merging, and error isolation.
+ */
+
+export class ParallelExecutor {
+  constructor(options = {}) {
+    this.maxConcurrent = options.maxConcurrent || 5;
+    this.timeout = options.timeout || 30000;
+  }
+
+  /**
+   * Execute multiple tools in parallel.
+   */
+  async execute(tools, executor, context = {}) {
+    if (!Array.isArray(tools) || tools.length === 0) {
+      return { results: [], errors: [] };
+    }
+
+    const batches = this._batch(tools, this.maxConcurrent);
+    const allResults = [];
+
+    for (const batch of batches) {
+      const batchResults = await Promise.allSettled(
+        batch.map(async (toolCall) => {
+          const toolName = toolCall.name || toolCall.tool;
+          const input = toolCall.input || toolCall.args || toolCall;
+
+          if (typeof executor === 'function') {
+            return await executor(toolName, input, context);
+          }
+          if (executor.execute) {
+            return await executor.execute(toolName, input, context);
+          }
+          throw new Error(`Invalid executor: ${typeof executor}`);
+        })
+      );
+
+      for (let i = 0; i < batch.length; i++) {
+        const result = batchResults[i];
+        const toolName = batch[i].name || batch[i].tool || 'unknown';
+        if (result.status === 'fulfilled') {
+          allResults.push({ tool: toolName, status: 'success', result: result.value });
+        } else {
+          allResults.push({ tool: toolName, status: 'error', error: result.reason?.message || String(result.reason) });
+        }
+      }
+    }
+
+    const successful = allResults.filter(r => r.status === 'success');
+    const errors = allResults.filter(r => r.status === 'error');
+
+    return {
+      results: successful,
+      errors,
+      total: allResults.length,
+      successCount: successful.length,
+      errorCount: errors.length,
+    };
+  }
+
+  /**
+   * Execute tools with dependency graph.
+   */
+  async executeWithDeps(tools, executor, context = {}) {
+    const dag = this._buildDAG(tools);
+    const results = new Map();
+    const errors = [];
+
+    while (dag.remaining.size > 0) {
+      // Find tools with all dependencies satisfied
+      const ready = [];
+      for (const [name, node] of dag.remaining) {
+        const depsMet = node.dependsOn.every(d => results.has(d));
+        if (depsMet) ready.push(node);
+      }
+
+      if (ready.length === 0) {
+        // Circular dependency or unresolvable
+        for (const [name] of dag.remaining) {
+          errors.push({ tool: name, error: 'Unresolved dependencies - possible circular dependency' });
+        }
+        break;
+      }
+
+      // Execute ready tools in parallel
+      const batchResults = await this.execute(
+        ready.map(r => ({ name: r.name, input: r.input })),
+        executor,
+        context
+      );
+
+      for (const result of batchResults.results) {
+        results.set(result.tool.replace(/^error:\s*/, ''), result);
+        dag.remaining.delete(result.tool.replace(/^error:\s*/, ''));
+      }
+      for (const err of batchResults.errors) {
+        errors.push(err);
+        dag.remaining.delete(err.tool);
+      }
+    }
+
+    return {
+      results: [...results.values()],
+      errors,
+      total: tools.length,
+    };
+  }
+
+  /**
+   * Merge results from multiple tools into a single coherent response.
+   */
+  mergeResults(results) {
+    const merged = {};
+
+    for (const result of results) {
+      if (result.status !== 'success') continue;
+      const data = result.result?.data || result.result || {};
+      const tool = result.tool;
+
+      if (typeof data === 'object' && !Array.isArray(data)) {
+        Object.assign(merged, { [`${tool}_result`]: data });
+      } else {
+        merged[`${tool}_result`] = data;
+      }
+    }
+
+    return merged;
+  }
+
+  /**
+   * Batch tools into groups for controlled parallelism.
+   */
+  _batch(tools, size) {
+    const batches = [];
+    for (let i = 0; i < tools.length; i += size) {
+      batches.push(tools.slice(i, i + size));
+    }
+    return batches;
+  }
+
+  /**
+   * Build a dependency graph from tools array.
+   */
+  _buildDAG(tools) {
+    const remaining = new Map();
+    for (const tool of tools) {
+      const name = tool.name || tool.tool || 'unknown';
+      remaining.set(name, {
+        name,
+        input: tool.input || tool.args || tool,
+        dependsOn: tool.dependsOn || [],
+      });
+    }
+    return { remaining };
+  }
+}
+
+export default ParallelExecutor;

package/src/tools/permission.js

@@ -0,0 +1,86 @@
+const DEFAULT_ALLOWED = new Set(['Read', 'Glob', 'Grep', 'LSP', 'TaskCreate', 'TaskUpdate', 'TaskList', 'WebFetch', 'WebSearch', 'Parallel']);
+const SENSITIVE_TOOLS = new Set(['Bash', 'Write', 'Edit', 'MCP']);
+
+export class PermissionManager {
+  constructor(config, session = null) {
+    this.config = config;
+    this.session = session;
+    this.lastSavedConfig = null;
+  }
+
+  async getPolicy() {
+    const cfg = this.config?.load ? await this.config.load() : {};
+    const permissions = cfg.permissions || {};
+    const allowlist = permissions.allowlist || {};
+
+    return {
+      promptByDefault: permissions.promptByDefault !== false,
+      allowedTools: new Set([...(allowlist.tools || []), ...DEFAULT_ALLOWED]),
+      allowedCommands: new Set(allowlist.commands || []),
+      allowedServers: new Set(allowlist.mcpServers || []),
+    };
+  }
+
+  async isAllowedTool(toolName) {
+    const policy = await this.getPolicy();
+    return policy.allowedTools.has(toolName);
+  }
+
+  async shouldPromptForTool(toolName) {
+    const policy = await this.getPolicy();
+    if (!policy.promptByDefault) return false;
+    if (policy.allowedTools.has(toolName)) return false;
+    return SENSITIVE_TOOLS.has(toolName);
+  }
+
+  async shouldPromptForToolPermission(toolName) {
+    return await this.shouldPromptForTool(toolName);
+  }
+
+  async isMcpServerAllowed(serverName) {
+    if (!serverName) return false;
+    const policy = await this.getPolicy();
+    return policy.allowedServers.has(serverName);
+  }
+
+  async allowTool(toolName) {
+    if (!this.config?.load || !this.config?.save) return;
+    const cfg = this.mergeWithLastSavedConfig(await this.config.load());
+    cfg.permissions = cfg.permissions || { allowlist: {} };
+    cfg.permissions.allowlist = cfg.permissions.allowlist || {};
+    const tools = new Set([...(cfg.permissions.allowlist.tools || []), toolName]);
+    cfg.permissions.allowlist.tools = [...tools];
+    await this.config.save(cfg);
+    this.lastSavedConfig = cfg;
+  }
+
+  async allowMcpServer(serverName) {
+    if (!this.config?.load || !this.config?.save) return;
+    const cfg = this.mergeWithLastSavedConfig(await this.config.load());
+    cfg.permissions = cfg.permissions || { allowlist: {} };
+    cfg.permissions.allowlist = cfg.permissions.allowlist || {};
+    const servers = new Set([...(cfg.permissions.allowlist.mcpServers || []), serverName]);
+    cfg.permissions.allowlist.mcpServers = [...servers];
+    await this.config.save(cfg);
+    this.lastSavedConfig = cfg;
+  }
+
+  mergeWithLastSavedConfig(cfg = {}) {
+    if (!this.lastSavedConfig?.permissions?.allowlist) return cfg;
+
+    const current = cfg.permissions?.allowlist || {};
+    const previous = this.lastSavedConfig.permissions.allowlist;
+
+    return {
+      ...cfg,
+      permissions: {
+        ...(cfg.permissions || {}),
+        allowlist: {
+          tools: [...new Set([...(previous.tools || []), ...(current.tools || [])])],
+          commands: [...new Set([...(previous.commands || []), ...(current.commands || [])])],
+          mcpServers: [...new Set([...(previous.mcpServers || []), ...(current.mcpServers || [])])],
+        },
+      },
+    };
+  }
+}

package/src/tools/retry.js

@@ -0,0 +1,88 @@
+export function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Calculate delay with optional jitter to avoid thundering herd.
+ */
+function calculateDelay(baseDelayMs, attempt, strategy, enableJitter) {
+  let delay;
+
+  switch (strategy) {
+    case 'linear':
+      delay = baseDelayMs * (attempt + 1);
+      break;
+    case 'fibonacci': {
+      let a = 0, b = 1;
+      for (let i = 0; i < attempt; i++) {
+        [a, b] = [b, a + b];
+      }
+      delay = baseDelayMs * Math.max(b, 1);
+      break;
+    }
+    case 'exponential':
+    default:
+      delay = baseDelayMs * (2 ** attempt);
+      break;
+  }
+
+  if (enableJitter && delay > 0) {
+    // Add ±25% jitter
+    const jitter = delay * 0.25 * (Math.random() * 2 - 1);
+    delay = Math.round(delay + jitter);
+  }
+
+  return Math.max(0, delay);
+}
+
+/**
+ * Default error classifier: returns true for retryable errors.
+ * Retry on: network errors, rate limits (429), server errors (5xx).
+ * Do NOT retry on: bad requests (400), auth errors (401/403), not found (404).
+ */
+function isRetryableError(error) {
+  if (!error) return true;
+  const status = error.status || error.statusCode || (error.response && error.response.status);
+  if (status) {
+    if (status === 429 || status === 503) return true;
+    if (status >= 500 && status < 600) return true;
+    if (status === 408) return true;
+    if (status === 400 || status === 401 || status === 403 || status === 404) return false;
+    return false;
+  }
+  const msg = (error.message || '').toLowerCase();
+  if (msg.includes('econnrefused') || msg.includes('enetunreach') ||
+      msg.includes('timeout') || msg.includes('econnreset') ||
+      msg.includes('etimedout') || msg.includes('socket')) {
+    return true;
+  }
+  return true;
+}
+
+export async function withRetry(task, options = {}) {
+  const maxAttempts = Math.max(1, Number(options.maxAttempts ?? 3));
+  const baseDelayMs = Math.max(0, Number(options.baseDelayMs ?? 100));
+  const strategy = options.strategy || 'exponential';
+  const enableJitter = options.jitter !== false;
+  const retryable = typeof options.retryable === 'function'
+    ? options.retryable
+    : isRetryableError;
+
+  let lastError = null;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await task(attempt);
+    } catch (error) {
+      lastError = error;
+      if (attempt >= maxAttempts - 1 || !retryable(error)) {
+        throw error;
+      }
+      const delay = calculateDelay(baseDelayMs, attempt, strategy, enableJitter);
+      if (delay > 0) {
+        await sleep(delay);
+      }
+    }
+  }
+
+  throw lastError || new Error('Retry failed');
+}

package/src/tools/scheduler.js

@@ -0,0 +1,160 @@
+/**
+ * ❄️ SCHEDULER TOOL ❄️
+ * Schedule wakeup reminders and recurring tasks
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+
+export class SchedulerTool {
+  constructor(schedulerDir) {
+    this.schedulerDir = schedulerDir || path.join(process.cwd(), '.winter');
+    this.scheduleFile = path.join(this.schedulerDir, 'schedule.json');
+    this.timers = new Map();
+  }
+
+  async load() {
+    try {
+      await fs.mkdir(this.schedulerDir, { recursive: true });
+      const raw = await fs.readFile(this.scheduleFile, 'utf8');
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+
+  async save(schedules) {
+    await fs.mkdir(this.schedulerDir, { recursive: true });
+    await fs.writeFile(this.scheduleFile, JSON.stringify(schedules, null, 2), 'utf8');
+  }
+
+  nextId(schedules) {
+    const maxId = schedules.reduce((max, s) => Math.max(max, parseInt(s.id, 10) || 0), 0);
+    return String(maxId + 1);
+  }
+
+  parseDelay(delay) {
+    if (typeof delay === 'number') return Math.max(1000, delay);
+    if (typeof delay === 'string') {
+      const match = delay.match(/^(\d+)\s*(ms|s|m|h|d)?$/);
+      if (!match) return null;
+      const num = parseInt(match[1], 10);
+      const unit = match[2] || 'ms';
+      const multipliers = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
+      return num * (multipliers[unit] || 1);
+    }
+    return null;
+  }
+
+  async schedule(delay, prompt, recurring = false) {
+    const delayMs = this.parseDelay(delay);
+    if (!delayMs || delayMs < 1000) {
+      return { success: false, error: 'delay must be at least 1000ms. Use format: "30s", "5m", "1h", "2d", or milliseconds.' };
+    }
+    if (!prompt || typeof prompt !== 'string' || prompt.trim() === '') {
+      return { success: false, error: 'prompt is required' };
+    }
+
+    const schedules = await this.load();
+    const scheduled = {
+      id: this.nextId(schedules),
+      prompt: prompt.trim(),
+      delay: delayMs,
+      recurring: Boolean(recurring),
+      scheduledAt: new Date().toISOString(),
+      triggerAt: new Date(Date.now() + delayMs).toISOString(),
+      status: 'scheduled',
+    };
+
+    schedules.push(scheduled);
+    await this.save(schedules);
+
+    this.startTimer(scheduled);
+
+    return {
+      success: true,
+      schedule: scheduled,
+      willTriggerAt: scheduled.triggerAt,
+    };
+  }
+
+  startTimer(scheduled) {
+    const delay = new Date(scheduled.triggerAt).getTime() - Date.now();
+    if (delay <= 0) return;
+
+    const timerId = setTimeout(async () => {
+      if (scheduled.recurring) {
+        const newDelay = scheduled.delay;
+        const newTrigger = new Date(Date.now() + newDelay).toISOString();
+
+        const all = await this.load();
+        const found = all.find(s => s.id === scheduled.id);
+        if (found) {
+          found.status = 'triggered';
+          found.triggeredAt = new Date().toISOString();
+          await this.save(all);
+        }
+
+        // Re-schedule
+        await this.schedule(newDelay, scheduled.prompt, true);
+      } else {
+        const all = await this.load();
+        const found = all.find(s => s.id === scheduled.id);
+        if (found) {
+          found.status = 'triggered';
+          found.triggeredAt = new Date().toISOString();
+          await this.save(all);
+        }
+      }
+
+      this.timers.delete(scheduled.id);
+    }, delay);
+
+    this.timers.set(scheduled.id, timerId);
+    this.timers.set(`timeout_${scheduled.id}`, timerId);
+  }
+
+  async list() {
+    const schedules = await this.load();
+    return {
+      success: true,
+      schedules,
+      count: schedules.length,
+      activeTimers: this.timers.size,
+    };
+  }
+
+  async delete(id) {
+    const schedules = await this.load();
+    const index = schedules.findIndex(s => s.id === String(id));
+    if (index === -1) {
+      return { success: false, error: `Schedule not found: ${id}` };
+    }
+
+    const removed = schedules.splice(index, 1)[0];
+    const timerId = this.timers.get(removed.id);
+    if (timerId) {
+      clearTimeout(timerId);
+      this.timers.delete(removed.id);
+    }
+
+    await this.save(schedules);
+    return { success: true, schedule: removed };
+  }
+
+  async clearAll() {
+    for (const [id, timerId] of this.timers) {
+      clearTimeout(timerId);
+    }
+    this.timers.clear();
+    await this.save([]);
+    return { success: true, message: 'All schedules cleared' };
+  }
+
+  destroy() {
+    for (const timerId of this.timers.values()) {
+      clearTimeout(timerId);
+    }
+    this.timers.clear();
+  }
+}

package/src/tools/str-replace-all.js

@@ -0,0 +1,61 @@
+/**
+ * ❄️ STRING REPLACE ALL TOOL ❄️
+ * Batch replace all occurrences of a string in a file
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { diffLines } from 'diff';
+
+export class StrReplaceAllTool {
+  async replaceAll(filePath, oldString, newString) {
+    if (!filePath) {
+      return { success: false, error: 'file_path is required' };
+    }
+    if (typeof oldString !== 'string' || oldString === '') {
+      return { success: false, error: 'old_string is required' };
+    }
+    if (typeof newString !== 'string') {
+      return { success: false, error: 'new_string is required' };
+    }
+
+    try {
+      const resolved = path.resolve(filePath);
+      const content = await fs.readFile(resolved, 'utf8');
+
+      let count = 0;
+      let newContent = content;
+      let pos = -1;
+
+      // Count occurrences and replace all
+      while ((pos = newContent.indexOf(oldString, pos + 1)) !== -1) {
+        count++;
+      }
+      if (count === 0) {
+        return { success: false, error: `old_string not found in file: "${oldString.slice(0, 100)}"`, path: resolved };
+      }
+
+      newContent = content.split(oldString).join(newString);
+
+      await fs.writeFile(resolved, newContent, 'utf8');
+
+      const diffOutput = diffLines(content, newContent)
+        .filter(part => part.added || part.removed)
+        .map(part => {
+          const prefix = part.added ? '+ ' : '- ';
+          return part.value.split('\n').filter(l => l.trim()).map(l => `${prefix}${l}`).join('\n');
+        })
+        .filter(Boolean)
+        .join('\n');
+
+      return {
+        success: true,
+        path: resolved,
+        replacements: count,
+        diff: diffOutput,
+      };
+    } catch (error) {
+      return { success: false, error: error.message, path: filePath };
+    }
+  }
+}

package/src/tools/todo.js

@@ -0,0 +1,98 @@
+/**
+ * ❄️ TODO TOOL ❄️
+ * Persistent todo list management
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+
+export class TodoTool {
+  constructor(todoDir) {
+    this.todoDir = todoDir || path.join(process.cwd(), '.winter');
+    this.todoFile = path.join(this.todoDir, 'todos.json');
+  }
+
+  async load() {
+    try {
+      await fs.mkdir(this.todoDir, { recursive: true });
+      const raw = await fs.readFile(this.todoFile, 'utf8');
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+
+  async save(todos) {
+    await fs.mkdir(this.todoDir, { recursive: true });
+    await fs.writeFile(this.todoFile, JSON.stringify(todos, null, 2), 'utf8');
+  }
+
+  nextId(todos) {
+    const maxId = todos.reduce((max, t) => Math.max(max, parseInt(t.id, 10) || 0), 0);
+    return String(maxId + 1);
+  }
+
+  async write(title, status = 'pending', priority = 'medium') {
+    const todos = await this.load();
+    const todo = {
+      id: this.nextId(todos),
+      title: String(title || '').trim(),
+      status: ['pending', 'in_progress', 'completed', 'cancelled'].includes(status) ? status : 'pending',
+      priority: ['low', 'medium', 'high', 'critical'].includes(priority) ? priority : 'medium',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+
+    if (!todo.title) {
+      return { success: false, error: 'title is required' };
+    }
+
+    todos.push(todo);
+    await this.save(todos);
+    return { success: true, todo };
+  }
+
+  async list(filterStatus) {
+    let todos = await this.load();
+    if (filterStatus) {
+      todos = todos.filter(t => t.status === filterStatus);
+    }
+    return {
+      success: true,
+      todos,
+      count: todos.length,
+    };
+  }
+
+  async update(id, changes = {}) {
+    const todos = await this.load();
+    const todo = todos.find(t => t.id === String(id));
+    if (!todo) {
+      return { success: false, error: `Todo not found: ${id}`, validIds: todos.map(t => t.id) };
+    }
+
+    if (changes.title !== undefined) todo.title = String(changes.title).trim();
+    if (changes.status !== undefined && ['pending', 'in_progress', 'completed', 'cancelled'].includes(changes.status)) {
+      todo.status = changes.status;
+    }
+    if (changes.priority !== undefined && ['low', 'medium', 'high', 'critical'].includes(changes.priority)) {
+      todo.priority = changes.priority;
+    }
+
+    todo.updatedAt = new Date().toISOString();
+    await this.save(todos);
+    return { success: true, todo };
+  }
+
+  async delete(id) {
+    const todos = await this.load();
+    const index = todos.findIndex(t => t.id === String(id));
+    if (index === -1) {
+      return { success: false, error: `Todo not found: ${id}` };
+    }
+
+    const removed = todos.splice(index, 1)[0];
+    await this.save(todos);
+    return { success: true, todo: removed };
+  }
+}