@creativeintelligence/abbie 0.1.0

package/src/lib/agent-trace.test.ts

@@ -0,0 +1,296 @@
+import { describe, expect, it } from "bun:test";
+import { execSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  type AbbieSessionData,
+  type AgentTrace,
+  mapToAgentTrace,
+  validateAgentTrace,
+} from "./agent-trace";
+
+const baseSession: AbbieSessionData = {
+  sessionId: "abbie-20260206-123456-abc1",
+  agent: "claude",
+  project: "arbor",
+  status: "completed",
+  startedAt: "2026-02-06T10:00:00Z",
+  endedAt: "2026-02-06T10:30:00Z",
+  traceId: "tr_a1b2c3d4e5f6a1b2c3d4e5f6",
+  issue: "ARBOR-123",
+  branch: "feat/auth",
+  commits: ["abc1234", "def5678"],
+  filesModified: ["src/auth/login.ts", "src/auth/logout.ts"],
+  model: "anthropic/claude-opus-4-6",
+};
+
+describe("mapToAgentTrace", () => {
+  it("produces a valid Agent Trace v0.1 record", () => {
+    const trace = mapToAgentTrace(baseSession);
+
+    expect(trace.version).toBe("0.1.0");
+    expect(typeof trace.id).toBe("string");
+    expect(trace.id.length).toBeGreaterThan(0);
+    expect(trace.timestamp).toBe("2026-02-06T10:30:00Z");
+    expect(trace.files).toHaveLength(2);
+    expect(trace.tool?.name).toBe("abbie");
+    expect(trace.files[0].conversations[0].ranges).toHaveLength(1);
+  });
+
+  it("maps files with correct paths", () => {
+    const trace = mapToAgentTrace(baseSession);
+
+    expect(trace.files[0].path).toBe("src/auth/login.ts");
+    expect(trace.files[1].path).toBe("src/auth/logout.ts");
+  });
+
+  it("maps contributor as AI with model_id", () => {
+    const trace = mapToAgentTrace(baseSession);
+
+    const contributor = trace.files[0].conversations[0].contributor;
+    expect(contributor.type).toBe("ai");
+    expect(contributor.model_id).toBe("anthropic/claude-opus-4-6");
+  });
+
+  it("omits model_id when not available", () => {
+    const session = { ...baseSession, model: undefined };
+    const trace = mapToAgentTrace(session);
+
+    const contributor = trace.files[0].conversations[0].contributor;
+    expect(contributor.type).toBe("ai");
+    expect(contributor.model_id).toBeUndefined();
+  });
+
+  it("includes Abbie metadata fields", () => {
+    const trace = mapToAgentTrace(baseSession);
+
+    expect(trace.metadata?.["abbie:session_id"]).toBe("abbie-20260206-123456-abc1");
+    expect(trace.metadata?.["abbie:agent"]).toBe("claude");
+    expect(trace.metadata?.["abbie:project"]).toBe("arbor");
+    expect(trace.metadata?.["abbie:trace_id"]).toBe("tr_a1b2c3d4e5f6a1b2c3d4e5f6");
+    expect(trace.metadata?.["abbie:issue"]).toBe("ARBOR-123");
+    expect(trace.metadata?.["abbie:branch"]).toBe("feat/auth");
+    expect(trace.metadata?.["abbie:commits"]).toEqual(["abc1234", "def5678"]);
+  });
+
+  it("includes Braintrust linkage when traceUrl present", () => {
+    const session = { ...baseSession, traceUrl: "https://braintrust.dev/traces/xyz" };
+    const trace = mapToAgentTrace(session);
+
+    expect(trace.metadata?.["braintrust:trace_url"]).toBe("https://braintrust.dev/traces/xyz");
+  });
+
+  it("handles empty filesModified gracefully", () => {
+    const session = { ...baseSession, filesModified: [] };
+    const trace = mapToAgentTrace(session);
+
+    expect(trace.files).toHaveLength(0);
+  });
+
+  it("handles undefined filesModified gracefully", () => {
+    const session = { ...baseSession, filesModified: undefined };
+    const trace = mapToAgentTrace(session);
+
+    expect(trace.files).toHaveLength(0);
+  });
+
+  it("uses startedAt as timestamp fallback", () => {
+    const session = { ...baseSession, endedAt: null };
+    const trace = mapToAgentTrace(session);
+
+    expect(trace.timestamp).toBe("2026-02-06T10:00:00Z");
+  });
+
+  it("passes self-validation", () => {
+    const trace = mapToAgentTrace(baseSession);
+    const errors = validateAgentTrace(trace);
+
+    expect(errors).toHaveLength(0);
+  });
+
+  it("uses diff-derived ranges with content hashes when git metadata is available", () => {
+    const repoRoot = mkdtempSync(join(tmpdir(), "abbie-agent-trace-"));
+
+    try {
+      execSync("git init", { cwd: repoRoot, stdio: "ignore" });
+      execSync('git config user.email "test@example.com"', { cwd: repoRoot, stdio: "ignore" });
+      execSync('git config user.name "Test User"', { cwd: repoRoot, stdio: "ignore" });
+
+      mkdirSync(join(repoRoot, "src"), { recursive: true });
+      const relativePath = "src/diff.ts";
+      const absolutePath = join(repoRoot, relativePath);
+
+      writeFileSync(
+        absolutePath,
+        ["const a = 1;", "const b = 2;", "const c = 3;", ""].join("\n"),
+        "utf-8",
+      );
+      execSync(`git add ${relativePath}`, { cwd: repoRoot, stdio: "ignore" });
+      execSync('git commit -m "init"', { cwd: repoRoot, stdio: "ignore" });
+
+      writeFileSync(
+        absolutePath,
+        ["const a = 1;", "const b = 22;", "const c = 3;", "const d = 4;", ""].join("\n"),
+        "utf-8",
+      );
+
+      const trace = mapToAgentTrace({
+        ...baseSession,
+        cwd: repoRoot,
+        filesModified: [relativePath],
+      });
+      const ranges = trace.files[0].conversations[0].ranges;
+
+      expect(ranges.length).toBeGreaterThan(0);
+      expect(ranges.some((range) => range.start_line === 2)).toBe(true);
+      expect(ranges.every((range) => range.start_line >= 2)).toBe(true);
+
+      for (const range of ranges) {
+        expect(range.end_line).toBeGreaterThanOrEqual(range.start_line);
+        expect(range.content_hash).toBeDefined();
+        expect(range.content_hash?.length).toBe(64);
+      }
+    } finally {
+      rmSync(repoRoot, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("validateAgentTrace", () => {
+  it("accepts a valid trace", () => {
+    const trace: AgentTrace = {
+      version: "0.1.0",
+      id: "550e8400-e29b-41d4-a716-446655440000",
+      timestamp: "2026-02-06T10:00:00Z",
+      files: [
+        {
+          path: "src/index.ts",
+          conversations: [
+            {
+              contributor: { type: "ai" },
+              ranges: [{ start_line: 1, end_line: 2 }],
+            },
+          ],
+        },
+      ],
+    };
+    expect(validateAgentTrace(trace)).toHaveLength(0);
+  });
+
+  it("rejects non-object input", () => {
+    expect(validateAgentTrace("string")).toContain("Root must be a JSON object");
+    expect(validateAgentTrace(null)).toContain("Root must be a JSON object");
+    expect(validateAgentTrace([])).toContain("Root must be a JSON object");
+  });
+
+  it("rejects missing version", () => {
+    const errors = validateAgentTrace({ id: "x", timestamp: "2026-01-01", files: [] });
+    expect(errors.some((e) => e.includes("version"))).toBe(true);
+  });
+
+  it("rejects wrong version", () => {
+    const errors = validateAgentTrace({
+      version: "2.0.0",
+      id: "x",
+      timestamp: "2026-01-01",
+      files: [],
+    });
+    expect(errors.some((e) => e.includes("Unsupported version"))).toBe(true);
+  });
+
+  it("rejects missing id", () => {
+    const errors = validateAgentTrace({
+      version: "0.1.0",
+      timestamp: "2026-01-01",
+      files: [],
+    });
+    expect(errors.some((e) => e.includes("id"))).toBe(true);
+  });
+
+  it("rejects invalid timestamp", () => {
+    const errors = validateAgentTrace({
+      version: "0.1.0",
+      id: "x",
+      timestamp: "not-a-date",
+      files: [],
+    });
+    expect(errors.some((e) => e.includes("timestamp"))).toBe(true);
+  });
+
+  it("rejects files with missing path", () => {
+    const errors = validateAgentTrace({
+      version: "0.1.0",
+      id: "x",
+      timestamp: "2026-01-01",
+      files: [
+        {
+          conversations: [
+            { contributor: { type: "ai" }, ranges: [{ start_line: 1, end_line: 1 }] },
+          ],
+        },
+      ],
+    });
+    expect(errors.some((e) => e.includes("path"))).toBe(true);
+  });
+
+  it("rejects invalid contributor type", () => {
+    const errors = validateAgentTrace({
+      version: "0.1.0",
+      id: "x",
+      timestamp: "2026-01-01",
+      files: [
+        {
+          path: "a.ts",
+          conversations: [
+            { contributor: { type: "robot" }, ranges: [{ start_line: 1, end_line: 1 }] },
+          ],
+        },
+      ],
+    });
+    expect(errors.some((e) => e.includes("contributor.type"))).toBe(true);
+  });
+
+  it("rejects missing ranges", () => {
+    const errors = validateAgentTrace({
+      version: "0.1.0",
+      id: "550e8400-e29b-41d4-a716-446655440000",
+      timestamp: "2026-01-01",
+      files: [{ path: "a.ts", conversations: [{ contributor: { type: "ai" } }] }],
+    });
+    expect(errors.some((e) => e.includes("ranges"))).toBe(true);
+  });
+
+  it("rejects malformed related entries", () => {
+    const errors = validateAgentTrace({
+      version: "0.1.0",
+      id: "550e8400-e29b-41d4-a716-446655440000",
+      timestamp: "2026-01-01",
+      files: [
+        {
+          path: "a.ts",
+          conversations: [
+            {
+              contributor: { type: "ai" },
+              ranges: [{ start_line: 1, end_line: 1 }],
+              related: [{ type: "trace", url: "not-a-url" }],
+            },
+          ],
+        },
+      ],
+    });
+    expect(errors.some((e) => e.includes("related"))).toBe(true);
+  });
+
+  it("validates optional vcs field", () => {
+    const errors = validateAgentTrace({
+      version: "0.1.0",
+      id: "x",
+      timestamp: "2026-01-01",
+      files: [],
+      vcs: { type: "cvs", revision: "abc" },
+    });
+    expect(errors.some((e) => e.includes("vcs.type"))).toBe(true);
+  });
+});