claude-yes 1.29.2 → 1.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-yes",
-  "version": "1.29.2",
+  "version": "1.31.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "claude",
@@ -50,13 +50,15 @@
   },
   "files": [
     "ts/*.ts",
-    "dist"
+    "dist",
+    "scripts"
   ],
   "scripts": {
     "build": "bun run build:index && bun run build:cli",
     "postbuild": "bun ./ts/postbuild.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",
+    "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",
@@ -89,6 +91,7 @@
     ]
   },
   "dependencies": {
+    "bun": "^1.3.1",
     "bun-pty": "^0.3.2",
     "from-node-stream": "^0.0.11"
   },
@@ -100,13 +103,14 @@
     "@semantic-release/release-notes-generator": "^14.1.0",
     "@types/bun": "^1.2.18",
     "@types/jest": "^30.0.0",
+    "@types/ms": "^2.1.0",
     "@types/node": "^24.0.10",
     "@types/yargs": "^17.0.33",
     "cpu-wait": "^0.0.10",
-    "enhanced-ms": "^4.1.0",
     "execa": "^9.6.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.1.4",
+    "ms": "^2.1.3",
     "p-map": "^7.0.3",
     "phpdie": "^1.7.0",
     "rambda": "^10.3.2",
@@ -119,7 +123,12 @@
     "yargs": "^18.0.0"
   },
   "peerDependencies": {
-    "node-pty": "^1.0.0",
+    "node-pty": "^1.1.0-beta38",
     "typescript": "^5.8.3"
+  },
+  "peerDependenciesMeta": {
+    "node-pty": {
+      "optional": true
+    }
   }
 }

package/ts/{tryCatch.spec.ts → catcher.spec.ts}

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
-import { catcher } from './tryCatch';
+import { catcher } from './catcher';
 
-describe('tryCatch', () => {
+describe('catcher', () => {
   describe('curried overload', () => {
     it('should return a function when called with only catchFn', () => {
       const catchFn = () => 'error';
@@ -9,10 +9,14 @@ describe('tryCatch', () => {
       expect(typeof result).toBe('function');
     });
 
-    it('should catch errors and call catchFn', () => {
+    it('should catch errors and call catchFn with error, function, and args', () => {
       let catchedError: unknown;
-      const catchFn = (error: unknown) => {
+      let catchedFn: unknown;
+      let catchedArgs: unknown[];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
         catchedError = error;
+        catchedFn = fn;
+        catchedArgs = args;
         return 'caught';
       };
 
@@ -27,6 +31,8 @@ describe('tryCatch', () => {
 
       expect(result).toBe('caught');
       expect(catchedError).toBeInstanceOf(Error);
+      expect(catchedFn).toBe(errorFn);
+      expect(catchedArgs).toEqual(['arg1', 'arg2']);
       expect(calledArgs).toEqual(['arg1', 'arg2']);
     });
 
@@ -53,10 +59,14 @@ describe('tryCatch', () => {
   });
 
   describe('direct overload', () => {
-    it('should catch errors and call catchFn directly', () => {
+    it('should catch errors and call catchFn with error, function, and args directly', () => {
       let catchedError: unknown;
-      const catchFn = (error: unknown) => {
+      let catchedFn: unknown;
+      let catchedArgs: unknown[];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
         catchedError = error;
+        catchedFn = fn;
+        catchedArgs = args;
         return 'caught';
       };
 
@@ -71,6 +81,8 @@ describe('tryCatch', () => {
 
       expect(result).toBe('caught');
       expect(catchedError).toBeInstanceOf(Error);
+      expect(catchedFn).toBe(errorFn);
+      expect(catchedArgs).toEqual(['arg1', 'arg2']);
       expect(calledArgs).toEqual(['arg1', 'arg2']);
     });
 
@@ -97,40 +109,52 @@ describe('tryCatch', () => {
   });
 
   describe('error handling', () => {
-    it('should handle different error types', () => {
+    it('should handle different error types and pass function context', () => {
       const results: unknown[] = [];
-      const catchFn = (error: unknown) => {
+      const functions: unknown[] = [];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
         results.push(error);
+        functions.push(fn);
         return 'handled';
       };
 
       // String error
-      const stringErrorFn = catcher(catchFn, () => {
+      const stringErrorFn = () => {
         throw 'string error';
-      });
-      expect(stringErrorFn()).toBe('handled');
+      };
+      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 = catcher(catchFn, () => {
+      const objectErrorFn = () => {
         throw objectError;
-      });
-      expect(objectErrorFn()).toBe('handled');
+      };
+      const wrappedObjectFn = catcher(catchFn, objectErrorFn);
+      expect(wrappedObjectFn()).toBe('handled');
       expect(results[1]).toBe(objectError);
+      expect(functions[1]).toBe(objectErrorFn);
 
       // null error
-      const nullErrorFn = catcher(catchFn, () => {
+      const nullErrorFn = () => {
         throw null;
-      });
-      expect(nullErrorFn()).toBe('handled');
+      };
+      const wrappedNullFn = catcher(catchFn, nullErrorFn);
+      expect(wrappedNullFn()).toBe('handled');
       expect(results[2]).toBe(null);
+      expect(functions[2]).toBe(nullErrorFn);
     });
 
-    it('should preserve function parameters', () => {
+    it('should preserve function parameters and pass them to catchFn', () => {
       let caughtError: unknown;
-      const catchFn = (error: unknown) => {
+      let caughtFn: unknown;
+      let caughtArgs: unknown[];
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
         caughtError = error;
+        caughtFn = fn;
+        caughtArgs = args;
         return 'caught';
       };
 
@@ -151,12 +175,18 @@ describe('tryCatch', () => {
       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;
-      const catchFn = (error: 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';
       };
 
@@ -172,6 +202,8 @@ describe('tryCatch', () => {
       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', () => {
@@ -194,7 +226,8 @@ describe('tryCatch', () => {
 
   describe('type safety', () => {
     it('should maintain function signature', () => {
-      const catchFn = (error: unknown) => 'error';
+      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) =>
+        'error';
       const originalFn = (a: number, b: string): string => `${a}-${b}`;
 
       const wrappedFn = catcher(catchFn, originalFn);
@@ -203,5 +236,25 @@ describe('tryCatch', () => {
       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,14 +1,34 @@
 #!/usr/bin/env node
 import DIE from 'phpdie';
-import cliYes, { parseCliArgs } from './';
+import cliYesConfig from '../cli-yes.config';
 
-// if (!globalThis.Bun) // run with same arguments in Bun
+// if node-pty is not installed, re-run with bun
+const hasNodePty = !!(await import('node-pty').catch(() => null));
+if (!globalThis.Bun && !hasNodePty) {
+  // run with same arguments in Bun if not already
+  console.log('No node-pty installed. 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(', ')}`;
 
 if (config.verbose) {
   process.env.VERBOSE = 'true'; // enable verbose logging in yesLog.ts

package/ts/codex-resume.spec.ts

@@ -68,10 +68,6 @@ describe('Codex Session Restoration', () => {
     // Create test directories
     await mkdir(cwd1, { recursive: true });
     await mkdir(cwd2, { recursive: true });
-
-    // Build the project first
-    const buildResult = await runCodexYes(['--help'], process.cwd(), 10000);
-    console.log('Build check:', buildResult.exitCode === 0 ? 'OK' : 'FAILED');
   });
 
   afterAll(async () => {

package/ts/codexSessionManager.test.ts

@@ -0,0 +1,259 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { mkdir, rm, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import {
+  type CodexSession,
+  extractSessionId,
+  extractSessionIdFromSessionMeta,
+  getAllWorkingDirectories,
+  getRecentSessionsForCwd,
+  getSessionForCwd,
+  storeSessionForCwd,
+} from './codexSessionManager';
+
+// Create a temporary test directory
+const testDir = join(tmpdir(), 'claude-yes-test-' + Date.now());
+const testCodexDir = join(testDir, '.codex', 'sessions');
+const testConfigDir = join(testDir, '.config', 'cli-yes');
+
+// Store original environment
+const originalTestHome = process.env.CLI_YES_TEST_HOME;
+
+beforeEach(async () => {
+  // Set up test directories
+  await mkdir(testCodexDir, { recursive: true });
+  await mkdir(testConfigDir, { recursive: true });
+
+  // Set test home directory
+  process.env.CLI_YES_TEST_HOME = testDir;
+});
+
+afterEach(async () => {
+  // Clean up
+  process.env.CLI_YES_TEST_HOME = originalTestHome;
+  await rm(testDir, { recursive: true, force: true });
+});
+
+// Helper function to create a mock codex session file
+async function createMockSessionFile(sessionData: {
+  id: string;
+  timestamp: string;
+  cwd: string;
+  git?: any;
+}) {
+  const year = new Date(sessionData.timestamp).getFullYear();
+  const month = String(new Date(sessionData.timestamp).getMonth() + 1).padStart(
+    2,
+    '0',
+  );
+  const day = String(new Date(sessionData.timestamp).getDate()).padStart(
+    2,
+    '0',
+  );
+
+  const sessionDir = join(testCodexDir, String(year), month, day);
+  await mkdir(sessionDir, { recursive: true });
+
+  const filename = `test-session-${sessionData.id}.jsonl`;
+  const filePath = join(sessionDir, filename);
+
+  const sessionMeta = {
+    timestamp: sessionData.timestamp,
+    type: 'session_meta',
+    payload: {
+      id: sessionData.id,
+      timestamp: sessionData.timestamp,
+      cwd: sessionData.cwd,
+      originator: 'codex_cli_rs',
+      cli_version: '0.42.0',
+      instructions: null,
+      git: sessionData.git,
+    },
+  };
+
+  const content = JSON.stringify(sessionMeta) + '\n';
+  await writeFile(filePath, content);
+
+  return filePath;
+}
+
+describe('codexSessionManager', () => {
+  describe('extractSessionId', () => {
+    it('should extract valid session IDs from output', () => {
+      const output1 = 'Session ID: 019a4877-5f3c-7763-b573-513cc2d5d291';
+      const output2 =
+        'Starting session 019a4877-5f3c-7763-b573-513cc2d5d291 for user';
+      const output3 = 'No session ID here';
+
+      expect(extractSessionId(output1)).toBe(
+        '019a4877-5f3c-7763-b573-513cc2d5d291',
+      );
+      expect(extractSessionId(output2)).toBe(
+        '019a4877-5f3c-7763-b573-513cc2d5d291',
+      );
+      expect(extractSessionId(output3)).toBeNull();
+    });
+  });
+
+  describe('extractSessionIdFromSessionMeta', () => {
+    it('should extract session ID from valid session metadata', () => {
+      const sessionContent = JSON.stringify({
+        timestamp: '2025-11-03T06:46:14.123Z',
+        type: 'session_meta',
+        payload: {
+          id: '019a4877-5f3c-7763-b573-513cc2d5d291',
+          cwd: '/test/path',
+        },
+      });
+
+      expect(extractSessionIdFromSessionMeta(sessionContent)).toBe(
+        '019a4877-5f3c-7763-b573-513cc2d5d291',
+      );
+    });
+
+    it('should fall back to regex extraction for invalid JSON', () => {
+      const invalidContent =
+        'Invalid JSON but contains 019a4877-5f3c-7763-b573-513cc2d5d291';
+
+      expect(extractSessionIdFromSessionMeta(invalidContent)).toBe(
+        '019a4877-5f3c-7763-b573-513cc2d5d291',
+      );
+    });
+  });
+
+  describe('session storage and retrieval', () => {
+    it('should store and retrieve session IDs for directories', async () => {
+      const cwd = '/test/project';
+      const sessionId = '019a4877-5f3c-7763-b573-513cc2d5d291';
+
+      await storeSessionForCwd(cwd, sessionId);
+      const retrieved = await getSessionForCwd(cwd);
+
+      expect(retrieved).toBe(sessionId);
+    });
+
+    it('should return null for non-existent directories', async () => {
+      const result = await getSessionForCwd('/non/existent');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('codex session file parsing', () => {
+    it('should read sessions from actual codex files', async () => {
+      const sessionData = {
+        id: '019a4877-5f3c-7763-b573-513cc2d5d291',
+        timestamp: '2025-11-03T06:46:14.123Z',
+        cwd: '/v1/code/snomiao/claude-yes/tree/main',
+        git: {
+          commit_hash: 'abc123',
+          branch: 'main',
+          repository_url: 'git@github.com:snomiao/claude-yes.git',
+        },
+      };
+
+      await createMockSessionFile(sessionData);
+
+      const retrieved = await getSessionForCwd(sessionData.cwd);
+      expect(retrieved).toBe(sessionData.id);
+    });
+
+    it('should get recent sessions for a directory', async () => {
+      const cwd = '/test/project';
+      const sessions = [
+        {
+          id: 'session-1',
+          timestamp: '2025-11-03T10:00:00.000Z',
+          cwd,
+        },
+        {
+          id: 'session-2',
+          timestamp: '2025-11-03T09:00:00.000Z',
+          cwd,
+        },
+        {
+          id: 'session-3',
+          timestamp: '2025-11-03T08:00:00.000Z',
+          cwd,
+        },
+      ];
+
+      for (const session of sessions) {
+        await createMockSessionFile(session);
+      }
+
+      const recent = await getRecentSessionsForCwd(cwd, 2);
+      expect(recent).toHaveLength(2);
+      expect(recent[0].id).toBe('session-1'); // Most recent first
+      expect(recent[1].id).toBe('session-2');
+    });
+
+    it('should get all working directories with counts', async () => {
+      const sessions = [
+        {
+          id: 'session-1',
+          timestamp: '2025-11-03T10:00:00.000Z',
+          cwd: '/project-a',
+        },
+        {
+          id: 'session-2',
+          timestamp: '2025-11-03T09:00:00.000Z',
+          cwd: '/project-a',
+        },
+        {
+          id: 'session-3',
+          timestamp: '2025-11-03T08:00:00.000Z',
+          cwd: '/project-b',
+        },
+      ];
+
+      for (const session of sessions) {
+        await createMockSessionFile(session);
+      }
+
+      const directories = await getAllWorkingDirectories();
+      expect(directories).toHaveLength(2);
+
+      const projectA = directories.find((d) => d.cwd === '/project-a');
+      const projectB = directories.find((d) => d.cwd === '/project-b');
+
+      expect(projectA?.count).toBe(2);
+      expect(projectB?.count).toBe(1);
+
+      // Should be sorted by last session time (most recent first)
+      expect(directories[0].cwd).toBe('/project-a');
+    });
+  });
+
+  describe('fallback behavior', () => {
+    it('should fall back to stored mapping when no codex files exist', async () => {
+      const cwd = '/fallback/test';
+      const sessionId = 'fallback-session-id';
+
+      // Store in mapping but don't create codex file
+      await storeSessionForCwd(cwd, sessionId);
+
+      const retrieved = await getSessionForCwd(cwd);
+      expect(retrieved).toBe(sessionId);
+    });
+
+    it('should prefer codex files over stored mapping', async () => {
+      const cwd = '/preference/test';
+      const storedSessionId = 'stored-session';
+      const codexSessionId = 'codex-session';
+
+      // Store in mapping first
+      await storeSessionForCwd(cwd, storedSessionId);
+
+      // Create codex file with different session ID
+      await createMockSessionFile({
+        id: codexSessionId,
+        timestamp: '2025-11-03T10:00:00.000Z',
+        cwd,
+      });
+
+      const retrieved = await getSessionForCwd(cwd);
+      expect(retrieved).toBe(codexSessionId); // Should prefer codex file
+    });
+  });
+});