@iinm/plain-agent 1.8.4 → 1.8.6

package/src/cliInteractive.mjs

@@ -0,0 +1,533 @@
+/**
+ * @import { UserEventEmitter, AgentEventEmitter, AgentCommands } from "./agent"
+ * @import { ClaudeCodePlugin } from "./claudeCodePlugin.mjs"
+ * @import { VoiceInputConfig, VoiceSession } from "./voiceInput.mjs"
+ */
+
+import readline from "node:readline";
+import { styleText } from "node:util";
+import { createCommandHandler } from "./cliCommands.mjs";
+import { createCompleter, SLASH_COMMANDS } from "./cliCompleter.mjs";
+import {
+  formatCostSummary,
+  formatProviderTokenUsage,
+  printMessage,
+} from "./cliFormatter.mjs";
+import { createInterruptTransform } from "./cliInterruptTransform.mjs";
+import { createMuteTransform } from "./cliMuteTransform.mjs";
+import { createPasteHandler } from "./cliPasteTransform.mjs";
+import { appendUsageRecord, buildUsageRecord } from "./usageStore.mjs";
+import { notify } from "./utils/notify.mjs";
+import { parseVoiceToggleKey, startVoiceSession } from "./voiceInput.mjs";
+
+const HELP_MESSAGE = [
+  "Commands:",
+  ...SLASH_COMMANDS.map(
+    (cmd) => `  ${cmd.name.padEnd(13)} - ${cmd.description}`,
+  ),
+  "",
+  "Multi-line Input Syntax:",
+  '  """               - Start/stop multi-line input mode',
+  "",
+  "File Input Syntax:",
+  "  !path/to/file     - Read content from a file",
+  "  !path/to/file:N   - Read line N from a file",
+  "  !path/to/file:N-M - Read lines N to M from a file",
+  "",
+  "References (use within input content):",
+  "  @path/to/file     - Reference content from another file",
+  "  @path/to/file:N   - Reference line N from another file",
+  "  @path/to/file:N-M - Reference lines N to M from another file",
+  "",
+  "Image Attachments (use within input content):",
+  "  @path/to/image.png      - Attach an image (png, jpg, jpeg, gif, webp)",
+  "  @'path/with spaces.png' - Quote paths that include spaces",
+  "  @path/with\\ spaces.png  - Escape spaces with a backslash",
+]
+  .join("\n")
+  .trim()
+  .replace(/^[^ ].*:/gm, (m) => styleText("bold", m))
+  .replace(/^ {2}\/.+?(?= - )/gm, (m) => styleText("cyan", m))
+  .replace(/^ {2}.+?(?= - )/gm, (m) => styleText("blue", m));
+
+/**
+ * @typedef {object} CliOptions
+ * @property {UserEventEmitter} userEventEmitter
+ * @property {AgentEventEmitter} agentEventEmitter
+ * @property {AgentCommands} agentCommands
+ * @property {string} sessionId
+ * @property {string} modelName
+ * @property {Date} startTime
+ * @property {{ command: string; args?: string[] } | undefined} notifyCmd
+ * @property {boolean} sandbox
+ * @property {() => Promise<void>} onStop
+ * @property {ClaudeCodePlugin[]} [claudeCodePlugins]
+ * @property {VoiceInputConfig} [voiceInput]
+ */
+
+/**
+ * Persist the session's cost summary to the usage log.
+ * Failures are logged but never thrown so exit is not blocked.
+ *
+ * @param {import("./costTracker.mjs").CostSummary} summary
+ * @param {{ sessionId: string, modelName: string, startTime: Date }} meta
+ */
+async function persistUsage(summary, { sessionId, modelName, startTime }) {
+  try {
+    const record = buildUsageRecord({
+      sessionId,
+      mode: "interactive",
+      modelName,
+      workingDir: process.cwd(),
+      costSummary: summary,
+      now: startTime,
+    });
+    if (!record) return;
+    await appendUsageRecord(record);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(
+      styleText("yellow", `Warning: failed to record usage: ${message}`),
+    );
+  }
+}
+
+/**
+ * @param {CliOptions} options
+ */
+export function startInteractiveSession({
+  userEventEmitter,
+  agentEventEmitter,
+  agentCommands,
+  sessionId,
+  modelName,
+  startTime,
+  notifyCmd,
+  sandbox,
+  onStop,
+  claudeCodePlugins,
+  voiceInput,
+}) {
+  /** @type {{ turn: boolean, multiLineBuffer: string[] | null, subagentName: string }} */
+  const state = {
+    turn: true,
+    multiLineBuffer: null,
+    subagentName: "",
+  };
+
+  /**
+   * Active voice input session, or null when not recording.
+   * @type {{ session: VoiceSession, startCursor: number, transcriptLength: number } | null}
+   */
+  let voice = null;
+
+  // Parse the voice toggle key once at startup so misconfiguration fails
+  // loudly instead of silently falling back.
+  const voiceToggle = parseVoiceToggleKey(voiceInput?.toggleKey);
+
+  const getCliPrompt = (subagentName = "", flashMessage = "") =>
+    [
+      "",
+      styleText(
+        ["white", "bgGray"],
+        [
+          ...(subagentName ? [`[${subagentName}]`] : []),
+          `session: ${sessionId} | model: ${modelName} | sandbox: ${sandbox ? "on" : "off"}`,
+        ].join(" "),
+      ),
+      ...(flashMessage ? [flashMessage] : []),
+      "> ",
+    ].join("\n");
+
+  // Cleanup handler to disable bracketed paste mode on exit
+  const cleanup = () => {
+    if (process.stdout.isTTY) {
+      process.stdout.write("\x1b[?2004l");
+    }
+  };
+
+  // Handle exit signals
+  let isExiting = false;
+  const handleExit = async () => {
+    if (isExiting) return;
+    isExiting = true;
+
+    cleanup();
+    const summary = agentCommands.getCostSummary();
+    console.log();
+    console.log(formatCostSummary(summary));
+    await persistUsage(summary, { sessionId, modelName, startTime });
+    await onStop();
+    process.exit(0);
+  };
+
+  // Double-press Ctrl-D exit confirmation
+  let lastCtrlDAttempt = 0;
+  const EXIT_CONFIRM_TIMEOUT = 1500;
+
+  /** @type {import("node:readline").Interface} */
+  let cli;
+
+  /**
+   * Clear the current readline input line and redraw the prompt.
+   * Also aborts multi-line input mode if active.
+   */
+  const resetInput = () => {
+    if (state.multiLineBuffer !== null) {
+      state.multiLineBuffer = null;
+      cli.setPrompt(currentCliPrompt);
+    }
+    cli.write(null, { ctrl: true, name: "a" }); // move to line start
+    cli.write(null, { ctrl: true, name: "k" }); // delete to line end
+    cli.prompt();
+  };
+
+  const stopVoiceSession = async () => {
+    if (!voice) return;
+    const current = voice;
+    voice = null;
+    await current.session.stop();
+    cli.setPrompt(currentCliPrompt);
+    // @ts-expect-error - internal property
+    cli._refreshLine?.();
+  };
+
+  const handleVoiceToggle = () => {
+    // Ignore while the agent is working.
+    if (!state.turn) return;
+
+    if (voice) {
+      stopVoiceSession();
+      return;
+    }
+
+    if (!voiceInput) {
+      cli.setPrompt(
+        getCliPrompt(
+          state.subagentName,
+          styleText(
+            "yellow",
+            `Voice input not configured. Set \`voiceInput\` in your config to enable ${voiceToggle.label}.`,
+          ),
+        ),
+      );
+      cli.prompt(true);
+      return;
+    }
+
+    const startCursor = cli.cursor;
+    const session = startVoiceSession({
+      config: voiceInput,
+      callbacks: {
+        onTranscript: (delta) => {
+          if (!voice) return;
+          const insertAt = voice.startCursor + voice.transcriptLength;
+          // Insert delta at the recording's insertion point. User input is
+          // swallowed while recording, so the buffer around `insertAt` is
+          // stable.
+          const before = cli.line.slice(0, insertAt);
+          const after = cli.line.slice(insertAt);
+          // `line` and `cursor` are declared readonly in the Node typings but
+          // are writable at runtime — the existing code already patches
+          // `_refreshLine` in the same way.
+          const mutableCli = /** @type {{ line: string, cursor: number }} */ (
+            /** @type {unknown} */ (cli)
+          );
+          mutableCli.line = before + delta + after;
+          mutableCli.cursor = insertAt + delta.length;
+          voice.transcriptLength += delta.length;
+          // @ts-expect-error - internal property
+          cli._refreshLine?.();
+        },
+        onError: (err) => {
+          voice = null;
+          cli.setPrompt(
+            getCliPrompt(
+              state.subagentName,
+              styleText("red", `Voice input error: ${err.message}`),
+            ),
+          );
+          cli.prompt(true);
+        },
+        onClose: () => {
+          if (!voice) return;
+          voice = null;
+          cli.setPrompt(currentCliPrompt);
+          // @ts-expect-error - internal property
+          cli._refreshLine?.();
+        },
+      },
+    });
+    voice = { session, startCursor, transcriptLength: 0 };
+    cli.setPrompt(
+      getCliPrompt(
+        state.subagentName,
+        styleText(["red", "bold"], `● REC  (${voiceToggle.label} to stop)`),
+      ),
+    );
+    // @ts-expect-error - internal property
+    cli._refreshLine?.();
+  };
+
+  const handleCtrlC = () => {
+    // Stop voice recording first if active.
+    if (voice) {
+      stopVoiceSession();
+      return;
+    }
+
+    // Agent turn: pause auto-approve; do not clear input.
+    if (!state.turn) {
+      agentCommands.pauseAutoApprove();
+      console.log(
+        styleText(
+          "yellow",
+          "\n\n⚠️ Ctrl-C: Auto-approve paused. Finishing current tool...\nPress Ctrl-D twice to exit.\n",
+        ),
+      );
+      return;
+    }
+
+    // User turn: clear current input. On empty input, show exit hint.
+    const hasInput = cli.line.length > 0 || state.multiLineBuffer !== null;
+    if (hasInput) {
+      resetInput();
+    } else {
+      cli.setPrompt(
+        getCliPrompt(
+          state.subagentName,
+          styleText("yellow", "Press Ctrl-D twice to exit"),
+        ),
+      );
+      cli.prompt();
+    }
+    // Reset Ctrl-D confirmation when Ctrl-C is pressed
+    lastCtrlDAttempt = 0;
+  };
+
+  const handleCtrlD = () => {
+    // User turn with non-empty input: ignore Ctrl-D entirely.
+    if (state.turn && (cli.line.length > 0 || state.multiLineBuffer !== null)) {
+      return;
+    }
+
+    const now = Date.now();
+    if (now - lastCtrlDAttempt < EXIT_CONFIRM_TIMEOUT) {
+      handleExit();
+      return;
+    }
+    lastCtrlDAttempt = now;
+    if (state.turn) {
+      cli.setPrompt(
+        getCliPrompt(
+          state.subagentName,
+          styleText("yellow", "Press Ctrl-D again to exit."),
+        ),
+      );
+      cli.prompt();
+    } else {
+      console.log(styleText("yellow", "\n\n⚠️ Press Ctrl-D again to exit.\n"));
+    }
+  };
+
+  // Pre-readline pipeline:
+  //   stdin -> interrupt (Ctrl-C / Ctrl-D) -> mute (voice recording) -> paste (bracketed paste) -> readline
+  const interrupt = createInterruptTransform({
+    onCtrlC: handleCtrlC,
+    onCtrlD: handleCtrlD,
+    onVoiceToggle: handleVoiceToggle,
+    voiceToggleByte: voiceToggle.byte,
+  });
+  // While a voice session is recording, swallow all stdin bytes other than
+  // Ctrl-C / Ctrl-D / the voice toggle key so transcript insertion stays
+  // consistent.
+  const mute = createMuteTransform({ isMuted: () => voice !== null });
+  const paste = createPasteHandler();
+
+  process.stdin.pipe(interrupt).pipe(mute).pipe(paste.transform);
+
+  // Enable bracketed paste mode
+  if (process.stdout.isTTY) {
+    process.stdout.write("\x1b[?2004h");
+  }
+
+  let currentCliPrompt = getCliPrompt();
+  cli = readline.createInterface({
+    input: paste.transform,
+    output: process.stdout,
+    prompt: currentCliPrompt,
+    completer: createCompleter(() => cli, claudeCodePlugins),
+  });
+
+  // Disable automatic prompt redraw on resize during agent turn
+  // @ts-expect-error - internal property
+  const originalRefreshLine = cli._refreshLine?.bind(cli);
+  if (originalRefreshLine) {
+    // @ts-expect-error - internal property
+    cli._refreshLine = (...args) => {
+      if (state.turn) {
+        originalRefreshLine(...args);
+      }
+    };
+  }
+
+  readline.emitKeypressEvents(process.stdin);
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+
+  // Handle readline close (e.g., stdin closed externally)
+  cli.on("close", handleExit);
+
+  const handleCommand = createCommandHandler({
+    agentCommands,
+    userEventEmitter,
+    claudeCodePlugins,
+    helpMessage: HELP_MESSAGE,
+  });
+
+  /**
+   * Process the complete user input.
+   * @param {string} input
+   * @returns {Promise<void>}
+   */
+  async function processInput(input) {
+    // Prevent concurrent input processing from multi-line paste
+    state.turn = false;
+
+    // Resolve paste placeholders to original content
+    const resolvedInput = paste.resolvePlaceholders(input);
+    const inputTrimmed = resolvedInput.trim();
+
+    if (inputTrimmed.length === 0) {
+      state.turn = true;
+      cli.prompt();
+      return;
+    }
+
+    cli.setPrompt(currentCliPrompt);
+
+    const result = await handleCommand(inputTrimmed);
+    if (result === "prompt") {
+      state.turn = true;
+      cli.prompt();
+    }
+  }
+
+  cli.on("line", async (lineInput) => {
+    if (!state.turn) {
+      console.warn(
+        styleText(
+          "yellow",
+          `\nAgent is working. Ignore input: ${lineInput.trim()}`,
+        ),
+      );
+      return;
+    }
+
+    // Check for multi-line delimiter
+    if (lineInput.trim() === '"""') {
+      if (state.multiLineBuffer === null) {
+        state.multiLineBuffer = [];
+        cli.setPrompt(styleText("gray", "... "));
+        cli.prompt();
+        return;
+      }
+
+      const combined = state.multiLineBuffer.join("\n");
+      state.multiLineBuffer = null;
+      cli.setPrompt(currentCliPrompt);
+
+      await processInput(combined);
+      return;
+    }
+
+    // Accumulate lines if in multi-line mode
+    if (state.multiLineBuffer !== null) {
+      state.multiLineBuffer.push(lineInput);
+      cli.prompt();
+      return;
+    }
+
+    await processInput(lineInput);
+  });
+
+  agentEventEmitter.on("partialMessageContent", (partialContent) => {
+    if (partialContent.position === "start") {
+      const subagentPrefix = state.subagentName
+        ? styleText("cyan", `[${state.subagentName}]\n`)
+        : "";
+      const partialContentStr = styleText("gray", `<${partialContent.type}>`);
+      console.log(`\n${subagentPrefix}${partialContentStr}`);
+    }
+    if (partialContent.content) {
+      if (partialContent.type === "tool_use") {
+        process.stdout.write(styleText("gray", partialContent.content));
+      } else {
+        process.stdout.write(partialContent.content);
+      }
+    }
+    if (partialContent.position === "stop") {
+      console.log(styleText("gray", `\n</${partialContent.type}>`));
+    }
+  });
+
+  agentEventEmitter.on("message", (message) => {
+    printMessage(message).catch((err) => {
+      console.error(
+        styleText("red", `Error rendering message: ${err.message}`),
+      );
+    });
+  });
+
+  agentEventEmitter.on("toolUseRequest", () => {
+    cli.setPrompt(
+      getCliPrompt(
+        state.subagentName,
+        styleText(
+          "yellow",
+          "Approve tool calls? (y = allow once, Y = allow in this session, or feedback)",
+        ),
+      ),
+    );
+  });
+
+  agentEventEmitter.on("subagentSwitched", (subagent) => {
+    state.subagentName = subagent?.name ?? "";
+    currentCliPrompt = getCliPrompt(state.subagentName);
+    cli.setPrompt(currentCliPrompt);
+  });
+
+  agentEventEmitter.on("providerTokenUsage", (usage) => {
+    console.log(formatProviderTokenUsage(usage));
+  });
+
+  agentEventEmitter.on("error", (error) => {
+    console.log(
+      styleText(
+        "red",
+        `\nError: message=${error.message}, stack=${error.stack}`,
+      ),
+    );
+  });
+
+  agentEventEmitter.on("turnEnd", async () => {
+    const err = notify(notifyCmd);
+    if (err) {
+      console.error(
+        styleText("yellow", `\nNotification error: ${err.message}`),
+      );
+    }
+    // 暫定対応: token usageのconsole出力を確実にflushするため、次のevent loop tickまで遅延
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    state.turn = true;
+    cli.prompt();
+  });
+
+  cli.prompt();
+
+  // Register cleanup handlers
+  process.on("exit", cleanup);
+  process.on("SIGTERM", cleanup);
+}

package/src/cliInterruptTransform.mjs

@@ -0,0 +1,51 @@
+import { Transform } from "node:stream";
+
+/**
+ * Create a Transform that intercepts Ctrl-C (0x03), Ctrl-D (0x04), and an
+ * optional "voice toggle" byte (default Ctrl-O, 0x0f). When one of those
+ * bytes is seen anywhere in a chunk, the corresponding callback is invoked
+ * and the entire chunk is dropped so that downstream consumers (e.g.
+ * readline) never observe it. All other input flows through unchanged.
+ *
+ * Priority when multiple handled bytes appear in the same chunk:
+ * Ctrl-C > Ctrl-D > voice toggle.
+ *
+ * @param {object} handlers
+ * @param {() => void} handlers.onCtrlC - Called when Ctrl-C is detected
+ * @param {() => void} handlers.onCtrlD - Called when Ctrl-D is detected
+ * @param {() => void} [handlers.onVoiceToggle]
+ *   Called when the voice toggle byte is detected.
+ * @param {number} [handlers.voiceToggleByte]
+ *   Byte value for the voice toggle key. Defaults to 0x0f (Ctrl-O).
+ * @returns {Transform}
+ */
+export function createInterruptTransform({
+  onCtrlC,
+  onCtrlD,
+  onVoiceToggle,
+  voiceToggleByte = 0x0f,
+}) {
+  const voiceToggleChar = String.fromCharCode(voiceToggleByte);
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      const data = chunk.toString("utf8");
+      if (data.includes("\x03")) {
+        onCtrlC();
+        callback();
+        return;
+      }
+      if (data.includes("\x04")) {
+        onCtrlD();
+        callback();
+        return;
+      }
+      if (onVoiceToggle && data.includes(voiceToggleChar)) {
+        onVoiceToggle();
+        callback();
+        return;
+      }
+      this.push(chunk);
+      callback();
+    },
+  });
+}

package/src/cliMuteTransform.mjs

@@ -0,0 +1,26 @@
+import { Transform } from "node:stream";
+
+/**
+ * Create a Transform that swallows all chunks while `isMuted()` returns true,
+ * and passes them through unchanged while it returns false.
+ *
+ * Intended to sit between `createInterruptTransform` and the paste handler so
+ * that callers can fully silence regular stdin input during special modes
+ * (e.g. while a voice input session is recording) without coupling that
+ * concern to the interrupt-detection logic.
+ *
+ * @param {object} options
+ * @param {() => boolean} options.isMuted
+ *   Called for each incoming chunk; when true the chunk is dropped.
+ * @returns {Transform}
+ */
+export function createMuteTransform({ isMuted }) {
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      if (!isMuted()) {
+        this.push(chunk);
+      }
+      callback();
+    },
+  });
+}