@iinm/plain-agent 1.6.0 → 1.7.0

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/README.md

@@ -238,9 +238,10 @@ Run in batch mode (non-interactive).
 In batch mode, config files are not loaded automatically. Only the files specified with `--config` are loaded.
 
 ```sh
-plain batch "Add tests for src/main.mjs" \
-      --config ~/.config/plain-agent/config.local.json \
-      --config .plain-agent/config.json
+plain batch \
+      -c ~/.config/plain-agent/config.local.json \
+      -c .plain-agent/config.json \
+      "Add tests for ..."
 ```
 
 Display the help message.
@@ -249,11 +250,9 @@ Display the help message.
 /help
 ```
 
-Interrupt the agent while it's running by providing additional instructions:
+Interrupt the agent while it's running:
 
-```sh
-plain-interrupt Stop and report the progress
-```
+Press **Ctrl-C** to pause auto-approve. The agent will finish the current tool call, then return to the prompt.
 
 ## Available Tools
 
@@ -281,7 +280,6 @@ The agent can use the following tools to assist with tasks:
   \__ .plain-agent/
         \__ config.json            # Project-specific configuration
         \__ config.local.json      # Project-specific local configuration (including secrets)
-        \__ interrupt-message.txt  # Interrupt message consumed by the agent
         \__ memory/                # Task-specific memory files
         \__ prompts/               # Project-specific prompts
         \__ agents/                # Project-specific agent roles

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iinm/plain-agent",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "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/agent.d.ts

@@ -21,6 +21,7 @@ export type AgentCommands = {
   dumpMessages: () => Promise<void>;
   loadMessages: () => Promise<void>;
   getCostSummary: () => CostSummary;
+  pauseAutoApprove: () => void;
 };
 
 type UserEventMap = {

package/src/agent.mjs

@@ -144,6 +144,16 @@ export function createAgent({
     }
   }
 
+  // Pause signal: set by Ctrl-C during agent execution, checked after each tool batch completes
+  let paused = false;
+  /** @type {import("./agentLoop.mjs").PauseSignal} */
+  const pauseSignal = {
+    isPaused: () => paused,
+    reset: () => {
+      paused = false;
+    },
+  };
+
   const agentLoop = createAgentLoop({
     callModel,
     stateManager,
@@ -152,6 +162,7 @@ export function createAgent({
     agentEventEmitter,
     toolUseApprover,
     subagentManager,
+    pauseSignal,
   });
 
   userEventEmitter.on("userInput", agentLoop.handleUserInput);
@@ -163,6 +174,9 @@ export function createAgent({
       dumpMessages,
       loadMessages,
       getCostSummary: () => costTracker.calculateCost(),
+      pauseAutoApprove: () => {
+        paused = true;
+      },
     },
   };
 }

package/src/agentLoop.mjs

@@ -7,7 +7,12 @@
  */
 
 import { styleText } from "node:util";
-import { consumeInterruptMessage } from "./context/consumeInterruptMessage.mjs";
+
+/**
+ * @typedef {Object} PauseSignal
+ * @property {() => boolean} isPaused - Returns true if auto-approve should be paused
+ * @property {() => void} reset - Resets the paused state
+ */
 
 /**
  * @typedef {Object} AgentLoopConfig
@@ -18,6 +23,7 @@ import { consumeInterruptMessage } from "./context/consumeInterruptMessage.mjs";
  * @property {AgentEventEmitter} agentEventEmitter - Event emitter for agent events
  * @property {ToolUseApprover} toolUseApprover - Tool use approval checker
  * @property {SubagentManager} subagentManager - Subagent manager instance
+ * @property {PauseSignal} pauseSignal - Signal to pause auto-approve after current tool completes
  */
 
 /**
@@ -36,6 +42,7 @@ export function createAgentLoop({
   agentEventEmitter,
   toolUseApprover,
   subagentManager,
+  pauseSignal,
 }) {
   const inputHandler = createInputHandler({
     stateManager,
@@ -198,14 +205,10 @@ export function createAgentLoop({
         stateManager.appendMessages([{ role: "user", content: toolResults }]);
       }
 
-      const interruptMessage = await consumeInterruptMessage();
-      if (interruptMessage) {
-        stateManager.appendMessages([
-          {
-            role: "user",
-            content: [{ type: "text", text: interruptMessage }],
-          },
-        ]);
+      // Check if auto-approve was paused by Ctrl-C during tool execution
+      if (pauseSignal.isPaused()) {
+        pauseSignal.reset();
+        break;
       }
     }
   }

package/src/cliArgs.mjs

@@ -125,10 +125,12 @@ Usage: plain [options]
 Options:
   -m, --model <model+variant>  Model to use
   -h, --help                   Show this help message
-  -c, --config <file>          Config file to load
+  -c, --config <file>          Config file to load (repeatable)
 
 Subcommands:
-  batch <task>                 Run in batch mode with the given task instruction
+  batch <task>                 Run in batch mode with the given task instruction.
+                               Config files are NOT auto-loaded in batch mode;
+                               use -c to specify config files explicitly.
   list-models                  List available models
   install-claude-code-plugins  Install Claude Code plugins
 
@@ -137,9 +139,7 @@ Examples:
   plain batch \\
         -c ~/.config/plain-agent/config.local.json \\
         -c .plain-agent/config.json \\
-        "Add tests for src/main.mjs"
-  plain list-models
-  plain install-claude-code-plugins
+        "Add tests for ..."
 `);
   process.exit(exitCode);
 }

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";
+  };
+}