claude-yes 1.28.0 → 1.30.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-yes",
-  "version": "1.28.0",
+  "version": "1.30.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "claude",
@@ -33,7 +33,6 @@
     "import": "./dist/index.js",
     "types": "./ts/index.ts"
   },
-  "main": "dist/index.js",
   "module": "ts/index.ts",
   "types": "./ts/index.ts",
   "bin": {
@@ -51,15 +50,19 @@
   },
   "files": [
     "ts/*.ts",
-    "dist"
+    "dist",
+    "scripts"
   ],
   "scripts": {
-    "build": "bun build ts/index.ts ts/cli.ts --outdir=dist --target=node --sourcemap --packages=external --external=node-pty",
+    "build": "bun run build:index && bun run build:cli",
     "postbuild": "bun ./ts/postbuild.ts",
-    "dev": "tsx ts/index.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",
+    "prepare": "bunx husky && bun run build",
     "test": "bun test --coverage"
   },
   "lint-staged": {
@@ -88,7 +91,11 @@
     ]
   },
   "dependencies": {
-    "bun-pty": "^0.3.2"
+    "@types/ms": "^2.1.0",
+    "bun": "^1.3.1",
+    "bun-pty": "^0.3.2",
+    "from-node-stream": "^0.0.11",
+    "ms": "^2.1.3"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.2.5",
@@ -101,9 +108,7 @@
     "@types/node": "^24.0.10",
     "@types/yargs": "^17.0.33",
     "cpu-wait": "^0.0.10",
-    "enhanced-ms": "^4.1.0",
     "execa": "^9.6.0",
-    "from-node-stream": "^0.0.11",
     "husky": "^9.1.7",
     "lint-staged": "^16.1.4",
     "p-map": "^7.0.3",
@@ -114,12 +119,11 @@
     "strip-ansi-control-characters": "^2.0.0",
     "terminal-render": "^1.2.0",
     "tsa-composer": "^3.0.2",
-    "tsx": "^4.20.3",
     "vitest": "^3.2.4",
     "yargs": "^18.0.0"
   },
   "peerDependencies": {
-    "node-pty": "^1.0.0",
+    "node-pty": "^1.1.0-beta38",
     "typescript": "^5.8.3"
   }
 }

package/ts/ReadyManager.spec.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+import { ReadyManager } from './ReadyManager';
+
+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 () => {
+    const manager = new ReadyManager();
+    const waitPromise = manager.wait();
+
+    manager.ready();
+
+    await expect(waitPromise).resolves.toBeUndefined();
+  });
+
+  it('should resolve immediately if already ready', async () => {
+    const manager = new ReadyManager();
+    manager.ready();
+
+    const result = manager.wait();
+    expect(result).toBeUndefined();
+  });
+
+  it('should handle multiple waiters', async () => {
+    const manager = new ReadyManager();
+    const wait1 = manager.wait();
+    const wait2 = manager.wait();
+    const wait3 = manager.wait();
+
+    manager.ready();
+
+    await Promise.all([
+      expect(wait1).resolves.toBeUndefined(),
+      expect(wait2).resolves.toBeUndefined(),
+      expect(wait3).resolves.toBeUndefined(),
+    ]);
+  });
+
+  it('should reset to not ready when unready is called', async () => {
+    const manager = new ReadyManager();
+    manager.ready();
+    manager.unready();
+
+    expect(manager.wait()).toBeInstanceOf(Promise);
+  });
+
+  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 () => {
+    const manager = new ReadyManager();
+
+    // First cycle
+    const wait1 = manager.wait();
+    manager.ready();
+    await wait1;
+
+    // Reset
+    manager.unready();
+
+    // Second cycle
+    const wait2 = manager.wait();
+    manager.ready();
+    await expect(wait2).resolves.toBeUndefined();
+  });
+});

package/ts/catcher.spec.ts

@@ -0,0 +1,260 @@
+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';
+      const result = catcher(catchFn);
+      expect(typeof result).toBe('function');
+    });
+
+    it('should catch errors and call catchFn with error, function, and args', () => {
+      let catchedError: unknown;
+      let catchedFn: unknown;
+      let catchedArgs: unknown[];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
+        catchedError = error;
+        catchedFn = fn;
+        catchedArgs = args;
+        return 'caught';
+      };
+
+      let calledArgs: unknown[] = [];
+      const errorFn = (...args: unknown[]) => {
+        calledArgs = args;
+        throw new Error('test error');
+      };
+
+      const wrappedFn = catcher(catchFn)(errorFn);
+      const result = wrappedFn('arg1', 'arg2');
+
+      expect(result).toBe('caught');
+      expect(catchedError).toBeInstanceOf(Error);
+      expect(catchedFn).toBe(errorFn);
+      expect(catchedArgs).toEqual(['arg1', 'arg2']);
+      expect(calledArgs).toEqual(['arg1', 'arg2']);
+    });
+
+    it('should return normal result when no error occurs', () => {
+      let catchCalled = false;
+      const catchFn = () => {
+        catchCalled = true;
+        return 'error';
+      };
+
+      let calledArgs: unknown[] = [];
+      const normalFn = (...args: unknown[]) => {
+        calledArgs = args;
+        return 'success';
+      };
+
+      const wrappedFn = catcher(catchFn)(normalFn);
+      const result = wrappedFn('arg1', 'arg2');
+
+      expect(result).toBe('success');
+      expect(catchCalled).toBe(false);
+      expect(calledArgs).toEqual(['arg1', 'arg2']);
+    });
+  });
+
+  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[];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
+        catchedError = error;
+        catchedFn = fn;
+        catchedArgs = args;
+        return 'caught';
+      };
+
+      let calledArgs: unknown[] = [];
+      const errorFn = (...args: unknown[]) => {
+        calledArgs = args;
+        throw new Error('test error');
+      };
+
+      const wrappedFn = catcher(catchFn, errorFn);
+      const result = wrappedFn('arg1', 'arg2');
+
+      expect(result).toBe('caught');
+      expect(catchedError).toBeInstanceOf(Error);
+      expect(catchedFn).toBe(errorFn);
+      expect(catchedArgs).toEqual(['arg1', 'arg2']);
+      expect(calledArgs).toEqual(['arg1', 'arg2']);
+    });
+
+    it('should return normal result when no error occurs directly', () => {
+      let catchCalled = false;
+      const catchFn = () => {
+        catchCalled = true;
+        return 'error';
+      };
+
+      let calledArgs: unknown[] = [];
+      const normalFn = (...args: unknown[]) => {
+        calledArgs = args;
+        return 'success';
+      };
+
+      const wrappedFn = catcher(catchFn, normalFn);
+      const result = wrappedFn('arg1', 'arg2');
+
+      expect(result).toBe('success');
+      expect(catchCalled).toBe(false);
+      expect(calledArgs).toEqual(['arg1', 'arg2']);
+    });
+  });
+
+  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[]) => {
+        results.push(error);
+        functions.push(fn);
+        return 'handled';
+      };
+
+      // String error
+      const stringErrorFn = () => {
+        throw 'string error';
+      };
+      const wrappedStringFn = catcher(catchFn, stringErrorFn);
+      expect(wrappedStringFn()).toBe('handled');
+      expect(results[0]).toBe('string error');
+      expect(functions[0]).toBe(stringErrorFn);
+
+      // Object error
+      const objectError = { message: 'object error' };
+      const objectErrorFn = () => {
+        throw objectError;
+      };
+      const wrappedObjectFn = catcher(catchFn, objectErrorFn);
+      expect(wrappedObjectFn()).toBe('handled');
+      expect(results[1]).toBe(objectError);
+      expect(functions[1]).toBe(objectErrorFn);
+
+      // null error
+      const nullErrorFn = () => {
+        throw null;
+      };
+      const wrappedNullFn = catcher(catchFn, nullErrorFn);
+      expect(wrappedNullFn()).toBe('handled');
+      expect(results[2]).toBe(null);
+      expect(functions[2]).toBe(nullErrorFn);
+    });
+
+    it('should preserve function parameters and pass them to catchFn', () => {
+      let caughtError: unknown;
+      let caughtFn: unknown;
+      let caughtArgs: unknown[];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
+        caughtError = error;
+        caughtFn = fn;
+        caughtArgs = args;
+        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');
+        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]);
+
+      // Error execution
+      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]);
+    });
+
+    it('should handle functions with no parameters', () => {
+      let caughtError: unknown;
+      let caughtFn: unknown;
+      let caughtArgs: unknown[];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
+        caughtError = error;
+        caughtFn = fn;
+        caughtArgs = args;
+        return 'no params caught';
+      };
+
+      let called = false;
+      const noParamsFn = () => {
+        called = true;
+        throw new Error('no params error');
+      };
+
+      const wrappedFn = catcher(catchFn, noParamsFn);
+      const result = wrappedFn();
+
+      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', () => {
+      const catchFn = () => null;
+
+      // Function returning number
+      const numberFn = catcher(catchFn, () => 42);
+      expect(numberFn()).toBe(42);
+
+      // Function returning object
+      const obj = { key: 'value' };
+      const objectFn = catcher(catchFn, () => obj);
+      expect(objectFn()).toBe(obj);
+
+      // Function returning undefined
+      const undefinedFn = catcher(catchFn, () => undefined);
+      expect(undefinedFn()).toBeUndefined();
+    });
+  });
+
+  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');
+    });
+
+    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';
+      };
+
+      const testFn = (x: number, y: string) => {
+        throw new Error('test');
+      };
+
+      const wrappedFn = catcher(catchFn, testFn);
+      wrappedFn(42, 'hello');
+
+      expect(capturedFn).toBe(testFn);
+      expect(capturedArgs).toEqual([42, 'hello']);
+    });
+  });
+});

package/ts/catcher.ts

@@ -0,0 +1,35 @@
+// curried overload
+export function catcher<F extends (...args: any[]) => any, R>(
+  catchFn: (error: unknown, fn: F, ...args: Parameters<F>) => R,
+): (fn: F) => (...args: Parameters<F>) => ReturnType<F> | R;
+
+// direct overload
+export function catcher<F extends (...args: any[]) => any, R>(
+  catchFn: (error: unknown, fn: F, ...args: Parameters<F>) => R,
+  fn: F,
+): (...args: Parameters<F>) => ReturnType<F> | R;
+
+/**
+ * A utility function to wrap another function with a try-catch block.
+ * If an error occurs during the execution of the function, the provided
+ * catchFn is called with the error, the original function, and its arguments.
+ *
+ * This function supports both direct invocation and curried usage.
+ *
+ * @param catchFn - The function to call when an error occurs.
+ * @param fn - The function to wrap (optional for curried usage).
+ * @returns A new function that wraps the original function with error handling.
+ */
+export function catcher<F extends (...args: any[]) => any, R>(
+  catchFn: (error: unknown, fn: F, ...args: Parameters<F>) => R,
+  fn?: F,
+) {
+  if (!fn) return (fn: F) => catcher(catchFn, fn) as any;
+  return (...args: Parameters<F>) => {
+    try {
+      return fn(...args);
+    } catch (error) {
+      return catchFn(error, fn, ...args);
+    }
+  };
+}

package/ts/cli.ts

@@ -1,17 +1,35 @@
 #!/usr/bin/env node
 import DIE from 'phpdie';
-import cliYes, { SUPPORTED_CLIS } from '.';
-import { parseCliArgs } from './parseCliArgs';
+import cliYesConfig from '../cli-yes.config';
+
+// if node-pty is not installed, re-run with bun
+// const hasNodePty = !!await import('node-pty').catch(() => null);
+if (!globalThis.Bun) {
+  // run with same arguments in Bun if not already
+  console.log('Re-running with Bun...', process.argv);
+  (await import('child_process')).spawnSync(
+    'node_modules/.bin/bun',
+    [process.argv[1]!, '--', ...process.argv.slice(2)],
+    { stdio: 'inherit' },
+  );
+  process.exit(0);
+}
+// check and fix bun-pty on some systems
+if (globalThis.Bun) console.log('Bun detected, using bun-pty');
+//   await import("./fix-pty.js")
+
+// console.log('Running', process.argv);
+
+// Import the CLI module
+const { default: cliYes, parseCliArgs } = await import('./');
 
 // Parse CLI arguments
 const config = parseCliArgs(process.argv);
 
 // Validate CLI name
-if (!config.cli) {
-  DIE('missing cli def');
-}
+if (!config.cli)
+  DIE`missing cli def, available clis: ${Object.keys((await cliYesConfig).clis).join(', ')}`;
 
-// console.clear();
 if (config.verbose) {
   process.env.VERBOSE = 'true'; // enable verbose logging in yesLog.ts
   console.log(config);

package/ts/idleWaiter.spec.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+import { IdleWaiter } from './idleWaiter';
+
+describe('IdleWaiter', () => {
+  it('should initialize with current time', () => {
+    const waiter = new IdleWaiter();
+    expect(waiter.lastActivityTime).toBeCloseTo(Date.now(), -2);
+  });
+
+  it('should update lastActivityTime when ping is called', () => {
+    const waiter = new IdleWaiter();
+    const initialTime = waiter.lastActivityTime;
+
+    // Wait a small amount
+    const start = Date.now();
+    while (Date.now() - start < 10) {
+      // busy wait
+    }
+
+    waiter.ping();
+    expect(waiter.lastActivityTime).toBeGreaterThan(initialTime);
+  });
+
+  it('should return this when ping is called for chaining', () => {
+    const waiter = new IdleWaiter();
+    expect(waiter.ping()).toBe(waiter);
+  });
+
+  it('should resolve wait immediately when already idle', async () => {
+    const waiter = new IdleWaiter();
+
+    // Wait enough time to be considered idle
+    const start = Date.now();
+    while (Date.now() - start < 50) {
+      // busy wait
+    }
+
+    // This should resolve quickly since enough time has passed
+    const waitPromise = waiter.wait(10);
+    await expect(waitPromise).resolves.toBeUndefined();
+  });
+
+  it('should respect custom check interval', () => {
+    const waiter = new IdleWaiter();
+    waiter.checkInterval = 200;
+
+    expect(waiter.checkInterval).toBe(200);
+  });
+
+  it('should have ping method that chains', () => {
+    const waiter = new IdleWaiter();
+    const result = waiter.ping().ping().ping();
+    expect(result).toBe(waiter);
+  });
+});