ashlrcode 1.0.0

package/src/__tests__/session.test.ts

@@ -0,0 +1,145 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { Session, resumeSession } 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", () => {
+  const testIds: string[] = [];
+  let configDir: string;
+  let sessionsDir: string;
+
+  beforeEach(() => {
+    configDir = mkdtempSync(join(tmpdir(), "ashlrcode-session-test-"));
+    sessionsDir = join(configDir, "sessions");
+    setConfigDirForTests(configDir);
+  });
+
+  function trackId(id: string) {
+    testIds.push(id);
+    return id;
+  }
+
+  afterEach(() => {
+    setConfigDirForTests(null);
+    if (existsSync(configDir)) rmSync(configDir, { recursive: true, force: true });
+    testIds.length = 0;
+  });
+
+  test("creates a session with unique id", () => {
+    const s1 = new Session();
+    const s2 = new Session();
+    expect(s1.id).not.toBe(s2.id);
+    expect(s1.id.length).toBeGreaterThan(0);
+  });
+
+  test("creates a session with provided id", () => {
+    const s = new Session("test-123");
+    expect(s.id).toBe("test-123");
+  });
+
+  test("init creates file and writes metadata", async () => {
+    const id = trackId(`test-init-${Date.now()}`);
+    const session = new Session(id);
+    await session.init("xai", "grok-4");
+
+    const path = join(sessionsDir, `${id}.jsonl`);
+    expect(existsSync(path)).toBe(true);
+
+    const content = await Bun.file(path).text();
+    const entry = JSON.parse(content.split("\n")[0]!);
+    expect(entry.type).toBe("metadata");
+    expect(entry.data.provider).toBe("xai");
+    expect(entry.data.model).toBe("grok-4");
+  });
+
+  test("appendMessage adds messages to file", async () => {
+    const id = trackId(`test-append-${Date.now()}`);
+    const session = new Session(id);
+    await session.init("anthropic", "claude");
+
+    await session.appendMessage({ role: "user", content: "Hello" });
+    await session.appendMessage({
+      role: "assistant",
+      content: "Hi there!",
+    });
+
+    const path = join(sessionsDir, `${id}.jsonl`);
+    const lines = (await Bun.file(path).text()).trim().split("\n");
+    // 1 metadata + 2 messages = 3 lines
+    expect(lines.length).toBe(3);
+  });
+
+  test("loadMessages returns only message entries", async () => {
+    const id = trackId(`test-load-${Date.now()}`);
+    const session = new Session(id);
+    await session.init("xai", "grok");
+
+    await session.appendMessage({ role: "user", content: "question" });
+    await session.appendMessage({
+      role: "assistant",
+      content: "answer",
+    });
+
+    const messages = await session.loadMessages();
+    expect(messages).toHaveLength(2);
+    expect(messages[0]!.role).toBe("user");
+    expect(messages[0]!.content).toBe("question");
+    expect(messages[1]!.role).toBe("assistant");
+    expect(messages[1]!.content).toBe("answer");
+  });
+
+  test("loadMessages returns empty for non-existent session", async () => {
+    const session = new Session("nonexistent-xyz");
+    const messages = await session.loadMessages();
+    expect(messages).toEqual([]);
+  });
+
+  test("setTitle persists title in metadata entry", async () => {
+    const id = trackId(`test-title-${Date.now()}`);
+    const session = new Session(id);
+    await session.init("xai", "grok");
+    await session.setTitle("My cool session");
+
+    const path = join(sessionsDir, `${id}.jsonl`);
+    const lines = (await Bun.file(path).text()).trim().split("\n");
+    const lastEntry = JSON.parse(lines[lines.length - 1]!);
+    expect(lastEntry.type).toBe("metadata");
+    expect(lastEntry.data.title).toBe("My cool session");
+  });
+});
+
+describe("resumeSession", () => {
+  const testIds: string[] = [];
+  let configDir: string;
+
+  beforeEach(() => {
+    configDir = mkdtempSync(join(tmpdir(), "ashlrcode-resume-test-"));
+    setConfigDirForTests(configDir);
+  });
+
+  afterEach(() => {
+    setConfigDirForTests(null);
+    if (existsSync(configDir)) rmSync(configDir, { recursive: true, force: true });
+    testIds.length = 0;
+  });
+
+  test("returns session and messages for existing session", async () => {
+    const id = `test-resume-${Date.now()}`;
+    testIds.push(id);
+    const session = new Session(id);
+    await session.init("xai", "grok");
+    await session.appendMessage({ role: "user", content: "hello" });
+
+    const result = await resumeSession(id);
+    expect(result).not.toBeNull();
+    expect(result!.session.id).toBe(id);
+    expect(result!.messages).toHaveLength(1);
+  });
+
+  test("returns null for empty/nonexistent session", async () => {
+    const result = await resumeSession("does-not-exist-999");
+    expect(result).toBeNull();
+  });
+});

package/src/__tests__/skill-registry.test.ts

@@ -0,0 +1,130 @@
+import { test, expect, describe, beforeEach } from "bun:test";
+import { SkillRegistry } from "../skills/registry.ts";
+import type { SkillDefinition } from "../skills/types.ts";
+
+function makeSkill(overrides: Partial<SkillDefinition> = {}): SkillDefinition {
+  return {
+    name: overrides.name ?? "commit",
+    description: overrides.description ?? "Create a git commit",
+    trigger: overrides.trigger ?? "/commit",
+    prompt: overrides.prompt ?? "Create a well-crafted git commit.",
+  };
+}
+
+describe("SkillRegistry", () => {
+  let registry: SkillRegistry;
+
+  beforeEach(() => {
+    registry = new SkillRegistry();
+  });
+
+  describe("register and get", () => {
+    test("registers and retrieves a skill by trigger", () => {
+      const skill = makeSkill();
+      registry.register(skill);
+      expect(registry.get("/commit")).toBe(skill);
+    });
+
+    test("registers by /name if trigger does not start with /", () => {
+      const skill = makeSkill({ name: "deploy", trigger: "deploy-prod" });
+      registry.register(skill);
+      expect(registry.get("deploy-prod")).toBe(skill);
+      expect(registry.get("/deploy")).toBe(skill);
+    });
+
+    test("does not double-register if trigger already starts with /", () => {
+      const skill = makeSkill({ name: "review", trigger: "/review" });
+      registry.register(skill);
+      // Only one entry with trigger /review
+      expect(registry.get("/review")).toBe(skill);
+    });
+
+    test("registerAll registers multiple skills", () => {
+      registry.registerAll([
+        makeSkill({ name: "a", trigger: "/a" }),
+        makeSkill({ name: "b", trigger: "/b" }),
+      ]);
+      expect(registry.get("/a")).toBeDefined();
+      expect(registry.get("/b")).toBeDefined();
+    });
+  });
+
+  describe("isSkill", () => {
+    test("returns true for registered trigger", () => {
+      registry.register(makeSkill({ trigger: "/commit" }));
+      expect(registry.isSkill("/commit")).toBe(true);
+    });
+
+    test("returns true when trigger has trailing args", () => {
+      registry.register(makeSkill({ trigger: "/commit" }));
+      expect(registry.isSkill("/commit fix typo")).toBe(true);
+    });
+
+    test("returns false for unregistered trigger", () => {
+      expect(registry.isSkill("/unknown")).toBe(false);
+    });
+  });
+
+  describe("expand", () => {
+    test("returns prompt for valid trigger", () => {
+      registry.register(makeSkill({ trigger: "/commit", prompt: "Do a commit." }));
+      expect(registry.expand("/commit")).toBe("Do a commit.");
+    });
+
+    test("replaces {{args}} with user arguments", () => {
+      registry.register(
+        makeSkill({
+          trigger: "/review",
+          prompt: "Review this: {{args}}",
+        })
+      );
+      expect(registry.expand("/review PR #42")).toBe("Review this: PR #42");
+    });
+
+    test("appends args as additional context when no template variable", () => {
+      registry.register(
+        makeSkill({ trigger: "/fix", prompt: "Fix the bug." })
+      );
+      const result = registry.expand("/fix memory leak");
+      expect(result).toContain("Fix the bug.");
+      expect(result).toContain("Additional context: memory leak");
+    });
+
+    test("returns null for unknown trigger", () => {
+      expect(registry.expand("/nope")).toBeNull();
+    });
+
+    test("does not append extra context when args are empty", () => {
+      registry.register(
+        makeSkill({ trigger: "/test", prompt: "Run tests." })
+      );
+      const result = registry.expand("/test");
+      expect(result).toBe("Run tests.");
+    });
+
+    test("replaces all occurrences of {{args}}", () => {
+      registry.register(
+        makeSkill({
+          trigger: "/search",
+          prompt: "Search for {{args}} and display {{args}} results.",
+        })
+      );
+      const result = registry.expand("/search foo");
+      expect(result).toBe("Search for foo and display foo results.");
+    });
+  });
+
+  describe("getAll", () => {
+    test("returns deduplicated skills", () => {
+      // A skill with trigger not starting with / gets registered twice
+      registry.register(makeSkill({ name: "deploy", trigger: "deploy-prod" }));
+      const all = registry.getAll();
+      expect(all).toHaveLength(1);
+      expect(all[0]!.name).toBe("deploy");
+    });
+
+    test("returns empty array when no skills registered", () => {
+      expect(registry.getAll()).toEqual([]);
+    });
+  });
+});

package/src/__tests__/speculation.test.ts

@@ -0,0 +1,196 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { SpeculationCache } from "../agent/speculation.ts";
+import { mkdtempSync, writeFileSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+describe("SpeculationCache", () => {
+  let cache: SpeculationCache;
+
+  beforeEach(() => {
+    cache = new SpeculationCache(5, 200); // small size, short TTL for testing
+  });
+
+  // ── Core get/set ──────────────────────────────────────────────────────
+
+  test("cache hit returns stored result", () => {
+    cache.set("Read", { file_path: "/foo/bar.ts" }, "file contents here");
+    const result = cache.get("Read", { file_path: "/foo/bar.ts" });
+    expect(result).toBe("file contents here");
+  });
+
+  test("cache miss returns null", () => {
+    const result = cache.get("Read", { file_path: "/nonexistent" });
+    expect(result).toBeNull();
+  });
+
+  test("different tool names are different cache keys", () => {
+    cache.set("Read", { file_path: "/foo" }, "read result");
+    cache.set("Grep", { file_path: "/foo" }, "grep result");
+
+    expect(cache.get("Read", { file_path: "/foo" })).toBe("read result");
+    expect(cache.get("Grep", { file_path: "/foo" })).toBe("grep result");
+  });
+
+  test("different inputs are different cache keys", () => {
+    cache.set("Read", { file_path: "/a.ts" }, "content a");
+    cache.set("Read", { file_path: "/b.ts" }, "content b");
+
+    expect(cache.get("Read", { file_path: "/a.ts" })).toBe("content a");
+    expect(cache.get("Read", { file_path: "/b.ts" })).toBe("content b");
+  });
+
+  // ── TTL expiry ────────────────────────────────────────────────────────
+
+  test("TTL expiry evicts entries", async () => {
+    cache.set("Read", { file_path: "/foo" }, "content");
+    expect(cache.get("Read", { file_path: "/foo" })).toBe("content");
+
+    // Wait for TTL to expire (200ms)
+    await new Promise((r) => setTimeout(r, 250));
+
+    expect(cache.get("Read", { file_path: "/foo" })).toBeNull();
+  });
+
+  test("entry is valid before TTL expiry", async () => {
+    cache.set("Read", { file_path: "/foo" }, "content");
+
+    // Wait less than TTL
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(cache.get("Read", { file_path: "/foo" })).toBe("content");
+  });
+
+  // ── Max size eviction ─────────────────────────────────────────────────
+
+  test("max size eviction removes oldest entry", () => {
+    // Cache maxSize = 5, add 5 entries
+    for (let i = 0; i < 5; i++) {
+      cache.set("Read", { file_path: `/file${i}` }, `content${i}`);
+    }
+
+    // All 5 should be present
+    expect(cache.get("Read", { file_path: "/file0" })).toBe("content0");
+    expect(cache.get("Read", { file_path: "/file4" })).toBe("content4");
+
+    // Add a 6th entry — should evict the oldest
+    cache.set("Read", { file_path: "/file5" }, "content5");
+
+    // file0 was the oldest and should be evicted
+    // Note: get() updates hitCount, so file0 was actually accessed above.
+    // The eviction is based on timestamp, so file0 (earliest timestamp) should be gone
+    expect(cache.getStats().size).toBe(5);
+    expect(cache.get("Read", { file_path: "/file5" })).toBe("content5");
+  });
+
+  test("overwriting existing key does not trigger eviction", () => {
+    for (let i = 0; i < 5; i++) {
+      cache.set("Read", { file_path: `/file${i}` }, `content${i}`);
+    }
+
+    // Overwrite an existing entry — should NOT evict
+    cache.set("Read", { file_path: "/file0" }, "updated content");
+
+    expect(cache.getStats().size).toBe(5);
+    expect(cache.get("Read", { file_path: "/file0" })).toBe("updated content");
+    expect(cache.get("Read", { file_path: "/file4" })).toBe("content4");
+  });
+
+  // ── prefetchRead ──────────────────────────────────────────────────────
+
+  test("prefetchRead caches file content", async () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "spec-prefetch-"));
+    const filePath = join(tmpDir, "test.ts");
+    writeFileSync(filePath, "export const x = 42;", "utf-8");
+
+    try {
+      await cache.prefetchRead(filePath);
+      const result = cache.get("Read", { file_path: filePath });
+      expect(result).toBe("export const x = 42;");
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  test("prefetchRead skips nonexistent files", async () => {
+    await cache.prefetchRead("/nonexistent/path/file.ts");
+    const result = cache.get("Read", { file_path: "/nonexistent/path/file.ts" });
+    expect(result).toBeNull();
+  });
+
+  test("prefetchRead skips files larger than 1MB", async () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "spec-large-"));
+    const filePath = join(tmpDir, "big.bin");
+    // Write >1MB file
+    writeFileSync(filePath, Buffer.alloc(1_100_000, "x"), "utf-8");
+
+    try {
+      await cache.prefetchRead(filePath);
+      const result = cache.get("Read", { file_path: filePath });
+      expect(result).toBeNull();
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  // ── Invalidation on write ─────────────────────────────────────────────
+
+  test("invalidateForFile removes Read cache for that file", () => {
+    cache.set("Read", { file_path: "/foo/bar.ts" }, "old content");
+    cache.set("Read", { file_path: "/foo/baz.ts" }, "other content");
+
+    cache.invalidateForFile("/foo/bar.ts");
+
+    expect(cache.get("Read", { file_path: "/foo/bar.ts" })).toBeNull();
+    // Other files unaffected
+    expect(cache.get("Read", { file_path: "/foo/baz.ts" })).toBe("other content");
+  });
+
+  test("invalidateForFile removes all Grep and Glob cache entries", () => {
+    cache.set("Grep", { pattern: "foo" }, "grep results");
+    cache.set("Glob", { pattern: "*.ts" }, "glob results");
+    cache.set("Read", { file_path: "/other.ts" }, "content");
+
+    cache.invalidateForFile("/some/file.ts");
+
+    // Grep and Glob results should be cleared (conservative invalidation)
+    expect(cache.get("Grep", { pattern: "foo" })).toBeNull();
+    expect(cache.get("Glob", { pattern: "*.ts" })).toBeNull();
+    // Read for other files should survive
+    expect(cache.get("Read", { file_path: "/other.ts" })).toBe("content");
+  });
+
+  // ── Stats and clear ───────────────────────────────────────────────────
+
+  test("getStats tracks size and misses", () => {
+    cache.set("Read", { file_path: "/a" }, "a");
+    cache.set("Read", { file_path: "/b" }, "b");
+    cache.get("Read", { file_path: "/nonexistent" }); // miss
+
+    const stats = cache.getStats();
+    expect(stats.size).toBe(2);
+    expect(stats.misses).toBe(1);
+  });
+
+  test("getStats tracks hits", () => {
+    cache.set("Read", { file_path: "/a" }, "a");
+    cache.get("Read", { file_path: "/a" }); // hit
+    cache.get("Read", { file_path: "/a" }); // hit
+
+    const stats = cache.getStats();
+    expect(stats.hits).toBe(2);
+  });
+
+  test("clear resets everything", () => {
+    cache.set("Read", { file_path: "/a" }, "a");
+    cache.get("Read", { file_path: "/miss" }); // miss
+    cache.get("Read", { file_path: "/a" }); // hit
+
+    cache.clear();
+
+    const stats = cache.getStats();
+    expect(stats.size).toBe(0);
+    expect(stats.hits).toBe(0);
+    expect(stats.misses).toBe(0);
+  });
+});