agent-yes 1.83.0 → 1.85.0

package/ts/index.ts

@@ -28,6 +28,7 @@ import { AgentContext } from "./core/context.ts";
 import { createTerminatorStream } from "./core/streamHelpers.ts";
 import { globalAgentRegistry } from "./agentRegistry.ts";
 import { notifyWebhook } from "./webhookNotifier.ts";
+import { readGlobalPids } from "./globalPidIndex.ts";
 
 export { removeControlCharacters };
 export { AgentContext };
@@ -124,6 +125,7 @@ export default async function agentYes({
   useStdinAppend = false,
   autoYes = true,
   idleAction,
+  swarmHint = true,
 }: {
   cli: keyof typeof CLIS_CONFIG;
   cliArgs?: string[];
@@ -142,6 +144,7 @@ export default async function agentYes({
   useStdinAppend?: boolean; // if true, enable FIFO input stream on Linux,  for additional stdin input
   autoYes?: boolean; // if true, auto-yes is enabled (default), toggle with Ctrl+Y during session
   idleAction?: string; // if set, type this message when idle instead of exiting
+  swarmHint?: boolean; // if true (default), inject peer discovery hint when other agents are running; --no-swarm-hint to opt out
 }) {
   if (!cli) throw new Error(`cli is required`);
   const conf =
@@ -274,6 +277,23 @@ export default async function agentYes({
     if (verbose) logger.warn("[skills] Failed to inject SKILL.md header:", { error });
   }
 
+  // Inject peer discovery hint when other agents are running
+  if (swarmHint) {
+    try {
+      const peers = await readGlobalPids({ liveOnly: true });
+      if (peers.length > 0) {
+        const hint = `${peers.length} peer agent${peers.length > 1 ? "s are" : " is"} running. Before asking the user for input on any domain-specific topic (design, testing, architecture, etc.), check for relevant peers first: \`ay ls --json\` (see \`prompt\` field for their role). Ask one: \`ay send <pid> <question>\`. Read reply: \`ay tail <pid>\`. Do not use interactive forms or user prompts when a peer can answer.`;
+        if (cli === "claude") {
+          cliArgs = ["--append-system-prompt", hint, ...cliArgs];
+        }
+        // Prepend to prompt for all CLIs (including claude) so it's read before the task
+        prompt = prompt ? `[${hint}]\n\n${prompt}` : hint;
+      }
+    } catch {
+      // Non-fatal
+    }
+  }
+
   // Handle --continue flag for codex session restoration
   if (resume) {
     if (cli === "codex" && resume) {
@@ -322,6 +342,7 @@ export default async function agentYes({
 
   // Spawn the agent CLI process
   const ptyEnv = { ...(env ?? (process.env as Record<string, string>)) };
+  ptyEnv.AGENT_YES_PID = String(process.pid);
   const ptyOptions = {
     name: "xterm-color",
     ...getTerminalDimensions(),

package/ts/parseCliArgs.ts

@@ -63,6 +63,12 @@ export function parseCliArgs(argv: string[], supportedClis?: readonly string[])
         "Prepend SKILL.md header from current directory to the prompt (helpful for non-Claude agents)",
       default: false,
     })
+    .option("swarm-hint", {
+      type: "boolean",
+      description:
+        "Inject peer discovery hint into agent system prompt when other agents are running (use --no-swarm-hint to opt out)",
+      default: true,
+    })
     .option("timeout", {
       type: "string",
       description: 'Exit after a period of inactivity, e.g., "5s" or "1m"',
@@ -313,6 +319,7 @@ export function parseCliArgs(argv: string[], supportedClis?: readonly string[])
     verbose: parsedArgv.verbose,
     resume: parsedArgv.continue, // Note: intentional use resume here to avoid preserved keyword (continue)
     useSkills: parsedArgv.useSkills,
+    swarmHint: parsedArgv.swarmHint,
     appendPrompt: parsedArgv.appendPrompt,
     useStdinAppend: Boolean(parsedArgv.stdpush || parsedArgv.ipc || parsedArgv.fifo), // Support --stdpush, --ipc, and --fifo (backward compatibility)
     showVersion: parsedArgv.version,

package/ts/subcommands.spec.ts

@@ -27,41 +27,6 @@ async function loadModule() {
   return await import("./subcommands.ts");
 }
 
-describe("subcommands.parseArgs", () => {
-  it("collects positional args and bare flags", async () => {
-    const { parseArgs } = await loadModule();
-    const out = parseArgs(["foo", "bar", "--all"]);
-    expect(out.positional).toEqual(["foo", "bar"]);
-    expect(out.flags.all).toBe(true);
-  });
-
-  it("parses --key=value form", async () => {
-    const { parseArgs } = await loadModule();
-    const out = parseArgs(["--code=enter"]);
-    expect(out.flags.code).toBe("enter");
-  });
-
-  it("parses --key value form for non-boolean keys", async () => {
-    const { parseArgs } = await loadModule();
-    const out = parseArgs(["--cwd", "/tmp/foo"]);
-    expect(out.flags.cwd).toBe("/tmp/foo");
-  });
-
-  it("treats well-known boolean flags as boolean even with a following positional", async () => {
-    const { parseArgs } = await loadModule();
-    const out = parseArgs(["--all", "claude"]);
-    expect(out.flags.all).toBe(true);
-    expect(out.positional).toEqual(["claude"]);
-  });
-
-  it("supports -n N short form", async () => {
-    const { parseArgs } = await loadModule();
-    const out = parseArgs(["-n", "50", "keyword"]);
-    expect(out.flags.n).toBe("50");
-    expect(out.positional).toEqual(["keyword"]);
-  });
-});
-
 describe("subcommands.controlCodeFromName", () => {
   it("maps named codes to the right control bytes", async () => {
     const { controlCodeFromName } = await loadModule();
@@ -525,6 +490,484 @@ describe("subcommands.cmdSend writes bytes to FIFO", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// cmdLs additional arg coverage
+// ---------------------------------------------------------------------------
+
+describe("subcommands.cmdLs -h / --help", () => {
+  function captureStdout() {
+    const chunks: string[] = [];
+    const orig = process.stdout.write.bind(process.stdout);
+    (process.stdout as any).write = (s: any) => {
+      chunks.push(String(s));
+      return true;
+    };
+    return {
+      get text() {
+        return chunks.join("");
+      },
+      restore() {
+        process.stdout.write = orig;
+      },
+    };
+  }
+
+  it("ay ls -h prints usage to stdout and exits 0", async () => {
+    const { runSubcommand } = await loadModule();
+    const cap = captureStdout();
+    let code: number | null;
+    try {
+      code = await runSubcommand(["bun", "cli.js", "ls", "-h"]);
+    } finally {
+      cap.restore();
+    }
+    expect(code).toBe(0);
+    expect(cap.text).toMatch(/Usage:/);
+    expect(cap.text).toMatch(/--all/);
+    expect(cap.text).toMatch(/--json/);
+  });
+
+  it("ay ls --help prints usage to stdout and exits 0", async () => {
+    const { runSubcommand } = await loadModule();
+    const cap = captureStdout();
+    let code: number | null;
+    try {
+      code = await runSubcommand(["bun", "cli.js", "ls", "--help"]);
+    } finally {
+      cap.restore();
+    }
+    expect(code).toBe(0);
+    expect(cap.text).toMatch(/Usage:/);
+  });
+});
+
+describe("subcommands.cmdLs --all / --active / keyword filter / aliases", () => {
+  function captureOutput() {
+    const out: string[] = [];
+    const err: string[] = [];
+    const origOut = process.stdout.write.bind(process.stdout);
+    const origErr = process.stderr.write.bind(process.stderr);
+    (process.stdout as any).write = (s: any) => {
+      out.push(String(s));
+      return true;
+    };
+    (process.stderr as any).write = (s: any) => {
+      err.push(String(s));
+      return true;
+    };
+    return {
+      get stdout() {
+        return out.join("");
+      },
+      get stderr() {
+        return err.join("");
+      },
+      restore() {
+        process.stdout.write = origOut;
+        process.stderr.write = origErr;
+      },
+    };
+  }
+
+  it("--all shows exited agents", async () => {
+    const mod = await loadModule();
+    const { appendGlobalPid } = await import("./globalPidIndex.ts");
+    await appendGlobalPid({
+      pid: 1, // pid 1 is almost never the test process, so isPidAlive returns false
+      cli: "claude",
+      prompt: "exited agent",
+      cwd: process.cwd(),
+      log_file: null,
+      status: "exited",
+      exit_code: 0,
+      exit_reason: "done",
+      started_at: Date.now() - 10_000,
+    });
+
+    const cap = captureOutput();
+    let code: number | null;
+    try {
+      code = await mod.runSubcommand(["bun", "cli.js", "ls", "--all", "--json"]);
+    } finally {
+      cap.restore();
+    }
+    expect(code).toBe(0);
+    const parsed = JSON.parse(cap.stdout);
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed.some((r: any) => r.prompt === "exited agent")).toBe(true);
+  });
+
+  it("keyword filter restricts results to matching agents", async () => {
+    const mod = await loadModule();
+    const { appendGlobalPid } = await import("./globalPidIndex.ts");
+    await appendGlobalPid({
+      pid: process.pid,
+      cli: "claude",
+      prompt: "unique-xyzzy-prompt",
+      cwd: process.cwd(),
+      log_file: null,
+      status: "active",
+      exit_code: null,
+      exit_reason: null,
+      started_at: Date.now(),
+    });
+
+    const cap = captureOutput();
+    let code: number | null;
+    try {
+      code = await mod.runSubcommand(["bun", "cli.js", "ls", "--json", "unique-xyzzy-prompt"]);
+    } finally {
+      cap.restore();
+    }
+    expect(code).toBe(0);
+    const parsed = JSON.parse(cap.stdout);
+    expect(parsed.every((r: any) => r.prompt?.includes("unique-xyzzy-prompt"))).toBe(true);
+  });
+
+  it("keyword filter returns 'no running agents' when nothing matches", async () => {
+    const { runSubcommand } = await loadModule();
+    const stderr: string[] = [];
+    const orig = process.stderr.write.bind(process.stderr);
+    (process.stderr as any).write = (s: any) => {
+      stderr.push(String(s));
+      return true;
+    };
+    try {
+      const code = await runSubcommand(["bun", "cli.js", "ls", "no-match-zzzzzz"]);
+      expect(code).toBe(0);
+      expect(stderr.join("")).toMatch(/no running agents matched/);
+    } finally {
+      process.stderr.write = orig;
+    }
+  });
+
+  it("list alias routes to cmdLs", async () => {
+    const { runSubcommand } = await loadModule();
+    const stderr: string[] = [];
+    const orig = process.stderr.write.bind(process.stderr);
+    (process.stderr as any).write = (s: any) => {
+      stderr.push(String(s));
+      return true;
+    };
+    try {
+      const code = await runSubcommand(["bun", "cli.js", "list"]);
+      expect(code).toBe(0);
+    } finally {
+      process.stderr.write = orig;
+    }
+  });
+
+  it("ps alias routes to cmdLs", async () => {
+    const { runSubcommand } = await loadModule();
+    const stderr: string[] = [];
+    const orig = process.stderr.write.bind(process.stderr);
+    (process.stderr as any).write = (s: any) => {
+      stderr.push(String(s));
+      return true;
+    };
+    try {
+      const code = await runSubcommand(["bun", "cli.js", "ps"]);
+      expect(code).toBe(0);
+    } finally {
+      process.stderr.write = orig;
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// cmdRead — head and cat modes
+// ---------------------------------------------------------------------------
+
+describe("subcommands.cmdRead head and cat modes", () => {
+  it("head emits first N lines", async () => {
+    const { runSubcommand } = await loadModule();
+    const { appendGlobalPid } = await import("./globalPidIndex.ts");
+    const tmp = await mkdtemp(path.join(tmpdir(), "ay-head-log-"));
+    try {
+      const logPath = path.join(tmp, "x.raw.log");
+      const lines: string[] = [];
+      for (let i = 0; i < 50; i++) lines.push(`line-${i}`);
+      await writeFile(logPath, lines.join("\r\n") + "\r\n");
+
+      await appendGlobalPid({
+        pid: process.pid,
+        cli: "claude",
+        prompt: null,
+        cwd: process.cwd(),
+        log_file: logPath,
+        status: "active",
+        exit_code: null,
+        exit_reason: null,
+        started_at: Date.now(),
+      });
+
+      const stdout: string[] = [];
+      const orig = process.stdout.write.bind(process.stdout);
+      (process.stdout as any).write = (s: any) => {
+        stdout.push(String(s));
+        return true;
+      };
+      const stderr_chunks: string[] = [];
+      const origErr = process.stderr.write.bind(process.stderr);
+      (process.stderr as any).write = (s: any) => {
+        stderr_chunks.push(String(s));
+        return true;
+      };
+      try {
+        const code = await runSubcommand(["bun", "cli.js", "head", String(process.pid), "-n", "5"]);
+        expect(code).toBe(0);
+      } finally {
+        process.stdout.write = orig;
+        process.stderr.write = origErr;
+      }
+      const text = stdout.join("");
+      expect(text).toMatch(/line-0/);
+      expect(text).toMatch(/line-4/);
+      expect(text).not.toMatch(/line-10\b/);
+    } finally {
+      await rm(tmp, { recursive: true, force: true }).catch(() => null);
+    }
+  });
+
+  it("cat emits all lines", async () => {
+    const { runSubcommand } = await loadModule();
+    const { appendGlobalPid } = await import("./globalPidIndex.ts");
+    const tmp = await mkdtemp(path.join(tmpdir(), "ay-cat-log-"));
+    try {
+      const logPath = path.join(tmp, "x.raw.log");
+      await writeFile(logPath, "alpha\r\nbeta\r\ngamma\r\n");
+
+      await appendGlobalPid({
+        pid: process.pid,
+        cli: "claude",
+        prompt: null,
+        cwd: process.cwd(),
+        log_file: logPath,
+        status: "active",
+        exit_code: null,
+        exit_reason: null,
+        started_at: Date.now(),
+      });
+
+      const stdout: string[] = [];
+      const orig = process.stdout.write.bind(process.stdout);
+      (process.stdout as any).write = (s: any) => {
+        stdout.push(String(s));
+        return true;
+      };
+      const stderr_chunks: string[] = [];
+      const origErr = process.stderr.write.bind(process.stderr);
+      (process.stderr as any).write = (s: any) => {
+        stderr_chunks.push(String(s));
+        return true;
+      };
+      try {
+        const code = await runSubcommand(["bun", "cli.js", "cat", String(process.pid)]);
+        expect(code).toBe(0);
+      } finally {
+        process.stdout.write = orig;
+        process.stderr.write = origErr;
+      }
+      const text = stdout.join("");
+      expect(text).toMatch(/alpha/);
+      expect(text).toMatch(/beta/);
+      expect(text).toMatch(/gamma/);
+    } finally {
+      await rm(tmp, { recursive: true, force: true }).catch(() => null);
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// cmdNote
+// ---------------------------------------------------------------------------
+
+describe("subcommands.cmdNote", () => {
+  it("throws usage error when no keyword given", async () => {
+    const { runSubcommand } = await loadModule();
+    const stderr: string[] = [];
+    const orig = process.stderr.write.bind(process.stderr);
+    (process.stderr as any).write = (s: any) => {
+      stderr.push(String(s));
+      return true;
+    };
+    try {
+      const code = await runSubcommand(["bun", "cli.js", "note"]);
+      expect(code).toBe(1);
+      expect(stderr.join("")).toMatch(/usage:/i);
+    } finally {
+      process.stderr.write = orig;
+    }
+  });
+
+  it("sets a note on a matched agent", async () => {
+    const mod = await loadModule();
+    const { appendGlobalPid } = await import("./globalPidIndex.ts");
+    await appendGlobalPid({
+      pid: process.pid,
+      cli: "claude",
+      prompt: "note-target",
+      cwd: process.cwd(),
+      log_file: null,
+      status: "active",
+      exit_code: null,
+      exit_reason: null,
+      started_at: Date.now(),
+    });
+
+    const stdout: string[] = [];
+    const origOut = process.stdout.write.bind(process.stdout);
+    (process.stdout as any).write = (s: any) => {
+      stdout.push(String(s));
+      return true;
+    };
+    const origErr = process.stderr.write.bind(process.stderr);
+    (process.stderr as any).write = () => true;
+    try {
+      const code = await mod.runSubcommand([
+        "bun",
+        "cli.js",
+        "note",
+        String(process.pid),
+        "my note text",
+      ]);
+      expect(code).toBe(0);
+      expect(stdout.join("")).toMatch(/note set/);
+    } finally {
+      process.stdout.write = origOut;
+      process.stderr.write = origErr;
+    }
+  });
+
+  it("clears a note when no text given", async () => {
+    const mod = await loadModule();
+    const { appendGlobalPid } = await import("./globalPidIndex.ts");
+    await appendGlobalPid({
+      pid: process.pid,
+      cli: "claude",
+      prompt: "note-clear-target",
+      cwd: process.cwd(),
+      log_file: null,
+      status: "active",
+      exit_code: null,
+      exit_reason: null,
+      started_at: Date.now(),
+    });
+
+    const stdout: string[] = [];
+    const origOut = process.stdout.write.bind(process.stdout);
+    (process.stdout as any).write = (s: any) => {
+      stdout.push(String(s));
+      return true;
+    };
+    (process.stderr as any).write = () => true;
+    try {
+      const code = await mod.runSubcommand(["bun", "cli.js", "note", String(process.pid)]);
+      expect(code).toBe(0);
+      expect(stdout.join("")).toMatch(/cleared note/);
+    } finally {
+      process.stdout.write = origOut;
+      process.stderr.write = process.stderr.write; // no-op restore (silenced above)
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// cmdStatus
+// ---------------------------------------------------------------------------
+
+describe("subcommands.cmdStatus", () => {
+  it("throws usage error when no keyword given", async () => {
+    const { runSubcommand } = await loadModule();
+    const stderr: string[] = [];
+    const orig = process.stderr.write.bind(process.stderr);
+    (process.stderr as any).write = (s: any) => {
+      stderr.push(String(s));
+      return true;
+    };
+    try {
+      const code = await runSubcommand(["bun", "cli.js", "status"]);
+      expect(code).toBe(1);
+      expect(stderr.join("")).toMatch(/usage:/i);
+    } finally {
+      process.stderr.write = orig;
+    }
+  });
+
+  it("emits JSON snapshot for a matched agent", async () => {
+    const mod = await loadModule();
+    const { appendGlobalPid } = await import("./globalPidIndex.ts");
+    await appendGlobalPid({
+      pid: process.pid,
+      cli: "claude",
+      prompt: "status-test",
+      cwd: process.cwd(),
+      log_file: null,
+      status: "active",
+      exit_code: null,
+      exit_reason: null,
+      started_at: Date.now() - 1000,
+    });
+
+    const stdout: string[] = [];
+    const origOut = process.stdout.write.bind(process.stdout);
+    (process.stdout as any).write = (s: any) => {
+      stdout.push(String(s));
+      return true;
+    };
+    (process.stderr as any).write = () => true;
+    try {
+      const code = await mod.runSubcommand(["bun", "cli.js", "status", String(process.pid)]);
+      expect(code).toBe(0);
+    } finally {
+      process.stdout.write = origOut;
+    }
+    const snap = JSON.parse(stdout.join(""));
+    expect(snap).toMatchObject({ pid: process.pid, cli: "claude" });
+    expect(typeof snap.age_ms).toBe("number");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// cmdRestart
+// ---------------------------------------------------------------------------
+
+describe("subcommands.cmdRestart", () => {
+  it("returns 1 and warns when the agent is still alive", async () => {
+    const mod = await loadModule();
+    const { appendGlobalPid } = await import("./globalPidIndex.ts");
+    await appendGlobalPid({
+      pid: process.pid,
+      cli: "claude",
+      prompt: "restart-live-test",
+      cwd: process.cwd(),
+      log_file: null,
+      status: "active",
+      exit_code: null,
+      exit_reason: null,
+      started_at: Date.now(),
+    });
+
+    const stderr: string[] = [];
+    const origErr = process.stderr.write.bind(process.stderr);
+    (process.stderr as any).write = (s: any) => {
+      stderr.push(String(s));
+      return true;
+    };
+    try {
+      const code = await mod.runSubcommand(["bun", "cli.js", "restart", String(process.pid)]);
+      expect(code).toBe(1);
+      expect(stderr.join("")).toMatch(/still running/);
+    } finally {
+      process.stderr.write = origErr;
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// listRecords merges per-cwd TS file with global
+// ---------------------------------------------------------------------------
+
 describe("subcommands.listRecords merges per-cwd TS file with global", () => {
   it("includes records from <cwd>/.agent-yes/pid-records.jsonl", async () => {
     // Write a fake per-cwd file that uses the live process pid so liveOnly