claude-yes 1.31.2 → 1.32.2

package/package.json

@@ -1,134 +1,146 @@
 {
   "name": "claude-yes",
-  "version": "1.31.2",
+  "version": "1.32.2",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
+    "ai",
+    "anthropic",
+    "assistant",
+    "auto-response",
+    "automation",
     "claude",
-    "qwen",
-    "gemini",
+    "cli",
     "codex",
     "copilot",
     "cursor",
+    "gemini",
     "grok",
-    "ai",
-    "automation",
-    "cli",
-    "wrapper",
-    "assistant",
-    "anthropic",
-    "auto-response"
+    "qwen",
+    "wrapper"
   ],
-  "homepage": "https://github.com/snomiao/claude-yes#readme",
+  "homepage": "https://github.com/snomiao/agent-yes#readme",
   "bugs": {
-    "url": "https://github.com/snomiao/claude-yes/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/snomiao/claude-yes.git"
+    "url": "https://github.com/snomiao/agent-yes/issues"
   },
   "license": "MIT",
   "author": "snomiao <snomiao@gmail.com>",
-  "type": "module",
-  "exports": {
-    "import": "./dist/index.js",
-    "types": "./ts/index.ts"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/snomiao/agent-yes.git"
   },
-  "module": "ts/index.ts",
-  "types": "./ts/index.ts",
   "bin": {
-    "claude-yes": "dist/claude-yes.js",
-    "cli-yes": "dist/cli.js",
-    "codex-yes": "dist/codex-yes.js",
-    "copilot-yes": "dist/copilot-yes.js",
-    "cursor-yes": "dist/cursor-yes.js",
-    "gemini-yes": "dist/gemini-yes.js",
-    "grok-yes": "dist/grok-yes.js",
-    "qwen-yes": "dist/qwen-yes.js"
+    "agent-yes": "./dist/agent-yes.js",
+    "amp-yes": "./dist/amp-yes.js",
+    "auggie-yes": "./dist/auggie-yes.js",
+    "claude-yes": "./dist/claude-yes.js",
+    "codex-yes": "./dist/codex-yes.js",
+    "copilot-yes": "./dist/copilot-yes.js",
+    "cursor-yes": "./dist/cursor-yes.js",
+    "gemini-yes": "./dist/gemini-yes.js",
+    "grok-yes": "./dist/grok-yes.js",
+    "qwen-yes": "./dist/qwen-yes.js"
   },
   "directories": {
     "doc": "docs"
   },
   "files": [
-    "ts/*.ts",
-    "dist",
-    "scripts"
+    "dist/**/*.js",
+    "!dist/**/*.map",
+    "scripts",
+    "ts/*.ts"
   ],
+  "type": "module",
+  "module": "ts/index.ts",
+  "types": "./ts/index.ts",
+  "exports": {
+    "types": "./ts/index.ts",
+    "import": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "scripts": {
-    "build": "bun run build:index && bun run build:cli",
+    "build": "bun build ./ts/cli.ts ./ts/index.ts --outdir=dist --target=node --sourcemap --external=@snomiao/bun-pty --external=bun-pty --external=node-pty --external=from-node-stream --external=bun",
     "postbuild": "bun ./ts/postbuild.ts",
-    "build:cli": "bun build ts/cli.ts --outdir=dist --target=node --sourcemap --external=bun-pty --external=node-pty --external=from-node-stream --external=bun",
-    "build:index": "bun build ts/index.ts --outdir=dist --target=node --sourcemap --external=bun-pty --external=node-pty --external=from-node-stream --external=bun",
     "demo": "bun run build && bun link && claude-yes -- demo",
     "dev": "bun ts/index.ts",
-    "fmt": "bunx @biomejs/biome check --fix && bunx sort-package-json",
-    "prepack": "bun run build",
-    "prepare": "bunx husky && bun run build",
+    "fmt": "oxlint --fix --fix-suggestions && oxfmt",
+    "_prepack": "bun run build",
+    "prepare": "husky",
+    "release": "standard-version && npm publish",
+    "release:beta": "standard-version && npm publish --tag beta",
     "test": "bun test --coverage"
   },
-  "lint-staged": {
-    "*.{ts,js,json,md}": [
-      "bunx @biomejs/biome check --fix"
-    ]
-  },
-  "release": {
-    "branches": [
-      "main"
-    ],
-    "plugins": [
-      "@semantic-release/commit-analyzer",
-      "@semantic-release/release-notes-generator",
-      "@semantic-release/changelog",
-      "@semantic-release/npm",
-      [
-        "@semantic-release/exec",
-        {
-          "publishCmd": "npm pkg set name=claude-yes"
-        }
-      ],
-      "@semantic-release/npm",
-      "@semantic-release/git",
-      "@semantic-release/github"
-    ]
-  },
   "dependencies": {
-    "bun": "^1.3.1",
-    "bun-pty": "^0.3.2",
+    "@snomiao/bun-pty": "^0.3.4",
+    "bun-pty": "^0.4.8",
     "from-node-stream": "^0.1.2"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.2.5",
+    "@anthropic-ai/sdk": "^0.71.2",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/exec": "^7.1.0",
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/release-notes-generator": "^14.1.0",
-    "@types/bun": "^1.2.18",
+    "@types/bun": "^1.3.6",
     "@types/jest": "^30.0.0",
     "@types/ms": "^2.1.0",
-    "@types/node": "^24.0.10",
-    "@types/yargs": "^17.0.33",
+    "@types/node": "^25.0.10",
+    "@types/yargs": "^17.0.35",
     "cpu-wait": "^0.0.10",
-    "execa": "^9.6.0",
+    "execa": "^9.6.1",
     "husky": "^9.1.7",
-    "lint-staged": "^16.1.4",
+    "ink": "^6.6.0",
+    "lint-staged": "^16.2.7",
     "ms": "^2.1.3",
-    "p-map": "^7.0.3",
+    "node-pty": "^1.1.0",
+    "openai": "^6.16.0",
+    "oxfmt": "^0.26.0",
+    "oxlint": "^1.41.0",
+    "p-map": "^7.0.4",
     "phpdie": "^1.7.0",
-    "rambda": "^10.3.2",
-    "semantic-release": "^24.2.6",
-    "sflow": "^1.20.2",
+    "rambda": "^11.0.1",
+    "semantic-release": "^25.0.2",
+    "sflow": "^1.27.0",
+    "standard-version": "^9.5.0",
     "strip-ansi-control-characters": "^2.0.0",
-    "terminal-render": "^1.2.0",
-    "tsa-composer": "^3.0.2",
-    "vitest": "^3.2.4",
+    "terminal-render": "^1.2.2",
+    "tsa-composer": "^3.0.3",
+    "vitest": "^4.0.17",
+    "winston": "^3.19.0",
     "yargs": "^18.0.0"
   },
   "peerDependencies": {
-    "node-pty": "^1.1.0-beta38",
-    "typescript": "^5.8.3"
+    "node-pty": "latest",
+    "typescript": "^5.9.3"
   },
   "peerDependenciesMeta": {
     "node-pty": {
       "optional": true
     }
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "_release": {
+    "branches": [
+      "main"
+    ],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      [
+        "@semantic-release/exec",
+        {
+          "publishCmd": "npm pkg set name=claude-yes"
+        }
+      ],
+      "@semantic-release/npm",
+      "@semantic-release/git",
+      "@semantic-release/github"
+    ]
   }
 }

package/ts/ReadyManager.spec.ts

@@ -1,13 +1,13 @@
-import { describe, expect, it } from 'vitest';
-import { ReadyManager } from './ReadyManager';
+import { describe, expect, it } from "vitest";
+import { ReadyManager } from "./ReadyManager";
 
-describe('ReadyManager', () => {
-  it('should start in not ready state', () => {
+describe("ReadyManager", () => {
+  it("should start in not ready state", () => {
     const manager = new ReadyManager();
     expect(manager.wait()).toBeInstanceOf(Promise);
   });
 
-  it('should resolve wait when ready is called', async () => {
+  it("should resolve wait when ready is called", async () => {
     const manager = new ReadyManager();
     const waitPromise = manager.wait();
 
@@ -16,7 +16,7 @@ describe('ReadyManager', () => {
     await expect(waitPromise).resolves.toBeUndefined();
   });
 
-  it('should resolve immediately if already ready', async () => {
+  it("should resolve immediately if already ready", async () => {
     const manager = new ReadyManager();
     manager.ready();
 
@@ -24,7 +24,7 @@ describe('ReadyManager', () => {
     expect(result).toBeUndefined();
   });
 
-  it('should handle multiple waiters', async () => {
+  it("should handle multiple waiters", async () => {
     const manager = new ReadyManager();
     const wait1 = manager.wait();
     const wait2 = manager.wait();
@@ -39,7 +39,7 @@ describe('ReadyManager', () => {
     ]);
   });
 
-  it('should reset to not ready when unready is called', async () => {
+  it("should reset to not ready when unready is called", async () => {
     const manager = new ReadyManager();
     manager.ready();
     manager.unready();
@@ -47,13 +47,13 @@ describe('ReadyManager', () => {
     expect(manager.wait()).toBeInstanceOf(Promise);
   });
 
-  it('should handle ready with no waiting queue', () => {
+  it("should handle ready with no waiting queue", () => {
     const manager = new ReadyManager();
     manager.ready(); // Should not throw even if no one is waiting
     expect(manager.wait()).toBeUndefined(); // Should be ready now
   });
 
-  it('should handle multiple ready/unready cycles', async () => {
+  it("should handle multiple ready/unready cycles", async () => {
     const manager = new ReadyManager();
 
     // First cycle

package/ts/ReadyManager.ts

@@ -1,5 +1,5 @@
 export class ReadyManager {
-  private isReady = false;
+  isReady = false;
   private readyQueue: (() => void)[] = [];
   wait() {
     if (this.isReady) return;

package/ts/SUPPORTED_CLIS.ts

@@ -0,0 +1,4 @@
+import { CLIS_CONFIG } from "./index.ts";
+
+export const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG) as SUPPORTED_CLIS[];
+export type SUPPORTED_CLIS = keyof typeof CLIS_CONFIG;

package/ts/catcher.spec.ts

@@ -1,15 +1,15 @@
-import { describe, expect, it } from 'vitest';
-import { catcher } from './catcher';
+import { describe, expect, it } from "vitest";
+import { catcher } from "./catcher";
 
-describe('catcher', () => {
-  describe('curried overload', () => {
-    it('should return a function when called with only catchFn', () => {
-      const catchFn = () => 'error';
+describe("catcher", () => {
+  describe("curried overload", () => {
+    it("should return a function when called with only catchFn", () => {
+      const catchFn = () => "error";
       const result = catcher(catchFn);
-      expect(typeof result).toBe('function');
+      expect(typeof result).toBe("function");
     });
 
-    it('should catch errors and call catchFn with error, function, and args', () => {
+    it("should catch errors and call catchFn with error, function, and args", () => {
       let catchedError: unknown;
       let catchedFn: unknown;
       let catchedArgs: unknown[];
@@ -17,49 +17,49 @@ describe('catcher', () => {
         catchedError = error;
         catchedFn = fn;
         catchedArgs = args;
-        return 'caught';
+        return "caught";
       };
 
       let calledArgs: unknown[] = [];
       const errorFn = (...args: unknown[]) => {
         calledArgs = args;
-        throw new Error('test error');
+        throw new Error("test error");
       };
 
       const wrappedFn = catcher(catchFn)(errorFn);
-      const result = wrappedFn('arg1', 'arg2');
+      const result = wrappedFn("arg1", "arg2");
 
-      expect(result).toBe('caught');
+      expect(result).toBe("caught");
       expect(catchedError).toBeInstanceOf(Error);
       expect(catchedFn).toBe(errorFn);
-      expect(catchedArgs).toEqual(['arg1', 'arg2']);
-      expect(calledArgs).toEqual(['arg1', 'arg2']);
+      expect(catchedArgs).toEqual(["arg1", "arg2"]);
+      expect(calledArgs).toEqual(["arg1", "arg2"]);
     });
 
-    it('should return normal result when no error occurs', () => {
+    it("should return normal result when no error occurs", () => {
       let catchCalled = false;
       const catchFn = () => {
         catchCalled = true;
-        return 'error';
+        return "error";
       };
 
       let calledArgs: unknown[] = [];
       const normalFn = (...args: unknown[]) => {
         calledArgs = args;
-        return 'success';
+        return "success";
       };
 
       const wrappedFn = catcher(catchFn)(normalFn);
-      const result = wrappedFn('arg1', 'arg2');
+      const result = wrappedFn("arg1", "arg2");
 
-      expect(result).toBe('success');
+      expect(result).toBe("success");
       expect(catchCalled).toBe(false);
-      expect(calledArgs).toEqual(['arg1', 'arg2']);
+      expect(calledArgs).toEqual(["arg1", "arg2"]);
     });
   });
 
-  describe('direct overload', () => {
-    it('should catch errors and call catchFn with error, function, and args directly', () => {
+  describe("direct overload", () => {
+    it("should catch errors and call catchFn with error, function, and args directly", () => {
       let catchedError: unknown;
       let catchedFn: unknown;
       let catchedArgs: unknown[];
@@ -67,73 +67,73 @@ describe('catcher', () => {
         catchedError = error;
         catchedFn = fn;
         catchedArgs = args;
-        return 'caught';
+        return "caught";
       };
 
       let calledArgs: unknown[] = [];
       const errorFn = (...args: unknown[]) => {
         calledArgs = args;
-        throw new Error('test error');
+        throw new Error("test error");
       };
 
       const wrappedFn = catcher(catchFn, errorFn);
-      const result = wrappedFn('arg1', 'arg2');
+      const result = wrappedFn("arg1", "arg2");
 
-      expect(result).toBe('caught');
+      expect(result).toBe("caught");
       expect(catchedError).toBeInstanceOf(Error);
       expect(catchedFn).toBe(errorFn);
-      expect(catchedArgs).toEqual(['arg1', 'arg2']);
-      expect(calledArgs).toEqual(['arg1', 'arg2']);
+      expect(catchedArgs).toEqual(["arg1", "arg2"]);
+      expect(calledArgs).toEqual(["arg1", "arg2"]);
     });
 
-    it('should return normal result when no error occurs directly', () => {
+    it("should return normal result when no error occurs directly", () => {
       let catchCalled = false;
       const catchFn = () => {
         catchCalled = true;
-        return 'error';
+        return "error";
       };
 
       let calledArgs: unknown[] = [];
       const normalFn = (...args: unknown[]) => {
         calledArgs = args;
-        return 'success';
+        return "success";
       };
 
       const wrappedFn = catcher(catchFn, normalFn);
-      const result = wrappedFn('arg1', 'arg2');
+      const result = wrappedFn("arg1", "arg2");
 
-      expect(result).toBe('success');
+      expect(result).toBe("success");
       expect(catchCalled).toBe(false);
-      expect(calledArgs).toEqual(['arg1', 'arg2']);
+      expect(calledArgs).toEqual(["arg1", "arg2"]);
     });
   });
 
-  describe('error handling', () => {
-    it('should handle different error types and pass function context', () => {
+  describe("error handling", () => {
+    it("should handle different error types and pass function context", () => {
       const results: unknown[] = [];
       const functions: unknown[] = [];
-      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
+      const catchFn = (error: unknown, fn: unknown, ..._args: unknown[]) => {
         results.push(error);
         functions.push(fn);
-        return 'handled';
+        return "handled";
       };
 
       // String error
       const stringErrorFn = () => {
-        throw 'string error';
+        throw "string error";
       };
       const wrappedStringFn = catcher(catchFn, stringErrorFn);
-      expect(wrappedStringFn()).toBe('handled');
-      expect(results[0]).toBe('string error');
+      expect(wrappedStringFn()).toBe("handled");
+      expect(results[0]).toBe("string error");
       expect(functions[0]).toBe(stringErrorFn);
 
       // Object error
-      const objectError = { message: 'object error' };
+      const objectError = { message: "object error" };
       const objectErrorFn = () => {
         throw objectError;
       };
       const wrappedObjectFn = catcher(catchFn, objectErrorFn);
-      expect(wrappedObjectFn()).toBe('handled');
+      expect(wrappedObjectFn()).toBe("handled");
       expect(results[1]).toBe(objectError);
       expect(functions[1]).toBe(objectErrorFn);
 
@@ -142,12 +142,12 @@ describe('catcher', () => {
         throw null;
       };
       const wrappedNullFn = catcher(catchFn, nullErrorFn);
-      expect(wrappedNullFn()).toBe('handled');
+      expect(wrappedNullFn()).toBe("handled");
       expect(results[2]).toBe(null);
       expect(functions[2]).toBe(nullErrorFn);
     });
 
-    it('should preserve function parameters and pass them to catchFn', () => {
+    it("should preserve function parameters and pass them to catchFn", () => {
       let caughtError: unknown;
       let caughtFn: unknown;
       let caughtArgs: unknown[];
@@ -155,31 +155,31 @@ describe('catcher', () => {
         caughtError = error;
         caughtFn = fn;
         caughtArgs = args;
-        return 'caught';
+        return "caught";
       };
 
       let testArgs: [number, string, boolean] | undefined;
       const testFn = (a: number, b: string, c: boolean) => {
         testArgs = [a, b, c];
-        if (a > 5) throw new Error('too big');
+        if (a > 5) throw new Error("too big");
         return `${a}-${b}-${c}`;
       };
 
       const wrappedFn = catcher(catchFn, testFn);
 
       // Normal execution
-      expect(wrappedFn(3, 'test', true)).toBe('3-test-true');
-      expect(testArgs).toEqual([3, 'test', true]);
+      expect(wrappedFn(3, "test", true)).toBe("3-test-true");
+      expect(testArgs).toEqual([3, "test", true]);
 
       // Error execution
-      expect(wrappedFn(10, 'error', false)).toBe('caught');
-      expect(testArgs).toEqual([10, 'error', false]);
+      expect(wrappedFn(10, "error", false)).toBe("caught");
+      expect(testArgs).toEqual([10, "error", false]);
       expect(caughtError).toBeInstanceOf(Error);
       expect(caughtFn).toBe(testFn);
-      expect(caughtArgs).toEqual([10, 'error', false]);
+      expect(caughtArgs).toEqual([10, "error", false]);
     });
 
-    it('should handle functions with no parameters', () => {
+    it("should handle functions with no parameters", () => {
       let caughtError: unknown;
       let caughtFn: unknown;
       let caughtArgs: unknown[];
@@ -187,26 +187,26 @@ describe('catcher', () => {
         caughtError = error;
         caughtFn = fn;
         caughtArgs = args;
-        return 'no params caught';
+        return "no params caught";
       };
 
       let called = false;
       const noParamsFn = () => {
         called = true;
-        throw new Error('no params error');
+        throw new Error("no params error");
       };
 
       const wrappedFn = catcher(catchFn, noParamsFn);
       const result = wrappedFn();
 
-      expect(result).toBe('no params caught');
+      expect(result).toBe("no params caught");
       expect(called).toBe(true);
       expect(caughtError).toBeInstanceOf(Error);
       expect(caughtFn).toBe(noParamsFn);
       expect(caughtArgs).toEqual([]);
     });
 
-    it('should handle functions returning different types', () => {
+    it("should handle functions returning different types", () => {
       const catchFn = () => null;
 
       // Function returning number
@@ -214,7 +214,7 @@ describe('catcher', () => {
       expect(numberFn()).toBe(42);
 
       // Function returning object
-      const obj = { key: 'value' };
+      const obj = { key: "value" };
       const objectFn = catcher(catchFn, () => obj);
       expect(objectFn()).toBe(obj);
 
@@ -224,37 +224,36 @@ describe('catcher', () => {
     });
   });
 
-  describe('type safety', () => {
-    it('should maintain function signature', () => {
-      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) =>
-        'error';
+  describe("type safety", () => {
+    it("should maintain function signature", () => {
+      const catchFn = (_error: unknown, _fn: unknown, ..._args: unknown[]) => "error";
       const originalFn = (a: number, b: string): string => `${a}-${b}`;
 
       const wrappedFn = catcher(catchFn, originalFn);
 
       // This should be type-safe
-      const result: string = wrappedFn(1, 'test');
-      expect(result).toBe('1-test');
+      const result: string = wrappedFn(1, "test");
+      expect(result).toBe("1-test");
     });
 
-    it('should pass function reference and arguments to catchFn', () => {
+    it("should pass function reference and arguments to catchFn", () => {
       let capturedFn: unknown;
       let capturedArgs: unknown[];
       const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
         capturedFn = fn;
         capturedArgs = args;
-        return 'handled';
+        return "handled";
       };
 
-      const testFn = (x: number, y: string) => {
-        throw new Error('test');
+      const testFn = (_x: number, _y: string) => {
+        throw new Error("test");
       };
 
       const wrappedFn = catcher(catchFn, testFn);
-      wrappedFn(42, 'hello');
+      wrappedFn(42, "hello");
 
       expect(capturedFn).toBe(testFn);
-      expect(capturedArgs).toEqual([42, 'hello']);
+      expect(capturedArgs).toEqual([42, "hello"]);
     });
   });
 });

package/ts/cli-idle.spec.ts

@@ -1,19 +1,19 @@
-import { exec } from 'child_process';
-import { fromStdio } from 'from-node-stream';
-import sflow from 'sflow';
-import { describe, it } from 'vitest';
-import { sleepms } from './utils';
+import { exec } from "child_process";
+import { fromStdio } from "from-node-stream";
+import sflow from "sflow";
+import { describe, it } from "vitest";
+import { sleepms } from "./utils";
 
-describe('CLI idle tests', () => {
+describe("CLI idle tests", () => {
   // 2025-08-11 ok
-  it.skip('CLI --exit-on-idle flag with custom timeout', async () => {
+  it.skip("CLI --exit-on-idle flag with custom timeout", async () => {
     const p = exec(
       `bunx tsx ./ts/cli.ts claude --verbose --logFile=./cli-idle.log --exit-on-idle=3s "say hello and wait"`,
     );
     const tr = new TransformStream<string, string>();
     const output = await sflow(tr.readable).by(fromStdio(p)).log().text();
     console.log(output);
-    expect(output).toContain('hello');
+    expect(output).toContain("hello");
     await sleepms(1000); // wait for process exit
     expect(p.exitCode).toBe(0);
   }, 20e3);