kaizenai 0.1.0

package/src/server/events.ts

@@ -0,0 +1,244 @@
+import type { AgentProvider, FeatureBrowserState, FeatureStage, FeatureSummary, ProjectSummary, TranscriptEntry } from "../shared/types"
+
+export interface ProjectRecord extends ProjectSummary {
+  deletedAt?: number
+}
+
+export interface FeatureRecord extends FeatureSummary {
+  deletedAt?: number
+}
+
+export interface ChatRecord {
+  id: string
+  projectId: string
+  title: string
+  createdAt: number
+  updatedAt: number
+  deletedAt?: number
+  featureId?: string | null
+  provider: AgentProvider | null
+  planMode: boolean
+  sessionToken: string | null
+  lastMessageAt?: number
+  lastTurnOutcome: "success" | "failed" | "cancelled" | null
+}
+
+export interface StoreState {
+  projectsById: Map<string, ProjectRecord>
+  projectIdsByRepoKey: Map<string, string>
+  projectIdsByPath: Map<string, string>
+  featuresById: Map<string, FeatureRecord>
+  chatsById: Map<string, ChatRecord>
+  hiddenProjectKeys: Set<string>
+}
+
+export interface SnapshotFile {
+  v: 3
+  generatedAt: number
+  projects: ProjectRecord[]
+  features: FeatureRecord[]
+  chats: ChatRecord[]
+  messages?: Array<{ chatId: string; entries: TranscriptEntry[] }>
+  hiddenProjectKeys?: string[]
+}
+
+export type ProjectEvent = {
+  v: 3
+  type: "project_opened"
+  timestamp: number
+  projectId: string
+  repoKey: string
+  localPath: string
+  worktreePaths: string[]
+  title: string
+  browserState?: FeatureBrowserState
+  generalChatsBrowserState?: FeatureBrowserState
+} | {
+  v: 3
+  type: "project_worktree_added"
+  timestamp: number
+  projectId: string
+  localPath: string
+} | {
+  v: 3
+  type: "project_browser_state_set"
+  timestamp: number
+  projectId: string
+  browserState: FeatureBrowserState
+} | {
+  v: 3
+  type: "project_general_chats_browser_state_set"
+  timestamp: number
+  projectId: string
+  browserState: FeatureBrowserState
+} | {
+  v: 3
+  type: "project_removed"
+  timestamp: number
+  projectId: string
+} | {
+  v: 3
+  type: "project_hidden"
+  timestamp: number
+  repoKey: string
+} | {
+  v: 3
+  type: "project_unhidden"
+  timestamp: number
+  repoKey: string
+}
+
+export type FeatureEvent =
+  | {
+      v: 3
+      type: "feature_created"
+      timestamp: number
+      featureId: string
+      projectId: string
+      title: string
+      description: string
+      browserState?: FeatureBrowserState
+      stage: FeatureStage
+      sortOrder: number
+      directoryRelativePath: string
+      overviewRelativePath: string
+    }
+  | {
+      v: 3
+      type: "feature_renamed"
+      timestamp: number
+      featureId: string
+      title: string
+    }
+  | {
+      v: 3
+      type: "feature_browser_state_set"
+      timestamp: number
+      featureId: string
+      browserState: FeatureBrowserState
+    }
+  | {
+      v: 3
+      type: "feature_stage_set"
+      timestamp: number
+      featureId: string
+      stage: FeatureStage
+      sortOrder?: number
+    }
+  | {
+      v: 3
+      type: "feature_reordered"
+      timestamp: number
+      projectId: string
+      orderedFeatureIds: string[]
+    }
+  | {
+      v: 3
+      type: "feature_deleted"
+      timestamp: number
+      featureId: string
+    }
+
+export type ChatEvent =
+  | {
+      v: 3
+      type: "chat_created"
+      timestamp: number
+      chatId: string
+      projectId: string
+      title: string
+      featureId?: string
+    }
+  | {
+      v: 3
+      type: "chat_renamed"
+      timestamp: number
+      chatId: string
+      title: string
+    }
+  | {
+      v: 3
+      type: "chat_deleted"
+      timestamp: number
+      chatId: string
+    }
+  | {
+      v: 3
+      type: "chat_provider_set"
+      timestamp: number
+      chatId: string
+      provider: AgentProvider
+    }
+  | {
+      v: 3
+      type: "chat_plan_mode_set"
+      timestamp: number
+      chatId: string
+      planMode: boolean
+    }
+  | {
+      v: 3
+      type: "chat_feature_set"
+      timestamp: number
+      chatId: string
+      featureId: string | null
+    }
+
+export type MessageEvent = {
+  v: 3
+  type: "message_appended"
+  timestamp: number
+  chatId: string
+  entry: TranscriptEntry
+}
+
+export type TurnEvent =
+  | {
+      v: 3
+      type: "turn_started"
+      timestamp: number
+      chatId: string
+    }
+  | {
+      v: 3
+      type: "turn_finished"
+      timestamp: number
+      chatId: string
+    }
+  | {
+      v: 3
+      type: "turn_failed"
+      timestamp: number
+      chatId: string
+      error: string
+    }
+  | {
+      v: 3
+      type: "turn_cancelled"
+      timestamp: number
+      chatId: string
+    }
+  | {
+      v: 3
+      type: "session_token_set"
+      timestamp: number
+      chatId: string
+      sessionToken: string | null
+    }
+
+export type StoreEvent = ProjectEvent | FeatureEvent | ChatEvent | MessageEvent | TurnEvent
+
+export function createEmptyState(): StoreState {
+  return {
+    projectsById: new Map(),
+    projectIdsByRepoKey: new Map(),
+    projectIdsByPath: new Map(),
+    featuresById: new Map(),
+    chatsById: new Map(),
+    hiddenProjectKeys: new Set(),
+  }
+}
+
+export function cloneTranscriptEntries(entries: TranscriptEntry[]): TranscriptEntry[] {
+  return entries.map((entry) => ({ ...entry }))
+}

package/src/server/external-open.ts

@@ -0,0 +1,272 @@
+import { stat } from "node:fs/promises"
+import path from "node:path"
+import process from "node:process"
+import type { ClientCommand, EditorOpenSettings, EditorPreset } from "../shared/protocol"
+import { resolveLocalPath } from "./paths"
+import { canOpenMacApp, hasCommand, spawnDetached } from "./process-utils"
+
+type OpenExternalCommand = Extract<ClientCommand, { type: "system.openExternal" }>
+type OpenUrlCommand = Extract<ClientCommand, { type: "system.openUrl" }>
+
+interface CommandSpec {
+  command: string
+  args: string[]
+}
+
+const DEFAULT_EDITOR_SETTINGS: EditorOpenSettings = {
+  preset: "cursor",
+  commandTemplate: "cursor {path}",
+}
+
+export async function openExternal(command: OpenExternalCommand) {
+  const resolvedPath = resolveLocalPath(command.localPath)
+  const platform = process.platform
+  const info = command.action === "open_editor" || command.action === "open_finder"
+    ? await stat(resolvedPath).catch(() => null)
+    : null
+
+  if (command.action === "open_editor") {
+    if (!info) {
+      throw new Error(`Path not found: ${resolvedPath}`)
+    }
+    const editorCommand = buildEditorCommand({
+      localPath: resolvedPath,
+      isDirectory: info.isDirectory(),
+      line: command.line,
+      column: command.column,
+      editor: command.editor ?? DEFAULT_EDITOR_SETTINGS,
+      platform,
+    })
+    spawnDetached(editorCommand.command, editorCommand.args)
+    return
+  }
+
+  if (platform === "darwin") {
+    if (command.action === "open_finder") {
+      if (info?.isDirectory()) {
+        spawnDetached("open", [resolvedPath])
+      } else {
+        spawnDetached("open", ["-R", resolvedPath])
+      }
+      return
+    }
+    if (command.action === "open_terminal") {
+      spawnDetached("open", ["-a", "Terminal", resolvedPath])
+      return
+    }
+  }
+
+  if (platform === "win32") {
+    if (command.action === "open_finder") {
+      if (info?.isDirectory()) {
+        spawnDetached("explorer", [resolvedPath])
+      } else {
+        spawnDetached("explorer", ["/select,", resolvedPath])
+      }
+      return
+    }
+    if (command.action === "open_terminal") {
+      if (hasCommand("wt")) {
+        spawnDetached("wt", ["-d", resolvedPath])
+        return
+      }
+      spawnDetached("cmd", ["/c", "start", "", "cmd", "/K", `cd /d ${resolvedPath}`])
+      return
+    }
+  }
+
+  if (command.action === "open_finder") {
+    spawnDetached("xdg-open", [info?.isDirectory() ? resolvedPath : path.dirname(resolvedPath)])
+    return
+  }
+  if (command.action === "open_terminal") {
+    for (const terminalCommand of ["x-terminal-emulator", "gnome-terminal", "konsole"]) {
+      if (!hasCommand(terminalCommand)) continue
+      if (terminalCommand === "gnome-terminal") {
+        spawnDetached(terminalCommand, ["--working-directory", resolvedPath])
+      } else if (terminalCommand === "konsole") {
+        spawnDetached(terminalCommand, ["--workdir", resolvedPath])
+      } else {
+        spawnDetached(terminalCommand, ["--working-directory", resolvedPath])
+      }
+      return
+    }
+    spawnDetached("xdg-open", [resolvedPath])
+  }
+}
+
+export async function openUrl(command: OpenUrlCommand) {
+  const platform = process.platform
+
+  if (platform === "darwin") {
+    spawnDetached("open", [command.url])
+    return
+  }
+
+  if (platform === "win32") {
+    spawnDetached("cmd", ["/c", "start", "", command.url])
+    return
+  }
+
+  spawnDetached("xdg-open", [command.url])
+}
+
+export function buildEditorCommand(args: {
+  localPath: string
+  isDirectory: boolean
+  line?: number
+  column?: number
+  editor: EditorOpenSettings
+  platform: NodeJS.Platform
+}): CommandSpec {
+  const editor = normalizeEditorSettings(args.editor)
+  if (editor.preset === "custom") {
+    return buildCustomEditorCommand({
+      commandTemplate: editor.commandTemplate,
+      localPath: args.localPath,
+      line: args.line,
+      column: args.column,
+    })
+  }
+  return buildPresetEditorCommand(args, editor.preset)
+}
+
+function buildPresetEditorCommand(
+  args: {
+    localPath: string
+    isDirectory: boolean
+    line?: number
+    column?: number
+    platform: NodeJS.Platform
+  },
+  preset: Exclude<EditorPreset, "custom">
+): CommandSpec {
+  const gotoTarget = `${args.localPath}:${args.line ?? 1}:${args.column ?? 1}`
+  const opener = resolveEditorExecutable(preset, args.platform)
+  if (args.isDirectory || !args.line) {
+    return { command: opener.command, args: [...opener.args, args.localPath] }
+  }
+  return { command: opener.command, args: [...opener.args, "--goto", gotoTarget] }
+}
+
+function resolveEditorExecutable(preset: Exclude<EditorPreset, "custom">, platform: NodeJS.Platform) {
+  if (preset === "cursor") {
+    if (hasCommand("cursor")) return { command: "cursor", args: [] }
+    if (platform === "darwin" && canOpenMacApp("Cursor")) return { command: "open", args: ["-a", "Cursor"] }
+  }
+  if (preset === "vscode") {
+    if (hasCommand("code")) return { command: "code", args: [] }
+    if (platform === "darwin" && canOpenMacApp("Visual Studio Code")) return { command: "open", args: ["-a", "Visual Studio Code"] }
+  }
+  if (preset === "windsurf") {
+    if (hasCommand("windsurf")) return { command: "windsurf", args: [] }
+    if (platform === "darwin" && canOpenMacApp("Windsurf")) return { command: "open", args: ["-a", "Windsurf"] }
+  }
+
+  if (platform === "darwin") {
+    switch (preset) {
+      case "cursor":
+        return { command: "open", args: ["-a", "Cursor"] }
+      case "vscode":
+        return { command: "open", args: ["-a", "Visual Studio Code"] }
+      case "windsurf":
+        return { command: "open", args: ["-a", "Windsurf"] }
+    }
+  }
+
+  return { command: preset === "vscode" ? "code" : preset, args: [] }
+}
+
+function buildCustomEditorCommand(args: {
+  commandTemplate: string
+  localPath: string
+  line?: number
+  column?: number
+}): CommandSpec {
+  const template = args.commandTemplate.trim()
+  if (!template.includes("{path}")) {
+    throw new Error("Custom editor command must include {path}")
+  }
+
+  const line = String(args.line ?? 1)
+  const column = String(args.column ?? 1)
+  const replaced = template
+    .replaceAll("{path}", args.localPath)
+    .replaceAll("{line}", line)
+    .replaceAll("{column}", column)
+
+  const tokens = tokenizeCommandTemplate(replaced)
+  const [command, ...commandArgs] = tokens
+  if (!command) {
+    throw new Error("Custom editor command is empty")
+  }
+  return { command, args: commandArgs }
+}
+
+export function tokenizeCommandTemplate(template: string) {
+  const tokens: string[] = []
+  let current = ""
+  let quote: "'" | "\"" | null = null
+
+  for (let index = 0; index < template.length; index += 1) {
+    const char = template[index]
+
+    if (char === "\\" && index + 1 < template.length) {
+      current += template[index + 1]
+      index += 1
+      continue
+    }
+
+    if (quote) {
+      if (char === quote) {
+        quote = null
+      } else {
+        current += char
+      }
+      continue
+    }
+
+    if (char === "'" || char === "\"") {
+      quote = char
+      continue
+    }
+
+    if (/\s/.test(char)) {
+      if (current.length > 0) {
+        tokens.push(current)
+        current = ""
+      }
+      continue
+    }
+
+    current += char
+  }
+
+  if (quote) {
+    throw new Error("Custom editor command has an unclosed quote")
+  }
+  if (current.length > 0) {
+    tokens.push(current)
+  }
+  return tokens
+}
+
+function normalizeEditorSettings(editor: EditorOpenSettings): EditorOpenSettings {
+  const preset = normalizeEditorPreset(editor.preset)
+  return {
+    preset,
+    commandTemplate: editor.commandTemplate.trim() || DEFAULT_EDITOR_SETTINGS.commandTemplate,
+  }
+}
+
+function normalizeEditorPreset(preset: EditorPreset): EditorPreset {
+  switch (preset) {
+    case "vscode":
+    case "windsurf":
+    case "custom":
+    case "cursor":
+      return preset
+    default:
+      return DEFAULT_EDITOR_SETTINGS.preset
+  }
+}