wispy-cli 2.7.7 → 2.7.9

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}`;
+  }
+}