kaizenai 0.1.0

package/src/server/quick-response.ts

@@ -0,0 +1,153 @@
+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,
+      },
+      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.ts

@@ -0,0 +1,275 @@
+import path from "node:path"
+import { existsSync, readdirSync, statSync } from "node:fs"
+import { homedir } from "node:os"
+import type {
+  ChatPendingToolSnapshot,
+  ChatRuntime,
+  ChatSnapshot,
+  ChatUsageSnapshot,
+  DirectoryBrowserSnapshot,
+  KaizenStatus,
+  LocalProjectsSnapshot,
+  ProviderSettingsSnapshot,
+  ProviderUsageMap,
+  SuggestedProjectFolder,
+  SidebarChatRow,
+  SidebarData,
+  SidebarFeatureRow,
+  SidebarProjectGroup,
+} from "../shared/types"
+import type { ChatRecord, StoreState } from "./events"
+import { getDefaultDirectoryRoot, resolveLocalPath } from "./paths"
+import { getProviderInactiveMessage, getSelectableProviders } from "../shared/types"
+import { resolveProjectIconDataUrl } from "./project-icon"
+
+function deriveLastChatModel(chatId: string, getMessages: (chatId: string) => ChatSnapshot["messages"]): string | null {
+  const entries = getMessages(chatId)
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index]
+    if (entry.kind === "system_init") {
+      return entry.model
+    }
+  }
+  return null
+}
+
+export function deriveStatus(chat: ChatRecord, activeStatus?: KaizenStatus): KaizenStatus {
+  if (activeStatus) return activeStatus
+  if (chat.lastTurnOutcome === "failed") return "failed"
+  return "idle"
+}
+
+export function deriveSidebarData(
+  state: StoreState,
+  activeStatuses: Map<string, KaizenStatus>,
+  providerUsage?: ProviderUsageMap
+): SidebarData {
+  const iconDataUrlByPath = new Map<string, string | null>()
+  const getProjectIconDataUrl = (localPath: string) => {
+    const normalizedPath = resolveLocalPath(localPath)
+    if (!iconDataUrlByPath.has(normalizedPath)) {
+      iconDataUrlByPath.set(normalizedPath, resolveProjectIconDataUrl(normalizedPath))
+    }
+    return iconDataUrlByPath.get(normalizedPath) ?? null
+  }
+
+  const projects = [...state.projectsById.values()]
+    .filter((project) => !project.deletedAt && !state.hiddenProjectKeys.has(project.repoKey))
+    .sort((a, b) => b.updatedAt - a.updatedAt)
+
+  const projectGroups: SidebarProjectGroup[] = projects.map((project) => {
+    const chats: SidebarChatRow[] = [...state.chatsById.values()]
+      .filter((chat) => chat.projectId === 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)),
+        localPath: project.localPath,
+        provider: chat.provider,
+        lastMessageAt: chat.lastMessageAt,
+        hasAutomation: false,
+        featureId: chat.featureId ?? null,
+      }))
+
+    const features: SidebarFeatureRow[] = [...state.featuresById.values()]
+      .filter((feature) => feature.projectId === project.id && !feature.deletedAt)
+      .sort((a, b) => {
+        const aDone = a.stage === "done" ? 1 : 0
+        const bDone = b.stage === "done" ? 1 : 0
+        if (aDone !== bDone) return aDone - bDone
+        if (a.sortOrder !== b.sortOrder) return a.sortOrder - b.sortOrder
+        return b.updatedAt - a.updatedAt
+      })
+      .map((feature) => ({
+        featureId: feature.id,
+        title: feature.title,
+        description: feature.description,
+        browserState: feature.browserState,
+        stage: feature.stage,
+        sortOrder: feature.sortOrder,
+        directoryRelativePath: feature.directoryRelativePath,
+        overviewRelativePath: feature.overviewRelativePath,
+        updatedAt: feature.updatedAt,
+        chats: chats.filter((chat) => chat.featureId === feature.id),
+      }))
+
+    return {
+      groupKey: project.id,
+      title: project.title,
+      localPath: project.localPath,
+      iconDataUrl: getProjectIconDataUrl(project.localPath),
+      browserState: project.browserState,
+      generalChatsBrowserState: project.generalChatsBrowserState,
+      features,
+      generalChats: chats.filter((chat) => !chat.featureId),
+    }
+  })
+
+  return { projectGroups, providerUsage }
+}
+
+export function deriveLocalProjectsSnapshot(
+  state: StoreState,
+  discoveredProjects: Array<{ repoKey: string; localPath: string; worktreePaths?: string[]; title: string; modifiedAt: number }>,
+  machineName: string
+): LocalProjectsSnapshot {
+  const projects = new Map<string, LocalProjectsSnapshot["projects"][number]>()
+  const iconDataUrlByPath = new Map<string, string | null>()
+  const getProjectIconDataUrl = (localPath: string) => {
+    const normalizedPath = resolveLocalPath(localPath)
+    if (!iconDataUrlByPath.has(normalizedPath)) {
+      iconDataUrlByPath.set(normalizedPath, resolveProjectIconDataUrl(normalizedPath))
+    }
+    return iconDataUrlByPath.get(normalizedPath) ?? null
+  }
+
+  for (const project of discoveredProjects) {
+    const normalizedPath = resolveLocalPath(project.localPath)
+    projects.set(project.repoKey, {
+      localPath: normalizedPath,
+      title: project.title,
+      iconDataUrl: getProjectIconDataUrl(normalizedPath),
+      source: "discovered",
+      lastOpenedAt: project.modifiedAt,
+      chatCount: 0,
+    })
+  }
+
+  for (const project of [...state.projectsById.values()].filter((entry) => !entry.deletedAt && !state.hiddenProjectKeys.has(entry.repoKey))) {
+    const chats = [...state.chatsById.values()].filter((chat) => chat.projectId === project.id && !chat.deletedAt)
+    const lastOpenedAt = chats.reduce(
+      (latest, chat) => Math.max(latest, chat.lastMessageAt ?? chat.updatedAt ?? 0),
+      project.updatedAt
+    )
+
+    projects.set(project.repoKey, {
+      localPath: project.localPath,
+      title: project.title,
+      iconDataUrl: getProjectIconDataUrl(project.localPath),
+      source: "saved",
+      lastOpenedAt,
+      chatCount: chats.length,
+    })
+  }
+
+  const suggestedFolders = deriveSuggestedProjectFolders(state, discoveredProjects)
+  const rootDirectory = deriveRootDirectorySnapshot()
+
+  return {
+    machine: {
+      id: "local",
+      displayName: machineName,
+    },
+    projects: [...projects.values()].sort((a, b) => (b.lastOpenedAt ?? 0) - (a.lastOpenedAt ?? 0)),
+    suggestedFolders,
+    rootDirectory,
+  }
+}
+
+function deriveRootDirectorySnapshot(): DirectoryBrowserSnapshot | null {
+  const currentPath = getDefaultDirectoryRoot()
+
+  try {
+    const entries = readdirSync(currentPath, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => ({
+        name: entry.name,
+        localPath: path.join(currentPath, entry.name),
+      }))
+      .sort((a, b) => a.name.localeCompare(b.name))
+
+    return {
+      currentPath,
+      parentPath: path.dirname(currentPath) === currentPath ? null : path.dirname(currentPath),
+      roots: [{ name: currentPath, localPath: currentPath }],
+      entries,
+    }
+  } catch {
+    return null
+  }
+}
+
+function deriveSuggestedProjectFolders(
+  state: StoreState,
+  discoveredProjects: Array<{ localPath: string }>
+): SuggestedProjectFolder[] {
+  const candidates = new Map<string, string>()
+  const home = homedir()
+
+  const addCandidate = (label: string, candidatePath: string | null | undefined) => {
+    if (!candidatePath) return
+    const resolvedPath = resolveLocalPath(candidatePath)
+    if (candidates.has(resolvedPath)) return
+    if (!existsSync(resolvedPath)) return
+    try {
+      if (!statSync(resolvedPath).isDirectory()) return
+    } catch {
+      return
+    }
+    candidates.set(resolvedPath, label)
+  }
+
+  addCandidate("Home", home)
+  addCandidate("Documents", path.join(home, "Documents"))
+  addCandidate("Projects", path.join(home, "projects"))
+  addCandidate("Projects", path.join(home, "Projects"))
+  addCandidate("Downloads", path.join(home, "Downloads"))
+  addCandidate("Desktop", path.join(home, "Desktop"))
+  addCandidate("Current Project", process.cwd())
+  addCandidate("Current Project Parent", path.dirname(process.cwd()))
+
+  for (const project of discoveredProjects) {
+    addCandidate(`Nearby: ${path.basename(project.localPath) || project.localPath}`, project.localPath)
+    addCandidate(`Parent: ${path.basename(path.dirname(project.localPath)) || path.dirname(project.localPath)}`, path.dirname(project.localPath))
+  }
+
+  for (const project of state.projectsById.values()) {
+    if (project.deletedAt) continue
+    addCandidate(`Saved: ${project.title}`, project.localPath)
+    addCandidate(`Parent: ${path.basename(path.dirname(project.localPath)) || path.dirname(project.localPath)}`, path.dirname(project.localPath))
+  }
+
+  return [...candidates.entries()]
+    .map(([localPath, label]) => ({ localPath, label }))
+    .slice(0, 12)
+}
+
+export function deriveChatSnapshot(
+  state: StoreState,
+  activeStatuses: Map<string, KaizenStatus>,
+  chatId: string,
+  getMessages: (chatId: string) => ChatSnapshot["messages"],
+  pendingTool: ChatPendingToolSnapshot | null = null,
+  usage: ChatUsageSnapshot | null = null,
+  providerSettings?: ProviderSettingsSnapshot["settings"]
+): ChatSnapshot | null {
+  const chat = state.chatsById.get(chatId)
+  if (!chat || chat.deletedAt) return null
+  const project = state.projectsById.get(chat.projectId)
+  if (!project || project.deletedAt) return null
+
+  const runtime: ChatRuntime = {
+    chatId: chat.id,
+    projectId: project.id,
+    localPath: project.localPath,
+    title: chat.title,
+    status: deriveStatus(chat, activeStatuses.get(chat.id)),
+    provider: chat.provider,
+    model: deriveLastChatModel(chat.id, getMessages),
+    planMode: chat.planMode,
+    sessionToken: chat.sessionToken,
+    pendingTool,
+    inactiveProviderMessage: chat.provider ? getProviderInactiveMessage(chat.provider, providerSettings) : null,
+  }
+
+  return {
+    runtime,
+    messages: getMessages(chat.id),
+    usage,
+    availableProviders: getSelectableProviders(providerSettings),
+    providerSettings,
+  }
+}