@calltelemetry/openclaw-linear 0.5.2 → 0.6.1

package/src/pipeline/dispatch-state.test.ts

@@ -0,0 +1,382 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  readDispatchState,
+  registerDispatch,
+  transitionDispatch,
+  completeDispatch,
+  updateDispatchStatus,
+  getActiveDispatch,
+  listActiveDispatches,
+  listStaleDispatches,
+  listRecoverableDispatches,
+  registerSessionMapping,
+  lookupSessionMapping,
+  removeSessionMapping,
+  markEventProcessed,
+  pruneCompleted,
+  removeActiveDispatch,
+  TransitionError,
+  type ActiveDispatch,
+} from "./dispatch-state.js";
+
+function tmpStatePath(): string {
+  const dir = mkdtempSync(join(tmpdir(), "claw-ds-"));
+  return join(dir, "state.json");
+}
+
+function makeDispatch(overrides?: Partial<ActiveDispatch>): ActiveDispatch {
+  return {
+    issueId: "uuid-1",
+    issueIdentifier: "API-100",
+    worktreePath: "/tmp/wt/API-100",
+    branch: "codex/API-100",
+    tier: "junior",
+    model: "test-model",
+    status: "dispatched",
+    dispatchedAt: new Date().toISOString(),
+    attempt: 0,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Read / Register
+// ---------------------------------------------------------------------------
+
+describe("readDispatchState", () => {
+  it("returns empty state when file missing", async () => {
+    const p = tmpStatePath();
+    const state = await readDispatchState(p);
+    expect(state.dispatches.active).toEqual({});
+    expect(state.dispatches.completed).toEqual({});
+    expect(state.sessionMap).toEqual({});
+    expect(state.processedEvents).toEqual([]);
+  });
+});
+
+describe("registerDispatch", () => {
+  it("registers and reads back", async () => {
+    const p = tmpStatePath();
+    const d = makeDispatch();
+    await registerDispatch("API-100", d, p);
+    const state = await readDispatchState(p);
+    const active = getActiveDispatch(state, "API-100");
+    expect(active).not.toBeNull();
+    expect(active!.issueIdentifier).toBe("API-100");
+    expect(active!.attempt).toBe(0);
+  });
+
+  it("sets attempt=0 default", async () => {
+    const p = tmpStatePath();
+    const d = makeDispatch();
+    (d as any).attempt = undefined;
+    await registerDispatch("API-100", d, p);
+    const state = await readDispatchState(p);
+    expect(getActiveDispatch(state, "API-100")!.attempt).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// CAS transitions
+// ---------------------------------------------------------------------------
+
+describe("transitionDispatch", () => {
+  it("dispatched → working", async () => {
+    const p = tmpStatePath();
+    await registerDispatch("API-100", makeDispatch(), p);
+    const updated = await transitionDispatch("API-100", "dispatched", "working", undefined, p);
+    expect(updated.status).toBe("working");
+  });
+
+  it("working → auditing", async () => {
+    const p = tmpStatePath();
+    await registerDispatch("API-100", makeDispatch({ status: "working" }), p);
+    const updated = await transitionDispatch("API-100", "working", "auditing", undefined, p);
+    expect(updated.status).toBe("auditing");
+  });
+
+  it("auditing → done", async () => {
+    const p = tmpStatePath();
+    await registerDispatch("API-100", makeDispatch({ status: "auditing" }), p);
+    const updated = await transitionDispatch("API-100", "auditing", "done", undefined, p);
+    expect(updated.status).toBe("done");
+  });
+
+  it("auditing → working (rework) with attempt update", async () => {
+    const p = tmpStatePath();
+    await registerDispatch("API-100", makeDispatch({ status: "auditing", attempt: 0 }), p);
+    const updated = await transitionDispatch("API-100", "auditing", "working", { attempt: 1 }, p);
+    expect(updated.status).toBe("working");
+    expect(updated.attempt).toBe(1);
+  });
+
+  it("throws TransitionError when fromStatus mismatch", async () => {
+    const p = tmpStatePath();
+    await registerDispatch("API-100", makeDispatch({ status: "working" }), p);
+    await expect(
+      transitionDispatch("API-100", "dispatched", "working", undefined, p),
+    ).rejects.toThrow(TransitionError);
+  });
+
+  it("throws on invalid transition", async () => {
+    const p = tmpStatePath();
+    await registerDispatch("API-100", makeDispatch({ status: "done" }), p);
+    await expect(
+      transitionDispatch("API-100", "done", "working", undefined, p),
+    ).rejects.toThrow();
+  });
+
+  it("throws when dispatch missing", async () => {
+    const p = tmpStatePath();
+    await expect(
+      transitionDispatch("MISSING-1", "dispatched", "working", undefined, p),
+    ).rejects.toThrow("No active dispatch");
+  });
+
+  it("applies stuckReason", async () => {
+    const p = tmpStatePath();
+    await registerDispatch("API-100", makeDispatch({ status: "working" }), p);
+    const updated = await transitionDispatch(
+      "API-100", "working", "stuck", { stuckReason: "watchdog_kill_2x" }, p,
+    );
+    expect(updated.status).toBe("stuck");
+    expect(updated.stuckReason).toBe("watchdog_kill_2x");
+  });
+
+  it("applies session key updates", async () => {
+    const p = tmpStatePath();
+    await registerDispatch("API-100", makeDispatch({ status: "dispatched" }), p);
+    const updated = await transitionDispatch(
+      "API-100", "dispatched", "working",
+      { workerSessionKey: "sess-w-1" }, p,
+    );
+    expect(updated.workerSessionKey).toBe("sess-w-1");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Session mapping
+// ---------------------------------------------------------------------------
+
+describe("session mapping", () => {
+  it("register + lookup round-trip", async () => {
+    const p = tmpStatePath();
+    await registerSessionMapping("sess-1", {
+      dispatchId: "API-100",
+      phase: "worker",
+      attempt: 0,
+    }, p);
+    const state = await readDispatchState(p);
+    const mapping = lookupSessionMapping(state, "sess-1");
+    expect(mapping).not.toBeNull();
+    expect(mapping!.dispatchId).toBe("API-100");
+    expect(mapping!.phase).toBe("worker");
+  });
+
+  it("lookup returns null for unknown key", async () => {
+    const p = tmpStatePath();
+    const state = await readDispatchState(p);
+    expect(lookupSessionMapping(state, "no-such")).toBeNull();
+  });
+
+  it("removeSessionMapping deletes", async () => {
+    const p = tmpStatePath();
+    await registerSessionMapping("sess-1", {
+      dispatchId: "API-100",
+      phase: "worker",
+      attempt: 0,
+    }, p);
+    await removeSessionMapping("sess-1", p);
+    const state = await readDispatchState(p);
+    expect(lookupSessionMapping(state, "sess-1")).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Idempotency
+// ---------------------------------------------------------------------------
+
+describe("markEventProcessed", () => {
+  it("returns true (new) first call", async () => {
+    const p = tmpStatePath();
+    const isNew = await markEventProcessed("evt-1", p);
+    expect(isNew).toBe(true);
+  });
+
+  it("returns false (dupe) second call", async () => {
+    const p = tmpStatePath();
+    await markEventProcessed("evt-1", p);
+    const isDupe = await markEventProcessed("evt-1", p);
+    expect(isDupe).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Complete dispatch
+// ---------------------------------------------------------------------------
+
+describe("completeDispatch", () => {
+  it("moves active → completed", async () => {
+    const p = tmpStatePath();
+    await registerDispatch("API-100", makeDispatch(), p);
+    await completeDispatch("API-100", {
+      tier: "junior",
+      status: "done",
+      completedAt: new Date().toISOString(),
+    }, p);
+    const state = await readDispatchState(p);
+    expect(getActiveDispatch(state, "API-100")).toBeNull();
+    expect(state.dispatches.completed["API-100"]).toBeDefined();
+    expect(state.dispatches.completed["API-100"].status).toBe("done");
+  });
+
+  it("cleans up session mappings for the dispatch", async () => {
+    const p = tmpStatePath();
+    await registerDispatch("API-100", makeDispatch(), p);
+    await registerSessionMapping("sess-w", { dispatchId: "API-100", phase: "worker", attempt: 0 }, p);
+    await registerSessionMapping("sess-a", { dispatchId: "API-100", phase: "audit", attempt: 0 }, p);
+    await completeDispatch("API-100", {
+      tier: "junior",
+      status: "done",
+      completedAt: new Date().toISOString(),
+    }, p);
+    const state = await readDispatchState(p);
+    expect(lookupSessionMapping(state, "sess-w")).toBeNull();
+    expect(lookupSessionMapping(state, "sess-a")).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// List helpers
+// ---------------------------------------------------------------------------
+
+describe("listStaleDispatches", () => {
+  it("returns old dispatches", async () => {
+    const p = tmpStatePath();
+    const oldDate = new Date(Date.now() - 3 * 60 * 60_000).toISOString(); // 3 hours ago
+    await registerDispatch("OLD-1", makeDispatch({
+      issueIdentifier: "OLD-1",
+      dispatchedAt: oldDate,
+    }), p);
+    const state = await readDispatchState(p);
+    const stale = listStaleDispatches(state, 2 * 60 * 60_000); // 2h threshold
+    expect(stale).toHaveLength(1);
+    expect(stale[0].issueIdentifier).toBe("OLD-1");
+  });
+
+  it("excludes recent dispatches", async () => {
+    const p = tmpStatePath();
+    await registerDispatch("NEW-1", makeDispatch({ issueIdentifier: "NEW-1" }), p);
+    const state = await readDispatchState(p);
+    const stale = listStaleDispatches(state, 2 * 60 * 60_000);
+    expect(stale).toHaveLength(0);
+  });
+});
+
+describe("listRecoverableDispatches", () => {
+  it("returns working + workerKey - no auditKey", async () => {
+    const p = tmpStatePath();
+    await registerDispatch("REC-1", makeDispatch({
+      issueIdentifier: "REC-1",
+      status: "working",
+      workerSessionKey: "sess-w",
+    }), p);
+    const state = await readDispatchState(p);
+    const rec = listRecoverableDispatches(state);
+    expect(rec).toHaveLength(1);
+  });
+
+  it("excludes dispatches with auditKey", async () => {
+    const p = tmpStatePath();
+    await registerDispatch("REC-2", makeDispatch({
+      issueIdentifier: "REC-2",
+      status: "working",
+      workerSessionKey: "sess-w",
+      auditSessionKey: "sess-a",
+    }), p);
+    const state = await readDispatchState(p);
+    expect(listRecoverableDispatches(state)).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Prune completed
+// ---------------------------------------------------------------------------
+
+describe("pruneCompleted", () => {
+  it("removes old entries", async () => {
+    const p = tmpStatePath();
+    await registerDispatch("DONE-1", makeDispatch({ issueIdentifier: "DONE-1" }), p);
+    await completeDispatch("DONE-1", {
+      tier: "junior",
+      status: "done",
+      completedAt: new Date(Date.now() - 2 * 24 * 60 * 60_000).toISOString(), // 2 days ago
+    }, p);
+    const pruned = await pruneCompleted(24 * 60 * 60_000, p); // 1 day threshold
+    expect(pruned).toBe(1);
+  });
+
+  it("preserves recent entries", async () => {
+    const p = tmpStatePath();
+    await registerDispatch("DONE-2", makeDispatch({ issueIdentifier: "DONE-2" }), p);
+    await completeDispatch("DONE-2", {
+      tier: "junior",
+      status: "done",
+      completedAt: new Date().toISOString(),
+    }, p);
+    const pruned = await pruneCompleted(24 * 60 * 60_000, p);
+    expect(pruned).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Migration
+// ---------------------------------------------------------------------------
+
+describe("migration", () => {
+  it("adds missing sessionMap and processedEvents", async () => {
+    const p = tmpStatePath();
+    // Write v1 state with no v2 fields
+    writeFileSync(p, JSON.stringify({
+      dispatches: {
+        active: { "X-1": makeDispatch({ issueIdentifier: "X-1" }) },
+        completed: {},
+      },
+    }), "utf-8");
+    const state = await readDispatchState(p);
+    expect(state.sessionMap).toEqual({});
+    expect(state.processedEvents).toEqual([]);
+  });
+
+  it('migrates "running" → "working"', async () => {
+    const p = tmpStatePath();
+    const d = makeDispatch({ issueIdentifier: "X-2" });
+    (d as any).status = "running"; // old v1 status
+    writeFileSync(p, JSON.stringify({
+      dispatches: { active: { "X-2": d }, completed: {} },
+      sessionMap: {},
+      processedEvents: [],
+    }), "utf-8");
+    const state = await readDispatchState(p);
+    expect(getActiveDispatch(state, "X-2")!.status).toBe("working");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Remove active dispatch
+// ---------------------------------------------------------------------------
+
+describe("removeActiveDispatch", () => {
+  it("removes dispatch and cleans session mappings", async () => {
+    const p = tmpStatePath();
+    await registerDispatch("RM-1", makeDispatch({ issueIdentifier: "RM-1" }), p);
+    await registerSessionMapping("sess-rm", { dispatchId: "RM-1", phase: "worker", attempt: 0 }, p);
+    await removeActiveDispatch("RM-1", p);
+    const state = await readDispatchState(p);
+    expect(getActiveDispatch(state, "RM-1")).toBeNull();
+    expect(lookupSessionMapping(state, "sess-rm")).toBeNull();
+  });
+});

package/src/pipeline/pipeline.test.ts

@@ -0,0 +1,226 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+// Mock all heavy dependencies to isolate pure functions
+vi.mock("../agent/agent.js", () => ({ runAgent: vi.fn() }));
+vi.mock("./dispatch-state.js", () => ({
+  transitionDispatch: vi.fn(),
+  registerSessionMapping: vi.fn(),
+  markEventProcessed: vi.fn(),
+  completeDispatch: vi.fn(),
+  readDispatchState: vi.fn(),
+  getActiveDispatch: vi.fn(),
+  TransitionError: class TransitionError extends Error {},
+}));
+vi.mock("./active-session.js", () => ({
+  setActiveSession: vi.fn(),
+  clearActiveSession: vi.fn(),
+}));
+vi.mock("../infra/notify.js", () => ({}));
+vi.mock("./artifacts.js", () => ({
+  saveWorkerOutput: vi.fn(),
+  saveAuditVerdict: vi.fn(),
+  appendLog: vi.fn(),
+  updateManifest: vi.fn(),
+  writeSummary: vi.fn(),
+  buildSummaryFromArtifacts: vi.fn(),
+  writeDispatchMemory: vi.fn(),
+  resolveOrchestratorWorkspace: vi.fn(),
+}));
+vi.mock("../agent/watchdog.js", () => ({
+  resolveWatchdogConfig: vi.fn(() => ({
+    inactivityMs: 120000,
+    maxTotalMs: 7200000,
+    toolTimeoutMs: 600000,
+  })),
+}));
+
+import {
+  parseVerdict,
+  buildWorkerTask,
+  buildAuditTask,
+  loadPrompts,
+  clearPromptCache,
+  type IssueContext,
+} from "./pipeline.js";
+
+// ---------------------------------------------------------------------------
+// parseVerdict
+// ---------------------------------------------------------------------------
+
+describe("parseVerdict", () => {
+  it("parses clean JSON pass=true", () => {
+    const output = '{"pass": true, "criteria": ["tests"], "gaps": [], "testResults": "ok"}';
+    const v = parseVerdict(output)!;
+    expect(v.pass).toBe(true);
+    expect(v.criteria).toEqual(["tests"]);
+    expect(v.gaps).toEqual([]);
+    expect(v.testResults).toBe("ok");
+  });
+
+  it("parses clean JSON pass=false", () => {
+    const output = '{"pass": false, "criteria": [], "gaps": ["missing tests"], "testResults": "none"}';
+    const v = parseVerdict(output)!;
+    expect(v.pass).toBe(false);
+    expect(v.gaps).toEqual(["missing tests"]);
+  });
+
+  it("extracts JSON embedded in prose", () => {
+    const output = `Here is my verdict:
+
+    \`\`\`json
+    {"pass": true, "criteria": ["implemented"], "gaps": [], "testResults": "pass"}
+    \`\`\`
+
+    That's my assessment.`;
+    const v = parseVerdict(output)!;
+    expect(v.pass).toBe(true);
+  });
+
+  it("takes last JSON when multiple present", () => {
+    const output = `
+    {"pass": true, "criteria": [], "gaps": [], "testResults": ""}
+    After review:
+    {"pass": false, "criteria": ["a"], "gaps": ["b"], "testResults": "fail"}
+    `;
+    const v = parseVerdict(output)!;
+    expect(v.pass).toBe(false);
+    expect(v.gaps).toEqual(["b"]);
+  });
+
+  it("returns null for no JSON", () => {
+    expect(parseVerdict("no json here")).toBeNull();
+  });
+
+  it("returns null for malformed JSON", () => {
+    expect(parseVerdict('{"pass": tru')).toBeNull();
+  });
+
+  it("returns null for empty string", () => {
+    expect(parseVerdict("")).toBeNull();
+  });
+
+  it("coerces missing fields to defaults", () => {
+    const output = '{"pass": true}';
+    const v = parseVerdict(output)!;
+    expect(v.pass).toBe(true);
+    expect(v.criteria).toEqual([]);
+    expect(v.gaps).toEqual([]);
+    expect(v.testResults).toBe("");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildWorkerTask
+// ---------------------------------------------------------------------------
+
+describe("buildWorkerTask", () => {
+  const issue: IssueContext = {
+    id: "id-1",
+    identifier: "API-42",
+    title: "Fix auth",
+    description: "The login endpoint fails.",
+  };
+
+  beforeEach(() => {
+    clearPromptCache();
+  });
+
+  it("substitutes template variables", () => {
+    const { system, task } = buildWorkerTask(issue, "/wt/API-42");
+    expect(task).toContain("API-42");
+    expect(task).toContain("Fix auth");
+    expect(task).toContain("The login endpoint fails.");
+    expect(task).toContain("/wt/API-42");
+    expect(system.length).toBeGreaterThan(0);
+  });
+
+  it('uses "(no description)" for null description', () => {
+    const noDesc = { ...issue, description: null };
+    const { task } = buildWorkerTask(noDesc, "/wt/API-42");
+    expect(task).toContain("(no description)");
+  });
+
+  it("appends rework addendum when attempt>0 and gaps present", () => {
+    const { task } = buildWorkerTask(issue, "/wt/API-42", {
+      attempt: 1,
+      gaps: ["missing validation", "no error handling"],
+    });
+    expect(task).toContain("PREVIOUS AUDIT FAILED");
+    expect(task).toContain("missing validation");
+    expect(task).toContain("no error handling");
+  });
+
+  it("no addendum when attempt=0", () => {
+    const { task } = buildWorkerTask(issue, "/wt/API-42", { attempt: 0, gaps: ["gap"] });
+    expect(task).not.toContain("PREVIOUS AUDIT FAILED");
+  });
+
+  it("no addendum when gaps empty", () => {
+    const { task } = buildWorkerTask(issue, "/wt/API-42", { attempt: 1, gaps: [] });
+    expect(task).not.toContain("PREVIOUS AUDIT FAILED");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildAuditTask
+// ---------------------------------------------------------------------------
+
+describe("buildAuditTask", () => {
+  const issue: IssueContext = {
+    id: "id-2",
+    identifier: "API-99",
+    title: "Add caching",
+    description: "Cache API responses.",
+  };
+
+  beforeEach(() => {
+    clearPromptCache();
+  });
+
+  it("substitutes template variables", () => {
+    const { system, task } = buildAuditTask(issue, "/wt/API-99");
+    expect(task).toContain("API-99");
+    expect(task).toContain("Add caching");
+    expect(task).toContain("Cache API responses.");
+    expect(task).toContain("/wt/API-99");
+    expect(system).toContain("auditor");
+  });
+
+  it('uses "(no description)" for null description', () => {
+    const noDesc = { ...issue, description: null };
+    const { task } = buildAuditTask(noDesc, "/wt/API-99");
+    expect(task).toContain("(no description)");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// loadPrompts / clearPromptCache
+// ---------------------------------------------------------------------------
+
+describe("loadPrompts", () => {
+  beforeEach(() => {
+    clearPromptCache();
+  });
+
+  it("returns defaults when no YAML available", () => {
+    const prompts = loadPrompts();
+    expect(prompts.worker.task).toContain("{{identifier}}");
+    expect(prompts.audit.task).toContain("{{identifier}}");
+    expect(prompts.rework.addendum).toContain("PREVIOUS AUDIT FAILED");
+  });
+
+  it("caches (same reference on 2nd call)", () => {
+    const first = loadPrompts();
+    const second = loadPrompts();
+    expect(first).toBe(second);
+  });
+
+  it("clearPromptCache forces re-read", () => {
+    const first = loadPrompts();
+    clearPromptCache();
+    const second = loadPrompts();
+    // Same content but different object ref after cache clear
+    expect(first).not.toBe(second);
+    expect(first).toEqual(second);
+  });
+});