muonroi-cli 1.4.0 → 1.4.1

package/src/tools/grep.ts

@@ -1,187 +0,0 @@
-import { stat } from "fs/promises";
-import path from "path";
-import { ripgrep } from "ripgrep";
-import type { ToolResult } from "../types/index";
-
-const MAX_MATCHES = 100;
-const MAX_LINE_LENGTH = 2000;
-
-interface GrepParams {
-  pattern: string;
-  path?: string;
-  include?: string;
-}
-
-interface RipgrepMatch {
-  type: "match";
-  data: {
-    path: { text: string };
-    lines: { text: string };
-    line_number: number;
-    absolute_offset: number;
-    submatches: Array<{ match: { text: string }; start: number; end: number }>;
-  };
-}
-
-function buildArgs(params: GrepParams): string[] {
-  const args = ["--json", "--hidden", "--glob=!.git/*", "--no-messages"];
-
-  if (params.include) {
-    args.push(`--glob=${params.include}`);
-  }
-
-  args.push("--", params.pattern, params.path ?? ".");
-  return args;
-}
-
-function cleanEnv(): Record<string, string> {
-  const env = Object.fromEntries(
-    Object.entries(process.env).filter((entry): entry is [string, string] => entry[1] !== undefined),
-  );
-  delete env.RIPGREP_CONFIG_PATH;
-  return env;
-}
-
-function cleanPath(file: string): string {
-  return path.normalize(file.replace(/^\.[\\/]/, ""));
-}
-
-function parseMatches(stdout: string): RipgrepMatch["data"][] {
-  if (!stdout.trim()) return [];
-
-  return stdout
-    .trim()
-    .split(/\r?\n/)
-    .filter(Boolean)
-    .flatMap((line) => {
-      try {
-        const parsed = JSON.parse(line);
-        if (parsed.type === "match") {
-          return [
-            {
-              ...parsed.data,
-              path: { ...parsed.data.path, text: cleanPath(parsed.data.path.text) },
-            },
-          ];
-        }
-      } catch {
-        // skip malformed lines
-      }
-      return [];
-    });
-}
-
-async function getFileMtimes(files: string[], cwd: string): Promise<Map<string, number>> {
-  const times = new Map<string, number>();
-  await Promise.all(
-    files.map(async (file) => {
-      const fullPath = path.isAbsolute(file) ? file : path.join(cwd, file);
-      try {
-        const info = await stat(fullPath);
-        times.set(file, info.mtimeMs);
-      } catch {
-        // skip inaccessible files
-      }
-    }),
-  );
-  return times;
-}
-
-export async function executeGrep(params: GrepParams, cwd: string): Promise<ToolResult> {
-  if (!params.pattern) {
-    return { success: false, error: "pattern is required" };
-  }
-
-  const searchPath = params.path ? (path.isAbsolute(params.path) ? params.path : path.join(cwd, params.path)) : cwd;
-
-  let searchCwd: string;
-  let searchTarget: string | undefined;
-  try {
-    const info = await stat(searchPath);
-    if (info.isDirectory()) {
-      searchCwd = searchPath;
-    } else {
-      searchCwd = path.dirname(searchPath);
-      searchTarget = path.relative(searchCwd, searchPath);
-    }
-  } catch {
-    searchCwd = cwd;
-    searchTarget = params.path;
-  }
-
-  const args = buildArgs({ ...params, path: searchTarget });
-
-  try {
-    const result = await ripgrep(args, {
-      buffer: true,
-      env: cleanEnv(),
-      preopens: { ".": searchCwd },
-    });
-
-    const stdout = (result.stdout as string) ?? "";
-    const code = result.code ?? 1;
-
-    if (code !== 0 && code !== 1 && code !== 2) {
-      const stderr = (result.stderr as string) ?? "";
-      return { success: false, error: stderr.trim() || `ripgrep failed with code ${code}` };
-    }
-
-    if (code === 1) {
-      return { success: true, output: "No matches found." };
-    }
-
-    const matches = parseMatches(stdout);
-    if (matches.length === 0) {
-      const msg = code === 2 ? "No matches found.\n(Some paths were inaccessible and skipped)" : "No matches found.";
-      return { success: true, output: msg };
-    }
-
-    const rebase = (file: string) => path.relative(cwd, path.resolve(searchCwd, file));
-
-    const uniqueFiles = [...new Set(matches.map((m) => rebase(m.path.text)))];
-    const mtimes = await getFileMtimes(uniqueFiles, cwd);
-
-    const rows = matches
-      .map((m) => ({
-        file: rebase(m.path.text),
-        line: m.line_number,
-        text: m.lines.text.replace(/\n$/, ""),
-        mtime: mtimes.get(rebase(m.path.text)) ?? 0,
-      }))
-      .sort((a, b) => b.mtime - a.mtime);
-
-    const total = rows.length;
-    const truncated = total > MAX_MATCHES;
-    const display = truncated ? rows.slice(0, MAX_MATCHES) : rows;
-
-    const output: string[] = [`Found ${total} matches${truncated ? ` (showing first ${MAX_MATCHES})` : ""}`];
-
-    let currentFile = "";
-    for (const row of display) {
-      if (currentFile !== row.file) {
-        if (currentFile !== "") output.push("");
-        currentFile = row.file;
-        output.push(`${row.file}:`);
-      }
-      const text = row.text.length > MAX_LINE_LENGTH ? `${row.text.substring(0, MAX_LINE_LENGTH)}...` : row.text;
-      output.push(`  Line ${row.line}: ${text}`);
-    }
-
-    if (truncated) {
-      output.push("");
-      output.push(
-        `(Results truncated: showing ${MAX_MATCHES} of ${total} matches. Consider using a more specific path or pattern.)`,
-      );
-    }
-
-    if (code === 2) {
-      output.push("");
-      output.push("(Some paths were inaccessible and skipped)");
-    }
-
-    return { success: true, output: output.join("\n") };
-  } catch (err: unknown) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { success: false, error: `Grep failed: ${msg}` };
-  }
-}

package/src/tools/registry-bash-empty-command.test.ts

@@ -1,64 +0,0 @@
-/**
- * Corrective guard for malformed bash tool calls (missing / empty `command`).
- *
- * Live obs (2026-06-04, deepseek long session 734e65cffdf6): on an open-ended
- * "find a bug" task the cheap model emitted `bash` calls with EMPTY arguments
- * (`{}`, no `command`) three times in a row until the loop-guard askcard fired.
- * Root cause: the registry passed `input.command` (undefined) straight to
- * `bash.execute()`, where `command.startsWith(...)` threw an opaque TypeError.
- * An opaque error doesn't steer a cheap model to self-correct — it just repeats
- * the malformed call. The guard returns a crisp, actionable instruction instead
- * so the next step supplies a real command.
- */
-
-import os from "node:os";
-import { describe, expect, it } from "vitest";
-import { BashTool } from "./bash.js";
-import { createBuiltinTools } from "./registry.js";
-
-interface ToolWithExecute {
-  execute?: (input: unknown) => Promise<unknown> | unknown;
-}
-
-async function runBash(tools: Record<string, unknown>, args: Record<string, unknown>): Promise<string> {
-  const t = tools.bash as ToolWithExecute;
-  if (!t?.execute) throw new Error("bash tool has no execute");
-  const out = await t.execute(args);
-  return typeof out === "string" ? out : JSON.stringify(out);
-}
-
-describe("bash tool — empty/missing command corrective guard", () => {
-  it("returns a corrective error (not a thrown TypeError) for missing command {}", async () => {
-    const bash = new BashTool(os.tmpdir());
-    const tools = createBuiltinTools(bash, "agent");
-    const out = await runBash(tools, {});
-    expect(out).toMatch(/ERROR/);
-    expect(out).toMatch(/non-empty/i);
-    expect(out).toMatch(/command/i);
-  });
-
-  it("returns the corrective error for an empty-string command", async () => {
-    const bash = new BashTool(os.tmpdir());
-    const tools = createBuiltinTools(bash, "agent");
-    const out = await runBash(tools, { command: "" });
-    expect(out).toMatch(/ERROR/);
-    expect(out).toMatch(/non-empty/i);
-  });
-
-  it("returns the corrective error for a whitespace-only command", async () => {
-    const bash = new BashTool(os.tmpdir());
-    const tools = createBuiltinTools(bash, "agent");
-    const out = await runBash(tools, { command: "   " });
-    expect(out).toMatch(/ERROR/);
-    expect(out).toMatch(/non-empty/i);
-  });
-
-  it("does NOT block a real command", async () => {
-    const bash = new BashTool(os.tmpdir());
-    const tools = createBuiltinTools(bash, "agent");
-    const out = await runBash(tools, { command: "echo guard-ok", timeout: 10_000 });
-    expect(out).toContain("guard-ok");
-    expect(out).toMatch(/\[bash_run_id: bash-\d+\]/);
-    expect(out).not.toMatch(/non-empty/i);
-  }, 15_000);
-});

package/src/tools/registry-bash-footer.test.ts

@@ -1,95 +0,0 @@
-/**
- * Verifies Bước 3-1 (always-on runId footer) and Bước 3-3 (inline reminder
- * on canonical-hash match) at the registry tool layer. Uses a real BashTool
- * against echo-style portable commands so the cache + footer wiring is
- * exercised end-to-end.
- */
-
-import os from "node:os";
-import { beforeEach, describe, expect, it } from "vitest";
-import { BashTool } from "./bash.js";
-import { clearBashOutputCache } from "./bash-output-cache.js";
-import { createBuiltinTools } from "./registry.js";
-
-interface ToolWithExecute {
-  execute?: (input: unknown) => Promise<unknown> | unknown;
-}
-
-async function runBash(tools: Record<string, unknown>, args: Record<string, unknown>): Promise<string> {
-  const t = tools.bash as ToolWithExecute;
-  if (!t?.execute) throw new Error("bash tool has no execute");
-  const out = await t.execute(args);
-  return typeof out === "string" ? out : JSON.stringify(out);
-}
-
-describe("Bước 3-1 — always-on runId footer", () => {
-  beforeEach(() => clearBashOutputCache());
-
-  it("emits [bash_run_id: bash-N] footer even when output is tiny", async () => {
-    const bash = new BashTool(os.tmpdir());
-    const tools = createBuiltinTools(bash, "agent");
-    const out = await runBash(tools, { command: "echo small-output", timeout: 10_000 });
-    expect(out).toMatch(/\[bash_run_id: bash-\d+\]/);
-    // Tiny output → no hint about bash_output_get (would be noise).
-    expect(out).not.toContain("use bash_output_get");
-  });
-
-  it("adds the bash_output_get hint only when cached output >= 4000 chars", async () => {
-    const bash = new BashTool(os.tmpdir());
-    const tools = createBuiltinTools(bash, "agent");
-    // ~5000 char output via printf.
-    const cmd =
-      process.platform === "win32"
-        ? `node -e "console.log('x'.repeat(5000))"`
-        : `node -e "console.log('x'.repeat(5000))"`;
-    const out = await runBash(tools, { command: cmd, timeout: 10_000 });
-    expect(out).toMatch(/\[bash_run_id: bash-\d+ — \d+ chars cached; use bash_output_get/);
-  }, 20_000);
-});
-
-describe("Bước 3-3 — inline reminder on canonical hash match", () => {
-  beforeEach(() => clearBashOutputCache());
-
-  it("appends [reminder: ...] when the second bash call canonicalizes identically", async () => {
-    const bash = new BashTool(os.tmpdir());
-    const tools = createBuiltinTools(bash, "agent");
-    // Same underlying intent (`echo same-base`) with different cosmetic
-    // wrapping (pipe to tail vs head). canonicalizeBashCommand collapses
-    // these to the same hash.
-    const first = await runBash(tools, { command: "echo same-base | head -1", timeout: 10_000 });
-    const firstRunId = first.match(/bash-(\d+)/)?.[0];
-    expect(firstRunId).toBeDefined();
-
-    const second = await runBash(tools, { command: "echo same-base | tail -1", timeout: 10_000 });
-    expect(second).toContain("[reminder:");
-    expect(second).toContain(`run_id=${firstRunId}`);
-    expect(second).toMatch(/Use bash_output_get/);
-  }, 20_000);
-
-  it("does NOT append the reminder when the canonical form differs", async () => {
-    const bash = new BashTool(os.tmpdir());
-    const tools = createBuiltinTools(bash, "agent");
-    await runBash(tools, { command: "echo first", timeout: 10_000 });
-    const second = await runBash(tools, { command: "echo second-different", timeout: 10_000 });
-    expect(second).not.toContain("[reminder:");
-    // Footer still present though.
-    expect(second).toMatch(/\[bash_run_id: bash-\d+\]/);
-  }, 20_000);
-
-  it("resets / advances correctly across three consecutive same-intent calls", async () => {
-    const bash = new BashTool(os.tmpdir());
-    const tools = createBuiltinTools(bash, "agent");
-    const r1 = await runBash(tools, { command: "echo repeat-me", timeout: 10_000 });
-    const r2 = await runBash(tools, { command: "echo repeat-me | head -1", timeout: 10_000 });
-    const r3 = await runBash(tools, { command: "echo repeat-me | tail -1", timeout: 10_000 });
-    expect(r1).not.toContain("[reminder:");
-    // r2's reminder must reference r1's runId.
-    const r1Id = r1.match(/bash-(\d+)/)?.[0];
-    expect(r2).toContain(`run_id=${r1Id}`);
-    // r3's reminder must reference r2's runId (the LATEST match, not r1).
-    const r2Id = r2.match(/bash-(\d+)/)?.[0];
-    expect(r3).toContain(`run_id=${r2Id}`);
-    // Sanity: ids are distinct.
-    expect(r1Id).not.toBe(r2Id);
-  }, 30_000);
-});

package/src/tools/registry-ee-query.test.ts

@@ -1,57 +0,0 @@
-/**
- * ee_query builtin tool — the in-CLI counterpart of the MCP `ee.query` tool.
- *
- * Session d95113d3be09: the Agent Operating Contract + checkpoint reminders
- * instruct the agent to "Use the ee_query tool with 'tool-artifact id=XXX'" to
- * rehydrate compaction-elided outputs, but the in-CLI agent had no such tool —
- * a dead reference. This verifies the tool now exists in the agent toolset, is
- * absent from non-agent modes, and degrades gracefully on a malformed call
- * (no network).
- */
-
-import os from "node:os";
-import { describe, expect, it } from "vitest";
-import { BashTool } from "./bash.js";
-import { createBuiltinTools, isToolArtifactQuery } from "./registry.js";
-
-interface ToolWithExecute {
-  execute?: (input: unknown) => Promise<unknown> | unknown;
-}
-
-describe("ee_query builtin tool", () => {
-  it("is registered in agent mode", () => {
-    const tools = createBuiltinTools(new BashTool(os.tmpdir()), "agent");
-    expect(tools.ee_query).toBeDefined();
-    expect((tools.ee_query as ToolWithExecute).execute).toBeTypeOf("function");
-  });
-
-  it("is NOT registered in non-agent modes (plan/ask)", () => {
-    expect(createBuiltinTools(new BashTool(os.tmpdir()), "plan").ee_query).toBeUndefined();
-    expect(createBuiltinTools(new BashTool(os.tmpdir()), "ask").ee_query).toBeUndefined();
-  });
-
-  it("returns a corrective error for an empty query (no network)", async () => {
-    const tools = createBuiltinTools(new BashTool(os.tmpdir()), "agent");
-    const t = tools.ee_query as ToolWithExecute;
-    const out = String(await t.execute?.({ query: "  " }));
-    expect(out).toMatch(/ERROR/);
-    expect(out).toMatch(/query/i);
-  });
-});
-
-describe("isToolArtifactQuery — ee_query intent routing", () => {
-  it("matches tool-artifact / full-tool-result id lookups (→ /api/search)", () => {
-    expect(isToolArtifactQuery("tool-artifact id=abc123")).toBe(true);
-    expect(isToolArtifactQuery("full tool result id=9f2c")).toBe(true);
-    expect(isToolArtifactQuery("rehydrate the TOOL-ARTIFACT  ID = xyz")).toBe(true);
-  });
-
-  it("does NOT match general recall queries (→ /api/recall)", () => {
-    expect(isToolArtifactQuery("recent compaction checkpoint Progress DONE")).toBe(false);
-    expect(isToolArtifactQuery("how do we restart the experience-engine server")).toBe(false);
-    // "id=" alone, without the artifact phrase, is not an artifact lookup.
-    expect(isToolArtifactQuery("what is the user id=field convention")).toBe(false);
-    // The artifact phrase without an id= is also not an exact lookup.
-    expect(isToolArtifactQuery("tool-artifact storage design")).toBe(false);
-  });
-});

package/src/tools/registry-session-repeat.test.ts

@@ -1,105 +0,0 @@
-/**
- * Phase 4R — session-scoped bash canonical-repeat detector.
- *
- * Verifies that the `[reminder: ...]` injection survives across
- * `createBuiltinTools()` rebuilds when the sessionId is preserved. The
- * baseline session `77cd2e11c6a5` re-ran an identical `grep` 9 times
- * because each askcard answer rebuilt the registry and wiped the
- * per-closure detector state. The fix lifts the state to a
- * process-global Map keyed by sessionId so the detector survives
- * registry rebuilds within the same session.
- */
-
-import os from "node:os";
-import { beforeEach, describe, expect, it } from "vitest";
-import { BashTool } from "./bash.js";
-import { clearBashOutputCache } from "./bash-output-cache.js";
-import { createBuiltinTools } from "./registry.js";
-
-interface ToolWithExecute {
-  execute?: (input: unknown) => Promise<unknown> | unknown;
-}
-
-async function runBash(tools: Record<string, unknown>, args: Record<string, unknown>): Promise<string> {
-  const t = tools.bash as ToolWithExecute;
-  if (!t?.execute) throw new Error("bash tool has no execute");
-  const out = await t.execute(args);
-  return typeof out === "string" ? out : JSON.stringify(out);
-}
-
-describe("Phase 4R — session-scoped bash repeat detector", () => {
-  beforeEach(() => {
-    clearBashOutputCache();
-    // Reset the process-global state so each test starts clean. The
-    // registry reads from this Map lazily, so clearing it here is enough.
-    (globalThis as { __muonroiBashRepeatState?: Map<string, unknown> }).__muonroiBashRepeatState = new Map();
-  });
-
-  it("fires reminder when the SAME sessionId is reused across registry rebuilds", async () => {
-    const bash = new BashTool(os.tmpdir());
-
-    // Turn 1: build registry with sessionId=S1, run command, no reminder.
-    const tools1 = createBuiltinTools(bash, "agent", { sessionId: "S1" });
-    const first = await runBash(tools1, { command: "echo same-base | head -1", timeout: 10_000 });
-    const firstRunId = first.match(/bash-(\d+)/)?.[0];
-    expect(firstRunId).toBeDefined();
-    expect(first).not.toContain("[reminder:");
-
-    // Simulate askcard answer or sub-agent turn: tear down + rebuild
-    // registry, but keep the same sessionId. Pre-fix this would reset
-    // the per-closure state and miss the repeat.
-    const tools2 = createBuiltinTools(bash, "agent", { sessionId: "S1" });
-    const second = await runBash(tools2, { command: "echo same-base | tail -1", timeout: 10_000 });
-    expect(second).toContain("[reminder:");
-    expect(second).toContain(`run_id=${firstRunId}`);
-    expect(second).toMatch(/Use bash_output_get/);
-  }, 30_000);
-
-  it("does NOT fire reminder when a DIFFERENT sessionId issues the same canonical command", async () => {
-    const bash = new BashTool(os.tmpdir());
-
-    const toolsS1 = createBuiltinTools(bash, "agent", { sessionId: "S1" });
-    await runBash(toolsS1, { command: "echo cross-session | head -1", timeout: 10_000 });
-
-    // Different session — must NOT see S1's history.
-    const toolsS2 = createBuiltinTools(bash, "agent", { sessionId: "S2" });
-    const out = await runBash(toolsS2, { command: "echo cross-session | tail -1", timeout: 10_000 });
-    expect(out).not.toContain("[reminder:");
-    // Footer still fires.
-    expect(out).toMatch(/\[bash_run_id: bash-\d+\]/);
-  }, 30_000);
-
-  it("fires reminder across 3 separate registry rebuilds within the same session", async () => {
-    const bash = new BashTool(os.tmpdir());
-
-    const tools1 = createBuiltinTools(bash, "agent", { sessionId: "S3" });
-    const r1 = await runBash(tools1, { command: "echo repeat-me", timeout: 10_000 });
-    expect(r1).not.toContain("[reminder:");
-    const r1Id = r1.match(/bash-(\d+)/)?.[0];
-
-    const tools2 = createBuiltinTools(bash, "agent", { sessionId: "S3" });
-    const r2 = await runBash(tools2, { command: "echo repeat-me | head -1", timeout: 10_000 });
-    expect(r2).toContain(`run_id=${r1Id}`);
-    const r2Id = r2.match(/bash-(\d+)/)?.[0];
-
-    const tools3 = createBuiltinTools(bash, "agent", { sessionId: "S3" });
-    const r3 = await runBash(tools3, { command: "echo repeat-me | tail -1", timeout: 10_000 });
-    // Each rebuild MUST chain — r3 sees the latest runId (r2's), not r1's.
-    expect(r3).toContain(`run_id=${r2Id}`);
-    expect(r1Id).not.toBe(r2Id);
-  }, 45_000);
-
-  it("legacy callers (no sessionId) keep per-instance isolation", async () => {
-    const bash = new BashTool(os.tmpdir());
-
-    // No sessionId — each registry instance is isolated, matching the
-    // pre-4R closure behaviour. This is what registry-bash-footer.test.ts
-    // implicitly relies on.
-    const toolsA = createBuiltinTools(bash, "agent");
-    await runBash(toolsA, { command: "echo legacy-iso | head -1", timeout: 10_000 });
-
-    const toolsB = createBuiltinTools(bash, "agent");
-    const out = await runBash(toolsB, { command: "echo legacy-iso | tail -1", timeout: 10_000 });
-    expect(out).not.toContain("[reminder:");
-  }, 30_000);
-});

package/src/tools/registry.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { MAX_TOOL_OUTPUT_CHARS, truncateOutput } from "./registry.js";
-
-describe("truncateOutput", () => {
-  it("returns input unchanged when under cap", () => {
-    const text = "a".repeat(100);
-    expect(truncateOutput(text)).toBe(text);
-  });
-
-  it("preserves head and tail when over cap", () => {
-    const big = "X".repeat(MAX_TOOL_OUTPUT_CHARS + 5_000);
-    const out = truncateOutput(big);
-    expect(out.length).toBeLessThan(big.length);
-    expect(out.startsWith("X")).toBe(true);
-    expect(out.endsWith("X")).toBe(true);
-    expect(out).toContain("chars truncated");
-    expect(out).toContain("full output in transcript");
-  });
-
-  it("honors custom maxChars", () => {
-    const big = "Y".repeat(2_000);
-    const out = truncateOutput(big, 500);
-    expect(out.length).toBeLessThan(big.length);
-    expect(out).toContain("chars truncated");
-  });
-
-  it("exports a cap within the documented range", () => {
-    expect(MAX_TOOL_OUTPUT_CHARS).toBeGreaterThanOrEqual(10_000);
-    expect(MAX_TOOL_OUTPUT_CHARS).toBeLessThanOrEqual(200_000);
-  });
-
-  it("truncation marker accounts for full delta", () => {
-    const big = "Z".repeat(100_000);
-    const out = truncateOutput(big, 10_000);
-    const expectedDelta = 100_000 - 10_000;
-    expect(out).toContain(`${expectedDelta} chars truncated`);
-  });
-});