@wrongstack/core 0.109.1 → 0.141.0

package/dist/models/index.js

@@ -756,6 +756,55 @@ function expectDefined(value, label) {
   return value;
 }
 
+// src/utils/token-estimate.ts
+var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
+var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
+var ESTIMATE_CACHE_MAX_SIZE = 1e4;
+function getCachedEstimate(key, compute) {
+  const existing = ESTIMATE_CACHE.get(key);
+  if (existing !== void 0) return existing;
+  if (ESTIMATE_CACHE.size >= ESTIMATE_CACHE_MAX_SIZE) {
+    const keys = [...ESTIMATE_CACHE.keys()];
+    for (let i = 0; i < Math.floor(ESTIMATE_CACHE_MAX_SIZE / 4); i++) {
+      ESTIMATE_CACHE.delete(expectDefined(keys[i]));
+    }
+  }
+  const estimate = compute();
+  ESTIMATE_CACHE.set(key, estimate);
+  return estimate;
+}
+function estimateToolInputTokens(input) {
+  if (typeof input === "string") return RoughTokenEstimate(input);
+  if (input === null || typeof input !== "object") {
+    return RoughTokenEstimate(String(input));
+  }
+  const key = JSON.stringify(input);
+  return getCachedEstimate(key, () => RoughTokenEstimate(key));
+}
+function estimateToolResultTokens(content) {
+  if (typeof content === "string") return RoughTokenEstimate(content);
+  const key = JSON.stringify(content);
+  return getCachedEstimate(key, () => RoughTokenEstimate(key));
+}
+function estimateTextTokens(text) {
+  return RoughTokenEstimate(text);
+}
+function estimateMessageTokens(messages) {
+  let total = 0;
+  for (const m of messages) {
+    if (typeof m.content === "string") {
+      total += estimateTextTokens(m.content);
+    } else {
+      for (const b of m.content) {
+        if (b.type === "text") total += estimateTextTokens(b.text);
+        else if (b.type === "tool_use") total += estimateToolInputTokens(b.input);
+        else if (b.type === "tool_result") total += estimateToolResultTokens(b.content);
+      }
+    }
+  }
+  return total;
+}
+
 // src/types/blocks.ts
 function isTextBlock(b) {
   return b.type === "text";
@@ -784,20 +833,6 @@ Rules:
 - If unsure, keep rather than collapse (errors are more costly than waste)
 
 Return ONLY the JSON object, no markdown, no explanation outside the JSON.`;
-function estimateTokens(messages) {
-  let total = 0;
-  for (const m of messages) {
-    if (typeof m.content === "string") {
-      total += Math.ceil(m.content.length / 4);
-    } else if (Array.isArray(m.content)) {
-      for (const b of m.content) {
-        if (b.type === "text") total += Math.ceil(b.text.length / 4);
-        else total += Math.ceil(JSON.stringify(b).length / 4);
-      }
-    }
-  }
-  return total;
-}
 function formatMessages(messages, maxChars = 8e3) {
   const lines = [];
   let used = 0;
@@ -836,7 +871,7 @@ var LLMSelector = class {
   async select(messages, maxToKeep) {
     const effectiveBudget = Math.min(maxToKeep, this.maxContextTokens);
     const historyText = formatMessages(messages);
-    const totalTokens = estimateTokens(messages);
+    const totalTokens = estimateMessageTokens(messages);
     const systemText = `${this.systemPrompt}
 
 Conversation (${messages.length} messages, ~${totalTokens} tokens, budget: ${effectiveBudget}):
@@ -868,10 +903,7 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
     let startIdx = 0;
     for (let i = messages.length - 1; i >= 0; i--) {
       const m = expectDefined(messages[i]);
-      const cost = typeof m.content === "string" ? Math.ceil(m.content.length / 4) : m.content.reduce(
-        (acc, b) => acc + (b.type === "text" ? Math.ceil(b.text.length / 4) : Math.ceil(JSON.stringify(b).length / 4)),
-        0
-      );
+      const cost = estimateMessageTokens([m]);
       if (tokenCount + cost <= budget) {
         tokenCount += cost;
       } else {
@@ -922,6 +954,429 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
   }
 };
 
-export { DefaultModeStore, DefaultModelsRegistry, LLMSelector, classifyFamily, loadProjectModes, loadUserModes };
+// src/models/model-intelligence.ts
+var MODEL_PROFILES = [
+  // ── Anthropic ──
+  {
+    provider: "anthropic",
+    pattern: /claude-opus/i,
+    family: "Claude Opus",
+    strengths: ["complex reasoning", "multi-step planning", "nuanced judgment", "long-form analysis"],
+    weaknesses: ["latency", "cost"],
+    bestFor: ["planning", "security", "debugging", "review"],
+    costTier: "premium",
+    speedTier: "slow"
+  },
+  {
+    provider: "anthropic",
+    pattern: /claude-sonnet/i,
+    family: "Claude Sonnet",
+    strengths: ["coding", "balanced reasoning", "tool use", "fast iteration"],
+    bestFor: ["coding", "refactoring", "backend", "general"],
+    costTier: "standard",
+    speedTier: "fast"
+  },
+  {
+    provider: "anthropic",
+    pattern: /claude-haiku/i,
+    family: "Claude Haiku",
+    strengths: ["speed", "low cost", "simple tasks"],
+    weaknesses: ["complex reasoning", "long context"],
+    bestFor: ["lightweight", "docs", "frontend"],
+    avoidFor: ["planning", "security"],
+    costTier: "budget",
+    speedTier: "fast"
+  },
+  // ── OpenAI ──
+  {
+    provider: "openai",
+    pattern: /gpt-5|o3|o4/i,
+    family: "GPT-5 / o3 / o4",
+    strengths: ["complex reasoning", "coding", "multi-modal"],
+    bestFor: ["planning", "coding", "debugging", "general"],
+    costTier: "premium",
+    speedTier: "normal"
+  },
+  {
+    provider: "openai",
+    pattern: /gpt-4\.1|gpt-4o/i,
+    family: "GPT-4.1 / 4o",
+    strengths: ["coding", "balanced reasoning", "fast"],
+    bestFor: ["coding", "refactoring", "backend", "docs"],
+    costTier: "standard",
+    speedTier: "fast"
+  },
+  {
+    provider: "openai",
+    pattern: /gpt-4o-mini/i,
+    family: "GPT-4o Mini",
+    strengths: ["speed", "low cost", "simple tasks"],
+    weaknesses: ["complex reasoning"],
+    bestFor: ["lightweight", "frontend", "docs"],
+    avoidFor: ["planning", "security"],
+    costTier: "budget",
+    speedTier: "fast"
+  },
+  // ── Google ──
+  {
+    provider: "google",
+    pattern: /gemini-(?:2\.5|3)/i,
+    family: "Gemini 2.5 / 3",
+    strengths: ["long context", "multi-modal", "coding", "reasoning"],
+    bestFor: ["coding", "planning", "data", "general"],
+    costTier: "standard",
+    speedTier: "normal"
+  },
+  {
+    provider: "google",
+    pattern: /gemini-2\.0-flash|gemini-flash/i,
+    family: "Gemini Flash",
+    strengths: ["speed", "low cost", "long context"],
+    weaknesses: ["deep reasoning"],
+    bestFor: ["lightweight", "docs", "frontend", "data"],
+    avoidFor: ["planning", "security"],
+    costTier: "budget",
+    speedTier: "fast"
+  },
+  // ── DeepSeek ──
+  {
+    provider: "deepseek",
+    pattern: /deepseek-v3|deepseek-r1/i,
+    family: "DeepSeek V3 / R1",
+    strengths: ["coding", "math", "reasoning", "cost-effective"],
+    bestFor: ["coding", "refactoring", "debugging", "general"],
+    costTier: "standard",
+    speedTier: "normal"
+  },
+  // ── OpenRouter / catch-all ──
+  {
+    provider: "openrouter",
+    pattern: /.*/,
+    family: "OpenRouter (routed)",
+    strengths: ["model variety", "fallback"],
+    bestFor: ["general"],
+    costTier: "standard",
+    speedTier: "normal"
+  }
+];
+var TASK_TO_ROLE = {
+  coding: ["executor", "architect", "bug-hunter"],
+  planning: ["planner", "architect", "refactor-planner"],
+  security: ["security-scanner", "security-reviewer"],
+  docs: ["document", "simplifier"],
+  testing: ["test", "e2e"],
+  refactoring: ["refactor-planner", "refactor", "simplifier"],
+  debugging: ["debugger", "bug-hunter", "tracer"],
+  data: ["analyst", "data", "database"],
+  frontend: ["frontend", "designer"],
+  backend: ["backend", "api", "auth"],
+  review: ["code-reviewer", "critic"],
+  lightweight: ["executor", "simplifier"],
+  general: ["executor", "analyst"]
+};
+function inferTaskType(description, role) {
+  const d = description.toLowerCase();
+  const keywords = [
+    [/plan|architect|design|strategy|blueprint|system\s*design/i, "planning"],
+    [/security|vuln|exploit|injection|auth/i, "security"],
+    [/doc|readme|explain|write\s*(a|the)\s*doc|tutorial/i, "docs"],
+    [/test|spec|assert|mock|coverage/i, "testing"],
+    [/refactor|clean\s*up|restructure|simplify/i, "refactoring"],
+    [/bug|fix|debug|trace|crash|error/i, "debugging"],
+    [/data|json|sql|query|analyze|parse/i, "data"],
+    [/frontend|react|ui|css|component|jsx/i, "frontend"],
+    [/backend|api|server|endpoint|route|middleware/i, "backend"],
+    [/review|audit|inspect|check/i, "review"],
+    [/simple|quick|one-liner|trivial/i, "lightweight"]
+  ];
+  for (const [re, taskType] of keywords) {
+    if (re.test(d)) return taskType;
+  }
+  if (role) {
+    for (const [taskType, roles] of Object.entries(TASK_TO_ROLE)) {
+      if (roles.includes(role)) return taskType;
+    }
+  }
+  return "general";
+}
+function findModelProfile(provider, modelId) {
+  const candidates = MODEL_PROFILES.filter((p) => p.provider === provider);
+  for (const p of candidates) {
+    if (p.pattern.test(modelId)) return p;
+  }
+  return void 0;
+}
+function scoreModelForTask(profile, taskType) {
+  if (!profile) return 50;
+  if (profile.avoidFor?.includes(taskType)) return 10;
+  const bestIdx = profile.bestFor.indexOf(taskType);
+  if (bestIdx >= 0) {
+    return 90 - bestIdx * 10;
+  }
+  let score = 50;
+  if (taskType === "lightweight") {
+    score += profile.costTier === "budget" ? 30 : profile.costTier === "standard" ? 15 : 0;
+    score += profile.speedTier === "fast" ? 20 : 0;
+  }
+  if (taskType === "planning" || taskType === "security") {
+    score += profile.costTier === "premium" ? 20 : 0;
+    score += profile.speedTier === "slow" ? 10 : 0;
+  }
+  return score;
+}
+
+// src/models/model-router.ts
+var DEFAULT_PROFILES = [
+  { provider: "anthropic", pattern: /claude-opus/i, family: "Claude Opus", strengths: ["reasoning", "planning"], bestFor: ["planning", "security", "debugging"], costTier: "premium", speedTier: "slow" },
+  { provider: "anthropic", pattern: /claude-sonnet/i, family: "Claude Sonnet", strengths: ["coding", "balanced"], bestFor: ["coding", "general"], costTier: "standard", speedTier: "fast" },
+  { provider: "anthropic", pattern: /claude-haiku/i, family: "Claude Haiku", strengths: ["speed"], bestFor: ["lightweight", "docs"], avoidFor: ["planning"], costTier: "budget", speedTier: "fast" },
+  { provider: "openai", pattern: /gpt-5|o3|o4/i, family: "GPT-5/o3/o4", strengths: ["reasoning", "coding"], bestFor: ["planning", "coding", "debugging"], costTier: "premium", speedTier: "normal" },
+  { provider: "openai", pattern: /gpt-4/i, family: "GPT-4", strengths: ["coding"], bestFor: ["coding", "docs"], costTier: "standard", speedTier: "fast" },
+  { provider: "openai", pattern: /gpt-4o-mini/i, family: "GPT-4o Mini", strengths: ["speed"], bestFor: ["lightweight", "docs"], avoidFor: ["planning"], costTier: "budget", speedTier: "fast" },
+  { provider: "google", pattern: /gemini-(?:2\.5|3)/i, family: "Gemini 2.5/3", strengths: ["context", "coding"], bestFor: ["coding", "data"], costTier: "standard", speedTier: "normal" },
+  { provider: "google", pattern: /gemini.*flash/i, family: "Gemini Flash", strengths: ["speed"], bestFor: ["lightweight", "docs"], avoidFor: ["planning"], costTier: "budget", speedTier: "fast" },
+  { provider: "deepseek", pattern: /deepseek/i, family: "DeepSeek", strengths: ["coding", "cost-effective"], bestFor: ["coding", "general"], costTier: "standard", speedTier: "normal" }
+];
+var TASK_CATEGORIES = {
+  plan: "planning",
+  architect: "planning",
+  design: "planning",
+  strategy: "planning",
+  security: "security",
+  vuln: "security",
+  exploit: "security",
+  auth: "security",
+  doc: "docs",
+  readme: "docs",
+  explain: "docs",
+  write: "docs",
+  test: "testing",
+  spec: "testing",
+  assert: "testing",
+  coverage: "testing",
+  refactor: "refactoring",
+  cleanup: "refactoring",
+  restructure: "refactoring",
+  bug: "debugging",
+  fix: "debugging",
+  debug: "debugging",
+  trace: "debugging",
+  crash: "debugging",
+  data: "data",
+  json: "data",
+  sql: "data",
+  query: "data",
+  analyze: "data",
+  parse: "data",
+  frontend: "frontend",
+  react: "frontend",
+  ui: "frontend",
+  css: "frontend",
+  component: "frontend",
+  backend: "backend",
+  api: "backend",
+  server: "backend",
+  endpoint: "backend",
+  review: "review",
+  audit: "review",
+  inspect: "review",
+  simple: "lightweight",
+  quick: "lightweight",
+  trivial: "lightweight"
+};
+var ModelRouter = class {
+  profiles;
+  matrix;
+  config;
+  costs = { byModel: {}, totalCost: 0 };
+  constructor(opts) {
+    this.profiles = opts.profiles ?? DEFAULT_PROFILES;
+    this.matrix = opts.matrix ?? {};
+    this.config = opts.config;
+  }
+  /** Look up the model matrix resolution for a role (role → phase → * → leader). */
+  resolveMatrix(role) {
+    if (this.matrix[role]) return this.matrix[role];
+    const phase = this.roleToPhase(role);
+    if (phase && this.matrix[phase]) return this.matrix[phase];
+    if (this.matrix["*"]) return this.matrix["*"];
+    return void 0;
+  }
+  /** Simplified phase lookup for common roles. */
+  roleToPhase(role) {
+    const phaseMap = {
+      planner: "plan",
+      architect: "plan",
+      "refactor-planner": "plan",
+      executor: "code",
+      refactor: "code",
+      simplifier: "code",
+      migration: "code",
+      "bug-hunter": "code",
+      debugger: "code",
+      tracer: "code",
+      test: "code",
+      e2e: "code",
+      performance: "code",
+      chaos: "code",
+      "security-scanner": "review",
+      "security-reviewer": "review",
+      "code-reviewer": "review",
+      critic: "review",
+      accessibility: "review",
+      compliance: "review",
+      analyst: "code",
+      data: "code",
+      database: "code",
+      frontend: "code",
+      backend: "code",
+      api: "code",
+      auth: "code",
+      designer: "code",
+      document: "code",
+      researcher: "plan",
+      explore: "plan",
+      search: "plan"
+    };
+    return phaseMap[role];
+  }
+  /**
+   * Pick the best model for a task.
+   *
+   * Priority:
+   *   1. User's /setmodel matrix entry for this role (explicit override)
+   *   2. Best-matching model from intelligence profiles
+   *   3. Leader model (fallback)
+   */
+  pickForTask(role, description) {
+    const matrixEntry = this.resolveMatrix(role);
+    if (matrixEntry) {
+      const provider = matrixEntry.provider ?? this.config.provider;
+      return {
+        provider,
+        model: matrixEntry.model,
+        reason: `matrix override for role ${role}`,
+        fromMatrix: true
+      };
+    }
+    const category = this.inferCategory(description, role);
+    const best = this.findBestModel(category);
+    if (best) {
+      return { ...best, reason: `best-for ${category} (auto-detected)`, fromMatrix: false };
+    }
+    return {
+      provider: this.config.provider,
+      model: this.config.model,
+      reason: "leader fallback",
+      fromMatrix: false
+    };
+  }
+  /** Infer task category from description keywords + role. */
+  inferCategory(description, role) {
+    const d = description.toLowerCase();
+    for (const [keyword, category] of Object.entries(TASK_CATEGORIES)) {
+      if (d.includes(keyword)) return category;
+    }
+    const roleMap = {
+      "security-scanner": "security",
+      "security-reviewer": "security",
+      "bug-hunter": "debugging",
+      debugger: "debugging",
+      planner: "planning",
+      architect: "planning",
+      "refactor-planner": "refactoring",
+      refactor: "refactoring",
+      test: "testing",
+      e2e: "testing",
+      document: "docs",
+      simplifier: "docs",
+      "code-reviewer": "review",
+      critic: "review",
+      "frontend": "frontend",
+      "backend": "backend"
+    };
+    return roleMap[role] ?? "general";
+  }
+  /** Find the best available model for a task category. */
+  findBestModel(category) {
+    const scored = this.profiles.filter((p) => this.hasKey(p.provider)).map((p) => {
+      let score = 50;
+      if (p.bestFor.includes(category)) score += 40;
+      if (p.avoidFor?.includes(category)) score -= 50;
+      if (category === "lightweight" && p.costTier === "budget") score += 20;
+      if (category === "planning" && p.costTier === "premium") score += 15;
+      if (category === "planning" && p.speedTier === "slow") score += 10;
+      return { profile: p, score };
+    }).filter((s) => s.score > 0).sort((a, b) => b.score - a.score);
+    if (scored.length === 0) return void 0;
+    const best = scored[0]?.profile;
+    if (!best) return void 0;
+    const models = this.getProviderModels(best.provider);
+    const match = models.find((m) => best.pattern.test(m)) ?? models[0];
+    if (!match) return void 0;
+    return { provider: best.provider, model: match };
+  }
+  /** Check if a provider has an API key configured. */
+  hasKey(providerId) {
+    const pc = this.config.providers?.[providerId];
+    if (!pc) return providerId === this.config.provider;
+    if (typeof pc.apiKey === "string" && pc.apiKey.length > 0) return true;
+    if (Array.isArray(pc.apiKeys) && pc.apiKeys.some((k) => k?.apiKey)) return true;
+    return false;
+  }
+  /** Get the configured model list for a provider. */
+  getProviderModels(providerId) {
+    const pc = this.config.providers?.[providerId];
+    return pc?.models ?? [];
+  }
+  /** Record cost for a model. */
+  recordCost(provider, model, cost, tokens) {
+    const key = `${provider}/${model}`;
+    const entry = this.costs.byModel[key] ?? { cost: 0, tokens: { input: 0, output: 0 }, calls: 0 };
+    entry.cost += cost;
+    if (tokens) {
+      entry.tokens.input += tokens.input;
+      entry.tokens.output += tokens.output;
+    }
+    entry.calls += 1;
+    this.costs.byModel[key] = entry;
+    this.costs.totalCost += cost;
+  }
+  /** Get cumulative costs. */
+  getCosts() {
+    return { ...this.costs, byModel: { ...this.costs.byModel } };
+  }
+  /** Reset cost tracking. */
+  resetCosts() {
+    this.costs = { byModel: {}, totalCost: 0 };
+  }
+  /** List all available providers with their best model for each task category. */
+  suggestMatrix() {
+    const matrix = {};
+    const roles = [
+      "security-scanner",
+      "bug-hunter",
+      "planner",
+      "architect",
+      "refactor-planner",
+      "test",
+      "document",
+      "code-reviewer",
+      "executor",
+      "debugger",
+      "analyst"
+    ];
+    for (const role of roles) {
+      if (this.matrix[role]) continue;
+      const pick = this.pickForTask(role, role);
+      if (!pick.fromMatrix) {
+        matrix[role] = pick;
+      }
+    }
+    return matrix;
+  }
+};
+
+export { DefaultModeStore, DefaultModelsRegistry, LLMSelector, MODEL_PROFILES, ModelRouter, TASK_TO_ROLE, classifyFamily, findModelProfile, inferTaskType, loadProjectModes, loadUserModes, scoreModelForTask };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map