claude-yes 1.31.2 → 1.32.2

package/ts/logger.ts

@@ -0,0 +1,22 @@
+import winston from "winston";
+
+// Configure Winston logger
+const logFormat = winston.format.combine(
+  winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+  winston.format.printf(({ timestamp, level, message, ...meta }) => {
+    const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : "";
+    return `${timestamp} [${level}]: ${message}${metaStr}`;
+  }),
+);
+
+export const logger = winston.createLogger({
+  level: process.env.VERBOSE ? "debug" : "info",
+  format: logFormat,
+  transports: [
+    new winston.transports.Console({
+      format: winston.format.combine(winston.format.colorize(), logFormat),
+    }),
+  ],
+  silent: false,
+});
+

package/ts/parseCliArgs.spec.ts

@@ -1,232 +1,231 @@
-import { describe, expect, it } from 'vitest';
-import { parseCliArgs } from './parseCliArgs';
+#!/usr/bin/env bun test
+import { describe, expect, it } from "vitest";
+import { parseCliArgs } from "./parseCliArgs";
 
-describe('CLI argument parsing', () => {
-  it('should parse cli name from first positional argument', () => {
-    const result = parseCliArgs(['node', '/path/to/cli', 'claude']);
+describe("CLI argument parsing", () => {
+  it("should parse cli name from first positional argument", () => {
+    const result = parseCliArgs(["node", "/path/to/cli", "claude"]);
 
-    expect(result.cli).toBe('claude');
+    expect(result.cli).toBe("claude");
   });
 
-  it('should parse prompt from --prompt flag', () => {
-    const result = parseCliArgs([
-      'node',
-      '/path/to/cli',
-      '--prompt',
-      'hello world',
-      'claude',
-    ]);
+  it("should parse prompt from --prompt flag", () => {
+    const result = parseCliArgs(["node", "/path/to/cli", "--prompt", "hello world", "claude"]);
 
-    expect(result.prompt).toBe('hello world');
+    expect(result.prompt).toBe("hello world");
   });
 
-  it('should parse prompt from -- separator', () => {
-    const result = parseCliArgs([
-      'node',
-      '/path/to/cli',
-      'claude',
-      '--',
-      'hello',
-      'world',
-    ]);
+  it("should parse prompt from -- separator", () => {
+    const result = parseCliArgs(["node", "/path/to/cli", "claude", "--", "hello", "world"]);
 
-    expect(result.prompt).toBe('hello world');
+    expect(result.prompt).toBe("hello world");
   });
 
-  it('should parse prompt from only -- separator with -yes cli', () => {
-    const result = parseCliArgs([
-      'node',
-      '/path/to/claude-yes',
-      '--',
-      'hello',
-      'world',
-    ]);
+  it("should parse prompt from only -- separator with -yes cli", () => {
+    const result = parseCliArgs(["node", "/path/to/claude-yes", "--", "hello", "world"]);
 
-    expect(result.prompt).toBe('hello world');
+    expect(result.prompt).toBe("hello world");
   });
 
-  it('should combine --prompt and -- prompt', () => {
+  it("should combine --prompt and -- prompt", () => {
     const result = parseCliArgs([
-      'node',
-      '/path/to/cli',
-      '--prompt',
-      'part1',
-      'claude',
-      '--',
-      'part2',
+      "node",
+      "/path/to/cli",
+      "--prompt",
+      "part1",
+      "claude",
+      "--",
+      "part2",
     ]);
 
-    expect(result.prompt).toBe('part1 part2');
+    expect(result.prompt).toBe("part1 part2");
   });
 
-  it('should parse --idle flag', () => {
-    const result = parseCliArgs([
-      'node',
-      '/path/to/cli',
-      '--idle',
-      '30s',
-      'claude',
-    ]);
+  it("should parse --idle flag", () => {
+    const result = parseCliArgs(["node", "/path/to/cli", "--idle", "30s", "claude"]);
 
     expect(result.exitOnIdle).toBe(30000);
   });
 
-  it('should parse --exit-on-idle flag (deprecated)', () => {
-    const result = parseCliArgs([
-      'node',
-      '/path/to/cli',
-      '--exit-on-idle',
-      '1m',
-      'claude',
-    ]);
+  it("should parse --exit-on-idle flag (deprecated)", () => {
+    const result = parseCliArgs(["node", "/path/to/cli", "--exit-on-idle", "1m", "claude"]);
 
     expect(result.exitOnIdle).toBe(60000);
   });
 
-  it('should parse --robust flag', () => {
-    const result = parseCliArgs(['node', '/path/to/cli', '--robust', 'claude']);
+  it("should parse --robust flag", () => {
+    const result = parseCliArgs(["node", "/path/to/cli", "--robust", "claude"]);
 
     expect(result.robust).toBe(true);
   });
 
-  it('should parse --no-robust flag', () => {
-    const result = parseCliArgs([
-      'node',
-      '/path/to/cli',
-      '--no-robust',
-      'claude',
-    ]);
+  it("should parse --no-robust flag", () => {
+    const result = parseCliArgs(["node", "/path/to/cli", "--no-robust", "claude"]);
 
     expect(result.robust).toBe(false);
   });
 
-  it('should parse --queue flag', () => {
-    const result = parseCliArgs(['node', '/path/to/cli', '--queue', 'claude']);
+  it("should parse --queue flag", () => {
+    const result = parseCliArgs(["node", "/path/to/cli", "--queue", "claude"]);
 
     expect(result.queue).toBe(true);
   });
 
-  it('should parse --no-queue flag', () => {
-    const result = parseCliArgs([
-      'node',
-      '/path/to/cli',
-      '--no-queue',
-      'claude',
-    ]);
+  it("should parse --no-queue flag", () => {
+    const result = parseCliArgs(["node", "/path/to/cli", "--no-queue", "claude"]);
 
     expect(result.queue).toBe(false);
   });
 
-  it('should parse --logFile flag', () => {
-    const result = parseCliArgs([
-      'node',
-      '/path/to/cli',
-      '--logFile',
-      './output.log',
-      'claude',
-    ]);
+  it("should parse --logFile flag", () => {
+    const result = parseCliArgs(["node", "/path/to/cli", "--logFile", "./output.log", "claude"]);
 
-    expect(result.logFile).toBe('./output.log');
+    expect(result.logFile).toBe("./output.log");
   });
 
-  it('should parse --verbose flag', () => {
-    const result = parseCliArgs([
-      'node',
-      '/path/to/cli',
-      '--verbose',
-      'claude',
-    ]);
+  it("should parse --verbose flag", () => {
+    const result = parseCliArgs(["node", "/path/to/cli", "--verbose", "claude"]);
 
     expect(result.verbose).toBe(true);
   });
 
-  it('should pass through unknown CLI args to cliArgs', () => {
+  it("should pass through unknown CLI args to cliArgs", () => {
+    const result = parseCliArgs(["node", "/path/to/cli", "claude", "--unknown-flag", "value"]);
+
+    expect(result.cliArgs).toContain("--unknown-flag");
+    expect(result.cliArgs).toContain("value");
+  });
+
+  it("should separate agent-yes args from cli args before --", () => {
     const result = parseCliArgs([
-      'node',
-      '/path/to/cli',
-      'claude',
-      '--unknown-flag',
-      'value',
+      "node",
+      "/path/to/cli",
+      "--robust",
+      "claude",
+      "--claude-arg",
+      "--",
+      "prompt",
     ]);
 
-    expect(result.cliArgs).toContain('--unknown-flag');
-    expect(result.cliArgs).toContain('value');
+    expect(result.cli).toBe("claude");
+    expect(result.robust).toBe(true);
+    expect(result.cliArgs).toContain("--claude-arg");
+    expect(result.prompt).toBe("prompt");
+  });
+
+  it("should detect cli name from script name (claude-yes)", () => {
+    const result = parseCliArgs(["/usr/bin/node", "/usr/local/bin/claude-yes", "--prompt", "test"]);
+
+    expect(result.cli).toBe("claude");
   });
 
-  it('should separate cli-yes args from cli args before --', () => {
+  it("should detect cli name from script name (codex-yes)", () => {
+    const result = parseCliArgs(["/usr/bin/node", "/usr/local/bin/codex-yes", "--prompt", "test"]);
+
+    expect(result.cli).toBe("codex");
+  });
+
+  it("should prefer script name over explicit cli argument", () => {
     const result = parseCliArgs([
-      'node',
-      '/path/to/cli',
-      '--robust',
-      'claude',
-      '--claude-arg',
-      '--',
-      'prompt',
+      "/usr/bin/node",
+      "/usr/local/bin/claude-yes",
+      "--prompt",
+      "test",
+      "gemini",
     ]);
 
-    expect(result.cli).toBe('claude');
-    expect(result.robust).toBe(true);
-    expect(result.cliArgs).toContain('--claude-arg');
-    expect(result.prompt).toBe('prompt');
+    // cliName (from script) takes precedence over positional arg
+    expect(result.cli).toBe("claude");
   });
 
-  it('should detect cli name from script name (claude-yes)', () => {
+  it("should handle empty cliArgs when no positional cli is provided", () => {
     const result = parseCliArgs([
-      '/usr/bin/node',
-      '/usr/local/bin/claude-yes',
-      '--prompt',
-      'test',
+      "/usr/bin/node",
+      "/usr/local/bin/claude-yes",
+      "--prompt",
+      "prompt",
     ]);
 
-    expect(result.cli).toBe('claude');
+    expect(result.cliArgs).toEqual([]);
+    expect(result.prompt).toBe("prompt");
   });
 
-  it('should detect cli name from script name (codex-yes)', () => {
+  it("should include all args when no -- separator is present", () => {
     const result = parseCliArgs([
-      '/usr/bin/node',
-      '/usr/local/bin/codex-yes',
-      '--prompt',
-      'test',
+      "node",
+      "/path/to/cli",
+      "claude",
+      "--some-flag",
+      "--another-flag",
     ]);
 
-    expect(result.cli).toBe('codex');
+    expect(result.cliArgs).toContain("--some-flag");
+    expect(result.cliArgs).toContain("--another-flag");
   });
 
-  it('should prefer script name over explicit cli argument', () => {
+  it("should parse bunx agent-yes command with verbose and dash prompt", () => {
     const result = parseCliArgs([
-      '/usr/bin/node',
-      '/usr/local/bin/claude-yes',
-      '--prompt',
-      'test',
-      'gemini',
+      "/tmp/bunx-0-agent-yes@beta/node_modules/bun/bin/bun.exe",
+      "/tmp/bunx-0-agent-yes@beta/node_modules/agent-yes/dist/cli.js",
+      "--verbose",
+      "claude",
+      "--",
+      "lets",
+      "fix",
+      "signin",
+      "page,",
+      "setup",
+      "shadcn",
     ]);
 
-    // cliName (from script) takes precedence over positional arg
-    expect(result.cli).toBe('claude');
+    expect(result.cli).toBe("claude");
+    expect(result.verbose).toBe(true);
+    expect(result.cliArgs).toEqual([]);
+    expect(result.prompt).toBe("lets fix signin page, setup shadcn");
   });
 
-  it('should handle empty cliArgs when no positional cli is provided', () => {
+  it("should parse bunx agent-yes command with verbose and dash prompt", () => {
     const result = parseCliArgs([
-      '/usr/bin/node',
-      '/usr/local/bin/claude-yes',
-      '--prompt',
-      'prompt',
+      "/tmp/bunx-0-agent-yes@beta/node_modules/bun/bin/bun.exe",
+      "/tmp/bunx-0-agent-yes@beta/node_modules/agent-yes/dist/claude-yes.js",
+      "--",
+      "lets",
+      "fix",
+      "signin",
+      "page,",
+      "setup",
+      "shadcn",
     ]);
 
+    expect(result.cli).toBe("claude");
+    expect(result.verbose).toBe(false);
     expect(result.cliArgs).toEqual([]);
-    expect(result.prompt).toBe('prompt');
+    expect(result.prompt).toBe("lets fix signin page, setup shadcn");
+  });
+
+  it("should pass -h flag to claude CLI args", () => {
+    const result = parseCliArgs([
+      "/root/.nvm/versions/node/v24.5.0/bin/node",
+      "/root/.bun/bin/claude-yes",
+      "-h",
+    ]);
+
+    expect(result.cli).toBe("claude");
+    expect(result.cliArgs).toEqual(["-h"]);
   });
 
-  it('should include all args when no -- separator is present', () => {
+  it("should parse --use-skills flag", () => {
     const result = parseCliArgs([
-      'node',
-      '/path/to/cli',
-      'claude',
-      '--some-flag',
-      '--another-flag',
+      "node",
+      "/path/to/cli",
+      "--use-skills",
+      "codex",
+      "--",
+      "Implement feature",
     ]);
 
-    expect(result.cliArgs).toContain('--some-flag');
-    expect(result.cliArgs).toContain('--another-flag');
+    expect(result.useSkills).toBe(true);
+    expect(result.cli).toBe("codex");
+    expect(result.prompt).toBe("Implement feature");
   });
 });

package/ts/parseCliArgs.ts

@@ -1,79 +1,105 @@
-import ms from 'ms';
-import yargs from 'yargs';
-import { hideBin } from 'yargs/helpers';
-import { SUPPORTED_CLIS } from '.';
+import ms from "ms";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
+import pkg from "../package.json" with { type: "json" };
 
+// const pkg = await JSON.parse(await readFile(path.resolve((import.meta.dir) + "/../package.json"), 'utf8'))
 /**
  * Parse CLI arguments the same way cli.ts does
  * This is a test helper that mirrors the parsing logic in cli.ts
  */
 export function parseCliArgs(argv: string[]) {
   // Detect cli name from script name (same logic as cli.ts:10-14)
-  const scriptName = argv[1]?.split(/[\/\\]/).pop();
-  const cliName = ((e?: string) => {
-    if (e === 'cli' || e === 'cli.ts' || e === 'cli.js') return undefined;
-    return e?.replace(/-yes(\.[jt]s)?$/, '');
-  })(scriptName);
+  const cliName =
+    argv[1]
+      ?.split(/[/\\]/)
+      .at(-1)
+      ?.replace(/(\.[jt]s)?$/, "")
+      .replace(/^(cli|agent)(-yes$)?/, "")
+      .replace(/-yes$/, "") || undefined;
 
   // Parse args with yargs (same logic as cli.ts:16-73)
   const parsedArgv = yargs(hideBin(argv))
-    .usage('Usage: $0 [cli] [cli-yes args] [agent-cli args] [--] [prompts...]')
+    .usage("Usage: $0 [cli] [agent-yes args] [agent-cli args] [--] [prompts...]")
     .example(
-      '$0 claude --idle=30s -- solve all todos in my codebase, commit one by one',
-      'Run Claude with a 30 seconds idle timeout, and the prompt is everything after `--`',
+      "$0 claude --idle=30s -- solve all todos in my codebase, commit one by one",
+      "Run Claude with a 30 seconds idle timeout, and the prompt is everything after `--`",
     )
-    .option('robust', {
-      type: 'boolean',
+    // TODO: add a --docker option, will tell cli.ts to start docker process with tty and handles all stdio forwarding
+
+    .option("robust", {
+      type: "boolean",
       default: true,
-      description:
-        're-spawn Claude with --continue if it crashes, only works for claude yet',
-      alias: 'r',
+      description: "re-spawn Claude with --continue if it crashes, only works for claude yet",
+      alias: "r",
     })
-    .option('logFile', {
-      type: 'string',
-      description: 'Rendered log file to write to.',
+    .option("logFile", {
+      type: "string",
+      description: "Rendered log file to write to.",
     })
-    .option('prompt', {
-      type: 'string',
-      description: 'Prompt to send to Claude (also can be passed after --)',
-      alias: 'p',
+    .option("prompt", {
+      type: "string",
+      description: "Prompt to send to Claude (also can be passed after --)",
+      alias: "p",
     })
-    .option('verbose', {
-      type: 'boolean',
-      description: 'Enable verbose logging, will emit ./agent-yes.log',
+    .option("verbose", {
+      type: "boolean",
+      description: "Enable verbose logging, will emit ./agent-yes.log",
       default: false,
     })
-    .option('exit-on-idle', {
-      type: 'string',
-      description: 'Exit after a period of inactivity, e.g., "5s" or "1m"',
-      deprecated: 'use --idle instead',
-      default: '60s',
-      alias: 'e',
+    .option("use-skills", {
+      type: "boolean",
+      description:
+        "Prepend SKILL.md header from current directory to the prompt (helpful for non-Claude agents)",
+      default: false,
     })
-    .option('idle', {
-      type: 'string',
+    .option("exit-on-idle", {
+      type: "string",
       description: 'Exit after a period of inactivity, e.g., "5s" or "1m"',
-      alias: 'i',
+      deprecated: "use --idle instead",
+      default: "60s",
+      alias: "e",
     })
-    .option('queue', {
-      type: 'boolean',
+    .option("idle", {
+      type: "string",
+      description: 'short idle time, will perform idle action when reached, e.g., "5s" or "1m"',
+      alias: "i",
+    })
+    .option("idle-action", {
+      type: "string",
+      description: 'Idle action to perform when idle time is reached, e.g., "exit" or "TODO.md"',
+    })
+    .option("queue", {
+      type: "boolean",
       description:
-        'Queue Agent when spawning multiple agents in the same directory/repo, can be disabled with --no-queue',
-      default: true,
+        "Queue Agent Commands when spawning multiple agents in the same directory/repo, can be disabled with --no-queue",
+      default: false,
     })
-    .positional('cli', {
-      describe:
-        'The AI CLI to run, e.g., claude, codex, copilot, cursor, gemini',
-      type: 'string',
+    .option("install", {
+      type: "boolean",
+      description: "Automatically Install/Update the CLI if not found or outdated",
+      default: false,
+    })
+    .option("continue", {
+      type: "boolean",
+      description:
+        "Resume previous session in current cwd if any, note: will exit if no previous session found",
+      default: false,
+      alias: "c",
+    })
+    .positional("cli", {
+      describe: "The AI CLI to run, e.g., claude, codex, copilot, cursor, gemini",
+      type: "string",
       choices: SUPPORTED_CLIS,
       demandOption: false,
       default: cliName,
     })
     .help()
-    .version()
+    .version(pkg.version)
     .parserConfiguration({
-      'unknown-options-as-args': true,
-      'halt-at-non-option': true,
+      "unknown-options-as-args": true,
+      "halt-at-non-option": true,
     })
     .parseSync();
 
@@ -81,15 +107,57 @@ export function parseCliArgs(argv: string[]) {
   const optionalIndex = (e: number) => (0 <= e ? e : undefined);
   const rawArgs = argv.slice(2);
   const cliArgIndex = optionalIndex(rawArgs.indexOf(String(parsedArgv._[0])));
-  const dashIndex = optionalIndex(rawArgs.indexOf('--'));
+  const dashIndex = optionalIndex(rawArgs.indexOf("--"));
+
+  // Reconstruct what yargs consumed vs what it didn't
+  const yargsConsumed = new Set<string>();
+
+  // Add consumed flags
+  Object.keys(parsedArgv).forEach((key) => {
+    if (key !== "_" && key !== "$0" && parsedArgv[key as keyof typeof parsedArgv] !== undefined) {
+      yargsConsumed.add(`--${key}`);
+      // Add short aliases
+      if (key === "prompt") yargsConsumed.add("-p");
+      if (key === "robust") yargsConsumed.add("-r");
+      if (key === "idle") yargsConsumed.add("-i");
+      if (key === "exitOnIdle") yargsConsumed.add("-e");
+      if (key === "continue") yargsConsumed.add("-c");
+    }
+  });
+
+  const cliArgsForSpawn = (() => {
+    if (parsedArgv._[0] && !cliName) {
+      // Explicit CLI name provided as positional arg
+      return rawArgs.slice((cliArgIndex ?? 0) + 1, dashIndex ?? undefined);
+    } else if (cliName) {
+      // CLI name from script, filter out only what yargs consumed
+      const result: string[] = [];
+      const argsToCheck = rawArgs.slice(0, dashIndex ?? undefined);
+
+      for (let i = 0; i < argsToCheck.length; i++) {
+        const arg = argsToCheck[i];
+        if (!arg) continue;
+
+        const [flag] = arg.split("=");
 
-  const cliArgsForSpawn = parsedArgv._[0]
-    ? rawArgs.slice(cliArgIndex ?? 0, dashIndex ?? undefined)
-    : [];
+        if (flag && yargsConsumed.has(flag)) {
+          // Skip consumed flag and its value if separate
+          if (!arg.includes("=") && i + 1 < argsToCheck.length) {
+            const nextArg = argsToCheck[i + 1];
+            if (nextArg && !nextArg.startsWith("-")) {
+              i++; // Skip value
+            }
+          }
+        } else {
+          result.push(arg);
+        }
+      }
+      return result;
+    }
+    return [];
+  })();
   const dashPrompt: string | undefined =
-    dashIndex === undefined
-      ? undefined
-      : rawArgs.slice(dashIndex + 1).join(' ');
+    dashIndex === undefined ? undefined : rawArgs.slice(dashIndex + 1).join(" ");
 
   // Return the config object that would be passed to cliYes (same logic as cli.ts:99-121)
   return {
@@ -97,12 +165,10 @@ export function parseCliArgs(argv: string[]) {
     env: process.env as Record<string, string>,
     cli: (cliName ||
       parsedArgv.cli ||
-      parsedArgv._[0]
-        ?.toString()
-        ?.replace?.(/-yes$/, '')) as (typeof SUPPORTED_CLIS)[number],
+      parsedArgv._[0]?.toString()?.replace?.(/-yes$/, "")) as (typeof SUPPORTED_CLIS)[number],
     cliArgs: cliArgsForSpawn,
-    prompt:
-      [parsedArgv.prompt, dashPrompt].filter(Boolean).join(' ') || undefined,
+    prompt: [parsedArgv.prompt, dashPrompt].filter(Boolean).join(" ") || undefined,
+    install: parsedArgv.install,
     exitOnIdle: Number(
       (parsedArgv.idle || parsedArgv.exitOnIdle)?.replace(/.*/, (e) =>
         String(ms(e as ms.StringValue)),
@@ -112,5 +178,7 @@ export function parseCliArgs(argv: string[]) {
     robust: parsedArgv.robust,
     logFile: parsedArgv.logFile,
     verbose: parsedArgv.verbose,
+    resume: parsedArgv.continue, // Note: intentional use resume here to avoid preserved keyword (continue)
+    useSkills: parsedArgv.useSkills,
   };
 }