airaknit 1.1.2-rc.9

package/src/server/event-store-profile.test.ts

@@ -0,0 +1,132 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { rm } from "node:fs/promises"
+import { mkdtemp } from "node:fs/promises"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { EventStore } from "./event-store"
+import type { ProviderProfile } from "../shared/profile-types"
+
+const tempDirs: string[] = []
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })))
+})
+
+async function createTempDataDir() {
+  const dir = await mkdtemp(join(tmpdir(), "kanna-pf-"))
+  tempDirs.push(dir)
+  return dir
+}
+
+const makeProfile = (id: string): ProviderProfile => ({
+  id,
+  name: `Profile ${id}`,
+  provider: "claude",
+  runtime: "system",
+  model: "opus-4",
+  systemPrompt: "You are helpful.",
+})
+
+describe("EventStore provider profiles", () => {
+  test("saveProviderProfile creates record", async () => {
+    const dataDir = await createTempDataDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+
+    await store.saveProviderProfile("p1", makeProfile("p1"))
+
+    const record = store.state.providerProfiles.get("p1")
+    expect(record).toBeDefined()
+    expect(record!.profile.name).toBe("Profile p1")
+    expect(record!.createdAt).toBeGreaterThan(0)
+  })
+
+  test("saveProviderProfile preserves createdAt on update", async () => {
+    const dataDir = await createTempDataDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+
+    await store.saveProviderProfile("p1", makeProfile("p1"))
+    const firstCreated = store.state.providerProfiles.get("p1")!.createdAt
+
+    const updated = { ...makeProfile("p1"), name: "Updated" }
+    await store.saveProviderProfile("p1", updated)
+
+    const record = store.state.providerProfiles.get("p1")!
+    expect(record.createdAt).toBe(firstCreated)
+    expect(record.updatedAt).toBeGreaterThanOrEqual(firstCreated)
+    expect(record.profile.name).toBe("Updated")
+  })
+
+  test("removeProviderProfile deletes record and cleans overrides", async () => {
+    const dataDir = await createTempDataDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+
+    await store.saveProviderProfile("p1", makeProfile("p1"))
+    await store.setWorkspaceProfileOverride("ws1", "p1", { model: "sonnet-4" })
+    await store.removeProviderProfile("p1")
+
+    expect(store.state.providerProfiles.get("p1")).toBeUndefined()
+    expect(store.state.workspaceProfileOverrides.get("ws1")?.get("p1")).toBeUndefined()
+  })
+
+  test("setWorkspaceProfileOverride stores override", async () => {
+    const dataDir = await createTempDataDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+
+    await store.saveProviderProfile("p1", makeProfile("p1"))
+    await store.setWorkspaceProfileOverride("ws1", "p1", { model: "sonnet-4" })
+
+    const override = store.state.workspaceProfileOverrides.get("ws1")?.get("p1")
+    expect(override).toBeDefined()
+    expect(override!.overrides.model).toBe("sonnet-4")
+  })
+
+  test("removeWorkspaceProfileOverride deletes override", async () => {
+    const dataDir = await createTempDataDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+
+    await store.saveProviderProfile("p1", makeProfile("p1"))
+    await store.setWorkspaceProfileOverride("ws1", "p1", { model: "sonnet-4" })
+    await store.removeWorkspaceProfileOverride("ws1", "p1")
+
+    expect(store.state.workspaceProfileOverrides.get("ws1")?.get("p1")).toBeUndefined()
+  })
+
+  test("profiles survive snapshot round-trip", async () => {
+    const dataDir = await createTempDataDir()
+    const store1 = new EventStore(dataDir)
+    await store1.initialize()
+
+    await store1.saveProviderProfile("p1", makeProfile("p1"))
+    await store1.setWorkspaceProfileOverride("ws1", "p1", { model: "haiku-4" })
+    await store1.compact()
+
+    const store2 = new EventStore(dataDir)
+    await store2.initialize()
+
+    expect(store2.state.providerProfiles.get("p1")).toBeDefined()
+    expect(store2.state.providerProfiles.get("p1")!.profile.name).toBe("Profile p1")
+    expect(store2.state.workspaceProfileOverrides.get("ws1")?.get("p1")?.overrides.model).toBe("haiku-4")
+  })
+
+  test("profiles survive log replay without snapshot", async () => {
+    const dataDir = await createTempDataDir()
+    const store1 = new EventStore(dataDir)
+    await store1.initialize()
+
+    await store1.saveProviderProfile("p1", makeProfile("p1"))
+    await store1.setWorkspaceProfileOverride("ws1", "p1", { model: "haiku-4" })
+    // No compact — force log replay on next load
+
+    const store2 = new EventStore(dataDir)
+    await store2.initialize()
+
+    expect(store2.state.providerProfiles.get("p1")).toBeDefined()
+    expect(store2.state.providerProfiles.get("p1")!.profile.name).toBe("Profile p1")
+    expect(store2.state.workspaceProfileOverrides.get("ws1")?.get("p1")?.overrides.model).toBe("haiku-4")
+  })
+})

package/src/server/event-store-repo.test.ts

@@ -0,0 +1,154 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtemp, readFile, rm } from "node:fs/promises"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { EventStore } from "./event-store"
+import type { SnapshotFile } from "./events"
+
+const tempDirs: string[] = []
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })))
+})
+
+async function createTempDataDir() {
+  const dir = await mkdtemp(join(tmpdir(), "kanna-repo-"))
+  tempDirs.push(dir)
+  return dir
+}
+
+async function createStoreWithWorkspace() {
+  const dataDir = await createTempDataDir()
+  const store = new EventStore(dataDir)
+  await store.initialize()
+  const workspace = await store.openProject("/tmp/repo-workspace")
+  return { dataDir, store, workspaceId: workspace.id }
+}
+
+describe("EventStore repo reducers", () => {
+  test("addRepo creates record in reposById with status cloned", async () => {
+    const { store, workspaceId } = await createStoreWithWorkspace()
+
+    await store.addRepo("r1", workspaceId, "/tmp/my-repo", "https://github.com/org/repo.git", "My Repo", "main")
+
+    const repo = store.state.reposById.get("r1")
+    expect(repo).toBeDefined()
+    expect(repo!.id).toBe("r1")
+    expect(repo!.workspaceId).toBe(workspaceId)
+    expect(repo!.origin).toBe("https://github.com/org/repo.git")
+    expect(repo!.localPath).toBe("/tmp/my-repo")
+    expect(repo!.label).toBe("My Repo")
+    expect(repo!.status).toBe("cloned")
+    expect(repo!.branch).toBe("main")
+    expect(repo!.createdAt).toBeGreaterThan(0)
+    expect(store.state.reposByPath.get("/tmp/my-repo")).toBe("r1")
+  })
+
+  test("startRepoClone creates record with status pending and indexes reposByPath", async () => {
+    const { store, workspaceId } = await createStoreWithWorkspace()
+
+    await store.startRepoClone("r2", workspaceId, "https://github.com/org/repo.git", "/tmp/target", "Clone Label")
+
+    const repo = store.state.reposById.get("r2")
+    expect(repo).toBeDefined()
+    expect(repo!.status).toBe("pending")
+    expect(repo!.origin).toBe("https://github.com/org/repo.git")
+    expect(repo!.localPath).toBe("/tmp/target")
+    expect(repo!.branch).toBeNull()
+    expect(store.state.reposByPath.get("/tmp/target")).toBe("r2")
+  })
+
+  test("markRepoCloned transitions status to cloned and sets localPath", async () => {
+    const { store, workspaceId } = await createStoreWithWorkspace()
+    await store.startRepoClone("r3", workspaceId, "https://github.com/org/repo.git", "/tmp/target", null)
+
+    await store.markRepoCloned("r3", "/tmp/cloned-path", "develop")
+
+    const repo = store.state.reposById.get("r3")
+    expect(repo!.status).toBe("cloned")
+    expect(repo!.localPath).toBe("/tmp/cloned-path")
+    expect(repo!.branch).toBe("develop")
+    expect(store.state.reposByPath.get("/tmp/cloned-path")).toBe("r3")
+  })
+
+  test("markRepoCloneFailed transitions status to error", async () => {
+    const { store, workspaceId } = await createStoreWithWorkspace()
+    await store.startRepoClone("r4", workspaceId, "https://github.com/org/repo.git", "/tmp/target", null)
+
+    await store.markRepoCloneFailed("r4", "clone failed: timeout")
+
+    const repo = store.state.reposById.get("r4")
+    expect(repo!.status).toBe("error")
+  })
+
+  test("removeRepo deletes from both maps", async () => {
+    const { store, workspaceId } = await createStoreWithWorkspace()
+    await store.addRepo("r5", workspaceId, "/tmp/to-remove", null, null, null)
+
+    await store.removeRepo("r5", workspaceId)
+
+    expect(store.state.reposById.has("r5")).toBe(false)
+    expect(store.state.reposByPath.has("/tmp/to-remove")).toBe(false)
+  })
+
+  test("updateRepoLabel updates label", async () => {
+    const { store, workspaceId } = await createStoreWithWorkspace()
+    await store.addRepo("r6", workspaceId, "/tmp/label-repo", null, "Old Label", null)
+
+    await store.updateRepoLabel("r6", "New Label")
+
+    const repo = store.state.reposById.get("r6")
+    expect(repo!.label).toBe("New Label")
+    expect(repo!.updatedAt).toBeGreaterThan(repo!.createdAt - 1)
+  })
+
+  test("createChat with repoId stores the association", async () => {
+    const { store, workspaceId } = await createStoreWithWorkspace()
+    await store.addRepo("r-chat", workspaceId, "/tmp/chat-repo", null, null, null)
+
+    const chat = await store.createChat(workspaceId, "r-chat")
+
+    expect(chat.repoId).toBe("r-chat")
+  })
+
+  test("createChat without repoId defaults to null", async () => {
+    const { store, workspaceId } = await createStoreWithWorkspace()
+
+    const chat = await store.createChat(workspaceId)
+
+    expect(chat.repoId).toBeNull()
+  })
+
+  test("removeRepo nullifies repoId on orphaned chats", async () => {
+    const { store, workspaceId } = await createStoreWithWorkspace()
+    await store.addRepo("r-orphan", workspaceId, "/tmp/orphan-repo", null, null, null)
+    const chat = await store.createChat(workspaceId, "r-orphan")
+
+    expect(store.state.chatsById.get(chat.id)!.repoId).toBe("r-orphan")
+
+    await store.removeRepo("r-orphan", workspaceId)
+
+    expect(store.state.chatsById.get(chat.id)!.repoId).toBeNull()
+  })
+
+  test("snapshot round-trip preserves repos", async () => {
+    const { dataDir, store, workspaceId } = await createStoreWithWorkspace()
+    await store.addRepo("r7", workspaceId, "/tmp/snap-repo", "https://github.com/org/snap.git", "Snap Repo", "main")
+    await store.addRepo("r8", workspaceId, "/tmp/snap-repo2", null, null, null)
+
+    await store.compact()
+
+    const snapshot = JSON.parse(await readFile(join(dataDir, "snapshot.json"), "utf8")) as SnapshotFile
+    expect(snapshot.repos).toBeDefined()
+    expect(snapshot.repos!.length).toBe(2)
+
+    const store2 = new EventStore(dataDir)
+    await store2.initialize()
+
+    expect(store2.state.reposById.size).toBe(2)
+    expect(store2.state.reposById.get("r7")!.label).toBe("Snap Repo")
+    expect(store2.state.reposById.get("r7")!.origin).toBe("https://github.com/org/snap.git")
+    expect(store2.state.reposByPath.get("/tmp/snap-repo")).toBe("r7")
+    expect(store2.state.reposByPath.get("/tmp/snap-repo2")).toBe("r8")
+  })
+})

package/src/server/event-store-runner-team.test.ts

@@ -0,0 +1,104 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { rm, mkdtemp } from "node:fs/promises"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { EventStore } from "./event-store"
+
+const tempDirs: string[] = []
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })))
+})
+
+async function createTempDataDir() {
+  const dir = await mkdtemp(join(tmpdir(), "kanna-rt-"))
+  tempDirs.push(dir)
+  return dir
+}
+
+describe("EventStore runner team (US-RTN)", () => {
+  test("saveTeamMember creates member", async () => {
+    const store = new EventStore(await createTempDataDir())
+    await store.initialize()
+
+    await store.saveTeamMember({ id: "m1", name: "Alice" })
+
+    expect(store.state.teamMembers.get("m1")).toEqual({ id: "m1", name: "Alice" })
+  })
+
+  test("setRunnerLabel upserts name + assignment", async () => {
+    const store = new EventStore(await createTempDataDir())
+    await store.initialize()
+
+    await store.setRunnerLabel("runner-1", "Studio Mac", "m1")
+    const first = store.state.runnerLabels.get("runner-1")!
+    expect(first.name).toBe("Studio Mac")
+    expect(first.memberId).toBe("m1")
+    expect(first.updatedAt).toBeGreaterThan(0)
+
+    await store.setRunnerLabel("runner-1", "Renamed", null)
+    const second = store.state.runnerLabels.get("runner-1")!
+    expect(second.name).toBe("Renamed")
+    expect(second.memberId).toBeNull()
+  })
+
+  test("removeTeamMember cascades to unassign runners", async () => {
+    const store = new EventStore(await createTempDataDir())
+    await store.initialize()
+
+    await store.saveTeamMember({ id: "m1", name: "Alice" })
+    await store.setRunnerLabel("runner-1", "Box A", "m1")
+    await store.setRunnerLabel("runner-2", "Box B", "m1")
+    await store.setRunnerLabel("runner-3", "Box C", "m2")
+
+    await store.removeTeamMember("m1")
+
+    expect(store.state.teamMembers.get("m1")).toBeUndefined()
+    // runners that pointed at m1 are unassigned; their names are preserved.
+    expect(store.state.runnerLabels.get("runner-1")!.memberId).toBeNull()
+    expect(store.state.runnerLabels.get("runner-1")!.name).toBe("Box A")
+    expect(store.state.runnerLabels.get("runner-2")!.memberId).toBeNull()
+    // a runner assigned to a different member is untouched.
+    expect(store.state.runnerLabels.get("runner-3")!.memberId).toBe("m2")
+  })
+
+  test("removeRunnerLabel deletes the label", async () => {
+    const store = new EventStore(await createTempDataDir())
+    await store.initialize()
+
+    await store.setRunnerLabel("runner-1", "Box A", null)
+    await store.removeRunnerLabel("runner-1")
+
+    expect(store.state.runnerLabels.get("runner-1")).toBeUndefined()
+  })
+
+  test("survive log replay without snapshot", async () => {
+    const dataDir = await createTempDataDir()
+    const store1 = new EventStore(dataDir)
+    await store1.initialize()
+    await store1.saveTeamMember({ id: "m1", name: "Alice" })
+    await store1.setRunnerLabel("runner-1", "Studio Mac", "m1")
+
+    const store2 = new EventStore(dataDir)
+    await store2.initialize()
+
+    expect(store2.state.teamMembers.get("m1")?.name).toBe("Alice")
+    expect(store2.state.runnerLabels.get("runner-1")?.name).toBe("Studio Mac")
+    expect(store2.state.runnerLabels.get("runner-1")?.memberId).toBe("m1")
+  })
+
+  test("survive snapshot round-trip (compaction)", async () => {
+    const dataDir = await createTempDataDir()
+    const store1 = new EventStore(dataDir)
+    await store1.initialize()
+    await store1.saveTeamMember({ id: "m1", name: "Alice" })
+    await store1.setRunnerLabel("runner-1", "Studio Mac", "m1")
+    await store1.compact()
+
+    const store2 = new EventStore(dataDir)
+    await store2.initialize()
+
+    expect(store2.state.teamMembers.get("m1")?.name).toBe("Alice")
+    expect(store2.state.runnerLabels.get("runner-1")?.memberId).toBe("m1")
+  })
+})