kaizenai 0.3.0 → 0.5.0

package/src/server/project-icon.ts

@@ -1,352 +0,0 @@
-import { readdirSync, readFileSync, statSync } from "node:fs"
-import path from "node:path"
-import { PROJECT_METADATA_DIR_NAME } from "../shared/branding"
-import { resolveLocalPath } from "./paths"
-import { getProjectMetadataCandidateRelativePath } from "./project-metadata"
-
-const MAX_ICON_BYTES = 128 * 1024
-const ICON_CANDIDATE_PATHS = [
-  "assets/icon.svg",
-  "assets/icon.png",
-  "assets/icon.jpg",
-  "assets/icon.jpeg",
-  "assets/icon.webp",
-  "assets/icon.gif",
-  "assets/icon.avif",
-  "assets/icon.ico",
-  "icon.svg",
-  "icon.png",
-  "icon.jpg",
-  "icon.jpeg",
-  "icon.webp",
-  "icon.gif",
-  "icon.avif",
-  "icon.ico",
-  getProjectMetadataCandidateRelativePath("icon.svg"),
-  getProjectMetadataCandidateRelativePath("icon.png"),
-  getProjectMetadataCandidateRelativePath("icon.jpg"),
-  getProjectMetadataCandidateRelativePath("icon.jpeg"),
-  getProjectMetadataCandidateRelativePath("icon.webp"),
-  getProjectMetadataCandidateRelativePath("icon.gif"),
-  getProjectMetadataCandidateRelativePath("icon.avif"),
-  getProjectMetadataCandidateRelativePath("icon.ico"),
-  "favicon.svg",
-  "favicon.png",
-  "favicon.jpg",
-  "favicon.jpeg",
-  "favicon.webp",
-  "favicon.gif",
-  "favicon.avif",
-  "favicon.ico",
-  "public/favicon.svg",
-  "public/favicon.png",
-  "public/favicon.jpg",
-  "public/favicon.jpeg",
-  "public/favicon.webp",
-  "public/favicon.gif",
-  "public/favicon.avif",
-  "public/favicon.ico",
-  "public/icon.svg",
-  "public/icon.png",
-  "public/icon.jpg",
-  "public/icon.jpeg",
-  "public/icon.webp",
-  "public/icon.gif",
-  "public/icon.avif",
-  "public/icon.ico",
-  "app/favicon.svg",
-  "app/favicon.png",
-  "app/favicon.jpg",
-  "app/favicon.jpeg",
-  "app/favicon.webp",
-  "app/favicon.gif",
-  "app/favicon.avif",
-  "app/favicon.ico",
-  "app/icon.svg",
-  "app/icon.png",
-  "app/icon.jpg",
-  "app/icon.jpeg",
-  "app/icon.webp",
-  "app/icon.gif",
-  "app/icon.avif",
-  "app/icon.ico",
-  "src/favicon.svg",
-  "src/favicon.png",
-  "src/favicon.jpg",
-  "src/favicon.jpeg",
-  "src/favicon.webp",
-  "src/favicon.gif",
-  "src/favicon.avif",
-  "src/favicon.ico",
-  "src/app/favicon.svg",
-  "src/app/favicon.png",
-  "src/app/favicon.jpg",
-  "src/app/favicon.jpeg",
-  "src/app/favicon.webp",
-  "src/app/favicon.gif",
-  "src/app/favicon.avif",
-  "src/app/favicon.ico",
-  "src/app/icon.svg",
-  "src/app/icon.png",
-  "src/app/icon.jpg",
-  "src/app/icon.jpeg",
-  "src/app/icon.webp",
-  "src/app/icon.gif",
-  "src/app/icon.avif",
-  "src/app/icon.ico",
-]
-const ICON_SOURCE_FILES = [
-  "index.html",
-  "public/index.html",
-  "app/root.tsx",
-  "src/root.tsx",
-  "app/routes/__root.tsx",
-  "src/routes/__root.tsx",
-]
-const LINK_ICON_HTML_RE = /<link[^>]*rel=["'](?:icon|shortcut icon)["'][^>]*href=["']([^"'?]+)/i
-const LINK_ICON_OBJ_RE = /rel:\s*["'](?:icon|shortcut icon)["'][^}]*href:\s*["']([^"'?]+)/i
-
-function getMimeType(extension: string) {
-  switch (extension) {
-    case ".svg":
-      return "image/svg+xml"
-    case ".png":
-      return "image/png"
-    case ".ico":
-      return "image/vnd.microsoft.icon"
-    case ".jpg":
-    case ".jpeg":
-      return "image/jpeg"
-    case ".webp":
-      return "image/webp"
-    case ".gif":
-      return "image/gif"
-    case ".avif":
-      return "image/avif"
-    default:
-      return null
-  }
-}
-
-function compareIconNames(a: string, b: string) {
-  const aExt = path.extname(a).toLowerCase()
-  const bExt = path.extname(b).toLowerCase()
-  const aIndex = getExtensionPriority(aExt)
-  const bIndex = getExtensionPriority(bExt)
-  if (aIndex !== bIndex) return aIndex - bIndex
-  return a.localeCompare(b)
-}
-
-function getExtensionPriority(extension: string) {
-  switch (extension) {
-    case ".svg":
-      return 0
-    case ".png":
-      return 1
-    case ".jpg":
-    case ".jpeg":
-      return 2
-    case ".webp":
-      return 3
-    case ".gif":
-      return 4
-    case ".avif":
-      return 5
-    case ".ico":
-      return 6
-    default:
-      return Number.MAX_SAFE_INTEGER
-  }
-}
-
-function findFixedIconCandidates(projectPath: string) {
-  try {
-    const existingPaths = new Map<string, string>()
-
-    for (const relativePath of ICON_CANDIDATE_PATHS) {
-      const extension = path.extname(relativePath).toLowerCase()
-      if (getMimeType(extension) === null) continue
-
-      const absolutePath = resolveCaseInsensitiveProjectPath(projectPath, relativePath)
-      if (!absolutePath) continue
-      existingPaths.set(relativePath, absolutePath)
-    }
-
-    return [...existingPaths.entries()]
-      .sort((a, b) => {
-        const pathCompare = ICON_CANDIDATE_PATHS.indexOf(a[0]) - ICON_CANDIDATE_PATHS.indexOf(b[0])
-        if (pathCompare !== 0) return pathCompare
-        return compareIconNames(a[0], b[0])
-      })
-      .map(([, absolutePath]) => absolutePath)
-  } catch {
-    return []
-  }
-}
-
-function findAppWorkspaceIconCandidates(projectPath: string) {
-  const appsPath = path.join(projectPath, "apps")
-
-  try {
-    const appDirectories = readdirSync(appsPath, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory())
-      .map((entry) => entry.name)
-      .sort((a, b) => a.localeCompare(b))
-
-    const existingPaths = new Map<string, string>()
-
-    for (const appDirectory of appDirectories) {
-      for (const relativePath of ICON_CANDIDATE_PATHS) {
-        if (relativePath.startsWith(`${PROJECT_METADATA_DIR_NAME}/`)) continue
-        const appRelativePath = path.join("apps", appDirectory, relativePath)
-        const extension = path.extname(appRelativePath).toLowerCase()
-        if (getMimeType(extension) === null) continue
-
-        const absolutePath = resolveCaseInsensitiveProjectPath(projectPath, appRelativePath)
-        if (!absolutePath) continue
-        existingPaths.set(appRelativePath, absolutePath)
-      }
-    }
-
-    return [...existingPaths.entries()]
-      .sort((a, b) => {
-        const [aPath] = a
-        const [bPath] = b
-        const aRelative = aPath.replace(/^apps\/[^/]+\//, "")
-        const bRelative = bPath.replace(/^apps\/[^/]+\//, "")
-        const pathCompare = ICON_CANDIDATE_PATHS.indexOf(aRelative) - ICON_CANDIDATE_PATHS.indexOf(bRelative)
-        if (pathCompare !== 0) return pathCompare
-        return compareIconNames(aPath, bPath)
-      })
-      .map(([, absolutePath]) => absolutePath)
-  } catch {
-    return []
-  }
-}
-
-function resolveCaseInsensitiveProjectPath(projectPath: string, relativePath: string) {
-  const segments = relativePath.split("/").filter(Boolean)
-  let currentPath = projectPath
-
-  for (const [index, segment] of segments.entries()) {
-    let entries: string[]
-    try {
-      entries = readdirSync(currentPath)
-    } catch {
-      return null
-    }
-
-    const matchedEntry = entries.find((entry) => entry.toLowerCase() === segment.toLowerCase())
-    if (!matchedEntry) {
-      return null
-    }
-
-    currentPath = path.join(currentPath, matchedEntry)
-
-    try {
-      const stat = statSync(currentPath)
-      const isLast = index === segments.length - 1
-      if (isLast) {
-        return stat.isFile() ? currentPath : null
-      }
-      if (!stat.isDirectory()) {
-        return null
-      }
-    } catch {
-      return null
-    }
-  }
-
-  return null
-}
-
-function extractDeclaredIconHref(source: string) {
-  const htmlMatch = source.match(LINK_ICON_HTML_RE)
-  if (htmlMatch?.[1]) return htmlMatch[1]
-  const objMatch = source.match(LINK_ICON_OBJ_RE)
-  if (objMatch?.[1]) return objMatch[1]
-  return null
-}
-
-function resolveDeclaredIconCandidates(projectPath: string, href: string) {
-  const cleanHref = href.replace(/^\//, "")
-  return [
-    path.join(projectPath, "public", cleanHref),
-    path.join(projectPath, cleanHref),
-  ]
-}
-
-function findDeclaredIconCandidates(projectPath: string) {
-  const candidates: string[] = []
-
-  for (const sourceFile of ICON_SOURCE_FILES) {
-    const sourcePath = path.join(projectPath, sourceFile)
-
-    try {
-      const source = readFileSync(sourcePath, "utf8")
-      const href = extractDeclaredIconHref(source)
-      if (!href) continue
-
-      for (const candidatePath of resolveDeclaredIconCandidates(projectPath, href)) {
-        const extension = path.extname(candidatePath).toLowerCase()
-        if (getMimeType(extension) === null) continue
-        if (!candidates.includes(candidatePath)) {
-          candidates.push(candidatePath)
-        }
-      }
-    } catch {
-      continue
-    }
-  }
-
-  return candidates
-}
-
-function tryReadImageDataUrl(filePath: string) {
-  try {
-    const stat = statSync(filePath)
-    if (!stat.isFile() || stat.size > MAX_ICON_BYTES) {
-      return null
-    }
-
-    const extension = path.extname(filePath).toLowerCase()
-    const mimeType = getMimeType(extension)
-    if (!mimeType) {
-      return null
-    }
-
-    if (extension === ".svg") {
-      const svg = readFileSync(filePath, "utf8").trim()
-      if (!svg.includes("<svg")) {
-        return null
-      }
-
-      return `data:${mimeType};utf8,${encodeURIComponent(svg)}`
-    }
-
-    const image = readFileSync(filePath)
-    return `data:${mimeType};base64,${image.toString("base64")}`
-  } catch {
-    return null
-  }
-
-  return null
-}
-
-export function resolveProjectIconDataUrl(localPath: string): string | null {
-  const projectPath = resolveLocalPath(localPath)
-  const candidatePaths = [
-    ...findFixedIconCandidates(projectPath),
-    ...findAppWorkspaceIconCandidates(projectPath),
-    ...findDeclaredIconCandidates(projectPath),
-  ]
-
-  for (const candidatePath of candidatePaths) {
-    const dataUrl = tryReadImageDataUrl(candidatePath)
-    if (dataUrl) {
-      return dataUrl
-    }
-  }
-
-  return null
-}

package/src/server/project-metadata.ts

@@ -1,10 +0,0 @@
-import path from "node:path"
-import { PROJECT_METADATA_DIR_NAME } from "../shared/branding"
-
-export function getProjectMetadataDirPath(localPath: string) {
-  return path.join(localPath, PROJECT_METADATA_DIR_NAME)
-}
-
-export function getProjectMetadataCandidateRelativePath(fileName: string) {
-  return path.posix.join(PROJECT_METADATA_DIR_NAME, fileName)
-}

package/src/server/provider-catalog.ts

@@ -1,85 +0,0 @@
-import type {
-  AgentProvider,
-  ClaudeModelOptions,
-  ClaudeContextWindow,
-  CodexModelOptions,
-  CursorModelOptions,
-  GeminiModelOptions,
-  ModelOptions,
-  ProviderCatalogEntry,
-  ServiceTier,
-} from "../shared/types"
-import {
-  getProviderCatalog,
-  getProviderDefaultModelOptions,
-  DEFAULT_CLAUDE_MODEL_OPTIONS,
-  normalizeClaudeContextWindow,
-  isClaudeReasoningEffort,
-  isCodexReasoningEffort,
-  isGeminiThinkingMode,
-  normalizeCursorModelId,
-} from "../shared/types"
-
-export function getServerProviderCatalog(provider: AgentProvider): ProviderCatalogEntry {
-  return getProviderCatalog(provider)
-}
-
-export function normalizeServerModel(provider: AgentProvider, model?: string): string {
-  if (provider === "cursor") {
-    return normalizeCursorModelId(model)
-  }
-  const catalog = getServerProviderCatalog(provider)
-  if (model && catalog.models.some((candidate) => candidate.id === model)) {
-    return model
-  }
-  return catalog.defaultModel
-}
-
-export function normalizeClaudeModelOptions(
-  model: string,
-  modelOptions?: ModelOptions,
-  legacyEffort?: string
-): ClaudeModelOptions {
-  const reasoningEffort = modelOptions?.claude?.reasoningEffort
-  return {
-    reasoningEffort: isClaudeReasoningEffort(reasoningEffort)
-      ? reasoningEffort
-      : isClaudeReasoningEffort(legacyEffort)
-        ? legacyEffort
-        : DEFAULT_CLAUDE_MODEL_OPTIONS.reasoningEffort,
-    contextWindow: normalizeClaudeContextWindow(model, modelOptions?.claude?.contextWindow as ClaudeContextWindow | undefined),
-  }
-}
-
-export function normalizeCodexModelOptions(modelOptions?: ModelOptions, legacyEffort?: string): CodexModelOptions {
-  const defaultOptions = getProviderDefaultModelOptions("codex")
-  const reasoningEffort = modelOptions?.codex?.reasoningEffort
-  return {
-    reasoningEffort: isCodexReasoningEffort(reasoningEffort)
-      ? reasoningEffort
-      : isCodexReasoningEffort(legacyEffort)
-        ? legacyEffort
-        : defaultOptions.reasoningEffort,
-    fastMode: typeof modelOptions?.codex?.fastMode === "boolean"
-      ? modelOptions.codex.fastMode
-      : defaultOptions.fastMode,
-  }
-}
-
-export function normalizeGeminiModelOptions(modelOptions?: ModelOptions): GeminiModelOptions {
-  const defaultOptions = getProviderDefaultModelOptions("gemini")
-  return {
-    thinkingMode: isGeminiThinkingMode(modelOptions?.gemini?.thinkingMode)
-      ? modelOptions.gemini.thinkingMode
-      : defaultOptions.thinkingMode,
-  }
-}
-
-export function normalizeCursorModelOptions(modelOptions?: ModelOptions): CursorModelOptions {
-  void modelOptions
-  return { ...getProviderDefaultModelOptions("cursor") }
-}
-
-export function codexServiceTierFromModelOptions(modelOptions: CodexModelOptions): ServiceTier | undefined {
-  return modelOptions.fastMode ? "fast" : undefined
-}

package/src/server/provider-settings.ts

@@ -1,155 +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 { getProviderSettingsFilePath, LOG_PREFIX } from "../shared/branding"
-import {
-  DEFAULT_PROVIDER_SETTINGS,
-  type AgentProvider,
-  type ProviderSettingsEntry,
-  type ProviderSettingsSnapshot,
-} from "../shared/types"
-
-const PROVIDER_IDS = Object.keys(DEFAULT_PROVIDER_SETTINGS) as AgentProvider[]
-
-type ProviderSettingsFile = Partial<Record<AgentProvider, Partial<ProviderSettingsEntry>>>
-
-export class ProviderSettingsManager {
-  readonly filePath: string
-  private watcher: FSWatcher | null = null
-  private snapshot: ProviderSettingsSnapshot
-  private readonly listeners = new Set<(snapshot: ProviderSettingsSnapshot) => void>()
-
-  constructor(filePath = getProviderSettingsFilePath(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_PROVIDER_SETTINGS, 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: ProviderSettingsSnapshot) => void) {
-    this.listeners.add(listener)
-    return () => {
-      this.listeners.delete(listener)
-    }
-  }
-
-  async reload() {
-    const nextSnapshot = await readProviderSettingsSnapshot(this.filePath)
-    this.setSnapshot(nextSnapshot)
-  }
-
-  async write(settings: ProviderSettingsSnapshot["settings"]) {
-    const nextSnapshot = normalizeProviderSettings(settings, this.filePath)
-    await mkdir(path.dirname(this.filePath), { recursive: true })
-    await writeFile(this.filePath, `${JSON.stringify(nextSnapshot.settings, null, 2)}\n`, "utf8")
-    this.setSnapshot(nextSnapshot)
-    return nextSnapshot
-  }
-
-  private setSnapshot(snapshot: ProviderSettingsSnapshot) {
-    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 provider settings:`, error)
-        })
-      })
-    } catch (error) {
-      console.warn(`${LOG_PREFIX} Failed to watch provider settings file:`, error)
-      this.watcher = null
-    }
-  }
-}
-
-export async function readProviderSettingsSnapshot(filePath: string): Promise<ProviderSettingsSnapshot> {
-  try {
-    const text = await readFile(filePath, "utf8")
-    if (!text.trim()) {
-      return createDefaultSnapshot(filePath, "Provider settings file was empty. Using defaults.")
-    }
-    const parsed = JSON.parse(text) as ProviderSettingsFile
-    return normalizeProviderSettings(parsed, filePath)
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException)?.code === "ENOENT") {
-      return createDefaultSnapshot(filePath)
-    }
-    if (error instanceof SyntaxError) {
-      return createDefaultSnapshot(filePath, "Provider settings file is invalid JSON. Using defaults.")
-    }
-    throw error
-  }
-}
-
-export function normalizeProviderSettings(
-  value: ProviderSettingsFile | null | undefined,
-  filePath = getProviderSettingsFilePath(homedir())
-): ProviderSettingsSnapshot {
-  const source = value && typeof value === "object" && !Array.isArray(value) ? value : {}
-
-  const settings = {} as ProviderSettingsSnapshot["settings"]
-  for (const provider of PROVIDER_IDS) {
-    const rawValue = source[provider]
-    const defaultValue = DEFAULT_PROVIDER_SETTINGS[provider]
-
-    settings[provider] = {
-      active: typeof rawValue?.active === "boolean" ? rawValue.active : defaultValue.active,
-    }
-  }
-
-  return {
-    settings,
-    warning: null,
-    filePathDisplay: formatDisplayPath(filePath),
-  }
-}
-
-function createDefaultSnapshot(filePath: string, warning: string | null = null): ProviderSettingsSnapshot {
-  return {
-    settings: {
-      claude: { ...DEFAULT_PROVIDER_SETTINGS.claude },
-      codex: { ...DEFAULT_PROVIDER_SETTINGS.codex },
-      gemini: { ...DEFAULT_PROVIDER_SETTINGS.gemini },
-      cursor: { ...DEFAULT_PROVIDER_SETTINGS.cursor },
-    },
-    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
-}