airaknit 1.1.2-rc.9

package/src/server/quick-response.ts

@@ -0,0 +1,154 @@
+import { query } from "@anthropic-ai/claude-agent-sdk"
+import { CodexAppServerManager } from "./codex-app-server"
+
+const CLAUDE_STRUCTURED_TIMEOUT_MS = 5_000
+
+type JsonSchema = {
+  type: "object"
+  properties: Record<string, unknown>
+  required?: readonly string[]
+  additionalProperties?: boolean
+}
+
+export interface StructuredQuickResponseArgs<T> {
+  cwd: string
+  task: string
+  prompt: string
+  schema: JsonSchema
+  parse: (value: unknown) => T | null
+}
+
+interface QuickResponseAdapterArgs {
+  codexManager?: CodexAppServerManager
+  runClaudeStructured?: (args: Omit<StructuredQuickResponseArgs<unknown>, "parse">) => Promise<unknown | null>
+  runCodexStructured?: (args: Omit<StructuredQuickResponseArgs<unknown>, "parse">) => Promise<unknown | null>
+}
+
+function parseJsonText(value: string): unknown | null {
+  const trimmed = value.trim()
+  if (!trimmed) return null
+
+  const candidates = [trimmed]
+  const fencedMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i)
+  if (fencedMatch?.[1]) {
+    candidates.unshift(fencedMatch[1].trim())
+  }
+
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(candidate)
+    } catch {
+      continue
+    }
+  }
+
+  return null
+}
+
+async function runClaudeStructured(args: Omit<StructuredQuickResponseArgs<unknown>, "parse">): Promise<unknown | null> {
+  const q = query({
+    prompt: args.prompt,
+    options: {
+      model: "haiku",
+      tools: [],
+      systemPrompt: "",
+      effort: "low",
+      permissionMode: "bypassPermissions",
+      outputFormat: {
+        type: "json_schema",
+        schema: args.schema,
+      },
+      persistSession: false,
+      env: { ...process.env },
+    },
+  })
+
+  try {
+    const result = await Promise.race<unknown | null>([
+      (async () => {
+        for await (const message of q) {
+          if ("result" in message) {
+            return (message as Record<string, unknown>).structured_output ?? null
+          }
+        }
+        return null
+      })(),
+      new Promise<null>((_, reject) => {
+        setTimeout(() => {
+          reject(new Error(`Claude structured response timed out after ${CLAUDE_STRUCTURED_TIMEOUT_MS}ms`))
+        }, CLAUDE_STRUCTURED_TIMEOUT_MS)
+      }),
+    ])
+
+    return result
+  } catch (error) {
+    return null
+  } finally {
+    try {
+      q.close()
+    } catch {
+      // Ignore close failures on timed-out or failed quick responses.
+    }
+  }
+}
+
+async function runCodexStructured(
+  codexManager: CodexAppServerManager,
+  args: Omit<StructuredQuickResponseArgs<unknown>, "parse">
+): Promise<unknown | null> {
+  const response = await codexManager.generateStructured({
+    cwd: args.cwd,
+    prompt: `${args.prompt}\n\nReturn JSON only that matches this schema:\n${JSON.stringify(args.schema, null, 2)}`,
+  })
+  if (typeof response !== "string") return null
+  return parseJsonText(response)
+}
+
+export class QuickResponseAdapter {
+  private readonly codexManager: CodexAppServerManager
+  private readonly runClaudeStructured: (args: Omit<StructuredQuickResponseArgs<unknown>, "parse">) => Promise<unknown | null>
+  private readonly runCodexStructured: (args: Omit<StructuredQuickResponseArgs<unknown>, "parse">) => Promise<unknown | null>
+
+  constructor(args: QuickResponseAdapterArgs = {}) {
+    this.codexManager = args.codexManager ?? new CodexAppServerManager()
+    this.runClaudeStructured = args.runClaudeStructured ?? runClaudeStructured
+    this.runCodexStructured = args.runCodexStructured ?? ((structuredArgs) =>
+      runCodexStructured(this.codexManager, structuredArgs))
+  }
+  async generateStructured<T>(args: StructuredQuickResponseArgs<T>): Promise<T | null> {
+    const request = {
+      cwd: args.cwd,
+      task: args.task,
+      prompt: args.prompt,
+      schema: args.schema,
+    }
+
+    const claudeResult = await this.tryProvider("claude", args.task, args.parse, () => this.runClaudeStructured(request))
+    if (claudeResult !== null) return claudeResult
+
+    return await this.tryProvider("codex", args.task, args.parse, () => this.runCodexStructured(request))
+  }
+
+  private async tryProvider<T>(
+    provider: "claude" | "codex",
+    task: string,
+    parse: (value: unknown) => T | null,
+    run: () => Promise<unknown | null>
+  ): Promise<T | null> {
+    try {
+      const result = await run()
+      if (result === null) {
+        return null
+      }
+  
+      const parsed = parse(result)
+      if (parsed === null) {
+        return null
+      }
+  
+      return parsed
+    } catch (error) {
+      return null
+    }
+  }
+}

package/src/server/read-models-agent-config.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test"
+import { deriveAgentConfigSnapshot } from "./read-models"
+import { createEmptyState } from "./events"
+import type { AgentConfigRecord } from "../shared/agent-config-types"
+
+describe("deriveAgentConfigSnapshot", () => {
+  test("returns correct structure from populated state", () => {
+    const state = createEmptyState()
+    const workspaceId = "ws-1"
+    const now = Date.now()
+
+    const records = new Map<string, AgentConfigRecord>()
+    records.set("a1", {
+      id: "a1",
+      workspaceId,
+      config: {
+        id: "a1",
+        name: "Agent Alpha",
+        description: "Test",
+        provider: "claude",
+        model: "opus-4",
+      },
+      createdAt: now - 1000,
+      updatedAt: now,
+      lastCommitHash: "abc123",
+    })
+    records.set("a2", {
+      id: "a2",
+      workspaceId,
+      config: {
+        id: "a2",
+        name: "Agent Beta",
+        description: "Test 2",
+        provider: "codex",
+        model: "gpt-5.4",
+      },
+      createdAt: now - 500,
+      updatedAt: now - 200,
+    })
+    state.agentConfigsByWorkspace.set(workspaceId, records)
+
+    const snapshot = deriveAgentConfigSnapshot(state, workspaceId)
+
+    expect(snapshot.workspaceId).toBe(workspaceId)
+    expect(snapshot.configs).toHaveLength(2)
+    expect(snapshot.lastUpdated).toBe(new Date(now).toISOString())
+    const ids = snapshot.configs.map((c) => c.id).sort()
+    expect(ids).toEqual(["a1", "a2"])
+  })
+
+  test("returns empty configs for unknown workspace", () => {
+    const state = createEmptyState()
+    const snapshot = deriveAgentConfigSnapshot(state, "nonexistent")
+
+    expect(snapshot.workspaceId).toBe("nonexistent")
+    expect(snapshot.configs).toHaveLength(0)
+    expect(snapshot.lastUpdated).toBe(new Date(0).toISOString())
+  })
+})

package/src/server/read-models-coordination.test.ts

@@ -0,0 +1,69 @@
+import { describe, test, expect } from "bun:test"
+import { deriveWorkspaceCoordinationSnapshot } from "./read-models"
+import { createEmptyState, createEmptyCoordinationState } from "./events"
+
+describe("deriveWorkspaceCoordinationSnapshot", () => {
+  test("returns empty snapshot for unknown project", () => {
+    const state = createEmptyState()
+    const snapshot = deriveWorkspaceCoordinationSnapshot(state, "unknown-proj")
+    expect(snapshot).toEqual({
+      workspaceId: "unknown-proj",
+      todos: [],
+      claims: [],
+      worktrees: [],
+      rules: [],
+      lastUpdated: expect.any(String),
+    })
+  })
+
+  test("returns todos sorted by updatedAt desc", () => {
+    const state = createEmptyState()
+    const coord = createEmptyCoordinationState()
+    coord.todos.set("t-1", {
+      id: "t-1", description: "First", priority: "normal", status: "open",
+      claimedBy: null, outputs: [], createdBy: "s-1",
+      createdAt: "2026-04-10T00:00:00.000Z", updatedAt: "2026-04-10T00:00:00.000Z",
+    })
+    coord.todos.set("t-2", {
+      id: "t-2", description: "Second", priority: "high", status: "claimed",
+      claimedBy: "s-2", outputs: [], createdBy: "s-1",
+      createdAt: "2026-04-10T01:00:00.000Z", updatedAt: "2026-04-10T01:00:00.000Z",
+    })
+    coord.lastUpdated = "2026-04-10T01:00:00.000Z"
+    state.coordinationByWorkspace.set("proj-1", coord)
+
+    const snapshot = deriveWorkspaceCoordinationSnapshot(state, "proj-1")
+    expect(snapshot.todos).toHaveLength(2)
+    expect(snapshot.todos[0].id).toBe("t-2")
+    expect(snapshot.lastUpdated).toBe("2026-04-10T01:00:00.000Z")
+  })
+
+  test("filters out released claims and removed worktrees", () => {
+    const state = createEmptyState()
+    const coord = createEmptyCoordinationState()
+    coord.claims.set("c-1", {
+      id: "c-1", intent: "active", files: ["a.ts"], sessionId: "s-1",
+      status: "active", conflictsWith: null, createdAt: "2026-04-10T00:00:00.000Z",
+    })
+    coord.claims.set("c-2", {
+      id: "c-2", intent: "released", files: ["b.ts"], sessionId: "s-2",
+      status: "released", conflictsWith: null, createdAt: "2026-04-10T00:00:00.000Z",
+    })
+    coord.worktrees.set("wt-1", {
+      id: "wt-1", branch: "main", baseBranch: "main", path: "/tmp/wt",
+      assignedTo: null, status: "ready", createdAt: "2026-04-10T00:00:00.000Z",
+    })
+    coord.worktrees.set("wt-2", {
+      id: "wt-2", branch: "old", baseBranch: "main", path: "/tmp/wt2",
+      assignedTo: null, status: "removed", createdAt: "2026-04-10T00:00:00.000Z",
+    })
+    coord.lastUpdated = "2026-04-10T00:00:00.000Z"
+    state.coordinationByWorkspace.set("proj-1", coord)
+
+    const snapshot = deriveWorkspaceCoordinationSnapshot(state, "proj-1")
+    expect(snapshot.claims).toHaveLength(1)
+    expect(snapshot.claims[0].id).toBe("c-1")
+    expect(snapshot.worktrees).toHaveLength(1)
+    expect(snapshot.worktrees[0].id).toBe("wt-1")
+  })
+})

package/src/server/read-models.test.ts

@@ -0,0 +1,332 @@
+import { describe, expect, test } from "bun:test"
+import { deriveChatSnapshot, deriveLocalWorkspacesSnapshot, deriveSidebarData, deriveStatus } from "./read-models"
+import { createEmptyState } from "./events"
+import type { ChatRecord } from "./events"
+
+function makeChatRecord(overrides?: Partial<ChatRecord>): ChatRecord {
+  return {
+    id: "chat-1",
+    workspaceId: "project-1",
+    repoId: null,
+    title: "Chat",
+    createdAt: 1,
+    updatedAt: 1,
+    unread: false,
+    provider: "claude",
+    planMode: false,
+    sessionToken: null,
+    lastTurnOutcome: null,
+    ...overrides,
+  }
+}
+
+describe("deriveStatus", () => {
+  test("returns 'awaiting_agents' when idle and has active blocking delegations", () => {
+    const chat = makeChatRecord()
+    const lookup = (id: string) => id === "chat-1"
+    expect(deriveStatus(chat, undefined, lookup)).toBe("awaiting_agents")
+  })
+
+  test("returns 'idle' when delegation lookup returns false", () => {
+    const chat = makeChatRecord()
+    const lookup = (_id: string) => false
+    expect(deriveStatus(chat, undefined, lookup)).toBe("idle")
+  })
+
+  test("returns active status even with active delegations (active status takes priority)", () => {
+    const chat = makeChatRecord()
+    const lookup = (id: string) => id === "chat-1"
+    expect(deriveStatus(chat, "running", lookup)).toBe("running")
+  })
+
+  test("returns 'failed' even with active delegations (failed takes priority)", () => {
+    const chat = makeChatRecord({ lastTurnOutcome: "failed" })
+    const lookup = (id: string) => id === "chat-1"
+    expect(deriveStatus(chat, undefined, lookup)).toBe("failed")
+  })
+})
+
+describe("read models", () => {
+  test("include provider and model data in sidebar rows", () => {
+    const state = createEmptyState()
+    state.workspacesById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Project",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+    state.workspaceIdsByPath.set("/tmp/project", "project-1")
+    state.chatsById.set("chat-1", {
+      id: "chat-1",
+      workspaceId: "project-1",
+    repoId: null,
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      unread: false,
+      provider: "codex",
+      model: "gpt-5.4",
+      planMode: false,
+      sessionToken: "thread-1",
+      lastTurnOutcome: null,
+    })
+
+    const sidebar = deriveSidebarData(state, new Map())
+    expect(sidebar.workspaceGroups[0]?.chats[0]?.provider).toBe("codex")
+    expect(sidebar.workspaceGroups[0]?.chats[0]?.model).toBe("gpt-5.4")
+  })
+
+  test("includes available providers in chat snapshots", () => {
+    const state = createEmptyState()
+    state.workspacesById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Project",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+    state.workspaceIdsByPath.set("/tmp/project", "project-1")
+    state.chatsById.set("chat-1", {
+      id: "chat-1",
+      workspaceId: "project-1",
+    repoId: null,
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      unread: false,
+      provider: "claude",
+      planMode: true,
+      sessionToken: "session-1",
+      lastTurnOutcome: null,
+    })
+
+    const chat = deriveChatSnapshot(state, new Map(), "chat-1", 0)
+    expect(chat?.runtime.provider).toBe("claude")
+    expect(chat?.runtime.model).toBeNull()
+    expect(chat?.availableProviders.length).toBeGreaterThan(1)
+    expect(chat?.availableProviders.find((provider) => provider.id === "codex")?.models.map((model) => model.id)).toEqual([
+      "gpt-5.4",
+      "gpt-5.3-codex",
+      "gpt-5.3-codex-spark",
+    ])
+  })
+
+  test("includes available skills in chat snapshot when provided", () => {
+    const state = createEmptyState()
+    state.workspacesById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Project",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+    state.workspaceIdsByPath.set("/tmp/project", "project-1")
+    state.chatsById.set("chat-1", {
+      id: "chat-1",
+      workspaceId: "project-1",
+    repoId: null,
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      unread: false,
+      provider: "claude",
+      planMode: false,
+      sessionToken: null,
+      lastTurnOutcome: null,
+    })
+
+    const chat = deriveChatSnapshot(state, new Map(), "chat-1", 0, ["skill-a", "skill-b"])
+    expect(chat?.availableSkills).toEqual(["skill-a", "skill-b"])
+  })
+
+  test("includes a server-owned queued turn in chat snapshots", () => {
+    const state = createEmptyState()
+    state.workspacesById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Project",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+    state.workspaceIdsByPath.set("/tmp/project", "project-1")
+    state.chatsById.set("chat-1", {
+      id: "chat-1",
+      workspaceId: "project-1",
+      repoId: null,
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      unread: false,
+      provider: "codex",
+      model: "gpt-5.4",
+      planMode: false,
+      sessionToken: "session-1",
+      lastTurnOutcome: null,
+    })
+    state.queuedTurnsByChat.set("chat-1", {
+      chatId: "chat-1",
+      provider: "codex",
+      content: "Queued follow-up",
+      model: "gpt-5.4",
+      planMode: true,
+      updatedAt: 2,
+    })
+
+    const chat = deriveChatSnapshot(state, new Map([["chat-1", "running"]]), "chat-1", 0)
+
+    expect(chat?.queuedTurn).toEqual({
+      chatId: "chat-1",
+      provider: "codex",
+      content: "Queued follow-up",
+      model: "gpt-5.4",
+      modelOptions: undefined,
+      effort: undefined,
+      planMode: true,
+      updatedAt: 2,
+    })
+  })
+
+  test("includes folded render units in chat snapshots", () => {
+    const state = createEmptyState()
+    state.workspacesById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Project",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+    state.workspaceIdsByPath.set("/tmp/project", "project-1")
+    state.chatsById.set("chat-1", {
+      id: "chat-1",
+      workspaceId: "project-1",
+      repoId: null,
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      unread: false,
+      provider: "codex",
+      model: "gpt-5.4",
+      planMode: false,
+      sessionToken: "session-1",
+      lastTurnOutcome: null,
+    })
+
+    const chat = deriveChatSnapshot(state, new Map(), "chat-1", 3, [], undefined, [
+      {
+        kind: "assistant_response",
+        id: "assistant_response:e1",
+        sourceEntryIds: ["e1"],
+        message: {
+          kind: "assistant_text",
+          id: "e1",
+          timestamp: "2026-04-16T00:00:00.000Z",
+          text: "Done",
+        },
+      },
+    ])
+
+    expect(chat?.renderUnits.map((unit) => unit.id)).toEqual(["assistant_response:e1"])
+  })
+
+  test("includes the persisted chat model in chat runtime", () => {
+    const state = createEmptyState()
+    state.workspacesById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Project",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+    state.workspaceIdsByPath.set("/tmp/project", "project-1")
+    state.chatsById.set("chat-1", {
+      id: "chat-1",
+      workspaceId: "project-1",
+    repoId: null,
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      unread: false,
+      provider: "claude",
+      model: "sonnet[1m]",
+      planMode: false,
+      sessionToken: "session-1",
+      lastTurnOutcome: null,
+    })
+
+    const chat = deriveChatSnapshot(state, new Map(), "chat-1", 0)
+    expect(chat?.runtime.model).toBe("sonnet[1m]")
+  })
+
+  test("defaults availableSkills to empty array when not provided", () => {
+    const state = createEmptyState()
+    state.workspacesById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Project",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+    state.workspaceIdsByPath.set("/tmp/project", "project-1")
+    state.chatsById.set("chat-1", {
+      id: "chat-1",
+      workspaceId: "project-1",
+    repoId: null,
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      unread: false,
+      provider: "claude",
+      planMode: false,
+      sessionToken: null,
+      lastTurnOutcome: null,
+    })
+
+    const chat = deriveChatSnapshot(state, new Map(), "chat-1", 0)
+    expect(chat?.availableSkills).toEqual([])
+  })
+
+  test("prefers saved project metadata over discovered entries for the same path", () => {
+    const state = createEmptyState()
+    state.workspacesById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Saved Project",
+      createdAt: 1,
+      updatedAt: 50,
+    })
+    state.workspaceIdsByPath.set("/tmp/project", "project-1")
+    state.chatsById.set("chat-1", {
+      id: "chat-1",
+      workspaceId: "project-1",
+    repoId: null,
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 75,
+      unread: false,
+      provider: "codex",
+      planMode: false,
+      sessionToken: null,
+      lastMessageAt: 100,
+      lastTurnOutcome: null,
+    })
+
+    const snapshot = deriveLocalWorkspacesSnapshot(state, [
+      {
+        localPath: "/tmp/project",
+        title: "Discovered Project",
+        modifiedAt: 10,
+      },
+    ], "Local Machine")
+
+    expect(snapshot.workspaces).toEqual([
+      {
+        localPath: "/tmp/project",
+        title: "Saved Project",
+        source: "saved",
+        lastOpenedAt: 100,
+        chatCount: 1,
+      },
+    ])
+  })
+})