claude-yes 1.27.0 → 1.29.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-yes",
-  "version": "1.27.0",
+  "version": "1.29.2",
   "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": {
@@ -54,12 +53,14 @@
     "dist"
   ],
   "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=node-pty --external=bun-pty --external=from-node-stream",
+    "build:index": "bun build ts/index.ts --outdir=dist --target=node --sourcemap --external=node-pty --external=bun-pty --external=from-node-stream",
+    "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 +89,8 @@
     ]
   },
   "dependencies": {
-    "bun-pty": "^0.3.2"
+    "bun-pty": "^0.3.2",
+    "from-node-stream": "^0.0.11"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.2.5",
@@ -103,7 +105,6 @@
     "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,7 +115,6 @@
     "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"
   },

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/cli.ts

@@ -1,17 +1,15 @@
 #!/usr/bin/env node
 import DIE from 'phpdie';
-import cliYes, { SUPPORTED_CLIS } from '.';
-import { parseCliArgs } from './parseCliArgs';
+import cliYes, { parseCliArgs } from './';
+
+// if (!globalThis.Bun) // run with same arguments in Bun
 
 // 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');
 
-// 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);
+  });
+});

package/ts/index.ts

@@ -1,17 +1,15 @@
 import { fromReadable, fromWritable } from 'from-node-stream';
-import { appendFile, mkdir, rm, writeFile } from 'fs/promises';
+import { mkdir, writeFile } from 'fs/promises';
 import path from 'path';
 import DIE from 'phpdie';
 import sflow from 'sflow';
 import { TerminalTextRender } from 'terminal-render';
-import tsaComposer from 'tsa-composer';
 import rawConfig from '../cli-yes.config.js';
 import {
   extractSessionId,
   getSessionForCwd,
   storeSessionForCwd,
 } from './codexSessionManager.js';
-import { defineCliYesConfig } from './defineConfig.js';
 import { IdleWaiter } from './idleWaiter';
 import { ReadyManager } from './ReadyManager';
 import { removeControlCharacters } from './removeControlCharacters';
@@ -22,9 +20,11 @@ import {
   updateCurrentTaskStatus,
 } from './runningLock';
 import { catcher } from './tryCatch';
-import { deepMixin } from './utils';
 import { yesLog } from './yesLog';
 
+export { parseCliArgs } from './parseCliArgs';
+export { removeControlCharacters };
+
 export type AgentCliConfig = {
   install?: string; // hint user for install command if not installed
   version?: string; // hint user for version command to check if installed
@@ -157,17 +157,29 @@ export default async function cliYes({
   // const pty = await import('node-pty');
 
   // its recommened to use bun-pty in windows
-  const pty = await import('node-pty')
-    .catch(async () => await import('bun-pty'))
+  const pty = await (globalThis.Bun ? import('bun-pty') : import('node-pty'))
+    // .catch(async () => await import('node-pty'))
     .catch(async () =>
       DIE('Please install node-pty or bun-pty, run this: bun install bun-pty'),
     );
+  console.log(globalThis.Bun);
+
+  // Detect if running as sub-agent
+  const isSubAgent = !!process.env.CLAUDE_PPID;
+  if (isSubAgent) {
+    console.log(
+      `[${cli}-yes] Running as sub-agent (CLAUDE_PPID=${process.env.CLAUDE_PPID})`,
+    );
+  }
 
   const getPtyOptions = () => ({
     name: 'xterm-color',
     ...getTerminalDimensions(),
     cwd: cwd ?? process.cwd(),
-    env: env ?? (process.env as Record<string, string>),
+    env: {
+      ...(env ?? (process.env as Record<string, string>)),
+      CLAUDE_PPID: String(process.ppid),
+    },
   });
 
   // Apply CLI specific configurations (moved to CLI_CONFIGURES)
@@ -496,5 +508,3 @@ export default async function cliYes({
     };
   }
 }
-
-export { removeControlCharacters };

package/ts/parseCliArgs.ts

@@ -87,12 +87,14 @@ export function parseCliArgs(argv: string[]) {
     ? rawArgs.slice(cliArgIndex ?? 0, dashIndex ?? undefined)
     : [];
   const dashPrompt: string | undefined =
-    dashIndex !== undefined
-      ? rawArgs.slice(dashIndex + 1).join(' ')
-      : undefined;
+    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 {
+    cwd: process.cwd(),
+    env: process.env as Record<string, string>,
     cli: (cliName ||
       parsedArgv.cli ||
       parsedArgv._[0]

package/ts/removeControlCharacters.spec.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest';
+import { removeControlCharacters } from './removeControlCharacters';
+
+describe('removeControlCharacters', () => {
+  it('should remove ANSI escape sequences', () => {
+    const input = '\u001b[31mRed text\u001b[0m';
+    const expected = 'Red text';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should remove cursor positioning codes', () => {
+    const input = '\u001b[1;1HHello\u001b[2;1HWorld';
+    const expected = 'HelloWorld';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should remove color codes', () => {
+    const input = '\u001b[32mGreen\u001b[0m \u001b[31mRed\u001b[0m';
+    const expected = 'Green Red';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should remove complex ANSI sequences', () => {
+    const input = '\u001b[1;33;40mYellow on black\u001b[0m';
+    const expected = 'Yellow on black';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should handle empty string', () => {
+    expect(removeControlCharacters('')).toBe('');
+  });
+
+  it('should handle string with no control characters', () => {
+    const input = 'Plain text with no escape sequences';
+    expect(removeControlCharacters(input)).toBe(input);
+  });
+
+  it('should remove CSI sequences with multiple parameters', () => {
+    const input = '\u001b[38;5;196mBright red\u001b[0m';
+    const expected = 'Bright red';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should remove C1 control characters', () => {
+    const input = '\u009b[32mGreen text\u009b[0m';
+    const expected = 'Green text';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should handle mixed control and regular characters', () => {
+    const input =
+      'Start\u001b[1mBold\u001b[0mMiddle\u001b[4mUnderline\u001b[0mEnd';
+    const expected = 'StartBoldMiddleUnderlineEnd';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should preserve spaces and newlines', () => {
+    const input = 'Line 1\u001b[31m\nRed Line 2\u001b[0m\n\nLine 4';
+    const expected = 'Line 1\nRed Line 2\n\nLine 4';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should handle cursor movement sequences', () => {
+    const input = '\u001b[2AUp\u001b[3BDown\u001b[4CRight\u001b[5DLeft';
+    const expected = 'UpDownRightLeft';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it('should handle erase sequences', () => {
+    const input = 'Text\u001b[2JClear\u001b[KLine';
+    const expected = 'TextClearLine';
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+});

package/ts/tryCatch.spec.ts

@@ -0,0 +1,207 @@
+import { describe, expect, it } from 'vitest';
+import { catcher } from './tryCatch';
+
+describe('tryCatch', () => {
+  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', () => {
+      let catchedError: unknown;
+      const catchFn = (error: unknown) => {
+        catchedError = error;
+        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(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 directly', () => {
+      let catchedError: unknown;
+      const catchFn = (error: unknown) => {
+        catchedError = error;
+        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(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', () => {
+      const results: unknown[] = [];
+      const catchFn = (error: unknown) => {
+        results.push(error);
+        return 'handled';
+      };
+
+      // String error
+      const stringErrorFn = catcher(catchFn, () => {
+        throw 'string error';
+      });
+      expect(stringErrorFn()).toBe('handled');
+      expect(results[0]).toBe('string error');
+
+      // Object error
+      const objectError = { message: 'object error' };
+      const objectErrorFn = catcher(catchFn, () => {
+        throw objectError;
+      });
+      expect(objectErrorFn()).toBe('handled');
+      expect(results[1]).toBe(objectError);
+
+      // null error
+      const nullErrorFn = catcher(catchFn, () => {
+        throw null;
+      });
+      expect(nullErrorFn()).toBe('handled');
+      expect(results[2]).toBe(null);
+    });
+
+    it('should preserve function parameters', () => {
+      let caughtError: unknown;
+      const catchFn = (error: unknown) => {
+        caughtError = error;
+        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);
+    });
+
+    it('should handle functions with no parameters', () => {
+      let caughtError: unknown;
+      const catchFn = (error: unknown) => {
+        caughtError = error;
+        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);
+    });
+
+    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) => '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');
+    });
+  });
+});