wispy-cli 2.7.11 → 2.7.13

package/bin/wispy.mjs

@@ -23,6 +23,47 @@ const rootDir = join(__dirname, "..");
 const args = process.argv.slice(2);
 const command = args[0];
 
+// ── Global flags parsed early ─────────────────────────────────────────────────
+
+/**
+ * Extract a flag value: --flag value or --flag=value
+ * Returns the value string or null if not found.
+ */
+function extractFlag(flagNames, removeFromArgs = false) {
+  for (const flag of Array.isArray(flagNames) ? flagNames : [flagNames]) {
+    const idx = args.indexOf(flag);
+    if (idx !== -1 && idx + 1 < args.length) {
+      const value = args[idx + 1];
+      if (removeFromArgs) { args.splice(idx, 2); }
+      return value;
+    }
+    // --flag=value form
+    const prefix = flag + "=";
+    const eqIdx = args.findIndex(a => a.startsWith(prefix));
+    if (eqIdx !== -1) {
+      const value = args[eqIdx].slice(prefix.length);
+      if (removeFromArgs) { args.splice(eqIdx, 1); }
+      return value;
+    }
+  }
+  return null;
+}
+
+/** Returns true if a boolean flag is present. */
+function hasFlag(flag) {
+  return args.includes(flag);
+}
+
+// Parse global flags (order doesn't matter, remove from args so REPL doesn't see them)
+const globalProfile = extractFlag(["--profile", "-p"], true);
+const globalPersonality = extractFlag(["--personality"], true);
+const globalJsonMode = hasFlag("--json");
+if (globalJsonMode) { args.splice(args.indexOf("--json"), 1); }
+
+// Expose for submodules via env
+if (globalProfile) process.env.WISPY_PROFILE = globalProfile;
+if (globalPersonality) process.env.WISPY_PERSONALITY = globalPersonality;
+
 // ── Flags ─────────────────────────────────────────────────────────────────────
 
 if (args.includes("--version") || command === "--version" || command === "-v") {
@@ -44,9 +85,12 @@ AI workspace assistant — chat, automate, and orchestrate from the terminal.
 Usage:
   wispy                        Start interactive REPL
   wispy <message>              One-shot chat
+  wispy exec <message>         Non-interactive one-shot (CI/pipeline friendly)
   wispy setup                  Run first-time setup wizard
   wispy config [show|get|set|delete|reset|path|edit]
                                Manage configuration
+  wispy features [list|enable|disable]
+                               Manage feature flags
   wispy model                  Show or change AI model
   wispy doctor                 Check system health
   wispy browser [tabs|attach|navigate|screenshot|doctor]
@@ -69,9 +113,12 @@ Usage:
 
 Options:
   -w, --workstream <name>      Set active workstream
+  -p, --profile <name>         Use a named config profile
   --session <id>               Resume a session
   --model <name>               Override AI model
   --provider <name>            Override AI provider
+  --personality <name>         Set personality (pragmatic|concise|explanatory|friendly|strict)
+  --json                       Output JSONL events (for exec command, CI/pipeline use)
   --help, -h                   Show this help
   --version, -v                Show version
 `);
@@ -529,6 +576,131 @@ if (command === "improve") {
   process.exit(0);
 }
 
+// ── Features ──────────────────────────────────────────────────────────────────
+
+if (command === "features") {
+  try {
+    const { FeatureManager } = await import(join(rootDir, "core/features.mjs"));
+    const fm = new FeatureManager();
+    const sub = args[1];
+
+    if (!sub || sub === "list") {
+      const features = await fm.list();
+      const stageOrder = { stable: 0, experimental: 1, development: 2 };
+      features.sort((a, b) => (stageOrder[a.stage] ?? 9) - (stageOrder[b.stage] ?? 9) || a.name.localeCompare(b.name));
+
+      const stageLabel = { stable: "stable", experimental: "experimental", development: "development" };
+      const stageColors = { stable: "\x1b[32m", experimental: "\x1b[33m", development: "\x1b[31m" };
+      const reset = "\x1b[0m";
+      const dim = "\x1b[2m";
+
+      console.log(`\n  Feature Flags (${features.length})\n`);
+      let lastStage = null;
+      for (const f of features) {
+        if (f.stage !== lastStage) {
+          console.log(`  ${stageColors[f.stage] ?? ""}── ${f.stage} ──${reset}`);
+          lastStage = f.stage;
+        }
+        const status = f.enabled ? "\x1b[32m✓ on \x1b[0m" : "\x1b[2m✗ off\x1b[0m";
+        const changed = f.enabled !== f.default ? " \x1b[33m(overridden)\x1b[0m" : "";
+        console.log(`  ${status}  ${f.name.padEnd(25)} ${dim}${f.description}${reset}${changed}`);
+      }
+      console.log("");
+      console.log(`  ${dim}Use: wispy features enable <name> / wispy features disable <name>${reset}\n`);
+    } else if (sub === "enable") {
+      const name = args[2];
+      if (!name) { console.error("Usage: wispy features enable <name>"); process.exit(1); }
+      const result = await fm.enable(name);
+      console.log(`  ✓ Feature "${name}" enabled.`);
+    } else if (sub === "disable") {
+      const name = args[2];
+      if (!name) { console.error("Usage: wispy features disable <name>"); process.exit(1); }
+      const result = await fm.disable(name);
+      console.log(`  ✓ Feature "${name}" disabled.`);
+    } else {
+      console.error(`Unknown subcommand: ${sub}`);
+      console.log("Available: list, enable <name>, disable <name>");
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error("Features error:", err.message);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+// ── Exec (non-interactive one-shot with optional JSONL output) ────────────────
+
+if (command === "exec") {
+  try {
+    // Message is everything after "exec" and any flags
+    const messageArgs = args.slice(1).filter(a => !a.startsWith("--") && !a.startsWith("-p"));
+    const message = messageArgs.join(" ").trim();
+
+    if (!message) {
+      console.error("Usage: wispy exec <message> [--json] [--profile <name>] [--personality <name>]");
+      process.exit(1);
+    }
+
+    // Load config (with optional profile)
+    const { loadConfigWithProfile } = await import(join(rootDir, "core/config.mjs"));
+    const { WispyEngine } = await import(join(rootDir, "core/engine.mjs"));
+    const { createEmitter } = await import(join(rootDir, "lib/jsonl-emitter.mjs"));
+
+    const profileName = globalProfile;
+    const profileConfig = await loadConfigWithProfile(profileName);
+
+    // Apply config overrides from profile
+    if (profileConfig.provider) process.env.WISPY_PROVIDER = process.env.WISPY_PROVIDER || profileConfig.provider;
+    if (profileConfig.model)    process.env.WISPY_MODEL = process.env.WISPY_MODEL || profileConfig.model;
+
+    const personality = globalPersonality || profileConfig.personality || null;
+
+    const engine = new WispyEngine({
+      personality,
+      workstream: process.env.WISPY_WORKSTREAM ?? "default",
+    });
+
+    const initResult = await engine.init({ skipMcp: false });
+    if (!initResult) {
+      if (globalJsonMode) {
+        const emitter = createEmitter(true);
+        emitter.error(new Error("No AI provider configured"));
+        emitter.done({ tokens: {}, duration_ms: 0 });
+      } else {
+        console.error("⚠️  No AI provider configured. Run `wispy setup` or set an API key.");
+      }
+      process.exit(1);
+    }
+
+    const emitter = createEmitter(globalJsonMode);
+
+    const result = await engine.processMessage(null, message, {
+      emitter,
+      personality,
+      skipSkillCapture: true,
+      skipUserModel: true,
+    });
+
+    if (!globalJsonMode) {
+      // Normal output: just print the assistant response
+      console.log(result.content);
+    }
+    // In JSON mode, everything was already emitted via the emitter
+  } catch (err) {
+    if (globalJsonMode) {
+      const { createEmitter } = await import(join(rootDir, "lib/jsonl-emitter.mjs"));
+      const emitter = createEmitter(true);
+      emitter.error(err);
+      emitter.done({ tokens: {}, duration_ms: 0 });
+    } else {
+      console.error("Exec error:", err.message);
+    }
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
 // ── Continuity ────────────────────────────────────────────────────────────────
 
 if (command === "where") {

package/core/config.mjs

@@ -133,6 +133,40 @@ export async function saveConfig(config) {
   await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf8");
 }
 
+/**
+ * Load config with a named profile merged on top.
+ * Profile keys override base config keys, but unset keys remain from base.
+ * The "profiles" map itself is stripped from the merged result.
+ *
+ * @param {string|null} profileName - Profile name to apply, or null for base config
+ * @returns {Promise<object>} Merged configuration object
+ */
+export async function loadConfigWithProfile(profileName) {
+  const config = await loadConfig();
+  if (!profileName) return config;
+
+  const profiles = config.profiles ?? {};
+  const profile = profiles[profileName];
+
+  if (!profile) {
+    throw new Error(`Profile "${profileName}" not found. Available profiles: ${Object.keys(profiles).join(", ") || "(none)"}`);
+  }
+
+  // Merge: profile overrides base config, but unset keys are kept from base
+  // Strip the "profiles" map from the result so it doesn't leak into engine
+  const { profiles: _profiles, ...base } = config;
+  return { ...base, ...profile };
+}
+
+/**
+ * List available profile names from config.
+ * @returns {Promise<string[]>}
+ */
+export async function listProfiles() {
+  const config = await loadConfig();
+  return Object.keys(config.profiles ?? {});
+}
+
 /**
  * Returns true if no config exists or onboarded flag is not set.
  */

package/core/engine.mjs

@@ -12,9 +12,22 @@
 
 import os from "node:os";
 import path from "node:path";
-import { readFile, writeFile, mkdir, appendFile } from "node:fs/promises";
+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 { NullEmitter } from "../lib/jsonl-emitter.mjs";
+
+/**
+ * Personality presets that modify the system prompt.
+ * Set via config, profile, or --personality CLI flag.
+ */
+export const PERSONALITIES = {
+  pragmatic: "Be direct and action-oriented. Minimize explanation, maximize execution. Show code, not words.",
+  concise: "Keep responses extremely brief. One-liners when possible. No filler.",
+  explanatory: "Explain your reasoning step by step. Help the user understand, not just get an answer.",
+  friendly: "Be warm and encouraging. Use casual language. Celebrate small wins.",
+  strict: "Follow instructions precisely. No creative interpretation. Verify before acting.",
+};
 import { ProviderRegistry } from "./providers.mjs";
 import { ToolRegistry } from "./tools.mjs";
 import { SessionManager } from "./session.mjs";
@@ -30,6 +43,7 @@ import { UserModel } from "./user-model.mjs";
 import { routeTask, classifyTask, filterAvailableModels } from "./task-router.mjs";
 import { decomposeTask, executeDecomposedPlan } from "./task-decomposer.mjs";
 import { BrowserBridge } from "./browser.mjs";
+import { LoopDetector } from "./loop-detector.mjs";
 
 const MAX_TOOL_ROUNDS = 10;
 const MAX_CONTEXT_CHARS = 40_000;
@@ -58,6 +72,8 @@ export class WispyEngine {
       ?? process.env.WISPY_WORKSTREAM
       ?? process.argv.find((a, i) => (process.argv[i-1] === "-w" || process.argv[i-1] === "--workstream"))
       ?? "default";
+    // Personality: from config, or null (use default Wispy personality)
+    this._personality = config.personality ?? null;
   }
 
   get activeWorkstream() { return this._activeWorkstream; }
@@ -130,7 +146,7 @@ export class WispyEngine {
    *
    * @param {string|null} sessionId - Session ID (null = create new)
    * @param {string} userMessage - The user's message
-   * @param {object} opts - Options: { onChunk, systemPrompt, workstream, noSave }
+   * @param {object} opts - Options: { onChunk, systemPrompt, workstream, noSave, emitter, personality }
    * @returns {object} { role: "assistant", content: string, usage? }
    */
   async processMessage(sessionId, userMessage, opts = {}) {
@@ -161,10 +177,25 @@ export class WispyEngine {
       session = this.sessions.create({ workstream: opts.workstream ?? this._activeWorkstream });
     }
 
+    // JSONL emitter (no-op by default)
+    const emitter = opts.emitter ?? new NullEmitter();
+
+    // Emit start event
+    emitter.start({
+      model: this.providers.model ?? "unknown",
+      session_id: session.id,
+    });
+
+    // Emit user message event
+    emitter.message("user", userMessage);
+
+    // Resolve personality for this call
+    const personality = opts.personality ?? this._personality ?? null;
+
     // Build messages array for the provider
     let systemPrompt;
     try {
-      systemPrompt = opts.systemPrompt ?? await this._buildSystemPrompt(userMessage);
+      systemPrompt = opts.systemPrompt ?? await this._buildSystemPrompt(userMessage, { personality });
     } catch {
       systemPrompt = "You are Wispy 🌿 — a helpful AI assistant in the terminal.";
     }
@@ -195,11 +226,13 @@ export class WispyEngine {
     }).catch(() => {});
 
     // Run agentic loop with error handling
+    const _startMs = Date.now();
     let responseText;
     try {
-      responseText = await this._agentLoop(messages, session, opts);
+      responseText = await this._agentLoop(messages, session, { ...opts, emitter });
     } catch (err) {
       responseText = this._friendlyError(err);
+      emitter.error(err);
       this.audit.log({
         type: EVENT_TYPES.ERROR,
         sessionId: session.id,
@@ -207,6 +240,13 @@ export class WispyEngine {
       }).catch(() => {});
     }
 
+    // Emit assistant message + done events
+    emitter.message("assistant", responseText);
+    emitter.done({
+      tokens: { ...(this.providers.sessionTokens ?? {}) },
+      duration_ms: Date.now() - _startMs,
+    });
+
     // Audit: log outgoing response
     this.audit.log({
       type: EVENT_TYPES.MESSAGE_SENT,
@@ -294,7 +334,38 @@ export class WispyEngine {
     // Optimize context
     messages = this._optimizeContext(messages);
 
+    // Create a fresh loop detector per agent turn
+    const loopDetector = new LoopDetector();
+    let loopWarned = false;
+
     for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+      // ── Loop detection check before LLM call ─────────────────────────────
+      if (loopDetector.size >= 2) {
+        const loopCheck = loopDetector.check();
+        if (loopCheck.looping) {
+          if (opts.onLoopDetected) opts.onLoopDetected(loopCheck);
+
+          if (!loopWarned) {
+            // First warning: inject a system message and continue
+            loopWarned = true;
+            const warningMsg = loopCheck.suggestion ?? `Loop detected: agent called ${loopCheck.tool} multiple times without progress. Try a different approach.`;
+            messages.push({
+              role: "user",
+              content: `[SYSTEM WARNING] ${warningMsg}`,
+            });
+            if (process.env.WISPY_DEBUG) {
+              console.error(`[wispy] Loop detected: ${loopCheck.reason} — warning injected`);
+            }
+          } else {
+            // Second time loop detected after warning: force-break the agent turn
+            if (process.env.WISPY_DEBUG) {
+              console.error(`[wispy] Loop force-break: ${loopCheck.reason}`);
+            }
+            return `⚠️ Agent loop detected and stopped: ${loopCheck.suggestion ?? loopCheck.reason}. Please try rephrasing your request.`;
+          }
+        }
+      }
+
       const result = await this.providers.chat(messages, this.tools.getDefinitions(), {
         onChunk: opts.onChunk,
         model: opts.model,
@@ -308,9 +379,13 @@ export class WispyEngine {
       const toolCallMsg = { role: "assistant", toolCalls: result.calls, content: "" };
       messages.push(toolCallMsg);
 
+      const loopEmitter = opts.emitter ?? new NullEmitter();
+
       for (const call of result.calls) {
         if (opts.onToolCall) opts.onToolCall(call.name, call.args);
+        loopEmitter.toolCall(call.name, call.args);
 
+        const _toolStartMs = Date.now();
         let toolResult;
         try {
           // Enforce 60s timeout on individual tool calls
@@ -328,7 +403,12 @@ export class WispyEngine {
           }
         }
 
+        // Record into loop detector
+        loopDetector.record(call.name, call.args, toolResult);
+
+        const _toolDuration = Date.now() - _toolStartMs;
         if (opts.onToolResult) opts.onToolResult(call.name, toolResult);
+        loopEmitter.toolResult(call.name, toolResult, _toolDuration);
 
         messages.push({
           role: "tool_result",
@@ -783,17 +863,32 @@ export class WispyEngine {
 
   // ── System prompt ────────────────────────────────────────────────────────────
 
-  async _buildSystemPrompt(lastUserMessage = "") {
+  async _buildSystemPrompt(lastUserMessage = "", opts = {}) {
+    const personality = opts.personality ?? this._personality ?? null;
+
     const parts = [
       "You are Wispy 🌿 — a small ghost that lives in terminals.",
       "You float between code, files, and servers. You're playful, honest, and curious.",
       "",
-      "## Personality",
-      "- Playful with a bit of humor, but serious when working",
-      "- Always use casual speech (반말). Never formal/polite speech.",
-      "- Honest — if you don't know, say so.",
-      "- Concise — don't over-explain.",
-      "",
+    ];
+
+    // Inject personality override if set
+    if (personality && PERSONALITIES[personality]) {
+      parts.push(`## Personality Override (${personality})`);
+      parts.push(PERSONALITIES[personality]);
+      parts.push("");
+    } else {
+      parts.push(
+        "## Personality",
+        "- Playful with a bit of humor, but serious when working",
+        "- Always use casual speech (반말). Never formal/polite speech.",
+        "- Honest — if you don't know, say so.",
+        "- Concise — don't over-explain.",
+        "",
+      );
+    }
+
+    parts.push(
       "## Speech rules",
       "- ALWAYS end your response with exactly one 🌿 emoji (signature)",
       "- Use 🌿 ONLY at the very end, not in the middle",
@@ -805,7 +900,7 @@ export class WispyEngine {
       `You have ${this.tools.getDefinitions().length} tools available: ${this.tools.getDefinitions().map(t => t.name).join(", ")}.`,
       "Use them proactively. Briefly mention what you're doing.",
       "",
-    ];
+    );
 
     // Load user model personalization
     try {