agent-yes 1.52.4 → 1.53.0

package/dist/{SUPPORTED_CLIS-CGHhOLoD.js → SUPPORTED_CLIS-CuEqXP9l.js}

@@ -9,7 +9,7 @@ import { homedir } from "os";
 import { fileURLToPath } from "url";
 import { appendFileSync, createReadStream, createWriteStream, readFileSync as readFileSync$1, statSync as statSync$1, writeFileSync } from "node:fs";
 import { fileURLToPath as fileURLToPath$1 } from "node:url";
-import { ChildProcess, execFile, spawn as spawn$1, spawnSync } from "node:child_process";
+import { ChildProcess, execFile, execSync as execSync$1, spawn as spawn$1, spawnSync } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
 import { aborted, callbackify, debuglog, inspect, promisify, stripVTControlCharacters } from "node:util";
 import process$1, { execArgv, execPath, hrtime, platform as platform$1 } from "node:process";
@@ -9735,25 +9735,24 @@ async function saveDeprecatedLogFile(logFile, content, verbose) {
 }
 
 //#endregion
-//#region ts/catcher.ts
+//#region ts/tryCatch.ts
 /**
 * 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).
+* @param fn - The function to wrap.
 * @returns A new function that wraps the original function with error handling.
 */
-function catcher(catchFn, fn) {
-	if (!fn) return (fn) => catcher(catchFn, fn);
-	return (...args) => {
+function tryCatch(catchFn, fn) {
+	let attempts = 0;
+	return function robustFn(...args) {
 		try {
+			attempts++;
 			return fn(...args);
 		} catch (error) {
-			return catchFn(error, fn, ...args);
+			return catchFn(error, attempts, robustFn, ...args);
 		}
 	};
 }
@@ -9929,7 +9928,7 @@ function spawnAgent(options) {
 		logger.info(`[${cli}-yes] Spawned ${bin} with PID ${spawned.pid}`);
 		return spawned;
 	};
-	return catcher((error, _fn, ..._args) => {
+	return tryCatch((error, attempts, spawn, ...args) => {
 		logger.error(`Fatal: Failed to start ${cli}.`);
 		const isNotFound = isCommandNotFoundError(error);
 		if (cliConf?.install && isNotFound) {
@@ -9940,10 +9939,10 @@ function spawnAgent(options) {
 			}
 			logger.info(`Please install the cli by run ${installCmd}`);
 			if (install) {
-				logger.info(`Attempting to install ${cli}...`);
-				execaCommandSync(installCmd, { stdio: "inherit" });
+				logger.debug(`Attempting to install ${cli}...`);
+				execSync$1(installCmd, { stdio: "inherit" });
 				logger.info(`${cli} installed successfully. Please rerun the command.`);
-				return spawn();
+				return spawn(...args);
 			} else {
 				logger.error(`If you did not installed it yet, Please install it first: ${installCmd}`);
 				throw error;
@@ -10118,7 +10117,7 @@ const globalAgentRegistry = new AgentRegistry();
 
 //#endregion
 //#region ts/index.ts
-const config = await import("./agent-yes.config-BJbInLnS.js").then((mod) => mod.default || mod);
+const config = await import("./agent-yes.config-mJP0MKqV.js").then((mod) => mod.default || mod);
 const CLIS_CONFIG = config.clis;
 /**
 * Main function to run agent-cli with automatic yes/no responses
@@ -10735,4 +10734,4 @@ const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { AgentContext as a, config as i, CLIS_CONFIG as n, PidStore as o, agentYes as r, removeControlCharacters as s, SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-CGHhOLoD.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-CuEqXP9l.js.map

package/dist/{agent-yes.config-B0st3al_.js → agent-yes.config-Dr2p5kBW.js}

@@ -239,9 +239,12 @@ function getDefaultConfig() {
 					/^.{0,4} ?1\. ?Yes/m,
 					/Press Enter to continue…/m
 				],
-				fatal: [/⎿  Claude usage limit reached\./, /^error: unknown option/],
+				fatal: [
+					/⎿  Claude usage limit reached\./,
+					/^error: unknown option/,
+					/No conversation found to continue/
+				],
 				restoreArgs: ["--continue"],
-				restartWithoutContinueArg: [/No conversation found to continue/],
 				exitCommand: ["/exit"],
 				bunx: true,
 				defaultArgs: []
@@ -256,7 +259,6 @@ function getDefaultConfig() {
 				],
 				fatal: [/Error resuming session/, /No previous sessions found for this project./],
 				restoreArgs: ["--resume"],
-				restartWithoutContinueArg: [/No previous sessions found for this project\./, /Error resuming session/],
 				exitCommand: ["/chat save ${PWD}", "/quit"]
 			},
 			codex: {
@@ -330,4 +332,4 @@ function getDefaultConfig() {
 
 //#endregion
 export { agent_yes_config_default as t };
-//# sourceMappingURL=agent-yes.config-B0st3al_.js.map
+//# sourceMappingURL=agent-yes.config-Dr2p5kBW.js.map

package/dist/{agent-yes.config-BJbInLnS.js → agent-yes.config-mJP0MKqV.js}

@@ -1,4 +1,4 @@
 import "./logger-DH1Rx9HI.js";
-import { t as agent_yes_config_default } from "./agent-yes.config-B0st3al_.js";
+import { t as agent_yes_config_default } from "./agent-yes.config-Dr2p5kBW.js";
 
 export { agent_yes_config_default as default };

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { c as __toESM, i as __commonJSMin, r as require_ms, t as logger } from "./logger-DH1Rx9HI.js";
-import "./agent-yes.config-B0st3al_.js";
-import { o as PidStore, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-CGHhOLoD.js";
+import "./agent-yes.config-Dr2p5kBW.js";
+import { o as PidStore, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-CuEqXP9l.js";
 import { createRequire } from "node:module";
 import { argv } from "process";
 import { spawn } from "child_process";
@@ -4505,7 +4505,7 @@ const Yargs = YargsFactory(esm_default);
 //#endregion
 //#region package.json
 var name = "agent-yes";
-var version = "1.52.4";
+var version = "1.53.0";
 
 //#endregion
 //#region ts/parseCliArgs.ts

package/dist/index.js

@@ -1,4 +1,4 @@
 import "./logger-DH1Rx9HI.js";
-import { a as AgentContext, i as config, n as CLIS_CONFIG, r as agentYes, s as removeControlCharacters } from "./SUPPORTED_CLIS-CGHhOLoD.js";
+import { a as AgentContext, i as config, n as CLIS_CONFIG, r as agentYes, s as removeControlCharacters } from "./SUPPORTED_CLIS-CuEqXP9l.js";
 
 export { AgentContext, CLIS_CONFIG, config, agentYes as default, removeControlCharacters };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.52.4",
+  "version": "1.53.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",

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

@@ -1,70 +1,17 @@
 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";
-      };
+import { tryCatch } from "./tryCatch";
 
-      const wrappedFn = catcher(catchFn)(normalFn);
-      const result = wrappedFn("arg1", "arg2");
-
-      expect(result).toBe("success");
-      expect(catchCalled).toBe(false);
-      expect(calledArgs).toEqual(["arg1", "arg2"]);
-    });
-  });
+describe("tryCatch", () => {
 
   describe("direct overload", () => {
-    it("should catch errors and call catchFn with error, function, and args directly", () => {
+    it("should catch errors and call catchFn with error, attempts, robustFn, and args", () => {
       let catchedError: unknown;
+      let catchedAttempts: unknown;
       let catchedFn: unknown;
       let catchedArgs: unknown[];
-      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
+      const catchFn = (error: unknown, attempts: number, fn: unknown, ...args: unknown[]) => {
         catchedError = error;
+        catchedAttempts = attempts;
         catchedFn = fn;
         catchedArgs = args;
         return "caught";
@@ -76,12 +23,13 @@ describe("catcher", () => {
         throw new Error("test error");
       };
 
-      const wrappedFn = catcher(catchFn, errorFn);
+      const wrappedFn = tryCatch(catchFn, errorFn);
       const result = wrappedFn("arg1", "arg2");
 
       expect(result).toBe("caught");
       expect(catchedError).toBeInstanceOf(Error);
-      expect(catchedFn).toBe(errorFn);
+      expect(catchedAttempts).toBe(1);
+      expect(catchedFn).toBe(wrappedFn);
       expect(catchedArgs).toEqual(["arg1", "arg2"]);
       expect(calledArgs).toEqual(["arg1", "arg2"]);
     });
@@ -99,7 +47,7 @@ describe("catcher", () => {
         return "success";
       };
 
-      const wrappedFn = catcher(catchFn, normalFn);
+      const wrappedFn = tryCatch(catchFn, normalFn);
       const result = wrappedFn("arg1", "arg2");
 
       expect(result).toBe("success");
@@ -112,7 +60,7 @@ describe("catcher", () => {
     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, _attempts: number, fn: unknown, ..._args: unknown[]) => {
         results.push(error);
         functions.push(fn);
         return "handled";
@@ -122,37 +70,39 @@ describe("catcher", () => {
       const stringErrorFn = () => {
         throw "string error";
       };
-      const wrappedStringFn = catcher(catchFn, stringErrorFn);
+      const wrappedStringFn = tryCatch(catchFn, stringErrorFn);
       expect(wrappedStringFn()).toBe("handled");
       expect(results[0]).toBe("string error");
-      expect(functions[0]).toBe(stringErrorFn);
+      expect(functions[0]).toBe(wrappedStringFn);
 
       // Object error
       const objectError = { message: "object error" };
       const objectErrorFn = () => {
         throw objectError;
       };
-      const wrappedObjectFn = catcher(catchFn, objectErrorFn);
+      const wrappedObjectFn = tryCatch(catchFn, objectErrorFn);
       expect(wrappedObjectFn()).toBe("handled");
       expect(results[1]).toBe(objectError);
-      expect(functions[1]).toBe(objectErrorFn);
+      expect(functions[1]).toBe(wrappedObjectFn);
 
       // null error
       const nullErrorFn = () => {
         throw null;
       };
-      const wrappedNullFn = catcher(catchFn, nullErrorFn);
+      const wrappedNullFn = tryCatch(catchFn, nullErrorFn);
       expect(wrappedNullFn()).toBe("handled");
       expect(results[2]).toBe(null);
-      expect(functions[2]).toBe(nullErrorFn);
+      expect(functions[2]).toBe(wrappedNullFn);
     });
 
     it("should preserve function parameters and pass them to catchFn", () => {
       let caughtError: unknown;
+      let caughtAttempts: unknown;
       let caughtFn: unknown;
       let caughtArgs: unknown[];
-      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
+      const catchFn = (error: unknown, attempts: number, fn: unknown, ...args: unknown[]) => {
         caughtError = error;
+        caughtAttempts = attempts;
         caughtFn = fn;
         caughtArgs = args;
         return "caught";
@@ -165,7 +115,7 @@ describe("catcher", () => {
         return `${a}-${b}-${c}`;
       };
 
-      const wrappedFn = catcher(catchFn, testFn);
+      const wrappedFn = tryCatch(catchFn, testFn);
 
       // Normal execution
       expect(wrappedFn(3, "test", true)).toBe("3-test-true");
@@ -175,16 +125,19 @@ describe("catcher", () => {
       expect(wrappedFn(10, "error", false)).toBe("caught");
       expect(testArgs).toEqual([10, "error", false]);
       expect(caughtError).toBeInstanceOf(Error);
-      expect(caughtFn).toBe(testFn);
+      expect(caughtAttempts).toBe(2);
+      expect(caughtFn).toBe(wrappedFn);
       expect(caughtArgs).toEqual([10, "error", false]);
     });
 
     it("should handle functions with no parameters", () => {
       let caughtError: unknown;
+      let caughtAttempts: unknown;
       let caughtFn: unknown;
       let caughtArgs: unknown[];
-      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
+      const catchFn = (error: unknown, attempts: number, fn: unknown, ...args: unknown[]) => {
         caughtError = error;
+        caughtAttempts = attempts;
         caughtFn = fn;
         caughtArgs = args;
         return "no params caught";
@@ -196,13 +149,14 @@ describe("catcher", () => {
         throw new Error("no params error");
       };
 
-      const wrappedFn = catcher(catchFn, noParamsFn);
+      const wrappedFn = tryCatch(catchFn, noParamsFn);
       const result = wrappedFn();
 
       expect(result).toBe("no params caught");
       expect(called).toBe(true);
       expect(caughtError).toBeInstanceOf(Error);
-      expect(caughtFn).toBe(noParamsFn);
+      expect(caughtAttempts).toBe(1);
+      expect(caughtFn).toBe(wrappedFn);
       expect(caughtArgs).toEqual([]);
     });
 
@@ -210,26 +164,88 @@ describe("catcher", () => {
       const catchFn = () => null;
 
       // Function returning number
-      const numberFn = catcher(catchFn, () => 42);
+      const numberFn = tryCatch(catchFn, () => 42);
       expect(numberFn()).toBe(42);
 
       // Function returning object
       const obj = { key: "value" };
-      const objectFn = catcher(catchFn, () => obj);
+      const objectFn = tryCatch(catchFn, () => obj);
       expect(objectFn()).toBe(obj);
 
       // Function returning undefined
-      const undefinedFn = catcher(catchFn, () => undefined);
+      const undefinedFn = tryCatch(catchFn, () => undefined);
       expect(undefinedFn()).toBeUndefined();
     });
   });
 
+  describe("attempts tracking", () => {
+    it("should increment attempts on each call", () => {
+      const attemptsList: number[] = [];
+      const catchFn = (_error: unknown, attempts: number) => {
+        attemptsList.push(attempts);
+        return "caught";
+      };
+
+      const errorFn = () => {
+        throw new Error("fail");
+      };
+
+      const wrappedFn = tryCatch(catchFn, errorFn);
+      wrappedFn();
+      wrappedFn();
+      wrappedFn();
+
+      expect(attemptsList).toEqual([1, 2, 3]);
+    });
+
+    it("should count attempts for both successful and failed calls", () => {
+      let lastAttempts = 0;
+      const catchFn = (_error: unknown, attempts: number) => {
+        lastAttempts = attempts;
+        return -1;
+      };
+
+      let callCount = 0;
+      const sometimesFails = () => {
+        callCount++;
+        if (callCount % 2 === 0) throw new Error("even call");
+        return callCount;
+      };
+
+      const wrappedFn = tryCatch(catchFn, sometimesFails);
+      expect(wrappedFn()).toBe(1);   // attempt 1, success
+      expect(wrappedFn()).toBe(-1);  // attempt 2, fail
+      expect(lastAttempts).toBe(2);
+      expect(wrappedFn()).toBe(3);   // attempt 3, success
+      expect(wrappedFn()).toBe(-1);  // attempt 4, fail
+      expect(lastAttempts).toBe(4);
+    });
+
+    it("should allow retry via robustFn", () => {
+      let callCount = 0;
+      const catchFn = (_error: unknown, attempts: number, retry: () => number) => {
+        if (attempts < 3) return retry();
+        return -1;
+      };
+
+      const unreliableFn = () => {
+        callCount++;
+        if (callCount < 3) throw new Error("not yet");
+        return 42;
+      };
+
+      const wrappedFn = tryCatch(catchFn, unreliableFn);
+      expect(wrappedFn()).toBe(42);
+      expect(callCount).toBe(3);
+    });
+  });
+
   describe("type safety", () => {
     it("should maintain function signature", () => {
-      const catchFn = (_error: unknown, _fn: unknown, ..._args: unknown[]) => "error";
+      const catchFn = (_error: unknown, _attempts: number, _fn: unknown, ..._args: unknown[]) => "error";
       const originalFn = (a: number, b: string): string => `${a}-${b}`;
 
-      const wrappedFn = catcher(catchFn, originalFn);
+      const wrappedFn = tryCatch(catchFn, originalFn);
 
       // This should be type-safe
       const result: string = wrappedFn(1, "test");
@@ -239,7 +255,7 @@ describe("catcher", () => {
     it("should pass function reference and arguments to catchFn", () => {
       let capturedFn: unknown;
       let capturedArgs: unknown[];
-      const catchFn = (error: unknown, fn: unknown, ...args: unknown[]) => {
+      const catchFn = (_error: unknown, _attempts: number, fn: unknown, ...args: unknown[]) => {
         capturedFn = fn;
         capturedArgs = args;
         return "handled";
@@ -249,10 +265,10 @@ describe("catcher", () => {
         throw new Error("test");
       };
 
-      const wrappedFn = catcher(catchFn, testFn);
+      const wrappedFn = tryCatch(catchFn, testFn);
       wrappedFn(42, "hello");
 
-      expect(capturedFn).toBe(testFn);
+      expect(capturedFn).toBe(wrappedFn);
       expect(capturedArgs).toEqual([42, "hello"]);
     });
   });

package/ts/tryCatch.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ *
+ * @param catchFn - The function to call when an error occurs.
+ * @param fn - The function to wrap.
+ * @returns A new function that wraps the original function with error handling.
+ */
+export function tryCatch<F extends (...args: any[]) => any, R>(
+  catchFn: (error: unknown, attempts: number, robustFn: F, ...args: Parameters<F>) => R,
+  fn: F,
+) {
+  let attempts = 0;
+  return function robustFn(...args: Parameters<F>) {
+    try {
+      attempts++;
+      return fn(...args);
+    } catch (error) {
+      return catchFn(error, attempts, robustFn as F, ...args);
+    }
+  };
+}

package/ts/catcher.ts

@@ -1,35 +0,0 @@
-// 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);
-    }
-  };
-}