@cuongtran001/kanna 1.2.0 → 1.3.1

package/src/server/diff-store-io.adapter.ts

@@ -70,3 +70,30 @@ export async function spawnCommandCapture(args: string[]): Promise<SpawnResult>
 export function getBunEnv(): Record<string, string | undefined> {
   return Bun.env
 }
+
+export const NON_INTERACTIVE_GIT_ENV = {
+  GIT_TERMINAL_PROMPT: "0",
+  GIT_ASKPASS: "echo",
+  SSH_ASKPASS: "echo",
+  GCM_INTERACTIVE: "Never",
+} as const
+
+export function runGit(args: string[], cwd: string) {
+  return spawnGitCapture(args, cwd, { ...getBunEnv(), ...NON_INTERACTIVE_GIT_ENV })
+}
+
+export function runCommand(args: string[]) {
+  return spawnCommandCapture(args)
+}
+
+export function formatGitFailure(result: SpawnResult) {
+  return [result.stderr.trim(), result.stdout.trim()].filter(Boolean).join("\n")
+}
+
+export function summarizeGitFailure(detail: string, fallback: string) {
+  return detail
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .find((line) => line.length > 0)
+    ?? fallback
+}

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

@@ -0,0 +1,212 @@
+import { describe, expect, test } from "bun:test"
+import {
+  appendGitIgnoreEntry,
+  countTextLines,
+  getContentDigest,
+  normalizeRepoRelativePath,
+  parseNumstatValue,
+  parseStatusPaths,
+} from "./diff-store-parse"
+
+describe("parseStatusPaths", () => {
+  test("parses modified file", () => {
+    const result = parseStatusPaths(" M src/foo.ts\n")
+    expect(result).toHaveLength(1)
+    expect(result[0]).toMatchObject({ path: "src/foo.ts", changeType: "modified", isUntracked: false })
+  })
+
+  test("parses untracked file", () => {
+    const result = parseStatusPaths("?? new-file.ts\n")
+    expect(result).toHaveLength(1)
+    expect(result[0]).toMatchObject({ path: "new-file.ts", changeType: "added", isUntracked: true })
+  })
+
+  test("parses added file", () => {
+    const result = parseStatusPaths("A  staged.ts\n")
+    expect(result).toHaveLength(1)
+    expect(result[0]).toMatchObject({ path: "staged.ts", changeType: "added", isUntracked: false })
+  })
+
+  test("parses deleted file", () => {
+    const result = parseStatusPaths(" D gone.ts\n")
+    expect(result).toHaveLength(1)
+    expect(result[0]).toMatchObject({ path: "gone.ts", changeType: "deleted", isUntracked: false })
+  })
+
+  test("parses renamed file", () => {
+    const result = parseStatusPaths("R  old.ts -> new.ts\n")
+    expect(result).toHaveLength(1)
+    expect(result[0]).toMatchObject({
+      path: "new.ts",
+      previousPath: "old.ts",
+      changeType: "renamed",
+      isUntracked: false,
+    })
+  })
+
+  test("sorts results by path", () => {
+    const output = "?? b.ts\n?? a.ts\n?? c.ts\n"
+    const result = parseStatusPaths(output)
+    expect(result.map((e) => e.path)).toEqual(["a.ts", "b.ts", "c.ts"])
+  })
+
+  test("ignores lines shorter than 4 chars", () => {
+    const result = parseStatusPaths("AB\n M valid.ts\n")
+    expect(result).toHaveLength(1)
+    expect(result[0]?.path).toBe("valid.ts")
+  })
+
+  test("skips lines with empty value after status code", () => {
+    const result = parseStatusPaths(" M \n M real.ts\n")
+    expect(result).toHaveLength(1)
+    expect(result[0]?.path).toBe("real.ts")
+  })
+
+  test("returns empty array for empty input", () => {
+    expect(parseStatusPaths("")).toEqual([])
+    expect(parseStatusPaths("\n\n")).toEqual([])
+  })
+})
+
+describe("getContentDigest", () => {
+  test("returns a hex string", () => {
+    const digest = getContentDigest({
+      changeType: "modified",
+      beforePath: "a.ts",
+      afterPath: "a.ts",
+      beforeText: "old",
+      afterText: "new",
+    })
+    expect(digest).toMatch(/^[\da-f]{40}$/)
+  })
+
+  test("same inputs produce same digest", () => {
+    const args = {
+      changeType: "modified" as const,
+      beforePath: "a.ts",
+      afterPath: "a.ts",
+      beforeText: "old",
+      afterText: "new",
+    }
+    expect(getContentDigest(args)).toBe(getContentDigest(args))
+  })
+
+  test("different inputs produce different digests", () => {
+    const base = {
+      changeType: "modified" as const,
+      beforePath: "a.ts",
+      afterPath: "a.ts",
+      beforeText: "old",
+      afterText: "new",
+    }
+    const changed = { ...base, afterText: "different" }
+    expect(getContentDigest(base)).not.toBe(getContentDigest(changed))
+  })
+
+  test("handles null text", () => {
+    const digest = getContentDigest({
+      changeType: "added",
+      beforePath: "a.ts",
+      afterPath: "a.ts",
+      beforeText: null,
+      afterText: "content",
+    })
+    expect(typeof digest).toBe("string")
+    expect(digest).toHaveLength(40)
+  })
+})
+
+describe("parseNumstatValue", () => {
+  test("parses integer", () => {
+    expect(parseNumstatValue("42")).toBe(42)
+    expect(parseNumstatValue("0")).toBe(0)
+  })
+
+  test("returns 0 for binary marker", () => {
+    expect(parseNumstatValue("-")).toBe(0)
+  })
+
+  test("returns 0 for empty string", () => {
+    expect(parseNumstatValue("")).toBe(0)
+    expect(parseNumstatValue("  ")).toBe(0)
+  })
+
+  test("returns 0 for non-numeric string", () => {
+    expect(parseNumstatValue("abc")).toBe(0)
+  })
+})
+
+describe("countTextLines", () => {
+  test("counts lines", () => {
+    expect(countTextLines("a\nb\nc\n")).toBe(3)
+    expect(countTextLines("a\nb")).toBe(2)
+  })
+
+  test("returns 0 for null", () => {
+    expect(countTextLines(null)).toBe(0)
+  })
+
+  test("returns 0 for empty string", () => {
+    expect(countTextLines("")).toBe(0)
+  })
+
+  test("handles single line with trailing newline", () => {
+    expect(countTextLines("hello\n")).toBe(1)
+  })
+
+  test("handles single line without trailing newline", () => {
+    expect(countTextLines("hello")).toBe(1)
+  })
+})
+
+describe("normalizeRepoRelativePath", () => {
+  test("passes through simple paths", () => {
+    expect(normalizeRepoRelativePath("src/foo.ts")).toBe("src/foo.ts")
+  })
+
+  test("strips leading ./", () => {
+    expect(normalizeRepoRelativePath("./src/foo.ts")).toBe("src/foo.ts")
+  })
+
+  test("rejects absolute paths", () => {
+    expect(() => normalizeRepoRelativePath("/etc/passwd")).toThrow("Invalid diff path")
+  })
+
+  test("rejects parent traversal", () => {
+    expect(() => normalizeRepoRelativePath("../outside")).toThrow("Invalid diff path")
+  })
+
+  test("rejects embedded traversal", () => {
+    expect(() => normalizeRepoRelativePath("src/../../../etc/passwd")).toThrow("Invalid diff path")
+  })
+
+  test("normalizes backslashes on Windows-style paths", () => {
+    expect(normalizeRepoRelativePath("src\\foo.ts")).toBe("src/foo.ts")
+  })
+})
+
+describe("appendGitIgnoreEntry", () => {
+  test("adds entry to empty file", () => {
+    expect(appendGitIgnoreEntry(null, "dist/")).toBe("dist/\n")
+    expect(appendGitIgnoreEntry("", "dist/")).toBe("dist/\n")
+  })
+
+  test("appends entry to existing content", () => {
+    expect(appendGitIgnoreEntry("node_modules/\n", "dist/")).toBe("node_modules/\ndist/\n")
+  })
+
+  test("does not duplicate existing entry", () => {
+    const result = appendGitIgnoreEntry("dist/\n", "dist/")
+    expect(result).toBe("dist/\n")
+  })
+
+  test("adds newline to file missing trailing newline before appending", () => {
+    const result = appendGitIgnoreEntry("node_modules/", "dist/")
+    expect(result).toBe("node_modules/\ndist/\n")
+  })
+
+  test("does not duplicate entry that exists without trailing newline", () => {
+    const result = appendGitIgnoreEntry("dist/", "dist/")
+    expect(result).toBe("dist/\n")
+  })
+})

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

@@ -0,0 +1,122 @@
+import { createHash } from "node:crypto"
+import path from "node:path"
+import type { ChatDiffFile } from "../shared/types"
+
+export interface DirtyPathEntry {
+  path: string
+  previousPath?: string
+  changeType: ChatDiffFile["changeType"]
+  isUntracked: boolean
+}
+
+export 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 isUntracked = statusCode === "??"
+    const isRename = statusCode.includes("R")
+    const isDelete = statusCode.includes("D")
+    const isAdd = statusCode.includes("A") || isUntracked
+    let changeType: ChatDiffFile["changeType"]
+    if (isRename) {
+      changeType = "renamed"
+    } else if (isDelete) {
+      changeType = "deleted"
+    } else if (isAdd) {
+      changeType = "added"
+    } else {
+      changeType = "modified"
+    }
+
+    if (isRename && value.includes(" -> ")) {
+      const [previousPath, nextPath] = value.split(" -> ")
+      if (nextPath) {
+        entries.push({
+          path: nextPath,
+          previousPath: previousPath || undefined,
+          changeType,
+          isUntracked,
+        })
+      }
+      continue
+    }
+
+    entries.push({
+      path: value,
+      changeType,
+      isUntracked,
+    })
+  }
+  return entries.sort((left, right) => left.path.localeCompare(right.path))
+}
+
+export function getContentDigest(args: {
+  changeType: ChatDiffFile["changeType"]
+  beforePath: string
+  afterPath: string
+  beforeText: string | null
+  afterText: string | null
+}): string {
+  return createHash("sha1")
+    .update(args.changeType)
+    .update("\u0000")
+    .update(args.beforePath)
+    .update("\u0000")
+    .update(args.afterPath)
+    .update("\u0000")
+    .update(args.beforeText ?? "")
+    .update("\u0000")
+    .update(args.afterText ?? "")
+    .digest("hex")
+}
+
+export function parseNumstatValue(value: string): number {
+  if (value === "-" || value.trim() === "") return 0
+  const parsed = Number.parseInt(value, 10)
+  return Number.isFinite(parsed) ? parsed : 0
+}
+
+export function countTextLines(text: string | null): number {
+  if (!text) return 0
+  const lines = text.split(/\r?\n/u)
+  if (lines.at(-1) === "") {
+    lines.pop()
+  }
+  return lines.length
+}
+
+export function normalizeRepoRelativePath(inputPath: string): 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 function appendGitIgnoreEntry(currentContents: string | null, entry: string): string {
+  const normalizedContents = currentContents ?? ""
+  const existingEntries = normalizedContents
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter(Boolean)
+
+  if (existingEntries.includes(entry)) {
+    return normalizedContents.length > 0 && !normalizedContents.endsWith("\n")
+      ? `${normalizedContents}\n`
+      : normalizedContents
+  }
+
+  let prefix: string
+  if (normalizedContents.length === 0) {
+    prefix = ""
+  } else if (normalizedContents.endsWith("\n")) {
+    prefix = normalizedContents
+  } else {
+    prefix = `${normalizedContents}\n`
+  }
+  return `${prefix}${entry}\n`
+}

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

@@ -0,0 +1,82 @@
+import type {
+  BranchMetadata,
+  ChatBranchHistorySnapshot,
+  ChatDiffFile,
+  ChatDiffSnapshot,
+  UpstreamStatus,
+} from "../shared/types"
+
+export interface StoredChatDiffState extends BranchMetadata, UpstreamStatus {
+  status: ChatDiffSnapshot["status"]
+  files: ChatDiffFile[]
+  branchHistory: ChatBranchHistorySnapshot
+}
+
+export function createEmptyState(): StoredChatDiffState {
+  return {
+    status: "unknown",
+    branchName: undefined,
+    defaultBranchName: undefined,
+    hasOriginRemote: undefined,
+    originRepoSlug: undefined,
+    hasUpstream: undefined,
+    aheadCount: undefined,
+    behindCount: undefined,
+    lastFetchedAt: undefined,
+    files: [],
+    branchHistory: { entries: [] },
+  }
+}
+
+export function branchMetadataEqual(left: BranchMetadata, right: BranchMetadata): boolean {
+  return left.branchName === right.branchName
+    && left.defaultBranchName === right.defaultBranchName
+    && left.hasOriginRemote === right.hasOriginRemote
+    && left.originRepoSlug === right.originRepoSlug
+    && left.hasUpstream === right.hasUpstream
+}
+
+export function upstreamStatusEqual(left: UpstreamStatus, right: UpstreamStatus): boolean {
+  return left.aheadCount === right.aheadCount
+    && left.behindCount === right.behindCount
+    && left.lastFetchedAt === right.lastFetchedAt
+}
+
+export function branchHistoryEqual(left: ChatBranchHistorySnapshot, right: ChatBranchHistorySnapshot): boolean {
+  if (left.entries.length !== right.entries.length) return false
+  return left.entries.every((entry, index) => {
+    const other = right.entries[index]
+    return Boolean(other)
+      && entry.sha === other.sha
+      && entry.summary === other.summary
+      && entry.description === other.description
+      && entry.authorName === other.authorName
+      && entry.authoredAt === other.authoredAt
+      && entry.githubUrl === other.githubUrl
+      && entry.tags.length === other.tags.length
+      && entry.tags.every((tag, tagIndex) => tag === other.tags[tagIndex])
+  })
+}
+
+export function snapshotsEqual(left: StoredChatDiffState | undefined, right: StoredChatDiffState): boolean {
+  if (!left) {
+    return right.status === "unknown" && right.files.length === 0
+  }
+  if (left.status !== right.status) return false
+  if (!branchMetadataEqual(left, right)) return false
+  if (!upstreamStatusEqual(left, right)) return false
+  if (left.files.length !== right.files.length) return false
+  if (!branchHistoryEqual(left.branchHistory, right.branchHistory)) 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.isUntracked === other.isUntracked
+      && file.additions === other.additions
+      && file.deletions === other.deletions
+      && file.patchDigest === other.patchDigest
+      && file.mimeType === other.mimeType
+      && file.size === other.size
+  })
+}