wispy-cli 2.7.10 → 2.7.12

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,13 +85,19 @@ 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]
                                Browser control via local-browser-bridge
+  wispy secrets [list|set|delete|get]
+                               Manage encrypted secrets & API keys
+  wispy tts "<text>"           Text-to-speech (OpenAI or macOS say)
   wispy trust [level|log]      Security level & audit
   wispy ws [start-client|run-debug]
                                WebSocket operations
@@ -66,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
 `);
@@ -338,6 +388,133 @@ if (command === "browser") {
   process.exit(0);
 }
 
+// ── Secrets ───────────────────────────────────────────────────────────────────
+
+if (command === "secrets") {
+  try {
+    const { SecretsManager } = await import(join(rootDir, "core/secrets.mjs"));
+    const sm = new SecretsManager();
+    const sub = args[1];
+
+    if (!sub || sub === "list") {
+      const keys = await sm.list();
+      if (keys.length === 0) {
+        console.log("No secrets stored. Use: wispy secrets set <key> <value>");
+      } else {
+        console.log(`\n  Stored secrets (${keys.length}):\n`);
+        for (const k of keys) {
+          console.log(`    ${k}`);
+        }
+        console.log("");
+      }
+    } else if (sub === "set") {
+      const key = args[2];
+      const value = args[3];
+      if (!key || value === undefined) {
+        console.error("Usage: wispy secrets set <key> <value>");
+        process.exit(1);
+      }
+      await sm.set(key, value);
+      console.log(`Secret '${key}' stored (encrypted).`);
+    } else if (sub === "delete") {
+      const key = args[2];
+      if (!key) {
+        console.error("Usage: wispy secrets delete <key>");
+        process.exit(1);
+      }
+      const result = await sm.delete(key);
+      if (result.success) {
+        console.log(`Secret '${key}' deleted.`);
+      } else {
+        console.error(`Secret '${key}' not found.`);
+        process.exit(1);
+      }
+    } else if (sub === "get") {
+      const key = args[2];
+      if (!key) {
+        console.error("Usage: wispy secrets get <key>");
+        process.exit(1);
+      }
+      const value = await sm.resolve(key);
+      if (value) {
+        console.log(`${key} = ***`);
+        console.log("(Use --reveal flag to show value — not recommended)");
+        if (args.includes("--reveal")) {
+          console.log(`Value: ${value}`);
+        }
+      } else {
+        console.log(`Secret '${key}' not found.`);
+      }
+    } else {
+      console.error(`Unknown secrets subcommand: ${sub}`);
+      console.log("Available: list, set <key> <value>, delete <key>, get <key>");
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error("Secrets error:", err.message);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+// ── TTS ───────────────────────────────────────────────────────────────────────
+
+if (command === "tts") {
+  try {
+    const { SecretsManager } = await import(join(rootDir, "core/secrets.mjs"));
+    const { TTSManager } = await import(join(rootDir, "core/tts.mjs"));
+
+    const sm = new SecretsManager();
+    const tts = new TTSManager(sm);
+
+    // Parse args: wispy tts "text" [--voice name] [--provider openai|macos] [--play]
+    let textArg = args[1];
+    if (!textArg) {
+      console.error('Usage: wispy tts "text to speak" [--voice <name>] [--provider openai|macos] [--play]');
+      process.exit(1);
+    }
+
+    const voiceIdx = args.indexOf("--voice");
+    const providerIdx = args.indexOf("--provider");
+    const shouldPlay = args.includes("--play");
+
+    const voice = voiceIdx !== -1 ? args[voiceIdx + 1] : undefined;
+    const provider = providerIdx !== -1 ? args[providerIdx + 1] : "auto";
+
+    console.log(`  Generating speech (provider: ${provider})...`);
+    const result = await tts.speak(textArg, { voice, provider });
+
+    if (result.error) {
+      console.error(`  TTS Error: ${result.error}`);
+      process.exit(1);
+    }
+
+    console.log(`  Provider: ${result.provider}`);
+    console.log(`  Voice:    ${result.voice}`);
+    console.log(`  Format:   ${result.format}`);
+    console.log(`  File:     ${result.path}`);
+
+    if (shouldPlay) {
+      const { execFile } = await import("node:child_process");
+      const { promisify } = await import("node:util");
+      const exec = promisify(execFile);
+      try {
+        if (process.platform === "darwin") {
+          await exec("afplay", [result.path]);
+        } else {
+          console.log('  Use --play flag only on macOS. Play manually with your audio player.');
+        }
+      } catch (playErr) {
+        console.error(`  Playback failed: ${playErr.message}`);
+      }
+    }
+  } catch (err) {
+    console.error("TTS error:", err.message);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
 // ── Trust ─────────────────────────────────────────────────────────────────────
 
 if (command === "trust") {
@@ -399,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.
  */
@@ -193,17 +227,35 @@ export async function detectProvider() {
     }
   }
 
-  // 4. macOS Keychain
-  const keychainMap = [
-    ["google-ai-key", "google"],
-    ["anthropic-api-key", "anthropic"],
-    ["openai-api-key", "openai"],
-  ];
-  for (const [service, provider] of keychainMap) {
-    const key = await tryKeychainKey(service);
-    if (key) {
-      process.env[PROVIDERS[provider].envKeys[0]] = key;
-      return { provider, key, model: process.env.WISPY_MODEL ?? PROVIDERS[provider].defaultModel };
+  // 4. macOS Keychain (via SecretsManager for unified resolution)
+  try {
+    const { getSecretsManager } = await import("./secrets.mjs");
+    const sm = getSecretsManager({ wispyDir: WISPY_DIR });
+    const keychainProviderMap = [
+      ["GOOGLE_AI_KEY", "google"],
+      ["ANTHROPIC_API_KEY", "anthropic"],
+      ["OPENAI_API_KEY", "openai"],
+    ];
+    for (const [envKey, provider] of keychainProviderMap) {
+      const key = await sm.resolve(envKey);
+      if (key) {
+        process.env[PROVIDERS[provider].envKeys[0]] = key;
+        return { provider, key, model: process.env.WISPY_MODEL ?? PROVIDERS[provider].defaultModel };
+      }
+    }
+  } catch {
+    // SecretsManager unavailable — fallback to legacy Keychain
+    const keychainMap = [
+      ["google-ai-key", "google"],
+      ["anthropic-api-key", "anthropic"],
+      ["openai-api-key", "openai"],
+    ];
+    for (const [service, provider] of keychainMap) {
+      const key = await tryKeychainKey(service);
+      if (key) {
+        process.env[PROVIDERS[provider].envKeys[0]] = key;
+        return { provider, key, model: process.env.WISPY_MODEL ?? PROVIDERS[provider].defaultModel };
+      }
     }
   }
 

package/core/engine.mjs

@@ -15,6 +15,19 @@ import path from "node:path";
 import { readFile, writeFile, mkdir, appendFile } 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";
@@ -58,6 +71,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 +145,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 +176,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 +225,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 +239,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,
@@ -308,9 +347,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 +371,9 @@ export class WispyEngine {
           }
         }
 
+        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 +828,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 +865,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 {