@linkedclaw/cli 0.1.3 → 0.1.5

package/test/converge-status.test.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect } from "vitest";
+import { reduceRunState } from "../src/commands/converge.js";
+import type { CommonsLogEvent, RunWorkspace } from "../src/converge/types.js";
+
+const FAKE_WS: RunWorkspace = {
+  runId: "clg_run00000000",
+  sourceDebateId: "dbt_source001",
+  paAgentId: "agt_pa001",
+  targetCorpus: "/corpus",
+  stagingDir: "/corpus/converged/staging/clg_run00000000",
+};
+
+const SAMPLE_EVENTS: CommonsLogEvent[] = [
+  {
+    seq: 1,
+    event_type: "run_started",
+    payload: {},
+    appended_at: "2026-04-30T10:00:00Z",
+    signed_by: "sys",
+  },
+  {
+    seq: 2,
+    event_type: "sub_debate_dispatched",
+    payload: { crux_id: "crux_001", sub_debate_id: "dbt_sub001" },
+    appended_at: "2026-04-30T10:01:00Z",
+    signed_by: "sys",
+  },
+  {
+    seq: 3,
+    event_type: "sub_debate_dispatched",
+    payload: { crux_id: "crux_002", sub_debate_id: "dbt_sub002" },
+    appended_at: "2026-04-30T10:02:00Z",
+    signed_by: "sys",
+  },
+  {
+    seq: 4,
+    event_type: "sub_debate_outcome_observed",
+    payload: { crux_id: "crux_001", outcome: "already_aligned", bilateral_mandate_intact: true },
+    appended_at: "2026-04-30T10:05:00Z",
+    signed_by: "sys",
+  },
+];
+
+describe("reduceRunState", () => {
+  it("extracts started_at from run_started event", () => {
+    const summary = reduceRunState(FAKE_WS, SAMPLE_EVENTS);
+    expect(summary.started_at).toBe("2026-04-30T10:00:00Z");
+  });
+
+  it("owner_b_accepted is false when no event emitted", () => {
+    const summary = reduceRunState(FAKE_WS, SAMPLE_EVENTS);
+    expect(summary.owner_b_accepted).toBe(false);
+  });
+
+  it("owner_b_accepted flips to true when event present", () => {
+    const events: CommonsLogEvent[] = [
+      ...SAMPLE_EVENTS,
+      {
+        seq: 5,
+        event_type: "owner_b_accepted",
+        payload: {},
+        appended_at: "2026-04-30T10:06:00Z",
+        signed_by: "owner_b",
+      },
+    ];
+    const summary = reduceRunState(FAKE_WS, events);
+    expect(summary.owner_b_accepted).toBe(true);
+  });
+
+  it("builds two crux entries from dispatched events", () => {
+    const summary = reduceRunState(FAKE_WS, SAMPLE_EVENTS);
+    expect(summary.cruxes).toHaveLength(2);
+  });
+
+  it("crux_001 has outcome=already_aligned and bilateral_mandate_intact=true", () => {
+    const summary = reduceRunState(FAKE_WS, SAMPLE_EVENTS);
+    const c1 = summary.cruxes.find((c) => c.crux_id === "crux_001");
+    expect(c1).toBeDefined();
+    expect(c1!.outcome).toBe("already_aligned");
+    expect(c1!.bilateral_mandate_intact).toBe(true);
+    expect(c1!.latest_sub_debate_id).toBe("dbt_sub001");
+  });
+
+  it("crux_002 has null outcome (in-progress)", () => {
+    const summary = reduceRunState(FAKE_WS, SAMPLE_EVENTS);
+    const c2 = summary.cruxes.find((c) => c.crux_id === "crux_002");
+    expect(c2).toBeDefined();
+    expect(c2!.outcome).toBeNull();
+    expect(c2!.bilateral_mandate_intact).toBeNull();
+  });
+
+  it("terminal_emitted is false without terminal event", () => {
+    const summary = reduceRunState(FAKE_WS, SAMPLE_EVENTS);
+    expect(summary.terminal_emitted).toBe(false);
+  });
+
+  it("terminal_emitted is true on convergence_map event", () => {
+    const events: CommonsLogEvent[] = [
+      ...SAMPLE_EVENTS,
+      {
+        seq: 6,
+        event_type: "convergence_map",
+        payload: {},
+        appended_at: "2026-04-30T11:00:00Z",
+        signed_by: "sys",
+      },
+    ];
+    const summary = reduceRunState(FAKE_WS, events);
+    expect(summary.terminal_emitted).toBe(true);
+  });
+
+  it("re-dispatch appends to sub_debate_chain and updates latest_sub_debate_id", () => {
+    const events: CommonsLogEvent[] = [
+      ...SAMPLE_EVENTS,
+      {
+        seq: 5,
+        event_type: "sub_debate_dispatched",
+        payload: { crux_id: "crux_001", sub_debate_id: "dbt_sub001b" },
+        appended_at: "2026-04-30T10:07:00Z",
+        signed_by: "sys",
+      },
+    ];
+    const summary = reduceRunState(FAKE_WS, events);
+    const c1 = summary.cruxes.find((c) => c.crux_id === "crux_001")!;
+    expect(c1.latest_sub_debate_id).toBe("dbt_sub001b");
+    expect(c1.sub_debate_chain).toEqual(["dbt_sub001", "dbt_sub001b"]);
+  });
+
+  it("empty event list yields empty cruxes and null started_at", () => {
+    const summary = reduceRunState(FAKE_WS, []);
+    expect(summary.cruxes).toHaveLength(0);
+    expect(summary.started_at).toBeNull();
+    expect(summary.terminal_emitted).toBe(false);
+  });
+
+  it("run_id and source_debate_id come from workspace", () => {
+    const summary = reduceRunState(FAKE_WS, SAMPLE_EVENTS);
+    expect(summary.run_id).toBe(FAKE_WS.runId);
+    expect(summary.source_debate_id).toBe(FAKE_WS.sourceDebateId);
+  });
+});

package/test/converge-workspace.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { resolveWorkspace, writeRunMeta, readRunMeta } from "../src/converge/workspace.js";
+import type { RunMeta } from "../src/converge/types.js";
+
+const SAMPLE_META: RunMeta = {
+  run_id: "clg_aabbccdd11223344",
+  source_debate_id: "dbt_001",
+  pa_agent_id: "agt_pa001",
+  target_corpus: "/corpus/root",
+  owner_role: "a",
+};
+
+let tmp: string;
+
+beforeEach(() => {
+  tmp = mkdtempSync(join(tmpdir(), "lc-ws-test-"));
+});
+
+afterEach(() => {
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+describe("resolveWorkspace", () => {
+  it("returns workspace from --staging-dir with .run-meta.yaml", async () => {
+    writeRunMeta(tmp, SAMPLE_META);
+    const ws = await resolveWorkspace({ stagingDir: tmp });
+    expect(ws.runId).toBe(SAMPLE_META.run_id);
+    expect(ws.sourceDebateId).toBe(SAMPLE_META.source_debate_id);
+    expect(ws.stagingDir).toBe(resolve(tmp));
+  });
+
+  it("searches upward from cwd and finds meta", async () => {
+    writeRunMeta(tmp, SAMPLE_META);
+    const subdir = join(tmp, "sub", "dir");
+    mkdirSync(subdir, { recursive: true });
+    const ws = await resolveWorkspace({ cwd: subdir });
+    expect(ws.runId).toBe(SAMPLE_META.run_id);
+    expect(ws.stagingDir).toBe(tmp);
+  });
+
+  it("throws run_id_mismatch when --run-id conflicts with meta", async () => {
+    writeRunMeta(tmp, SAMPLE_META);
+    await expect(
+      resolveWorkspace({ stagingDir: tmp, runId: "clg_different00000000" }),
+    ).rejects.toMatchObject({ code: "run_id_mismatch" });
+  });
+
+  it("succeeds when --run-id matches meta", async () => {
+    writeRunMeta(tmp, SAMPLE_META);
+    const ws = await resolveWorkspace({ stagingDir: tmp, runId: SAMPLE_META.run_id });
+    expect(ws.runId).toBe(SAMPLE_META.run_id);
+  });
+
+  it("throws meta_not_found when staging-dir has no meta", async () => {
+    await expect(resolveWorkspace({ stagingDir: tmp })).rejects.toMatchObject({
+      code: "meta_not_found",
+    });
+  });
+
+  it("throws meta_not_found with guidance when --run-id given but no meta found", async () => {
+    const empty = mkdtempSync(join(tmpdir(), "lc-empty-"));
+    try {
+      await expect(
+        resolveWorkspace({ runId: "clg_xyz", cwd: empty }),
+      ).rejects.toMatchObject({ code: "meta_not_found" });
+    } finally {
+      rmSync(empty, { recursive: true, force: true });
+    }
+  });
+
+  it("returns absolute paths even when stagingDir is relative concept (resolved from cwd)", async () => {
+    writeRunMeta(tmp, SAMPLE_META);
+    const ws = await resolveWorkspace({ stagingDir: tmp });
+    expect(ws.stagingDir).toMatch(/^\//);
+  });
+});
+
+describe("readRunMeta / writeRunMeta roundtrip", () => {
+  it("roundtrips all fields correctly", () => {
+    writeRunMeta(tmp, SAMPLE_META);
+    const loaded = readRunMeta(tmp);
+    expect(loaded).toEqual(SAMPLE_META);
+  });
+
+  it("returns null when file does not exist", () => {
+    const result = readRunMeta(join(tmp, "nonexistent"));
+    expect(result).toBeNull();
+  });
+});