wispy-cli 2.7.8 → 2.7.10

package/core/task-decomposer.mjs

@@ -0,0 +1,375 @@
+/**
+ * core/task-decomposer.mjs — Task Decomposition Engine for Wispy
+ *
+ * Splits complex tasks into parallel subtasks, routes each to the best model,
+ * executes concurrently, and synthesizes results.
+ */
+
+import { routeTask, getCheapDecomposerModel, classifyTask } from "./task-router.mjs";
+
+// ── Subtask counter ───────────────────────────────────────────────────────────
+
+let _subtaskCounter = 0;
+function makeSubtaskId() {
+  return `st-${(++_subtaskCounter).toString().padStart(2, "0")}`;
+}
+
+// ── Decompose task using LLM ─────────────────────────────────────────────────
+
+/**
+ * Decompose a complex task into parallel subtasks using a cheap LLM.
+ *
+ * @param {string} task - The task description
+ * @param {object} [options]
+ * @param {number} [options.maxSubtasks=5] - Max number of subtasks
+ * @param {string} [options.costPreference="balanced"] - "minimize" | "balanced" | "maximize-quality"
+ * @param {object} [options.engine] - WispyEngine instance (for LLM calls)
+ * @returns {Promise<{
+ *   subtasks: Array<{id,task,type,dependencies,priority}>,
+ *   parallelGroups: string[][],
+ *   estimatedCost: string,
+ *   estimatedTime: string
+ * }>}
+ */
+export async function decomposeTask(task, options = {}) {
+  const maxSubtasks = options.maxSubtasks ?? 5;
+  const costPreference = options.costPreference ?? "balanced";
+  const engine = options.engine ?? null;
+
+  _subtaskCounter = 0; // reset for this decomposition
+
+  // Quick path: if the task seems simple, don't bother decomposing
+  const classification = classifyTask(task);
+  if (classification.complexity !== "complex" || !classification.parallelizable) {
+    const subtaskId = makeSubtaskId();
+    return {
+      subtasks: [
+        {
+          id: subtaskId,
+          task,
+          type: classification.type,
+          dependencies: [],
+          priority: 1,
+        },
+      ],
+      parallelGroups: [[subtaskId]],
+      estimatedCost: costPreference === "minimize" ? "very-low" : "low",
+      estimatedTime: classification.complexity === "simple" ? "<1min" : "1-2min",
+    };
+  }
+
+  // Use LLM decomposition if engine is available
+  if (engine) {
+    try {
+      return await _llmDecompose(task, maxSubtasks, costPreference, engine);
+    } catch (err) {
+      if (process.env.WISPY_DEBUG) {
+        console.error(`[task-decomposer] LLM decompose failed: ${err.message}, falling back to heuristic`);
+      }
+    }
+  }
+
+  // Heuristic decomposition (no LLM)
+  return _heuristicDecompose(task, maxSubtasks, costPreference, classification);
+}
+
+/**
+ * Decompose using an LLM call (cheap model).
+ */
+async function _llmDecompose(task, maxSubtasks, costPreference, engine) {
+  const { model } = getCheapDecomposerModel();
+
+  const systemPrompt = `You are a task decomposition expert. Split complex tasks into independent subtasks that can be parallelized.
+Reply with ONLY valid JSON. No markdown, no explanation.`;
+
+  const userPrompt = `Decompose this task into at most ${maxSubtasks} subtasks. 
+Task: "${task}"
+
+Requirements:
+- Identify subtasks that can run in parallel (no dependencies)
+- Identify subtasks that need results from others (add dependency IDs)  
+- Classify each subtask type: coding, research, analysis, design, review, summarize, format, or general
+- Set priority: 1 = first group (parallel), 2 = waits for priority 1, etc.
+
+Respond with ONLY this JSON (no markdown):
+{
+  "subtasks": [
+    {"id": "st-01", "task": "...", "type": "coding", "dependencies": [], "priority": 1},
+    {"id": "st-02", "task": "...", "type": "research", "dependencies": [], "priority": 1},
+    {"id": "st-03", "task": "...", "type": "review", "dependencies": ["st-01","st-02"], "priority": 2}
+  ],
+  "estimatedTime": "2-5min",
+  "estimatedCost": "low"
+}`;
+
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userPrompt },
+  ];
+
+  const result = await engine.providers.chat(messages, [], { model });
+  const text = result.type === "text" ? result.text : JSON.stringify(result);
+
+  // Extract JSON from response
+  const jsonMatch = text.match(/\{[\s\S]*"subtasks"[\s\S]*\}/);
+  if (!jsonMatch) throw new Error("LLM did not return valid decomposition JSON");
+
+  const parsed = JSON.parse(jsonMatch[0]);
+  const subtasks = (parsed.subtasks ?? []).slice(0, maxSubtasks);
+
+  // Ensure IDs are consistent
+  const idMap = {};
+  subtasks.forEach((st, i) => {
+    const newId = makeSubtaskId();
+    idMap[st.id] = newId;
+    st.id = newId;
+  });
+
+  // Remap dependency IDs
+  for (const st of subtasks) {
+    st.dependencies = (st.dependencies ?? []).map(d => idMap[d] ?? d).filter(d => subtasks.some(s => s.id === d));
+  }
+
+  // Build parallel groups from priority
+  const groups = {};
+  for (const st of subtasks) {
+    const p = st.priority ?? 1;
+    if (!groups[p]) groups[p] = [];
+    groups[p].push(st.id);
+  }
+  const parallelGroups = Object.keys(groups).sort((a, b) => Number(a) - Number(b)).map(k => groups[k]);
+
+  return {
+    subtasks,
+    parallelGroups,
+    estimatedCost: parsed.estimatedCost ?? _estimateCost(costPreference, subtasks.length),
+    estimatedTime: parsed.estimatedTime ?? _estimateTime(subtasks.length),
+  };
+}
+
+/**
+ * Heuristic decomposition (no LLM required).
+ */
+function _heuristicDecompose(task, maxSubtasks, costPreference, classification) {
+  // Split by "and" / newlines / semicolons as a heuristic
+  const sentences = task
+    .split(/\n|;|\band\b(?=[^,]*,|\s+\w+\s+the\s)/)
+    .map(s => s.trim())
+    .filter(s => s.length > 10);
+
+  const subtasks = sentences.slice(0, maxSubtasks).map((s, i) => ({
+    id: makeSubtaskId(),
+    task: s,
+    type: classifyTask(s).type,
+    dependencies: [],
+    priority: 1,
+  }));
+
+  // If no useful split found, use the whole task as one subtask
+  if (subtasks.length === 0) {
+    const id = makeSubtaskId();
+    return {
+      subtasks: [{ id, task, type: classification.type, dependencies: [], priority: 1 }],
+      parallelGroups: [[id]],
+      estimatedCost: _estimateCost(costPreference, 1),
+      estimatedTime: "1-3min",
+    };
+  }
+
+  return {
+    subtasks,
+    parallelGroups: [subtasks.map(s => s.id)],
+    estimatedCost: _estimateCost(costPreference, subtasks.length),
+    estimatedTime: _estimateTime(subtasks.length),
+  };
+}
+
+function _estimateCost(costPreference, numSubtasks) {
+  if (costPreference === "minimize") return "very-low";
+  if (costPreference === "maximize-quality") return numSubtasks > 3 ? "high" : "medium";
+  return numSubtasks > 3 ? "medium" : "low";
+}
+
+function _estimateTime(numSubtasks) {
+  if (numSubtasks <= 1) return "<1min";
+  if (numSubtasks <= 3) return "1-3min";
+  return "2-5min";
+}
+
+// ── Execute decomposed plan ──────────────────────────────────────────────────
+
+/**
+ * Execute an execution plan, running parallel groups concurrently.
+ *
+ * @param {object} plan - Result from decomposeTask()
+ * @param {object} engine - WispyEngine instance
+ * @param {object} [opts]
+ * @param {string} [opts.costPreference="balanced"]
+ * @param {Function} [opts.onSubtaskStart] - (subtask) => void
+ * @param {Function} [opts.onSubtaskComplete] - (subtask, result) => void
+ * @param {Function} [opts.onSubtaskFail] - (subtask, error) => void
+ * @returns {Promise<{ results: object[], synthesized: string, errors: object[] }>}
+ */
+export async function executeDecomposedPlan(plan, engine, opts = {}) {
+  const costPreference = opts.costPreference ?? "balanced";
+  const completedResults = {}; // id → result
+  const errors = [];
+  const MAX_RETRIES = 1;
+
+  for (const group of plan.parallelGroups) {
+    // Filter to subtasks in this group (skip if all deps not satisfied)
+    const groupSubtasks = group
+      .map(id => plan.subtasks.find(s => s.id === id))
+      .filter(Boolean);
+
+    // Run group in parallel
+    const groupPromises = groupSubtasks.map(async (subtask) => {
+      // Route to best model
+      const routing = routeTask(
+        { type: subtask.type, complexity: "medium", estimatedTokens: Math.ceil(subtask.task.length / 4) + 800, parallelizable: false },
+        null,
+        { costPreference }
+      );
+
+      opts.onSubtaskStart?.(subtask);
+
+      let attempt = 0;
+      while (attempt <= MAX_RETRIES) {
+        try {
+          // Build context from dependencies
+          const depContext = subtask.dependencies
+            .map(depId => completedResults[depId])
+            .filter(Boolean)
+            .map((r, i) => `### Dependency ${i + 1} result:\n${r}`)
+            .join("\n\n");
+
+          const fullTask = depContext
+            ? `${subtask.task}\n\n---\nContext from previous steps:\n${depContext}`
+            : subtask.task;
+
+          // Use sub-agent manager if available, else direct provider call
+          let result;
+          if (engine.subagents) {
+            const agent = await engine.subagents.spawn({
+              task: fullTask,
+              label: `decomposed-${subtask.id}`,
+              model: routing.model,
+              timeout: 120, // seconds
+              workstream: engine._activeWorkstream,
+            });
+
+            // Wait for completion
+            result = await engine.subagents.waitFor(agent.id, 120_000);
+            result = result.result ?? result.error ?? "(no result)";
+          } else {
+            // Direct provider call
+            const messages = [
+              { role: "system", content: `You are a focused worker agent. Complete only this specific subtask. Be concise.` },
+              { role: "user", content: fullTask },
+            ];
+            const response = await engine.providers.chat(messages, [], { model: routing.model });
+            result = response.type === "text" ? response.text : JSON.stringify(response);
+          }
+
+          completedResults[subtask.id] = result;
+          opts.onSubtaskComplete?.(subtask, result);
+          return { id: subtask.id, result, routing, success: true };
+        } catch (err) {
+          attempt++;
+          if (attempt > MAX_RETRIES) {
+            const error = { id: subtask.id, error: err.message, subtask };
+            errors.push(error);
+            opts.onSubtaskFail?.(subtask, err);
+            // Non-critical: continue with empty result
+            completedResults[subtask.id] = `[subtask ${subtask.id} failed: ${err.message}]`;
+            return { id: subtask.id, result: null, error: err.message, success: false };
+          }
+          // Retry
+          await new Promise(r => setTimeout(r, 1000 * attempt));
+        }
+      }
+    });
+
+    // Wait for all in group before proceeding to next group
+    await Promise.all(groupPromises);
+  }
+
+  // Collect results in subtask order
+  const orderedResults = plan.subtasks.map(st => ({
+    id: st.id,
+    task: st.task,
+    type: st.type,
+    result: completedResults[st.id] ?? null,
+  }));
+
+  // Synthesize
+  let synthesized;
+  try {
+    synthesized = await synthesizeResults(orderedResults, engine);
+  } catch (err) {
+    // Fallback: concatenate results
+    synthesized = orderedResults
+      .filter(r => r.result)
+      .map(r => `**${r.type.toUpperCase()}**: ${r.result}`)
+      .join("\n\n---\n\n");
+  }
+
+  return {
+    results: orderedResults,
+    synthesized,
+    errors,
+  };
+}
+
+// ── Synthesize results ────────────────────────────────────────────────────────
+
+/**
+ * Synthesize multiple subtask results into a coherent response.
+ *
+ * @param {Array<{id, task, type, result}>} subtaskResults
+ * @param {object} [engine] - WispyEngine instance (for LLM synthesis)
+ * @returns {Promise<string>}
+ */
+export async function synthesizeResults(subtaskResults, engine) {
+  const validResults = subtaskResults.filter(r => r.result && !r.result.startsWith("[subtask"));
+
+  if (validResults.length === 0) {
+    return "All subtasks failed to produce results.";
+  }
+
+  if (validResults.length === 1) {
+    return validResults[0].result;
+  }
+
+  // Build synthesis prompt
+  const parts = validResults.map((r, i) =>
+    `### Subtask ${i + 1} (${r.type}): ${r.task.slice(0, 100)}\n${r.result.slice(0, 2000)}`
+  ).join("\n\n---\n\n");
+
+  // If no engine, concatenate
+  if (!engine) {
+    return `## Combined Results\n\n${parts}`;
+  }
+
+  const { model } = getCheapDecomposerModel();
+
+  const messages = [
+    {
+      role: "system",
+      content: `You are a synthesis agent. Merge multiple subtask outputs into a single, coherent, well-structured response.
+Remove redundancy. Resolve conflicts by noting them. Maintain all important information.`,
+    },
+    {
+      role: "user",
+      content: `Synthesize these ${validResults.length} subtask results into one coherent response:\n\n${parts}`,
+    },
+  ];
+
+  try {
+    const result = await engine.providers.chat(messages, [], { model });
+    return result.type === "text" ? result.text : JSON.stringify(result);
+  } catch (err) {
+    // Fallback
+    return `## Synthesized Results\n\n${parts}`;
+  }
+}

package/core/task-router.mjs

@@ -42,7 +42,7 @@ export const MODEL_CAPABILITIES = {
 
   // Claude family
   "claude-opus-4-20250514": {
-    strengths: ["architecture", "reasoning", "writing", "analysis"],
+    strengths: ["architecture", "reasoning", "writing", "analysis", "design"],
     speed: "slow",
     cost: "very-high",
     contextWindow: 200000,
@@ -327,7 +327,7 @@ export function routeTask(task, availableModels, opts = {}) {
       score -= costScore(model) * 2;
       score -= speedScore(model);
     } else if (costPreference === "maximize-quality") {
-      score += (5 - costScore(model));  // prefer expensive (high quality)
+      score += costScore(model) * 2;    // prefer expensive (high quality)
       score -= speedScore(model) * 0.5;
     } else {
       // balanced: for complex tasks lean toward quality, simple tasks lean toward speed+cost

package/core/tools.mjs

@@ -275,6 +275,57 @@ export class ToolRegistry {
           required: ["id", "message"],
         },
       },
+      // ── Browser tools ────────────────────────────────────────────────────────
+      {
+        name: "browser_status",
+        description: "Check browser bridge health and current session status",
+        parameters: { type: "object", properties: {} },
+      },
+      {
+        name: "browser_tabs",
+        description: "List all open browser tabs",
+        parameters: {
+          type: "object",
+          properties: {
+            browser: { type: "string", enum: ["safari", "chrome"] },
+          },
+        },
+      },
+      {
+        name: "browser_navigate",
+        description: "Navigate the active browser tab to a URL",
+        parameters: {
+          type: "object",
+          properties: { url: { type: "string" } },
+          required: ["url"],
+        },
+      },
+      {
+        name: "browser_screenshot",
+        description: "Take a screenshot of the active browser tab",
+        parameters: { type: "object", properties: {} },
+      },
+      {
+        name: "browser_front_tab",
+        description: "Get info about the currently active browser tab (URL, title)",
+        parameters: { type: "object", properties: {} },
+      },
+      {
+        name: "browser_activate",
+        description: "Bring the browser tab to front / focus it",
+        parameters: { type: "object", properties: {} },
+      },
+      {
+        name: "browser_attach",
+        description: "Attach to a browser for control. Auto-selects the best available browser if no args given.",
+        parameters: {
+          type: "object",
+          properties: {
+            browser: { type: "string" },
+            mode: { type: "string" },
+          },
+        },
+      },
     ];
 
     for (const def of builtins) {
@@ -594,6 +645,14 @@ export class ToolRegistry {
         case "get_subagent_result":
         case "kill_subagent":
         case "steer_subagent":
+        // Browser tools — handled at engine level
+        case "browser_status":
+        case "browser_tabs":
+        case "browser_navigate":
+        case "browser_screenshot":
+        case "browser_front_tab":
+        case "browser_activate":
+        case "browser_attach":
           return { success: false, error: `Tool "${name}" requires engine context. Call via WispyEngine.processMessage().` };
 
         default:

package/core/tts.mjs

@@ -0,0 +1,194 @@
+/**
+ * core/tts.mjs — Text-to-Speech Manager for Wispy
+ *
+ * Auto-detects available TTS provider:
+ *   1. OpenAI TTS API (best quality, requires OPENAI_API_KEY)
+ *   2. macOS native `say` command (free, always available on macOS)
+ *
+ * Usage:
+ *   const tts = new TTSManager(secretsManager);
+ *   const result = await tts.speak("Hello world");
+ *   // result.path → audio file path
+ */
+
+import os from "node:os";
+import path from "node:path";
+import { writeFile } from "node:fs/promises";
+
+export class TTSManager {
+  constructor(secretsManager) {
+    this.secrets = secretsManager;
+    this._provider = null; // cached auto-detected provider
+  }
+
+  /**
+   * Auto-detect available TTS provider.
+   * Order: OpenAI (best quality) → macOS say (free) → null
+   */
+  async detectProvider() {
+    if (this._provider) return this._provider;
+
+    const openaiKey = await this.secrets.resolve("OPENAI_API_KEY");
+    if (openaiKey) {
+      this._provider = "openai";
+      return "openai";
+    }
+
+    if (process.platform === "darwin") {
+      this._provider = "macos";
+      return "macos";
+    }
+
+    return null;
+  }
+
+  /**
+   * Generate speech from text.
+   *
+   * @param {string} text - Text to speak
+   * @param {object} options
+   * @param {string} [options.provider] - "openai" | "macos" | "auto"
+   * @param {string} [options.voice] - Voice name
+   * @param {string} [options.model] - OpenAI TTS model
+   * @param {string} [options.format] - Output format (openai: mp3/opus/aac/flac, macos: aiff)
+   * @param {number} [options.rate] - Speech rate (macOS only)
+   * @returns {Promise<{provider, path, format, voice}|{error}>}
+   */
+  async speak(text, options = {}) {
+    const providerOpt = options.provider ?? "auto";
+    const provider = providerOpt === "auto"
+      ? await this.detectProvider()
+      : providerOpt;
+
+    switch (provider) {
+      case "openai":
+        return this._openaiTTS(text, options);
+      case "macos":
+        return this._macosTTS(text, options);
+      default:
+        return { error: "No TTS provider available. Set OPENAI_API_KEY or use macOS." };
+    }
+  }
+
+  /**
+   * OpenAI TTS API
+   * https://platform.openai.com/docs/api-reference/audio/createSpeech
+   */
+  async _openaiTTS(text, {
+    voice = "alloy",
+    model = "tts-1",
+    format = "mp3",
+  } = {}) {
+    const apiKey = await this.secrets.resolve("OPENAI_API_KEY");
+    if (!apiKey) {
+      return { error: "OPENAI_API_KEY not found" };
+    }
+
+    const response = await fetch("https://api.openai.com/v1/audio/speech", {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model,
+        input: text,
+        voice,
+        response_format: format,
+      }),
+    });
+
+    if (!response.ok) {
+      const errText = await response.text().catch(() => "unknown error");
+      return { error: `OpenAI TTS failed: ${response.status} ${errText}` };
+    }
+
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const outputPath = path.join(os.tmpdir(), `wispy-tts-${Date.now()}.${format}`);
+    await writeFile(outputPath, buffer);
+
+    return { provider: "openai", path: outputPath, format, voice };
+  }
+
+  /**
+   * macOS native TTS using `say` command
+   */
+  async _macosTTS(text, {
+    voice = "Samantha",
+    rate = 200,
+  } = {}) {
+    if (process.platform !== "darwin") {
+      return { error: "macOS TTS is only available on macOS" };
+    }
+
+    const outputPath = path.join(os.tmpdir(), `wispy-tts-${Date.now()}.aiff`);
+
+    const { execFile } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const exec = promisify(execFile);
+
+    try {
+      await exec("say", ["-v", voice, "-r", String(rate), "-o", outputPath, text], {
+        timeout: 30000,
+      });
+    } catch (err) {
+      return { error: `macOS TTS failed: ${err.message}` };
+    }
+
+    return { provider: "macos", path: outputPath, format: "aiff", voice };
+  }
+
+  /**
+   * List available macOS voices
+   */
+  async listMacOSVoices() {
+    if (process.platform !== "darwin") return [];
+    try {
+      const { execFile } = await import("node:child_process");
+      const { promisify } = await import("node:util");
+      const exec = promisify(execFile);
+      const { stdout } = await exec("say", ["-v", "?"], { timeout: 5000 });
+      return stdout.trim().split("\n").map(line => {
+        const parts = line.trim().split(/\s+/);
+        return { name: parts[0], locale: parts[1] };
+      });
+    } catch {
+      return [];
+    }
+  }
+}
+
+/**
+ * Tool definition for ToolRegistry integration
+ */
+export const TTS_TOOL_DEFINITION = {
+  name: "text_to_speech",
+  description: "Convert text to speech audio file. Returns the path to the generated audio file.",
+  parameters: {
+    type: "object",
+    properties: {
+      text: {
+        type: "string",
+        description: "Text to convert to speech",
+      },
+      voice: {
+        type: "string",
+        description: "Voice name (openai: alloy/echo/fable/onyx/nova/shimmer, macos: Samantha/Alex/Victoria/etc)",
+      },
+      provider: {
+        type: "string",
+        enum: ["openai", "macos", "auto"],
+        description: "TTS provider to use (default: auto-detect)",
+      },
+      model: {
+        type: "string",
+        description: "TTS model (OpenAI only: tts-1 or tts-1-hd)",
+      },
+      rate: {
+        type: "number",
+        description: "Speech rate in words per minute (macOS only, default: 200)",
+      },
+    },
+    required: ["text"],
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wispy-cli",
-  "version": "2.7.8",
+  "version": "2.7.10",
   "description": "🌿 Wispy — AI workspace assistant with trustworthy execution (harness, receipts, approvals, diffs)",
   "license": "MIT",
   "author": "Minseo & Poropo",