wispy-cli 2.7.6 → 2.7.8

package/core/task-router.mjs

@@ -0,0 +1,395 @@
+/**
+ * core/task-router.mjs — Smart Model Router for Wispy
+ *
+ * Decides WHICH model handles WHICH task based on task classification,
+ * model capabilities, cost/speed tradeoffs, and available providers.
+ */
+
+import { PROVIDERS, detectProvider } from "./config.mjs";
+
+// ── Model capability registry ────────────────────────────────────────────────
+
+export const MODEL_CAPABILITIES = {
+  // Coding specialists
+  "gpt-5.4": {
+    strengths: ["coding", "debugging", "refactoring"],
+    speed: "medium",
+    cost: "high",
+    contextWindow: 128000,
+    provider: "openai",
+  },
+  "gpt-4o": {
+    strengths: ["coding", "analysis", "general"],
+    speed: "fast",
+    cost: "medium",
+    contextWindow: 128000,
+    provider: "openai",
+  },
+  "gpt-4o-mini": {
+    strengths: ["coding", "summarization"],
+    speed: "very-fast",
+    cost: "low",
+    contextWindow: 128000,
+    provider: "openai",
+  },
+  "o3-mini": {
+    strengths: ["reasoning", "math", "coding"],
+    speed: "slow",
+    cost: "medium",
+    contextWindow: 128000,
+    provider: "openai",
+  },
+
+  // Claude family
+  "claude-opus-4-20250514": {
+    strengths: ["architecture", "reasoning", "writing", "analysis"],
+    speed: "slow",
+    cost: "very-high",
+    contextWindow: 200000,
+    provider: "anthropic",
+  },
+  "claude-sonnet-4-20250514": {
+    strengths: ["coding", "analysis", "review"],
+    speed: "medium",
+    cost: "medium",
+    contextWindow: 200000,
+    provider: "anthropic",
+  },
+  "claude-3-5-haiku-20241022": {
+    strengths: ["summarization", "formatting", "quick-tasks"],
+    speed: "very-fast",
+    cost: "low",
+    contextWindow: 200000,
+    provider: "anthropic",
+  },
+
+  // Gemini family
+  "gemini-2.5-pro": {
+    strengths: ["research", "analysis", "long-context", "planning"],
+    speed: "medium",
+    cost: "medium",
+    contextWindow: 1000000,
+    provider: "google",
+  },
+  "gemini-2.5-flash": {
+    strengths: ["summarization", "quick-tasks", "formatting"],
+    speed: "very-fast",
+    cost: "very-low",
+    contextWindow: 1000000,
+    provider: "google",
+  },
+
+  // Speed / free tier
+  "llama-3.3-70b-versatile": {
+    strengths: ["general", "summarization"],
+    speed: "very-fast",
+    cost: "free",
+    contextWindow: 32768,
+    provider: "groq",
+  },
+  "deepseek-chat": {
+    strengths: ["coding", "reasoning"],
+    speed: "fast",
+    cost: "very-low",
+    contextWindow: 64000,
+    provider: "deepseek",
+  },
+  "deepseek-reasoner": {
+    strengths: ["reasoning", "math", "analysis"],
+    speed: "slow",
+    cost: "low",
+    contextWindow: 64000,
+    provider: "deepseek",
+  },
+};
+
+// ── Provider → model map (for detecting available models) ────────────────────
+
+const PROVIDER_ENV_KEYS = {
+  openai:    ["OPENAI_API_KEY"],
+  anthropic: ["ANTHROPIC_API_KEY"],
+  google:    ["GOOGLE_AI_KEY", "GOOGLE_GENERATIVE_AI_KEY", "GEMINI_API_KEY"],
+  groq:      ["GROQ_API_KEY"],
+  deepseek:  ["DEEPSEEK_API_KEY"],
+};
+
+// ── Keyword→task type maps ────────────────────────────────────────────────────
+
+const TYPE_KEYWORDS = {
+  coding:   [
+    "code", "function", "implement", "bug", "fix", "debug", "refactor", "write a", "create a",
+    "class", "method", "variable", "typescript", "javascript", "python", "rust", "go", "java",
+    ".ts", ".js", ".py", ".rs", ".go", ".java", ".cpp", ".c", "```", "error:", "syntax",
+    "compile", "build", "test", "unit test", "integration test",
+  ],
+  research: [
+    "research", "find", "search", "look up", "what is", "explain", "describe", "tell me about",
+    "history of", "why does", "how does", "what are", "latest", "news", "papers", "sources",
+  ],
+  analysis: [
+    "analyze", "analysis", "evaluate", "compare", "contrast", "pros and cons", "review",
+    "assess", "benchmark", "performance", "metrics", "statistics", "data", "trend",
+  ],
+  design:   [
+    "design", "architecture", "system design", "schema", "diagram", "structure", "layout",
+    "plan", "blueprint", "mockup", "wireframe",
+  ],
+  review:   [
+    "review", "check", "verify", "validate", "audit", "security", "issues", "problems",
+    "vulnerabilities", "code review", "pull request", "pr review",
+  ],
+  summarize: [
+    "summarize", "summary", "tldr", "tl;dr", "recap", "brief", "overview", "key points",
+    "shorten", "condense",
+  ],
+  format:   [
+    "format", "reformat", "prettify", "lint", "clean up", "style", "markdown", "json",
+    "yaml", "csv", "table", "list",
+  ],
+};
+
+const COMPLEXITY_THRESHOLDS = {
+  simple:  150,   // < 150 chars → simple
+  medium:  600,   // < 600 chars → medium
+  // above → complex
+};
+
+// ── Task classification ──────────────────────────────────────────────────────
+
+/**
+ * Classify a task into type, complexity, estimated tokens, and parallelizability.
+ *
+ * @param {string} taskText
+ * @returns {{ type: string, complexity: string, estimatedTokens: number, parallelizable: boolean }}
+ */
+export function classifyTask(taskText) {
+  const lower = taskText.toLowerCase();
+
+  // Determine type via keyword matching
+  let bestType = "general";
+  let bestScore = 0;
+
+  for (const [type, keywords] of Object.entries(TYPE_KEYWORDS)) {
+    let score = 0;
+    for (const kw of keywords) {
+      if (lower.includes(kw)) score++;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      bestType = type;
+    }
+  }
+
+  // Heuristic overrides
+  const hasCodeBlock = taskText.includes("```");
+  const hasFileExtension = /\.(ts|js|py|rs|go|java|cpp|c|rb|php|swift|kt)\b/i.test(taskText);
+  if (hasCodeBlock || hasFileExtension) {
+    bestType = "coding";
+  }
+
+  // Complexity based on text length + heuristics
+  let complexity;
+  const len = taskText.length;
+  const wordCount = taskText.split(/\s+/).length;
+  if (len < COMPLEXITY_THRESHOLDS.simple && wordCount < 30) {
+    complexity = "simple";
+  } else if (len < COMPLEXITY_THRESHOLDS.medium && wordCount < 100) {
+    complexity = "medium";
+  } else {
+    complexity = "complex";
+  }
+
+  // More complexity signals
+  const complexSignals = [
+    "multiple", "all", "entire", "full", "complete", "end-to-end", "from scratch",
+    "and also", "in addition", "furthermore", "step by step",
+  ];
+  if (complexSignals.some(s => lower.includes(s))) {
+    if (complexity === "simple") complexity = "medium";
+    else if (complexity === "medium") complexity = "complex";
+  }
+
+  // Estimate tokens (rough: 1 token ≈ 4 chars, plus response overhead)
+  const estimatedTokens = Math.ceil(len / 4) + (complexity === "complex" ? 2000 : complexity === "medium" ? 800 : 300);
+
+  // Parallelizable: tasks that can be split across multiple independent workers
+  const parallelSignals = [
+    "and", "also", "multiple", "each", "for each", "list of", "all the", "several",
+  ];
+  const parallelizable = complexity === "complex" && parallelSignals.some(s => lower.includes(s));
+
+  return { type: bestType, complexity, estimatedTokens, parallelizable };
+}
+
+// ── Provider availability detection ─────────────────────────────────────────
+
+/**
+ * Return the set of provider IDs that actually have API keys in env.
+ * @returns {Set<string>}
+ */
+export function getAvailableProviders() {
+  const available = new Set();
+  for (const [provider, envKeys] of Object.entries(PROVIDER_ENV_KEYS)) {
+    if (envKeys.some(k => process.env[k])) {
+      available.add(provider);
+    }
+  }
+  return available;
+}
+
+/**
+ * Filter model list to only those whose provider is available.
+ * @param {string[]} modelNames
+ * @returns {string[]}
+ */
+export function filterAvailableModels(modelNames) {
+  const available = getAvailableProviders();
+  return modelNames.filter(m => {
+    const cap = MODEL_CAPABILITIES[m];
+    return cap && available.has(cap.provider);
+  });
+}
+
+// ── Cost/speed ordering helpers ──────────────────────────────────────────────
+
+const COST_ORDER = { free: 0, "very-low": 1, low: 2, medium: 3, high: 4, "very-high": 5 };
+const SPEED_ORDER = { "very-fast": 0, fast: 1, medium: 2, slow: 3 };
+
+function costScore(model) {
+  return COST_ORDER[MODEL_CAPABILITIES[model]?.cost] ?? 3;
+}
+
+function speedScore(model) {
+  return SPEED_ORDER[MODEL_CAPABILITIES[model]?.speed] ?? 2;
+}
+
+// ── Core routing logic ────────────────────────────────────────────────────────
+
+/**
+ * Route a task to the best available model.
+ *
+ * @param {string|object} task — task text or { type, complexity, estimatedTokens, parallelizable }
+ * @param {string[]} [availableModels] — explicit list; if omitted, auto-detected from env
+ * @param {object} [opts]
+ * @param {string} [opts.costPreference] — "minimize" | "balanced" | "maximize-quality"
+ * @param {string} [opts.defaultModel] — fallback model
+ * @returns {{ model: string, provider: string, reason: string }}
+ */
+export function routeTask(task, availableModels, opts = {}) {
+  const taskText = typeof task === "string" ? task : task.task ?? "";
+  const classification = typeof task === "object" && task.type
+    ? task
+    : classifyTask(taskText);
+
+  const { type, complexity, estimatedTokens } = classification;
+  const costPreference = opts.costPreference ?? "balanced";
+
+  // Determine candidate models
+  let candidates = availableModels;
+  if (!candidates || candidates.length === 0) {
+    candidates = filterAvailableModels(Object.keys(MODEL_CAPABILITIES));
+  }
+
+  // Filter to models that have valid capabilities
+  candidates = candidates.filter(m => MODEL_CAPABILITIES[m]);
+
+  if (candidates.length === 0) {
+    // No models available — fall back to default
+    const fallback = opts.defaultModel ?? "gemini-2.5-flash";
+    const cap = MODEL_CAPABILITIES[fallback];
+    return {
+      model: fallback,
+      provider: cap?.provider ?? "google",
+      reason: `No models available; using default (${fallback})`,
+    };
+  }
+
+  // Score each candidate
+  const scored = candidates.map(model => {
+    const cap = MODEL_CAPABILITIES[model];
+    if (!cap) return { model, score: -Infinity };
+
+    let score = 0;
+
+    // Strength match
+    const strengthScore = cap.strengths.includes(type) ? 10 : 0;
+    score += strengthScore;
+
+    // Partial strength match (related types)
+    const related = { coding: ["analysis", "review"], research: ["analysis"], design: ["analysis", "planning"] };
+    const relatedStrengths = related[type] ?? [];
+    for (const rs of relatedStrengths) {
+      if (cap.strengths.includes(rs)) score += 3;
+    }
+
+    // Complexity × cost/speed tradeoff
+    if (costPreference === "minimize") {
+      score -= costScore(model) * 2;
+      score -= speedScore(model);
+    } else if (costPreference === "maximize-quality") {
+      score += (5 - costScore(model));  // prefer expensive (high quality)
+      score -= speedScore(model) * 0.5;
+    } else {
+      // balanced: for complex tasks lean toward quality, simple tasks lean toward speed+cost
+      if (complexity === "complex") {
+        score -= costScore(model);
+        score -= speedScore(model) * 0.5;
+      } else if (complexity === "simple") {
+        score -= costScore(model) * 2;
+        score += (3 - speedScore(model)) * 1.5;
+      } else {
+        score -= costScore(model);
+        score -= speedScore(model);
+      }
+    }
+
+    // Context window bonus for large tasks
+    if (estimatedTokens > 50000 && cap.contextWindow >= 200000) {
+      score += 3;
+    }
+
+    return { model, score, cap };
+  });
+
+  scored.sort((a, b) => b.score - a.score);
+  const best = scored[0];
+  const cap = best.cap ?? MODEL_CAPABILITIES[best.model];
+
+  const strengthMatch = cap?.strengths.includes(type)
+    ? `strengths match '${type}'`
+    : `best available for '${type}'`;
+
+  const reason = `${best.model} selected: ${strengthMatch}, ${cap?.speed ?? "?"} speed, ${cap?.cost ?? "?"} cost (complexity: ${complexity}, preference: ${costPreference})`;
+
+  return {
+    model: best.model,
+    provider: cap?.provider ?? "unknown",
+    reason,
+  };
+}
+
+/**
+ * Given a provider name, return the best cheap/fast decomposition model available.
+ * Used by the task decomposer.
+ * @returns {{ model: string, provider: string }}
+ */
+export function getCheapDecomposerModel() {
+  const available = getAvailableProviders();
+  const cheapModels = [
+    { model: "gemini-2.5-flash", provider: "google" },
+    { model: "claude-3-5-haiku-20241022", provider: "anthropic" },
+    { model: "gpt-4o-mini", provider: "openai" },
+    { model: "llama-3.3-70b-versatile", provider: "groq" },
+    { model: "deepseek-chat", provider: "deepseek" },
+  ];
+  for (const entry of cheapModels) {
+    if (available.has(entry.provider)) return entry;
+  }
+  // Final fallback — return first available model
+  const allCandidates = filterAvailableModels(Object.keys(MODEL_CAPABILITIES));
+  if (allCandidates.length > 0) {
+    const m = allCandidates[0];
+    return { model: m, provider: MODEL_CAPABILITIES[m].provider };
+  }
+  return { model: "gemini-2.5-flash", provider: "google" };
+}

package/package.json

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