agent-yes 1.60.7 → 1.61.0

package/dist/{SUPPORTED_CLIS-gNHv7RnK.js → SUPPORTED_CLIS-C0l1NfFH.js}

@@ -904,7 +904,7 @@ function tryCatch(catchFn, fn) {
 //#endregion
 //#region package.json
 var name = "agent-yes";
-var version = "1.60.7";
+var version = "1.61.0";
 
 //#endregion
 //#region ts/pty-fix.ts
@@ -1951,4 +1951,4 @@ const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { AgentContext as a, PidStore as c, config as i, removeControlCharacters as l, CLIS_CONFIG as n, name as o, agentYes as r, version as s, SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-gNHv7RnK.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-C0l1NfFH.js.map

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-gNHv7RnK.js";
+import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-C0l1NfFH.js";
 import { t as logger } from "./logger-CX77vJDA.js";
 import { argv } from "process";
 import { spawn } from "child_process";

package/dist/index.js

@@ -1,4 +1,4 @@
-import { a as AgentContext, i as config, l as removeControlCharacters, n as CLIS_CONFIG, r as agentYes } from "./SUPPORTED_CLIS-gNHv7RnK.js";
+import { a as AgentContext, i as config, l as removeControlCharacters, n as CLIS_CONFIG, r as agentYes } from "./SUPPORTED_CLIS-C0l1NfFH.js";
 import "./logger-CX77vJDA.js";
 
 export { AgentContext, CLIS_CONFIG, config, agentYes as default, removeControlCharacters };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.60.7",
+  "version": "1.61.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",
@@ -80,7 +80,8 @@
     "prepare": "husky",
     "release": "standard-version && npm publish",
     "release:beta": "standard-version && npm publish --tag beta",
-    "test": "bun test --coverage ts/"
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
     "@snomiao/bun-pty": "^0.3.4",
@@ -106,6 +107,7 @@
     "@types/proper-lockfile": "^4.1.4",
     "@types/yargs": "^17.0.35",
     "@typescript/native-preview": "^7.0.0-dev.20260124.1",
+    "@vitest/coverage-v8": "^4.1.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.7",
     "node-pty": "^1.1.0",
@@ -116,7 +118,7 @@
     "semantic-release": "^25.0.2",
     "standard-version": "^9.5.0",
     "tsdown": "^0.20.3",
-    "vitest": "^4.0.17",
+    "vitest": "4.1.0",
     "zod": "^3.23.0"
   },
   "peerDependencies": {

package/ts/JsonlStore.spec.ts

@@ -0,0 +1,195 @@
+import { describe, expect, it, beforeEach, afterEach } from "vitest";
+import { JsonlStore } from "./JsonlStore";
+import { rm, readFile, writeFile, mkdir } from "fs/promises";
+import path from "path";
+
+const TEST_DIR = "/tmp/jsonlstore-test-" + process.pid;
+const TEST_FILE = path.join(TEST_DIR, "test.jsonl");
+
+describe("JsonlStore", () => {
+  let store: JsonlStore;
+
+  beforeEach(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+    await mkdir(TEST_DIR, { recursive: true });
+    store = new JsonlStore(TEST_FILE);
+  });
+
+  afterEach(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+  });
+
+  describe("load", () => {
+    it("should return empty map for new file", async () => {
+      const docs = await store.load();
+      expect(docs.size).toBe(0);
+    });
+
+    it("should load existing JSONL data", async () => {
+      await writeFile(TEST_FILE, '{"_id":"1","name":"Alice"}\n{"_id":"2","name":"Bob"}\n');
+      const docs = await store.load();
+      expect(docs.size).toBe(2);
+      expect(docs.get("1")).toEqual({ _id: "1", name: "Alice" });
+    });
+
+    it("should merge duplicate IDs (last wins)", async () => {
+      await writeFile(
+        TEST_FILE,
+        '{"_id":"1","name":"Alice","age":30}\n{"_id":"1","name":"Alice Updated"}\n',
+      );
+      const docs = await store.load();
+      expect(docs.size).toBe(1);
+      expect(docs.get("1")).toEqual({ _id: "1", name: "Alice Updated", age: 30 });
+    });
+
+    it("should handle $$deleted tombstones", async () => {
+      await writeFile(TEST_FILE, '{"_id":"1","name":"Alice"}\n{"_id":"1","$$deleted":true}\n');
+      const docs = await store.load();
+      expect(docs.size).toBe(0);
+    });
+
+    it("should skip lines without _id", async () => {
+      await writeFile(TEST_FILE, '{"name":"no id"}\n{"_id":"1","name":"valid"}\n');
+      const docs = await store.load();
+      expect(docs.size).toBe(1);
+    });
+
+    it("should skip corrupt lines gracefully", async () => {
+      await writeFile(
+        TEST_FILE,
+        '{"_id":"1","name":"ok"}\n{corrupt json\n{"_id":"2","name":"also ok"}\n',
+      );
+      const docs = await store.load();
+      expect(docs.size).toBe(2);
+    });
+
+    it("should recover from temp file when main file missing", async () => {
+      const tempFile = TEST_FILE + "~";
+      await writeFile(tempFile, '{"_id":"1","name":"recovered"}\n');
+      const docs = await store.load();
+      expect(docs.size).toBe(1);
+      expect(docs.get("1")!.name).toBe("recovered");
+    });
+  });
+
+  describe("getAll / getById / find / findOne", () => {
+    beforeEach(async () => {
+      await writeFile(
+        TEST_FILE,
+        '{"_id":"1","name":"Alice","age":30}\n{"_id":"2","name":"Bob","age":25}\n{"_id":"3","name":"Charlie","age":35}\n',
+      );
+      await store.load();
+    });
+
+    it("getAll returns all documents", () => {
+      expect(store.getAll()).toHaveLength(3);
+    });
+
+    it("getById returns correct doc", () => {
+      expect(store.getById("2")).toEqual({ _id: "2", name: "Bob", age: 25 });
+    });
+
+    it("getById returns undefined for missing id", () => {
+      expect(store.getById("999")).toBeUndefined();
+    });
+
+    it("find returns matching docs", () => {
+      const result = store.find((d) => d.age > 28);
+      expect(result).toHaveLength(2);
+    });
+
+    it("findOne returns first match", () => {
+      const result = store.findOne((d) => d.age > 28);
+      expect(result).toBeDefined();
+      expect(result!.age).toBeGreaterThan(28);
+    });
+
+    it("findOne returns undefined when no match", () => {
+      expect(store.findOne((d) => d.age > 100)).toBeUndefined();
+    });
+  });
+
+  describe("append", () => {
+    it("should append and return doc with generated id", async () => {
+      await store.load();
+      const doc = await store.append({ name: "test" } as any);
+      expect(doc._id).toBeDefined();
+      expect(doc.name).toBe("test");
+      expect(store.getAll()).toHaveLength(1);
+    });
+
+    it("should append with provided _id", async () => {
+      await store.load();
+      const doc = await store.append({ _id: "custom-id", name: "test" } as any);
+      expect(doc._id).toBe("custom-id");
+    });
+
+    it("should merge with existing doc of same _id", async () => {
+      await store.load();
+      await store.append({ _id: "x", name: "first", value: 1 } as any);
+      await store.append({ _id: "x", name: "second" } as any);
+      const doc = store.getById("x")!;
+      expect(doc.name).toBe("second");
+      expect(doc.value).toBe(1);
+    });
+  });
+
+  describe("updateById", () => {
+    it("should update existing doc", async () => {
+      await store.load();
+      await store.append({ _id: "u1", name: "original", status: "active" } as any);
+      await store.updateById("u1", { status: "done" });
+      expect(store.getById("u1")!.status).toBe("done");
+      expect(store.getById("u1")!.name).toBe("original");
+    });
+
+    it("should no-op for non-existent id", async () => {
+      await store.load();
+      await store.updateById("nonexistent", { status: "done" });
+      expect(store.getAll()).toHaveLength(0);
+    });
+  });
+
+  describe("deleteById", () => {
+    it("should remove doc from memory and write tombstone", async () => {
+      await store.load();
+      await store.append({ _id: "d1", name: "to delete" } as any);
+      expect(store.getAll()).toHaveLength(1);
+
+      await store.deleteById("d1");
+      expect(store.getAll()).toHaveLength(0);
+      expect(store.getById("d1")).toBeUndefined();
+
+      // Tombstone should be written to file
+      const content = await readFile(TEST_FILE, "utf-8");
+      expect(content).toContain('"$$deleted":true');
+    });
+  });
+
+  describe("compact", () => {
+    it("should deduplicate entries", async () => {
+      await store.load();
+      await store.append({ _id: "c1", name: "v1" } as any);
+      await store.updateById("c1", { name: "v2" });
+      await store.updateById("c1", { name: "v3" });
+
+      // Before compact: 3 lines
+      const before = (await readFile(TEST_FILE, "utf-8")).trim().split("\n");
+      expect(before).toHaveLength(3);
+
+      await store.compact();
+
+      // After compact: 1 line
+      const after = (await readFile(TEST_FILE, "utf-8")).trim().split("\n");
+      expect(after).toHaveLength(1);
+      expect(JSON.parse(after[0]!).name).toBe("v3");
+    });
+
+    it("should handle empty store", async () => {
+      await store.load();
+      await store.compact();
+      const content = await readFile(TEST_FILE, "utf-8");
+      expect(content).toBe("");
+    });
+  });
+});

package/ts/configLoader.spec.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { loadCascadingConfig, getConfigPaths, ensureSchemaInConfigFiles } from "./configLoader.ts";
 import { mkdir, writeFile, readFile, rm } from "node:fs/promises";
 import path from "node:path";
@@ -187,4 +187,68 @@ configDir: /test
     expect(result.skipped).toContain(configPath);
     expect(result.modified).not.toContain(configPath);
   });
+
+  it("should handle invalid JSON config gracefully", async () => {
+    const configPath = path.join(testDir, ".agent-yes.config.json");
+    await writeFile(configPath, "not valid json {{{");
+
+    const config = await loadCascadingConfig({ projectDir: testDir, homeDir: testDir });
+    // Should not throw, returns empty
+    expect(config).toEqual({});
+  });
+
+  it("should handle empty YAML config returning null", async () => {
+    const configPath = path.join(testDir, ".agent-yes.config.yaml");
+    await writeFile(configPath, "");
+
+    const config = await loadCascadingConfig({ projectDir: testDir, homeDir: testDir });
+    expect(config).toEqual({});
+  });
+
+  it("should add schema to YAML with leading comments", async () => {
+    const configPath = path.join(testDir, ".agent-yes.config.yaml");
+    await writeFile(
+      configPath,
+      `# My config comment
+# Another comment
+configDir: /test
+`,
+    );
+
+    const result = await ensureSchemaInConfigFiles({ projectDir: testDir, homeDir: testDir });
+    expect(result.modified).toContain(configPath);
+    const content = await readFile(configPath, "utf-8");
+    expect(content).toContain("yaml-language-server:");
+  });
+
+  it("should handle ensureSchema when no config files exist", async () => {
+    const emptyDir = path.join(testDir, "empty");
+    await mkdir(emptyDir, { recursive: true });
+
+    const result = await ensureSchemaInConfigFiles({ projectDir: emptyDir, homeDir: emptyDir });
+    expect(result.modified).toHaveLength(0);
+    expect(result.skipped).toHaveLength(0);
+  });
+
+  it("should handle addSchemaReference for JSON that already has schema", async () => {
+    const configPath = path.join(testDir, ".agent-yes.config.json");
+    const content = JSON.stringify({ $schema: "existing", configDir: "/test" }, null, 2);
+    await writeFile(configPath, content);
+
+    const result = await ensureSchemaInConfigFiles({ projectDir: testDir, homeDir: testDir });
+    expect(result.skipped).toContain(configPath);
+  });
+
+  it("should use defaults for getConfigPaths without options", () => {
+    const paths = getConfigPaths();
+    expect(paths.length).toBeGreaterThan(0);
+    expect(paths.some((p) => p.includes(".agent-yes.config.json"))).toBe(true);
+  });
+
+  it("should use defaults for loadCascadingConfig without options", async () => {
+    // This tests the default path (process.cwd() and os.homedir())
+    const config = await loadCascadingConfig();
+    // Should not throw, may or may not find configs
+    expect(config).toBeDefined();
+  });
 });

package/ts/defineConfig.spec.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { defineCliYesConfig } from "./defineConfig";
+
+describe("defineCliYesConfig", () => {
+  it("should return a plain config object", async () => {
+    const cfg = await defineCliYesConfig({ clis: {} });
+    expect(cfg).toEqual({ clis: {} });
+  });
+
+  it("should accept a function that receives the default config", async () => {
+    const cfg = await defineCliYesConfig((original) => {
+      expect(original).toEqual({ clis: {} });
+      return { ...original, clis: { claude: { bin: "claude" } } };
+    });
+    expect(cfg.clis).toHaveProperty("claude");
+  });
+
+  it("should accept an async function", async () => {
+    const cfg = await defineCliYesConfig(async () => {
+      return { clis: { test: { bin: "test-cli" } } };
+    });
+    expect(cfg.clis.test).toEqual({ bin: "test-cli" });
+  });
+
+  it("should accept a promise", async () => {
+    const cfg = await defineCliYesConfig(Promise.resolve({ clis: {} }));
+    expect(cfg).toEqual({ clis: {} });
+  });
+});

package/ts/idleWaiter.spec.ts

@@ -52,4 +52,20 @@ describe("IdleWaiter", () => {
     const result = waiter.ping().ping().ping();
     expect(result).toBe(waiter);
   });
+
+  it("should wait until idle period has passed", async () => {
+    const waiter = new IdleWaiter();
+    waiter.checkInterval = 10;
+
+    // Ping right now so it's not idle
+    waiter.ping();
+
+    const start = Date.now();
+    // Wait for 50ms idle period — the wait loop should actually iterate
+    await waiter.wait(50);
+    const elapsed = Date.now() - start;
+
+    // Should have waited at least ~50ms
+    expect(elapsed).toBeGreaterThanOrEqual(40);
+  });
 });

package/ts/pidStore.spec.ts

@@ -115,6 +115,20 @@ describe("PidStore", () => {
       expect(rec?.exitReason).toBe("crash");
       expect(rec?.exitCode).toBe(1);
     });
+
+    it("should no-op when updating non-existent pid", async () => {
+      await store.updateStatus(999888, "exited");
+      // Should not throw and records should be unchanged
+      expect(store.getAllRecords()).toHaveLength(0);
+    });
+
+    it("should update status without extra params", async () => {
+      await store.registerProcess({ pid: 333, cli: "test", args: [], cwd: "/tmp" });
+      await store.updateStatus(333, "idle");
+      const rec = store.getAllRecords().find((r) => r.pid === 333);
+      expect(rec?.status).toBe("idle");
+      expect(rec?.exitReason).toBe("");
+    });
   });
 
   describe("getAllRecords", () => {

package/ts/session-integration.spec.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "bun:test";
+import { describe, expect, it } from "vitest";
 import { extractSessionId, extractSessionIdFromSessionMeta } from "./resume/codexSessionManager";
 
 describe("Session Extraction Test", () => {

package/ts/versionChecker.spec.ts

@@ -0,0 +1,119 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import { compareVersions, fetchLatestVersion, displayVersion } from "./versionChecker";
+
+describe("versionChecker", () => {
+  describe("compareVersions", () => {
+    it("should return 0 for equal versions", () => {
+      expect(compareVersions("1.0.0", "1.0.0")).toBe(0);
+      expect(compareVersions("2.3.4", "2.3.4")).toBe(0);
+    });
+
+    it("should return 1 when v1 > v2", () => {
+      expect(compareVersions("2.0.0", "1.0.0")).toBe(1);
+      expect(compareVersions("1.1.0", "1.0.0")).toBe(1);
+      expect(compareVersions("1.0.1", "1.0.0")).toBe(1);
+    });
+
+    it("should return -1 when v1 < v2", () => {
+      expect(compareVersions("1.0.0", "2.0.0")).toBe(-1);
+      expect(compareVersions("1.0.0", "1.1.0")).toBe(-1);
+      expect(compareVersions("1.0.0", "1.0.1")).toBe(-1);
+    });
+
+    it("should handle versions with different segment counts", () => {
+      expect(compareVersions("1.0", "1.0.0")).toBe(0);
+      expect(compareVersions("1.0.0", "1.0")).toBe(0);
+      expect(compareVersions("1.0.1", "1.0")).toBe(1);
+      expect(compareVersions("1.0", "1.0.1")).toBe(-1);
+    });
+  });
+
+  describe("fetchLatestVersion", () => {
+    beforeEach(() => {
+      vi.stubGlobal("fetch", vi.fn());
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it("should return version from npm registry", async () => {
+      vi.mocked(fetch).mockResolvedValue({
+        ok: true,
+        json: async () => ({ version: "1.2.3" }),
+      } as Response);
+
+      const version = await fetchLatestVersion();
+      expect(version).toBe("1.2.3");
+    });
+
+    it("should return null on non-ok response", async () => {
+      vi.mocked(fetch).mockResolvedValue({
+        ok: false,
+      } as Response);
+
+      const version = await fetchLatestVersion();
+      expect(version).toBeNull();
+    });
+
+    it("should return null on network error", async () => {
+      vi.mocked(fetch).mockRejectedValue(new Error("network error"));
+
+      const version = await fetchLatestVersion();
+      expect(version).toBeNull();
+    });
+  });
+
+  describe("displayVersion", () => {
+    beforeEach(() => {
+      vi.stubGlobal("fetch", vi.fn());
+      vi.spyOn(console, "log").mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it("should log update available when behind", async () => {
+      vi.mocked(fetch).mockResolvedValue({
+        ok: true,
+        json: async () => ({ version: "999.0.0" }),
+      } as Response);
+
+      await displayVersion();
+
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining("update available"));
+    });
+
+    it("should log latest when versions match", async () => {
+      const pkg = await import("../package.json");
+      vi.mocked(fetch).mockResolvedValue({
+        ok: true,
+        json: async () => ({ version: pkg.default.version }),
+      } as Response);
+
+      await displayVersion();
+
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining("latest"));
+    });
+
+    it("should log latest published when ahead", async () => {
+      vi.mocked(fetch).mockResolvedValue({
+        ok: true,
+        json: async () => ({ version: "0.0.1" }),
+      } as Response);
+
+      await displayVersion();
+
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining("latest published"));
+    });
+
+    it("should handle fetch failure gracefully", async () => {
+      vi.mocked(fetch).mockRejectedValue(new Error("fail"));
+
+      await displayVersion();
+
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining("unable to check"));
+    });
+  });
+});