@cuongtran001/kanna 0.39.2

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

@@ -0,0 +1,79 @@
+import { describe, expect, test } from "bun:test"
+import { QuickResponseAdapter } from "./quick-response"
+import { generateCommitMessageDetailed } from "./generate-commit-message"
+
+describe("generateCommitMessageDetailed", () => {
+  test("returns sanitized generated subject and body", async () => {
+    const result = await generateCommitMessageDetailed(
+      {
+        cwd: "/tmp/project",
+        branchName: "feature/test",
+        files: [{
+          path: "app.ts",
+          changeType: "modified",
+          patch: "diff --git a/app.ts b/app.ts\n--- a/app.ts\n+++ b/app.ts\n@@\n-old\n+new\n",
+        }],
+      },
+      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  ",
+        }),
+      })
+    )
+
+    expect(result).toEqual({
+      subject: "Add login UI",
+      body: "- wire form\n- add validation",
+      usedFallback: false,
+      failureMessage: null,
+    })
+  })
+
+  test("falls back when providers fail", async () => {
+    const result = await generateCommitMessageDetailed(
+      {
+        cwd: "/tmp/project",
+        branchName: "feature/test",
+        files: [{
+          path: "src/feature.ts",
+          changeType: "modified",
+          patch: "diff --git a/src/feature.ts b/src/feature.ts\n",
+        }],
+      },
+      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")
+        },
+        runCodexStructured: async () => null,
+      })
+    )
+
+    expect(result).toEqual({
+      subject: "Update feature.ts",
+      body: "",
+      usedFallback: true,
+      failureMessage: "claude failed commit message generation: Not authenticated; codex returned no result for commit message generation",
+    })
+  })
+})

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

@@ -0,0 +1,126 @@
+import path from "node:path"
+import { QuickResponseAdapter } from "./quick-response"
+
+interface CommitMessageFile {
+  path: string
+  changeType: "added" | "deleted" | "modified" | "renamed"
+  patch: string
+}
+
+const COMMIT_MESSAGE_SCHEMA = {
+  type: "object",
+  properties: {
+    subject: { type: "string" },
+    body: { type: "string" },
+  },
+  required: ["subject", "body"],
+  additionalProperties: false,
+} as const
+
+export interface GenerateCommitMessageResult {
+  subject: string
+  body: string
+  usedFallback: boolean
+  failureMessage: string | null
+}
+
+function summarizeFailures(failures: Array<{ provider: "openai" | "claude" | "codex"; reason: string }>) {
+  if (failures.length === 0) return null
+  return failures.map((failure) => failure.reason).join("; ")
+}
+
+function limitText(value: string, maxLength: number) {
+  return value.length <= maxLength ? value : `${value.slice(0, maxLength).trimEnd()}\n...[truncated]`
+}
+
+function sanitizeSubject(value: unknown): string | null {
+  if (typeof value !== "string") return null
+  const normalized = (value.split(/\r?\n/u)[0] ?? "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .replace(/[.]+$/u, "")
+    .slice(0, 72)
+    .trim()
+  return normalized.length > 0 ? normalized : null
+}
+
+function sanitizeBody(value: unknown): string {
+  if (typeof value !== "string") return ""
+  return value.trim()
+}
+
+function fallbackSubject(files: CommitMessageFile[]) {
+  if (files.length === 1) {
+    const fileName = path.posix.basename(files[0]?.path ?? "file")
+    const normalized = `Update ${fileName}`.replace(/\s+/g, " ").trim()
+    return normalized.slice(0, 72).trim()
+  }
+
+  return `Update ${files.length} files`
+}
+
+function buildCommitMessagePrompt(args: {
+  branchName?: string
+  files: CommitMessageFile[]
+}) {
+  const fileList = args.files.map((file) => `${file.changeType}: ${file.path}`).join("\n")
+  const combinedPatch = args.files.map((file) => file.patch).join("\n\n")
+
+  return [
+    "Generate a git commit message for the selected changes.",
+    "Return JSON with keys: subject, body.",
+    "Rules:",
+    "- subject must be imperative, under 72 chars, and have no trailing period",
+    "- body may be an empty string or 3-5 bullet points",
+    "- capture the primary user-visible or developer-visible change",
+    "",
+    `Branch: ${args.branchName ?? "current branch"}`,
+    "",
+    "Selected files:",
+    limitText(fileList, 6_000),
+    "",
+    "Selected patch:",
+    limitText(combinedPatch, 40_000),
+  ].join("\n")
+}
+
+export async function generateCommitMessageDetailed(
+  args: {
+    cwd: string
+    branchName?: string
+    files: CommitMessageFile[]
+  },
+  adapter = new QuickResponseAdapter()
+): Promise<GenerateCommitMessageResult> {
+  const result = await adapter.generateStructuredWithDiagnostics<{ subject: string; body: string }>({
+    cwd: args.cwd,
+    task: "commit message generation",
+    prompt: buildCommitMessagePrompt(args),
+    schema: COMMIT_MESSAGE_SCHEMA,
+    parse: (value) => {
+      const output = value && typeof value === "object" ? value as { subject?: unknown; body?: unknown } : {}
+      const subject = sanitizeSubject(output.subject)
+      if (!subject) return null
+      return {
+        subject,
+        body: sanitizeBody(output.body),
+      }
+    },
+  })
+
+  if (result.value) {
+    return {
+      subject: result.value.subject,
+      body: result.value.body,
+      usedFallback: false,
+      failureMessage: null,
+    }
+  }
+
+  return {
+    subject: fallbackSubject(args.files),
+    body: "",
+    usedFallback: true,
+    failureMessage: summarizeFailures(result.failures),
+  }
+}

package/src/server/generate-title.ts

@@ -0,0 +1,76 @@
+import { QuickResponseAdapter } from "./quick-response"
+
+const TITLE_SCHEMA = {
+  type: "object",
+  properties: {
+    title: { type: "string" },
+  },
+  required: ["title"],
+  additionalProperties: false,
+} as const
+
+function normalizeGeneratedTitle(value: unknown): string | null {
+  if (typeof value !== "string") return null
+  const normalized = value.replace(/\s+/g, " ").trim().slice(0, 80)
+  if (!normalized || normalized === "New Chat") return null
+  return normalized
+}
+
+export function fallbackTitleFromMessage(messageContent: string): string | null {
+  const normalized = messageContent.replace(/\s+/g, " ").trim()
+  if (!normalized) return null
+  if (normalized.length <= 35) return normalized
+  return `${normalized.slice(0, 35)}...`
+}
+
+export interface GenerateChatTitleResult {
+  title: string | null
+  usedFallback: boolean
+  failureMessage: string | null
+}
+
+function summarizeFailures(failures: Array<{ provider: "openai" | "claude" | "codex"; reason: string }>) {
+  if (failures.length === 0) return null
+  return failures.map((failure) => failure.reason).join("; ")
+}
+
+export async function generateTitleForChat(
+  messageContent: string,
+  cwd: string,
+  adapter = new QuickResponseAdapter()
+): Promise<string | null> {
+  const result = await generateTitleForChatDetailed(messageContent, cwd, adapter)
+  return result.title
+}
+
+export async function generateTitleForChatDetailed(
+  messageContent: string,
+  cwd: string,
+  adapter = new QuickResponseAdapter()
+): Promise<GenerateChatTitleResult> {
+  const result = await adapter.generateStructuredWithDiagnostics<string>({
+    cwd,
+    task: "conversation title generation",
+    prompt: `Generate a short, descriptive title (under 30 chars) for a conversation that starts with this message.\n\n${messageContent}`,
+    schema: TITLE_SCHEMA,
+    parse: (value) => {
+      const output = value && typeof value === "object" ? value as { title?: unknown } : {}
+      return normalizeGeneratedTitle(output.title)
+    },
+  })
+
+  if (result.value) {
+    return {
+      title: result.value,
+      usedFallback: false,
+      failureMessage: null,
+    }
+  }
+
+  const fallbackTitle = fallbackTitleFromMessage(messageContent)
+  return {
+    title: fallbackTitle,
+    usedFallback: true,
+    failureMessage: summarizeFailures(result.failures),
+  }
+}

package/src/server/harness-types.ts

@@ -0,0 +1,19 @@
+import type { AccountInfo, AgentProvider, NormalizedToolCall, TranscriptEntry } from "../shared/types"
+
+export interface HarnessEvent {
+  type: "transcript" | "session_token"
+  entry?: TranscriptEntry
+  sessionToken?: string
+}
+
+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.test.ts

@@ -0,0 +1,144 @@
+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_KEYBINDINGS } from "../shared/types"
+import { KeybindingsManager, normalizeKeybindings, readKeybindingsSnapshot } from "./keybindings"
+
+let tempDirs: string[] = []
+const TEST_FILE_PATH = "/tmp/kanna-test-keybindings.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-keybindings-"))
+  tempDirs.push(dir)
+  return path.join(dir, "keybindings.json")
+}
+
+describe("normalizeKeybindings", () => {
+  test("falls back to defaults for invalid entries", () => {
+    const snapshot = normalizeKeybindings({
+      toggleEmbeddedTerminal: [],
+      toggleRightSidebar: "Ctrl+B",
+    }, TEST_FILE_PATH)
+
+    expect(snapshot.bindings).toEqual(DEFAULT_KEYBINDINGS)
+    expect(snapshot.warning).toContain("toggleEmbeddedTerminal")
+    expect(snapshot.warning).toContain("toggleRightSidebar")
+  })
+
+  test("keeps valid shortcut arrays", () => {
+    const snapshot = normalizeKeybindings({
+      toggleEmbeddedTerminal: [" Cmd+K ", "Ctrl+`"],
+      toggleRightSidebar: ["Ctrl+Shift+B"],
+      openInFinder: ["Cmd+Alt+F"],
+      openInEditor: ["Cmd+Shift+O"],
+      addSplitTerminal: ["Cmd+Shift+J"],
+      jumpToSidebarChat: ["Cmd+Alt"],
+      createChatInCurrentProject: ["Cmd+Alt+N"],
+      openAddProject: ["Cmd+Alt+O"],
+    }, TEST_FILE_PATH)
+
+    expect(snapshot).toEqual({
+      bindings: {
+        toggleEmbeddedTerminal: ["cmd+k", "ctrl+`"],
+        toggleRightSidebar: ["ctrl+shift+b"],
+        openInFinder: ["cmd+alt+f"],
+        openInEditor: ["cmd+shift+o"],
+        addSplitTerminal: ["cmd+shift+j"],
+        jumpToSidebarChat: ["cmd+alt"],
+        createChatInCurrentProject: ["cmd+alt+n"],
+        openAddProject: ["cmd+alt+o"],
+      },
+      warning: null,
+      filePathDisplay: TEST_FILE_PATH,
+    })
+  })
+})
+
+describe("readKeybindingsSnapshot", () => {
+  test("returns defaults when the file does not exist", async () => {
+    const filePath = await createTempFilePath()
+    const snapshot = await readKeybindingsSnapshot(filePath)
+    expect(snapshot).toEqual({
+      bindings: DEFAULT_KEYBINDINGS,
+      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 readKeybindingsSnapshot(filePath)
+    expect(snapshot.bindings).toEqual(DEFAULT_KEYBINDINGS)
+    expect(snapshot.warning).toContain("invalid JSON")
+  })
+})
+
+describe("KeybindingsManager", () => {
+  test("creates the keybindings file with defaults during initialization", async () => {
+    const filePath = await createTempFilePath()
+    const manager = new KeybindingsManager(filePath)
+
+    await manager.initialize()
+
+    expect(await Bun.file(filePath).json()).toEqual(DEFAULT_KEYBINDINGS)
+    manager.dispose()
+  })
+
+  test("writes normalized bindings to disk", async () => {
+    const filePath = await createTempFilePath()
+    const manager = new KeybindingsManager(filePath)
+
+    await manager.initialize()
+    const snapshot = await manager.write({
+      toggleEmbeddedTerminal: ["Cmd+K"],
+      toggleRightSidebar: ["Ctrl+Shift+B"],
+      openInFinder: ["Cmd+Alt+F"],
+      openInEditor: ["Cmd+Shift+O"],
+      addSplitTerminal: ["Cmd+Shift+J"],
+      jumpToSidebarChat: ["Cmd+Alt"],
+      createChatInCurrentProject: ["Cmd+Alt+N"],
+      openAddProject: ["Cmd+Alt+O"],
+    })
+
+    expect(snapshot).toEqual({
+      bindings: {
+        toggleEmbeddedTerminal: ["cmd+k"],
+        toggleRightSidebar: ["ctrl+shift+b"],
+        openInFinder: ["cmd+alt+f"],
+        openInEditor: ["cmd+shift+o"],
+        addSplitTerminal: ["cmd+shift+j"],
+        jumpToSidebarChat: ["cmd+alt"],
+        createChatInCurrentProject: ["cmd+alt+n"],
+        openAddProject: ["cmd+alt+o"],
+      },
+      warning: null,
+      filePathDisplay: filePath,
+    })
+    expect(JSON.parse(await Bun.file(filePath).text())).toEqual(snapshot.bindings)
+
+    manager.dispose()
+  })
+
+  test("uses the runtime profile for the default keybindings path", () => {
+    const previous = process.env.KANNA_RUNTIME_PROFILE
+    process.env.KANNA_RUNTIME_PROFILE = "dev"
+
+    const manager = new KeybindingsManager()
+
+    expect(manager.filePath).toEndWith("/.kanna-dev/keybindings.json")
+
+    if (previous === undefined) {
+      delete process.env.KANNA_RUNTIME_PROFILE
+    } else {
+      process.env.KANNA_RUNTIME_PROFILE = previous
+    }
+  })
+})

package/src/server/keybindings.ts

@@ -0,0 +1,178 @@
+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: {
+      toggleEmbeddedTerminal: [...DEFAULT_KEYBINDINGS.toggleEmbeddedTerminal],
+      toggleRightSidebar: [...DEFAULT_KEYBINDINGS.toggleRightSidebar],
+      openInFinder: [...DEFAULT_KEYBINDINGS.openInFinder],
+      openInEditor: [...DEFAULT_KEYBINDINGS.openInEditor],
+      addSplitTerminal: [...DEFAULT_KEYBINDINGS.addSplitTerminal],
+      jumpToSidebarChat: [...DEFAULT_KEYBINDINGS.jumpToSidebarChat],
+      createChatInCurrentProject: [...DEFAULT_KEYBINDINGS.createChatInCurrentProject],
+      openAddProject: [...DEFAULT_KEYBINDINGS.openAddProject],
+    },
+    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
+}