ashlrcode 1.0.0

package/src/__tests__/error-handler.test.ts

@@ -0,0 +1,192 @@
+import { test, expect, describe } from "bun:test";
+import { categorizeError, retryWithBackoff } from "../agent/error-handler.ts";
+
+describe("categorizeError", () => {
+  describe("rate_limit", () => {
+    test("detects 429 status code", () => {
+      const result = categorizeError(new Error("HTTP 429 Too Many Requests"));
+      expect(result.category).toBe("rate_limit");
+      expect(result.retryable).toBe(true);
+      expect(result.retryAfterMs).toBeGreaterThan(0);
+    });
+
+    test("detects rate_limit keyword", () => {
+      const result = categorizeError("rate_limit exceeded");
+      expect(result.category).toBe("rate_limit");
+      expect(result.retryable).toBe(true);
+    });
+
+    test("detects quota keyword", () => {
+      const result = categorizeError(new Error("quota exceeded for this key"));
+      expect(result.category).toBe("rate_limit");
+    });
+
+    test("detects 'too many requests'", () => {
+      const result = categorizeError("Too many requests, please slow down");
+      expect(result.category).toBe("rate_limit");
+    });
+
+    test("extracts retry-after from message", () => {
+      const result = categorizeError(new Error("429 rate_limit: retry after 30 seconds"));
+      expect(result.category).toBe("rate_limit");
+      expect(result.retryAfterMs).toBe(30000);
+    });
+
+    test("defaults to 5000ms when no retry-after found", () => {
+      const result = categorizeError(new Error("429"));
+      expect(result.retryAfterMs).toBe(5000);
+    });
+  });
+
+  describe("auth", () => {
+    test("detects 401 status", () => {
+      const result = categorizeError(new Error("HTTP 401 Unauthorized"));
+      expect(result.category).toBe("auth");
+      expect(result.retryable).toBe(false);
+    });
+
+    test("detects 403 status", () => {
+      const result = categorizeError(new Error("403 Forbidden"));
+      expect(result.category).toBe("auth");
+    });
+
+    test("detects 'unauthorized'", () => {
+      const result = categorizeError("Request unauthorized");
+      expect(result.category).toBe("auth");
+    });
+
+    test("detects 'invalid api key'", () => {
+      const result = categorizeError(new Error("Invalid API key provided"));
+      expect(result.category).toBe("auth");
+    });
+  });
+
+  describe("network", () => {
+    test("detects ECONNREFUSED", () => {
+      const result = categorizeError(new Error("connect ECONNREFUSED 127.0.0.1:443"));
+      expect(result.category).toBe("network");
+      expect(result.retryable).toBe(true);
+      expect(result.retryAfterMs).toBe(2000);
+    });
+
+    test("detects ENOTFOUND", () => {
+      const result = categorizeError(new Error("getaddrinfo ENOTFOUND api.example.com"));
+      expect(result.category).toBe("network");
+    });
+
+    test("detects timeout", () => {
+      const result = categorizeError("Request timeout after 30s");
+      expect(result.category).toBe("network");
+    });
+
+    test("detects fetch failed", () => {
+      const result = categorizeError(new Error("fetch failed"));
+      expect(result.category).toBe("network");
+    });
+
+    test("detects socket errors", () => {
+      const result = categorizeError(new Error("socket hang up"));
+      expect(result.category).toBe("network");
+    });
+  });
+
+  describe("validation", () => {
+    test("detects validation keyword", () => {
+      const result = categorizeError(new Error("Validation error: missing field"));
+      expect(result.category).toBe("validation");
+      expect(result.retryable).toBe(false);
+    });
+
+    test("detects invalid keyword", () => {
+      const result = categorizeError("Invalid parameter: model");
+      expect(result.category).toBe("validation");
+    });
+
+    test("detects schema keyword", () => {
+      const result = categorizeError(new Error("Schema mismatch on input"));
+      expect(result.category).toBe("validation");
+    });
+  });
+
+  describe("unknown", () => {
+    test("returns unknown for unrecognized errors", () => {
+      const result = categorizeError(new Error("Something unexpected happened"));
+      expect(result.category).toBe("unknown");
+      expect(result.retryable).toBe(false);
+    });
+
+    test("handles string errors", () => {
+      const result = categorizeError("just a string error");
+      expect(result.category).toBe("unknown");
+      expect(result.message).toBe("just a string error");
+    });
+  });
+
+  describe("priority: rate_limit before auth", () => {
+    // If a message contains both "429" and "unauthorized", rate_limit should win
+    // because it's checked first
+    test("rate_limit takes priority when both match", () => {
+      const result = categorizeError(new Error("429 unauthorized"));
+      expect(result.category).toBe("rate_limit");
+    });
+  });
+});
+
+describe("retryWithBackoff", () => {
+  test("returns result on first success", async () => {
+    const result = await retryWithBackoff(async () => "success", 3, 10);
+    expect(result).toBe("success");
+  });
+
+  test("retries on retryable error and succeeds", async () => {
+    let attempts = 0;
+    const result = await retryWithBackoff(
+      async () => {
+        attempts++;
+        if (attempts < 3) throw new Error("fetch failed");
+        return "recovered";
+      },
+      3,
+      10 // Short delay for test speed
+    );
+    expect(result).toBe("recovered");
+    expect(attempts).toBe(3);
+  });
+
+  test("throws on non-retryable error immediately", async () => {
+    let attempts = 0;
+    try {
+      await retryWithBackoff(
+        async () => {
+          attempts++;
+          throw new Error("401 Unauthorized");
+        },
+        3,
+        10
+      );
+      expect(true).toBe(false); // Should not reach here
+    } catch (err) {
+      expect((err as Error).message).toContain("401");
+    }
+    expect(attempts).toBe(1);
+  });
+
+  test("throws after max retries exhausted", async () => {
+    let attempts = 0;
+    try {
+      await retryWithBackoff(
+        async () => {
+          attempts++;
+          throw new Error("fetch failed"); // network = retryable
+        },
+        2,
+        10
+      );
+      expect(true).toBe(false);
+    } catch (err) {
+      expect((err as Error).message).toContain("fetch failed");
+    }
+    // 1 initial + 2 retries = 3 attempts
+    expect(attempts).toBe(3);
+  });
+});

package/src/__tests__/features.test.ts

@@ -0,0 +1,69 @@
+import { test, expect, describe, afterEach } from "bun:test";
+import { feature, setFeature, listFeatures } from "../config/features.ts";
+
+// Track features we modify so we can reset them
+const modified: Array<{ name: string; original: boolean }> = [];
+
+function setAndTrack(name: string, value: boolean) {
+  const features = listFeatures();
+  if (name in features) {
+    modified.push({ name, original: features[name]! });
+  } else {
+    modified.push({ name, original: false });
+  }
+  setFeature(name, value);
+}
+
+afterEach(() => {
+  for (const { name, original } of modified) {
+    setFeature(name, original);
+  }
+  modified.length = 0;
+});
+
+describe("feature", () => {
+  test("returns default values for known flags", () => {
+    const features = listFeatures();
+    // DREAM_TASK defaults to true
+    expect(feature("DREAM_TASK")).toBe(features["DREAM_TASK"]!);
+    // VOICE_MODE defaults to false
+    expect(feature("VOICE_MODE")).toBe(features["VOICE_MODE"]!);
+  });
+
+  test("returns false for unknown feature", () => {
+    expect(feature("TOTALLY_FAKE_FEATURE_" + Date.now())).toBe(false);
+  });
+});
+
+describe("setFeature", () => {
+  test("overrides a feature value", () => {
+    setAndTrack("VOICE_MODE", true);
+    expect(feature("VOICE_MODE")).toBe(true);
+
+    setAndTrack("VOICE_MODE", false);
+    expect(feature("VOICE_MODE")).toBe(false);
+  });
+
+  test("can set a new feature that did not exist", () => {
+    const name = "TEST_FEATURE_" + Date.now();
+    setAndTrack(name, true);
+    expect(feature(name)).toBe(true);
+  });
+});
+
+describe("listFeatures", () => {
+  test("returns all flags as a plain object", () => {
+    const features = listFeatures();
+    expect(typeof features).toBe("object");
+    expect("DREAM_TASK" in features).toBe(true);
+    expect("VOICE_MODE" in features).toBe(true);
+    expect("TEAM_MODE" in features).toBe(true);
+  });
+
+  test("returns a copy (mutations do not affect internal state)", () => {
+    const features = listFeatures();
+    features["DREAM_TASK"] = false;
+    // Internal state should be unchanged
+    expect(feature("DREAM_TASK")).toBe(listFeatures()["DREAM_TASK"]!);
+  });
+});

package/src/__tests__/file-history.test.ts

@@ -0,0 +1,177 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { FileHistoryStore, setFileHistory, getFileHistory, fileHistory } from "../state/file-history.ts";
+import { writeFileSync, readFileSync, rmSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+describe("FileHistoryStore", () => {
+  const testDir = join(tmpdir(), `ashlrcode-test-${Date.now()}`);
+  const testFile = join(testDir, "test.txt");
+  let store: FileHistoryStore;
+
+  beforeEach(() => {
+    store = new FileHistoryStore(`test-${Date.now()}`);
+    setFileHistory(store);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true });
+    }
+  });
+
+  test("capture records existing file content", async () => {
+    writeFileSync(testFile, "original content");
+    await store.capture(testFile, "Write", 1);
+    expect(store.hasSnapshot(testFile)).toBe(true);
+    expect(store.undoCount).toBe(1);
+  });
+
+  test("capture records new file as empty content (undo = delete)", async () => {
+    const newFile = join(testDir, "brand-new.txt");
+    await store.capture(newFile, "Write", 1);
+    expect(store.hasSnapshot(newFile)).toBe(true);
+    expect(store.undoCount).toBe(1);
+  });
+
+  test("undoLast restores previous content", async () => {
+    writeFileSync(testFile, "version 1");
+    await store.capture(testFile, "Edit", 1);
+
+    writeFileSync(testFile, "version 2");
+    expect(readFileSync(testFile, "utf-8")).toBe("version 2");
+
+    const result = await store.undoLast();
+    expect(result).not.toBeNull();
+    expect(result!.filePath).toBe(testFile);
+    expect(result!.restored).toBe(true);
+    expect(readFileSync(testFile, "utf-8")).toBe("version 1");
+  });
+
+  test("undoLast deletes newly created file", async () => {
+    const newFile = join(testDir, "created.txt");
+    await store.capture(newFile, "Write", 1);
+
+    writeFileSync(newFile, "new content");
+    expect(existsSync(newFile)).toBe(true);
+
+    const result = await store.undoLast();
+    expect(result).not.toBeNull();
+    expect(existsSync(newFile)).toBe(false);
+  });
+
+  test("undoLast returns null when no snapshots", async () => {
+    const result = await store.undoLast();
+    expect(result).toBeNull();
+  });
+
+  test("multiple snapshots form a stack (LIFO)", async () => {
+    writeFileSync(testFile, "v1");
+    await store.capture(testFile, "Edit", 1);
+
+    writeFileSync(testFile, "v2");
+    await store.capture(testFile, "Edit", 2);
+
+    writeFileSync(testFile, "v3");
+
+    // First undo → v2
+    await store.undoLast();
+    expect(readFileSync(testFile, "utf-8")).toBe("v2");
+
+    // Second undo → v1
+    await store.undoLast();
+    expect(readFileSync(testFile, "utf-8")).toBe("v1");
+
+    expect(store.undoCount).toBe(0);
+  });
+
+  test("undoTurn restores all changes from a specific turn", async () => {
+    const file2 = join(testDir, "other.txt");
+    writeFileSync(testFile, "a-original");
+    writeFileSync(file2, "b-original");
+
+    await store.capture(testFile, "Edit", 3);
+    await store.capture(file2, "Edit", 3);
+
+    writeFileSync(testFile, "a-modified");
+    writeFileSync(file2, "b-modified");
+
+    const restored = await store.undoTurn(3);
+    expect(restored).toContain(testFile);
+    expect(restored).toContain(file2);
+    expect(readFileSync(testFile, "utf-8")).toBe("a-original");
+    expect(readFileSync(file2, "utf-8")).toBe("b-original");
+    expect(store.undoCount).toBe(0);
+  });
+
+  test("undoTurn only affects the specified turn", async () => {
+    writeFileSync(testFile, "turn1-before");
+    await store.capture(testFile, "Edit", 1);
+    writeFileSync(testFile, "turn1-after");
+
+    await store.capture(testFile, "Edit", 2);
+    writeFileSync(testFile, "turn2-after");
+
+    // Undo only turn 2
+    await store.undoTurn(2);
+    expect(readFileSync(testFile, "utf-8")).toBe("turn1-after");
+    expect(store.undoCount).toBe(1); // turn 1 snapshot still there
+  });
+
+  test("getSnapshotFiles returns files with snapshots", async () => {
+    const file2 = join(testDir, "other.txt");
+    writeFileSync(testFile, "content1");
+    writeFileSync(file2, "content2");
+
+    await store.capture(testFile, "Write", 1);
+    await store.capture(file2, "Edit", 1);
+
+    const files = store.getSnapshotFiles();
+    expect(files.length).toBe(2);
+
+    const paths = files.map((f) => f.path);
+    expect(paths).toContain(testFile);
+    expect(paths).toContain(file2);
+
+    for (const f of files) {
+      expect(f.count).toBe(1);
+      expect(f.lastModified).toBeTruthy();
+    }
+  });
+
+  test("getHistory returns snapshots newest first", async () => {
+    writeFileSync(testFile, "v1");
+    await store.capture(testFile, "Edit", 1);
+    writeFileSync(testFile, "v2");
+    await store.capture(testFile, "Edit", 2);
+
+    const history = store.getHistory();
+    expect(history.length).toBe(2);
+    expect(history[0]!.turnNumber).toBe(2); // newest first
+    expect(history[1]!.turnNumber).toBe(1);
+  });
+
+  test("clear removes all snapshots", async () => {
+    writeFileSync(testFile, "content");
+    await store.capture(testFile, "Write", 1);
+    expect(store.hasSnapshot(testFile)).toBe(true);
+
+    store.clear();
+    expect(store.hasSnapshot(testFile)).toBe(false);
+    expect(store.getSnapshotFiles()).toEqual([]);
+    expect(store.undoCount).toBe(0);
+  });
+
+  // Backward-compat shim tests
+  test("fileHistory shim delegates to the active store", async () => {
+    writeFileSync(testFile, "original");
+    await fileHistory.snapshot(testFile);
+    expect(fileHistory.hasSnapshot(testFile)).toBe(true);
+
+    writeFileSync(testFile, "changed");
+    const restored = await fileHistory.restore(testFile);
+    expect(restored).toBe(true);
+    expect(readFileSync(testFile, "utf-8")).toBe("original");
+  });
+});

package/src/__tests__/hooks.test.ts

@@ -0,0 +1,145 @@
+import { test, expect, describe } from "bun:test";
+import { runPreToolHooks, runPostToolHooks } from "../config/hooks.ts";
+import type { HooksConfig, HookDefinition } from "../config/hooks.ts";
+
+describe("runPreToolHooks", () => {
+  test("returns allow when no hooks are configured", async () => {
+    const result = await runPreToolHooks({}, "Bash", { command: "ls" });
+    expect(result.action).toBe("allow");
+  });
+
+  test("returns allow when no hooks match", async () => {
+    const hooks: HooksConfig = {
+      preToolUse: [{ toolName: "Write", action: "deny" }],
+    };
+    const result = await runPreToolHooks(hooks, "Bash", {});
+    expect(result.action).toBe("allow");
+  });
+
+  test("denies when exact toolName matches deny hook", async () => {
+    const hooks: HooksConfig = {
+      preToolUse: [{ toolName: "Bash", action: "deny", message: "no bash" }],
+    };
+    const result = await runPreToolHooks(hooks, "Bash", {});
+    expect(result.action).toBe("deny");
+    expect(result.message).toBe("no bash");
+  });
+
+  test("allows when exact toolName matches allow hook", async () => {
+    const hooks: HooksConfig = {
+      preToolUse: [{ toolName: "Read", action: "allow" }],
+    };
+    const result = await runPreToolHooks(hooks, "Read", {});
+    expect(result.action).toBe("allow");
+  });
+
+  test("matches glob patterns in toolName", async () => {
+    const hooks: HooksConfig = {
+      preToolUse: [{ toolName: "Bash*", action: "deny", message: "no bash" }],
+    };
+    const result = await runPreToolHooks(hooks, "BashTool", {});
+    expect(result.action).toBe("deny");
+  });
+
+  test("matches wildcard * to any tool", async () => {
+    const hooks: HooksConfig = {
+      preToolUse: [{ toolName: "*", action: "deny", message: "all blocked" }],
+    };
+    const result = await runPreToolHooks(hooks, "AnyTool", {});
+    expect(result.action).toBe("deny");
+    expect(result.message).toBe("all blocked");
+  });
+
+  test("matches inputPattern against serialized input", async () => {
+    const hooks: HooksConfig = {
+      preToolUse: [
+        {
+          inputPattern: "rm\\s+-rf",
+          action: "deny",
+          message: "dangerous command",
+        },
+      ],
+    };
+    const result = await runPreToolHooks(hooks, "Bash", {
+      command: "rm -rf /",
+    });
+    expect(result.action).toBe("deny");
+  });
+
+  test("does not match inputPattern when pattern is absent from input", async () => {
+    const hooks: HooksConfig = {
+      preToolUse: [{ inputPattern: "rm\\s+-rf", action: "deny" }],
+    };
+    const result = await runPreToolHooks(hooks, "Bash", { command: "ls -la" });
+    expect(result.action).toBe("allow");
+  });
+
+  test("matches when both toolName and inputPattern match", async () => {
+    const hooks: HooksConfig = {
+      preToolUse: [
+        {
+          toolName: "Bash",
+          inputPattern: "sudo",
+          action: "deny",
+          message: "no sudo",
+        },
+      ],
+    };
+    // Both match
+    const result = await runPreToolHooks(hooks, "Bash", {
+      command: "sudo rm foo",
+    });
+    expect(result.action).toBe("deny");
+
+    // toolName matches but inputPattern doesn't
+    const result2 = await runPreToolHooks(hooks, "Bash", { command: "ls" });
+    expect(result2.action).toBe("allow");
+  });
+
+  test("hook with no toolName or inputPattern matches everything", async () => {
+    const hooks: HooksConfig = {
+      preToolUse: [{ action: "deny", message: "global deny" }],
+    };
+    const result = await runPreToolHooks(hooks, "AnyTool", {});
+    expect(result.action).toBe("deny");
+  });
+
+  test("runs command-based hook and denies on non-zero exit", async () => {
+    const hooks: HooksConfig = {
+      preToolUse: [{ toolName: "Bash", command: "exit 1" }],
+    };
+    const result = await runPreToolHooks(hooks, "Bash", {});
+    expect(result.action).toBe("deny");
+  });
+
+  test("runs command-based hook and allows on zero exit", async () => {
+    const hooks: HooksConfig = {
+      preToolUse: [{ toolName: "Bash", command: "exit 0" }],
+    };
+    const result = await runPreToolHooks(hooks, "Bash", {});
+    expect(result.action).toBe("allow");
+  });
+});
+
+describe("runPostToolHooks", () => {
+  test("runs without error with no hooks", async () => {
+    // Should not throw
+    await runPostToolHooks({}, "Bash", {}, "output");
+  });
+
+  test("runs without error with matching hook", async () => {
+    const hooks: HooksConfig = {
+      postToolUse: [{ toolName: "Bash", command: "true" }],
+    };
+    // Fire and forget, should not throw
+    await runPostToolHooks(hooks, "Bash", {}, "output");
+  });
+
+  test("does not run hooks that don't match", async () => {
+    const hooks: HooksConfig = {
+      postToolUse: [{ toolName: "Write", command: "exit 1" }],
+    };
+    // Should not throw because the hook shouldn't match "Bash"
+    await runPostToolHooks(hooks, "Bash", {}, "output");
+  });
+});