airaknit 1.1.2-rc.9

package/src/server/coordination-integration.test.ts

@@ -0,0 +1,63 @@
+import { describe, test, expect, afterEach } from "bun:test"
+import { EventStore } from "./event-store"
+import { deriveWorkspaceCoordinationSnapshot } from "./read-models"
+import { rmSync, mkdirSync } from "node:fs"
+import { join } from "node:path"
+
+const TEST_DIR = join(import.meta.dir, ".test-coordination-integration")
+
+afterEach(() => {
+  rmSync(TEST_DIR, { recursive: true, force: true })
+})
+
+describe("coordination integration", () => {
+  test("full lifecycle: add todo → claim → complete → read model → compact → replay", async () => {
+    mkdirSync(TEST_DIR, { recursive: true })
+    const store = new EventStore(TEST_DIR)
+    await store.initialize()
+    const project = await store.openProject("/tmp/test-coord-integration", "Test")
+    const workspaceId = project.id
+
+    await store.addTodo(workspaceId, "t-1", "Build feature", "high", "session-a")
+    await store.claimTodo(workspaceId, "t-1", "session-b")
+    await store.completeTodo(workspaceId, "t-1", ["feature.ts"])
+    await store.createClaim(workspaceId, "c-1", "Refactor", ["src/a.ts"], "session-a")
+    await store.setRule(workspaceId, "r-1", "No any types", "user")
+
+    const snapshot = deriveWorkspaceCoordinationSnapshot(store.state, workspaceId)
+    expect(snapshot.todos).toHaveLength(1)
+    expect(snapshot.todos[0].status).toBe("complete")
+    expect(snapshot.claims).toHaveLength(1)
+    expect(snapshot.rules).toHaveLength(1)
+
+    await store.compact()
+
+    const store2 = new EventStore(TEST_DIR)
+    await store2.initialize()
+    const snapshot2 = deriveWorkspaceCoordinationSnapshot(store2.state, workspaceId)
+    expect(snapshot2.todos).toHaveLength(1)
+    expect(snapshot2.todos[0].description).toBe("Build feature")
+    expect(snapshot2.todos[0].status).toBe("complete")
+    expect(snapshot2.claims).toHaveLength(1)
+    expect(snapshot2.claims[0].intent).toBe("Refactor")
+    expect(snapshot2.rules).toHaveLength(1)
+    expect(snapshot2.rules[0].content).toBe("No any types")
+  })
+
+  test("claim conflict detection end-to-end", async () => {
+    mkdirSync(TEST_DIR, { recursive: true })
+    const store = new EventStore(TEST_DIR)
+    await store.initialize()
+    const project = await store.openProject("/tmp/test-coord-conflict", "Test")
+    const workspaceId = project.id
+
+    await store.createClaim(workspaceId, "c-1", "Auth refactor", ["src/auth.ts", "src/middleware.ts"], "s-1")
+    await store.createClaim(workspaceId, "c-2", "Fix middleware", ["src/middleware.ts"], "s-2")
+
+    const snapshot = deriveWorkspaceCoordinationSnapshot(store.state, workspaceId)
+    const conflictClaim = snapshot.claims.find((c) => c.id === "c-2")
+    expect(conflictClaim).toBeDefined()
+    expect(conflictClaim!.status).toBe("conflict")
+    expect(conflictClaim!.conflictsWith).toBe("c-1")
+  })
+})

package/src/server/coordination-mcp.test.ts

@@ -0,0 +1,149 @@
+import { describe, test, expect, afterEach } from "bun:test"
+import { createCoordinationMcpServer } from "./coordination-mcp"
+import { EventStore } from "./event-store"
+import { rmSync, mkdirSync } from "node:fs"
+import { join } from "node:path"
+
+const TEST_DIR = join(import.meta.dir, ".test-coordination-mcp")
+
+function createTestStore() {
+  mkdirSync(TEST_DIR, { recursive: true })
+  return new EventStore(TEST_DIR)
+}
+
+afterEach(() => {
+  rmSync(TEST_DIR, { recursive: true, force: true })
+})
+
+async function createStoreWithProject() {
+  const store = createTestStore()
+  await store.initialize()
+  const project = await store.openProject("/tmp/coord-mcp-test")
+  return { store, workspaceId: project.id }
+}
+
+type ToolRegistry = Record<string, { handler: (args: Record<string, unknown>) => Promise<unknown> }>
+
+function getTools(store: EventStore) {
+  const server = createCoordinationMcpServer(store)
+  return (server.instance as unknown as { _registeredTools: ToolRegistry })._registeredTools
+}
+
+describe("createCoordinationMcpServer", () => {
+  test("registers all 12 coordination tools", async () => {
+    const store = createTestStore()
+    await store.initialize()
+
+    const server = createCoordinationMcpServer(store)
+    const tools = Object.keys(
+      (server.instance as unknown as { _registeredTools: Record<string, unknown> })._registeredTools
+    )
+
+    expect(tools).toEqual([
+      "workspace_todo_add",
+      "workspace_todo_claim",
+      "workspace_todo_complete",
+      "workspace_todo_abandon",
+      "workspace_claim_create",
+      "workspace_claim_release",
+      "workspace_worktree_create",
+      "workspace_worktree_assign",
+      "workspace_worktree_remove",
+      "workspace_rule_set",
+      "workspace_rule_remove",
+      "workspace_snapshot_get",
+    ])
+  })
+})
+
+describe("coordination MCP tool handlers", () => {
+  test("workspace_todo_add creates a todo and returns it", async () => {
+    const { store, workspaceId } = await createStoreWithProject()
+    const tools = getTools(store)
+
+    const result = await tools.workspace_todo_add.handler({
+      workspaceId,
+      description: "Fix the login bug",
+      priority: "high",
+      createdBy: "session-a",
+    }) as { content: Array<{ text: string }> }
+
+    const todo = JSON.parse(result.content[0].text)
+    expect(todo.description).toBe("Fix the login bug")
+    expect(todo.priority).toBe("high")
+    expect(todo.status).toBe("open")
+    expect(todo.createdBy).toBe("session-a")
+    expect(todo.id).toBeDefined()
+  })
+
+  test("workspace_claim_create detects conflicts on overlapping files", async () => {
+    const { store, workspaceId } = await createStoreWithProject()
+    const tools = getTools(store)
+
+    // First claim — no conflict
+    await tools.workspace_claim_create.handler({
+      workspaceId,
+      intent: "Refactor auth",
+      files: ["src/auth.ts", "src/login.ts"],
+      sessionId: "s-1",
+    })
+
+    // Overlapping claim — should detect conflict
+    const conflictResult = await tools.workspace_claim_create.handler({
+      workspaceId,
+      intent: "Fix login",
+      files: ["src/login.ts"],
+      sessionId: "s-2",
+    }) as { content: Array<{ text: string }> }
+
+    const claim = JSON.parse(conflictResult.content[0].text)
+    expect(claim.status).toBe("conflict")
+    expect(claim.conflictsWith).toBeDefined()
+  })
+
+  test("workspace_snapshot_get returns full coordination state", async () => {
+    const { store, workspaceId } = await createStoreWithProject()
+    const tools = getTools(store)
+
+    await tools.workspace_todo_add.handler({ workspaceId, description: "Task A" })
+    await tools.workspace_rule_set.handler({ workspaceId, content: "Use strict TypeScript" })
+
+    const result = await tools.workspace_snapshot_get.handler({ workspaceId }) as { content: Array<{ text: string }> }
+
+    const snapshot = JSON.parse(result.content[0].text)
+    expect(snapshot.workspaceId).toBe(workspaceId)
+    expect(snapshot.todos).toHaveLength(1)
+    expect(snapshot.rules).toHaveLength(1)
+  })
+
+  test("todo lifecycle: add → claim → complete", async () => {
+    const { store, workspaceId } = await createStoreWithProject()
+    const tools = getTools(store)
+
+    // Add
+    const addResult = await tools.workspace_todo_add.handler({
+      workspaceId,
+      description: "Build feature X",
+      createdBy: "s-1",
+    }) as { content: Array<{ text: string }> }
+    const todoId = JSON.parse(addResult.content[0].text).id
+
+    // Claim
+    const claimResult = await tools.workspace_todo_claim.handler({
+      workspaceId,
+      todoId,
+      sessionId: "s-2",
+    }) as { content: Array<{ text: string }> }
+    expect(JSON.parse(claimResult.content[0].text).status).toBe("claimed")
+    expect(JSON.parse(claimResult.content[0].text).claimedBy).toBe("s-2")
+
+    // Complete
+    const completeResult = await tools.workspace_todo_complete.handler({
+      workspaceId,
+      todoId,
+      outputs: ["feature-x.ts"],
+    }) as { content: Array<{ text: string }> }
+    expect(JSON.parse(completeResult.content[0].text).status).toBe("complete")
+    expect(JSON.parse(completeResult.content[0].text).outputs).toEqual(["feature-x.ts"])
+  })
+})

package/src/server/coordination-mcp.ts

@@ -0,0 +1,197 @@
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk"
+import { z } from "zod/v4"
+import { randomUUID } from "node:crypto"
+import type { CoordinationStore } from "../shared/coordination-store"
+import type { WorkspaceCoordinationSnapshot } from "../shared/workspace-types"
+import { deriveCoordinationSnapshot } from "./read-models"
+
+function json(data: unknown) {
+  return { content: [{ type: "text" as const, text: JSON.stringify(data) }] }
+}
+
+/** Fetch the full snapshot, using remote getSnapshot when state is not in-process. */
+async function getProjectSnapshot(store: CoordinationStore, workspaceId: string): Promise<WorkspaceCoordinationSnapshot> {
+  if (store.getSnapshot) {
+    return store.getSnapshot(workspaceId)
+  }
+  return deriveCoordinationSnapshot(store.state, workspaceId)
+}
+
+/** Read back an entity after mutation — tries in-process state first, falls back to snapshot. */
+async function readBackEntity(
+  store: CoordinationStore,
+  workspaceId: string,
+  collection: "todos" | "claims" | "worktrees" | "rules",
+  entityId: string,
+): Promise<unknown> {
+  const coord = store.state.coordinationByWorkspace.get(workspaceId)
+  if (coord) return coord[collection].get(entityId) ?? { id: entityId }
+  const snapshot = await getProjectSnapshot(store, workspaceId)
+  const list = snapshot[collection] as Array<{ id: string }>
+  return list.find((e) => e.id === entityId) ?? { id: entityId }
+}
+
+export function createCoordinationMcpServer(store: CoordinationStore) {
+  return createSdkMcpServer({
+    name: "project-coordination",
+    tools: [
+      tool(
+        "workspace_todo_add",
+        "Add a shared todo to a project's coordination board. Returns the created todo.",
+        {
+          workspaceId: z.string().describe("The project ID"),
+          description: z.string().describe("What needs to be done"),
+          priority: z.enum(["high", "normal", "low"]).optional().describe("Priority level (default: normal)"),
+          createdBy: z.string().optional().describe("Session or user creating the todo"),
+        },
+        async (args) => {
+          const todoId = randomUUID()
+          await store.addTodo(args.workspaceId, todoId, args.description, args.priority ?? "normal", args.createdBy ?? "unknown")
+          return json(await readBackEntity(store, args.workspaceId, "todos", todoId))
+        },
+      ),
+      tool(
+        "workspace_todo_claim",
+        "Claim a todo for a session. Sets status to 'claimed'.",
+        {
+          workspaceId: z.string().describe("The project ID"),
+          todoId: z.string().describe("The todo to claim"),
+          sessionId: z.string().describe("The session claiming the todo"),
+        },
+        async (args) => {
+          await store.claimTodo(args.workspaceId, args.todoId, args.sessionId)
+          return json(await readBackEntity(store, args.workspaceId, "todos", args.todoId))
+        },
+      ),
+      tool(
+        "workspace_todo_complete",
+        "Mark a todo as complete with optional output artifacts.",
+        {
+          workspaceId: z.string().describe("The project ID"),
+          todoId: z.string().describe("The todo to complete"),
+          outputs: z.array(z.string()).optional().describe("Output file paths or artifact references"),
+        },
+        async (args) => {
+          await store.completeTodo(args.workspaceId, args.todoId, args.outputs ?? [])
+          return json(await readBackEntity(store, args.workspaceId, "todos", args.todoId))
+        },
+      ),
+      tool(
+        "workspace_todo_abandon",
+        "Abandon a todo. Sets status to 'abandoned'.",
+        {
+          workspaceId: z.string().describe("The project ID"),
+          todoId: z.string().describe("The todo to abandon"),
+        },
+        async (args) => {
+          await store.abandonTodo(args.workspaceId, args.todoId)
+          return json(await readBackEntity(store, args.workspaceId, "todos", args.todoId))
+        },
+      ),
+      tool(
+        "workspace_claim_create",
+        "Declare intent to work on files. If files overlap with an existing active claim, the claim is created with 'conflict' status.",
+        {
+          workspaceId: z.string().describe("The project ID"),
+          intent: z.string().describe("What you intend to do with these files"),
+          files: z.array(z.string()).describe("File paths being claimed"),
+          sessionId: z.string().describe("The session creating the claim"),
+        },
+        async (args) => {
+          const claimId = randomUUID()
+          await store.createClaim(args.workspaceId, claimId, args.intent, args.files, args.sessionId)
+          return json(await readBackEntity(store, args.workspaceId, "claims", claimId))
+        },
+      ),
+      tool(
+        "workspace_claim_release",
+        "Release a file claim when done working on those files.",
+        {
+          workspaceId: z.string().describe("The project ID"),
+          claimId: z.string().describe("The claim to release"),
+        },
+        async (args) => {
+          await store.releaseClaim(args.workspaceId, args.claimId)
+          return json(await readBackEntity(store, args.workspaceId, "claims", args.claimId))
+        },
+      ),
+      tool(
+        "workspace_worktree_create",
+        "Create a git worktree for isolated work on a branch.",
+        {
+          workspaceId: z.string().describe("The project ID"),
+          branch: z.string().describe("Branch name for the worktree"),
+          baseBranch: z.string().optional().describe("Base branch to create from (default: main)"),
+        },
+        async (args) => {
+          const worktreeId = randomUUID()
+          await store.createWorktree(args.workspaceId, worktreeId, args.branch, args.baseBranch ?? "main", "")
+          return json(await readBackEntity(store, args.workspaceId, "worktrees", worktreeId))
+        },
+      ),
+      tool(
+        "workspace_worktree_assign",
+        "Assign a worktree to a session.",
+        {
+          workspaceId: z.string().describe("The project ID"),
+          worktreeId: z.string().describe("The worktree to assign"),
+          sessionId: z.string().describe("The session to assign to"),
+        },
+        async (args) => {
+          await store.assignWorktree(args.workspaceId, args.worktreeId, args.sessionId)
+          return json(await readBackEntity(store, args.workspaceId, "worktrees", args.worktreeId))
+        },
+      ),
+      tool(
+        "workspace_worktree_remove",
+        "Remove a worktree.",
+        {
+          workspaceId: z.string().describe("The project ID"),
+          worktreeId: z.string().describe("The worktree to remove"),
+        },
+        async (args) => {
+          await store.removeWorktree(args.workspaceId, args.worktreeId)
+          return json({ ok: true, worktreeId: args.worktreeId })
+        },
+      ),
+      tool(
+        "workspace_rule_set",
+        "Set a project rule or instruction that applies to all sessions.",
+        {
+          workspaceId: z.string().describe("The project ID"),
+          ruleId: z.string().optional().describe("Rule ID (auto-generated if omitted)"),
+          content: z.string().describe("The rule content"),
+          setBy: z.string().optional().describe("Who set this rule"),
+        },
+        async (args) => {
+          const ruleId = args.ruleId ?? randomUUID()
+          await store.setRule(args.workspaceId, ruleId, args.content, args.setBy ?? "unknown")
+          return json(await readBackEntity(store, args.workspaceId, "rules", ruleId))
+        },
+      ),
+      tool(
+        "workspace_rule_remove",
+        "Remove a project rule.",
+        {
+          workspaceId: z.string().describe("The project ID"),
+          ruleId: z.string().describe("The rule to remove"),
+        },
+        async (args) => {
+          await store.removeRule(args.workspaceId, args.ruleId)
+          return json({ ok: true, ruleId: args.ruleId })
+        },
+      ),
+      tool(
+        "workspace_snapshot_get",
+        "Get the current coordination snapshot for a project — all active todos, claims, worktrees, and rules.",
+        {
+          workspaceId: z.string().describe("The project ID"),
+        },
+        async (args) => {
+          const snapshot = await getProjectSnapshot(store, args.workspaceId)
+          return json(snapshot)
+        },
+      ),
+    ],
+  })
+}