airaknit 1.1.2-rc.9

package/src/server/read-models.ts

@@ -0,0 +1,258 @@
+import type {
+  ChatRuntime,
+  ChatSnapshot,
+  SessionStatus,
+  LocalWorkspacesSnapshot,
+  ProviderCatalogEntry,
+  RepoSummary,
+  SidebarChatRow,
+  SidebarData,
+  SidebarWorkspaceGroup,
+  TranscriptEntry,
+  TranscriptRenderUnit,
+} from "../shared/types"
+import { compareIndependentWorkspaces } from "../shared/types"
+import type { ChatRecord, StoreState, WorkspaceCoordinationState } from "./events"
+import { createEmptyCoordinationState } from "./events"
+import type { WorkspaceCoordinationSnapshot } from "../shared/workspace-types"
+import type { AgentConfigSnapshot } from "../shared/agent-config-types"
+import type { WorkflowRunsSnapshot } from "../shared/workflow-types"
+import { resolveLocalPath } from "./paths"
+import { SERVER_PROVIDERS } from "./provider-catalog"
+import { foldTranscriptRenderUnits } from "../shared/transcript-render"
+
+export const TRANSCRIPT_RENDER_WINDOW_SIZE = 200
+
+export function isTranscriptRenderLoadingStatus(status: SessionStatus | undefined): boolean {
+  return status === "starting" || status === "running" || status === "waiting_for_user" || status === "awaiting_agents"
+}
+
+export function deriveTranscriptRenderUnits(
+  entries: TranscriptEntry[],
+  status?: SessionStatus,
+): TranscriptRenderUnit[] {
+  return foldTranscriptRenderUnits(entries, { isLoading: isTranscriptRenderLoadingStatus(status) })
+}
+
+export function deriveStatus(
+  chat: ChatRecord,
+  activeStatus?: SessionStatus,
+  hasActiveBlockingDelegations?: (chatId: string) => boolean,
+): SessionStatus {
+  if (activeStatus) return activeStatus
+  if (chat.lastTurnOutcome === "failed") return "failed"
+  if (hasActiveBlockingDelegations?.(chat.id)) return "awaiting_agents"
+  return "idle"
+}
+
+export function deriveSidebarData(
+  state: StoreState,
+  activeStatuses: Map<string, SessionStatus>,
+  hasActiveBlockingDelegations?: (chatId: string) => boolean,
+): SidebarData {
+  const projects = [...state.workspacesById.values()]
+    .filter((project) => !project.deletedAt)
+    .sort((a, b) => b.updatedAt - a.updatedAt)
+
+  const workspaceGroups: SidebarWorkspaceGroup[] = projects.map((project) => {
+    const chats: SidebarChatRow[] = [...state.chatsById.values()]
+      .filter((chat) => chat.workspaceId === project.id && !chat.deletedAt)
+      .sort((a, b) => (b.lastMessageAt ?? b.updatedAt) - (a.lastMessageAt ?? a.updatedAt))
+      .map((chat) => ({
+        _id: chat.id,
+        _creationTime: chat.createdAt,
+        chatId: chat.id,
+        title: chat.title,
+        status: deriveStatus(chat, activeStatuses.get(chat.id), hasActiveBlockingDelegations),
+        unread: chat.unread,
+        localPath: project.localPath,
+        provider: chat.provider,
+        model: chat.model ?? null,
+        lastMessageAt: chat.lastMessageAt,
+        hasAutomation: false,
+      }))
+
+    return {
+      groupKey: project.id,
+      localPath: project.localPath,
+      chats,
+    }
+  })
+
+  const independentWorkspaces = [...state.independentWorkspacesById.values()]
+    .sort(compareIndependentWorkspaces)
+
+  return { workspaceGroups, independentWorkspaces }
+}
+
+export function deriveLocalWorkspacesSnapshot(
+  state: StoreState,
+  discoveredProjects: Array<{ localPath: string; title: string; modifiedAt: number }>,
+  machineName: string
+): LocalWorkspacesSnapshot {
+  const workspaces = new Map<string, LocalWorkspacesSnapshot["workspaces"][number]>()
+
+  for (const project of discoveredProjects) {
+    const normalizedPath = resolveLocalPath(project.localPath)
+    workspaces.set(normalizedPath, {
+      localPath: normalizedPath,
+      title: project.title,
+      source: "discovered",
+      lastOpenedAt: project.modifiedAt,
+      chatCount: 0,
+    })
+  }
+
+  for (const project of [...state.workspacesById.values()].filter((entry) => !entry.deletedAt)) {
+    const chats = [...state.chatsById.values()].filter((chat) => chat.workspaceId === project.id && !chat.deletedAt)
+    const lastOpenedAt = chats.reduce(
+      (latest, chat) => Math.max(latest, chat.lastMessageAt ?? chat.updatedAt ?? 0),
+      project.updatedAt
+    )
+
+    workspaces.set(project.localPath, {
+      localPath: project.localPath,
+      title: project.title,
+      source: "saved",
+      lastOpenedAt,
+      chatCount: chats.length,
+    })
+  }
+
+  return {
+    machine: {
+      id: "local",
+      displayName: machineName,
+    },
+    workspaces: [...workspaces.values()].sort((a, b) => (b.lastOpenedAt ?? 0) - (a.lastOpenedAt ?? 0)),
+  }
+}
+
+export function deriveChatSnapshot(
+  state: StoreState,
+  activeStatuses: Map<string, SessionStatus>,
+  chatId: string,
+  messageCount: number,
+  availableSkills?: string[],
+  hasActiveBlockingDelegations?: (chatId: string) => boolean,
+  renderUnits: TranscriptRenderUnit[] = [],
+  availableProviders: ProviderCatalogEntry[] = [...SERVER_PROVIDERS],
+): ChatSnapshot | null {
+  const chat = state.chatsById.get(chatId)
+  if (!chat || chat.deletedAt) return null
+  const project = state.workspacesById.get(chat.workspaceId)
+  if (!project || project.deletedAt) return null
+
+  const runtime: ChatRuntime = {
+    chatId: chat.id,
+    workspaceId: project.id,
+    localPath: project.localPath,
+    title: chat.title,
+    status: deriveStatus(chat, activeStatuses.get(chat.id), hasActiveBlockingDelegations),
+    provider: chat.provider,
+    model: chat.model ?? null,
+    planMode: chat.planMode,
+    sessionToken: chat.sessionToken,
+  }
+  const queuedTurn = state.queuedTurnsByChat.get(chatId) ?? null
+
+  return {
+    runtime,
+    messageCount,
+    renderUnits,
+    availableProviders,
+    availableSkills: availableSkills ?? [],
+    queuedTurn: queuedTurn ? { ...queuedTurn } : null,
+  }
+}
+
+/** Derive a coordination snapshot from any state with coordinationByWorkspace. */
+export function deriveCoordinationSnapshot(
+  state: { coordinationByWorkspace: Map<string, WorkspaceCoordinationState> },
+  workspaceId: string,
+): WorkspaceCoordinationSnapshot {
+  const coord = state.coordinationByWorkspace.get(workspaceId) ?? createEmptyCoordinationState()
+
+  const todos = [...coord.todos.values()]
+    .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
+
+  const claims = [...coord.claims.values()]
+    .filter((c) => c.status !== "released")
+
+  const worktrees = [...coord.worktrees.values()]
+    .filter((w) => w.status !== "removed")
+
+  const rules = [...coord.rules.values()]
+
+  return {
+    workspaceId,
+    todos,
+    claims,
+    worktrees,
+    rules,
+    lastUpdated: coord.lastUpdated,
+  }
+}
+
+/** Convenience overload accepting full StoreState (used by nats-publisher). */
+export function deriveWorkspaceCoordinationSnapshot(
+  state: StoreState,
+  workspaceId: string,
+): WorkspaceCoordinationSnapshot {
+  return deriveCoordinationSnapshot(state, workspaceId)
+}
+
+/** Derive repo list snapshot for a workspace. */
+export function deriveRepoListSnapshot(state: StoreState, workspaceId: string): { workspaceId: string; repos: RepoSummary[] } {
+  const repos: RepoSummary[] = []
+  for (const repo of state.reposById.values()) {
+    if (repo.workspaceId === workspaceId) {
+      repos.push({
+        id: repo.id,
+        workspaceId: repo.workspaceId,
+        label: repo.label,
+        origin: repo.origin,
+        localPath: repo.localPath,
+        status: repo.status,
+        branch: repo.branch,
+      })
+    }
+  }
+  return { workspaceId, repos }
+}
+
+/** Derive agent config snapshot for a workspace. */
+export function deriveAgentConfigSnapshot(
+  state: StoreState,
+  workspaceId: string,
+): AgentConfigSnapshot {
+  const configMap = state.agentConfigsByWorkspace.get(workspaceId)
+  const configs = configMap ? [...configMap.values()] : []
+  const lastUpdated = configs.length > 0
+    ? new Date(Math.max(...configs.map((c) => c.updatedAt))).toISOString()
+    : new Date(0).toISOString()
+  return { workspaceId, configs, lastUpdated }
+}
+
+/** Derive workflow runs snapshot for a workspace. */
+export function deriveWorkflowRunsSnapshot(
+  state: StoreState,
+  workspaceId: string,
+): WorkflowRunsSnapshot {
+  const runsMap = state.workflowRunsByWorkspace.get(workspaceId) ?? new Map()
+  const runs = [...runsMap.values()]
+    .sort((a, b) => b.startedAt - a.startedAt)
+    .slice(0, 50)
+  const activeRunIds = runs
+    .filter((r) => r.status === "running")
+    .map((r) => r.runId)
+  return { workspaceId, runs, activeRunIds }
+}
+
+export function deriveSandboxSnapshot(
+  state: StoreState,
+  workspaceId: string,
+): import("../shared/sandbox-types").SandboxSnapshot {
+  const sandbox = state.sandboxByWorkspace.get(workspaceId) ?? null
+  return { workspaceId, sandbox, health: null }
+}

package/src/server/repo-journey.test.ts

@@ -0,0 +1,96 @@
+import { describe, test, expect, afterEach } from "bun:test"
+import { EventStore } from "./event-store"
+import { deriveRepoListSnapshot, deriveWorkspaceCoordinationSnapshot } from "./read-models"
+import { rmSync, mkdirSync } from "node:fs"
+import { join } from "node:path"
+
+const TEST_DIR = join(import.meta.dir, ".test-repo-journey")
+
+afterEach(() => {
+  rmSync(TEST_DIR, { recursive: true, force: true })
+})
+
+async function createStoreWithProject() {
+  mkdirSync(TEST_DIR, { recursive: true })
+  const store = new EventStore(TEST_DIR)
+  await store.initialize()
+  const project = await store.openProject("/tmp/repo-journey-test", "RepoJourney")
+  return { store, workspaceId: project.id }
+}
+
+describe("repo journey", () => {
+  test("stage 7: add local repo appears in snapshot", async () => {
+    const { store, workspaceId } = await createStoreWithProject()
+
+    await store.addRepo("r-1", workspaceId, "/home/user/my-repo", "git@github.com:user/repo.git", "My Repo", "main")
+
+    const snapshot = deriveRepoListSnapshot(store.state, workspaceId)
+    expect(snapshot.workspaceId).toBe(workspaceId)
+    expect(snapshot.repos).toHaveLength(1)
+    expect(snapshot.repos[0].id).toBe("r-1")
+    expect(snapshot.repos[0].localPath).toBe("/home/user/my-repo")
+    expect(snapshot.repos[0].origin).toBe("git@github.com:user/repo.git")
+    expect(snapshot.repos[0].label).toBe("My Repo")
+    expect(snapshot.repos[0].branch).toBe("main")
+    expect(snapshot.repos[0].status).toBe("cloned")
+  })
+
+  test("stage 8: clone repo starts as pending", async () => {
+    const { store, workspaceId } = await createStoreWithProject()
+
+    await store.startRepoClone("r-2", workspaceId, "git@github.com:org/lib.git", "/tmp/clones/lib", "Lib Clone")
+
+    const snapshot = deriveRepoListSnapshot(store.state, workspaceId)
+    expect(snapshot.repos).toHaveLength(1)
+    expect(snapshot.repos[0].id).toBe("r-2")
+    expect(snapshot.repos[0].status).toBe("pending")
+    expect(snapshot.repos[0].origin).toBe("git@github.com:org/lib.git")
+  })
+
+  test("stage 10: remove repo disappears from snapshot", async () => {
+    const { store, workspaceId } = await createStoreWithProject()
+
+    await store.addRepo("r-3", workspaceId, "/home/user/old-repo", null, "Old Repo", null)
+    const before = deriveRepoListSnapshot(store.state, workspaceId)
+    expect(before.repos).toHaveLength(1)
+
+    await store.removeRepo("r-3", workspaceId)
+    const after = deriveRepoListSnapshot(store.state, workspaceId)
+    expect(after.repos).toHaveLength(0)
+  })
+
+  test("repo state survives compact and replay", async () => {
+    const { store, workspaceId } = await createStoreWithProject()
+
+    await store.addRepo("r-4", workspaceId, "/home/user/persist-repo", "https://github.com/user/persist.git", "Persist", "develop")
+
+    const snapshotBefore = deriveRepoListSnapshot(store.state, workspaceId)
+    expect(snapshotBefore.repos).toHaveLength(1)
+
+    await store.compact()
+
+    const store2 = new EventStore(TEST_DIR)
+    await store2.initialize()
+
+    const snapshotAfter = deriveRepoListSnapshot(store2.state, workspaceId)
+    expect(snapshotAfter.repos).toHaveLength(1)
+    expect(snapshotAfter.repos[0].id).toBe("r-4")
+    expect(snapshotAfter.repos[0].localPath).toBe("/home/user/persist-repo")
+    expect(snapshotAfter.repos[0].origin).toBe("https://github.com/user/persist.git")
+    expect(snapshotAfter.repos[0].label).toBe("Persist")
+    expect(snapshotAfter.repos[0].branch).toBe("develop")
+  })
+
+  test("claim release updates coordination snapshot", async () => {
+    const { store, workspaceId } = await createStoreWithProject()
+
+    await store.createClaim(workspaceId, "c-1", "Refactor auth", ["src/auth.ts"], "session-a")
+    const before = deriveWorkspaceCoordinationSnapshot(store.state, workspaceId)
+    expect(before.claims).toHaveLength(1)
+    expect(before.claims[0].id).toBe("c-1")
+
+    await store.releaseClaim(workspaceId, "c-1")
+    const after = deriveWorkspaceCoordinationSnapshot(store.state, workspaceId)
+    expect(after.claims).toHaveLength(0)
+  })
+})

package/src/server/repo-manager.test.ts

@@ -0,0 +1,118 @@
+import { describe, test, expect, afterEach } from "bun:test"
+import { mkdtemp, rm, writeFile } from "node:fs/promises"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { $ } from "bun"
+import { RepoManager } from "./repo-manager"
+
+const mgr = new RepoManager()
+
+let tempDirs: string[] = []
+
+async function makeTempDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "repo-mgr-test-"))
+  tempDirs.push(dir)
+  return dir
+}
+
+async function initRepo(dir: string): Promise<void> {
+  await $`git -C ${dir} init`.quiet()
+  await $`git -C ${dir} config user.email "test@test.com"`.quiet()
+  await $`git -C ${dir} config user.name "Test"`.quiet()
+}
+
+async function commitFile(dir: string, name = "file.txt", content = "hello"): Promise<void> {
+  await writeFile(join(dir, name), content)
+  await $`git -C ${dir} add ${name}`.quiet()
+  await $`git -C ${dir} commit -m "add ${name}"`.quiet()
+}
+
+async function getBranch(dir: string): Promise<string> {
+  return (await $`git -C ${dir} branch --show-current`.text()).trim()
+}
+
+afterEach(async () => {
+  for (const d of tempDirs) {
+    await rm(d, { recursive: true, force: true }).catch(() => {})
+  }
+  tempDirs = []
+})
+
+describe("RepoManager", () => {
+  test("addLocal — valid repo without remote", async () => {
+    const dir = await makeTempDir()
+    await initRepo(dir)
+    await commitFile(dir)
+    const branch = await getBranch(dir)
+
+    const result = await mgr.addLocal(dir)
+    expect(result.origin).toBeNull()
+    expect(result.branch).toBe(branch)
+  })
+
+  test("addLocal — repo with remote", async () => {
+    const dir = await makeTempDir()
+    await initRepo(dir)
+    await commitFile(dir)
+    await $`git -C ${dir} remote add origin https://example.com/repo.git`.quiet()
+
+    const result = await mgr.addLocal(dir)
+    expect(result.origin).toBe("https://example.com/repo.git")
+    expect(result.branch).toBeTruthy()
+  })
+
+  test("addLocal — invalid path throws", async () => {
+    await expect(mgr.addLocal("/tmp/nonexistent-path-xyz-999")).rejects.toThrow()
+  })
+
+  test("addLocal — not a git repo throws", async () => {
+    const dir = await makeTempDir()
+    await expect(mgr.addLocal(dir)).rejects.toThrow()
+  })
+
+  test("status — clean repo", async () => {
+    const dir = await makeTempDir()
+    await initRepo(dir)
+    await commitFile(dir)
+    const branch = await getBranch(dir)
+
+    const s = await mgr.status(dir)
+    expect(s.branch).toBe(branch)
+    expect(s.ahead).toBe(0)
+    expect(s.behind).toBe(0)
+    expect(s.dirty).toBe(false)
+  })
+
+  test("status — dirty repo", async () => {
+    const dir = await makeTempDir()
+    await initRepo(dir)
+    await commitFile(dir)
+    await writeFile(join(dir, "file.txt"), "modified")
+
+    const s = await mgr.status(dir)
+    expect(s.dirty).toBe(true)
+  })
+
+  test("clone — bare repo", async () => {
+    const bare = await makeTempDir()
+    await $`git init --bare ${bare}`.quiet()
+
+    const target = join(await makeTempDir(), "cloned")
+    await mgr.clone(bare, target)
+
+    const check = await $`git -C ${target} rev-parse --git-dir`.quiet()
+    expect(check.exitCode).toBe(0)
+  })
+
+  test("remove — is a no-op", async () => {
+    const dir = await makeTempDir()
+    await initRepo(dir)
+    await commitFile(dir)
+
+    await mgr.remove(dir)
+
+    // Directory and git repo still exist
+    const check = await $`git -C ${dir} rev-parse --git-dir`.quiet()
+    expect(check.exitCode).toBe(0)
+  })
+})

package/src/server/repo-manager.ts

@@ -0,0 +1,97 @@
+import { $ } from "bun"
+import { stat } from "node:fs/promises"
+
+const LOG_PREFIX = "[RepoManager]"
+
+export class RepoManager {
+  /** Validate path is a git repo, read remote origin + current branch */
+  async addLocal(localPath: string): Promise<{ origin: string | null; branch: string | null }> {
+    try {
+      await stat(localPath)
+    } catch (error) {
+      throw new Error(`${LOG_PREFIX} Path does not exist: ${localPath}`)
+    }
+
+    const gitCheck = await $`git -C ${localPath} rev-parse --git-dir`.quiet()
+    if (gitCheck.exitCode !== 0) {
+      throw new Error(`${LOG_PREFIX} Not a git repository: ${localPath}`)
+    }
+
+    let origin: string | null = null
+    const originResult = await $`git -C ${localPath} remote get-url origin`.quiet().nothrow()
+    if (originResult.exitCode === 0) {
+      origin = originResult.text().trim() || null
+    }
+
+    let branch: string | null = null
+    const branchResult = await $`git -C ${localPath} branch --show-current`.quiet()
+    if (branchResult.exitCode === 0) {
+      branch = branchResult.text().trim() || null
+    }
+
+    return { origin, branch }
+  }
+
+  /** Clone a remote repo to target path */
+  async clone(origin: string, targetPath: string): Promise<void> {
+    const result = await $`git clone ${origin} ${targetPath}`.quiet()
+    if (result.exitCode !== 0) {
+      throw new Error(`${LOG_PREFIX} Clone failed: ${result.stderr.toString().trim()}`)
+    }
+  }
+
+  /** Pull latest changes */
+  async pull(localPath: string, branch?: string): Promise<string> {
+    const args = branch ? [branch] : []
+    const result = await $`git -C ${localPath} pull ${args}`.quiet()
+    if (result.exitCode !== 0) {
+      throw new Error(`${LOG_PREFIX} Pull failed: ${result.stderr.toString().trim()}`)
+    }
+    return result.text().trim()
+  }
+
+  /** Push changes */
+  async push(localPath: string, branch?: string): Promise<string> {
+    const args = branch ? [branch] : []
+    const result = await $`git -C ${localPath} push ${args}`.quiet()
+    if (result.exitCode !== 0) {
+      throw new Error(`${LOG_PREFIX} Push failed: ${result.stderr.toString().trim()}`)
+    }
+    return result.text().trim()
+  }
+
+  /** Get repo status: branch, ahead/behind, dirty flag */
+  async status(localPath: string): Promise<{ branch: string; ahead: number; behind: number; dirty: boolean }> {
+    const result = await $`git -C ${localPath} status --porcelain=v2 --branch`.quiet()
+    if (result.exitCode !== 0) {
+      throw new Error(`${LOG_PREFIX} Status failed: ${result.stderr.toString().trim()}`)
+    }
+
+    const output = result.text()
+    let branch = ""
+    let ahead = 0
+    let behind = 0
+    let dirty = false
+
+    for (const line of output.split("\n")) {
+      if (line.startsWith("# branch.head ")) {
+        branch = line.slice("# branch.head ".length).trim()
+      } else if (line.startsWith("# branch.ab ")) {
+        const match = line.match(/\+(\d+) -(\d+)/)
+        if (match) {
+          ahead = parseInt(match[1], 10)
+          behind = parseInt(match[2], 10)
+        }
+      } else if (line.length > 0 && !line.startsWith("#")) {
+        dirty = true
+      }
+    }
+
+    return { branch, ahead, behind, dirty }
+  }
+
+  /** No-op — signals intent to remove, does NOT delete files */
+  async remove(_localPath: string): Promise<void> {
+    // intentional no-op
+  }
+}

package/src/server/repo-status.test.ts

@@ -0,0 +1,54 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtemp, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { execFile } from "node:child_process"
+import { promisify } from "node:util"
+import { readRepoStatus } from "./repo-status"
+
+const execFileAsync = promisify(execFile)
+const tempDirs: string[] = []
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })))
+})
+
+async function makeTempRepo() {
+  const dir = await mkdtemp(path.join(tmpdir(), "tinkaria-repo-status-"))
+  tempDirs.push(dir)
+  await execFileAsync("git", ["init", "-b", "main"], { cwd: dir })
+  await execFileAsync("git", ["config", "user.email", "test@example.com"], { cwd: dir })
+  await execFileAsync("git", ["config", "user.name", "Test User"], { cwd: dir })
+  await writeFile(path.join(dir, "tracked.txt"), "hello\n")
+  await execFileAsync("git", ["add", "tracked.txt"], { cwd: dir })
+  await execFileAsync("git", ["commit", "-m", "init"], { cwd: dir })
+  return dir
+}
+
+describe("readRepoStatus", () => {
+  test("returns null-ish git metadata for non-repos", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "tinkaria-non-repo-"))
+    tempDirs.push(dir)
+
+    const status = await readRepoStatus(dir)
+    expect(status.isRepo).toBe(false)
+    expect(status.branch).toBeNull()
+  })
+
+  test("reports branch and dirty counts for repos", async () => {
+    const dir = await makeTempRepo()
+    await execFileAsync("git", ["checkout", "-b", "feat/status-bar"], { cwd: dir })
+    await writeFile(path.join(dir, "tracked.txt"), "changed\n")
+    await writeFile(path.join(dir, "staged.txt"), "staged\n")
+    await writeFile(path.join(dir, "new.txt"), "new\n")
+    await execFileAsync("git", ["add", "staged.txt"], { cwd: dir })
+
+    const status = await readRepoStatus(dir)
+
+    expect(status.isRepo).toBe(true)
+    expect(status.branch).toBe("feat/status-bar")
+    expect(status.stagedCount).toBe(1)
+    expect(status.unstagedCount).toBe(1)
+    expect(status.untrackedCount).toBe(1)
+  })
+})