kanna-code 0.24.0 → 0.25.1

package/src/server/diff-store.ts

@@ -1,7 +1,9 @@
+import { createHash } from "node:crypto"
 import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises"
 import { tmpdir } from "node:os"
 import path from "node:path"
 import type {
+  BranchMetadata,
   ChatBranchHistoryEntry,
   ChatBranchHistorySnapshot,
   ChatBranchListEntry,
@@ -10,22 +12,18 @@ import type {
   ChatCreateBranchResult,
   ChatDiffFile,
   ChatDiffSnapshot,
+  ChatMergeBranchResult,
+  ChatMergePreviewResult,
   ChatSyncResult,
   DiffCommitMode,
   DiffCommitResult,
+  UpstreamStatus,
 } from "../shared/types"
 import { generateCommitMessageDetailed } from "./generate-commit-message"
 import { inferProjectFileContentType } from "./uploads"
 
-interface StoredChatDiffState {
+interface StoredChatDiffState extends BranchMetadata, UpstreamStatus {
   status: ChatDiffSnapshot["status"]
-  branchName?: string
-  defaultBranchName?: string
-  originRepoSlug?: string
-  hasUpstream?: boolean
-  aheadCount?: number
-  behindCount?: number
-  lastFetchedAt?: string
   files: ChatDiffFile[]
   branchHistory: ChatBranchHistorySnapshot
 }
@@ -45,22 +43,23 @@ function createEmptyState(): StoredChatDiffState {
   }
 }
 
-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.defaultBranchName !== right.defaultBranchName) return false
-  if (left.originRepoSlug !== right.originRepoSlug) return false
-  if (left.hasUpstream !== right.hasUpstream) return false
-  if (left.aheadCount !== right.aheadCount) return false
-  if (left.behindCount !== right.behindCount) return false
-  if (left.lastFetchedAt !== right.lastFetchedAt) return false
-  if (left.files.length !== right.files.length) return false
-  if (left.branchHistory.entries.length !== right.branchHistory.entries.length) return false
-  const sameHistory = left.branchHistory.entries.every((entry, index) => {
-    const other = right.branchHistory.entries[index]
+function branchMetadataEqual(left: BranchMetadata, right: BranchMetadata) {
+  return left.branchName === right.branchName
+    && left.defaultBranchName === right.defaultBranchName
+    && left.originRepoSlug === right.originRepoSlug
+    && left.hasUpstream === right.hasUpstream
+}
+
+function upstreamStatusEqual(left: UpstreamStatus, right: UpstreamStatus) {
+  return left.aheadCount === right.aheadCount
+    && left.behindCount === right.behindCount
+    && left.lastFetchedAt === right.lastFetchedAt
+}
+
+function branchHistoryEqual(left: ChatBranchHistorySnapshot, right: ChatBranchHistorySnapshot) {
+  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
@@ -71,13 +70,28 @@ function snapshotsEqual(left: StoredChatDiffState | undefined, right: StoredChat
       && entry.tags.length === other.tags.length
       && entry.tags.every((tag, tagIndex) => tag === other.tags[tagIndex])
   })
-  if (!sameHistory) return false
+}
+
+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 (!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.patch === other.patch
+      && file.isUntracked === other.isUntracked
+      && file.additions === other.additions
+      && file.deletions === other.deletions
+      && file.patchDigest === other.patchDigest
+      && file.mimeType === other.mimeType
+      && file.size === other.size
   })
 }
 
@@ -88,6 +102,19 @@ interface DirtyPathEntry {
   isUntracked: boolean
 }
 
+type SelectedBranch =
+  | { kind: "local"; name: string }
+  | { kind: "remote"; name: string; remoteRef: string }
+  | {
+      kind: "pull_request"
+      name: string
+      prNumber: number
+      headRefName: string
+      headRepoCloneUrl?: string
+      isCrossRepository?: boolean
+      remoteRef?: string
+    }
+
 async function fileExists(filePath: string) {
   try {
     await stat(filePath)
@@ -188,6 +215,35 @@ function createPushFailure(mode: DiffCommitMode, detail: string, snapshotChanged
   }
 }
 
+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,
+  }
+}
+
 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) {
@@ -366,6 +422,89 @@ async function getRecentBranchNames(repoRoot: string) {
   return recent
 }
 
+async function resolveSelectedBranchRef(repoRoot: string, branch: SelectedBranch) {
+  if (branch.kind === "local") {
+    const localBranchNames = await getLocalBranchNames(repoRoot)
+    if (!localBranchNames.includes(branch.name)) {
+      throw new Error(`Local branch not found: ${branch.name}`)
+    }
+    return {
+      ref: branch.name,
+      displayName: branch.name,
+      branchName: branch.name,
+    }
+  }
+
+  if (branch.kind === "remote") {
+    const remoteRef = branch.remoteRef.trim()
+    const remoteBranchNames = await getRemoteBranchNames(repoRoot)
+    if (!remoteBranchNames.includes(remoteRef)) {
+      throw new Error(`Remote branch not found: ${remoteRef}`)
+    }
+    return {
+      ref: remoteRef,
+      displayName: remoteRef,
+      branchName: branch.name,
+    }
+  }
+
+  const localBranchNames = await getLocalBranchNames(repoRoot)
+  if (localBranchNames.includes(branch.name)) {
+    return {
+      ref: branch.name,
+      displayName: `PR #${branch.prNumber}`,
+      branchName: branch.name,
+    }
+  }
+
+  const remoteRef = branch.remoteRef?.trim()
+  if (remoteRef) {
+    const remoteBranchNames = await getRemoteBranchNames(repoRoot)
+    if (remoteBranchNames.includes(remoteRef)) {
+      return {
+        ref: remoteRef,
+        displayName: `PR #${branch.prNumber}`,
+        branchName: branch.headRefName || branch.name,
+      }
+    }
+  }
+
+  if (branch.isCrossRepository) {
+    throw new Error("This pull request branch is not available locally yet. Check it out first before merging.")
+  }
+
+  throw new Error(`Pull request branch not found: ${branch.headRefName || branch.name}`)
+}
+
+async function getMergeCommitCount(repoRoot: string, sourceRef: string) {
+  const result = await runGit(["rev-list", "--count", `HEAD..${sourceRef}`], repoRoot)
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr.trim() || "Failed to calculate merge commit count")
+  }
+
+  const commitCount = Number.parseInt(result.stdout.trim(), 10)
+  return Number.isFinite(commitCount) ? commitCount : 0
+}
+
+async function predictMergeConflicts(repoRoot: string, sourceRef: string) {
+  const result = await runGit(["merge-tree", "--write-tree", "--messages", "HEAD", sourceRef], repoRoot)
+  const output = `${result.stdout}\n${result.stderr}`.trim()
+
+  if (result.exitCode === 0) {
+    return { hasConflicts: false }
+  }
+
+  const normalizedOutput = output.toLowerCase()
+  if (result.exitCode === 1 || normalizedOutput.includes("conflict")) {
+    return {
+      hasConflicts: true,
+      detail: output || "Git reported merge conflicts for this branch pair.",
+    }
+  }
+
+  throw new Error(output || "Failed to analyze merge conflicts")
+}
+
 export function extractGitHubRepoSlug(remoteUrl: string | null | undefined) {
   if (!remoteUrl) return null
 
@@ -464,16 +603,40 @@ function buildGitHubCommitUrl(remoteUrl: string | null, sha: string) {
   return slug ? `https://github.com/${slug}/commit/${sha}` : undefined
 }
 
-async function listCommitTags(repoRoot: string, sha: string) {
-  const result = await runGit(["tag", "--points-at", sha], repoRoot)
-  if (result.exitCode !== 0) {
-    return []
+async function getTagsByCommit(repoRoot: string, shas: string[]): Promise<Map<string, string[]>> {
+  const tagMap = new Map<string, string[]>()
+  if (shas.length === 0) return tagMap
+
+  for (const sha of shas) {
+    tagMap.set(sha, [])
   }
-  return result.stdout
-    .split(/\r?\n/u)
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .sort((left, right) => left.localeCompare(right))
+
+  const result = await runGit(
+    ["log", "--max-count", String(shas.length), "--decorate-refs=refs/tags", "--format=%H %D", shas[0]!],
+    repoRoot
+  )
+
+  if (result.exitCode !== 0) return tagMap
+
+  for (const line of result.stdout.split(/\r?\n/u)) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    const spaceIndex = trimmed.indexOf(" ")
+    if (spaceIndex < 0) continue
+    const sha = trimmed.slice(0, spaceIndex)
+    const decorations = trimmed.slice(spaceIndex + 1)
+    if (!tagMap.has(sha) || !decorations) continue
+    const tags = decorations
+      .split(",")
+      .map((decoration) => decoration.trim())
+      .filter((decoration) => decoration.startsWith("tag: "))
+      .map((decoration) => decoration.slice(5))
+      .filter(Boolean)
+      .sort((left, right) => left.localeCompare(right))
+    tagMap.set(sha, tags)
+  }
+
+  return tagMap
 }
 
 async function getBranchHistory(args: {
@@ -497,24 +660,30 @@ async function getBranchHistory(args: {
   }
 
   const remoteUrl = await getOriginRemoteUrl(args.repoRoot)
-  const entries: ChatBranchHistoryEntry[] = []
+  const parsedRecords: Array<{ sha: string; summary: string; description: string; authorName?: string; authoredAt: string }> = []
 
   for (const record of logResult.stdout.split("\u001e")) {
     const trimmed = record.trim()
     if (!trimmed) continue
     const [sha, summary, description, authorName, authoredAt] = trimmed.split("\u001f")
     if (!sha || !summary || !authoredAt) continue
-    entries.push({
+    parsedRecords.push({
       sha,
       summary,
       description: (description ?? "").trim(),
       authorName: authorName?.trim() || undefined,
       authoredAt,
-      tags: await listCommitTags(args.repoRoot, sha),
-      githubUrl: buildGitHubCommitUrl(remoteUrl, sha),
     })
   }
 
+  const tagMap = await getTagsByCommit(args.repoRoot, parsedRecords.map((record) => record.sha))
+
+  const entries: ChatBranchHistoryEntry[] = parsedRecords.map((record) => ({
+    ...record,
+    tags: tagMap.get(record.sha) ?? [],
+    githubUrl: buildGitHubCommitUrl(remoteUrl, record.sha),
+  }))
+
   return { entries }
 }
 
@@ -527,6 +696,21 @@ function createBranchActionFailure(title: string, detail: string, fallback: stri
   } as const
 }
 
+function createMergeActionFailure(args: {
+  title: string
+  detail: string
+  fallback: string
+  snapshotChanged: boolean
+}) {
+  return {
+    ok: false,
+    title: args.title,
+    message: summarizeGitFailure(args.detail, args.fallback),
+    detail: args.detail,
+    snapshotChanged: args.snapshotChanged,
+  } as const
+}
+
 function parseStatusPaths(output: string): DirtyPathEntry[] {
   const entries: DirtyPathEntry[] = []
   for (const rawLine of output.split(/\r?\n/u)) {
@@ -637,8 +821,83 @@ async function createPatch(beforePathLabel: string, afterPathLabel: string, befo
   }
 }
 
+function getContentDigest(args: {
+  changeType: ChatDiffFile["changeType"]
+  beforePath: string
+  afterPath: string
+  beforeText: string | null
+  afterText: string | null
+}) {
+  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")
+}
+
+function parseNumstatValue(value: string) {
+  if (value === "-" || value.trim() === "") return 0
+  const parsed = Number.parseInt(value, 10)
+  return Number.isFinite(parsed) ? parsed : 0
+}
+
+function countTextLines(text: string | null) {
+  if (!text) return 0
+  const lines = text.split(/\r?\n/u)
+  if (lines.at(-1) === "") {
+    lines.pop()
+  }
+  return lines.length
+}
+
+async function getTrackedDiffStats(repoRoot: string, baseCommit: string | null) {
+  const statsByPath = new Map<string, { additions: number; deletions: number }>()
+  if (!baseCommit) {
+    return statsByPath
+  }
+
+  const result = await runGit(["diff", "--numstat", "-z", "-M", baseCommit], repoRoot)
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr.trim() || "Failed to read git diff stats")
+  }
+
+  const tokens = result.stdout.split("\u0000")
+  for (let index = 0; index < tokens.length;) {
+    const header = tokens[index++] ?? ""
+    if (!header) continue
+
+    const [additionsValue, deletionsValue, pathValue = ""] = header.split("\t")
+    if (typeof additionsValue !== "string" || typeof deletionsValue !== "string") continue
+
+    if (pathValue) {
+      statsByPath.set(pathValue, {
+        additions: parseNumstatValue(additionsValue),
+        deletions: parseNumstatValue(deletionsValue),
+      })
+      continue
+    }
+
+    index += 1
+    const nextPath = tokens[index++] ?? ""
+    if (!nextPath) continue
+    statsByPath.set(nextPath, {
+      additions: parseNumstatValue(additionsValue),
+      deletions: parseNumstatValue(deletionsValue),
+    })
+  }
+
+  return statsByPath
+}
+
 async function computeCurrentFiles(repoRoot: string, baseCommit: string | null): Promise<ChatDiffFile[]> {
   const currentDirtyPaths = await listDirtyPaths(repoRoot)
+  const trackedStatsByPath = await getTrackedDiffStats(repoRoot, baseCommit)
   const files: ChatDiffFile[] = []
 
   for (const entry of currentDirtyPaths) {
@@ -656,12 +915,22 @@ async function computeCurrentFiles(repoRoot: string, baseCommit: string | null):
       continue
     }
 
-    const patch = await createPatch(beforePath, relativePath, beforeText, afterText)
+    const trackedStats = trackedStatsByPath.get(relativePath)
+    const additions = trackedStats?.additions ?? countTextLines(afterText)
+    const deletions = trackedStats?.deletions ?? 0
     files.push({
       path: relativePath,
       changeType: entry.changeType,
       isUntracked: entry.isUntracked,
-      patch,
+      additions,
+      deletions,
+      patchDigest: getContentDigest({
+        changeType: entry.changeType,
+        beforePath,
+        afterPath: relativePath,
+        beforeText,
+        afterText,
+      }),
       mimeType,
       size,
     })
@@ -743,8 +1012,31 @@ export class DiffStore {
 
   async initialize() {}
 
-  getSnapshot(chatId: string): ChatDiffSnapshot {
-    const state = this.states.get(chatId) ?? createEmptyState()
+  async readPatch(args: {
+    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}`)
+    }
+
+    const beforePath = entry.previousPath ?? relativePath
+    const beforeText = await readBaseFile(repo.repoRoot, repo.baseCommit, beforePath)
+    const afterText = await readWorktreeFile(repo.repoRoot, relativePath)
+    const patch = await createPatch(beforePath, relativePath, beforeText, afterText)
+
+    return { patch }
+  }
+
+  getProjectSnapshot(projectId: string): ChatDiffSnapshot {
+    const state = this.states.get(projectId) ?? createEmptyState()
     return {
       status: state.status,
       branchName: state.branchName,
@@ -764,7 +1056,7 @@ export class DiffStore {
     }
   }
 
-  async refreshSnapshot(chatId: string, projectPath: string) {
+  async refreshSnapshot(projectId: string, projectPath: string) {
     const repo = await resolveRepo(projectPath)
     if (!repo) {
       const nextState = {
@@ -779,8 +1071,8 @@ export class DiffStore {
         files: [],
         branchHistory: { entries: [] },
       } satisfies StoredChatDiffState
-      const changed = !snapshotsEqual(this.states.get(chatId), nextState)
-      this.states.set(chatId, nextState)
+      const changed = !snapshotsEqual(this.states.get(projectId), nextState)
+      this.states.set(projectId, nextState)
       return changed
     }
 
@@ -813,8 +1105,8 @@ export class DiffStore {
       files,
       branchHistory,
     } satisfies StoredChatDiffState
-    const changed = !snapshotsEqual(this.states.get(chatId), nextState)
-    this.states.set(chatId, nextState)
+    const changed = !snapshotsEqual(this.states.get(projectId), nextState)
+    this.states.set(projectId, nextState)
     return changed
   }
 
@@ -962,21 +1254,145 @@ export class DiffStore {
     }
   }
 
-  async checkoutBranch(args: {
-    chatId: string
+  async previewMergeBranch(args: {
     projectPath: string
-    branch:
-    | { kind: "local"; name: string }
-    | { kind: "remote"; name: string; remoteRef: string }
-    | {
-        kind: "pull_request"
-        name: string
-        prNumber: number
-        headRefName: string
-        headRepoCloneUrl?: string
-        isCrossRepository?: boolean
-        remoteRef?: string
+    branch: SelectedBranch
+  }): Promise<ChatMergePreviewResult> {
+    const repo = await resolveRepo(args.projectPath)
+    if (!repo) {
+      throw new Error("Project is not in a git repository")
+    }
+
+    const currentBranchName = await getBranchName(repo.repoRoot)
+    const resolvedBranch = await resolveSelectedBranchRef(repo.repoRoot, args.branch)
+
+    if (currentBranchName && resolvedBranch.branchName === currentBranchName) {
+      return {
+        currentBranchName,
+        targetBranchName: resolvedBranch.branchName,
+        targetDisplayName: resolvedBranch.displayName,
+        status: "up_to_date",
+        commitCount: 0,
+        hasConflicts: false,
+        message: `${currentBranchName} is already up to date with ${resolvedBranch.displayName}.`,
       }
+    }
+
+    try {
+      const commitCount = await getMergeCommitCount(repo.repoRoot, resolvedBranch.ref)
+      if (commitCount === 0) {
+        return {
+          currentBranchName,
+          targetBranchName: resolvedBranch.branchName,
+          targetDisplayName: resolvedBranch.displayName,
+          status: "up_to_date",
+          commitCount,
+          hasConflicts: false,
+          message: `${currentBranchName ?? "Current branch"} is already up to date with ${resolvedBranch.displayName}.`,
+        }
+      }
+
+      const conflictPrediction = await predictMergeConflicts(repo.repoRoot, resolvedBranch.ref)
+      if (conflictPrediction.hasConflicts) {
+        return {
+          currentBranchName,
+          targetBranchName: resolvedBranch.branchName,
+          targetDisplayName: resolvedBranch.displayName,
+          status: "conflicts",
+          commitCount,
+          hasConflicts: true,
+          message: `${commitCount} ${commitCount === 1 ? "commit" : "commits"} from ${resolvedBranch.displayName} would merge into ${currentBranchName ?? "the current branch"}, but conflicts are expected.`,
+          detail: conflictPrediction.detail,
+        }
+      }
+
+      return {
+        currentBranchName,
+        targetBranchName: resolvedBranch.branchName,
+        targetDisplayName: resolvedBranch.displayName,
+        status: "mergeable",
+        commitCount,
+        hasConflicts: false,
+        message: `${commitCount} ${commitCount === 1 ? "commit" : "commits"} from ${resolvedBranch.displayName} will merge into ${currentBranchName ?? "the current branch"}.`,
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      return {
+        currentBranchName,
+        targetBranchName: resolvedBranch.branchName,
+        targetDisplayName: resolvedBranch.displayName,
+        status: "error",
+        commitCount: 0,
+        hasConflicts: false,
+        message: "Could not preview this merge.",
+        detail: message,
+      }
+    }
+  }
+
+  async mergeBranch(args: {
+    projectId: string
+    projectPath: string
+    branch: SelectedBranch
+  }): Promise<ChatMergeBranchResult> {
+    const repo = await resolveRepo(args.projectPath)
+    if (!repo) {
+      throw new Error("Project is not in a git repository")
+    }
+
+    const currentDirtyPaths = await listDirtyPaths(repo.repoRoot)
+    if (currentDirtyPaths.length > 0) {
+      return {
+        ok: false,
+        title: "Merge blocked",
+        message: "Commit, discard, or stash your local changes before merging.",
+        snapshotChanged: false,
+      }
+    }
+
+    const resolvedBranch = await resolveSelectedBranchRef(repo.repoRoot, args.branch)
+    const commitCount = await getMergeCommitCount(repo.repoRoot, resolvedBranch.ref)
+    if (commitCount === 0) {
+      return {
+        ok: false,
+        title: "Already up to date",
+        message: `${resolvedBranch.displayName} is already merged into ${await getBranchName(repo.repoRoot) ?? "the current branch"}.`,
+        snapshotChanged: false,
+      }
+    }
+
+    const mergeResult = await runGit(["merge", "--no-edit", resolvedBranch.ref], repo.repoRoot)
+    const detail = formatGitFailure(mergeResult)
+
+    if (mergeResult.exitCode !== 0) {
+      const snapshotChanged = await this.refreshSnapshot(args.projectId, args.projectPath)
+      const normalized = detail.toLowerCase()
+      const title = normalized.includes("conflict")
+        ? "Merge conflicts need resolution"
+        : "Merge failed"
+      const fallback = normalized.includes("conflict")
+        ? "Git reported merge conflicts while merging this branch."
+        : "Git could not merge this branch."
+      return createMergeActionFailure({
+        title,
+        detail,
+        fallback,
+        snapshotChanged,
+      })
+    }
+
+    const snapshotChanged = await this.refreshSnapshot(args.projectId, args.projectPath)
+    return {
+      ok: true,
+      branchName: await getBranchName(repo.repoRoot),
+      snapshotChanged,
+    }
+  }
+
+  async checkoutBranch(args: {
+    projectId: string
+    projectPath: string
+    branch: SelectedBranch
     bringChanges?: boolean
   }): Promise<ChatCheckoutBranchResult> {
     const repo = await resolveRepo(args.projectPath)
@@ -1049,7 +1465,7 @@ export class DiffStore {
       return createBranchActionFailure("Checkout failed", formatGitFailure(switchResult), "Git could not switch branches.")
     }
 
-    const snapshotChanged = await this.refreshSnapshot(args.chatId, args.projectPath)
+    const snapshotChanged = await this.refreshSnapshot(args.projectId, args.projectPath)
     return {
       ok: true,
       branchName: await getBranchName(repo.repoRoot),
@@ -1058,7 +1474,7 @@ export class DiffStore {
   }
 
   async createBranch(args: {
-    chatId: string
+    projectId: string
     projectPath: string
     name: string
     baseBranchName?: string
@@ -1098,7 +1514,7 @@ export class DiffStore {
       return createBranchActionFailure("Create branch failed", formatGitFailure(switchResult), "Git could not create the branch.")
     }
 
-    const snapshotChanged = await this.refreshSnapshot(args.chatId, args.projectPath)
+    const snapshotChanged = await this.refreshSnapshot(args.projectId, args.projectPath)
     return {
       ok: true,
       branchName,
@@ -1107,9 +1523,9 @@ export class DiffStore {
   }
 
   async syncBranch(args: {
-    chatId: string
+    projectId: string
     projectPath: string
-    action: "fetch" | "pull" | "publish"
+    action: "fetch" | "pull" | "push" | "publish"
   }): Promise<ChatSyncResult> {
     const repo = await resolveRepo(args.projectPath)
     if (!repo) {
@@ -1140,7 +1556,41 @@ export class DiffStore {
         }
       }
 
-      const snapshotChanged = await this.refreshSnapshot(args.chatId, args.projectPath)
+      const snapshotChanged = await this.refreshSnapshot(args.projectId, args.projectPath)
+      const branchName = await getBranchName(repo.repoRoot)
+      const nextHasUpstream = await hasUpstreamBranch(repo.repoRoot)
+      const { aheadCount, behindCount } = nextHasUpstream
+        ? await getUpstreamStatusCounts(repo.repoRoot)
+        : { aheadCount: undefined, behindCount: undefined }
+
+      return {
+        ok: true,
+        action: args.action,
+        branchName,
+        aheadCount,
+        behindCount,
+        snapshotChanged,
+      }
+    }
+
+    if (args.action === "push") {
+      if (!hasUpstream) {
+        return {
+          ok: false,
+          action: args.action,
+          title: "Push failed",
+          message: "This branch does not have an upstream remote branch configured yet.",
+          snapshotChanged: false,
+        }
+      }
+
+      const pushResult = await runGit(["push"], repo.repoRoot)
+      if (pushResult.exitCode !== 0) {
+        const detail = formatGitFailure(pushResult)
+        return createSyncPushFailure(detail, false)
+      }
+
+      const snapshotChanged = await this.refreshSnapshot(args.projectId, args.projectPath)
       const branchName = await getBranchName(repo.repoRoot)
       const nextHasUpstream = await hasUpstreamBranch(repo.repoRoot)
       const { aheadCount, behindCount } = nextHasUpstream
@@ -1195,7 +1645,7 @@ export class DiffStore {
       }
     }
 
-    const snapshotChanged = await this.refreshSnapshot(args.chatId, args.projectPath)
+    const snapshotChanged = await this.refreshSnapshot(args.projectId, args.projectPath)
     const branchName = await getBranchName(repo.repoRoot)
     const nextHasUpstream = await hasUpstreamBranch(repo.repoRoot)
     const { aheadCount, behindCount } = nextHasUpstream
@@ -1226,14 +1676,24 @@ export class DiffStore {
       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) {
+    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}`)
       }
-      return file
-    })
+
+      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({
@@ -1244,7 +1704,7 @@ export class DiffStore {
   }
 
   async commitFiles(args: {
-    chatId: string
+    projectId: string
     projectPath: string
     paths: string[]
     summary: string
@@ -1266,6 +1726,7 @@ export class DiffStore {
     if (!repo) {
       throw new Error("Project is not in a git repository")
     }
+    const hasUpstream = await hasUpstreamBranch(repo.repoRoot)
 
     const currentDirtyPaths = new Set((await listDirtyPaths(repo.repoRoot)).map((entry) => entry.path))
     const missingPaths = normalizedPaths.filter((relativePath) => !currentDirtyPaths.has(relativePath))
@@ -1289,7 +1750,7 @@ export class DiffStore {
       return createCommitFailure(args.mode, formatGitFailure(commitResult))
     }
 
-    const snapshotChanged = await this.refreshSnapshot(args.chatId, args.projectPath)
+    const snapshotChanged = await this.refreshSnapshot(args.projectId, args.projectPath)
     const branchName = await getBranchName(repo.repoRoot)
 
     if (args.mode === "commit_only") {
@@ -1302,12 +1763,14 @@ export class DiffStore {
       } satisfies DiffCommitResult
     }
 
-    const pushResult = await runGit(["push"], repo.repoRoot)
+    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 this.refreshSnapshot(args.chatId, args.projectPath)
+    const postPushSnapshotChanged = await this.refreshSnapshot(args.projectId, args.projectPath)
 
     return {
       ok: true,
@@ -1319,7 +1782,7 @@ export class DiffStore {
   }
 
   async discardFile(args: {
-    chatId: string
+    projectId: string
     projectPath: string
     path: string
   }) {
@@ -1355,12 +1818,12 @@ export class DiffStore {
     }
 
     return {
-      snapshotChanged: await this.refreshSnapshot(args.chatId, args.projectPath),
+      snapshotChanged: await this.refreshSnapshot(args.projectId, args.projectPath),
     }
   }
 
   async ignoreFile(args: {
-    chatId: string
+    projectId: string
     projectPath: string
     path: string
   }) {
@@ -1386,7 +1849,7 @@ export class DiffStore {
     }
 
     return {
-      snapshotChanged: await this.refreshSnapshot(args.chatId, args.projectPath),
+      snapshotChanged: await this.refreshSnapshot(args.projectId, args.projectPath),
     }
   }
 }