ashlrcode 1.0.0

package/src/__tests__/retry.test.ts

@@ -0,0 +1,321 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { withRetry, CircuitBreaker, RetryError } from "../providers/retry.ts";
+
+describe("withRetry", () => {
+  test("succeeds on first attempt", async () => {
+    const result = await withRetry(() => Promise.resolve("ok"), {
+      providerName: "test",
+    });
+    expect(result).toBe("ok");
+  });
+
+  test("retries on rate limit (429) and succeeds", async () => {
+    let attempt = 0;
+    const result = await withRetry(
+      () => {
+        attempt++;
+        if (attempt < 3) throw new Error("429 Too Many Requests");
+        return Promise.resolve("recovered");
+      },
+      { providerName: "test", baseDelayMs: 1, maxDelayMs: 10 },
+    );
+    expect(result).toBe("recovered");
+    expect(attempt).toBe(3);
+  });
+
+  test("retries on server error (500) and succeeds", async () => {
+    let attempt = 0;
+    const result = await withRetry(
+      () => {
+        attempt++;
+        if (attempt < 2) throw new Error("500 Internal Server Error");
+        return Promise.resolve("recovered");
+      },
+      { providerName: "test", baseDelayMs: 1, maxDelayMs: 10 },
+    );
+    expect(result).toBe("recovered");
+    expect(attempt).toBe(2);
+  });
+
+  test("retries on 502 Bad Gateway", async () => {
+    let attempt = 0;
+    const result = await withRetry(
+      () => {
+        attempt++;
+        if (attempt < 2) throw new Error("502 Bad Gateway");
+        return Promise.resolve("ok");
+      },
+      { providerName: "test", baseDelayMs: 1, maxDelayMs: 10 },
+    );
+    expect(result).toBe("ok");
+  });
+
+  test("retries on 503 Service Unavailable", async () => {
+    let attempt = 0;
+    const result = await withRetry(
+      () => {
+        attempt++;
+        if (attempt < 2) throw new Error("503 Service Unavailable");
+        return Promise.resolve("ok");
+      },
+      { providerName: "test", baseDelayMs: 1, maxDelayMs: 10 },
+    );
+    expect(result).toBe("ok");
+  });
+
+  test("fails immediately on 400 (non-retryable)", async () => {
+    let attempt = 0;
+    try {
+      await withRetry(
+        () => {
+          attempt++;
+          throw new Error("400 Bad Request — invalid schema");
+          return Promise.resolve("never");
+        },
+        { providerName: "test", baseDelayMs: 1 },
+      );
+      expect(true).toBe(false); // Should not reach
+    } catch (err: any) {
+      expect(attempt).toBe(1);
+      expect(err.message).toContain("400");
+    }
+  });
+
+  test("fails immediately on 401 (auth error) with clear message", async () => {
+    let attempt = 0;
+    try {
+      await withRetry(
+        () => {
+          attempt++;
+          throw new Error("401 Unauthorized");
+        },
+        { providerName: "myProvider", baseDelayMs: 1 },
+      );
+      expect(true).toBe(false);
+    } catch (err: any) {
+      expect(attempt).toBe(1);
+      expect(err.message).toContain("myProvider");
+      expect(err.message).toContain("Authentication failed");
+    }
+  });
+
+  test("fails immediately on 403 (auth error)", async () => {
+    let attempt = 0;
+    try {
+      await withRetry(
+        () => {
+          attempt++;
+          throw new Error("403 Forbidden");
+        },
+        { providerName: "test", baseDelayMs: 1 },
+      );
+      expect(true).toBe(false);
+    } catch (err: any) {
+      expect(attempt).toBe(1);
+      expect(err.message).toContain("Authentication failed");
+    }
+  });
+
+  test("respects maxRetries for rate limits", async () => {
+    let attempt = 0;
+    try {
+      await withRetry(
+        () => {
+          attempt++;
+          throw new Error("429 rate_limit exceeded");
+        },
+        {
+          providerName: "test",
+          baseDelayMs: 1,
+          maxDelayMs: 10,
+          maxRetriesRateLimit: 2,
+        },
+      );
+      expect(true).toBe(false);
+    } catch (err: any) {
+      // 1 initial + 2 retries = 3 attempts total
+      expect(attempt).toBe(3);
+    }
+  });
+
+  test("respects maxRetries for server errors", async () => {
+    let attempt = 0;
+    try {
+      await withRetry(
+        () => {
+          attempt++;
+          throw new Error("500 internal server error");
+        },
+        {
+          providerName: "test",
+          baseDelayMs: 1,
+          maxDelayMs: 10,
+          maxRetriesServer: 1,
+        },
+      );
+      expect(true).toBe(false);
+    } catch (err: any) {
+      // 1 initial + 1 retry = 2 attempts
+      expect(attempt).toBe(2);
+    }
+  });
+
+  test("respects maxRetries for network errors", async () => {
+    let attempt = 0;
+    try {
+      await withRetry(
+        () => {
+          attempt++;
+          throw new Error("ECONNREFUSED");
+        },
+        {
+          providerName: "test",
+          baseDelayMs: 1,
+          maxDelayMs: 10,
+          maxRetriesNetwork: 1,
+        },
+      );
+      expect(true).toBe(false);
+    } catch (err: any) {
+      expect(attempt).toBe(2);
+    }
+  });
+});
+
+describe("CircuitBreaker", () => {
+  let breaker: CircuitBreaker;
+
+  beforeEach(() => {
+    breaker = new CircuitBreaker(3, 100); // low threshold and reset time for testing
+  });
+
+  test("starts in closed state", () => {
+    expect(breaker.getState()).toBe("closed");
+    expect(breaker.canRequest()).toBe(true);
+  });
+
+  test("allows requests in closed state", () => {
+    expect(breaker.canRequest()).toBe(true);
+    expect(breaker.canRequest()).toBe(true);
+    expect(breaker.canRequest()).toBe(true);
+  });
+
+  test("opens after threshold consecutive failures", () => {
+    breaker.recordFailure();
+    breaker.recordFailure();
+    expect(breaker.getState()).toBe("closed");
+
+    breaker.recordFailure(); // threshold = 3
+    expect(breaker.getState()).toBe("open");
+    expect(breaker.canRequest()).toBe(false);
+  });
+
+  test("success resets failure count", () => {
+    breaker.recordFailure();
+    breaker.recordFailure();
+    breaker.recordSuccess();
+
+    // Should be back to closed with 0 failures
+    expect(breaker.getState()).toBe("closed");
+
+    // Need 3 more failures to open again
+    breaker.recordFailure();
+    breaker.recordFailure();
+    expect(breaker.getState()).toBe("closed");
+  });
+
+  test("transitions to half-open after reset time", async () => {
+    // Open the circuit
+    breaker.recordFailure();
+    breaker.recordFailure();
+    breaker.recordFailure();
+    expect(breaker.getState()).toBe("open");
+
+    // Wait for reset time
+    await new Promise((r) => setTimeout(r, 150));
+
+    // Should transition to half-open
+    expect(breaker.getState()).toBe("half-open");
+  });
+
+  test("allows one probe request in half-open state", async () => {
+    // Open the circuit
+    breaker.recordFailure();
+    breaker.recordFailure();
+    breaker.recordFailure();
+
+    // Wait for reset time
+    await new Promise((r) => setTimeout(r, 150));
+
+    // First request should be allowed (probe)
+    expect(breaker.canRequest()).toBe(true);
+    // Second request should be blocked (probe in flight)
+    expect(breaker.canRequest()).toBe(false);
+  });
+
+  test("probe success resets to closed", async () => {
+    // Open the circuit
+    breaker.recordFailure();
+    breaker.recordFailure();
+    breaker.recordFailure();
+
+    // Wait for reset time
+    await new Promise((r) => setTimeout(r, 150));
+
+    // Probe request
+    expect(breaker.canRequest()).toBe(true);
+
+    // Probe succeeds
+    breaker.recordSuccess();
+    expect(breaker.getState()).toBe("closed");
+    expect(breaker.canRequest()).toBe(true);
+    expect(breaker.canRequest()).toBe(true); // all requests allowed again
+  });
+
+  test("probe failure keeps circuit open", async () => {
+    // Open the circuit
+    breaker.recordFailure();
+    breaker.recordFailure();
+    breaker.recordFailure();
+
+    // Wait for reset time
+    await new Promise((r) => setTimeout(r, 150));
+
+    // Probe request allowed
+    expect(breaker.canRequest()).toBe(true);
+
+    // Probe fails — failures now >= threshold so still open
+    breaker.recordFailure();
+    expect(breaker.getState()).toBe("open");
+    expect(breaker.canRequest()).toBe(false);
+  });
+
+  test("probeInFlight prevents multiple simultaneous probes", async () => {
+    // Open the circuit
+    breaker.recordFailure();
+    breaker.recordFailure();
+    breaker.recordFailure();
+
+    // Wait for reset time — enters half-open via canRequest
+    await new Promise((r) => setTimeout(r, 150));
+
+    // First probe allowed
+    expect(breaker.canRequest()).toBe(true);
+    // probeInFlight is now true — second probe blocked
+    expect(breaker.canRequest()).toBe(false);
+    expect(breaker.canRequest()).toBe(false);
+
+    // After recording failure, probeInFlight resets but state is still open
+    breaker.recordFailure();
+    expect(breaker.canRequest()).toBe(false); // still open, timer restarted
+  });
+
+  test("getStatus returns descriptive string", () => {
+    const status = breaker.getStatus();
+    expect(status).toContain("closed");
+    expect(status).toContain("0/3");
+
+    breaker.recordFailure();
+    expect(breaker.getStatus()).toContain("1/3");
+  });
+});

package/src/__tests__/router.test.ts

@@ -0,0 +1,158 @@
+import { test, expect, describe } from "bun:test";
+import { ProviderRouter, CostTracker } from "../providers/router.ts";
+
+// We can't easily test the full router without real providers, but we can test
+// the cost tracking logic by creating a CostTracker directly.
+
+describe("CostTracker", () => {
+  test("record accumulates usage and computes cost", () => {
+    const tracker = new CostTracker();
+    tracker.record("anthropic", "claude-sonnet-4-6-20250514", {
+      inputTokens: 1000,
+      outputTokens: 500,
+    });
+
+    expect(tracker.totalInputTokens).toBe(1000);
+    expect(tracker.totalOutputTokens).toBe(500);
+    // (1000/1M)*3 + (500/1M)*15 = 0.003 + 0.0075 = 0.0105
+    expect(tracker.totalCostUSD).toBeCloseTo(0.0105, 6);
+  });
+
+  test("reasoning tokens use separate pricing when available", () => {
+    const tracker = new CostTracker();
+    tracker.record("openai", "o1", {
+      inputTokens: 1000,
+      outputTokens: 500,
+      reasoningTokens: 200,
+    });
+
+    expect(tracker.totalTokens.reasoningTokens).toBe(200);
+    // (1000/1M)*15 + (500/1M)*60 + (200/1M)*60 = 0.015 + 0.030 + 0.012 = 0.057
+    expect(tracker.totalCostUSD).toBeCloseTo(0.057, 6);
+  });
+
+  test("multiple calls to same provider:model accumulate", () => {
+    const tracker = new CostTracker();
+    tracker.record("xai", "grok-3-fast", { inputTokens: 500, outputTokens: 200 });
+    tracker.record("xai", "grok-3-fast", { inputTokens: 500, outputTokens: 300 });
+
+    const breakdown = tracker.getBreakdown();
+    expect(breakdown).toHaveLength(1);
+    expect(breakdown[0]!.calls).toBe(2);
+    expect(breakdown[0]!.usage.inputTokens).toBe(1000);
+    expect(breakdown[0]!.usage.outputTokens).toBe(500);
+  });
+
+  test("multiple providers show in breakdown", () => {
+    const tracker = new CostTracker();
+    tracker.record("xai", "grok-3-fast", { inputTokens: 1000, outputTokens: 500 });
+    tracker.record("anthropic", "claude-sonnet-4-6-20250514", { inputTokens: 2000, outputTokens: 1000 });
+
+    const breakdown = tracker.getBreakdown();
+    expect(breakdown).toHaveLength(2);
+    expect(tracker.totalInputTokens).toBe(3000);
+    expect(tracker.totalOutputTokens).toBe(1500);
+  });
+
+  test("formatSummary includes reasoning when present", () => {
+    const tracker = new CostTracker();
+    tracker.record("openai", "o1", {
+      inputTokens: 10000,
+      outputTokens: 5000,
+      reasoningTokens: 3000,
+    });
+
+    const summary = tracker.formatSummary();
+    expect(summary).toContain("Cost:");
+    expect(summary).toContain("reasoning");
+    expect(summary).toContain("10K in");
+    expect(summary).toContain("5K out");
+    expect(summary).toContain("3K reasoning");
+  });
+
+  test("formatSummary omits reasoning when zero", () => {
+    const tracker = new CostTracker();
+    tracker.record("xai", "grok-3-fast", { inputTokens: 1000, outputTokens: 500 });
+
+    const summary = tracker.formatSummary();
+    expect(summary).not.toContain("reasoning");
+  });
+
+  test("formatSummary shows per-provider breakdown when multiple providers", () => {
+    const tracker = new CostTracker();
+    tracker.record("xai", "grok-3-fast", { inputTokens: 1000, outputTokens: 500 });
+    tracker.record("anthropic", "claude-sonnet-4-6-20250514", { inputTokens: 2000, outputTokens: 1000 });
+
+    const summary = tracker.formatSummary();
+    expect(summary).toContain("Per provider:");
+    expect(summary).toContain("xai:grok-3-fast");
+    expect(summary).toContain("anthropic:claude-sonnet-4-6-20250514");
+  });
+
+  test("unknown models get default pricing", () => {
+    const tracker = new CostTracker();
+    tracker.record("custom", "unknown-model-v2", {
+      inputTokens: 1_000_000,
+      outputTokens: 1_000_000,
+    });
+
+    // Default: $1/M input, $3/M output = $4 total
+    expect(tracker.totalCostUSD).toBeCloseTo(4.0, 2);
+  });
+
+  test("partial model name matching works", () => {
+    const tracker = new CostTracker();
+    // "claude-sonnet-4-6-20250514" should match even with extra suffix
+    tracker.record("anthropic", "claude-sonnet-4-6-20250514-latest", {
+      inputTokens: 1_000_000,
+      outputTokens: 0,
+    });
+
+    // Should match claude-sonnet-4-6 pricing: $3/M input
+    expect(tracker.totalCostUSD).toBeCloseTo(3.0, 2);
+  });
+});
+
+describe("ProviderRouter", () => {
+  test("uses the provider-specific name for OpenAI-compatible configs", () => {
+    const router = new ProviderRouter({
+      primary: {
+        provider: "openai",
+        apiKey: "test-key",
+        model: "gpt-test",
+      },
+    });
+
+    expect(router.currentProvider.name).toBe("openai");
+  });
+
+  test("getCostSummary delegates to costTracker.formatSummary", () => {
+    const router = new ProviderRouter({
+      primary: {
+        provider: "openai",
+        apiKey: "test-key",
+        model: "gpt-4o",
+      },
+    });
+
+    // Both should return the same result
+    expect(router.getCostSummary()).toBe(router.costTracker.formatSummary());
+  });
+
+  test("legacy costs getter provides backward-compatible shape", () => {
+    const router = new ProviderRouter({
+      primary: {
+        provider: "openai",
+        apiKey: "test-key",
+        model: "gpt-4o",
+      },
+    });
+
+    const costs = router.costs;
+    expect(costs.totalInputTokens).toBe(0);
+    expect(costs.totalOutputTokens).toBe(0);
+    expect(costs.totalReasoningTokens).toBe(0);
+    expect(costs.totalCostUSD).toBe(0);
+    expect(costs.perProvider).toBeInstanceOf(Map);
+  });
+});

package/src/__tests__/session-compact.test.ts

@@ -0,0 +1,191 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { Session, resumeSession, forkSession, compactSession } from "../persistence/session.ts";
+import { rmSync, existsSync, mkdtempSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { setConfigDirForTests } from "../config/settings.ts";
+
+describe("Session compact boundaries", () => {
+  let configDir: string;
+
+  beforeEach(() => {
+    configDir = mkdtempSync(join(tmpdir(), "ashlrcode-compact-test-"));
+    setConfigDirForTests(configDir);
+  });
+
+  afterEach(() => {
+    setConfigDirForTests(null);
+    if (existsSync(configDir)) rmSync(configDir, { recursive: true, force: true });
+  });
+
+  // ── insertCompactBoundary ─────────────────────────────────────────────
+
+  test("insertCompactBoundary writes a compact entry to the JSONL file", async () => {
+    const session = new Session("compact-write-test");
+    await session.init("xai", "grok");
+    await session.appendMessage({ role: "user", content: "hello" });
+    await session.appendMessage({ role: "assistant", content: "hi" });
+
+    await session.insertCompactBoundary("Summary of conversation", 2);
+
+    const sessionsDir = join(configDir, "sessions");
+    const content = await Bun.file(join(sessionsDir, "compact-write-test.jsonl")).text();
+    const lines = content.trim().split("\n");
+    const lastEntry = JSON.parse(lines[lines.length - 1]!);
+    expect(lastEntry.type).toBe("compact");
+    expect(lastEntry.data.summary).toBe("Summary of conversation");
+    expect(lastEntry.data.messageCountBefore).toBe(2);
+  });
+
+  // ── loadMessages with compact boundary ────────────────────────────────
+
+  test("loadMessages skips messages before compact boundary", async () => {
+    const session = new Session("compact-skip-test");
+    await session.init("xai", "grok");
+
+    // Messages before boundary
+    await session.appendMessage({ role: "user", content: "old message 1" });
+    await session.appendMessage({ role: "assistant", content: "old reply 1" });
+
+    // Insert boundary
+    await session.insertCompactBoundary("Old context summary", 2);
+
+    // Messages after boundary
+    await session.appendMessage({ role: "user", content: "new message" });
+    await session.appendMessage({ role: "assistant", content: "new reply" });
+
+    const messages = await session.loadMessages();
+    // Should have: 1 synthetic summary + 2 new messages = 3
+    expect(messages).toHaveLength(3);
+
+    // Should NOT contain old messages
+    const contents = messages.map((m) => m.content);
+    expect(contents).not.toContain("old message 1");
+    expect(contents).not.toContain("old reply 1");
+  });
+
+  test("loadMessages injects summary as user message", async () => {
+    const session = new Session("compact-summary-test");
+    await session.init("xai", "grok");
+
+    await session.appendMessage({ role: "user", content: "hello" });
+    await session.insertCompactBoundary("This is the summary", 1);
+    await session.appendMessage({ role: "user", content: "next question" });
+
+    const messages = await session.loadMessages();
+    expect(messages[0]!.role).toBe("user");
+    expect(messages[0]!.content).toContain("[Previous session context]");
+    expect(messages[0]!.content).toContain("This is the summary");
+  });
+
+  test("loadMessages returns all messages when no boundary exists", async () => {
+    const session = new Session("compact-none-test");
+    await session.init("xai", "grok");
+
+    await session.appendMessage({ role: "user", content: "msg1" });
+    await session.appendMessage({ role: "assistant", content: "msg2" });
+    await session.appendMessage({ role: "user", content: "msg3" });
+
+    const messages = await session.loadMessages();
+    expect(messages).toHaveLength(3);
+    expect(messages[0]!.content).toBe("msg1");
+  });
+
+  // ── loadAllMessages ignores boundaries ────────────────────────────────
+
+  test("loadAllMessages returns all messages ignoring compact boundaries", async () => {
+    const session = new Session("compact-all-test");
+    await session.init("xai", "grok");
+
+    await session.appendMessage({ role: "user", content: "before" });
+    await session.insertCompactBoundary("summary", 1);
+    await session.appendMessage({ role: "user", content: "after" });
+
+    const allMessages = await session.loadAllMessages();
+    expect(allMessages).toHaveLength(2);
+    expect(allMessages[0]!.content).toBe("before");
+    expect(allMessages[1]!.content).toBe("after");
+    // No synthetic summary injected
+    const contents = allMessages.map((m) => m.content);
+    expect(contents.some((c) => typeof c === "string" && c.includes("[Previous session context]"))).toBe(false);
+  });
+
+  // ── compactSession ────────────────────────────────────────────────────
+
+  test("compactSession creates boundary with summary of recent messages", async () => {
+    const session = new Session("compact-session-test");
+    await session.init("xai", "grok");
+
+    await session.appendMessage({ role: "user", content: "question 1" });
+    await session.appendMessage({ role: "assistant", content: "answer 1" });
+    await session.appendMessage({ role: "user", content: "question 2" });
+    await session.appendMessage({ role: "assistant", content: "answer 2" });
+
+    const result = await compactSession("compact-session-test");
+    expect(result.messagesBefore).toBe(4);
+    expect(result.summary).toContain("question 1");
+    expect(result.summary).toContain("answer 2");
+
+    // After compaction, loadMessages should return summary + no old messages
+    const messages = await session.loadMessages();
+    expect(messages[0]!.role).toBe("user");
+    expect(messages[0]!.content).toContain("[Previous session context]");
+    // Only the synthetic summary should be returned (no messages after the boundary)
+    expect(messages).toHaveLength(1);
+  });
+
+  // ── forkSession uses loadAllMessages ──────────────────────────────────
+
+  test("forkSession preserves full history including before compact boundary", async () => {
+    const session = new Session("compact-fork-source");
+    await session.init("xai", "grok");
+
+    await session.appendMessage({ role: "user", content: "old msg" });
+    await session.insertCompactBoundary("summary", 1);
+    await session.appendMessage({ role: "user", content: "new msg" });
+
+    const forked = await forkSession("compact-fork-source", "xai", "grok");
+    expect(forked).not.toBeNull();
+
+    // Fork should have ALL messages (loadAllMessages), not just post-boundary
+    const forkedMessages = await forked!.session.loadAllMessages();
+    expect(forkedMessages).toHaveLength(2);
+    expect(forkedMessages[0]!.content).toBe("old msg");
+    expect(forkedMessages[1]!.content).toBe("new msg");
+  });
+
+  // ── Multiple boundaries ───────────────────────────────────────────────
+
+  test("multiple boundaries: loadMessages uses the last one", async () => {
+    const session = new Session("compact-multi-test");
+    await session.init("xai", "grok");
+
+    await session.appendMessage({ role: "user", content: "era 1" });
+    await session.insertCompactBoundary("Summary of era 1", 1);
+
+    await session.appendMessage({ role: "user", content: "era 2" });
+    await session.insertCompactBoundary("Summary of eras 1+2", 2);
+
+    await session.appendMessage({ role: "user", content: "era 3" });
+
+    const messages = await session.loadMessages();
+    // Should use the LAST boundary: summary of eras 1+2 + era 3 message
+    expect(messages).toHaveLength(2);
+    expect(messages[0]!.content).toContain("Summary of eras 1+2");
+    expect(messages[1]!.content).toBe("era 3");
+  });
+
+  test("multiple boundaries: loadAllMessages returns everything", async () => {
+    const session = new Session("compact-multi-all-test");
+    await session.init("xai", "grok");
+
+    await session.appendMessage({ role: "user", content: "era 1" });
+    await session.insertCompactBoundary("Summary 1", 1);
+    await session.appendMessage({ role: "user", content: "era 2" });
+    await session.insertCompactBoundary("Summary 2", 2);
+    await session.appendMessage({ role: "user", content: "era 3" });
+
+    const allMessages = await session.loadAllMessages();
+    expect(allMessages).toHaveLength(3);
+  });
+});