@iinm/plain-agent 1.0.7 → 1.1.0

package/README.md

@@ -141,7 +141,16 @@ Run the agent.
 plain
 
 # Or
-plain -m <model>+<variant>
+plain -m <model+variant>
+```
+
+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
 ```
 
 Display the help message.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iinm/plain-agent",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "description": "A lightweight CLI-based coding agent",
   "license": "MIT",
   "type": "module",

package/src/cliArgs.mjs

@@ -3,6 +3,8 @@
  * @property {string|null} model - Model name with variant
  * @property {boolean} showHelp - Whether to show help message
  * @property {boolean} listModels - Whether to list available models
+ * @property {string|null} batch - Task instruction for batch mode
+ * @property {string[]} config - Paths to additional config files for batch mode
  */
 
 /**
@@ -13,15 +15,25 @@
 export function parseCliArgs(argv) {
   const args = argv.slice(2);
   /** @type {CliArgs} */
-  const result = { model: null, showHelp: false, listModels: false };
+  const result = {
+    model: null,
+    showHelp: false,
+    listModels: false,
+    batch: null,
+    config: [],
+  };
 
   for (let i = 0; i < args.length; i++) {
-    if (args[i] === "-m" && args[i + 1]) {
+    if ((args[i] === "-m" || args[i] === "--model") && args[i + 1]) {
       result.model = args[++i];
     } else if (args[i] === "-h" || args[i] === "--help") {
       result.showHelp = true;
     } else if (args[i] === "-l" || args[i] === "--list-models") {
       result.listModels = true;
+    } else if (args[i] === "--batch" && args[i + 1]) {
+      result.batch = args[++i];
+    } else if (args[i] === "--config" && args[i + 1]) {
+      result.config.push(args[++i]);
     }
   }
 
@@ -35,15 +47,21 @@ export function parseCliArgs(argv) {
 export function printHelp(exitCode = 0) {
   console.log(`
 Usage: agent [options]
+       agent --batch "task instruction" [options]
 
 Options:
-  -m <model+variant>  Model to use
-  -l, --list-models   List available models
+  -m, --model <model+variant>  Model to use
+  -l, --list-models            List available models
   -h, --help          Show this help message
+  --batch <task>      Run in batch mode with the given task instruction
+  --config <file>     Config file to load (required in batch mode)
+                      In batch mode, only explicitly specified config files are loaded
 
 Examples:
-  agent -m claude-sonnet-4-6+thinking-16k
   agent -m gpt-5.4+thinking-medium
+  plain --batch "Add tests for src/main.mjs" \\
+        --config ~/.config/plain-agent/config.local.json \\
+        --config .plain-agent/config.json
 `);
   process.exit(exitCode);
 }

package/src/cliBatch.mjs

@@ -0,0 +1,115 @@
+/**
+ * @import { UserEventEmitter, AgentEventEmitter } from "./agent"
+ */
+
+/**
+ * @typedef {object} BatchSessionOptions
+ * @property {UserEventEmitter} userEventEmitter
+ * @property {AgentEventEmitter} agentEventEmitter
+ * @property {string} task - Task instruction to execute
+ * @property {string} sessionId
+ * @property {string} modelName
+ * @property {boolean} sandbox
+ * @property {() => Promise<void>} onStop
+ */
+
+/**
+ * Start a batch session and execute the task.
+ * Events are output as JSON Lines (1 line = 1 JSON object).
+ *
+ * @param {BatchSessionOptions} options
+ * @returns {Promise<void>}
+ */
+export async function startBatchSession({
+  userEventEmitter,
+  agentEventEmitter,
+  task,
+  sessionId,
+  modelName,
+  sandbox,
+  onStop,
+}) {
+  setupEventHandlers(agentEventEmitter, { sessionId, modelName, sandbox });
+
+  userEventEmitter.emit("userInput", [{ type: "text", text: task }]);
+
+  await new Promise((/** @type {(value?: void) => void} */ resolve) => {
+    agentEventEmitter.on("turnEnd", async () => {
+      outputEvent({
+        type: "session_end",
+        timestamp: new Date().toISOString(),
+      });
+      await onStop();
+      resolve();
+    });
+  });
+
+  process.exit(0);
+}
+
+/**
+ * Setup event handlers for batch mode.
+ * Output events as JSON Lines.
+ *
+ * @param {AgentEventEmitter} agentEventEmitter
+ * @param {{ sessionId: string, modelName: string, sandbox: boolean }} meta
+ */
+function setupEventHandlers(
+  agentEventEmitter,
+  { sessionId, modelName, sandbox },
+) {
+  outputEvent({
+    type: "session_start",
+    sessionId,
+    modelName,
+    sandbox,
+    timestamp: new Date().toISOString(),
+  });
+
+  agentEventEmitter.on("message", (message) => {
+    outputEvent({
+      type: "message",
+      message,
+      timestamp: new Date().toISOString(),
+    });
+  });
+
+  agentEventEmitter.on("error", (error) => {
+    outputEvent({
+      type: "error",
+      error: {
+        message: error.message,
+        stack: error.stack,
+      },
+      timestamp: new Date().toISOString(),
+    });
+
+    process.exit(1);
+  });
+
+  agentEventEmitter.on("subagentSwitched", (subagent) => {
+    outputEvent({
+      type: "subagent_switched",
+      subagent,
+      timestamp: new Date().toISOString(),
+    });
+  });
+
+  agentEventEmitter.on("providerTokenUsage", (usage) => {
+    outputEvent({
+      type: "token_usage",
+      usage,
+      timestamp: new Date().toISOString(),
+    });
+  });
+}
+
+/**
+ * Output an event as JSON Lines format.
+ * Each event is a single line of JSON.
+ *
+ * @param {object} event
+ */
+function outputEvent(event) {
+  console.log(JSON.stringify(event));
+}

package/src/config.mjs

@@ -16,19 +16,37 @@ import {
 import { evalJSONConfig } from "./utils/evalJSONConfig.mjs";
 
 /**
- * @param {Object} [options]
- * @param {boolean} [options.skipTrustCheck] - Skip trust check for config files
+ * @typedef {Object} LoadAppConfigOptions
+ * @property {boolean} [skipTrustCheck] - Skip trust check for config files
+ * @property {string[]} [configFiles] - Additional config files to load (for batch mode)
+ * @property {boolean} [skipUserConfig] - Skip default user config files (for batch mode)
+ */
+
+/**
+ * @param {LoadAppConfigOptions} [options]
  * @returns {Promise<{appConfig: AppConfig, loadedConfigPath: string[]}>}
  */
 export async function loadAppConfig(options = {}) {
-  const { skipTrustCheck = false } = options;
-  const paths = [
-    `${AGENT_ROOT}/.config/config.predefined.json`,
-    `${AGENT_USER_CONFIG_DIR}/config.json`,
-    `${AGENT_USER_CONFIG_DIR}/config.local.json`,
-    `${AGENT_PROJECT_METADATA_DIR}/config.json`,
-    `${AGENT_PROJECT_METADATA_DIR}/config.local.json`,
-  ];
+  const {
+    skipTrustCheck = false,
+    configFiles = [],
+    skipUserConfig = false,
+  } = options;
+
+  // Always load predefined config
+  const paths = [`${AGENT_ROOT}/.config/config.predefined.json`];
+
+  if (!skipUserConfig) {
+    paths.push(
+      `${AGENT_USER_CONFIG_DIR}/config.json`,
+      `${AGENT_USER_CONFIG_DIR}/config.local.json`,
+      `${AGENT_PROJECT_METADATA_DIR}/config.json`,
+      `${AGENT_PROJECT_METADATA_DIR}/config.local.json`,
+    );
+  }
+
+  // Add explicitly specified config files
+  paths.push(...configFiles);
 
   /** @type {string[]} */
   const loadedConfigPath = [];

package/src/main.mjs

@@ -5,6 +5,7 @@
 import { styleText } from "node:util";
 import { createAgent } from "./agent.mjs";
 import { parseCliArgs, printHelp } from "./cliArgs.mjs";
+import { startBatchSession } from "./cliBatch.mjs";
 import { startInteractiveSession } from "./cliInteractive.mjs";
 import { loadAppConfig } from "./config.mjs";
 import { loadAgentRoles } from "./context/loadAgentRoles.mjs";
@@ -56,22 +57,31 @@ if (cliArgs.listModels) {
       `0${startTime.getMinutes()}`.slice(-2),
   ].join("-");
   const tmuxSessionId = `agent-${sessionId}`;
-  const { appConfig, loadedConfigPath } = await loadAppConfig();
+  const isBatchMode = Boolean(cliArgs.batch);
 
-  if (loadedConfigPath.length > 0) {
-    console.log(styleText("green", "\n⚡ Loaded configuration files"));
-    console.log(loadedConfigPath.map((p) => `  ⤷ ${p}`).join("\n"));
-  }
+  const { appConfig, loadedConfigPath } = await loadAppConfig({
+    skipUserConfig: isBatchMode,
+    skipTrustCheck: isBatchMode,
+    configFiles: cliArgs.config,
+  });
 
-  if (appConfig.sandbox) {
-    const sandboxStr = [
-      appConfig.sandbox.command,
-      ...(appConfig.sandbox.args || []),
-    ].join(" ");
-    console.log(styleText("green", "\n📦 Sandbox: on"));
-    console.log(`  ⤷ ${sandboxStr}`);
-  } else {
-    console.log(styleText("yellow", "\n📦 Sandbox: off"));
+  // In batch mode, skip human-readable output
+  if (!isBatchMode) {
+    if (loadedConfigPath.length > 0) {
+      console.log(styleText("green", "\n⚡ Loaded configuration files"));
+      console.log(loadedConfigPath.map((p) => `  ⤷ ${p}`).join("\n"));
+    }
+
+    if (appConfig.sandbox) {
+      const sandboxStr = [
+        appConfig.sandbox.command,
+        ...(appConfig.sandbox.args || []),
+      ].join(" ");
+      console.log(styleText("green", "\n📦 Sandbox: on"));
+      console.log(`  ⤷ ${sandboxStr}`);
+    } else {
+      console.log(styleText("yellow", "\n📦 Sandbox: off"));
+    }
   }
 
   /** @type {(() => Promise<void>)[]} */
@@ -82,11 +92,13 @@ if (cliArgs.listModels) {
   if (appConfig.mcpServers) {
     const mcpServerEntries = Object.entries(appConfig.mcpServers);
 
-    console.log();
-    for (const [serverName] of mcpServerEntries) {
-      console.log(
-        styleText("blue", `🔌 Connecting to MCP server: ${serverName}...`),
-      );
+    if (!isBatchMode) {
+      console.log();
+      for (const [serverName] of mcpServerEntries) {
+        console.log(
+          styleText("blue", `🔌 Connecting to MCP server: ${serverName}...`),
+        );
+      }
     }
 
     const mcpResults = await Promise.all(
@@ -99,12 +111,14 @@ if (cliArgs.listModels) {
     for (const { serverName, tools, cleanup } of mcpResults) {
       mcpTools.push(...tools);
       mcpCleanups.push(cleanup);
-      console.log(
-        styleText(
-          "green",
-          `✅ Successfully connected to MCP server: ${serverName}`,
-        ),
-      );
+      if (!isBatchMode) {
+        console.log(
+          styleText(
+            "green",
+            `✅ Successfully connected to MCP server: ${serverName}`,
+          ),
+        );
+      }
     }
   }
 
@@ -196,21 +210,35 @@ if (cliArgs.listModels) {
     agentRoles,
   });
 
-  startInteractiveSession({
+  const sessionOptions = {
     userEventEmitter,
     agentEventEmitter,
     agentCommands,
     sessionId,
     modelName: modelNameWithVariant,
-    notifyCmd: appConfig.notifyCmd || AGENT_NOTIFY_CMD_DEFAULT,
     sandbox: Boolean(appConfig.sandbox),
     onStop: async () => {
       for (const cleanup of mcpCleanups) {
         await cleanup();
       }
     },
-    claudeCodePlugins: appConfig.claudeCodePlugins,
-  });
+  };
+
+  if (isBatchMode) {
+    if (!cliArgs.batch) {
+      throw new Error("Batch task is required in batch mode");
+    }
+    await startBatchSession({
+      ...sessionOptions,
+      task: cliArgs.batch,
+    });
+  } else {
+    startInteractiveSession({
+      ...sessionOptions,
+      notifyCmd: appConfig.notifyCmd || AGENT_NOTIFY_CMD_DEFAULT,
+      claudeCodePlugins: appConfig.claudeCodePlugins,
+    });
+  }
 })().catch((err) => {
   console.error(err);
   process.exit(1);