kanna-code 0.20.0 → 0.21.0

package/src/server/diff-store.test.ts

@@ -0,0 +1,126 @@
+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 { DiffStore } from "./diff-store"
+
+async function run(command: string[], cwd: string) {
+  const process = Bun.spawn(command, {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(process.stdout).text(),
+    new Response(process.stderr).text(),
+    process.exited,
+  ])
+
+  if (exitCode !== 0) {
+    throw new Error(stderr || stdout || `Command failed: ${command.join(" ")}`)
+  }
+
+  return stdout
+}
+
+async function createRepo() {
+  const root = await mkdtemp(path.join(tmpdir(), "kanna-diff-store-"))
+  await run(["git", "init"], root)
+  await run(["git", "config", "user.email", "kanna@example.com"], root)
+  await run(["git", "config", "user.name", "Kanna"], root)
+  return root
+}
+
+const tempDirs: string[] = []
+
+describe("DiffStore", () => {
+  afterEach(async () => {
+    await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })))
+  })
+
+  test("returns current worktree diffs for modified files", async () => {
+    const repoRoot = await createRepo()
+    tempDirs.push(repoRoot)
+    await writeFile(path.join(repoRoot, "app.txt"), "base\n", "utf8")
+    await run(["git", "add", "."], repoRoot)
+    await run(["git", "commit", "-m", "init"], repoRoot)
+    await writeFile(path.join(repoRoot, "app.txt"), "changed\n", "utf8")
+
+    const store = new DiffStore(repoRoot)
+    await store.initialize()
+    await store.refreshSnapshot("chat-1", repoRoot)
+
+    const snapshot = store.getSnapshot("chat-1")
+    expect(snapshot.status).toBe("ready")
+    expect(snapshot.files).toHaveLength(1)
+    expect(snapshot.files[0]?.path).toBe("app.txt")
+    expect(snapshot.files[0]?.patch).toContain("-base")
+    expect(snapshot.files[0]?.patch).toContain("+changed")
+  })
+
+  test("returns no_repo outside a git repository", async () => {
+    const root = await mkdtemp(path.join(tmpdir(), "kanna-no-repo-"))
+    tempDirs.push(root)
+
+    const store = new DiffStore(root)
+    await store.initialize()
+    await store.refreshSnapshot("chat-1", root)
+
+    expect(store.getSnapshot("chat-1")).toEqual({
+      status: "no_repo",
+      branchName: undefined,
+      files: [],
+    })
+  })
+
+  test("commits only the selected files and refreshes the snapshot", async () => {
+    const repoRoot = await createRepo()
+    tempDirs.push(repoRoot)
+    await writeFile(path.join(repoRoot, "app.txt"), "base\n", "utf8")
+    await writeFile(path.join(repoRoot, "notes.txt"), "keep\n", "utf8")
+    await run(["git", "add", "."], repoRoot)
+    await run(["git", "commit", "-m", "init"], repoRoot)
+
+    await writeFile(path.join(repoRoot, "app.txt"), "changed\n", "utf8")
+    await writeFile(path.join(repoRoot, "notes.txt"), "changed too\n", "utf8")
+
+    const store = new DiffStore(repoRoot)
+    await store.initialize()
+    await store.refreshSnapshot("chat-1", repoRoot)
+
+    await store.commitFiles({
+      chatId: "chat-1",
+      projectPath: repoRoot,
+      paths: ["app.txt"],
+      summary: "Update app",
+      description: "Only app changes",
+    })
+
+    const snapshot = store.getSnapshot("chat-1")
+    expect(snapshot.status).toBe("ready")
+    expect(snapshot.files).toHaveLength(1)
+    expect(snapshot.files[0]?.path).toBe("notes.txt")
+
+    const lastMessage = (await run(["git", "log", "-1", "--pretty=%B"], repoRoot)).trim()
+    expect(lastMessage).toBe("Update app\n\nOnly app changes")
+  })
+
+  test("detects renamed files", async () => {
+    const repoRoot = await createRepo()
+    tempDirs.push(repoRoot)
+    await writeFile(path.join(repoRoot, "before.txt"), "same\n", "utf8")
+    await run(["git", "add", "."], repoRoot)
+    await run(["git", "commit", "-m", "init"], repoRoot)
+    await run(["git", "mv", "before.txt", "after.txt"], repoRoot)
+
+    const store = new DiffStore(repoRoot)
+    await store.initialize()
+    await store.refreshSnapshot("chat-1", repoRoot)
+
+    const snapshot = store.getSnapshot("chat-1")
+    expect(snapshot.status).toBe("ready")
+    expect(snapshot.files).toHaveLength(1)
+    expect(snapshot.files[0]?.path).toBe("after.txt")
+    expect(snapshot.files[0]?.changeType).toBe("renamed")
+  })
+})

package/src/server/diff-store.ts

@@ -0,0 +1,365 @@
+import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import type { ChatDiffFile, ChatDiffSnapshot } from "../shared/types"
+import { generateCommitMessageDetailed } from "./generate-commit-message"
+import { inferProjectFileContentType } from "./uploads"
+
+interface StoredChatDiffState {
+  status: ChatDiffSnapshot["status"]
+  branchName?: string
+  files: ChatDiffFile[]
+}
+
+function createEmptyState(): StoredChatDiffState {
+  return {
+    status: "unknown",
+    branchName: undefined,
+    files: [],
+  }
+}
+
+function snapshotsEqual(left: StoredChatDiffState | undefined, right: StoredChatDiffState) {
+  if (!left) {
+    return right.status === "unknown" && right.files.length === 0
+  }
+  if (left.status !== right.status) return false
+  if (left.branchName !== right.branchName) return false
+  if (left.files.length !== right.files.length) return false
+  return left.files.every((file, index) => {
+    const other = right.files[index]
+    return Boolean(other)
+      && file.path === other.path
+      && file.changeType === other.changeType
+      && file.patch === other.patch
+  })
+}
+
+interface DirtyPathEntry {
+  path: string
+  previousPath?: string
+  changeType: ChatDiffFile["changeType"]
+}
+
+async function fileExists(filePath: string) {
+  try {
+    await stat(filePath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function runGit(args: string[], cwd: string) {
+  const process = Bun.spawn(["git", "-C", cwd, ...args], {
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(process.stdout).text(),
+    new Response(process.stderr).text(),
+    process.exited,
+  ])
+
+  return {
+    stdout,
+    stderr,
+    exitCode,
+  }
+}
+
+async function resolveRepo(projectPath: string): Promise<{ repoRoot: string; baseCommit: string | null } | null> {
+  const topLevel = await runGit(["rev-parse", "--show-toplevel"], projectPath)
+  if (topLevel.exitCode !== 0) {
+    return null
+  }
+
+  const repoRoot = topLevel.stdout.trim()
+  const head = await runGit(["rev-parse", "--verify", "HEAD"], repoRoot)
+  return {
+    repoRoot,
+    baseCommit: head.exitCode === 0 ? head.stdout.trim() : null,
+  }
+}
+
+async function getBranchName(repoRoot: string) {
+  const symbolicRef = await runGit(["symbolic-ref", "--quiet", "--short", "HEAD"], repoRoot)
+  if (symbolicRef.exitCode === 0) {
+    return symbolicRef.stdout.trim()
+  }
+
+  const revParse = await runGit(["rev-parse", "--abbrev-ref", "HEAD"], repoRoot)
+  if (revParse.exitCode === 0) {
+    return revParse.stdout.trim()
+  }
+
+  return undefined
+}
+
+function parseStatusPaths(output: string): DirtyPathEntry[] {
+  const entries: DirtyPathEntry[] = []
+  for (const rawLine of output.split(/\r?\n/u)) {
+    const line = rawLine.trimEnd()
+    if (line.length < 4) continue
+    const statusCode = line.slice(0, 2)
+    const value = line.slice(3)
+    if (!value) continue
+    const isRename = statusCode.includes("R")
+    const isDelete = statusCode.includes("D")
+    const isAdd = statusCode.includes("A") || statusCode === "??"
+    const changeType: ChatDiffFile["changeType"] = isRename
+      ? "renamed"
+      : isDelete
+        ? "deleted"
+        : isAdd
+          ? "added"
+          : "modified"
+
+    if (isRename && value.includes(" -> ")) {
+      const [previousPath, nextPath] = value.split(" -> ")
+      if (nextPath) {
+        entries.push({
+          path: nextPath,
+          previousPath: previousPath || undefined,
+          changeType,
+        })
+      }
+      continue
+    }
+
+    entries.push({
+      path: value,
+      changeType,
+    })
+  }
+  return entries.sort((left, right) => left.path.localeCompare(right.path))
+}
+
+async function listDirtyPaths(repoRoot: string) {
+  const status = await runGit(["status", "--short", "--untracked-files=all"], repoRoot)
+  if (status.exitCode !== 0) {
+    throw new Error(status.stderr.trim() || "Failed to read git status")
+  }
+
+  const paths = parseStatusPaths(status.stdout)
+  return paths
+}
+
+async function readWorktreeFile(repoRoot: string, relativePath: string): Promise<string | null> {
+  const absolutePath = path.join(repoRoot, relativePath)
+  if (!(await fileExists(absolutePath))) {
+    return null
+  }
+
+  return await readFile(absolutePath, "utf8")
+}
+
+async function readBaseFile(repoRoot: string, baseCommit: string | null, relativePath: string): Promise<string | null> {
+  if (!baseCommit) {
+    return null
+  }
+
+  const result = await runGit(["show", `${baseCommit}:${relativePath}`], repoRoot)
+  if (result.exitCode !== 0) {
+    return null
+  }
+  return result.stdout
+}
+
+async function createPatch(beforePathLabel: string, afterPathLabel: string, beforeText: string | null, afterText: string | null) {
+  const tempDir = await mkdtemp(path.join(tmpdir(), "kanna-diff-"))
+  const beforePath = path.join(tempDir, "before")
+  const afterPath = path.join(tempDir, "after")
+
+  try {
+    await writeFile(beforePath, beforeText ?? "", "utf8")
+    await writeFile(afterPath, afterText ?? "", "utf8")
+
+    const result = await runGit(
+      [
+        "diff",
+        "--no-index",
+        "--no-ext-diff",
+        "--text",
+        "--unified=3",
+        "--src-prefix=a/",
+        "--dst-prefix=b/",
+        "before",
+        "after",
+      ],
+      tempDir
+    )
+
+    if (result.exitCode !== 0 && result.exitCode !== 1) {
+      throw new Error(result.stderr.trim() || `Failed to build patch for ${afterPathLabel}`)
+    }
+
+    return result.stdout
+      .replace("diff --git a/before b/after", `diff --git a/${beforePathLabel} b/${afterPathLabel}`)
+      .replace("--- a/before", `--- a/${beforePathLabel}`)
+      .replace("+++ b/after", `+++ b/${afterPathLabel}`)
+  } finally {
+    await rm(tempDir, { recursive: true, force: true })
+  }
+}
+
+async function computeCurrentFiles(repoRoot: string, baseCommit: string | null): Promise<ChatDiffFile[]> {
+  const currentDirtyPaths = await listDirtyPaths(repoRoot)
+  const files: ChatDiffFile[] = []
+
+  for (const entry of currentDirtyPaths) {
+    const relativePath = entry.path
+    const beforePath = entry.previousPath ?? relativePath
+    const beforeText = await readBaseFile(repoRoot, baseCommit, beforePath)
+    const afterText = await readWorktreeFile(repoRoot, relativePath)
+    const absolutePath = path.join(repoRoot, relativePath)
+    const fileInfo = await stat(absolutePath).catch(() => null)
+    const file = fileInfo?.isFile() ? Bun.file(absolutePath) : null
+    const mimeType = file ? inferProjectFileContentType(relativePath, file.type) : undefined
+    const size = fileInfo?.isFile() ? fileInfo.size : undefined
+
+    if (beforeText === afterText && entry.changeType !== "renamed") {
+      continue
+    }
+
+    const patch = await createPatch(beforePath, relativePath, beforeText, afterText)
+    files.push({
+      path: relativePath,
+      changeType: entry.changeType,
+      patch,
+      mimeType,
+      size,
+    })
+  }
+
+  return files
+}
+
+function normalizeRepoRelativePath(inputPath: string) {
+  const normalized = path.posix.normalize(inputPath.replaceAll("\\", "/")).replace(/^\.\/+/u, "")
+  if (!normalized || normalized === "." || normalized.startsWith("../") || normalized.includes("/../") || path.posix.isAbsolute(normalized)) {
+    throw new Error(`Invalid diff path: ${inputPath}`)
+  }
+  return normalized
+}
+
+export class DiffStore {
+  private readonly states = new Map<string, StoredChatDiffState>()
+
+  constructor(_: string) {}
+
+  async initialize() {}
+
+  getSnapshot(chatId: string): ChatDiffSnapshot {
+    const state = this.states.get(chatId) ?? createEmptyState()
+    return {
+      status: state.status,
+      branchName: state.branchName,
+      files: [...state.files],
+    }
+  }
+
+  async refreshSnapshot(chatId: string, projectPath: string) {
+    const repo = await resolveRepo(projectPath)
+    if (!repo) {
+      const nextState = {
+        status: "no_repo",
+        branchName: undefined,
+        files: [],
+      } satisfies StoredChatDiffState
+      const changed = !snapshotsEqual(this.states.get(chatId), nextState)
+      this.states.set(chatId, nextState)
+      return changed
+    }
+
+    const files = await computeCurrentFiles(repo.repoRoot, repo.baseCommit)
+    const branchName = await getBranchName(repo.repoRoot)
+    const nextState = {
+      status: "ready",
+      branchName,
+      files,
+    } satisfies StoredChatDiffState
+    const changed = !snapshotsEqual(this.states.get(chatId), nextState)
+    this.states.set(chatId, nextState)
+    return changed
+  }
+
+  async generateCommitMessage(args: {
+    projectPath: string
+    paths: string[]
+  }) {
+    const normalizedPaths = [...new Set(args.paths.map(normalizeRepoRelativePath))]
+    if (normalizedPaths.length === 0) {
+      throw new Error("Select at least one file")
+    }
+
+    const repo = await resolveRepo(args.projectPath)
+    if (!repo) {
+      throw new Error("Project is not in a git repository")
+    }
+
+    const files = await computeCurrentFiles(repo.repoRoot, repo.baseCommit)
+    const selectedFiles = normalizedPaths.map((selectedPath) => {
+      const file = files.find((candidate) => candidate.path === selectedPath)
+      if (!file) {
+        throw new Error(`File is no longer changed: ${selectedPath}`)
+      }
+      return file
+    })
+
+    const branchName = await getBranchName(repo.repoRoot)
+    return await generateCommitMessageDetailed({
+      cwd: repo.repoRoot,
+      branchName,
+      files: selectedFiles,
+    })
+  }
+
+  async commitFiles(args: {
+    chatId: string
+    projectPath: string
+    paths: string[]
+    summary: string
+    description?: string
+  }) {
+    const summary = args.summary.trim()
+    const description = args.description?.trim()
+    if (!summary) {
+      throw new Error("Commit summary is required")
+    }
+
+    const normalizedPaths = [...new Set(args.paths.map(normalizeRepoRelativePath))]
+    if (normalizedPaths.length === 0) {
+      throw new Error("Select at least one file to commit")
+    }
+
+    const repo = await resolveRepo(args.projectPath)
+    if (!repo) {
+      throw new Error("Project is not in a git repository")
+    }
+
+    const currentDirtyPaths = new Set((await listDirtyPaths(repo.repoRoot)).map((entry) => entry.path))
+    const missingPaths = normalizedPaths.filter((relativePath) => !currentDirtyPaths.has(relativePath))
+    if (missingPaths.length > 0) {
+      throw new Error(`File is no longer changed: ${missingPaths[0]}`)
+    }
+
+    const addResult = await runGit(["add", "--", ...normalizedPaths], repo.repoRoot)
+    if (addResult.exitCode !== 0) {
+      throw new Error(addResult.stderr.trim() || "Failed to stage selected files")
+    }
+
+    const commitArgs = ["commit", "--only", "-m", summary]
+    if (description) {
+      commitArgs.push("-m", description)
+    }
+    commitArgs.push("--", ...normalizedPaths)
+
+    const commitResult = await runGit(commitArgs, repo.repoRoot)
+    if (commitResult.exitCode !== 0) {
+      throw new Error(commitResult.stderr.trim() || commitResult.stdout.trim() || "Failed to commit selected files")
+    }
+
+    return await this.refreshSnapshot(args.chatId, args.projectPath)
+  }
+}

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

@@ -0,0 +1,59 @@
+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({
+        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({
+        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,121 @@
+import path from "node:path"
+import type { ChatDiffFile } from "../shared/types"
+import { QuickResponseAdapter } from "./quick-response"
+
+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: "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: ChatDiffFile[]) {
+  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: ChatDiffFile[]
+}) {
+  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 concise 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 short 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: ChatDiffFile[]
+  },
+  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/read-models.test.ts

@@ -54,7 +54,7 @@ describe("read models", () => {
       lastTurnOutcome: null,
     })
 
-    const chat = deriveChatSnapshot(state, new Map(), new Set(), "chat-1", () => [])
+    const chat = deriveChatSnapshot(state, new Map(), new Set(), "chat-1", () => [], () => ({ status: "unknown", files: [] }))
     expect(chat?.runtime.provider).toBe("claude")
     expect(chat?.availableProviders.length).toBeGreaterThan(1)
     expect(chat?.availableProviders.find((provider) => provider.id === "codex")?.models.map((model) => model.id)).toEqual([

package/src/server/read-models.ts

@@ -1,4 +1,5 @@
 import type {
+  ChatDiffSnapshot,
   ChatRuntime,
   ChatSnapshot,
   KannaStatus,
@@ -100,7 +101,8 @@ export function deriveChatSnapshot(
   activeStatuses: Map<string, KannaStatus>,
   drainingChatIds: Set<string>,
   chatId: string,
-  getMessages: (chatId: string) => ChatSnapshot["messages"]
+  getMessages: (chatId: string) => ChatSnapshot["messages"],
+  getDiffs: (chatId: string) => ChatDiffSnapshot
 ): ChatSnapshot | null {
   const chat = state.chatsById.get(chatId)
   if (!chat || chat.deletedAt) return null
@@ -122,6 +124,7 @@ export function deriveChatSnapshot(
   return {
     runtime,
     messages: getMessages(chat.id),
+    diffs: getDiffs(chat.id),
     availableProviders: [...SERVER_PROVIDERS],
   }
 }