kaizenai 0.2.2 → 0.4.0

package/src/server/git-repository.ts

@@ -1,101 +0,0 @@
-import path from "node:path"
-import { resolveLocalPath } from "./paths"
-
-export interface ProjectRepositoryIdentity {
-  isGitRepo: boolean
-  localPath: string
-  repoKey: string
-  repoRootPath: string | null
-  title: string
-  worktreePath: string
-}
-
-function normalizeAbsolutePath(value: string, cwd: string) {
-  const resolved = path.isAbsolute(value) ? value : path.resolve(cwd, value)
-  return path.normalize(resolved)
-}
-
-export function resolveProjectWorktreePaths(localPath: string): string[] {
-  const normalizedLocalPath = resolveLocalPath(localPath)
-  const result = Bun.spawnSync(
-    ["git", "-C", normalizedLocalPath, "worktree", "list", "--porcelain"],
-    {
-      stdout: "pipe",
-      stderr: "pipe",
-    }
-  )
-
-  if (result.exitCode !== 0) {
-    return [normalizedLocalPath]
-  }
-
-  const worktreePaths: string[] = []
-  for (const line of new TextDecoder().decode(result.stdout).split("\n")) {
-    const match = line.match(/^worktree\s+(.+)$/)
-    if (!match?.[1]) continue
-    worktreePaths.push(normalizeAbsolutePath(match[1], normalizedLocalPath))
-  }
-
-  return worktreePaths.length > 0 ? [...new Set(worktreePaths)] : [normalizedLocalPath]
-}
-
-export function resolveProjectRepositoryIdentity(localPath: string): ProjectRepositoryIdentity {
-  const normalizedLocalPath = resolveLocalPath(localPath)
-  const fallbackTitle = path.basename(normalizedLocalPath) || normalizedLocalPath
-  const fallbackRepoKey = `path:${normalizedLocalPath}`
-
-  const result = Bun.spawnSync(
-    [
-      "git",
-      "-C",
-      normalizedLocalPath,
-      "rev-parse",
-      "--path-format=absolute",
-      "--show-toplevel",
-      "--git-common-dir",
-    ],
-    {
-      stdout: "pipe",
-      stderr: "pipe",
-    }
-  )
-
-  if (result.exitCode !== 0) {
-    return {
-      isGitRepo: false,
-      localPath: normalizedLocalPath,
-      repoKey: fallbackRepoKey,
-      repoRootPath: null,
-      title: fallbackTitle,
-      worktreePath: normalizedLocalPath,
-    }
-  }
-
-  const stdout = new TextDecoder().decode(result.stdout).trim()
-  const [repoRootPathRaw, gitCommonDirRaw] = stdout.split("\n").map((line) => line.trim())
-  if (!repoRootPathRaw || !gitCommonDirRaw) {
-    return {
-      isGitRepo: false,
-      localPath: normalizedLocalPath,
-      repoKey: fallbackRepoKey,
-      repoRootPath: null,
-      title: fallbackTitle,
-      worktreePath: normalizedLocalPath,
-    }
-  }
-
-  const gitCommonDir = normalizeAbsolutePath(gitCommonDirRaw, normalizedLocalPath)
-  const repoRootPath = normalizeAbsolutePath(repoRootPathRaw, normalizedLocalPath)
-  const repositoryDisplayPath = path.basename(gitCommonDir) === ".git"
-    ? path.dirname(gitCommonDir)
-    : repoRootPath
-
-  return {
-    isGitRepo: true,
-    localPath: normalizedLocalPath,
-    repoKey: `git:${gitCommonDir}`,
-    repoRootPath: repositoryDisplayPath,
-    title: path.basename(repositoryDisplayPath) || fallbackTitle,
-    worktreePath: repoRootPath,
-  }
-}

package/src/server/harness-types.ts

@@ -1,20 +0,0 @@
-import type { AccountInfo, AgentProvider, ChatUsageSnapshot, NormalizedToolCall, TranscriptEntry } from "../shared/types"
-
-export interface HarnessEvent {
-  type: "transcript" | "session_token" | "usage"
-  entry?: TranscriptEntry
-  sessionToken?: string
-  usage?: ChatUsageSnapshot
-}
-
-export interface HarnessToolRequest {
-  tool: NormalizedToolCall & { toolKind: "ask_user_question" | "exit_plan_mode" }
-}
-
-export interface HarnessTurn {
-  provider: AgentProvider
-  stream: AsyncIterable<HarnessEvent>
-  getAccountInfo?: () => Promise<AccountInfo | null>
-  interrupt: () => Promise<void>
-  close: () => void
-}

package/src/server/keybindings.ts

@@ -1,177 +0,0 @@
-import { watch, type FSWatcher } from "node:fs"
-import { mkdir, readFile, writeFile } from "node:fs/promises"
-import { homedir } from "node:os"
-import path from "node:path"
-import { getKeybindingsFilePath, LOG_PREFIX } from "../shared/branding"
-import { DEFAULT_KEYBINDINGS, type KeybindingAction, type KeybindingsSnapshot } from "../shared/types"
-
-const KEYBINDING_ACTIONS = Object.keys(DEFAULT_KEYBINDINGS) as KeybindingAction[]
-
-type KeybindingsFile = Partial<Record<KeybindingAction, unknown>>
-
-export class KeybindingsManager {
-  readonly filePath: string
-  private watcher: FSWatcher | null = null
-  private snapshot: KeybindingsSnapshot
-  private readonly listeners = new Set<(snapshot: KeybindingsSnapshot) => void>()
-
-  constructor(filePath = getKeybindingsFilePath(homedir())) {
-    this.filePath = filePath
-    this.snapshot = createDefaultSnapshot(this.filePath)
-  }
-
-  async initialize() {
-    await mkdir(path.dirname(this.filePath), { recursive: true })
-    const file = Bun.file(this.filePath)
-    if (!(await file.exists())) {
-      await writeFile(this.filePath, `${JSON.stringify(DEFAULT_KEYBINDINGS, null, 2)}\n`, "utf8")
-    }
-    await this.reload()
-    this.startWatching()
-  }
-
-  dispose() {
-    this.watcher?.close()
-    this.watcher = null
-    this.listeners.clear()
-  }
-
-  getSnapshot() {
-    return this.snapshot
-  }
-
-  onChange(listener: (snapshot: KeybindingsSnapshot) => void) {
-    this.listeners.add(listener)
-    return () => {
-      this.listeners.delete(listener)
-    }
-  }
-
-  async reload() {
-    const nextSnapshot = await readKeybindingsSnapshot(this.filePath)
-    this.setSnapshot(nextSnapshot)
-  }
-
-  async write(bindings: Partial<Record<KeybindingAction, string[]>>) {
-    const nextSnapshot = normalizeKeybindings(bindings, this.filePath)
-    await mkdir(path.dirname(this.filePath), { recursive: true })
-    await writeFile(this.filePath, `${JSON.stringify(nextSnapshot.bindings, null, 2)}\n`, "utf8")
-    this.setSnapshot(nextSnapshot)
-    return nextSnapshot
-  }
-
-  private setSnapshot(snapshot: KeybindingsSnapshot) {
-    this.snapshot = snapshot
-    for (const listener of this.listeners) {
-      listener(snapshot)
-    }
-  }
-
-  private startWatching() {
-    this.watcher?.close()
-    try {
-      this.watcher = watch(path.dirname(this.filePath), { persistent: false }, (_eventType, filename) => {
-        if (filename && filename !== path.basename(this.filePath)) {
-          return
-        }
-        void this.reload().catch((error: unknown) => {
-          console.warn(`${LOG_PREFIX} Failed to reload keybindings:`, error)
-        })
-      })
-    } catch (error) {
-      console.warn(`${LOG_PREFIX} Failed to watch keybindings file:`, error)
-      this.watcher = null
-    }
-  }
-}
-
-export async function readKeybindingsSnapshot(filePath: string) {
-  try {
-    const text = await readFile(filePath, "utf8")
-    if (!text.trim()) {
-      return createDefaultSnapshot(filePath, "Keybindings file was empty. Using defaults.")
-    }
-    const parsed = JSON.parse(text) as KeybindingsFile
-    return normalizeKeybindings(parsed, filePath)
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException)?.code === "ENOENT") {
-      return createDefaultSnapshot(filePath)
-    }
-
-    if (error instanceof SyntaxError) {
-      return createDefaultSnapshot(filePath, "Keybindings file is invalid JSON. Using defaults.")
-    }
-
-    throw error
-  }
-}
-
-export function normalizeKeybindings(value: KeybindingsFile | null | undefined, filePath = getKeybindingsFilePath(homedir())): KeybindingsSnapshot {
-  const warnings: string[] = []
-  const source = value && typeof value === "object" && !Array.isArray(value)
-    ? value
-    : null
-
-  if (!source) {
-    return createDefaultSnapshot(filePath, "Keybindings file must contain a JSON object. Using defaults.")
-  }
-
-  const bindings = {} as Record<KeybindingAction, string[]>
-  for (const action of KEYBINDING_ACTIONS) {
-    const rawValue = source[action]
-    if (!Array.isArray(rawValue)) {
-      bindings[action] = [...DEFAULT_KEYBINDINGS[action]]
-      if (rawValue !== undefined) {
-        warnings.push(`${action} must be an array of shortcut strings`)
-      }
-      continue
-    }
-
-    const normalized = rawValue
-      .filter((entry): entry is string => typeof entry === "string")
-      .map((entry) => entry.trim())
-      .map((entry) => entry.toLowerCase())
-      .filter(Boolean)
-
-    if (normalized.length === 0) {
-      bindings[action] = [...DEFAULT_KEYBINDINGS[action]]
-      if (rawValue.length > 0 || source[action] !== undefined) {
-        warnings.push(`${action} did not contain any valid shortcut strings`)
-      }
-      continue
-    }
-
-    bindings[action] = normalized
-  }
-
-  return {
-    bindings,
-    warning: warnings.length > 0 ? `Some keybindings were reset to defaults: ${warnings.join("; ")}` : null,
-    filePathDisplay: formatDisplayPath(filePath),
-  }
-}
-
-function createDefaultSnapshot(filePath: string, warning: string | null = null): KeybindingsSnapshot {
-  return {
-    bindings: {
-      submitChatMessage: [...DEFAULT_KEYBINDINGS.submitChatMessage],
-      toggleProjectsSidebar: [...DEFAULT_KEYBINDINGS.toggleProjectsSidebar],
-      toggleEmbeddedTerminal: [...DEFAULT_KEYBINDINGS.toggleEmbeddedTerminal],
-      toggleRightSidebar: [...DEFAULT_KEYBINDINGS.toggleRightSidebar],
-      openInFinder: [...DEFAULT_KEYBINDINGS.openInFinder],
-      openInEditor: [...DEFAULT_KEYBINDINGS.openInEditor],
-      addSplitTerminal: [...DEFAULT_KEYBINDINGS.addSplitTerminal],
-    },
-    warning,
-    filePathDisplay: formatDisplayPath(filePath),
-  }
-}
-
-function formatDisplayPath(filePath: string) {
-  const homePath = homedir()
-  if (filePath === homePath) return "~"
-  if (filePath.startsWith(`${homePath}${path.sep}`)) {
-    return `~${filePath.slice(homePath.length)}`
-  }
-  return filePath
-}

package/src/server/machine-name.ts

@@ -1,22 +0,0 @@
-import { hostname } from "node:os"
-import process from "node:process"
-import { spawnSync } from "node:child_process"
-
-function runAndRead(command: string, args: string[]) {
-  const result = spawnSync(command, args, { encoding: "utf8" })
-  if (result.status !== 0) return null
-  const value = result.stdout.trim()
-  return value || null
-}
-
-export function getMachineDisplayName() {
-  if (process.platform === "darwin") {
-    const computerName = runAndRead("scutil", ["--get", "ComputerName"])
-    if (computerName) {
-      return computerName
-    }
-  }
-
-  const rawHostname = hostname().trim()
-  return rawHostname.replace(/\.local$|\.lan$/i, "") || "This Machine"
-}

package/src/server/paths.ts

@@ -1,112 +0,0 @@
-import { statSync } from "node:fs"
-import { mkdir, readdir, stat } from "node:fs/promises"
-import { homedir } from "node:os"
-import path from "node:path"
-import type { DirectoryBrowserSnapshot } from "../shared/types"
-
-export function getDefaultDirectoryRoot() {
-  const home = homedir()
-  const candidates = [
-    path.join(home, "Documents"),
-    path.join(home, "projects"),
-    path.join(home, "Projects"),
-    home,
-  ]
-
-  for (const candidate of candidates) {
-    try {
-      const info = statSync(candidate)
-      if (info.isDirectory()) {
-        return candidate
-      }
-    } catch {
-      continue
-    }
-  }
-
-  if (process.platform === "win32") {
-    return path.parse(home).root || "C:\\"
-  }
-  return "/"
-}
-
-export function resolveLocalPath(localPath: string) {
-  const trimmed = localPath.trim()
-  if (!trimmed) {
-    throw new Error("Project path is required")
-  }
-  if (trimmed === "~") {
-    return homedir()
-  }
-  if (trimmed.startsWith("~/")) {
-    return path.join(homedir(), trimmed.slice(2))
-  }
-  return path.resolve(trimmed)
-}
-
-export async function ensureProjectDirectory(localPath: string) {
-  const resolvedPath = resolveLocalPath(localPath)
-
-  await mkdir(resolvedPath, { recursive: true })
-  const info = await stat(resolvedPath)
-  if (!info.isDirectory()) {
-    throw new Error("Project path must be a directory")
-  }
-}
-
-export async function requireProjectDirectory(localPath: string) {
-  const resolvedPath = resolveLocalPath(localPath)
-  const info = await stat(resolvedPath).catch(() => null)
-  if (!info) {
-    throw new Error(`Project folder not found: ${resolvedPath}`)
-  }
-  if (!info.isDirectory()) {
-    throw new Error("Project path must be a directory")
-  }
-}
-
-function getDirectoryRoots() {
-  const home = homedir()
-  if (process.platform === "win32") {
-    const drive = path.parse(home).root || "C:\\"
-    return [
-      { name: "Home", localPath: home },
-      { name: drive, localPath: drive },
-    ]
-  }
-
-  return [
-    { name: "Home", localPath: home },
-    { name: "/", localPath: "/" },
-  ]
-}
-
-export async function listProjectDirectories(localPath?: string): Promise<DirectoryBrowserSnapshot> {
-  const currentPath = localPath ? resolveLocalPath(localPath) : getDefaultDirectoryRoot()
-  const info = await stat(currentPath).catch(() => null)
-
-  if (!info) {
-    throw new Error(`Folder not found: ${currentPath}`)
-  }
-  if (!info.isDirectory()) {
-    throw new Error("Project path must be a directory")
-  }
-
-  const directoryEntries = await readdir(currentPath, { withFileTypes: true })
-  const entries = directoryEntries
-    .filter((entry) => entry.isDirectory())
-    .map((entry) => ({
-      name: entry.name,
-      localPath: path.join(currentPath, entry.name),
-    }))
-    .sort((a, b) => a.name.localeCompare(b.name))
-
-  const parentPath = path.dirname(currentPath) === currentPath ? null : path.dirname(currentPath)
-
-  return {
-    currentPath,
-    parentPath,
-    roots: getDirectoryRoots(),
-    entries,
-  }
-}

package/src/server/process-utils.ts

@@ -1,22 +0,0 @@
-import { spawn, spawnSync } from "node:child_process"
-
-export function spawnDetached(command: string, args: string[]) {
-  spawn(command, args, { stdio: "ignore", detached: true }).unref()
-}
-
-export function hasCommand(command: string) {
-  const result = spawnSync("sh", ["-lc", `command -v ${command}`], { stdio: "ignore" })
-  return result.status === 0
-}
-
-export function resolveCommandPath(command: string) {
-  const result = spawnSync("sh", ["-lc", `command -v ${command}`], { stdio: ["ignore", "pipe", "ignore"] })
-  if (result.status !== 0) return null
-  const output = result.stdout?.toString().trim()
-  return output || null
-}
-
-export function canOpenMacApp(appName: string) {
-  const result = spawnSync("open", ["-Ra", appName], { stdio: "ignore" })
-  return result.status === 0
-}