@iinm/plain-agent 1.8.5 → 1.8.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iinm/plain-agent",
-  "version": "1.8.5",
+  "version": "1.8.6",
   "description": "A lightweight CLI-based coding agent",
   "license": "MIT",
   "type": "module",
@@ -33,10 +33,7 @@
     "lint": "npx @biomejs/biome check",
     "fix": "npx @biomejs/biome check --fix"
   },
-  "dependencies": {
-    "diff": "^8.0.4",
-    "yaml": "^2.8.3"
-  },
+  "dependencies": {},
   "devDependencies": {
     "@biomejs/biome": "^2.4.12",
     "@types/node": "^22.19.17",

package/src/cliFormatter.mjs

@@ -8,8 +8,12 @@
  * @import { SwitchToSubagentInput } from "./tools/switchToSubagent"
  */
 
+import { execFile } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 import { styleText } from "node:util";
-import { createPatch } from "diff";
+import { noThrow } from "./utils/noThrow.mjs";
 
 /** Length above which a single-line arg forces block-form rendering. */
 const ARG_BLOCK_LENGTH_THRESHOLD = 60;
@@ -57,9 +61,11 @@ export function formatArgs(args) {
 /**
  * Format tool use for display.
  * @param {MessageContentToolUse} toolUse
- * @returns {string}
+ * @param {{ createDiff?: (oldContent: string, newContent: string) => Promise<string | null> }} [options]
+ * @returns {Promise<string>}
  */
-export function formatToolUse(toolUse) {
+export async function formatToolUse(toolUse, options = {}) {
+  const { createDiff = tryGitDiff } = options;
   const { toolName, input } = toolUse;
 
   if (toolName === "exec_command") {
@@ -99,23 +105,26 @@ export function formatToolUse(toolUse) {
       diffs.push({ search, replace });
     }
 
-    const highlightedDiff = diffs
-      .map(
-        ({ search, replace }) =>
-          `${createPatch(patchFileInput.filePath || "", search, replace)
-            .replace(/^-.+$/gm, (match) => styleText("red", match))
-            .replace(/^\+.+$/gm, (match) => styleText("green", match))
-            .replace(/^@@.+$/gm, (match) => styleText("gray", match))
-            .replace(/^\$/gm, (match) =>
-              styleText("gray", match),
-            )}\n-------\n${replace}`,
-      )
-      .join("\n\n");
+    const highlightedDiff = await Promise.all(
+      diffs.map(async ({ search, replace }) => {
+        const gitDiffOutput = await createDiff(search, replace);
+        if (gitDiffOutput) {
+          return `${gitDiffOutput}\n-------\n${replace}`;
+        }
+        return [
+          `${styleText("yellow", "(git diff unavailable, showing plain diff)")}`,
+          "--- old",
+          `${search}`,
+          "+++ new",
+          `${replace}`,
+        ].join("\n");
+      }),
+    );
 
     return [
       `tool: ${toolName}`,
       `path: ${patchFileInput.filePath}`,
-      `diff:\n${highlightedDiff}`,
+      `diff:\n${highlightedDiff.join("\n\n")}`,
     ].join("\n");
   }
 
@@ -349,11 +358,20 @@ export function formatCostForBatch(summary) {
 /**
  * Print a message to the console.
  * @param {Message} message
+ * @returns {Promise<void>}
  */
-export function printMessage(message) {
+export async function printMessage(message) {
   switch (message.role) {
     case "assistant": {
       // console.log(styleText("bold", "\nAgent:"));
+      // Pre-format all tool_use parts in parallel to avoid sequential awaits
+      const toolUseParts = message.content.filter(
+        (part) => part.type === "tool_use",
+      );
+      const formattedToolUses = await Promise.all(
+        toolUseParts.map((part) => formatToolUse(part)),
+      );
+      let toolUseIndex = 0;
       for (const part of message.content) {
         switch (part.type) {
           // Note: Streamで表示するためここでは表示しない
@@ -371,7 +389,7 @@ export function printMessage(message) {
           //   break;
           case "tool_use":
             console.log(styleText("bold", "\nTool call:"));
-            console.log(formatToolUse(part));
+            console.log(formattedToolUses[toolUseIndex++]);
             break;
         }
       }
@@ -411,3 +429,90 @@ export function printMessage(message) {
     }
   }
 }
+
+/**
+ * Generate a colored unified diff using `git diff --color`.
+ * Falls back to `null` if git is unavailable or if any step fails
+ * (temp directory creation, file writing, git execution, or cleanup).
+ * @param {string} oldContent
+ * @param {string} newContent
+ * @returns {Promise<string | null>}
+ */
+async function tryGitDiff(oldContent, newContent) {
+  const tmpDir = await noThrow(() =>
+    mkdtemp(path.join(os.tmpdir(), "git-diff-")),
+  );
+  if (tmpDir instanceof Error) {
+    console.error(
+      styleText("yellow", `git diff: mkdtemp failed: ${tmpDir.message}`),
+    );
+    return null;
+  }
+
+  const oldPath = path.join(tmpDir, "old");
+  const newPath = path.join(tmpDir, "new");
+
+  try {
+    const w1 = await noThrow(() => writeFile(oldPath, oldContent, "utf8"));
+    if (w1 instanceof Error) {
+      console.error(
+        styleText("yellow", `git diff: writeFile(old) failed: ${w1.message}`),
+      );
+      return null;
+    }
+
+    const w2 = await noThrow(() => writeFile(newPath, newContent, "utf8"));
+    if (w2 instanceof Error) {
+      console.error(
+        styleText("yellow", `git diff: writeFile(new) failed: ${w2.message}`),
+      );
+      return null;
+    }
+
+    const diffResult = await noThrow(() => execGitDiff(oldPath, newPath));
+    if (diffResult instanceof Error) {
+      console.error(
+        styleText("yellow", `git diff: exec failed: ${diffResult.message}`),
+      );
+      return null;
+    }
+
+    return diffResult;
+  } finally {
+    const cleanup = await noThrow(() =>
+      rm(tmpDir, { recursive: true, force: true }),
+    );
+    if (cleanup instanceof Error) {
+      console.error(
+        styleText("yellow", `git diff: cleanup failed: ${cleanup.message}`),
+      );
+    }
+  }
+}
+
+/**
+ * Execute git diff accepting exit code 1 as success (differences found).
+ * @param {string} oldPath
+ * @param {string} newPath
+ * @returns {Promise<string>}
+ */
+function execGitDiff(oldPath, newPath) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      "git",
+      ["--no-pager", "diff", "--color", "--no-index", "--", oldPath, newPath],
+      { encoding: "utf8", maxBuffer: 10 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        if (stderr) {
+          console.error(styleText("yellow", `git diff stderr: ${stderr}`));
+        }
+        // git diff returns exit code 1 when there are differences, which is expected
+        if (error && error.code !== 1) {
+          reject(error);
+        } else {
+          resolve(stdout);
+        }
+      },
+    );
+  });
+}

package/src/cliInteractive.mjs

@@ -473,7 +473,11 @@ export function startInteractiveSession({
   });
 
   agentEventEmitter.on("message", (message) => {
-    printMessage(message);
+    printMessage(message).catch((err) => {
+      console.error(
+        styleText("red", `Error rendering message: ${err.message}`),
+      );
+    });
   });
 
   agentEventEmitter.on("toolUseRequest", () => {

package/src/context/loadAgentRoles.mjs

@@ -3,13 +3,13 @@
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { parse as parseYaml } from "yaml";
 import {
   AGENT_CACHE_DIR,
   AGENT_PROJECT_METADATA_DIR,
   AGENT_ROOT,
   AGENT_USER_CONFIG_DIR,
 } from "../env.mjs";
+import { parseFrontmatter } from "../utils/parseFrontmatter.mjs";
 
 /**
  * @typedef {Object} AgentRole
@@ -253,21 +253,7 @@ function parseAgentRole(relativePath, fileContent, fullPath, idPrefix = "") {
     };
   }
 
-  /** @type {{description?:string; import?:string}} */
-  let frontmatter;
-  try {
-    frontmatter = /** @type {{description?:string; import?:string}} */ (
-      parseYaml(match[1])
-    );
-  } catch (_err) {
-    return {
-      id,
-      description: parseFrontmatterField(match[1], "description") ?? "",
-      content: fileContent.trim(),
-      filePath: fullPath,
-      claudeOriginated,
-    };
-  }
+  const frontmatter = parseFrontmatter(match[1]);
   const content = match[2].trim();
 
   return {
@@ -279,16 +265,3 @@ function parseAgentRole(relativePath, fileContent, fullPath, idPrefix = "") {
     import: frontmatter.import,
   };
 }
-
-/**
- * Parse a field from YAML frontmatter.
- * @param {string} frontmatter
- * @param {string} field
- * @returns {string | undefined}
- */
-
-function parseFrontmatterField(frontmatter, field) {
-  const regex = new RegExp(`^${field}:\\s*(.*)$`, "m");
-  const match = frontmatter.match(regex);
-  return match ? match[1].trim() : undefined;
-}

package/src/context/loadPrompts.mjs

@@ -4,13 +4,13 @@ import { execFileSync } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { parse as parseYaml } from "yaml";
 import {
   AGENT_CACHE_DIR,
   AGENT_PROJECT_METADATA_DIR,
   AGENT_ROOT,
   AGENT_USER_CONFIG_DIR,
 } from "../env.mjs";
+import { parseFrontmatter } from "../utils/parseFrontmatter.mjs";
 
 /**
  * @typedef {Object} Prompt
@@ -287,29 +287,7 @@ function parsePrompt(relativePath, fileContent, fullPath, idPrefix = "") {
 
   const content = match[2].trim();
 
-  /** @type {{description?:string; import?:string; "user-invocable"?:boolean}} */
-  let frontmatter;
-  try {
-    frontmatter =
-      /** @type {{description?:string; import?:string; "user-invocable"?:boolean}} */ (
-        parseYaml(match[1])
-      );
-  } catch (_err) {
-    return {
-      id,
-      description: parseFrontmatterField(match[1], "description") ?? "",
-      content,
-      filePath: fullPath,
-      claudeOriginated,
-      import: parseFrontmatterField(match[1], "import"),
-      userInvocable:
-        parseFrontmatterField(match[1], "user-invocable") === "true" ||
-        undefined,
-      isShortcut,
-      isSkill,
-    };
-  }
-  const userInvocable = frontmatter["user-invocable"];
+  const frontmatter = parseFrontmatter(match[1]);
 
   return {
     id,
@@ -318,20 +296,8 @@ function parsePrompt(relativePath, fileContent, fullPath, idPrefix = "") {
     filePath: fullPath,
     claudeOriginated,
     import: frontmatter.import,
-    userInvocable: userInvocable ?? undefined,
+    userInvocable: frontmatter["user-invocable"] === "true" ? true : undefined,
     isShortcut,
     isSkill: relativePath.endsWith("SKILL.md"),
   };
 }
-
-/**
- * Parse a field from YAML frontmatter.
- * @param {string} frontmatter
- * @param {string} field
- * @returns {string | undefined}
- */
-function parseFrontmatterField(frontmatter, field) {
-  const regex = new RegExp(`^${field}:\\s*(.*)$`, "m");
-  const match = frontmatter.match(regex);
-  return match ? match[1].trim() : undefined;
-}

package/src/utils/parseFrontmatter.mjs

@@ -0,0 +1,19 @@
+/**
+ * Parse simple key-value frontmatter using regex.
+ * Only supports `key: value` format. No multiline strings.
+ * @param {string} frontmatter - The YAML frontmatter content (without --- delimiters)
+ * @returns {Record<string, string>} Parsed key-value pairs
+ */
+export function parseFrontmatter(frontmatter) {
+  /** @type {Record<string, string>} */
+  const result = {};
+
+  for (const line of frontmatter.split(/\r?\n/)) {
+    const match = line.match(/^(\w[\w-]*):\s?(.*)$/);
+    if (match) {
+      result[match[1]] = match[2].trimEnd();
+    }
+  }
+
+  return result;
+}