kanna-code 0.30.0 → 0.32.0

package/src/server/event-store.ts

@@ -59,6 +59,7 @@ function getReplayEventPriority(event: StoreEvent) {
   switch (event.type) {
     case "project_opened":
     case "project_removed":
+    case "sidebar_project_order_set":
       return 0
     case "chat_created":
       return 1
@@ -198,6 +199,7 @@ export class EventStore {
           unread: chat.unread ?? false,
         })
       }
+      this.state.sidebarProjectOrder = [...(parsed.sidebarProjectOrder ?? [])]
       if (parsed.queuedMessages?.length) {
         for (const queuedSet of parsed.queuedMessages) {
           this.state.queuedMessagesByChatId.set(queuedSet.chatId, queuedSet.entries.map((entry) => ({
@@ -223,6 +225,7 @@ export class EventStore {
     this.state.projectIdsByPath.clear()
     this.state.chatsById.clear()
     this.state.queuedMessagesByChatId.clear()
+    this.state.sidebarProjectOrder = []
     this.cachedTranscript = null
   }
 
@@ -322,6 +325,10 @@ export class EventStore {
         this.state.projectIdsByPath.delete(project.localPath)
         break
       }
+      case "sidebar_project_order_set": {
+        this.state.sidebarProjectOrder = [...event.projectIds]
+        break
+      }
       case "chat_created": {
       const chat = {
           id: event.chatId,
@@ -527,6 +534,30 @@ export class EventStore {
     await this.append(this.projectsLogPath, event)
   }
 
+  async setSidebarProjectOrder(projectIds: string[]) {
+    const validProjectIds = projectIds.filter((projectId) => {
+      const project = this.state.projectsById.get(projectId)
+      return Boolean(project && !project.deletedAt)
+    })
+
+    const uniqueProjectIds = [...new Set(validProjectIds)]
+    const current = this.state.sidebarProjectOrder
+    if (
+      uniqueProjectIds.length === current.length
+      && uniqueProjectIds.every((projectId, index) => current[index] === projectId)
+    ) {
+      return
+    }
+
+    const event: ProjectEvent = {
+      v: STORE_VERSION,
+      type: "sidebar_project_order_set",
+      timestamp: Date.now(),
+      projectIds: uniqueProjectIds,
+    }
+    await this.append(this.projectsLogPath, event)
+  }
+
   async createChat(projectId: string) {
     const project = this.state.projectsById.get(projectId)
     if (!project || project.deletedAt) {
@@ -930,6 +961,7 @@ export class EventStore {
       v: STORE_VERSION,
       generatedAt: Date.now(),
       projects: this.listProjects().map((project) => ({ ...project })),
+      sidebarProjectOrder: [...this.state.sidebarProjectOrder],
       chats: [...this.state.chatsById.values()]
         .filter((chat) => !chat.deletedAt)
         .map((chat) => ({ ...chat })),

package/src/server/events.ts

@@ -25,6 +25,7 @@ export interface StoreState {
   projectIdsByPath: Map<string, string>
   chatsById: Map<string, ChatRecord>
   queuedMessagesByChatId: Map<string, QueuedChatMessage[]>
+  sidebarProjectOrder: string[]
 }
 
 export interface SnapshotFile {
@@ -32,6 +33,7 @@ export interface SnapshotFile {
   generatedAt: number
   projects: ProjectRecord[]
   chats: ChatRecord[]
+  sidebarProjectOrder?: string[]
   queuedMessages?: Array<{ chatId: string; entries: QueuedChatMessage[] }>
   messages?: Array<{ chatId: string; entries: TranscriptEntry[] }>
 }
@@ -48,6 +50,11 @@ export type ProjectEvent = {
   type: "project_removed"
   timestamp: number
   projectId: string
+} | {
+  v: 2
+  type: "sidebar_project_order_set"
+  timestamp: number
+  projectIds: string[]
 }
 
 export type ChatEvent =
@@ -160,6 +167,7 @@ export function createEmptyState(): StoreState {
     projectIdsByPath: new Map(),
     chatsById: new Map(),
     queuedMessagesByChatId: new Map(),
+    sidebarProjectOrder: [],
   }
 }
 

package/src/server/generate-commit-message.test.ts

@@ -15,6 +15,16 @@ describe("generateCommitMessageDetailed", () => {
         }],
       },
       new QuickResponseAdapter({
+        readLlmProvider: async () => ({
+          provider: "openai",
+          apiKey: "",
+          model: "",
+          baseUrl: "",
+          resolvedBaseUrl: "https://api.openai.com/v1",
+          enabled: false,
+          warning: null,
+          filePathDisplay: "~/.kanna/llm-provider.json",
+        }),
         runClaudeStructured: async () => ({
           subject: "  Add login UI.\nextra line",
           body: "  - wire form\n- add validation  ",
@@ -42,6 +52,16 @@ describe("generateCommitMessageDetailed", () => {
         }],
       },
       new QuickResponseAdapter({
+        readLlmProvider: async () => ({
+          provider: "openai",
+          apiKey: "",
+          model: "",
+          baseUrl: "",
+          resolvedBaseUrl: "https://api.openai.com/v1",
+          enabled: false,
+          warning: null,
+          filePathDisplay: "~/.kanna/llm-provider.json",
+        }),
         runClaudeStructured: async () => {
           throw new Error("Not authenticated")
         },

package/src/server/generate-commit-message.ts

@@ -24,7 +24,7 @@ export interface GenerateCommitMessageResult {
   failureMessage: string | null
 }
 
-function summarizeFailures(failures: Array<{ provider: "claude" | "codex"; reason: string }>) {
+function summarizeFailures(failures: Array<{ provider: "openai" | "claude" | "codex"; reason: string }>) {
   if (failures.length === 0) return null
   return failures.map((failure) => failure.reason).join("; ")
 }

package/src/server/generate-title.ts

@@ -29,7 +29,7 @@ export interface GenerateChatTitleResult {
   failureMessage: string | null
 }
 
-function summarizeFailures(failures: Array<{ provider: "claude" | "codex"; reason: string }>) {
+function summarizeFailures(failures: Array<{ provider: "openai" | "claude" | "codex"; reason: string }>) {
   if (failures.length === 0) return null
   return failures.map((failure) => failure.reason).join("; ")
 }

package/src/server/llm-provider.test.ts

@@ -0,0 +1,134 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtemp, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { DEFAULT_OPENAI_SDK_MODEL, DEFAULT_OPENROUTER_SDK_MODEL } from "../shared/types"
+import {
+  normalizeLlmProviderSnapshot,
+  OPENAI_BASE_URL,
+  OPENROUTER_BASE_URL,
+  readLlmProviderSnapshot,
+  resolveLlmProviderBaseUrl,
+  writeLlmProviderSnapshot,
+} from "./llm-provider"
+
+let tempDirs: string[] = []
+const TEST_FILE_PATH = "/tmp/kanna-test-llm-provider.json"
+
+afterEach(async () => {
+  await Promise.all(tempDirs.map((dir) => rm(dir, { recursive: true, force: true })))
+  tempDirs = []
+})
+
+async function createTempFilePath() {
+  const dir = await mkdtemp(path.join(tmpdir(), "kanna-llm-provider-"))
+  tempDirs.push(dir)
+  return path.join(dir, "llm-provider.json")
+}
+
+describe("resolveLlmProviderBaseUrl", () => {
+  test("derives known provider URLs and preserves custom URLs", () => {
+    expect(resolveLlmProviderBaseUrl("openai", "")).toBe(OPENAI_BASE_URL)
+    expect(resolveLlmProviderBaseUrl("openrouter", "")).toBe(OPENROUTER_BASE_URL)
+    expect(resolveLlmProviderBaseUrl("custom", " https://example.com/v1 ")).toBe("https://example.com/v1")
+  })
+})
+
+describe("normalizeLlmProviderSnapshot", () => {
+  test("normalizes a valid custom provider config", () => {
+    expect(normalizeLlmProviderSnapshot({
+      provider: "custom",
+      apiKey: "  test-key  ",
+      model: "  gpt-test  ",
+      baseUrl: " https://example.com/v1 ",
+    }, TEST_FILE_PATH)).toEqual({
+      provider: "custom",
+      apiKey: "test-key",
+      model: "gpt-test",
+      baseUrl: "https://example.com/v1",
+      resolvedBaseUrl: "https://example.com/v1",
+      enabled: true,
+      warning: null,
+      filePathDisplay: TEST_FILE_PATH,
+    })
+  })
+
+  test("disables invalid configs with a warning", () => {
+    const snapshot = normalizeLlmProviderSnapshot({
+      provider: "custom",
+      apiKey: "test-key",
+      model: "gpt-test",
+      baseUrl: "",
+    }, TEST_FILE_PATH)
+
+    expect(snapshot.enabled).toBe(false)
+    expect(snapshot.warning).toContain("custom provider requires a baseUrl")
+  })
+})
+
+describe("readLlmProviderSnapshot", () => {
+  test("returns defaults when the file does not exist", async () => {
+    const filePath = await createTempFilePath()
+    expect(await readLlmProviderSnapshot(filePath)).toEqual({
+      provider: "openai",
+      apiKey: "",
+      model: DEFAULT_OPENAI_SDK_MODEL,
+      baseUrl: "",
+      resolvedBaseUrl: OPENAI_BASE_URL,
+      enabled: false,
+      warning: null,
+      filePathDisplay: filePath,
+    })
+  })
+
+  test("returns a warning when the file contains invalid json", async () => {
+    const filePath = await createTempFilePath()
+    await writeFile(filePath, "{not-json", "utf8")
+
+    const snapshot = await readLlmProviderSnapshot(filePath)
+    expect(snapshot.enabled).toBe(false)
+    expect(snapshot.warning).toContain("invalid JSON")
+  })
+
+  test("fills named-provider default models when the file omits them", async () => {
+    const filePath = await createTempFilePath()
+    await writeFile(filePath, JSON.stringify({
+      provider: "openrouter",
+      apiKey: "test-key",
+      baseUrl: null,
+    }), "utf8")
+
+    const snapshot = await readLlmProviderSnapshot(filePath)
+    expect(snapshot.model).toBe(DEFAULT_OPENROUTER_SDK_MODEL)
+    expect(snapshot.enabled).toBe(true)
+  })
+})
+
+describe("writeLlmProviderSnapshot", () => {
+  test("writes normalized config to disk", async () => {
+    const filePath = await createTempFilePath()
+    const snapshot = await writeLlmProviderSnapshot({
+      provider: "openrouter",
+      apiKey: " test-key ",
+      model: " openrouter/model ",
+      baseUrl: "ignored",
+    }, filePath)
+
+    expect(snapshot).toEqual({
+      provider: "openrouter",
+      apiKey: "test-key",
+      model: "openrouter/model",
+      baseUrl: "ignored",
+      resolvedBaseUrl: OPENROUTER_BASE_URL,
+      enabled: true,
+      warning: null,
+      filePathDisplay: filePath,
+    })
+    expect(await Bun.file(filePath).json()).toEqual({
+      provider: "openrouter",
+      apiKey: "test-key",
+      model: "openrouter/model",
+      baseUrl: null,
+    })
+  })
+})

package/src/server/llm-provider.ts

@@ -0,0 +1,149 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises"
+import { homedir } from "node:os"
+import path from "node:path"
+import { getLlmProviderFilePath } from "../shared/branding"
+import {
+  DEFAULT_OPENAI_SDK_MODEL,
+  DEFAULT_OPENROUTER_SDK_MODEL,
+  type LlmProviderFile,
+  type LlmProviderKind,
+  type LlmProviderSnapshot,
+} from "../shared/types"
+
+export const OPENAI_BASE_URL = "https://api.openai.com/v1"
+export const OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
+
+const DEFAULT_PROVIDER: LlmProviderKind = "openai"
+
+function formatDisplayPath(filePath: string) {
+  const homePath = homedir()
+  if (filePath === homePath) return "~"
+  if (filePath.startsWith(`${homePath}${path.sep}`)) {
+    return `~${filePath.slice(homePath.length)}`
+  }
+  return filePath
+}
+
+function resolveProvider(value: unknown) {
+  if (value === "openai" || value === "openrouter" || value === "custom") {
+    return value
+  }
+  return null
+}
+
+function normalizeString(value: unknown) {
+  return typeof value === "string" ? value.trim() : ""
+}
+
+export function resolveLlmProviderBaseUrl(provider: LlmProviderKind, baseUrl: string) {
+  if (provider === "openai") return OPENAI_BASE_URL
+  if (provider === "openrouter") return OPENROUTER_BASE_URL
+  return baseUrl.trim()
+}
+
+export function resolveLlmProviderDefaultModel(provider: LlmProviderKind) {
+  if (provider === "openai") return DEFAULT_OPENAI_SDK_MODEL
+  if (provider === "openrouter") return DEFAULT_OPENROUTER_SDK_MODEL
+  return ""
+}
+
+export function normalizeLlmProviderSnapshot(
+  value: unknown,
+  filePath = getLlmProviderFilePath(homedir())
+): LlmProviderSnapshot {
+  const source = value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null
+  const warnings: string[] = []
+
+  if (!source) {
+    return createDefaultSnapshot(
+      filePath,
+      value === undefined || value === null ? null : "LLM provider file must contain a JSON object. Using defaults."
+    )
+  }
+
+  const provider = resolveProvider(source.provider)
+  const apiKey = normalizeString(source.apiKey)
+  const model = normalizeString(source.model)
+  const baseUrl = normalizeString(source.baseUrl)
+
+  if (!provider) {
+    warnings.push("provider must be one of openai, openrouter, or custom")
+  }
+  if (source.apiKey !== undefined && typeof source.apiKey !== "string") {
+    warnings.push("apiKey must be a string")
+  }
+  if (source.model !== undefined && typeof source.model !== "string") {
+    warnings.push("model must be a string")
+  }
+  if (source.baseUrl !== undefined && source.baseUrl !== null && typeof source.baseUrl !== "string") {
+    warnings.push("baseUrl must be a string or null")
+  }
+  if ((provider ?? DEFAULT_PROVIDER) === "custom" && !baseUrl) {
+    warnings.push("custom provider requires a baseUrl")
+  }
+
+  const normalizedProvider = provider ?? DEFAULT_PROVIDER
+  const resolvedModel = model || resolveLlmProviderDefaultModel(normalizedProvider)
+  const resolvedBaseUrl = resolveLlmProviderBaseUrl(normalizedProvider, baseUrl)
+  const enabled = warnings.length === 0 && apiKey.length > 0 && resolvedModel.length > 0 && resolvedBaseUrl.length > 0
+
+  return {
+    provider: normalizedProvider,
+    apiKey,
+    model: resolvedModel,
+    baseUrl,
+    resolvedBaseUrl,
+    enabled,
+    warning: warnings.length > 0 ? `Some LLM provider settings are invalid: ${warnings.join("; ")}` : null,
+    filePathDisplay: formatDisplayPath(filePath),
+  }
+}
+
+function createDefaultSnapshot(filePath: string, warning: string | null = null): LlmProviderSnapshot {
+  return {
+    provider: DEFAULT_PROVIDER,
+    apiKey: "",
+    model: DEFAULT_OPENAI_SDK_MODEL,
+    baseUrl: "",
+    resolvedBaseUrl: OPENAI_BASE_URL,
+    enabled: false,
+    warning,
+    filePathDisplay: formatDisplayPath(filePath),
+  }
+}
+
+export async function readLlmProviderSnapshot(filePath = getLlmProviderFilePath(homedir())) {
+  try {
+    const text = await readFile(filePath, "utf8")
+    if (!text.trim()) {
+      return createDefaultSnapshot(filePath, "LLM provider file was empty. Using defaults.")
+    }
+    return normalizeLlmProviderSnapshot(JSON.parse(text), filePath)
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code === "ENOENT") {
+      return createDefaultSnapshot(filePath)
+    }
+    if (error instanceof SyntaxError) {
+      return createDefaultSnapshot(filePath, "LLM provider file is invalid JSON. Using defaults.")
+    }
+    throw error
+  }
+}
+
+export async function writeLlmProviderSnapshot(
+  value: Pick<LlmProviderFile, "provider" | "apiKey" | "model"> & { baseUrl: string },
+  filePath = getLlmProviderFilePath(homedir())
+) {
+  const snapshot = normalizeLlmProviderSnapshot(value, filePath)
+  const payload: LlmProviderFile = {
+    provider: snapshot.provider,
+    apiKey: snapshot.apiKey,
+    model: snapshot.model,
+    baseUrl: snapshot.provider === "custom" ? snapshot.baseUrl : null,
+  }
+  await mkdir(path.dirname(filePath), { recursive: true })
+  await writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8")
+  return snapshot
+}