wispy-cli 2.7.13 → 2.7.15

package/core/budget.mjs

@@ -0,0 +1,277 @@
+/**
+ * core/budget.mjs — API Spending Tracker for Wispy
+ *
+ * Tracks API costs per session and across sessions.
+ * Persisted to ~/.wispy/budget.json
+ *
+ * Usage:
+ *   const budget = new BudgetManager({ maxBudgetUsd: 5.00 });
+ *   budget.record(1000, 500, "gpt-4o");
+ *   const check = budget.checkBudget();
+ *   // { ok: true, remaining: 4.98, spent: 0.02 }
+ */
+
+import os from "node:os";
+import path from "node:path";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+
+// ── Model pricing (approximate, USD per 1M tokens) ────────────────────────────
+
+export const MODEL_PRICING = {
+  // OpenAI
+  "gpt-4o":                       { input: 2.50,  output: 10.00 },
+  "gpt-4o-mini":                  { input: 0.15,  output: 0.60  },
+  "gpt-4-turbo":                  { input: 10.00, output: 30.00 },
+  "gpt-4":                        { input: 30.00, output: 60.00 },
+  "o1":                           { input: 15.00, output: 60.00 },
+  "o1-mini":                      { input: 3.00,  output: 12.00 },
+  "o3":                           { input: 10.00, output: 40.00 },
+  "o3-mini":                      { input: 1.10,  output: 4.40  },
+  "o4-mini":                      { input: 1.10,  output: 4.40  },
+
+  // Anthropic
+  "claude-opus-4-20250514":       { input: 15.00, output: 75.00 },
+  "claude-sonnet-4-20250514":     { input: 3.00,  output: 15.00 },
+  "claude-3-5-sonnet-20241022":   { input: 3.00,  output: 15.00 },
+  "claude-3-5-haiku-20241022":    { input: 0.80,  output: 4.00  },
+  "claude-3-opus-20240229":       { input: 15.00, output: 75.00 },
+
+  // Google
+  "gemini-2.5-pro":               { input: 1.25,  output: 10.00 },
+  "gemini-2.5-flash":             { input: 0.075, output: 0.30  },
+  "gemini-2.0-flash":             { input: 0.075, output: 0.30  },
+  "gemini-1.5-pro":               { input: 1.25,  output: 5.00  },
+  "gemini-1.5-flash":             { input: 0.075, output: 0.30  },
+
+  // DeepSeek
+  "deepseek-chat":                { input: 0.14,  output: 0.28  },
+  "deepseek-coder":               { input: 0.14,  output: 0.28  },
+  "deepseek-reasoner":            { input: 0.55,  output: 2.19  },
+
+  // Groq (free for now, but tracking usage)
+  "llama-3.3-70b-versatile":      { input: 0,     output: 0     },
+  "llama-3.1-8b-instant":         { input: 0,     output: 0     },
+  "mixtral-8x7b-32768":           { input: 0,     output: 0     },
+  "gemma2-9b-it":                 { input: 0,     output: 0     },
+
+  // Mistral
+  "mistral-large-latest":         { input: 2.00,  output: 6.00  },
+  "mistral-small-latest":         { input: 0.20,  output: 0.60  },
+  "codestral-latest":             { input: 1.00,  output: 3.00  },
+
+  // xAI
+  "grok-3":                       { input: 3.00,  output: 15.00 },
+  "grok-3-mini":                  { input: 0.30,  output: 0.50  },
+};
+
+// ── BudgetManager ─────────────────────────────────────────────────────────────
+
+export class BudgetManager {
+  /**
+   * @param {object} options
+   * @param {number|null} options.maxBudgetUsd - Max budget for this session (null = unlimited)
+   * @param {string} options.budgetPath - Path to persist budget.json
+   */
+  constructor(options = {}) {
+    this.maxBudgetUsd = options.maxBudgetUsd ?? null;
+    this.sessionSpend = 0;       // USD spent this session
+    this.sessionInputTokens = 0;
+    this.sessionOutputTokens = 0;
+    this.sessionCalls = 0;
+    this.totalSpend = 0;         // loaded from disk
+    this.totalInputTokens = 0;
+    this.totalOutputTokens = 0;
+    this.totalCalls = 0;
+    this._budgetPath = options.budgetPath ?? path.join(os.homedir(), ".wispy", "budget.json");
+    this._loaded = false;
+  }
+
+  /**
+   * Load persisted budget data from disk (lazy).
+   */
+  async _ensureLoaded() {
+    if (this._loaded) return;
+    this._loaded = true;
+    try {
+      const raw = await readFile(this._budgetPath, "utf8");
+      const data = JSON.parse(raw);
+      this.totalSpend = data.totalSpend ?? 0;
+      this.totalInputTokens = data.totalInputTokens ?? 0;
+      this.totalOutputTokens = data.totalOutputTokens ?? 0;
+      this.totalCalls = data.totalCalls ?? 0;
+    } catch {
+      // File doesn't exist yet — start fresh
+    }
+  }
+
+  /**
+   * Persist total spend to disk.
+   */
+  async _persist() {
+    try {
+      await mkdir(path.dirname(this._budgetPath), { recursive: true });
+      await writeFile(
+        this._budgetPath,
+        JSON.stringify({
+          totalSpend: this.totalSpend,
+          totalInputTokens: this.totalInputTokens,
+          totalOutputTokens: this.totalOutputTokens,
+          totalCalls: this.totalCalls,
+          updatedAt: new Date().toISOString(),
+        }, null, 2) + "\n",
+        "utf8",
+      );
+    } catch { /* ignore write errors */ }
+  }
+
+  /**
+   * Get pricing for a model. Returns { input, output } in USD/1M tokens.
+   * Returns { input: 0, output: 0 } for unknown models (assume free/included).
+   * @param {string} model
+   */
+  getPricing(model) {
+    if (!model) return { input: 0, output: 0 };
+    // Exact match
+    if (MODEL_PRICING[model]) return MODEL_PRICING[model];
+    // Prefix match (e.g., "claude-sonnet-4" matches "claude-sonnet-4-20250514")
+    for (const [key, price] of Object.entries(MODEL_PRICING)) {
+      if (model.startsWith(key) || key.startsWith(model)) return price;
+    }
+    return { input: 0, output: 0 };
+  }
+
+  /**
+   * Estimate cost of an API call without recording it.
+   * @param {number} inputTokens
+   * @param {number} outputTokens
+   * @param {string} model
+   * @returns {number} Estimated cost in USD
+   */
+  estimateCost(inputTokens, outputTokens, model) {
+    const pricing = this.getPricing(model);
+    const inputCost = (inputTokens / 1_000_000) * pricing.input;
+    const outputCost = (outputTokens / 1_000_000) * pricing.output;
+    return inputCost + outputCost;
+  }
+
+  /**
+   * Record actual API usage after a call.
+   * @param {number} inputTokens
+   * @param {number} outputTokens
+   * @param {string} model
+   * @returns {number} Cost of this call in USD
+   */
+  async record(inputTokens, outputTokens, model) {
+    await this._ensureLoaded();
+
+    const cost = this.estimateCost(inputTokens || 0, outputTokens || 0, model);
+
+    this.sessionSpend += cost;
+    this.sessionInputTokens += inputTokens || 0;
+    this.sessionOutputTokens += outputTokens || 0;
+    this.sessionCalls++;
+
+    this.totalSpend += cost;
+    this.totalInputTokens += inputTokens || 0;
+    this.totalOutputTokens += outputTokens || 0;
+    this.totalCalls++;
+
+    // Persist async (don't await — non-blocking)
+    this._persist().catch(() => {});
+
+    return cost;
+  }
+
+  /**
+   * Check whether the current session is within budget.
+   * @returns {{ ok: boolean, remaining: number|null, spent: number }}
+   */
+  checkBudget() {
+    if (this.maxBudgetUsd === null) {
+      return { ok: true, remaining: null, spent: this.sessionSpend };
+    }
+    const remaining = this.maxBudgetUsd - this.sessionSpend;
+    return {
+      ok: remaining >= 0,
+      remaining,
+      spent: this.sessionSpend,
+      limit: this.maxBudgetUsd,
+    };
+  }
+
+  /**
+   * Get a spending report.
+   * @returns {object}
+   */
+  async getReport() {
+    await this._ensureLoaded();
+    return {
+      session: {
+        spend: this.sessionSpend,
+        inputTokens: this.sessionInputTokens,
+        outputTokens: this.sessionOutputTokens,
+        calls: this.sessionCalls,
+        limit: this.maxBudgetUsd,
+        remaining: this.maxBudgetUsd !== null ? this.maxBudgetUsd - this.sessionSpend : null,
+      },
+      total: {
+        spend: this.totalSpend,
+        inputTokens: this.totalInputTokens,
+        outputTokens: this.totalOutputTokens,
+        calls: this.totalCalls,
+      },
+    };
+  }
+
+  /**
+   * Format a spending report for CLI display.
+   */
+  async formatReport() {
+    const report = await this.getReport();
+    const fmt = (n) => `$${n.toFixed(4)}`;
+    const fmtTokens = (n) => n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
+
+    const lines = ["\n  💰 Wispy Spending Report\n"];
+
+    lines.push("  This session:");
+    lines.push(`    Spent:    ${fmt(report.session.spend)}`);
+    if (report.session.limit !== null) {
+      const pct = ((report.session.spend / report.session.limit) * 100).toFixed(1);
+      const bar = this._progressBar(report.session.spend, report.session.limit, 20);
+      lines.push(`    Budget:   ${fmt(report.session.spend)} / ${fmt(report.session.limit)}  [${bar}] ${pct}%`);
+      lines.push(`    Remaining: ${fmt(Math.max(0, report.session.remaining))}`);
+    }
+    lines.push(`    Tokens:   ${fmtTokens(report.session.inputTokens)} in + ${fmtTokens(report.session.outputTokens)} out`);
+    lines.push(`    API calls: ${report.session.calls}`);
+
+    lines.push("\n  All time:");
+    lines.push(`    Spent:    ${fmt(report.total.spend)}`);
+    lines.push(`    Tokens:   ${fmtTokens(report.total.inputTokens)} in + ${fmtTokens(report.total.outputTokens)} out`);
+    lines.push(`    API calls: ${report.total.calls}`);
+    lines.push("");
+
+    return lines.join("\n");
+  }
+
+  _progressBar(value, max, width = 20) {
+    if (max <= 0) return " ".repeat(width);
+    const filled = Math.min(width, Math.round((value / max) * width));
+    const color = filled > width * 0.8 ? "\x1b[31m" : filled > width * 0.5 ? "\x1b[33m" : "\x1b[32m";
+    return `${color}${"█".repeat(filled)}\x1b[0m${"░".repeat(width - filled)}`;
+  }
+
+  /**
+   * Format a budget exceeded warning.
+   */
+  formatExceededWarning() {
+    const check = this.checkBudget();
+    return [
+      "",
+      "  \x1b[31m⛔ Budget limit reached!\x1b[0m",
+      `  Spent: $${this.sessionSpend.toFixed(4)} / $${this.maxBudgetUsd.toFixed(4)} limit`,
+      `  Session ended to prevent overspending.`,
+      `  Use --max-budget-usd to set a higher limit, or run without it for unlimited.`,
+      "",
+    ].join("\n");
+  }
+}

package/core/engine.mjs

@@ -15,6 +15,7 @@ import path from "node:path";
 import { readFile, writeFile, mkdir, appendFile, stat as fsStat } from "node:fs/promises";
 
 import { WISPY_DIR, CONVERSATIONS_DIR, MEMORY_DIR, MCP_CONFIG_PATH, detectProvider, PROVIDERS } from "./config.mjs";
+import { findProjectSettings, mergeSettings } from "./project-settings.mjs";
 import { NullEmitter } from "../lib/jsonl-emitter.mjs";
 
 /**
@@ -44,6 +45,33 @@ import { routeTask, classifyTask, filterAvailableModels } from "./task-router.mj
 import { decomposeTask, executeDecomposedPlan } from "./task-decomposer.mjs";
 import { BrowserBridge } from "./browser.mjs";
 import { LoopDetector } from "./loop-detector.mjs";
+import { AgentManager } from "./agents.mjs";
+import { BudgetManager } from "./budget.mjs";
+
+// ── Effort levels ──────────────────────────────────────────────────────────────
+
+export const EFFORT_LEVELS = {
+  low: {
+    maxRounds: 5,
+    maxTokens: 2000,
+    systemSuffix: "Be extremely brief. One-shot answers preferred. Minimize tool use.",
+  },
+  medium: {
+    maxRounds: 15,
+    maxTokens: 4000,
+    systemSuffix: "", // default behavior
+  },
+  high: {
+    maxRounds: 30,
+    maxTokens: 8000,
+    systemSuffix: "Be thorough. Explore multiple approaches. Verify your work.",
+  },
+  max: {
+    maxRounds: 50,
+    maxTokens: 16000,
+    systemSuffix: "Be exhaustive. Leave no stone unturned. Multiple verification passes. Consider edge cases.",
+  },
+};
 
 const MAX_TOOL_ROUNDS = 10;
 const MAX_CONTEXT_CHARS = 40_000;
@@ -74,6 +102,15 @@ export class WispyEngine {
       ?? "default";
     // Personality: from config, or null (use default Wispy personality)
     this._personality = config.personality ?? null;
+    // Agent manager
+    this.agentManager = new AgentManager(config);
+    // Effort level: low | medium | high | max
+    this._effort = config.effort ?? process.env.WISPY_EFFORT ?? "medium";
+    // Budget manager
+    this.budget = new BudgetManager({
+      maxBudgetUsd: config.maxBudgetUsd ?? null,
+      budgetPath: config.budgetPath,
+    });
   }
 
   get activeWorkstream() { return this._activeWorkstream; }
@@ -168,13 +205,25 @@ export class WispyEngine {
       if (sessionId) {
         session = this.sessions.get(sessionId) ?? await this.sessions.load(sessionId);
         if (!session) {
-          session = this.sessions.create({ workstream: opts.workstream ?? this._activeWorkstream });
+          session = this.sessions.create({
+            workstream: opts.workstream ?? this._activeWorkstream,
+            name: opts.sessionName ?? null,
+          });
+        } else if (opts.sessionName && !session.name) {
+          // Set name on existing session if not already named
+          session.name = opts.sessionName;
         }
       } else {
-        session = this.sessions.create({ workstream: opts.workstream ?? this._activeWorkstream });
+        session = this.sessions.create({
+          workstream: opts.workstream ?? this._activeWorkstream,
+          name: opts.sessionName ?? null,
+        });
       }
     } catch (err) {
-      session = this.sessions.create({ workstream: opts.workstream ?? this._activeWorkstream });
+      session = this.sessions.create({
+        workstream: opts.workstream ?? this._activeWorkstream,
+        name: opts.sessionName ?? null,
+      });
     }
 
     // JSONL emitter (no-op by default)
@@ -192,10 +241,44 @@ export class WispyEngine {
     // Resolve personality for this call
     const personality = opts.personality ?? this._personality ?? null;
 
+    // Resolve effort level for this call
+    const effort = opts.effort ?? this._effort ?? "medium";
+    const effortConfig = EFFORT_LEVELS[effort] ?? EFFORT_LEVELS.medium;
+
+    // Resolve agent for this call
+    const agentName = opts.agent ?? null;
+    const agentDef = agentName ? this.agentManager.get(agentName) : null;
+    if (agentName && !agentDef) {
+      return {
+        role: "assistant",
+        content: `⚠️ Unknown agent: "${agentName}". Run \`wispy agents\` to list available agents.`,
+        sessionId: session.id,
+        error: "UNKNOWN_AGENT",
+      };
+    }
+
+    // Check budget before processing
+    const budgetCheck = this.budget.checkBudget();
+    if (!budgetCheck.ok) {
+      return {
+        role: "assistant",
+        content: this.budget.formatExceededWarning(),
+        sessionId: session.id,
+        error: "BUDGET_EXCEEDED",
+      };
+    }
+
     // Build messages array for the provider
+    // opts.systemPrompt = full override, opts.appendSystemPrompt = append to default
     let systemPrompt;
     try {
-      systemPrompt = opts.systemPrompt ?? await this._buildSystemPrompt(userMessage, { personality });
+      systemPrompt = await this._buildSystemPrompt(userMessage, {
+        personality,
+        agentDef,
+        effortConfig,
+        systemPrompt: opts.systemPrompt ?? null,
+        appendSystemPrompt: opts.appendSystemPrompt ?? null,
+      });
     } catch {
       systemPrompt = "You are Wispy 🌿 — a helpful AI assistant in the terminal.";
     }
@@ -214,8 +297,15 @@ export class WispyEngine {
       }
     }
 
-    // Add user message
-    messages.push({ role: "user", content: userMessage });
+    // Add user message (with optional image attachments)
+    const userMsg = { role: "user", content: userMessage };
+    if (opts.images && opts.images.length > 0) {
+      const imageData = await this._loadImages(opts.images);
+      if (imageData.length > 0) {
+        userMsg.images = imageData;
+      }
+    }
+    messages.push(userMsg);
     this.sessions.addMessage(session.id, { role: "user", content: userMessage });
 
     // Audit: log incoming message
@@ -229,7 +319,7 @@ export class WispyEngine {
     const _startMs = Date.now();
     let responseText;
     try {
-      responseText = await this._agentLoop(messages, session, { ...opts, emitter });
+      responseText = await this._agentLoop(messages, session, { ...opts, emitter, effortConfig, agentDef });
     } catch (err) {
       responseText = this._friendlyError(err);
       emitter.error(err);
@@ -338,7 +428,11 @@ export class WispyEngine {
     const loopDetector = new LoopDetector();
     let loopWarned = false;
 
-    for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+    // Effort level config
+    const effortConfig = opts.effortConfig ?? EFFORT_LEVELS.medium;
+    const maxRounds = effortConfig.maxRounds ?? MAX_TOOL_ROUNDS;
+
+    for (let round = 0; round < maxRounds; round++) {
       // ── Loop detection check before LLM call ─────────────────────────────
       if (loopDetector.size >= 2) {
         const loopCheck = loopDetector.check();
@@ -366,11 +460,25 @@ export class WispyEngine {
         }
       }
 
+      // Use agent model if specified
+      const agentDef = opts.agentDef ?? null;
+      const resolvedModel = agentDef?.model ?? opts.model;
+
       const result = await this.providers.chat(messages, this.tools.getDefinitions(), {
         onChunk: opts.onChunk,
-        model: opts.model,
+        model: resolvedModel,
+        maxTokens: effortConfig.maxTokens,
       });
 
+      // Record spend if usage info available
+      if (result?.usage) {
+        this.budget.record(
+          result.usage.inputTokens ?? result.usage.prompt_tokens ?? 0,
+          result.usage.outputTokens ?? result.usage.completion_tokens ?? 0,
+          resolvedModel ?? this.model,
+        ).catch(() => {});
+      }
+
       if (result.type === "text") {
         return result.text;
       }
@@ -419,7 +527,8 @@ export class WispyEngine {
       }
     }
 
-    return "(tool call limit reached)";
+    const effortName = Object.entries(EFFORT_LEVELS).find(([, v]) => v === effortConfig)?.[0] ?? "medium";
+    return `(tool call limit reached — effort: ${effortName}, max rounds: ${maxRounds})`;
   }
 
   /**
@@ -865,6 +974,52 @@ export class WispyEngine {
 
   async _buildSystemPrompt(lastUserMessage = "", opts = {}) {
     const personality = opts.personality ?? this._personality ?? null;
+    const agentDef = opts.agentDef ?? null;
+    const effortConfig = opts.effortConfig ?? null;
+
+    // Resolve system prompt override with precedence:
+    // opts.systemPrompt (call-level) > this._systemPrompt (engine config) > default
+    // Resolve append with precedence:
+    // opts.appendSystemPrompt (call-level) > this._appendSystemPrompt (engine config) > project settings
+    const systemPromptOverride = opts.systemPrompt ?? this._systemPrompt ?? null;
+    const appendSystemPrompt = opts.appendSystemPrompt ?? this._appendSystemPrompt ?? null;
+
+    // If a full system prompt override is provided (not from agent), use it as-is
+    // then apply appends
+    if (systemPromptOverride && !agentDef?.prompt) {
+      const parts = [systemPromptOverride];
+      if (appendSystemPrompt) {
+        parts.push("\n" + appendSystemPrompt);
+      }
+      if (personality && PERSONALITIES[personality]) {
+        parts.push(`\n## Personality Override (${personality})\n${PERSONALITIES[personality]}`);
+      }
+      if (effortConfig?.systemSuffix) {
+        parts.push("\n## Effort Level\n" + effortConfig.systemSuffix);
+      }
+      return parts.join("");
+    }
+
+    // If an agent with a custom prompt is active, use that as the system prompt base
+    if (agentDef?.prompt) {
+      const parts = [agentDef.prompt];
+      // Append effort suffix if effort is not medium/default
+      if (effortConfig?.systemSuffix) {
+        parts.push("\n" + effortConfig.systemSuffix);
+      }
+      // Append custom system prompt addition if provided
+      if (appendSystemPrompt) {
+        parts.push("\n" + appendSystemPrompt);
+      }
+      // Still inject memories for context
+      try {
+        const memories = await this.memory.getContextForPrompt(lastUserMessage);
+        if (memories) {
+          parts.push("\n## Persistent Memory\n" + memories);
+        }
+      } catch { /* ignore */ }
+      return parts.join("\n");
+    }
 
     const parts = [
       "You are Wispy 🌿 — a small ghost that lives in terminals.",
@@ -872,6 +1027,13 @@ export class WispyEngine {
       "",
     ];
 
+    // Inject effort level modifier if not default (medium)
+    if (effortConfig?.systemSuffix) {
+      parts.push("## Effort Level");
+      parts.push(effortConfig.systemSuffix);
+      parts.push("");
+    }
+
     // Inject personality override if set
     if (personality && PERSONALITIES[personality]) {
       parts.push(`## Personality Override (${personality})`);
@@ -936,6 +1098,11 @@ export class WispyEngine {
       }
     }
 
+    // Append custom system prompt addition (from opts, engine config, or project settings)
+    if (appendSystemPrompt) {
+      parts.push("## Additional Instructions", appendSystemPrompt, "");
+    }
+
     return parts.join("\n");
   }
 
@@ -1525,6 +1692,45 @@ export class WispyEngine {
     }
   }
 
+  // ── Image handling ────────────────────────────────────────────────────────────
+
+  /**
+   * Load images from file paths and return base64-encoded data with MIME types.
+   * @param {string[]} imagePaths - Array of file paths
+   * @returns {Array<{data: string, mimeType: string, path: string}>}
+   */
+  async _loadImages(imagePaths) {
+    const MIME_TYPES = {
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".bmp": "image/bmp",
+      ".svg": "image/svg+xml",
+    };
+
+    const results = [];
+    for (const imgPath of imagePaths) {
+      try {
+        const resolvedPath = path.resolve(imgPath);
+        const ext = path.extname(resolvedPath).toLowerCase();
+        const mimeType = MIME_TYPES[ext] ?? "image/jpeg";
+        const buffer = await readFile(resolvedPath);
+        results.push({
+          data: buffer.toString("base64"),
+          mimeType,
+          path: resolvedPath,
+        });
+      } catch (err) {
+        if (process.env.WISPY_DEBUG) {
+          console.error(`[wispy] Failed to load image ${imgPath}: ${err.message}`);
+        }
+      }
+    }
+    return results;
+  }
+
   // ── Cleanup ──────────────────────────────────────────────────────────────────
 
   destroy() {