kanna-code 0.19.0 → 0.21.0

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(), "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,
@@ -98,8 +99,10 @@ export function deriveLocalProjectsSnapshot(
 export function deriveChatSnapshot(
   state: StoreState,
   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
@@ -112,6 +115,7 @@ export function deriveChatSnapshot(
     localPath: project.localPath,
     title: chat.title,
     status: deriveStatus(chat, activeStatuses.get(chat.id)),
+    isDraining: drainingChatIds.has(chat.id),
     provider: chat.provider,
     planMode: chat.planMode,
     sessionToken: chat.sessionToken,
@@ -120,6 +124,7 @@ export function deriveChatSnapshot(
   return {
     runtime,
     messages: getMessages(chat.id),
+    diffs: getDiffs(chat.id),
     availableProviders: [...SERVER_PROVIDERS],
   }
 }

package/src/server/server.ts

@@ -4,6 +4,7 @@ import { APP_NAME, getRuntimeProfile } from "../shared/branding"
 import type { ChatAttachment } from "../shared/types"
 import { EventStore } from "./event-store"
 import { AgentCoordinator } from "./agent"
+import { DiffStore } from "./diff-store"
 import { discoverProjects, type DiscoveredProject } from "./discovery"
 import { KeybindingsManager } from "./keybindings"
 import { getMachineDisplayName } from "./machine-name"
@@ -11,7 +12,7 @@ import { TerminalManager } from "./terminal-manager"
 import { UpdateManager } from "./update-manager"
 import type { UpdateInstallAttemptResult } from "./cli-runtime"
 import { createWsRouter, type ClientState } from "./ws-router"
-import { deleteProjectUpload, inferAttachmentContentType, persistProjectUpload } from "./uploads"
+import { deleteProjectUpload, inferAttachmentContentType, inferProjectFileContentType, persistProjectUpload } from "./uploads"
 import { getProjectUploadDir } from "./paths"
 
 const MAX_UPLOAD_FILES = 10
@@ -68,8 +69,10 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   const hostname = options.host ?? "127.0.0.1"
   const strictPort = options.strictPort ?? false
   const store = new EventStore()
+  const diffStore = new DiffStore(store.dataDir)
   const machineDisplayName = getMachineDisplayName()
   await store.initialize()
+  await diffStore.initialize()
   await store.migrateLegacyTranscripts(options.onMigrationProgress)
   let discoveredProjects: DiscoveredProject[] = []
 
@@ -101,6 +104,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   })
   router = createWsRouter({
     store,
+    diffStore,
     agent,
     terminals,
     keybindings,
@@ -127,6 +131,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
             const upgraded = serverInstance.upgrade(req, {
               data: {
                 subscriptions: new Map(),
+                snapshotSignatures: new Map(),
               },
             })
             return upgraded ? undefined : new Response("WebSocket upgrade failed", { status: 400 })
@@ -151,6 +156,11 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
             return attachmentContentResponse
           }
 
+          const projectFileContentResponse = await handleProjectFileContent(req, url, store)
+          if (projectFileContentResponse) {
+            return projectFileContentResponse
+          }
+
           return serveStatic(distDir, url.pathname)
         },
         websocket: {
@@ -191,6 +201,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   return {
     port: actualPort,
     store,
+    diffStore,
     updateManager,
     stop: shutdown,
   }
@@ -289,6 +300,54 @@ async function handleAttachmentContent(req: Request, url: URL, store: EventStore
   })
 }
 
+async function handleProjectFileContent(req: Request, url: URL, store: EventStore) {
+  const match = url.pathname.match(/^\/api\/projects\/([^/]+)\/files\/([^/]+)\/content$/)
+  if (!match) {
+    return null
+  }
+
+  if (req.method !== "GET") {
+    return new Response(null, {
+      status: 405,
+      headers: {
+        Allow: "GET",
+      },
+    })
+  }
+
+  const project = store.getProject(match[1])
+  if (!project) {
+    return Response.json({ error: "Project not found" }, { status: 404 })
+  }
+
+  const relativePath = path.posix.normalize(decodeURIComponent(match[2]).replaceAll("\\", "/"))
+  if (!relativePath || relativePath === "." || relativePath.startsWith("../") || relativePath.includes("/../") || path.posix.isAbsolute(relativePath)) {
+    return Response.json({ error: "Invalid project file path" }, { status: 400 })
+  }
+
+  const filePath = path.resolve(project.localPath, relativePath)
+  const projectRoot = path.resolve(project.localPath)
+  if (filePath !== projectRoot && !filePath.startsWith(`${projectRoot}${path.sep}`)) {
+    return Response.json({ error: "Invalid project file path" }, { status: 400 })
+  }
+
+  const file = Bun.file(filePath)
+  try {
+    const info = await stat(filePath)
+    if (!info.isFile()) {
+      return Response.json({ error: "File not found" }, { status: 404 })
+    }
+  } catch {
+    return Response.json({ error: "File not found" }, { status: 404 })
+  }
+
+  return new Response(file, {
+    headers: {
+      "Content-Type": inferProjectFileContentType(relativePath, file.type),
+    },
+  })
+}
+
 async function handleProjectUploadDelete(req: Request, url: URL, store: EventStore) {
   if (req.method !== "DELETE") {
     return null