ashlrcode 1.0.0

package/src/__tests__/tasks-v2.test.ts

@@ -0,0 +1,267 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import {
+  taskCreateTool,
+  taskUpdateTool,
+  taskListTool,
+  taskGetTool,
+  resetTasks,
+} from "../tools/tasks.ts";
+import type { ToolContext } from "../tools/types.ts";
+
+const ctx: ToolContext = {
+  cwd: "/tmp",
+  requestPermission: async () => true,
+};
+
+describe("TaskCreate", () => {
+  beforeEach(() => {
+    resetTasks();
+  });
+
+  test("creates task with string ID using source prefix", async () => {
+    const result = await taskCreateTool.call(
+      { subject: "Write tests", description: "Unit tests for tasks" },
+      ctx,
+    );
+    expect(result).toContain("u-001");
+    expect(result).toContain("Write tests");
+  });
+
+  test("creates task with agent source prefix", async () => {
+    const result = await taskCreateTool.call(
+      { subject: "Agent task", description: "From agent", source: "a" },
+      ctx,
+    );
+    expect(result).toContain("a-001");
+  });
+
+  test("increments ID counter across creates", async () => {
+    await taskCreateTool.call({ subject: "First", description: "" }, ctx);
+    const result = await taskCreateTool.call({ subject: "Second", description: "" }, ctx);
+    expect(result).toContain("u-002");
+  });
+
+  test("creates task with blockedBy dependency", async () => {
+    await taskCreateTool.call({ subject: "First", description: "" }, ctx);
+    await taskCreateTool.call(
+      { subject: "Second", description: "", blockedBy: ["u-001"] },
+      ctx,
+    );
+
+    // Check that the blocker has blocks[] wired
+    const firstJson = await taskGetTool.call({ taskId: "u-001" }, ctx);
+    const first = JSON.parse(firstJson);
+    expect(first.blocks).toContain("u-002");
+
+    // Check the blocked task has blockedBy[]
+    const secondJson = await taskGetTool.call({ taskId: "u-002" }, ctx);
+    const second = JSON.parse(secondJson);
+    expect(second.blockedBy).toContain("u-001");
+  });
+
+  test("creates task with owner field", async () => {
+    await taskCreateTool.call(
+      { subject: "Owned task", description: "", owner: "agent-1" },
+      ctx,
+    );
+
+    const json = await taskGetTool.call({ taskId: "u-001" }, ctx);
+    const task = JSON.parse(json);
+    expect(task.owner).toBe("agent-1");
+  });
+});
+
+describe("TaskUpdate", () => {
+  beforeEach(() => {
+    resetTasks();
+  });
+
+  test("updates task status to in_progress", async () => {
+    await taskCreateTool.call({ subject: "Do stuff", description: "" }, ctx);
+    await taskUpdateTool.call({ taskId: "u-001", status: "in_progress" }, ctx);
+
+    const json = await taskGetTool.call({ taskId: "u-001" }, ctx);
+    const task = JSON.parse(json);
+    expect(task.status).toBe("in_progress");
+  });
+
+  test("updates task status to completed with timestamp", async () => {
+    await taskCreateTool.call({ subject: "Do stuff", description: "" }, ctx);
+    await taskUpdateTool.call({ taskId: "u-001", status: "completed" }, ctx);
+
+    const json = await taskGetTool.call({ taskId: "u-001" }, ctx);
+    const task = JSON.parse(json);
+    expect(task.status).toBe("completed");
+    expect(task.completedAt).toBeDefined();
+  });
+
+  test("returns not found for invalid taskId", async () => {
+    const result = await taskUpdateTool.call({ taskId: "u-999" }, ctx);
+    expect(result).toContain("not found");
+  });
+
+  test("addBlocks wires both directions", async () => {
+    await taskCreateTool.call({ subject: "Task A", description: "" }, ctx);
+    await taskCreateTool.call({ subject: "Task B", description: "" }, ctx);
+
+    await taskUpdateTool.call(
+      { taskId: "u-001", addBlocks: ["u-002"] },
+      ctx,
+    );
+
+    const aJson = await taskGetTool.call({ taskId: "u-001" }, ctx);
+    const a = JSON.parse(aJson);
+    expect(a.blocks).toContain("u-002");
+
+    const bJson = await taskGetTool.call({ taskId: "u-002" }, ctx);
+    const b = JSON.parse(bJson);
+    expect(b.blockedBy).toContain("u-001");
+  });
+
+  test("addBlockedBy wires both directions", async () => {
+    await taskCreateTool.call({ subject: "Task A", description: "" }, ctx);
+    await taskCreateTool.call({ subject: "Task B", description: "" }, ctx);
+
+    await taskUpdateTool.call(
+      { taskId: "u-002", addBlockedBy: ["u-001"] },
+      ctx,
+    );
+
+    const aJson = await taskGetTool.call({ taskId: "u-001" }, ctx);
+    const a = JSON.parse(aJson);
+    expect(a.blocks).toContain("u-002");
+
+    const bJson = await taskGetTool.call({ taskId: "u-002" }, ctx);
+    const b = JSON.parse(bJson);
+    expect(b.blockedBy).toContain("u-001");
+  });
+
+  test("addBlocks does not duplicate entries", async () => {
+    await taskCreateTool.call({ subject: "Task A", description: "" }, ctx);
+    await taskCreateTool.call({ subject: "Task B", description: "" }, ctx);
+
+    await taskUpdateTool.call({ taskId: "u-001", addBlocks: ["u-002"] }, ctx);
+    await taskUpdateTool.call({ taskId: "u-001", addBlocks: ["u-002"] }, ctx);
+
+    const json = await taskGetTool.call({ taskId: "u-001" }, ctx);
+    const task = JSON.parse(json);
+    expect(task.blocks.filter((id: string) => id === "u-002")).toHaveLength(1);
+  });
+
+  test("updates owner field", async () => {
+    await taskCreateTool.call({ subject: "Task", description: "" }, ctx);
+    await taskUpdateTool.call({ taskId: "u-001", owner: "explorer" }, ctx);
+
+    const json = await taskGetTool.call({ taskId: "u-001" }, ctx);
+    const task = JSON.parse(json);
+    expect(task.owner).toBe("explorer");
+  });
+});
+
+describe("TaskGet", () => {
+  beforeEach(() => {
+    resetTasks();
+  });
+
+  test("returns full JSON detail for existing task", async () => {
+    await taskCreateTool.call(
+      { subject: "Build feature", description: "Details here", owner: "me" },
+      ctx,
+    );
+
+    const json = await taskGetTool.call({ taskId: "u-001" }, ctx);
+    const task = JSON.parse(json);
+    expect(task.id).toBe("u-001");
+    expect(task.subject).toBe("Build feature");
+    expect(task.description).toBe("Details here");
+    expect(task.status).toBe("pending");
+    expect(task.owner).toBe("me");
+    expect(task.createdAt).toBeDefined();
+  });
+
+  test("returns not found for missing task", async () => {
+    const result = await taskGetTool.call({ taskId: "u-999" }, ctx);
+    expect(result).toContain("not found");
+  });
+});
+
+describe("TaskList", () => {
+  beforeEach(() => {
+    resetTasks();
+  });
+
+  test("returns 'No tasks.' when empty", async () => {
+    const result = await taskListTool.call({}, ctx);
+    expect(result).toBe("No tasks.");
+  });
+
+  test("lists tasks with status icons", async () => {
+    await taskCreateTool.call({ subject: "Pending task", description: "" }, ctx);
+    await taskCreateTool.call({ subject: "Active task", description: "" }, ctx);
+    await taskUpdateTool.call({ taskId: "u-002", status: "in_progress" }, ctx);
+
+    const result = await taskListTool.call({}, ctx);
+    expect(result).toContain("○"); // pending
+    expect(result).toContain("●"); // in_progress
+  });
+
+  test("shows dependency annotations", async () => {
+    await taskCreateTool.call({ subject: "First", description: "" }, ctx);
+    await taskCreateTool.call(
+      { subject: "Second", description: "", blockedBy: ["u-001"] },
+      ctx,
+    );
+
+    const result = await taskListTool.call({}, ctx);
+    expect(result).toContain("→ blocks #u-002");
+    expect(result).toContain("← blocked by #u-001");
+  });
+
+  test("shows (blocked) when blockers are incomplete", async () => {
+    await taskCreateTool.call({ subject: "Blocker", description: "" }, ctx);
+    await taskCreateTool.call(
+      { subject: "Blocked", description: "", blockedBy: ["u-001"] },
+      ctx,
+    );
+
+    const result = await taskListTool.call({}, ctx);
+    expect(result).toContain("(blocked)");
+  });
+
+  test("completing a blocker removes (blocked) annotation", async () => {
+    await taskCreateTool.call({ subject: "Blocker", description: "" }, ctx);
+    await taskCreateTool.call(
+      { subject: "Blocked", description: "", blockedBy: ["u-001"] },
+      ctx,
+    );
+
+    // Complete the blocker
+    await taskUpdateTool.call({ taskId: "u-001", status: "completed" }, ctx);
+
+    const result = await taskListTool.call({}, ctx);
+    expect(result).not.toContain("(blocked)");
+  });
+
+  test("shows owner with @ prefix", async () => {
+    await taskCreateTool.call(
+      { subject: "Task", description: "", owner: "agent-1" },
+      ctx,
+    );
+
+    const result = await taskListTool.call({}, ctx);
+    expect(result).toContain("@agent-1");
+  });
+
+  test("shows progress summary", async () => {
+    await taskCreateTool.call({ subject: "A", description: "" }, ctx);
+    await taskCreateTool.call({ subject: "B", description: "" }, ctx);
+    await taskCreateTool.call({ subject: "C", description: "" }, ctx);
+    await taskUpdateTool.call({ taskId: "u-001", status: "completed" }, ctx);
+    await taskUpdateTool.call({ taskId: "u-002", status: "in_progress" }, ctx);
+
+    const result = await taskListTool.call({}, ctx);
+    expect(result).toContain("1/3 completed");
+    expect(result).toContain("1 in progress");
+    expect(result).toContain("1 pending");
+  });
+});

package/src/__tests__/telemetry.test.ts

@@ -0,0 +1,149 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { mkdtempSync, rmSync, existsSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { readFile } from "fs/promises";
+import { setConfigDirForTests } from "../config/settings.ts";
+import {
+  initTelemetry,
+  logEvent,
+  readRecentEvents,
+  formatEvents,
+} from "../telemetry/event-log.ts";
+
+describe("Telemetry", () => {
+  let configDir: string;
+
+  beforeEach(() => {
+    configDir = mkdtempSync(join(tmpdir(), "ashlrcode-telemetry-test-"));
+    setConfigDirForTests(configDir);
+  });
+
+  afterEach(() => {
+    setConfigDirForTests(null);
+    if (existsSync(configDir)) rmSync(configDir, { recursive: true, force: true });
+  });
+
+  test("initTelemetry sets session ID that appears in logged events", async () => {
+    initTelemetry("test-session-42");
+    await logEvent("session_start");
+
+    const events = await readRecentEvents();
+    expect(events.length).toBe(1);
+    expect(events[0]!.sessionId).toBe("test-session-42");
+  });
+
+  test("logEvent writes to JSONL file", async () => {
+    initTelemetry("sess-write");
+    await logEvent("turn_start", { prompt: "hello" });
+    await logEvent("turn_end", { tokens: 100 });
+
+    const logPath = join(configDir, "telemetry", "events.jsonl");
+    expect(existsSync(logPath)).toBe(true);
+
+    const content = await readFile(logPath, "utf-8");
+    const lines = content.trim().split("\n");
+    expect(lines.length).toBe(2);
+
+    const first = JSON.parse(lines[0]!);
+    expect(first.type).toBe("turn_start");
+    expect(first.data.prompt).toBe("hello");
+
+    const second = JSON.parse(lines[1]!);
+    expect(second.type).toBe("turn_end");
+    expect(second.data.tokens).toBe(100);
+  });
+
+  test("readRecentEvents reads back events", async () => {
+    initTelemetry("sess-read");
+    await logEvent("session_start");
+    await logEvent("tool_start", { tool: "Bash" });
+    await logEvent("tool_end", { tool: "Bash" });
+
+    const events = await readRecentEvents();
+    expect(events.length).toBe(3);
+    expect(events[0]!.type).toBe("session_start");
+    expect(events[1]!.type).toBe("tool_start");
+    expect(events[2]!.type).toBe("tool_end");
+  });
+
+  test("readRecentEvents respects count parameter", async () => {
+    initTelemetry("sess-count");
+    await logEvent("session_start");
+    await logEvent("turn_start");
+    await logEvent("turn_end");
+    await logEvent("session_end");
+
+    const events = await readRecentEvents(2);
+    expect(events.length).toBe(2);
+    // Should return the last 2 events
+    expect(events[0]!.type).toBe("turn_end");
+    expect(events[1]!.type).toBe("session_end");
+  });
+
+  test("readRecentEvents returns empty for non-existent log", async () => {
+    const events = await readRecentEvents();
+    expect(events).toEqual([]);
+  });
+
+  test("formatEvents produces readable output", () => {
+    const events = [
+      {
+        type: "session_start" as const,
+        timestamp: "2025-01-15T10:30:00.000Z",
+        sessionId: "s1",
+      },
+      {
+        type: "tool_start" as const,
+        timestamp: "2025-01-15T10:30:05.000Z",
+        sessionId: "s1",
+        data: { tool: "Bash" },
+      },
+    ];
+
+    const output = formatEvents(events);
+    expect(output).toContain("session_start");
+    expect(output).toContain("tool_start");
+    expect(output).toContain("Bash");
+    // Each line should be indented with two spaces
+    const lines = output.split("\n");
+    expect(lines.length).toBe(2);
+    for (const line of lines) {
+      expect(line.startsWith("  ")).toBe(true);
+    }
+  });
+
+  test("log rotation occurs when file exceeds size limit", async () => {
+    initTelemetry("sess-rotate");
+
+    // Manually create the telemetry dir and seed file
+    const telemetryDir = join(configDir, "telemetry");
+    mkdirSync(telemetryDir, { recursive: true });
+    const logPath = join(telemetryDir, "events.jsonl");
+    writeFileSync(logPath, "", "utf-8");
+
+    // Now overwrite with a large file that exceeds 5MB
+    const bigLine = JSON.stringify({
+      type: "session_start",
+      timestamp: new Date().toISOString(),
+      sessionId: "bulk",
+      data: { payload: "x".repeat(1000) },
+    }) + "\n";
+
+    const linesNeeded = Math.ceil((5 * 1024 * 1024) / bigLine.length) + 1;
+    const bulk = bigLine.repeat(linesNeeded);
+    writeFileSync(logPath, bulk, "utf-8");
+
+    // Log one more event which should trigger rotation
+    await logEvent("session_start", { after: "rotation" });
+
+    // The old file should have been rotated to events.1.jsonl
+    const rotatedPath = join(telemetryDir, "events.1.jsonl");
+    expect(existsSync(rotatedPath)).toBe(true);
+
+    // The rotated file should contain the bulk data + the new event
+    // (logEvent appends first, then rotates, so the new event is in the rotated file)
+    const rotatedContent = await readFile(rotatedPath, "utf-8");
+    expect(rotatedContent).toContain("rotation");
+  });
+});

package/src/__tests__/tool-executor.test.ts

@@ -0,0 +1,141 @@
+import { test, expect, describe, beforeEach } from "bun:test";
+import { executeToolCalls } from "../agent/tool-executor.ts";
+import { ToolRegistry } from "../tools/registry.ts";
+import type { Tool, ToolContext } from "../tools/types.ts";
+import type { ToolCall } from "../providers/types.ts";
+
+function makeTool(name: string, concurrencySafe: boolean, result = "ok"): Tool {
+  return {
+    name,
+    prompt: () => `Tool ${name}`,
+    inputSchema: () => ({ type: "object", properties: {} }),
+    isReadOnly: () => true,
+    isDestructive: () => false,
+    isConcurrencySafe: () => concurrencySafe,
+    validateInput: () => null,
+    call: async () => result,
+  };
+}
+
+function makeToolCall(name: string, id?: string): ToolCall {
+  return { id: id ?? `call_${name}`, name, input: {} };
+}
+
+const ctx: ToolContext = {
+  cwd: "/tmp",
+  requestPermission: async () => true,
+};
+
+describe("executeToolCalls", () => {
+  let registry: ToolRegistry;
+
+  beforeEach(() => {
+    registry = new ToolRegistry();
+  });
+
+  test("returns empty array for no tool calls", async () => {
+    const results = await executeToolCalls([], registry, ctx);
+    expect(results).toEqual([]);
+  });
+
+  test("executes a single tool call", async () => {
+    registry.register(makeTool("Read", true, "file content"));
+    const results = await executeToolCalls(
+      [makeToolCall("Read")],
+      registry,
+      ctx
+    );
+    expect(results).toHaveLength(1);
+    expect(results[0]!.result).toBe("file content");
+    expect(results[0]!.isError).toBe(false);
+    expect(results[0]!.name).toBe("Read");
+  });
+
+  test("runs concurrency-safe tools in parallel", async () => {
+    const startTimes: number[] = [];
+    const makeTimedTool = (name: string): Tool => ({
+      ...makeTool(name, true),
+      call: async () => {
+        startTimes.push(Date.now());
+        await new Promise((r) => setTimeout(r, 50));
+        return `${name} done`;
+      },
+    });
+
+    registry.register(makeTimedTool("A"));
+    registry.register(makeTimedTool("B"));
+
+    const results = await executeToolCalls(
+      [makeToolCall("A"), makeToolCall("B")],
+      registry,
+      ctx
+    );
+
+    expect(results).toHaveLength(2);
+    // Both should have started nearly simultaneously (within 30ms)
+    expect(Math.abs(startTimes[0]! - startTimes[1]!)).toBeLessThan(30);
+  });
+
+  test("runs non-concurrency-safe tools sequentially", async () => {
+    const executionOrder: string[] = [];
+    const makeSeqTool = (name: string): Tool => ({
+      ...makeTool(name, false),
+      call: async () => {
+        executionOrder.push(`${name}_start`);
+        await new Promise((r) => setTimeout(r, 20));
+        executionOrder.push(`${name}_end`);
+        return `${name} done`;
+      },
+    });
+
+    registry.register(makeSeqTool("X"));
+    registry.register(makeSeqTool("Y"));
+
+    await executeToolCalls(
+      [makeToolCall("X"), makeToolCall("Y")],
+      registry,
+      ctx
+    );
+
+    // Sequential: X should finish before Y starts
+    expect(executionOrder).toEqual(["X_start", "X_end", "Y_start", "Y_end"]);
+  });
+
+  test("fires onToolStart and onToolEnd callbacks", async () => {
+    registry.register(makeTool("T", true, "result"));
+
+    const starts: string[] = [];
+    const ends: string[] = [];
+
+    await executeToolCalls([makeToolCall("T")], registry, ctx, {
+      onToolStart: (name) => starts.push(name),
+      onToolEnd: (name) => ends.push(name),
+    });
+
+    expect(starts).toEqual(["T"]);
+    expect(ends).toEqual(["T"]);
+  });
+
+  test("handles errors from tool execution", async () => {
+    registry.register(makeTool("Fail", true));
+    // The tool is registered but executeToolCalls routes through registry.execute,
+    // which catches errors. An unknown tool would return isError.
+    const results = await executeToolCalls(
+      [makeToolCall("Unknown")],
+      registry,
+      ctx
+    );
+    expect(results).toHaveLength(1);
+    expect(results[0]!.isError).toBe(true);
+  });
+
+  test("preserves toolCallId in results", async () => {
+    registry.register(makeTool("R", true));
+    const results = await executeToolCalls(
+      [{ id: "my-custom-id", name: "R", input: {} }],
+      registry,
+      ctx
+    );
+    expect(results[0]!.toolCallId).toBe("my-custom-id");
+  });
+});