@iinm/plain-agent 1.5.4 → 1.6.1

package/.config/config.predefined.json

@@ -745,7 +745,7 @@
         "unit": "1M",
         "costs": {
           "input_tokens": 0.75,
-          "cached_tokens": -0.675,
+          "input_tokens_details.cached_tokens": -0.675,
           "output_tokens": 4.5
         }
       }
@@ -772,7 +772,7 @@
         "unit": "1M",
         "costs": {
           "input_tokens": 0.75,
-          "cached_tokens": -0.675,
+          "input_tokens_details.cached_tokens": -0.675,
           "output_tokens": 4.5
         }
       }
@@ -799,7 +799,7 @@
         "unit": "1M",
         "costs": {
           "input_tokens": 0.75,
-          "cached_tokens": -0.675,
+          "input_tokens_details.cached_tokens": -0.675,
           "output_tokens": 4.5
         }
       }
@@ -826,7 +826,7 @@
         "unit": "1M",
         "costs": {
           "input_tokens": 2.5,
-          "cached_tokens": -2.25,
+          "input_tokens_details.cached_tokens": -2.25,
           "output_tokens": 15
         }
       }
@@ -853,7 +853,7 @@
         "unit": "1M",
         "costs": {
           "input_tokens": 2.5,
-          "cached_tokens": -2.25,
+          "input_tokens_details.cached_tokens": -2.25,
           "output_tokens": 15
         }
       }
@@ -880,7 +880,7 @@
         "unit": "1M",
         "costs": {
           "input_tokens": 2.5,
-          "cached_tokens": -2.25,
+          "input_tokens_details.cached_tokens": -2.25,
           "output_tokens": 15
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iinm/plain-agent",
-  "version": "1.5.4",
+  "version": "1.6.1",
   "description": "A lightweight CLI-based coding agent",
   "license": "MIT",
   "type": "module",
@@ -36,11 +36,11 @@
   },
   "dependencies": {
     "@aws-crypto/sha256-js": "^5.2.0",
-    "@aws-sdk/credential-providers": "^3.1024.0",
+    "@aws-sdk/credential-providers": "^3.1026.0",
     "@cfworker/json-schema": "^4.1.1",
     "@modelcontextprotocol/client": "^2.0.0-alpha.2",
-    "@smithy/protocol-http": "^5.3.12",
-    "@smithy/signature-v4": "^5.3.12",
+    "@smithy/protocol-http": "^5.3.13",
+    "@smithy/signature-v4": "^5.3.13",
     "diff": "^8.0.4",
     "js-yaml": "^4.1.1"
   },

package/src/cliCommands.mjs

@@ -0,0 +1,270 @@
+/**
+ * @import { UserEventEmitter, AgentCommands } from "./agent"
+ * @import { ClaudeCodePlugin } from "./claudeCodePlugin.mjs"
+ */
+
+import { execFileSync } from "node:child_process";
+import { styleText } from "node:util";
+import { formatCostSummary } from "./cliFormatter.mjs";
+import { loadAgentRoles } from "./context/loadAgentRoles.mjs";
+import { loadPrompts } from "./context/loadPrompts.mjs";
+import { loadUserMessageContext } from "./context/loadUserMessageContext.mjs";
+import { CLAUDE_CODE_COMPATIBILITY_NOTES } from "./prompt.mjs";
+import { parseFileRange } from "./utils/parseFileRange.mjs";
+import { readFileRange } from "./utils/readFileRange.mjs";
+
+/**
+ * @typedef {"prompt" | "continue"} CommandResult
+ * - "prompt": return control to prompt (state.turn = true; cli.prompt())
+ * - "continue": agent is now running, do nothing
+ */
+
+/**
+ * @typedef {object} CommandHandlerDeps
+ * @property {AgentCommands} agentCommands
+ * @property {UserEventEmitter} userEventEmitter
+ * @property {ClaudeCodePlugin[] | undefined} claudeCodePlugins
+ * @property {string} helpMessage
+ */
+
+/**
+ * Create command handler function for processing slash commands.
+ *
+ * @param {CommandHandlerDeps} deps
+ * @returns {(input: string) => Promise<CommandResult>}
+ */
+export function createCommandHandler({
+  agentCommands,
+  userEventEmitter,
+  claudeCodePlugins,
+  helpMessage,
+}) {
+  /**
+   * Invoke an agent with the given id and goal.
+   * @param {string} id
+   * @param {string} goal
+   * @returns {Promise<CommandResult>}
+   */
+  async function invokeAgent(id, goal) {
+    const agentRoles = await loadAgentRoles(claudeCodePlugins);
+    const agent = agentRoles.get(id);
+    const name = agent ? id : `custom:${id}`;
+
+    const [goalTextContent, ...goalImages] = await loadUserMessageContext(goal);
+    const goalText =
+      goalTextContent?.type === "text" ? goalTextContent.text : goal;
+
+    const messageText = `Delegate to "${name}" agent with goal: ${goalText}`;
+    userEventEmitter.emit("userInput", [
+      { type: "text", text: messageText },
+      ...goalImages,
+    ]);
+    return "continue";
+  }
+
+  /**
+   * Invoke a prompt with the given id, args, and display invocation.
+   * @param {string} id
+   * @param {string} args
+   * @param {string} displayInvocation
+   * @returns {Promise<CommandResult>}
+   */
+  async function invokePrompt(id, args, displayInvocation) {
+    const prompts = await loadPrompts(claudeCodePlugins);
+    const prompt = prompts.get(id);
+
+    if (!prompt) {
+      console.log(styleText("red", `\nPrompt not found: ${id}`));
+      return "prompt";
+    }
+
+    const [argsTextContent, ...argsImages] = args
+      ? await loadUserMessageContext(args)
+      : [];
+    const argsText =
+      argsTextContent?.type === "text" ? argsTextContent.text : args;
+
+    const invocation = `${displayInvocation}${argsText ? ` ${argsText}` : ""}`;
+    const promptContent = prompt.claudeOriginated
+      ? `${prompt.content}\n\n---\n\n${CLAUDE_CODE_COMPATIBILITY_NOTES}`
+      : prompt.content;
+    const message = prompt.isSkill
+      ? `System: This prompt was invoked as "${invocation}".\nPrompt path: ${prompt.filePath}\n\n${promptContent}`
+      : `System: This prompt was invoked as "${invocation}".\n\n${promptContent}`;
+
+    userEventEmitter.emit("userInput", [
+      { type: "text", text: message },
+      ...argsImages,
+    ]);
+    return "continue";
+  }
+
+  /**
+   * Handle a complete user input string and return a CommandResult.
+   * @param {string} inputTrimmed
+   * @returns {Promise<CommandResult>}
+   */
+  return async function handleCommand(inputTrimmed) {
+    // /help or help
+    if (["/help", "help"].includes(inputTrimmed.toLowerCase())) {
+      console.log(`\n${helpMessage}`);
+      return "prompt";
+    }
+
+    // !path — read file content and emit as user input
+    if (inputTrimmed.startsWith("!")) {
+      const fileRange = parseFileRange(inputTrimmed.slice(1));
+      if (fileRange instanceof Error) {
+        console.log(styleText("red", `\n${fileRange.message}`));
+        return "prompt";
+      }
+
+      const fileContent = await readFileRange(fileRange);
+      if (fileContent instanceof Error) {
+        console.log(styleText("red", `\n${fileContent.message}`));
+        return "prompt";
+      }
+
+      const messageWithContext = await loadUserMessageContext(fileContent);
+      userEventEmitter.emit("userInput", messageWithContext);
+      return "continue";
+    }
+
+    // /dump
+    if (inputTrimmed.toLowerCase() === "/dump") {
+      await agentCommands.dumpMessages();
+      return "prompt";
+    }
+
+    // /load
+    if (inputTrimmed.toLowerCase() === "/load") {
+      await agentCommands.loadMessages();
+      return "prompt";
+    }
+
+    // /cost
+    if (inputTrimmed.toLowerCase() === "/cost") {
+      const summary = agentCommands.getCostSummary();
+      console.log(formatCostSummary(summary));
+      return "prompt";
+    }
+
+    // /agents or /agents:id
+    if (inputTrimmed === "/agents") {
+      const agentRoles = await loadAgentRoles(claudeCodePlugins);
+
+      console.log(styleText("bold", "\nAvailable Agent Roles:"));
+      if (agentRoles.size === 0) {
+        console.log("  No agent roles found.");
+      } else {
+        for (const role of agentRoles.values()) {
+          const maxLength = process.stdout.columns ?? 100;
+          const line = `  ${styleText("cyan", role.id.padEnd(20))} - ${role.description}`;
+          console.log(
+            line.length > maxLength ? `${line.slice(0, maxLength)}...` : line,
+          );
+        }
+      }
+      return "prompt";
+    }
+
+    if (inputTrimmed.startsWith("/agents:")) {
+      const match = inputTrimmed.match(/^\/agents:([^ ]+)(?:\s+(.*))?$/s);
+      if (!match) {
+        console.log(styleText("red", "\nInvalid agent invocation format."));
+        return "prompt";
+      }
+      return await invokeAgent(match[1], match[2] || "");
+    }
+
+    // /prompts or /prompts:id
+    if (inputTrimmed.startsWith("/prompts")) {
+      const prompts = await loadPrompts(claudeCodePlugins);
+
+      if (inputTrimmed === "/prompts") {
+        console.log(styleText("bold", "\nAvailable Prompts:"));
+        if (prompts.size === 0) {
+          console.log("  No prompts found.");
+        } else {
+          for (const prompt of prompts.values()) {
+            const maxLength = process.stdout.columns ?? 100;
+            const line = `  ${styleText("cyan", prompt.id.padEnd(20))} - ${prompt.description}`;
+            console.log(
+              line.length > maxLength ? `${line.slice(0, maxLength)}...` : line,
+            );
+          }
+        }
+        return "prompt";
+      }
+
+      if (inputTrimmed.startsWith("/prompts:")) {
+        const match = inputTrimmed.match(/^\/prompts:([^ ]+)(?:\s+(.*))?$/s);
+        if (!match) {
+          console.log(styleText("red", "\nInvalid prompt invocation format."));
+          return "prompt";
+        }
+        return await invokePrompt(
+          match[1],
+          match[2] || "",
+          `/prompts:${match[1]}`,
+        );
+      }
+    }
+
+    // /paste — read clipboard and emit as user input
+    if (inputTrimmed.startsWith("/paste")) {
+      const prompt = inputTrimmed.slice("/paste".length).trim();
+      let clipboard;
+      try {
+        if (process.platform === "darwin") {
+          clipboard = execFileSync("pbpaste", { encoding: "utf8" });
+        } else if (process.platform === "linux") {
+          clipboard = execFileSync("xsel", ["--clipboard", "--output"], {
+            encoding: "utf8",
+          });
+        } else {
+          console.log(
+            styleText(
+              "red",
+              `\nUnsupported platform for /paste: ${process.platform}`,
+            ),
+          );
+          return "prompt";
+        }
+      } catch (e) {
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        console.log(
+          styleText(
+            "red",
+            `\nFailed to get clipboard content: ${errorMessage}`,
+          ),
+        );
+        return "prompt";
+      }
+
+      const combinedInput = prompt ? `${prompt}\n\n${clipboard}` : clipboard;
+      const messageWithContext = await loadUserMessageContext(combinedInput);
+      userEventEmitter.emit("userInput", messageWithContext);
+      return "continue";
+    }
+
+    // /<id> — shortcut for prompts in shortcuts/ directory
+    if (inputTrimmed.startsWith("/")) {
+      const match = inputTrimmed.match(/^\/([^ ]+)(?:\s+(.*))?$/);
+      if (match) {
+        const id = match[1];
+        const prompts = await loadPrompts(claudeCodePlugins);
+        const prompt = prompts.get(id);
+
+        if (prompt?.isShortcut) {
+          return await invokePrompt(id, match[2] || "", `/${id}`);
+        }
+      }
+    }
+
+    // Default: emit as plain user input
+    const messageWithContext = await loadUserMessageContext(inputTrimmed);
+    userEventEmitter.emit("userInput", messageWithContext);
+    return "continue";
+  };
+}

package/src/cliCompleter.mjs

@@ -0,0 +1,222 @@
+/**
+ * @import { ClaudeCodePlugin } from "./claudeCodePlugin.mjs"
+ */
+
+import { styleText } from "node:util";
+import { loadAgentRoles } from "./context/loadAgentRoles.mjs";
+import { loadPrompts } from "./context/loadPrompts.mjs";
+
+// Define available slash commands for tab completion
+export const SLASH_COMMANDS = [
+  { name: "/help", description: "Display this help message" },
+  { name: "/agents", description: "List available agent roles" },
+  {
+    name: "/agents:<id>",
+    description:
+      "Delegate to an agent with the given ID (e.g., /agents:code-simplifier)",
+  },
+  { name: "/prompts", description: "List available prompts" },
+  {
+    name: "/prompts:<id>",
+    description:
+      "Invoke a prompt with the given ID (e.g., /prompts:feature-dev)",
+  },
+  {
+    name: "/<id>",
+    description:
+      "Shortcut for prompts in the shortcuts/ directory (e.g., /commit)",
+  },
+  { name: "/paste", description: "Paste content from clipboard" },
+  {
+    name: "/resume",
+    description: "Resume conversation after an LLM provider error",
+  },
+  { name: "/dump", description: "Save current messages to a JSON file" },
+  { name: "/load", description: "Load messages from a JSON file" },
+  { name: "/cost", description: "Display session cost and token usage" },
+];
+
+/**
+ * @typedef {Object} CompletionCandidate
+ * @property {string} name
+ * @property {string} description
+ */
+
+/**
+ * Find candidates that match the line, prioritizing prefix matches.
+ * @param {(string | CompletionCandidate)[]} candidates
+ * @param {string} line
+ * @param {number} queryStartIndex
+ * @returns {(string | CompletionCandidate)[]}
+ */
+function findMatches(candidates, line, queryStartIndex) {
+  const query = line.slice(queryStartIndex);
+  const prefixMatches = [];
+  const partialMatches = [];
+
+  for (const candidate of candidates) {
+    const name = typeof candidate === "string" ? candidate : candidate.name;
+    if (name.startsWith(line)) {
+      prefixMatches.push(candidate);
+    } else if (
+      query.length > 0 &&
+      name.slice(queryStartIndex).includes(query)
+    ) {
+      partialMatches.push(candidate);
+    }
+  }
+
+  return [...prefixMatches, ...partialMatches];
+}
+
+/**
+ * Return the longest common prefix of the given strings.
+ * @param {string[]} strings
+ * @returns {string}
+ */
+function commonPrefix(strings) {
+  if (strings.length === 0) return "";
+  let prefix = strings[0];
+  for (let i = 1; i < strings.length; i++) {
+    while (!strings[i].startsWith(prefix)) {
+      prefix = prefix.slice(0, -1);
+    }
+  }
+  return prefix;
+}
+
+/**
+ * Display completion candidates and invoke the readline callback.
+ *
+ * Node.js readline normally requires two consecutive Tab presses to show the
+ * candidate list. This helper lets readline handle the common-prefix
+ * auto-completion first, then prints the candidate list on the next tick and
+ * redraws the prompt so the display stays clean.
+ *
+ * @param {import("node:readline").Interface} rl
+ * @param {(string | CompletionCandidate)[]} candidates
+ * @param {string} line
+ * @param {(err: Error | null, result: [string[], string]) => void} callback
+ */
+function showCompletions(rl, candidates, line, callback) {
+  const names = candidates.map((c) => (typeof c === "string" ? c : c.name));
+  if (candidates.length <= 1) {
+    callback(null, [names, line]);
+    return;
+  }
+  const prefix = commonPrefix(names);
+  if (prefix.length > line.length) {
+    // Let readline insert the common prefix.
+    callback(null, [[prefix], line]);
+  } else {
+    // Nothing new to insert.
+    callback(null, [[], line]);
+  }
+  // After readline finishes its own refresh, print the candidate list and
+  // redraw the prompt line.  We cannot use rl.prompt(true) because its
+  // internal _refreshLine clears everything below the prompt start, which
+  // erases the candidate list we just wrote.  Instead we manually re-output
+  // the prompt and current line content.
+  setTimeout(() => {
+    const maxLength = process.stdout.columns ?? 100;
+    const list = candidates
+      .map((c) => {
+        if (typeof c === "string") return c;
+        const nameText = c.name.padEnd(25);
+        const separator = " - ";
+        const descText = c.description;
+
+        // 画面幅に合わせて説明文をカット（色を付ける前に計算）
+        const availableWidth =
+          maxLength - nameText.length - separator.length - 3;
+        const displayDesc =
+          descText.length > availableWidth && availableWidth > 0
+            ? `${descText.slice(0, availableWidth)}...`
+            : descText;
+
+        const name = styleText("cyan", nameText);
+        const description = styleText("dim", displayDesc);
+        return `${name}${separator}${description}`;
+      })
+      .join("\r\n");
+    process.stdout.write(`\r\n${list}\r\n`);
+    process.stdout.write(`${rl.getPrompt()}${rl.line}`);
+  }, 0);
+}
+
+/**
+ * Create a completer function for readline.
+ *
+ * Because the readline.Interface instance (`cli`) is not available until after
+ * `readline.createInterface` returns, we accept a getter function so the
+ * completer can resolve the reference lazily at call time.
+ *
+ * @param {() => import("node:readline").Interface} getCliRef - A function that returns the readline Interface
+ * @param {ClaudeCodePlugin[] | undefined} claudeCodePlugins
+ * @returns {(line: string, callback: (err?: Error | null, result?: [string[], string]) => void) => void}
+ */
+export function createCompleter(getCliRef, claudeCodePlugins) {
+  return (line, callback) => {
+    (async () => {
+      try {
+        const cli = getCliRef();
+        const prompts = await loadPrompts(claudeCodePlugins);
+        const agentRoles = await loadAgentRoles(claudeCodePlugins);
+
+        if (line.startsWith("/agents:")) {
+          const prefix = "/agents:";
+          const candidates = Array.from(agentRoles.values()).map((a) => ({
+            name: `${prefix}${a.id}`,
+            description: a.description,
+          }));
+          const hits = findMatches(candidates, line, prefix.length);
+
+          showCompletions(cli, hits, line, callback);
+          return;
+        }
+
+        if (line.startsWith("/prompts:")) {
+          const prefix = "/prompts:";
+          const candidates = Array.from(prompts.values()).map((p) => ({
+            name: `${prefix}${p.id}`,
+            description: p.description,
+          }));
+          const hits = findMatches(candidates, line, prefix.length);
+
+          showCompletions(cli, hits, line, callback);
+          return;
+        }
+
+        if (line.startsWith("/")) {
+          const shortcuts = Array.from(prompts.values())
+            .filter((p) => p.isShortcut)
+            .map((p) => ({
+              name: `/${p.id}`,
+              description: p.description,
+            }));
+
+          const allCommands = [...SLASH_COMMANDS, ...shortcuts].filter(
+            (cmd) => {
+              const name = typeof cmd === "string" ? cmd : cmd.name;
+              return (
+                name !== "/<id>" &&
+                (name === "/agents:" || !name.startsWith("/agent:")) &&
+                (name === "/prompts:" || !name.startsWith("/prompt:"))
+              );
+            },
+          );
+
+          const hits = findMatches(allCommands, line, 1);
+
+          showCompletions(cli, hits, line, callback);
+          return;
+        }
+
+        callback(null, [[], line]);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        callback(error, [[], line]);
+      }
+    })();
+  };
+}

package/src/cliFormatter.mjs

@@ -1,5 +1,5 @@
 /**
- * @import { MessageContentToolUse, MessageContentToolResult, ProviderTokenUsage } from "./model"
+ * @import { Message, MessageContentToolUse, MessageContentToolResult, ProviderTokenUsage } from "./model"
  * @import { ExecCommandInput } from "./tools/execCommand"
  * @import { PatchFileInput } from "./tools/patchFile"
  * @import { WriteFileInput } from "./tools/writeFile"
@@ -266,3 +266,65 @@ export function formatCostForBatch(summary) {
     ),
   };
 }
+
+/**
+ * Print a message to the console.
+ * @param {Message} message
+ */
+export function printMessage(message) {
+  switch (message.role) {
+    case "assistant": {
+      // console.log(styleText("bold", "\nAgent:"));
+      for (const part of message.content) {
+        switch (part.type) {
+          // Note: Streamで表示するためここでは表示しない
+          // case "thinking":
+          //   console.log(
+          //     [
+          //       styleText("blue", "<thinking>"),
+          //       part.thinking,
+          //       styleText("blue", "</thinking>\n"),
+          //     ].join("\n"),
+          //   );
+          //   break;
+          // case "text":
+          //   console.log(part.text);
+          //   break;
+          case "tool_use":
+            console.log(styleText("bold", "\nTool call:"));
+            console.log(formatToolUse(part));
+            break;
+        }
+      }
+      break;
+    }
+    case "user": {
+      for (const part of message.content) {
+        switch (part.type) {
+          case "tool_result": {
+            console.log(styleText("bold", "\nTool result:"));
+            console.log(formatToolResult(part));
+            break;
+          }
+          case "text": {
+            console.log(styleText("bold", "\nUser:"));
+            console.log(part.text);
+            break;
+          }
+          case "image": {
+            break;
+          }
+          default: {
+            console.log(styleText("bold", "\nUnknown Message Format:"));
+            console.log(JSON.stringify(part, null, 2));
+          }
+        }
+      }
+      break;
+    }
+    default: {
+      console.log(styleText("bold", "\nUnknown Message Format:"));
+      console.log(JSON.stringify(message, null, 2));
+    }
+  }
+}