@axiom-lattice/protocols 3.0.4 → 4.0.1

package/src/__tests__/TaskBeliefProtocol.test.ts

@@ -0,0 +1,421 @@
+import {
+  parseTaskBeliefState,
+  replaceTaskBeliefState,
+  taskBeliefStatesEqual,
+  type TaskBeliefState,
+} from "../TaskBeliefProtocol";
+
+const HEADER = "| Belief Key | Probability | Target | Basis |";
+const SEPARATOR = "|---|---:|---:|---|";
+
+function beliefSection(rows: string[]): string {
+  return ["## Belief State", "", HEADER, SEPARATOR, ...rows].join("\n");
+}
+
+describe("parseTaskBeliefState", () => {
+  it("parses the canonical four-column Belief State", () => {
+    const markdown = [
+      "## Objective",
+      "Ship",
+      "",
+      beliefSection(["| `input-valid` | 60% | 90% | File exists |"]),
+    ].join("\n");
+
+    expect(parseTaskBeliefState(markdown)).toEqual({
+      success: true,
+      state: {
+        entries: [
+          { key: "input-valid", probability: 60, target: 90, basis: "File exists" },
+        ],
+      },
+    });
+  });
+
+  it("accepts escaped pipes in Basis", () => {
+    const result = parseTaskBeliefState(
+      beliefSection(["| `input-valid` | 60% | 90% | JSON parser A \\| B passed |"]),
+    );
+
+    expect(result).toEqual({
+      success: true,
+      state: {
+        entries: [
+          {
+            key: "input-valid",
+            probability: 60,
+            target: 90,
+            basis: "JSON parser A | B passed",
+          },
+        ],
+      },
+    });
+  });
+
+  it("stops the section at an ATX heading with up to three leading spaces", () => {
+    const markdown = [
+      beliefSection(["| `input-valid` | 60% | 90% | File exists |"]),
+      "",
+      "  ## Notes",
+      "This is not a belief row.",
+    ].join("\n");
+
+    expect(parseTaskBeliefState(markdown)).toEqual({
+      success: true,
+      state: {
+        entries: [
+          { key: "input-valid", probability: 60, target: 90, basis: "File exists" },
+        ],
+      },
+    });
+  });
+
+  it("rejects a row whose apparent closing pipe is escaped", () => {
+    const result = parseTaskBeliefState(
+      beliefSection(["| `input-valid` | 60% | 90% | basis \\|"]),
+    );
+
+    expect(result).toMatchObject({
+      success: false,
+      code: "MALFORMED_BELIEF_ROW",
+    });
+  });
+
+  it("parses a Basis ending in a literal pipe followed by a closing delimiter", () => {
+    const result = parseTaskBeliefState(
+      beliefSection(["| `input-valid` | 60% | 90% | basis \\| |"]),
+    );
+
+    expect(result).toEqual({
+      success: true,
+      state: {
+        entries: [
+          { key: "input-valid", probability: 60, target: 90, basis: "basis |" },
+        ],
+      },
+    });
+  });
+
+  it("ignores a fake section inside a code fence", () => {
+    const markdown = [
+      "```markdown",
+      beliefSection(["| `fake-key` | 1% | 2% | fake |"]),
+      "```",
+      "",
+      beliefSection(["| `real-key` | 40% | 80% | observed |"]),
+    ].join("\n");
+
+    expect(parseTaskBeliefState(markdown)).toMatchObject({
+      success: true,
+      state: { entries: [{ key: "real-key" }] },
+    });
+  });
+
+  it.each([
+    ["backtick", "```markdown", "```not-a-close", "```"],
+    ["tilde", "~~~markdown", "~~~not-a-close", "~~~"],
+  ])("keeps headings fenced after a malformed %s close candidate", (_, opener, malformedClose, close) => {
+    const markdown = [
+      opener,
+      malformedClose,
+      beliefSection(["| `fake-key` | 1% | 2% | fake |"]),
+      close,
+    ].join("\n");
+
+    expect(parseTaskBeliefState(markdown)).toMatchObject({
+      success: false,
+      code: "MISSING_BELIEF_STATE",
+    });
+  });
+
+  it("reports a missing non-fenced section", () => {
+    const markdown = [
+      "## Objective",
+      "Ship",
+      "",
+      "~~~markdown",
+      beliefSection(["| `fake-key` | 1% | 2% | fake |"]),
+      "~~~",
+    ].join("\n");
+
+    expect(parseTaskBeliefState(markdown)).toMatchObject({
+      success: false,
+      code: "MISSING_BELIEF_STATE",
+    });
+  });
+
+  it("reports duplicate non-fenced sections", () => {
+    const markdown = [
+      beliefSection(["| `first-key` | 10% | 90% | first |"]),
+      "",
+      beliefSection(["| `second-key` | 20% | 90% | second |"]),
+    ].join("\n");
+
+    expect(parseTaskBeliefState(markdown)).toMatchObject({
+      success: false,
+      code: "DUPLICATE_BELIEF_STATE",
+    });
+  });
+
+  it("reports duplicate keys", () => {
+    const result = parseTaskBeliefState(
+      beliefSection([
+        "| `same-key` | 10% | 90% | one |",
+        "| `same-key` | 20% | 90% | two |",
+      ]),
+    );
+
+    expect(result).toMatchObject({
+      success: false,
+      code: "DUPLICATE_BELIEF_KEY",
+      key: "same-key",
+    });
+  });
+
+  it("reports localized or reordered headers", () => {
+    const markdown = [
+      "## Belief State",
+      "",
+      "| Belief Key | Target | Probability | Basis |",
+      SEPARATOR,
+      "| `input-valid` | 90% | 60% | exists |",
+    ].join("\n");
+
+    expect(parseTaskBeliefState(markdown)).toMatchObject({
+      success: false,
+      code: "INVALID_BELIEF_HEADERS",
+    });
+  });
+
+  it.each(["60.5%", "-1%", "101%", "60", " 60 % "])(
+    "reports malformed probability %s",
+    (probability) => {
+      const result = parseTaskBeliefState(
+        beliefSection([`| \`input-valid\` | ${probability} | 90% | exists |`]),
+      );
+
+      expect(result).toMatchObject({
+        success: false,
+        code: "INVALID_BELIEF_PERCENT",
+        column: "probability",
+      });
+    },
+  );
+
+  it("reports malformed target percentages", () => {
+    const result = parseTaskBeliefState(
+      beliefSection(["| `input-valid` | 60% | nope | exists |"]),
+    );
+
+    expect(result).toMatchObject({
+      success: false,
+      code: "INVALID_BELIEF_PERCENT",
+      column: "target",
+    });
+  });
+
+  it.each(["input-valid", "`Input-valid`", "`input_valid`", "`-input-valid`"]) (
+    "reports malformed belief key %s",
+    (key) => {
+      const result = parseTaskBeliefState(
+        beliefSection([`| ${key} | 60% | 90% | exists |`]),
+      );
+
+      expect(result).toMatchObject({
+        success: false,
+        code: "INVALID_BELIEF_KEY",
+      });
+    },
+  );
+
+  it("reports malformed rows", () => {
+    const result = parseTaskBeliefState(
+      beliefSection(["| `input-valid` | 60% | 90% | basis | extra |"]),
+    );
+
+    expect(result).toMatchObject({
+      success: false,
+      code: "MALFORMED_BELIEF_ROW",
+    });
+  });
+});
+
+describe("taskBeliefStatesEqual", () => {
+  it("ignores row order and insignificant whitespace", () => {
+    const left: TaskBeliefState = {
+      entries: [
+        { key: "alpha-ready", probability: 20, target: 80, basis: " first  observation " },
+        { key: "beta-ready", probability: 30, target: 90, basis: "line one\n  line two" },
+      ],
+    };
+    const right: TaskBeliefState = {
+      entries: [
+        { key: "beta-ready", probability: 30, target: 90, basis: "line one line two" },
+        { key: "alpha-ready", probability: 20, target: 80, basis: "first observation" },
+      ],
+    };
+
+    expect(taskBeliefStatesEqual(left, right)).toBe(true);
+  });
+
+  it.each(["probability", "target", "basis"] as const)("compares %s", (field) => {
+    const left: TaskBeliefState = {
+      entries: [{ key: "input-valid", probability: 60, target: 90, basis: "exists" }],
+    };
+    const changed = {
+      probability: 61,
+      target: 91,
+      basis: "verified",
+    }[field];
+    const right: TaskBeliefState = {
+      entries: [{ ...left.entries[0], [field]: changed }],
+    };
+
+    expect(taskBeliefStatesEqual(left, right)).toBe(false);
+  });
+});
+
+describe("replaceTaskBeliefState", () => {
+  const replacement: TaskBeliefState = {
+    entries: [
+      { key: "input-valid", probability: 75, target: 90, basis: "A | B verified" },
+    ],
+  };
+
+  it.each([
+    ["literal pipe", "|", "\\|"],
+    ["backslash before pipe", "\\|", "\\\\\\|"],
+    ["trailing backslash and pipe", "evidence \\|", "evidence \\\\\\|"],
+    ["multiple backslashes before pipe", "\\\\|", "\\\\\\\\\\|"],
+    ["plain backslash", "path\\segment", "path\\\\segment"],
+  ])("round-trips a Basis containing %s", (_, basis, escapedBasis) => {
+    const state: TaskBeliefState = {
+      entries: [{ key: "input-valid", probability: 75, target: 90, basis }],
+    };
+
+    const replaced = replaceTaskBeliefState("# Task", state);
+    expect(replaced).toContain(`| \`input-valid\` | 75% | 90% | ${escapedBasis} |`);
+
+    const parsed = parseTaskBeliefState(replaced);
+    expect(parsed.success).toBe(true);
+    if (parsed.success) {
+      expect(taskBeliefStatesEqual(parsed.state, state)).toBe(true);
+    }
+  });
+
+  it("replaces only the existing Belief State section", () => {
+    const before = [
+      "# Task",
+      "",
+      "## Objective",
+      "Keep this text exactly.  ",
+      "",
+      beliefSection(["| `old-key` | 10% | 80% | old |"]),
+      "",
+      "## Acceptance Criteria",
+      "- [ ] Preserve this | text",
+      "",
+    ].join("\n");
+
+    const replaced = replaceTaskBeliefState(before, replacement);
+
+    expect(replaced).toBe([
+      "# Task",
+      "",
+      "## Objective",
+      "Keep this text exactly.  ",
+      "",
+      beliefSection(["| `input-valid` | 75% | 90% | A \\| B verified |"]),
+      "",
+      "## Acceptance Criteria",
+      "- [ ] Preserve this | text",
+      "",
+    ].join("\n"));
+  });
+
+  it("preserves a following ATX heading with leading spaces", () => {
+    const before = [
+      beliefSection(["| `old-key` | 10% | 80% | old |"]),
+      "",
+      "  ## Notes",
+      "Keep this text exactly.",
+    ].join("\n");
+
+    expect(replaceTaskBeliefState(before, replacement)).toBe([
+      beliefSection(["| `input-valid` | 75% | 90% | A \\| B verified |"]),
+      "",
+      "  ## Notes",
+      "Keep this text exactly.",
+    ].join("\n"));
+  });
+
+  it("inserts after Acceptance Criteria content and before the next section", () => {
+    const before = [
+      "## Objective",
+      "Ship",
+      "",
+      "## Acceptance Criteria",
+      "- [ ] Tests pass",
+      "",
+      "## Notes",
+      "Do not damage this text.",
+    ].join("\n");
+
+    expect(replaceTaskBeliefState(before, replacement)).toBe([
+      "## Objective",
+      "Ship",
+      "",
+      "## Acceptance Criteria",
+      "- [ ] Tests pass",
+      "",
+      beliefSection(["| `input-valid` | 75% | 90% | A \\| B verified |"]),
+      "",
+      "## Notes",
+      "Do not damage this text.",
+    ].join("\n"));
+  });
+
+  it("inserts at the end when Acceptance Criteria is the final section", () => {
+    const before = "## Acceptance Criteria\n\n- [ ] Tests pass\n";
+
+    expect(replaceTaskBeliefState(before, replacement)).toBe(
+      `${before}\n${beliefSection(["| `input-valid` | 75% | 90% | A \\| B verified |"])}`,
+    );
+  });
+
+  it.each(["Input-valid", "`input-valid`", "input_valid", "input-valid\nextra"])(
+    "rejects invalid state key %j",
+    (key) => {
+      expect(() => replaceTaskBeliefState("", {
+        entries: [{ ...replacement.entries[0], key }],
+      })).toThrow("Belief keys must be kebab-case without backticks or newlines.");
+    },
+  );
+
+  it.each([
+    ["probability", 60.5],
+    ["probability", -1],
+    ["probability", 101],
+    ["target", 90.5],
+    ["target", -1],
+    ["target", 101],
+  ] as const)("rejects invalid state %s %s", (field, value) => {
+    expect(() => replaceTaskBeliefState("", {
+      entries: [{ ...replacement.entries[0], [field]: value }],
+    })).toThrow(`Belief ${field} must be an integer from 0 to 100.`);
+  });
+
+  it.each(["", "   ", "line one\nline two", "line one\rline two"])(
+    "rejects blank or multiline state basis %j",
+    (basis) => {
+      expect(() => replaceTaskBeliefState("", {
+        entries: [{ ...replacement.entries[0], basis }],
+      })).toThrow("Belief basis must be a nonempty single line.");
+    },
+  );
+
+  it("rejects duplicate state keys", () => {
+    expect(() => replaceTaskBeliefState("", {
+      entries: [replacement.entries[0], { ...replacement.entries[0], probability: 80 }],
+    })).toThrow("Belief key 'input-valid' appears more than once.");
+  });
+});

package/src/__tests__/a2a-types.test.ts

@@ -0,0 +1,30 @@
+import type { TaskFileRef, CreateTaskRequest } from "../TaskStoreProtocol";
+import type { A2AApiKeyRecord, CreateA2AApiKeyInput } from "../A2AApiKeyStoreProtocol";
+import type { A2AExposure } from "../A2AProtocol";
+
+describe("A2A protocol types", () => {
+  it("TaskFileRef supports mimeType", () => {
+    const ref: TaskFileRef = { uri: "/project/uploads/a.pdf", name: "a.pdf", mimeType: "application/pdf", addedBy: "user" };
+    expect(ref.mimeType).toBe("application/pdf");
+  });
+
+  it("CreateTaskRequest supports caller-provided id", () => {
+    const req: CreateTaskRequest = { id: "a2a-task-1", title: "t" };
+    expect(req.id).toBe("a2a-task-1");
+  });
+
+  it("A2A key model requires projectId and supports assistantIds, no workspaceId", () => {
+    const input: CreateA2AApiKeyInput = { tenantId: "t1", projectId: "p1", assistantIds: ["a1"], label: "l" };
+    expect(input.projectId).toBe("p1");
+    const rec: A2AApiKeyRecord = {
+      id: "k1", key: "a2a_x", tenantId: "t1", projectId: "p1",
+      assistantIds: ["a1"], enabled: true, createdAt: new Date(), updatedAt: new Date(),
+    };
+    expect("workspaceId" in rec).toBe(false);
+  });
+
+  it("A2AExposure shape", () => {
+    const exp: A2AExposure = { enabled: true, skills: [{ id: "s", name: "n", description: "d" }] };
+    expect(exp.enabled).toBe(true);
+  });
+});