@iinm/plain-agent 1.10.5 → 1.10.7

package/README.md

@@ -381,7 +381,7 @@ Files are loaded in the following order. Settings in later files override earlie
           "args": ["ci"]
         },
         "mode": "sandbox",
-        "extraArgs": ["--allow-net", "0.0.0.0/0"]
+        "additionalArgs": ["--allow-net", "0.0.0.0/0"]
       }
     ]
   }

package/bin/plain

@@ -1,3 +1,8 @@
 #!/usr/bin/env node
 
-import("../src/main.mjs");
+import { main } from "../src/main.mjs";
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iinm/plain-agent",
-  "version": "1.10.5",
+  "version": "1.10.7",
   "description": "A lightweight CLI-based coding agent",
   "license": "MIT",
   "type": "module",
@@ -31,6 +31,7 @@
   "scripts": {
     "check": "npm run lint && tsc && npm run test",
     "test": "node --test",
+    "coverage": "node --experimental-test-coverage --test",
     "lint": "npx @biomejs/biome check",
     "fix": "npx @biomejs/biome check --fix"
   },

package/src/cli/formatter.mjs

@@ -428,6 +428,21 @@ export async function printMessage(message) {
     }
   }
 }
+/**
+ * Convert **bold** Markdown to ANSI bold terminal escape codes.
+ * Only matches when ** is preceded by whitespace or line start
+ * and followed by whitespace, line end, or punctuation — so inline
+ * code like `**bold**` is left untouched.
+ * @param {string} text
+ * @returns {string}
+ */
+export function applyInlineMarkdown(text) {
+  return text.replace(
+    /(?<=\s|^)\*\*(.+?)\*\*(?=[\s.,;:!?)〕）】」』]|$)/g,
+    (_, c) => styleText("bold", c),
+  );
+}
+
 /**
  * Format markdown table lines with aligned columns.
  * Input lines may have leading/trailing pipes.

package/src/cli/interactive.mjs

@@ -22,7 +22,7 @@ import {
 import { createInterruptTransform } from "./interruptTransform.mjs";
 import { createMuteTransform } from "./muteTransform.mjs";
 import { createPasteHandler } from "./pasteTransform.mjs";
-import { createTableDetector } from "./tableDetector.mjs";
+import { createStreamFormatter } from "./streamFormatter.mjs";
 
 const HELP_MESSAGE = [
   "Commands:",
@@ -130,8 +130,8 @@ export function startInteractiveSession({
    */
   let voice = null;
 
-  // Create the table buffer instance for this session
-  const tableBuffer = createTableBuffer();
+  // Create the stream buffer instance for this session
+  const streamBuffer = createStreamBuffer();
 
   // Parse the voice toggle key once at startup so misconfiguration fails
   // loudly instead of silently falling back.
@@ -494,7 +494,7 @@ export function startInteractiveSession({
           );
         }
       } else if (partialContent.type === "text") {
-        tableBuffer.feed(partialContent.content);
+        streamBuffer.feed(partialContent.content);
       } else {
         process.stdout.write(partialContent.content);
       }
@@ -502,9 +502,11 @@ export function startInteractiveSession({
     if (partialContent.position === "stop") {
       if (partialContent.type === "tool_use") {
         process.stdout.write(
-          `\r\x1b[K${styleText("gray", `<${partialContent.type}>`)} ${styleText("green", "✓")}\n`,
+          `\r\x1b[K${styleText("gray", `<${partialContent.type}>`)}\n`,
         );
       } else {
+        // Flush any buffered text before printing the closing tag
+        streamBuffer.forceFlush();
         console.log(styleText("gray", `\n</${partialContent.type}>`));
       }
     }
@@ -556,8 +558,8 @@ export function startInteractiveSession({
   });
 
   agentEventEmitter.on("turnEnd", async () => {
-    // Flush any remaining table buffer content
-    tableBuffer.forceFlush();
+    // Flush any remaining stream buffer content
+    streamBuffer.forceFlush();
 
     const err = notify(notifyCmd);
     if (err) {
@@ -584,21 +586,20 @@ export function startInteractiveSession({
 }
 
 /**
- * Creates a table buffer for detecting and formatting markdown tables
- * in streaming text output.
- * Thin shell: delegates pure logic to createTableDetector and handles I/O.
+ * Creates a stream buffer for formatting streaming text output.
+ * Thin shell: delegates pure logic to createStreamFormatter and handles I/O.
  */
-function createTableBuffer() {
-  const detector = createTableDetector();
+function createStreamBuffer() {
+  const formatter = createStreamFormatter();
 
   function feed(/** @type {string} */ chunk) {
-    const { output, warnings } = detector.feed(chunk);
+    const { output, warnings } = formatter.feed(chunk);
     for (const s of output) process.stdout.write(s);
     for (const w of warnings) console.error(styleText("yellow", w));
   }
 
   function forceFlush() {
-    const { output, warnings } = detector.forceFlush();
+    const { output, warnings } = formatter.forceFlush();
     for (const s of output) process.stdout.write(s);
     for (const w of warnings) console.error(styleText("yellow", w));
   }

package/src/cli/{tableDetector.mjs → streamFormatter.mjs}

@@ -1,18 +1,24 @@
-import { formatMarkdownTable } from "./formatter.mjs";
+import { applyInlineMarkdown, formatMarkdownTable } from "./formatter.mjs";
 
 /**
- * @typedef {{ output: string[], warnings: string[] }} DetectorResult
+ * @typedef {{ output: string[], warnings: string[] }} StreamFormatterResult
  */
 
 /**
- * Creates a table detector for detecting and formatting markdown tables
- * in streaming text output. This is a pure logic module with no I/O side effects.
+ * Creates a stream formatter for formatting streaming text output
+ * in a terminal. Applies **bold** Markdown styling
+ * on completed lines, and detects + formats markdown tables.
+ * This is a pure logic module with no I/O side effects.
+ *
+ * All output is deferred until line completion (\n or forceFlush),
+ * so inline Markdown patterns spanning chunk boundaries are handled
+ * correctly without special boundary-detection logic.
  *
  * @param {(lines: string[], maxWidth?: number) => string} [formatTable=formatMarkdownTable] - Table formatting function (injectable for testing)
  * @param {number} [maxWidth] - Maximum terminal display width (defaults to process.stdout.columns - 4 or 80)
- * @returns {{ feed: (chunk: string) => DetectorResult, forceFlush: () => DetectorResult }}
+ * @returns {{ feed: (chunk: string) => StreamFormatterResult, forceFlush: () => StreamFormatterResult }}
  */
-export function createTableDetector(
+export function createStreamFormatter(
   formatTable = formatMarkdownTable,
   maxWidth = process.stdout.columns ? process.stdout.columns - 4 : 80,
 ) {
@@ -25,9 +31,9 @@ export function createTableDetector(
   const MAX_TABLE_LINES = 200;
 
   /**
-   * Feed a text chunk to the detector.
+   * Feed a text chunk to the formatter.
    * @param {string} chunk
-   * @returns {DetectorResult}
+   * @returns {StreamFormatterResult}
    */
   function feed(chunk) {
     if (chunk.length === 0) return { output: [], warnings: [] };
@@ -48,19 +54,12 @@ export function createTableDetector(
       warnings.push(...result.warnings);
     }
 
-    // If not buffering a table and pendingLine has no pipe, output immediately
-    // This ensures non-table text is streamed without delay
-    if (tableLines.length === 0 && !pendingLine.includes("|")) {
-      output.push(pendingLine);
-      pendingLine = "";
-    }
-
     return { output, warnings };
   }
 
   /**
    * Force flush any pending content (call on turn end).
-   * @returns {DetectorResult}
+   * @returns {StreamFormatterResult}
    */
   function forceFlush() {
     /** @type {string[]} */
@@ -68,14 +67,11 @@ export function createTableDetector(
     /** @type {string[]} */
     const warnings = [];
 
-    // Process any remaining pending line
+    // Process any remaining pending line as a completed line
     if (pendingLine.length > 0) {
-      // If we have a table buffer, add pending line to it or output directly
-      if (tableLines.length > 0) {
-        tableLines.push(`${pendingLine}\n`);
-      } else {
-        output.push(pendingLine);
-      }
+      const result = processLine(pendingLine);
+      output.push(...result.output);
+      warnings.push(...result.warnings);
       pendingLine = "";
     }
     const flushResult = flushTable();
@@ -87,30 +83,33 @@ export function createTableDetector(
 
   /**
    * Process a complete line.
-   * @param {string} line - Line including trailing newline
-   * @returns {DetectorResult}
+   * @param {string} rawLine - Line (may or may not include trailing newline)
+   * @returns {StreamFormatterResult}
    */
-  function processLine(line) {
+  function processLine(rawLine) {
     /** @type {string[]} */
     const output = [];
     /** @type {string[]} */
     const warnings = [];
 
-    // Code block detection
-    if (line.trimStart().startsWith("```")) {
+    // Code block detection (before Markdown conversion — code blocks stay raw)
+    if (rawLine.trimStart().startsWith("```")) {
       inCodeBlock = !inCodeBlock;
       const flushResult = flushTable(); // Code block terminates any ongoing table
       output.push(...flushResult.output);
       warnings.push(...flushResult.warnings);
-      output.push(line);
+      output.push(rawLine);
       return { output, warnings };
     }
 
     if (inCodeBlock) {
-      output.push(line);
+      output.push(rawLine);
       return { output, warnings };
     }
 
+    // Apply inline Markdown styling on completed lines
+    const line = applyInlineMarkdown(rawLine);
+
     // Table start: line begins with pipe
     if (isTableStart(line)) {
       tableLines.push(line);
@@ -145,7 +144,7 @@ export function createTableDetector(
 
   /**
    * Flush table buffer with formatting.
-   * @returns {DetectorResult}
+   * @returns {StreamFormatterResult}
    */
   function flushTable() {
     if (tableLines.length === 0) return { output: [], warnings: [] };
@@ -193,7 +192,7 @@ export function createTableDetector(
 
   /**
    * Flush table buffer without formatting (for oversized tables).
-   * @returns {DetectorResult}
+   * @returns {StreamFormatterResult}
    */
   function flushTableAsIs() {
     if (tableLines.length === 0) return { output: [], warnings: [] };

package/src/main.mjs

@@ -34,64 +34,70 @@ import { createWebSearchTool } from "./tools/webSearch.mjs";
 import { writeFileTool } from "./tools/writeFile.mjs";
 import { createToolUseApprover } from "./toolUseApprover.mjs";
 
-const cliArgs = parseCliArgs(process.argv);
-if (cliArgs.subcommand.type === "help") {
-  printHelp();
-}
-
-if (cliArgs.subcommand.type === "list-models") {
-  const { appConfig } = await loadAppConfig({ skipTrustCheck: true });
-  if (!appConfig.models || appConfig.models.length === 0) {
-    console.error("No models found in configuration.");
-    process.exit(1);
-  }
-  for (const model of appConfig.models) {
-    const platform = model.platform;
-    console.log(
-      `${model.name}+${model.variant} (platform: ${platform.name}+${platform.variant})`,
-    );
+/**
+ * CLI entry point. Separated from top-level so that importing this module
+ * does not start the application — required for code-coverage smoke tests.
+ *
+ * @param {string[]} argv - Typically `process.argv`.
+ */
+export async function main(argv = process.argv) {
+  const cliArgs = parseCliArgs(argv);
+  if (cliArgs.subcommand.type === "help") {
+    printHelp();
   }
-  process.exit(0);
-}
 
-if (cliArgs.subcommand.type === "install-claude-code-plugins") {
-  await installClaudeCodePlugins();
-  process.exit(0);
-}
-
-if (cliArgs.subcommand.type === "cost") {
-  try {
-    const exitCode = await runCostCommand({
-      from: cliArgs.subcommand.from,
-      to: cliArgs.subcommand.to,
-    });
-    process.exit(exitCode);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(message);
-    process.exit(1);
+  if (cliArgs.subcommand.type === "list-models") {
+    const { appConfig } = await loadAppConfig({ skipTrustCheck: true });
+    if (!appConfig.models || appConfig.models.length === 0) {
+      console.error("No models found in configuration.");
+      process.exit(1);
+    }
+    for (const model of appConfig.models) {
+      const platform = model.platform;
+      console.log(
+        `${model.name}+${model.variant} (platform: ${platform.name}+${platform.variant})`,
+      );
+    }
+    process.exit(0);
   }
-}
 
-if (cliArgs.subcommand.type === "resume" && cliArgs.subcommand.list) {
-  const sessions = await listSessions();
-  if (sessions.length === 0) {
-    console.log("No resumable sessions in .plain-agent/sessions/.");
+  if (cliArgs.subcommand.type === "install-claude-code-plugins") {
+    await installClaudeCodePlugins();
     process.exit(0);
   }
-  console.log("Resumable sessions (most recently updated first):\n");
-  for (const s of sessions) {
-    console.log(
-      `  ${s.sessionId}  ${s.modelName}  (updated ${formatLocalDateTime(s.lastUpdatedAt)}, ${s.messageCount} messages)`,
-    );
-    if (s.workingDir !== process.cwd()) {
-      console.log(`    workingDir: ${s.workingDir}`);
+
+  if (cliArgs.subcommand.type === "cost") {
+    try {
+      const exitCode = await runCostCommand({
+        from: cliArgs.subcommand.from,
+        to: cliArgs.subcommand.to,
+      });
+      process.exit(exitCode);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(message);
+      process.exit(1);
     }
   }
-  process.exit(0);
-}
 
-(async () => {
+  if (cliArgs.subcommand.type === "resume" && cliArgs.subcommand.list) {
+    const sessions = await listSessions();
+    if (sessions.length === 0) {
+      console.log("No resumable sessions in .plain-agent/sessions/.");
+      process.exit(0);
+    }
+    console.log("Resumable sessions (most recently updated first):\n");
+    for (const s of sessions) {
+      console.log(
+        `  ${s.sessionId}  ${s.modelName}  (updated ${formatLocalDateTime(s.lastUpdatedAt)}, ${s.messageCount} messages)`,
+      );
+      if (s.workingDir !== process.cwd()) {
+        console.log(`    workingDir: ${s.workingDir}`);
+      }
+    }
+    process.exit(0);
+  }
+
   /** @type {SessionState | null} */
   let resumedState = null;
 
@@ -430,10 +436,7 @@ if (cliArgs.subcommand.type === "resume" && cliArgs.subcommand.list) {
       voiceInput: appConfig.voiceInput,
     });
   }
-})().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
+}
 
 /**
  * Generate a session id of the form `YYYY-MM-DD-HHMM-<3 random base36 chars>`.

package/src/prompt.mjs

@@ -70,6 +70,10 @@ Memory files should include:
 
 Call multiple tools at once when they don't depend on each other's results.
 
+## patch_file
+
+Always read the target lines with \`read_file\` first to verify line numbers and their 2-char hashes before calling \`patch_file\`.
+
 ## exec_command
 
 - Use relative paths.