@ch4p/cli 0.1.3 → 0.1.5

package/dist/agent-6WIHK7NM.js

@@ -0,0 +1,767 @@
+import {
+  DeepgramSTT,
+  ElevenLabsTTS,
+  WakeListener,
+  WhisperSTT,
+  buildSystemPrompt
+} from "./chunk-WL32AHUY.js";
+import {
+  DefaultSecurityPolicy,
+  NativeEngine,
+  ProviderRegistry,
+  SubprocessEngine,
+  createClaudeCliEngine,
+  createCodexCliEngine,
+  createMemoryBackend,
+  createObserver
+} from "./chunk-BMEBRUYL.js";
+import {
+  LoadSkillTool,
+  ToolRegistry
+} from "./chunk-PGZ24EFT.js";
+import {
+  SkillRegistry
+} from "./chunk-6BURGD2Y.js";
+import {
+  AgentLoop,
+  ContextManager,
+  FormatVerifier,
+  LLMVerifier,
+  Session,
+  createAutoRecallHook,
+  createAutoSummarizeHook
+} from "./chunk-U7S375OS.js";
+import {
+  generateId
+} from "./chunk-YSCX2QQQ.js";
+import {
+  playBriefSplash
+} from "./chunk-CNLYUY2K.js";
+import {
+  getLogsDir,
+  loadConfig
+} from "./chunk-TB4IZ7F7.js";
+import {
+  BLUE,
+  BOLD,
+  BOX,
+  CHAPPIE_GLYPH,
+  CHECK,
+  CROSS,
+  DIM,
+  GREEN,
+  PROMPT_CHAR,
+  RED,
+  RESET,
+  TEAL,
+  TEAL_DIM,
+  WARN,
+  YELLOW,
+  chatHeader,
+  separator,
+  sessionBanner,
+  tokenFooter
+} from "./chunk-NMGPBPNU.js";
+
+// src/commands/agent.ts
+import * as readline from "readline";
+function truncateArgs(args) {
+  const str = typeof args === "string" ? args : JSON.stringify(args);
+  return truncate(str, 80);
+}
+function truncate(str, max) {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 3) + "...";
+}
+var GUTTER = `  ${TEAL_DIM}${BOX.vertical}${RESET} `;
+function createChatRenderState() {
+  return { headerPrinted: false, inTextStream: false, wasThinking: false };
+}
+function resetChatRenderState(state) {
+  state.headerPrinted = false;
+  state.inTextStream = false;
+  state.wasThinking = false;
+}
+function handleAgentEvent(event, state) {
+  const ensureHeader = () => {
+    if (!state.headerPrinted) {
+      console.log(chatHeader(CHAPPIE_GLYPH, "ch4p"));
+      state.headerPrinted = true;
+    }
+  };
+  switch (event.type) {
+    case "thinking":
+      ensureHeader();
+      if (!state.wasThinking) {
+        process.stdout.write("  ");
+      }
+      process.stdout.write(`${DIM}${event.delta}${RESET}`);
+      state.wasThinking = true;
+      break;
+    case "text":
+      ensureHeader();
+      if (state.wasThinking && !state.inTextStream) {
+        process.stdout.write("\n\n");
+        state.wasThinking = false;
+      }
+      if (!state.inTextStream) {
+        process.stdout.write("  ");
+        state.inTextStream = true;
+      }
+      process.stdout.write(event.delta);
+      break;
+    case "tool_start":
+      ensureHeader();
+      if (state.inTextStream) {
+        process.stdout.write("\n");
+        state.inTextStream = false;
+      }
+      if (state.wasThinking) {
+        process.stdout.write("\n");
+        state.wasThinking = false;
+      }
+      console.log("");
+      console.log(`${GUTTER}${BOLD}${event.tool}${RESET}${DIM}(${truncateArgs(event.args)})${RESET}`);
+      break;
+    case "tool_progress":
+      process.stdout.write(`${GUTTER}${DIM}${event.update}${RESET}
+`);
+      break;
+    case "tool_end":
+      if (event.result.success) {
+        const output = truncate(event.result.output, 120);
+        if (output) {
+          console.log(`${GUTTER}${DIM}${output}${RESET}`);
+        }
+        console.log(`${GUTTER}${CHECK} ${DIM}Done${RESET}`);
+      } else {
+        console.log(`${GUTTER}${CROSS} ${event.result.error ?? "Unknown error"}`);
+      }
+      break;
+    case "tool_validation_error":
+      console.log(`${GUTTER}${WARN} ${YELLOW}${event.tool}: ${event.errors.join(", ")}${RESET}`);
+      break;
+    case "verification": {
+      const v = event.result;
+      const outcomeColor = v.outcome === "success" ? GREEN : v.outcome === "partial" ? YELLOW : RED;
+      console.log(`
+${GUTTER}${BLUE}verify${RESET} ${outcomeColor}${v.outcome}${RESET} ${DIM}confidence=${v.confidence.toFixed(2)}${RESET}`);
+      if (v.reasoning) {
+        console.log(`${GUTTER}${DIM}${v.reasoning}${RESET}`);
+      }
+      if (v.issues && v.issues.length > 0) {
+        for (const issue of v.issues) {
+          console.log(`${GUTTER}${WARN} ${issue}`);
+        }
+      }
+      break;
+    }
+    case "complete":
+      if (state.inTextStream) {
+        process.stdout.write("\n");
+        state.inTextStream = false;
+      }
+      if (event.usage) {
+        console.log(tokenFooter(event.usage));
+      }
+      resetChatRenderState(state);
+      break;
+    case "error":
+      ensureHeader();
+      console.error(`
+  ${RED}Error:${RESET} ${event.error.message}`);
+      break;
+    case "aborted":
+      ensureHeader();
+      console.log(`
+  ${YELLOW}Aborted:${RESET} ${event.reason}`);
+      break;
+  }
+}
+function createEngine(config) {
+  const engineId = config.engines?.default ?? "native";
+  const engineConfig = config.engines?.available?.[engineId];
+  if (engineId === "claude-cli") {
+    try {
+      return createClaudeCliEngine({
+        command: engineConfig?.command ?? void 0,
+        cwd: engineConfig?.cwd ?? void 0,
+        timeout: engineConfig?.timeout ?? void 0
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.log(`  ${YELLOW}\u26A0 Failed to create Claude CLI engine: ${message}${RESET}`);
+      console.log(`  ${DIM}Falling back to stub engine.${RESET}
+`);
+      return createStubEngine(config);
+    }
+  }
+  if (engineId === "codex-cli") {
+    try {
+      return createCodexCliEngine({
+        command: engineConfig?.command ?? void 0,
+        cwd: engineConfig?.cwd ?? void 0,
+        timeout: engineConfig?.timeout ?? void 0
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.log(`  ${YELLOW}\u26A0 Failed to create Codex CLI engine: ${message}${RESET}`);
+      console.log(`  ${DIM}Falling back to stub engine.${RESET}
+`);
+      return createStubEngine(config);
+    }
+  }
+  if (engineConfig?.type === "subprocess") {
+    try {
+      return new SubprocessEngine({
+        id: engineId,
+        name: engineConfig.name ?? `Subprocess (${engineId})`,
+        command: engineConfig.command,
+        args: engineConfig.args ?? void 0,
+        promptMode: engineConfig.promptMode ?? void 0,
+        promptFlag: engineConfig.promptFlag ?? void 0,
+        cwd: engineConfig.cwd ?? void 0,
+        timeout: engineConfig.timeout ?? void 0
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.log(`  ${YELLOW}\u26A0 Failed to create subprocess engine "${engineId}": ${message}${RESET}`);
+      console.log(`  ${DIM}Falling back to stub engine.${RESET}
+`);
+      return createStubEngine(config);
+    }
+  }
+  const providerName = config.agent.provider;
+  const providerConfig = config.providers?.[providerName];
+  const apiKey = providerConfig?.apiKey;
+  const needsKey = providerName !== "ollama";
+  if (needsKey && (!apiKey || apiKey.trim().length === 0)) {
+    console.log(`  ${YELLOW}\u26A0 No API key for ${providerName}. Running in stub mode.${RESET}`);
+    console.log(`  ${DIM}Set ${providerName.toUpperCase()}_API_KEY or run 'ch4p onboard' to configure.${RESET}
+`);
+    return createStubEngine(config);
+  }
+  try {
+    const provider = ProviderRegistry.createProvider({
+      id: providerName,
+      type: providerName,
+      ...providerConfig
+    });
+    return new NativeEngine({
+      provider,
+      defaultModel: config.agent.model
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.log(`  ${YELLOW}\u26A0 Failed to create ${providerName} provider: ${message}${RESET}`);
+    console.log(`  ${DIM}Falling back to stub engine.${RESET}
+`);
+    return createStubEngine(config);
+  }
+}
+function createStubEngine(config) {
+  return {
+    id: config.engines?.default ?? "native",
+    name: "Native Engine (stub)",
+    async startRun(job, opts) {
+      const ref = generateId(12);
+      async function* events() {
+        yield { type: "started" };
+        const lastMessage = job.messages[job.messages.length - 1];
+        const userText = typeof lastMessage?.content === "string" ? lastMessage.content : "(no message)";
+        const response = `I received your message: "${truncate(userText, 100)}"
+
+This is a placeholder response from the ch4p stub engine. To use a real LLM, configure your API key for ${config.agent.provider}.
+
+Current configuration:
+  Provider: ${config.agent.provider}
+  Model: ${config.agent.model}
+  Autonomy: ${config.autonomy.level}
+`;
+        for (const char of response) {
+          if (opts?.signal?.aborted) {
+            yield { type: "error", error: new Error("Aborted") };
+            return;
+          }
+          yield { type: "text_delta", delta: char };
+        }
+        yield {
+          type: "completed",
+          answer: response,
+          usage: { inputTokens: Math.ceil(userText.length / 4), outputTokens: Math.ceil(response.length / 4) }
+        };
+      }
+      return {
+        ref,
+        events: events(),
+        async cancel() {
+        },
+        steer(_message) {
+        }
+      };
+    },
+    async resume(_token, _prompt) {
+      throw new Error("Resume not supported in stub engine");
+    }
+  };
+}
+function createSessionConfig(config, skillRegistry, hasMemory, hasSearch) {
+  const systemPrompt = buildSystemPrompt({ hasMemory, hasSearch, skillRegistry });
+  return {
+    sessionId: generateId(16),
+    engineId: config.engines?.default ?? "native",
+    model: config.agent.model,
+    provider: config.agent.provider,
+    autonomyLevel: config.autonomy.level,
+    cwd: process.cwd(),
+    systemPrompt
+  };
+}
+function createSkillRegistry(config) {
+  if (!config.skills?.enabled) return new SkillRegistry();
+  try {
+    return SkillRegistry.createFromPaths(config.skills.paths);
+  } catch {
+    return new SkillRegistry();
+  }
+}
+function createToolRegistry(config, skillRegistry) {
+  const exclude = [];
+  if (config.autonomy.level === "readonly") {
+    exclude.push("bash", "file_write", "file_edit", "delegate");
+  }
+  if (!config.mesh?.enabled) {
+    exclude.push("mesh");
+  }
+  const registry = ToolRegistry.createDefault(
+    exclude.length > 0 ? { exclude } : void 0
+  );
+  if (skillRegistry && skillRegistry.size > 0) {
+    registry.register(new LoadSkillTool(skillRegistry));
+  }
+  return registry;
+}
+function createMemory(config) {
+  try {
+    const memCfg = {
+      backend: config.memory.backend,
+      vectorWeight: config.memory.vectorWeight,
+      keywordWeight: config.memory.keywordWeight,
+      embeddingProvider: config.memory.embeddingProvider,
+      openaiApiKey: config.providers?.openai?.apiKey || void 0
+    };
+    const backend = createMemoryBackend(memCfg);
+    return backend;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.log(`  ${YELLOW}\u26A0 Memory backend failed to initialise: ${message}${RESET}`);
+    console.log(`  ${DIM}Memory tools will be unavailable this session.${RESET}
+`);
+    return void 0;
+  }
+}
+function createConfiguredObserver(config) {
+  try {
+    const obsCfg = {
+      observers: config.observability.observers ?? ["console"],
+      logLevel: config.observability.logLevel ?? "info",
+      logPath: `${getLogsDir()}/ch4p.jsonl`
+    };
+    return createObserver(obsCfg);
+  } catch {
+    return createObserver({ observers: ["console"], logLevel: "info" });
+  }
+}
+function createSecurityPolicy(config, cwd) {
+  return new DefaultSecurityPolicy({
+    workspace: cwd,
+    autonomyLevel: config.autonomy.level,
+    allowedCommands: config.autonomy.allowedCommands,
+    blockedPaths: config.security.blockedPaths
+  });
+}
+function createVerifier(config, _engine) {
+  const vCfg = config.verification;
+  if (!vCfg?.enabled) return void 0;
+  const formatOpts = {
+    maxToolErrorRatio: vCfg.maxToolErrorRatio ?? 0.5
+  };
+  if (vCfg.semantic) {
+    try {
+      const providerName = config.agent.provider;
+      const providerConfig = config.providers?.[providerName];
+      const provider = ProviderRegistry.createProvider({
+        id: `${providerName}-verifier`,
+        type: providerName,
+        ...providerConfig
+      });
+      return new LLMVerifier({
+        provider,
+        model: config.agent.model,
+        formatOpts
+      });
+    } catch {
+      return new FormatVerifier(formatOpts);
+    }
+  }
+  return new FormatVerifier(formatOpts);
+}
+function createAgentLoop(config, engine, sessionConfig, memoryBackend, skillRegistry, extras) {
+  const session = new Session(sessionConfig, {
+    ...extras?.sessionOpts,
+    maxErrors: config.agent.maxSessionErrors
+  });
+  const tools = createToolRegistry(config, skillRegistry);
+  const observer = createConfiguredObserver(config);
+  const securityPolicy = createSecurityPolicy(config, sessionConfig.cwd ?? process.cwd());
+  const toolContextExtensions = {};
+  if (config.search?.enabled && config.search.apiKey) {
+    toolContextExtensions.searchApiKey = config.search.apiKey;
+    toolContextExtensions.searchConfig = {
+      maxResults: config.search.maxResults,
+      country: config.search.country,
+      searchLang: config.search.searchLang
+    };
+  }
+  const verifier = createVerifier(config, engine);
+  return new AgentLoop(session, engine, tools.list(), observer, {
+    maxIterations: extras?.maxIterations ?? 50,
+    maxRetries: 3,
+    enableStateSnapshots: true,
+    verifier,
+    memoryBackend,
+    securityPolicy,
+    onBeforeFirstRun: extras?.onBeforeFirstRun,
+    onAfterComplete: extras?.onAfterComplete,
+    toolContextExtensions: Object.keys(toolContextExtensions).length > 0 ? toolContextExtensions : void 0,
+    maxToolResults: config.agent.maxToolResults,
+    maxToolOutputLen: config.agent.maxToolOutputLen,
+    maxStateRecords: config.agent.maxStateRecords
+  });
+}
+async function runAgentMessage(config, engine, sessionConfig, message, memoryBackend, skillRegistry, extras, renderState) {
+  const loop = createAgentLoop(config, engine, sessionConfig, memoryBackend, skillRegistry, extras);
+  const state = renderState ?? createChatRenderState();
+  for await (const event of loop.run(message)) {
+    handleAgentEvent(event, state);
+  }
+}
+function createWakeListener(config) {
+  const voiceCfg = config.voice;
+  if (!voiceCfg?.enabled || !voiceCfg.wake?.enabled) return null;
+  try {
+    const stt = voiceCfg.stt.provider === "deepgram" ? new DeepgramSTT({ apiKey: voiceCfg.stt.apiKey ?? "" }) : new WhisperSTT({ apiKey: voiceCfg.stt.apiKey ?? "" });
+    const tts = voiceCfg.tts.provider === "elevenlabs" ? new ElevenLabsTTS({ apiKey: voiceCfg.tts.apiKey ?? "", voiceId: voiceCfg.tts.voiceId }) : void 0;
+    return new WakeListener({
+      stt,
+      tts,
+      config: {
+        enabled: true,
+        wakeWord: voiceCfg.wake.wakeWord,
+        energyThreshold: voiceCfg.wake.energyThreshold,
+        silenceDurationMs: voiceCfg.wake.silenceDurationMs
+      }
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.log(`  ${YELLOW}\u26A0 Voice wake failed to initialise: ${message}${RESET}`);
+    console.log(`  ${DIM}Voice wake will be unavailable this session.${RESET}
+`);
+    return null;
+  }
+}
+var REPL_HELP = `
+  ${BOLD}Special Commands${RESET}
+${separator()}
+  ${TEAL}/exit${RESET}     Exit the session
+  ${TEAL}/clear${RESET}    Clear conversation history
+  ${TEAL}/audit${RESET}    Run security audit
+  ${TEAL}/memory${RESET}   Show memory status
+  ${TEAL}/tools${RESET}    List available tools
+  ${TEAL}/skills${RESET}   List available skills
+  ${TEAL}/help${RESET}     Show this help
+`;
+async function runRepl(config, voiceEnabled = false) {
+  const engine = createEngine(config);
+  const skillRegistry = createSkillRegistry(config);
+  const memoryBackend = createMemory(config);
+  const hasMemory = !!memoryBackend;
+  const hasSearch = !!(config.search?.enabled && config.search.apiKey);
+  const sessionConfig = createSessionConfig(config, skillRegistry, hasMemory, hasSearch);
+  const tools = createToolRegistry(config);
+  const sharedContext = new ContextManager();
+  if (sessionConfig.systemPrompt) {
+    sharedContext.setSystemPrompt(sessionConfig.systemPrompt);
+  }
+  const autoSave = config.memory.autoSave !== false;
+  const onBeforeFirstRun = memoryBackend && autoSave ? createAutoRecallHook(memoryBackend) : void 0;
+  const onAfterComplete = memoryBackend && autoSave ? createAutoSummarizeHook(memoryBackend) : void 0;
+  if (process.stdout.isTTY) {
+    await playBriefSplash();
+  }
+  const bannerInfo = {
+    Engine: engine.name,
+    Model: config.agent.model,
+    Autonomy: config.autonomy.level,
+    Tools: `${tools.size} loaded`,
+    Memory: memoryBackend ? `${config.memory.backend}${autoSave ? " (auto)" : ""}` : `${DIM}disabled${RESET}`
+  };
+  if (skillRegistry.size > 0) {
+    bannerInfo.Skills = `${skillRegistry.size} loaded`;
+  }
+  const wakeListener = voiceEnabled ? createWakeListener(config) : null;
+  if (wakeListener) {
+    const wakeCfg = config.voice?.wake;
+    bannerInfo.Voice = `${GREEN}wake${RESET}${wakeCfg?.wakeWord ? ` "${wakeCfg.wakeWord}"` : ""}`;
+  }
+  console.log("\n" + sessionBanner(bannerInfo));
+  console.log(`  ${DIM}Type ${TEAL}/help${DIM} for commands, ${TEAL}/exit${DIM} to quit.${RESET}
+`);
+  if (engine.name === "Native Engine (stub)") {
+    console.log(
+      `  ${YELLOW}${BOLD}\u26A0  Stub engine active${RESET}
+  ${YELLOW}No API key is configured for "${config.agent.provider}".${RESET}
+  ${DIM}Responses are placeholders only. Run ${TEAL}ch4p onboard${DIM} to set up a real provider.${RESET}
+`
+    );
+  }
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: `${TEAL}${BOLD}${PROMPT_CHAR} ${RESET}`,
+    historySize: 200
+  });
+  let running = true;
+  rl.on("SIGINT", () => {
+    console.log(`
+${DIM}  Use /exit to quit.${RESET}`);
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    if (running) {
+      running = false;
+      wakeListener?.stop();
+      void memoryBackend?.close();
+      console.log(`
+${DIM}  Goodbye!${RESET}
+`);
+    }
+  });
+  if (wakeListener) {
+    let voiceProcessing = false;
+    wakeListener.on("listening", () => {
+      console.log(`
+  ${TEAL}\u{1F399} Voice wake active${RESET}${config.voice?.wake?.wakeWord ? ` \u2014 say "${config.voice.wake.wakeWord}" to start` : ""}${RESET}`);
+      rl.prompt();
+    });
+    wakeListener.on("wake", (event) => {
+      if (voiceProcessing || !running) return;
+      voiceProcessing = true;
+      console.log(chatHeader(PROMPT_CHAR, "You") + `  ${DIM}(voice)${RESET}`);
+      console.log(`  ${event.text}`);
+      const renderState = createChatRenderState();
+      runAgentMessage(config, engine, sessionConfig, event.text, memoryBackend, skillRegistry, {
+        sessionOpts: { sharedContext },
+        onBeforeFirstRun,
+        onAfterComplete
+      }, renderState).then(async () => {
+        const messages = sharedContext.getMessages();
+        const lastAssistant = messages.filter((m) => m.role === "assistant").pop();
+        if (lastAssistant && typeof lastAssistant.content === "string") {
+          await wakeListener.speak(lastAssistant.content);
+        }
+      }).catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`
+  ${RED}Error:${RESET} ${message}`);
+      }).finally(() => {
+        voiceProcessing = false;
+        console.log("");
+        rl.prompt();
+      });
+    });
+    wakeListener.on("error", (err) => {
+      console.error(`  ${YELLOW}Voice error:${RESET} ${err.message}`);
+    });
+    try {
+      wakeListener.start();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.log(`  ${YELLOW}\u26A0 Voice wake start failed: ${message}${RESET}`);
+      console.log(`  ${DIM}Continuing without voice wake.${RESET}
+`);
+    }
+  }
+  rl.prompt();
+  for await (const line of rl) {
+    const input = line.trim();
+    if (!input) {
+      rl.prompt();
+      continue;
+    }
+    if (input.startsWith("/")) {
+      const cmd = input.toLowerCase().split(/\s+/)[0];
+      switch (cmd) {
+        case "/exit":
+        case "/quit":
+        case "/q":
+          running = false;
+          wakeListener?.stop();
+          console.log(`
+${DIM}  Goodbye!${RESET}
+`);
+          rl.close();
+          await memoryBackend?.close();
+          return;
+        case "/clear":
+          sharedContext.clear();
+          if (sessionConfig.systemPrompt) {
+            sharedContext.setSystemPrompt(sessionConfig.systemPrompt);
+          }
+          console.log(`  ${GREEN}Conversation cleared.${RESET}
+`);
+          rl.prompt();
+          continue;
+        case "/audit": {
+          const { runAudit } = await import("./audit-UIGPH3FK.js");
+          console.log("");
+          runAudit(config);
+          console.log("");
+          rl.prompt();
+          continue;
+        }
+        case "/memory":
+          console.log(`
+  ${BOLD}Memory Status${RESET}`);
+          console.log(`  ${DIM}Backend: ${config.memory.backend}${RESET}`);
+          console.log(`  ${DIM}Active: ${memoryBackend ? `${GREEN}yes${RESET}` : `${YELLOW}no (failed to initialise)${RESET}`}`);
+          console.log(`  ${DIM}Auto-save: ${config.memory.autoSave}${RESET}`);
+          console.log(`  ${DIM}Vector weight: ${config.memory.vectorWeight ?? 0.7}${RESET}`);
+          console.log(`  ${DIM}Keyword weight: ${config.memory.keywordWeight ?? 0.3}${RESET}
+`);
+          rl.prompt();
+          continue;
+        case "/tools":
+          console.log(`
+  ${BOLD}Available Tools${RESET} ${DIM}(${tools.size})${RESET}`);
+          for (const tool of tools.list()) {
+            console.log(`  ${TEAL}${tool.name}${RESET} ${DIM}[${tool.weight}]${RESET} ${tool.description}`);
+          }
+          console.log("");
+          rl.prompt();
+          continue;
+        case "/skills":
+          if (skillRegistry.size === 0) {
+            console.log(`
+  ${DIM}No skills loaded.${RESET}
+`);
+          } else {
+            console.log(`
+  ${BOLD}Available Skills${RESET} ${DIM}(${skillRegistry.size})${RESET}`);
+            for (const skill of skillRegistry.list()) {
+              console.log(`  ${TEAL}${skill.manifest.name}${RESET} ${DIM}(${skill.source})${RESET} ${skill.manifest.description}`);
+            }
+            console.log("");
+          }
+          rl.prompt();
+          continue;
+        case "/help":
+          console.log(REPL_HELP);
+          rl.prompt();
+          continue;
+        default:
+          console.log(`  ${YELLOW}Unknown command: ${cmd}${RESET}`);
+          console.log(`  ${DIM}Type /help for available commands.${RESET}
+`);
+          rl.prompt();
+          continue;
+      }
+    }
+    console.log(chatHeader(PROMPT_CHAR, "You"));
+    console.log(`  ${input}`);
+    const renderState = createChatRenderState();
+    try {
+      await runAgentMessage(config, engine, sessionConfig, input, memoryBackend, skillRegistry, {
+        sessionOpts: { sharedContext },
+        onBeforeFirstRun,
+        onAfterComplete
+      }, renderState);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`
+  ${RED}Error:${RESET} ${message}`);
+    }
+    console.log("");
+    rl.prompt();
+  }
+}
+async function runSingleMessage(config, message) {
+  const engine = createEngine(config);
+  const skillRegistry = createSkillRegistry(config);
+  const memoryBackend = createMemory(config);
+  const hasMemory = !!memoryBackend;
+  const hasSearch = !!(config.search?.enabled && config.search.apiKey);
+  const sessionConfig = createSessionConfig(config, skillRegistry, hasMemory, hasSearch);
+  const autoSave = config.memory.autoSave !== false;
+  const onBeforeFirstRun = memoryBackend && autoSave ? createAutoRecallHook(memoryBackend) : void 0;
+  const onAfterComplete = memoryBackend && autoSave ? createAutoSummarizeHook(memoryBackend) : void 0;
+  try {
+    console.log(chatHeader(PROMPT_CHAR, "You"));
+    console.log(`  ${message}`);
+    await runAgentMessage(config, engine, sessionConfig, message, memoryBackend, skillRegistry, {
+      onBeforeFirstRun,
+      onAfterComplete
+    });
+    console.log("");
+  } catch (err) {
+    const errMessage = err instanceof Error ? err.message : String(err);
+    console.error(`
+${RED}Error:${RESET} ${errMessage}`);
+    process.exitCode = 1;
+  } finally {
+    await memoryBackend?.close();
+  }
+}
+async function agent(args) {
+  let config;
+  try {
+    config = loadConfig();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`
+  ${RED}Failed to load config:${RESET} ${message}`);
+    console.error(`  ${DIM}Run ${TEAL}ch4p onboard${DIM} to set up ch4p.${RESET}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  let singleMessage = null;
+  let voiceEnabled = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-m" || arg === "--message") {
+      singleMessage = args[i + 1] ?? "";
+      break;
+    }
+    if (arg.startsWith("-m") && arg.length > 2) {
+      singleMessage = arg.slice(2);
+      break;
+    }
+    if (arg === "--voice") {
+      voiceEnabled = true;
+    }
+  }
+  if (singleMessage !== null) {
+    if (!singleMessage) {
+      console.error(`  ${RED}Error:${RESET} -m flag requires a message argument.`);
+      process.exitCode = 1;
+      return;
+    }
+    await runSingleMessage(config, singleMessage);
+  } else {
+    await runRepl(config, voiceEnabled);
+  }
+}
+export {
+  agent
+};