kaizenai 0.3.0 → 0.5.0

package/src/server/events.ts

@@ -1,252 +0,0 @@
-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
-      directoryRelativePath?: string
-      overviewRelativePath?: 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
-    }
-  | {
-      v: 3
-      type: "feature_overview_updated"
-      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

@@ -1,272 +0,0 @@
-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
-  }
-}