@cuongtran001/kanna 1.2.0 → 1.3.1

package/src/server/diff-store-commit-ops.adapter.test.ts

@@ -0,0 +1,358 @@
+import { describe, expect, test } from "bun:test"
+import { mkdtempSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { runGit } from "./diff-store"
+import type { DiffStoreCommitOpsDeps } from "./diff-store-commit-ops.adapter"
+import {
+  commitFiles,
+  discardFile,
+  generateCommitMessage,
+  ignoreFile,
+} from "./diff-store-commit-ops.adapter"
+
+async function makeRepo(): Promise<string> {
+  const dir = mkdtempSync(path.join(tmpdir(), "kanna-commit-ops-"))
+  await runGit(["init", "-b", "main"], dir)
+  await runGit(["config", "user.email", "test@kanna.local"], dir)
+  await runGit(["config", "user.name", "kanna-test"], dir)
+  writeFileSync(path.join(dir, "README.md"), "hello\n")
+  await runGit(["add", "README.md"], dir)
+  await runGit(["commit", "-m", "init"], dir)
+  return dir
+}
+
+function makeDeps(overrides: Partial<DiffStoreCommitOpsDeps> = {}): DiffStoreCommitOpsDeps {
+  return {
+    refreshSnapshot: async () => false,
+    ...overrides,
+  }
+}
+
+describe("commitFiles", () => {
+  test("throws when not a git repo", async () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "kanna-not-git-"))
+    await expect(
+      commitFiles(makeDeps(), {
+        projectId: "p1",
+        projectPath: dir,
+        paths: ["README.md"],
+        summary: "test commit",
+        mode: "commit_only",
+      })
+    ).rejects.toThrow("not in a git repository")
+  }, 15_000)
+
+  test("throws when summary is empty", async () => {
+    const repo = await makeRepo()
+    await expect(
+      commitFiles(makeDeps(), {
+        projectId: "p1",
+        projectPath: repo,
+        paths: ["README.md"],
+        summary: "   ",
+        mode: "commit_only",
+      })
+    ).rejects.toThrow("Commit summary is required")
+  }, 15_000)
+
+  test("throws when no paths provided", async () => {
+    const repo = await makeRepo()
+    await expect(
+      commitFiles(makeDeps(), {
+        projectId: "p1",
+        projectPath: repo,
+        paths: [],
+        summary: "test commit",
+        mode: "commit_only",
+      })
+    ).rejects.toThrow("Select at least one file to commit")
+  }, 15_000)
+
+  test("throws when file is no longer changed", async () => {
+    const repo = await makeRepo()
+    await expect(
+      commitFiles(makeDeps(), {
+        projectId: "p1",
+        projectPath: repo,
+        paths: ["README.md"],
+        summary: "test commit",
+        mode: "commit_only",
+      })
+    ).rejects.toThrow("File is no longer changed")
+  }, 15_000)
+
+  test("commits an untracked file in commit_only mode", async () => {
+    const repo = await makeRepo()
+    writeFileSync(path.join(repo, "new-file.txt"), "content\n")
+
+    const result = await commitFiles(makeDeps(), {
+      projectId: "p1",
+      projectPath: repo,
+      paths: ["new-file.txt"],
+      summary: "add new file",
+      mode: "commit_only",
+    })
+
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.mode).toBe("commit_only")
+      expect(result.pushed).toBe(false)
+      expect(result.branchName).toBe("main")
+    }
+  }, 30_000)
+
+  test("commits a modified tracked file in commit_only mode", async () => {
+    const repo = await makeRepo()
+    writeFileSync(path.join(repo, "README.md"), "modified content\n")
+
+    const result = await commitFiles(makeDeps(), {
+      projectId: "p1",
+      projectPath: repo,
+      paths: ["README.md"],
+      summary: "update readme",
+      mode: "commit_only",
+    })
+
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.mode).toBe("commit_only")
+      expect(result.pushed).toBe(false)
+    }
+  }, 30_000)
+
+  test("calls refreshSnapshot on success", async () => {
+    const repo = await makeRepo()
+    writeFileSync(path.join(repo, "new-file.txt"), "content\n")
+
+    let called = false
+    const deps = makeDeps({
+      refreshSnapshot: async () => {
+        called = true
+        return true
+      },
+    })
+
+    await commitFiles(deps, {
+      projectId: "p1",
+      projectPath: repo,
+      paths: ["new-file.txt"],
+      summary: "add new file",
+      mode: "commit_only",
+    })
+
+    expect(called).toBe(true)
+  }, 30_000)
+
+  test("returns commit_only with pushed:false when no remote", async () => {
+    const repo = await makeRepo()
+    writeFileSync(path.join(repo, "new-file.txt"), "content\n")
+
+    const result = await commitFiles(makeDeps(), {
+      projectId: "p1",
+      projectPath: repo,
+      paths: ["new-file.txt"],
+      summary: "add new file",
+      mode: "commit_and_push",
+    })
+
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.pushed).toBe(false)
+    }
+  }, 30_000)
+})
+
+describe("discardFile", () => {
+  test("throws when not a git repo", async () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "kanna-not-git-"))
+    await expect(
+      discardFile(makeDeps(), {
+        projectId: "p1",
+        projectPath: dir,
+        path: "some-file.txt",
+      })
+    ).rejects.toThrow("not in a git repository")
+  }, 15_000)
+
+  test("throws when file is no longer changed", async () => {
+    const repo = await makeRepo()
+    await expect(
+      discardFile(makeDeps(), {
+        projectId: "p1",
+        projectPath: repo,
+        path: "README.md",
+      })
+    ).rejects.toThrow("File is no longer changed")
+  }, 15_000)
+
+  test("discards an untracked file by deleting it", async () => {
+    const repo = await makeRepo()
+    const filePath = path.join(repo, "untracked.txt")
+    writeFileSync(filePath, "content\n")
+
+    const result = await discardFile(makeDeps(), {
+      projectId: "p1",
+      projectPath: repo,
+      path: "untracked.txt",
+    })
+
+    expect(result.snapshotChanged).toBe(false)
+    const exists = await Bun.file(filePath).exists()
+    expect(exists).toBe(false)
+  }, 30_000)
+
+  test("discards modifications to a tracked file via restore", async () => {
+    const repo = await makeRepo()
+    writeFileSync(path.join(repo, "README.md"), "modified content\n")
+
+    const result = await discardFile(makeDeps(), {
+      projectId: "p1",
+      projectPath: repo,
+      path: "README.md",
+    })
+
+    expect(result.snapshotChanged).toBe(false)
+
+    // Verify the file was restored
+    const content = await Bun.file(path.join(repo, "README.md")).text()
+    expect(content).toBe("hello\n")
+  }, 30_000)
+
+  test("calls refreshSnapshot after discard", async () => {
+    const repo = await makeRepo()
+    writeFileSync(path.join(repo, "untracked.txt"), "content\n")
+
+    let called = false
+    const deps = makeDeps({
+      refreshSnapshot: async () => {
+        called = true
+        return true
+      },
+    })
+
+    await discardFile(deps, {
+      projectId: "p1",
+      projectPath: repo,
+      path: "untracked.txt",
+    })
+
+    expect(called).toBe(true)
+  }, 30_000)
+})
+
+describe("ignoreFile", () => {
+  test("throws when not a git repo", async () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "kanna-not-git-"))
+    await expect(
+      ignoreFile(makeDeps(), {
+        projectId: "p1",
+        projectPath: dir,
+        path: "some-file.txt",
+      })
+    ).rejects.toThrow("not in a git repository")
+  }, 15_000)
+
+  test("throws when file is no longer changed", async () => {
+    const repo = await makeRepo()
+    await expect(
+      ignoreFile(makeDeps(), {
+        projectId: "p1",
+        projectPath: repo,
+        path: "README.md",
+      })
+    ).rejects.toThrow("File is no longer changed")
+  }, 15_000)
+
+  test("throws when file is tracked (not untracked)", async () => {
+    const repo = await makeRepo()
+    writeFileSync(path.join(repo, "README.md"), "modified content\n")
+    await expect(
+      ignoreFile(makeDeps(), {
+        projectId: "p1",
+        projectPath: repo,
+        path: "README.md",
+      })
+    ).rejects.toThrow("Only untracked files can be ignored")
+  }, 30_000)
+
+  test("adds untracked file to .gitignore", async () => {
+    const repo = await makeRepo()
+    writeFileSync(path.join(repo, "secret.txt"), "secret content\n")
+
+    const result = await ignoreFile(makeDeps(), {
+      projectId: "p1",
+      projectPath: repo,
+      path: "secret.txt",
+    })
+
+    expect(result.snapshotChanged).toBe(false)
+
+    const gitignoreContent = await Bun.file(path.join(repo, ".gitignore")).text()
+    expect(gitignoreContent).toContain("secret.txt")
+  }, 30_000)
+
+  test("calls refreshSnapshot after ignore", async () => {
+    const repo = await makeRepo()
+    writeFileSync(path.join(repo, "secret.txt"), "secret content\n")
+
+    let called = false
+    const deps = makeDeps({
+      refreshSnapshot: async () => {
+        called = true
+        return true
+      },
+    })
+
+    await ignoreFile(deps, {
+      projectId: "p1",
+      projectPath: repo,
+      path: "secret.txt",
+    })
+
+    expect(called).toBe(true)
+  }, 30_000)
+})
+
+describe("generateCommitMessage", () => {
+  test("throws when not a git repo", async () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "kanna-not-git-"))
+    await expect(
+      generateCommitMessage(makeDeps(), {
+        projectPath: dir,
+        paths: ["README.md"],
+      })
+    ).rejects.toThrow("not in a git repository")
+  }, 15_000)
+
+  test("throws when no paths provided", async () => {
+    const repo = await makeRepo()
+    await expect(
+      generateCommitMessage(makeDeps(), {
+        projectPath: repo,
+        paths: [],
+      })
+    ).rejects.toThrow("Select at least one file")
+  }, 15_000)
+
+  test("throws when file is no longer changed", async () => {
+    const repo = await makeRepo()
+    await expect(
+      generateCommitMessage(makeDeps(), {
+        projectPath: repo,
+        paths: ["README.md"],
+      })
+    ).rejects.toThrow("File is no longer changed")
+  }, 15_000)
+
+  test("deduplicates paths before processing", async () => {
+    const repo = await makeRepo()
+    // Both paths resolve to the same file — the error should mention the unique path
+    await expect(
+      generateCommitMessage(makeDeps(), {
+        projectPath: repo,
+        paths: ["README.md", "README.md"],
+      })
+    ).rejects.toThrow("File is no longer changed")
+  }, 15_000)
+})

package/src/server/diff-store-commit-ops.adapter.ts

@@ -0,0 +1,258 @@
+import path from "node:path"
+import {
+  formatGitFailure,
+  readTextFileOrNull,
+  rmPathRecursive,
+  runGit,
+  writeTextFile,
+} from "./diff-store-io.adapter"
+import {
+  getBranchName,
+  getOriginRemoteUrl,
+  hasUpstreamBranch,
+  resolveRepo,
+} from "./diff-store-git-branch.adapter"
+import { appendGitIgnoreEntry, normalizeRepoRelativePath } from "./diff-store-parse"
+import {
+  createCommitFailure,
+  createPushFailure,
+} from "./diff-store-errors"
+import {
+  createPatch,
+  discardAddedPath,
+  discardRenamedPath,
+  findDirtyPath,
+  listDirtyPaths,
+  readBaseFile,
+  readWorktreeFile,
+} from "./diff-store-file-ops.adapter"
+import type {
+  DiffCommitMode,
+  DiffCommitResult,
+} from "../shared/types"
+import { generateCommitMessageDetailed } from "./generate-commit-message"
+
+export interface DiffStoreCommitOpsDeps {
+  readonly refreshSnapshot: (projectId: string, projectPath: string) => Promise<boolean>
+}
+
+export async function generateCommitMessage(
+  _deps: DiffStoreCommitOpsDeps,
+  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 currentDirtyPaths = await listDirtyPaths(repo.repoRoot)
+  const selectedFiles = await Promise.all(normalizedPaths.map(async (selectedPath) => {
+    const entry = currentDirtyPaths.find((candidate) => candidate.path === selectedPath)
+    if (!entry) {
+      throw new Error(`File is no longer changed: ${selectedPath}`)
+    }
+
+    const beforePath = entry.previousPath ?? selectedPath
+    const beforeText = await readBaseFile(repo.repoRoot, repo.baseCommit, beforePath)
+    const afterText = await readWorktreeFile(repo.repoRoot, selectedPath)
+    const patch = await createPatch(beforePath, selectedPath, beforeText, afterText)
+
+    return {
+      path: selectedPath,
+      changeType: entry.changeType,
+      patch,
+    }
+  }))
+
+  const branchName = await getBranchName(repo.repoRoot)
+  return await generateCommitMessageDetailed({
+    cwd: repo.repoRoot,
+    branchName,
+    files: selectedFiles,
+  })
+}
+
+export async function commitFiles(
+  deps: DiffStoreCommitOpsDeps,
+  args: {
+    projectId: string
+    projectPath: string
+    paths: string[]
+    summary: string
+    description?: string
+    mode: DiffCommitMode
+  }
+): Promise<DiffCommitResult> {
+  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 [hasUpstream, originRemoteUrl] = await Promise.all([
+    hasUpstreamBranch(repo.repoRoot),
+    getOriginRemoteUrl(repo.repoRoot),
+  ])
+  const hasOriginRemote = originRemoteUrl !== null
+
+  const currentDirtyEntries = await listDirtyPaths(repo.repoRoot)
+  const currentDirtyPathsByPath = new Map(currentDirtyEntries.map((entry) => [entry.path, entry]))
+  const missingPaths = normalizedPaths.filter((relativePath) => !currentDirtyPathsByPath.has(relativePath))
+  if (missingPaths.length > 0) {
+    throw new Error(`File is no longer changed: ${missingPaths[0]}`)
+  }
+
+  const trackedPaths = normalizedPaths.filter((relativePath) => !currentDirtyPathsByPath.get(relativePath)?.isUntracked)
+  if (trackedPaths.length > 0) {
+    const addTrackedResult = await runGit(["add", "-u", "--", ...trackedPaths], repo.repoRoot)
+    if (addTrackedResult.exitCode !== 0) {
+      return createCommitFailure(args.mode, formatGitFailure(addTrackedResult))
+    }
+  }
+
+  const untrackedPaths = normalizedPaths.filter((relativePath) => currentDirtyPathsByPath.get(relativePath)?.isUntracked)
+  if (untrackedPaths.length > 0) {
+    const addUntrackedResult = await runGit(["add", "--", ...untrackedPaths], repo.repoRoot)
+    if (addUntrackedResult.exitCode !== 0) {
+      return createCommitFailure(args.mode, formatGitFailure(addUntrackedResult))
+    }
+  }
+
+  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) {
+    return createCommitFailure(args.mode, formatGitFailure(commitResult))
+  }
+
+  const snapshotChanged = await deps.refreshSnapshot(args.projectId, args.projectPath)
+  const branchName = await getBranchName(repo.repoRoot)
+
+  if (args.mode === "commit_only") {
+    return {
+      ok: true,
+      mode: args.mode,
+      branchName,
+      pushed: false,
+      snapshotChanged,
+    } satisfies DiffCommitResult
+  }
+
+  if (!hasUpstream && !hasOriginRemote) {
+    return {
+      ok: true,
+      mode: args.mode,
+      branchName,
+      pushed: false,
+      snapshotChanged,
+    } satisfies DiffCommitResult
+  }
+
+  const pushResult = hasUpstream
+    ? await runGit(["push"], repo.repoRoot)
+    : await runGit(["push", "-u", "origin", "HEAD"], repo.repoRoot)
+  if (pushResult.exitCode !== 0) {
+    return createPushFailure(args.mode, formatGitFailure(pushResult), snapshotChanged)
+  }
+
+  const postPushSnapshotChanged = await deps.refreshSnapshot(args.projectId, args.projectPath)
+
+  return {
+    ok: true,
+    mode: args.mode,
+    branchName,
+    pushed: true,
+    snapshotChanged: snapshotChanged || postPushSnapshotChanged,
+  } satisfies DiffCommitResult
+}
+
+export async function discardFile(
+  deps: DiffStoreCommitOpsDeps,
+  args: { projectId: string; projectPath: string; path: string }
+) {
+  const relativePath = normalizeRepoRelativePath(args.path)
+  const repo = await resolveRepo(args.projectPath)
+  if (!repo) {
+    throw new Error("Project is not in a git repository")
+  }
+
+  const entry = await findDirtyPath(repo.repoRoot, relativePath)
+  if (!entry) {
+    throw new Error(`File is no longer changed: ${relativePath}`)
+  }
+
+  if (entry.isUntracked) {
+    await rmPathRecursive(path.join(repo.repoRoot, entry.path))
+  } else if (entry.changeType === "added") {
+    await discardAddedPath(repo.repoRoot, repo.baseCommit !== null, entry.path)
+    await rmPathRecursive(path.join(repo.repoRoot, entry.path))
+  } else if (entry.changeType === "renamed") {
+    if (!repo.baseCommit) {
+      throw new Error("Cannot discard a rename before the repository has an initial commit")
+    }
+    await discardRenamedPath(repo.repoRoot, entry)
+  } else {
+    if (!repo.baseCommit) {
+      throw new Error("Cannot discard tracked changes before the repository has an initial commit")
+    }
+    const restoreResult = await runGit(["restore", "--staged", "--worktree", "--source=HEAD", "--", entry.path], repo.repoRoot)
+    if (restoreResult.exitCode !== 0) {
+      throw new Error(formatGitFailure(restoreResult) || "Failed to discard file changes")
+    }
+  }
+
+  return {
+    snapshotChanged: await deps.refreshSnapshot(args.projectId, args.projectPath),
+  }
+}
+
+export async function ignoreFile(
+  deps: DiffStoreCommitOpsDeps,
+  args: { projectId: string; projectPath: string; path: string }
+) {
+  const ignoreEntry = normalizeRepoRelativePath(args.path)
+  const repo = await resolveRepo(args.projectPath)
+  if (!repo) {
+    throw new Error("Project is not in a git repository")
+  }
+
+  const dirtyPaths = await listDirtyPaths(repo.repoRoot)
+  const exactEntry = dirtyPaths.find((candidate) => candidate.path === ignoreEntry)
+  if (exactEntry && !exactEntry.isUntracked) {
+    throw new Error("Only untracked files can be ignored from the diff viewer")
+  }
+
+  const entry = dirtyPaths.find((candidate) => candidate.isUntracked && (candidate.path === ignoreEntry || candidate.path.startsWith(ignoreEntry)))
+  if (!entry) {
+    throw new Error(`File is no longer changed: ${ignoreEntry}`)
+  }
+
+  const gitignorePath = path.join(repo.repoRoot, ".gitignore")
+  const currentContents = await readTextFileOrNull(gitignorePath)
+  const nextContents = appendGitIgnoreEntry(currentContents, ignoreEntry)
+  if (nextContents !== currentContents) {
+    await writeTextFile(gitignorePath, nextContents)
+  }
+
+  return {
+    snapshotChanged: await deps.refreshSnapshot(args.projectId, args.projectPath),
+  }
+}

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

@@ -0,0 +1,85 @@
+import { summarizeGitFailure } from "./diff-store-io.adapter"
+import type { ChatSyncResult, DiffCommitMode, DiffCommitResult } from "../shared/types"
+
+export function createCommitFailure(mode: DiffCommitMode, detail: string): DiffCommitResult {
+  const normalized = detail.toLowerCase()
+  let title = "Commit failed"
+  let message = summarizeGitFailure(detail, "Git could not create the commit.")
+
+  if (normalized.includes("ignored by one of your .gitignore files")) {
+    title = "Ignored files cannot be staged"
+    message = "One or more selected paths are ignored by .gitignore. Unignore them or remove them from the commit selection."
+  }
+
+  return {
+    ok: false,
+    mode,
+    phase: "commit",
+    title,
+    message,
+    detail,
+  }
+}
+
+export function createPushFailure(mode: DiffCommitMode, detail: string, snapshotChanged: boolean): DiffCommitResult {
+  const normalized = detail.toLowerCase()
+  let title = "Push failed"
+  let message = summarizeGitFailure(detail, "Git could not push the commit.")
+
+  if (normalized.includes("non-fast-forward") || normalized.includes("fetch first")) {
+    title = "Branch is not up to date"
+    message = "Your branch is behind its remote. Pull or rebase, then try pushing again."
+  } else if (normalized.includes("does not appear to be a git repository")) {
+    title = "No origin remote configured"
+    message = "This repository does not have an origin remote configured."
+  } else if (normalized.includes("has no upstream branch") || normalized.includes("set-upstream")) {
+    title = "No upstream branch configured"
+    message = "This branch does not have an upstream remote branch configured yet."
+  } else if (normalized.includes("merge conflict") || normalized.includes("resolve conflicts")) {
+    title = "Merge conflicts need resolution"
+    message = "Git reported conflicts while preparing the push. Resolve them, then try again."
+  } else if (normalized.includes("permission denied") || normalized.includes("authentication failed") || normalized.includes("could not read from remote repository")) {
+    title = "Remote authentication failed"
+    message = "Git could not authenticate with the remote repository."
+  }
+
+  return {
+    ok: false,
+    mode,
+    phase: "push",
+    title,
+    message,
+    detail,
+    localCommitCreated: true,
+    snapshotChanged,
+  }
+}
+
+export function createSyncPushFailure(detail: string, snapshotChanged: boolean): ChatSyncResult {
+  const normalized = detail.toLowerCase()
+  let title = "Push failed"
+  let message = summarizeGitFailure(detail, "Git could not push this branch.")
+
+  if (normalized.includes("non-fast-forward") || normalized.includes("fetch first")) {
+    title = "Branch is not up to date"
+    message = "Your branch is behind its remote. Pull or rebase, then try pushing again."
+  } else if (normalized.includes("has no upstream branch") || normalized.includes("set-upstream")) {
+    title = "No upstream branch configured"
+    message = "This branch does not have an upstream remote branch configured yet."
+  } else if (normalized.includes("merge conflict") || normalized.includes("resolve conflicts")) {
+    title = "Merge conflicts need resolution"
+    message = "Git reported conflicts while preparing the push. Resolve them, then try again."
+  } else if (normalized.includes("permission denied") || normalized.includes("authentication failed") || normalized.includes("could not read from remote repository")) {
+    title = "Remote authentication failed"
+    message = "Git could not authenticate with the remote repository."
+  }
+
+  return {
+    ok: false,
+    action: "push",
+    title,
+    message,
+    detail,
+    snapshotChanged,
+  }
+}