airaknit 1.1.2-rc.9

package/src/server/discovery.ts

@@ -0,0 +1,301 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs"
+import { homedir } from "node:os"
+import path from "node:path"
+import type { AgentProvider } from "../shared/types"
+import { resolveLocalPath } from "./paths"
+
+export interface DiscoveredProject {
+  localPath: string
+  title: string
+  modifiedAt: number
+}
+
+export interface ProviderDiscoveredProject extends DiscoveredProject {
+  provider: AgentProvider
+}
+
+export interface ProjectDiscoveryAdapter {
+  provider: AgentProvider
+  scan(homeDir?: string): ProviderDiscoveredProject[]
+}
+
+function resolveEncodedClaudePath(folderName: string) {
+  const segments = folderName.replace(/^-/, "").split("-").filter(Boolean)
+  let currentPath = ""
+  let remainingSegments = [...segments]
+
+  while (remainingSegments.length > 0) {
+    let found = false
+
+    for (let index = remainingSegments.length; index >= 1; index -= 1) {
+      const segment = remainingSegments.slice(0, index).join("-")
+      const candidate = `${currentPath}/${segment}`
+
+      if (existsSync(candidate)) {
+        currentPath = candidate
+        remainingSegments = remainingSegments.slice(index)
+        found = true
+        break
+      }
+    }
+
+    if (!found) {
+      const [head, ...tail] = remainingSegments
+      currentPath = `${currentPath}/${head}`
+      remainingSegments = tail
+    }
+  }
+
+  return currentPath || "/"
+}
+
+function normalizeExistingDirectory(localPath: string) {
+  try {
+    const normalized = resolveLocalPath(localPath)
+    if (!statSync(normalized).isDirectory()) {
+      return null
+    }
+    return normalized
+  } catch {
+    return null
+  }
+}
+
+function mergeDiscoveredProjects(projects: Iterable<DiscoveredProject>): DiscoveredProject[] {
+  const merged = new Map<string, DiscoveredProject>()
+
+  for (const project of projects) {
+    const existing = merged.get(project.localPath)
+    if (!existing || project.modifiedAt > existing.modifiedAt) {
+      merged.set(project.localPath, {
+        localPath: project.localPath,
+        title: project.title || path.basename(project.localPath) || project.localPath,
+        modifiedAt: project.modifiedAt,
+      })
+      continue
+    }
+
+    if (!existing.title && project.title) {
+      existing.title = project.title
+    }
+  }
+
+  return [...merged.values()].sort((a, b) => b.modifiedAt - a.modifiedAt)
+}
+
+export class ClaudeProjectDiscoveryAdapter implements ProjectDiscoveryAdapter {
+  readonly provider = "claude" as const
+
+  scan(homeDir: string = homedir()): ProviderDiscoveredProject[] {
+    const projectsDir = path.join(homeDir, ".claude", "projects")
+    if (!existsSync(projectsDir)) {
+      return []
+    }
+
+    const entries = readdirSync(projectsDir, { withFileTypes: true })
+    const projects: ProviderDiscoveredProject[] = []
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+
+      const resolvedPath = resolveEncodedClaudePath(entry.name)
+      const normalizedPath = normalizeExistingDirectory(resolvedPath)
+      if (!normalizedPath) {
+        continue
+      }
+
+      const stat = statSync(path.join(projectsDir, entry.name))
+      projects.push({
+        provider: this.provider,
+        localPath: normalizedPath,
+        title: path.basename(normalizedPath) || normalizedPath,
+        modifiedAt: stat.mtimeMs,
+      })
+    }
+
+    const mergedProjects = mergeDiscoveredProjects(projects).map((project) => ({
+      provider: this.provider,
+      ...project,
+    }))
+
+    return mergedProjects
+  }
+}
+
+function parseJsonRecord(line: string): Record<string, unknown> | null {
+  try {
+    const parsed = JSON.parse(line)
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null
+    }
+    return parsed as Record<string, unknown>
+  } catch {
+    return null
+  }
+}
+
+function readCodexSessionIndex(indexPath: string) {
+  const updatedAtById = new Map<string, number>()
+  if (!existsSync(indexPath)) {
+    return updatedAtById
+  }
+
+  for (const line of readFileSync(indexPath, "utf8").split("\n")) {
+    if (!line.trim()) continue
+    const record = parseJsonRecord(line)
+    if (!record) continue
+
+    const id = typeof record.id === "string" ? record.id : null
+    const updatedAt = typeof record.updated_at === "string" ? Date.parse(record.updated_at) : Number.NaN
+    if (!id || Number.isNaN(updatedAt)) continue
+
+    const existing = updatedAtById.get(id)
+    if (existing === undefined || updatedAt > existing) {
+      updatedAtById.set(id, updatedAt)
+    }
+  }
+
+  return updatedAtById
+}
+
+function collectCodexSessionFiles(directory: string): string[] {
+  if (!existsSync(directory)) {
+    return []
+  }
+
+  const files: string[] = []
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const fullPath = path.join(directory, entry.name)
+    if (entry.isDirectory()) {
+      files.push(...collectCodexSessionFiles(fullPath))
+      continue
+    }
+    if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+      files.push(fullPath)
+    }
+  }
+  return files
+}
+
+function readCodexConfiguredProjects(configPath: string) {
+  const projects = new Map<string, number>()
+  if (!existsSync(configPath)) {
+    return projects
+  }
+
+  const configMtime = statSync(configPath).mtimeMs
+  for (const line of readFileSync(configPath, "utf8").split("\n")) {
+    const match = line.match(/^\[projects\."(.+)"\]$/)
+    if (!match?.[1]) continue
+    projects.set(match[1], configMtime)
+  }
+
+  return projects
+}
+
+function readCodexSessionMetadata(sessionsDir: string) {
+  const metadataById = new Map<string, { cwd: string; modifiedAt: number }>()
+
+  for (const sessionFile of collectCodexSessionFiles(sessionsDir)) {
+    const fileStat = statSync(sessionFile)
+    const firstLine = readFileSync(sessionFile, "utf8").split("\n", 1)[0]
+    if (!firstLine?.trim()) continue
+
+    const record = parseJsonRecord(firstLine)
+    if (!record || record.type !== "session_meta") continue
+
+    const payload = record.payload
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) continue
+
+    const payloadRecord = payload as Record<string, unknown>
+    const sessionId = typeof payloadRecord.id === "string" ? payloadRecord.id : null
+    const cwd = typeof payloadRecord.cwd === "string" ? payloadRecord.cwd : null
+    if (!sessionId || !cwd) continue
+
+    const recordTimestamp = typeof record.timestamp === "string" ? Date.parse(record.timestamp) : Number.NaN
+    const payloadTimestamp = typeof payloadRecord.timestamp === "string" ? Date.parse(payloadRecord.timestamp) : Number.NaN
+    const modifiedAt = [recordTimestamp, payloadTimestamp, fileStat.mtimeMs].find((value) => !Number.isNaN(value)) ?? fileStat.mtimeMs
+
+    metadataById.set(sessionId, { cwd, modifiedAt })
+  }
+
+  return metadataById
+}
+
+export class CodexProjectDiscoveryAdapter implements ProjectDiscoveryAdapter {
+  readonly provider = "codex" as const
+
+  scan(homeDir: string = homedir()): ProviderDiscoveredProject[] {
+    const indexPath = path.join(homeDir, ".codex", "session_index.jsonl")
+    const sessionsDir = path.join(homeDir, ".codex", "sessions")
+    const configPath = path.join(homeDir, ".codex", "config.toml")
+    const updatedAtById = readCodexSessionIndex(indexPath)
+    const metadataById = readCodexSessionMetadata(sessionsDir)
+    const configuredProjects = readCodexConfiguredProjects(configPath)
+    const projects: ProviderDiscoveredProject[] = []
+
+    for (const [sessionId, metadata] of metadataById.entries()) {
+      const modifiedAt = updatedAtById.get(sessionId) ?? metadata.modifiedAt
+      const cwd = metadata.cwd
+      if (!cwd) {
+        continue
+      }
+      if (!path.isAbsolute(cwd)) {
+        continue
+      }
+
+      const normalizedPath = normalizeExistingDirectory(cwd)
+      if (!normalizedPath) {
+        continue
+      }
+
+      projects.push({
+        provider: this.provider,
+        localPath: normalizedPath,
+        title: path.basename(normalizedPath) || normalizedPath,
+        modifiedAt,
+      })
+    }
+
+    for (const [configuredPath, modifiedAt] of configuredProjects.entries()) {
+      if (!path.isAbsolute(configuredPath)) {
+        continue
+      }
+
+      const normalizedPath = normalizeExistingDirectory(configuredPath)
+      if (!normalizedPath) {
+        continue
+      }
+
+      projects.push({
+        provider: this.provider,
+        localPath: normalizedPath,
+        title: path.basename(normalizedPath) || normalizedPath,
+        modifiedAt,
+      })
+    }
+
+    const mergedProjects = mergeDiscoveredProjects(projects).map((project) => ({
+      provider: this.provider,
+      ...project,
+    }))
+
+    return mergedProjects
+  }
+}
+
+export const DEFAULT_PROJECT_DISCOVERY_ADAPTERS: ProjectDiscoveryAdapter[] = [
+  new ClaudeProjectDiscoveryAdapter(),
+  new CodexProjectDiscoveryAdapter(),
+]
+
+export function discoverProjects(
+  homeDir: string = homedir(),
+  adapters: ProjectDiscoveryAdapter[] = DEFAULT_PROJECT_DISCOVERY_ADAPTERS
+): DiscoveredProject[] {
+  const mergedProjects = mergeDiscoveredProjects(
+    adapters.flatMap((adapter) => adapter.scan(homeDir).map(({ provider: _provider, ...project }) => project))
+  )
+
+  return mergedProjects
+}

package/src/server/event-store-agent-config.test.ts

@@ -0,0 +1,124 @@
+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"
+import type { AgentConfig } from "../shared/agent-config-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-ac-"))
+  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/ac-workspace")
+  return { dataDir, store, workspaceId: workspace.id }
+}
+
+const makeConfig = (id: string): AgentConfig => ({
+  id,
+  name: `Agent ${id}`,
+  description: `Test agent ${id}`,
+  provider: "claude",
+  model: "opus-4",
+  systemPrompt: "You are helpful.",
+  tools: ["bash"],
+  temperature: 0.5,
+})
+
+describe("EventStore agent config reducers", () => {
+  test("saveAgentConfig creates record in agentConfigsByWorkspace", async () => {
+    const { store, workspaceId } = await createStoreWithWorkspace()
+    const config = makeConfig("a1")
+
+    await store.saveAgentConfig(workspaceId, "a1", config)
+
+    const wsMap = store.state.agentConfigsByWorkspace.get(workspaceId)
+    expect(wsMap).toBeDefined()
+    const record = wsMap!.get("a1")
+    expect(record).toBeDefined()
+    expect(record!.id).toBe("a1")
+    expect(record!.workspaceId).toBe(workspaceId)
+    expect(record!.config).toEqual(config)
+    expect(record!.createdAt).toBeGreaterThan(0)
+    expect(record!.updatedAt).toBeGreaterThan(0)
+    expect(record!.lastCommitHash).toBeUndefined()
+  })
+
+  test("commitAgentConfig sets lastCommitHash", async () => {
+    const { store, workspaceId } = await createStoreWithWorkspace()
+    await store.saveAgentConfig(workspaceId, "a1", makeConfig("a1"))
+
+    await store.commitAgentConfig(workspaceId, "a1", "abc123def")
+
+    const record = store.state.agentConfigsByWorkspace.get(workspaceId)!.get("a1")!
+    expect(record.lastCommitHash).toBe("abc123def")
+  })
+
+  test("removeAgentConfig deletes record from map", async () => {
+    const { store, workspaceId } = await createStoreWithWorkspace()
+    await store.saveAgentConfig(workspaceId, "a1", makeConfig("a1"))
+
+    await store.removeAgentConfig(workspaceId, "a1")
+
+    const wsMap = store.state.agentConfigsByWorkspace.get(workspaceId)
+    expect(wsMap?.has("a1")).toBe(false)
+  })
+
+  test("snapshot round-trip preserves agent configs", async () => {
+    const { dataDir, store, workspaceId } = await createStoreWithWorkspace()
+    await store.saveAgentConfig(workspaceId, "a1", makeConfig("a1"))
+    await store.commitAgentConfig(workspaceId, "a1", "hash1")
+    await store.saveAgentConfig(workspaceId, "a2", makeConfig("a2"))
+
+    await store.compact()
+
+    // Verify snapshot file has agentConfigs
+    const snapshot = JSON.parse(await readFile(join(dataDir, "snapshot.json"), "utf8")) as SnapshotFile
+    expect(snapshot.agentConfigs).toBeDefined()
+    expect(snapshot.agentConfigs!.length).toBe(1)
+    expect(snapshot.agentConfigs![0].workspaceId).toBe(workspaceId)
+    expect(snapshot.agentConfigs![0].records.length).toBe(2)
+
+    // Fresh store from snapshot
+    const store2 = new EventStore(dataDir)
+    await store2.initialize()
+
+    const wsMap = store2.state.agentConfigsByWorkspace.get(workspaceId)!
+    expect(wsMap.size).toBe(2)
+    expect(wsMap.get("a1")!.config.name).toBe("Agent a1")
+    expect(wsMap.get("a1")!.lastCommitHash).toBe("hash1")
+    expect(wsMap.get("a2")!.config.name).toBe("Agent a2")
+  })
+
+  test("second save updates updatedAt but preserves createdAt", async () => {
+    const { store, workspaceId } = await createStoreWithWorkspace()
+    await store.saveAgentConfig(workspaceId, "a1", makeConfig("a1"))
+
+    const record1 = store.state.agentConfigsByWorkspace.get(workspaceId)!.get("a1")!
+    const createdAt = record1.createdAt
+    const updatedAt1 = record1.updatedAt
+
+    // Small delay to ensure timestamp differs
+    await new Promise((r) => setTimeout(r, 5))
+
+    const updated = { ...makeConfig("a1"), name: "Renamed Agent" }
+    await store.saveAgentConfig(workspaceId, "a1", updated)
+
+    const record2 = store.state.agentConfigsByWorkspace.get(workspaceId)!.get("a1")!
+    expect(record2.createdAt).toBe(createdAt)
+    expect(record2.updatedAt).toBeGreaterThan(updatedAt1)
+    expect(record2.config.name).toBe("Renamed Agent")
+  })
+})

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

@@ -0,0 +1,149 @@
+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-coord-"))
+  tempDirs.push(dir)
+  return dir
+}
+
+async function createStoreWithProject() {
+  const dataDir = await createTempDataDir()
+  const store = new EventStore(dataDir)
+  await store.initialize()
+  const project = await store.openProject("/tmp/coord-project")
+  return { dataDir, store, workspaceId: project.id }
+}
+
+describe("EventStore coordination", () => {
+  test("appends todo_added and replays on restart", async () => {
+    const { dataDir, store, workspaceId } = await createStoreWithProject()
+
+    await store.addTodo(workspaceId, "t1", "Build feature X", "high", "agent-1")
+
+    const coord = store.state.coordinationByWorkspace.get(workspaceId)!
+    expect(coord.todos.get("t1")).toMatchObject({
+      id: "t1",
+      description: "Build feature X",
+      priority: "high",
+      status: "open",
+      claimedBy: null,
+      createdBy: "agent-1",
+    })
+
+    // Replay on restart
+    const store2 = new EventStore(dataDir)
+    await store2.initialize()
+    const coord2 = store2.state.coordinationByWorkspace.get(workspaceId)!
+    expect(coord2.todos.get("t1")?.description).toBe("Build feature X")
+  })
+
+  test("todo claim, complete, abandon lifecycle", async () => {
+    const { store, workspaceId } = await createStoreWithProject()
+
+    await store.addTodo(workspaceId, "t1", "Task A", "normal", "agent-1")
+    await store.claimTodo(workspaceId, "t1", "agent-2")
+    expect(store.state.coordinationByWorkspace.get(workspaceId)!.todos.get("t1")?.status).toBe("claimed")
+    expect(store.state.coordinationByWorkspace.get(workspaceId)!.todos.get("t1")?.claimedBy).toBe("agent-2")
+
+    await store.completeTodo(workspaceId, "t1", ["output.ts"])
+    expect(store.state.coordinationByWorkspace.get(workspaceId)!.todos.get("t1")?.status).toBe("complete")
+    expect(store.state.coordinationByWorkspace.get(workspaceId)!.todos.get("t1")?.outputs).toEqual(["output.ts"])
+
+    await store.addTodo(workspaceId, "t2", "Task B", "low", "agent-1")
+    await store.claimTodo(workspaceId, "t2", "agent-3")
+    await store.abandonTodo(workspaceId, "t2")
+    expect(store.state.coordinationByWorkspace.get(workspaceId)!.todos.get("t2")?.status).toBe("abandoned")
+  })
+
+  test("claim with file overlap detects conflict", async () => {
+    const { store, workspaceId } = await createStoreWithProject()
+
+    await store.createClaim(workspaceId, "c1", "Refactor auth", ["src/auth.ts", "src/login.ts"], "session-1")
+    await store.createClaim(workspaceId, "c2", "Fix login bug", ["src/login.ts", "src/utils.ts"], "session-2")
+
+    const c2 = store.state.coordinationByWorkspace.get(workspaceId)!.claims.get("c2")!
+    expect(c2.status).toBe("conflict")
+    expect(c2.conflictsWith).toBe("c1")
+  })
+
+  test("worktree create and assign", async () => {
+    const { store, workspaceId } = await createStoreWithProject()
+
+    await store.createWorktree(workspaceId, "w1", "feat/auth", "main", "/tmp/wt1")
+    const wt = store.state.coordinationByWorkspace.get(workspaceId)!.worktrees.get("w1")!
+    expect(wt.status).toBe("ready")
+    expect(wt.assignedTo).toBeNull()
+
+    await store.assignWorktree(workspaceId, "w1", "session-1")
+    expect(store.state.coordinationByWorkspace.get(workspaceId)!.worktrees.get("w1")?.status).toBe("assigned")
+    expect(store.state.coordinationByWorkspace.get(workspaceId)!.worktrees.get("w1")?.assignedTo).toBe("session-1")
+
+    await store.removeWorktree(workspaceId, "w1")
+    expect(store.state.coordinationByWorkspace.get(workspaceId)!.worktrees.get("w1")?.status).toBe("removed")
+    expect(store.state.coordinationByWorkspace.get(workspaceId)!.worktrees.get("w1")?.assignedTo).toBeNull()
+  })
+
+  test("rule set and remove", async () => {
+    const { store, workspaceId } = await createStoreWithProject()
+
+    await store.setRule(workspaceId, "r1", "No console.log in production", "lead")
+    expect(store.state.coordinationByWorkspace.get(workspaceId)!.rules.get("r1")?.content).toBe("No console.log in production")
+
+    await store.setRule(workspaceId, "r1", "No console.log or debugger", "lead")
+    expect(store.state.coordinationByWorkspace.get(workspaceId)!.rules.get("r1")?.content).toBe("No console.log or debugger")
+
+    await store.removeRule(workspaceId, "r1")
+    expect(store.state.coordinationByWorkspace.get(workspaceId)!.rules.has("r1")).toBe(false)
+  })
+
+  test("compact preserves coordination state", async () => {
+    const { dataDir, store, workspaceId } = await createStoreWithProject()
+
+    await store.addTodo(workspaceId, "t1", "Survive compaction", "high", "agent-1")
+    await store.setRule(workspaceId, "r1", "Be excellent", "lead")
+    await store.compact()
+
+    // Coordination JSONL should be truncated
+    expect(await readFile(join(dataDir, "coordination.jsonl"), "utf8")).toBe("")
+
+    // Snapshot should have coordination
+    const snapshot = JSON.parse(await readFile(join(dataDir, "snapshot.json"), "utf8")) as SnapshotFile
+    expect(snapshot.coordination).toBeDefined()
+    expect(snapshot.coordination!.length).toBe(1)
+    expect(snapshot.coordination![0].workspaceId).toBe(workspaceId)
+
+    // New store should restore from snapshot
+    const store2 = new EventStore(dataDir)
+    await store2.initialize()
+    expect(store2.state.coordinationByWorkspace.get(workspaceId)!.todos.get("t1")?.description).toBe("Survive compaction")
+    expect(store2.state.coordinationByWorkspace.get(workspaceId)!.rules.get("r1")?.content).toBe("Be excellent")
+  })
+
+  test("clearStorage resets coordination state", async () => {
+    const { dataDir, store, workspaceId } = await createStoreWithProject()
+
+    await store.addTodo(workspaceId, "t1", "Will be cleared", "normal", "agent-1")
+
+    // Force a version mismatch to trigger clearStorage during replay
+    const coordPath = join(dataDir, "coordination.jsonl")
+    const { writeFile } = await import("node:fs/promises")
+    await writeFile(coordPath, '{"v":999,"type":"todo_added"}\n', "utf8")
+
+    const store2 = new EventStore(dataDir)
+    await store2.initialize()
+
+    // State should be empty after clearStorage
+    expect(store2.state.coordinationByWorkspace.size).toBe(0)
+  })
+})