kanna-code 0.23.0 → 0.24.0

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

@@ -11,6 +11,7 @@ describe("generateCommitMessageDetailed", () => {
         files: [{
           path: "app.ts",
           changeType: "modified",
+          isUntracked: false,
           patch: "diff --git a/app.ts b/app.ts\n--- a/app.ts\n+++ b/app.ts\n@@\n-old\n+new\n",
         }],
       },
@@ -38,6 +39,7 @@ describe("generateCommitMessageDetailed", () => {
         files: [{
           path: "src/feature.ts",
           changeType: "modified",
+          isUntracked: false,
           patch: "diff --git a/src/feature.ts b/src/feature.ts\n",
         }],
       },

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

@@ -62,11 +62,11 @@ function buildCommitMessagePrompt(args: {
   const combinedPatch = args.files.map((file) => file.patch).join("\n\n")
 
   return [
-    "Generate a concise git commit message for the selected changes.",
+    "Generate a 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",
+    "- body may be an empty string or 3-5 bullet points",
     "- capture the primary user-visible or developer-visible change",
     "",
     `Branch: ${args.branchName ?? "current branch"}`,

package/src/server/ws-router.test.ts

@@ -38,7 +38,7 @@ const DEFAULT_UPDATE_SNAPSHOT: UpdateSnapshot = {
 }
 
 describe("ws-router", () => {
-  test("acks system.ping without broadcasting snapshots", () => {
+  test("acks system.ping without broadcasting snapshots", async () => {
     const router = createWsRouter({
       store: { state: createEmptyState() } as never,
       agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set() } as never,
@@ -58,7 +58,7 @@ describe("ws-router", () => {
     const ws = new FakeWebSocket()
 
     ws.data.subscriptions.set("sub-1", { type: "sidebar" })
-    router.handleMessage(
+    await router.handleMessage(
       ws as never,
       JSON.stringify({
         v: 1,
@@ -77,7 +77,7 @@ describe("ws-router", () => {
     ])
   })
 
-  test("acks terminal.input without rebroadcasting terminal snapshots", () => {
+  test("acks terminal.input without rebroadcasting terminal snapshots", async () => {
     const router = createWsRouter({
       store: { state: createEmptyState() } as never,
       agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set() } as never,
@@ -98,7 +98,7 @@ describe("ws-router", () => {
     const ws = new FakeWebSocket()
 
     ws.data.subscriptions.set("sub-terminal", { type: "terminal", terminalId: "terminal-1" })
-    router.handleMessage(
+    await router.handleMessage(
       ws as never,
       JSON.stringify({
         v: 1,
@@ -121,7 +121,7 @@ describe("ws-router", () => {
     ])
   })
 
-  test("subscribes and unsubscribes chat topics", () => {
+  test("subscribes and unsubscribes chat topics", async () => {
     const router = createWsRouter({
       store: { state: createEmptyState() } as never,
       agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set() } as never,
@@ -140,7 +140,7 @@ describe("ws-router", () => {
     })
     const ws = new FakeWebSocket()
 
-    router.handleMessage(
+    await router.handleMessage(
       ws as never,
       JSON.stringify({
         v: 1,
@@ -160,7 +160,7 @@ describe("ws-router", () => {
       },
     })
 
-    router.handleMessage(
+    await router.handleMessage(
       ws as never,
       JSON.stringify({
         v: 1,
@@ -176,7 +176,7 @@ describe("ws-router", () => {
     })
   })
 
-  test("loads older chat history pages", () => {
+  test("loads older chat history pages", async () => {
     const state = createEmptyState()
     state.projectsById.set("project-1", {
       id: "project-1",
@@ -230,7 +230,7 @@ describe("ws-router", () => {
     })
     const ws = new FakeWebSocket()
 
-    router.handleMessage(
+    await router.handleMessage(
       ws as never,
       JSON.stringify({
         v: 1,
@@ -472,7 +472,7 @@ describe("ws-router", () => {
     })
     const ws = new FakeWebSocket()
 
-    router.handleMessage(
+    await router.handleMessage(
       ws as never,
       JSON.stringify({
         v: 1,
@@ -492,7 +492,7 @@ describe("ws-router", () => {
       },
     })
 
-    router.handleMessage(
+    await router.handleMessage(
       ws as never,
       JSON.stringify({
         v: 1,
@@ -576,7 +576,7 @@ describe("ws-router", () => {
     })
     const ws = new FakeWebSocket()
 
-    router.handleMessage(
+    await router.handleMessage(
       ws as never,
       JSON.stringify({
         v: 1,
@@ -596,7 +596,7 @@ describe("ws-router", () => {
       },
     })
 
-    router.handleMessage(
+    await router.handleMessage(
       ws as never,
       JSON.stringify({
         v: 1,
@@ -625,7 +625,7 @@ describe("ws-router", () => {
       },
     })
 
-    router.handleMessage(
+    await router.handleMessage(
       ws as never,
       JSON.stringify({
         v: 1,
@@ -651,4 +651,188 @@ describe("ws-router", () => {
       },
     })
   })
+
+  test("routes discard diff file commands through the diff store and rebroadcasts chat snapshots", async () => {
+    const state = createEmptyState()
+    state.projectsById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Project",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+    state.projectIdsByPath.set("/tmp/project", "project-1")
+    state.chatsById.set("chat-1", {
+      id: "chat-1",
+      projectId: "project-1",
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      unread: false,
+      provider: null,
+      planMode: false,
+      sessionToken: null,
+      lastTurnOutcome: null,
+    })
+
+    const discardCalls: Array<{ chatId: string; projectPath: string; path: string }> = []
+    const diffStore = {
+      getSnapshot: () => ({ status: "ready" as const, files: [], defaultBranchName: "main", originRepoSlug: "acme/repo", aheadCount: 0, behindCount: 0, lastFetchedAt: undefined }),
+      refreshSnapshot: async () => false,
+      syncBranch: async () => ({ ok: true as const, action: "fetch" as const, snapshotChanged: false }),
+      generateCommitMessage: async () => ({ subject: "", body: "" }),
+      commitFiles: async () => ({ ok: true as const, mode: "commit_only" as const, pushed: false, snapshotChanged: false }),
+      discardFile: async (args: { chatId: string; projectPath: string; path: string }) => {
+        discardCalls.push(args)
+        return { snapshotChanged: true }
+      },
+      ignoreFile: async () => ({ snapshotChanged: false }),
+    }
+
+    const router = createWsRouter({
+      store: {
+        state,
+        getChat: (chatId: string) => state.chatsById.get(chatId) ?? null,
+        getProject: (projectId: string) => state.projectsById.get(projectId) ?? null,
+        getRecentChatHistory: () => ({ entries: [], hasOlder: false, olderCursor: null }),
+      } as never,
+      diffStore: diffStore as never,
+      agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set() } as never,
+      terminals: {
+        getSnapshot: () => null,
+        onEvent: () => () => {},
+      } as never,
+      keybindings: {
+        getSnapshot: () => DEFAULT_KEYBINDINGS_SNAPSHOT,
+        onChange: () => () => {},
+      } as never,
+      refreshDiscovery: async () => [],
+      getDiscoveredProjects: () => [],
+      machineDisplayName: "Local Machine",
+      updateManager: null,
+    })
+    const ws = new FakeWebSocket()
+
+    router.handleOpen(ws as never)
+    router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "subscribe",
+        id: "chat-sub",
+        topic: { type: "chat", chatId: "chat-1" },
+      })
+    )
+
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "discard-1",
+        command: {
+          type: "chat.discardDiffFile",
+          chatId: "chat-1",
+          path: "app.txt",
+        },
+      })
+    )
+
+    expect(discardCalls).toEqual([{
+      chatId: "chat-1",
+      projectPath: "/tmp/project",
+      path: "app.txt",
+    }])
+    expect(ws.sent).toContainEqual({
+      v: PROTOCOL_VERSION,
+      type: "ack",
+      id: "discard-1",
+      result: { snapshotChanged: true },
+    })
+  })
+
+  test("routes ignore diff file commands through the diff store", async () => {
+    const state = createEmptyState()
+    state.projectsById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Project",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+    state.projectIdsByPath.set("/tmp/project", "project-1")
+    state.chatsById.set("chat-1", {
+      id: "chat-1",
+      projectId: "project-1",
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      unread: false,
+      provider: null,
+      planMode: false,
+      sessionToken: null,
+      lastTurnOutcome: null,
+    })
+
+    const ignoreCalls: Array<{ chatId: string; projectPath: string; path: string }> = []
+    const router = createWsRouter({
+      store: {
+        state,
+        getChat: (chatId: string) => state.chatsById.get(chatId) ?? null,
+        getProject: (projectId: string) => state.projectsById.get(projectId) ?? null,
+      } as never,
+      diffStore: {
+        getSnapshot: () => ({ status: "ready" as const, files: [], defaultBranchName: "main", originRepoSlug: "acme/repo", aheadCount: 0, behindCount: 0, lastFetchedAt: undefined }),
+        refreshSnapshot: async () => false,
+        syncBranch: async () => ({ ok: true as const, action: "fetch" as const, snapshotChanged: false }),
+        generateCommitMessage: async () => ({ subject: "", body: "" }),
+        commitFiles: async () => ({ ok: true as const, mode: "commit_only" as const, pushed: false, snapshotChanged: false }),
+        discardFile: async () => ({ snapshotChanged: false }),
+        ignoreFile: async (args: { chatId: string; projectPath: string; path: string }) => {
+          ignoreCalls.push(args)
+          return { snapshotChanged: false }
+        },
+      } as never,
+      agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set() } as never,
+      terminals: {
+        getSnapshot: () => null,
+        onEvent: () => () => {},
+      } as never,
+      keybindings: {
+        getSnapshot: () => DEFAULT_KEYBINDINGS_SNAPSHOT,
+        onChange: () => () => {},
+      } as never,
+      refreshDiscovery: async () => [],
+      getDiscoveredProjects: () => [],
+      machineDisplayName: "Local Machine",
+      updateManager: null,
+    })
+    const ws = new FakeWebSocket()
+
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "ignore-1",
+        command: {
+          type: "chat.ignoreDiffFile",
+          chatId: "chat-1",
+          path: "scratch.log",
+        },
+      })
+    )
+
+    expect(ignoreCalls).toEqual([{
+      chatId: "chat-1",
+      projectPath: "/tmp/project",
+      path: "scratch.log",
+    }])
+    expect(ws.sent).toContainEqual({
+      v: PROTOCOL_VERSION,
+      type: "ack",
+      id: "ignore-1",
+      result: { snapshotChanged: false },
+    })
+  })
 })

package/src/server/ws-router.ts

@@ -22,7 +22,7 @@ export interface ClientState {
 
 interface CreateWsRouterArgs {
   store: EventStore
-  diffStore?: Pick<DiffStore, "getSnapshot" | "refreshSnapshot" | "generateCommitMessage" | "commitFiles">
+  diffStore?: Pick<DiffStore, "getSnapshot" | "refreshSnapshot" | "listBranches" | "syncBranch" | "checkoutBranch" | "createBranch" | "generateCommitMessage" | "commitFiles" | "discardFile" | "ignoreFile">
   agent: AgentCoordinator
   terminals: TerminalManager
   keybindings: KeybindingsManager
@@ -57,10 +57,16 @@ export function createWsRouter({
 }: CreateWsRouterArgs) {
   const sockets = new Set<ServerWebSocket<ClientState>>()
   const resolvedDiffStore = diffStore ?? {
-    getSnapshot: () => ({ status: "unknown", branchName: undefined, hasUpstream: undefined, files: [] as const }),
+    getSnapshot: () => ({ status: "unknown", branchName: undefined, defaultBranchName: undefined, originRepoSlug: undefined, hasUpstream: undefined, aheadCount: undefined, behindCount: undefined, lastFetchedAt: undefined, files: [] as const, branchHistory: { entries: [] as const } }),
     refreshSnapshot: async () => false,
+    listBranches: async () => ({ recent: [], local: [], remote: [], pullRequests: [], pullRequestsStatus: "unavailable" as const }),
+    syncBranch: async () => ({ ok: true, action: "fetch" as const, branchName: undefined, snapshotChanged: false }),
+    checkoutBranch: async () => ({ ok: true, branchName: undefined, snapshotChanged: false }),
+    createBranch: async () => ({ ok: true, branchName: "main", snapshotChanged: false }),
     generateCommitMessage: async () => ({ subject: "Update selected files", body: "", usedFallback: true, failureMessage: null }),
     commitFiles: async () => ({ ok: true, mode: "commit_only" as const, branchName: undefined, pushed: false, snapshotChanged: false }),
+    discardFile: async () => ({ snapshotChanged: false }),
+    ignoreFile: async () => ({ snapshotChanged: false }),
   }
 
   function createEnvelope(id: string, topic: SubscriptionTopic): ServerEnvelope {
@@ -368,6 +374,83 @@ export function createWsRouter({
           }
           return
         }
+        case "chat.listBranches": {
+          const chat = store.getChat(command.chatId)
+          if (!chat) {
+            throw new Error("Chat not found")
+          }
+          const project = store.getProject(chat.projectId)
+          if (!project) {
+            throw new Error("Project not found")
+          }
+          const result = await resolvedDiffStore.listBranches({
+            projectPath: project.localPath,
+          })
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
+          return
+        }
+        case "chat.checkoutBranch": {
+          const chat = store.getChat(command.chatId)
+          if (!chat) {
+            throw new Error("Chat not found")
+          }
+          const project = store.getProject(chat.projectId)
+          if (!project) {
+            throw new Error("Project not found")
+          }
+          const result = await resolvedDiffStore.checkoutBranch({
+            chatId: command.chatId,
+            projectPath: project.localPath,
+            branch: command.branch,
+            bringChanges: command.bringChanges,
+          })
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
+          if (result.snapshotChanged) {
+            broadcastSnapshots()
+          }
+          return
+        }
+        case "chat.syncBranch": {
+          const chat = store.getChat(command.chatId)
+          if (!chat) {
+            throw new Error("Chat not found")
+          }
+          const project = store.getProject(chat.projectId)
+          if (!project) {
+            throw new Error("Project not found")
+          }
+          const result = await resolvedDiffStore.syncBranch({
+            chatId: command.chatId,
+            projectPath: project.localPath,
+            action: command.action,
+          })
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
+          if (result.snapshotChanged) {
+            broadcastSnapshots()
+          }
+          return
+        }
+        case "chat.createBranch": {
+          const chat = store.getChat(command.chatId)
+          if (!chat) {
+            throw new Error("Chat not found")
+          }
+          const project = store.getProject(chat.projectId)
+          if (!project) {
+            throw new Error("Project not found")
+          }
+          const result = await resolvedDiffStore.createBranch({
+            chatId: command.chatId,
+            projectPath: project.localPath,
+            name: command.name,
+            baseBranchName: command.baseBranchName,
+          })
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
+          if (result.snapshotChanged) {
+            broadcastSnapshots()
+          }
+          return
+        }
         case "chat.generateCommitMessage": {
           const chat = store.getChat(command.chatId)
           if (!chat) {
@@ -407,6 +490,46 @@ export function createWsRouter({
           }
           return
         }
+        case "chat.discardDiffFile": {
+          const chat = store.getChat(command.chatId)
+          if (!chat) {
+            throw new Error("Chat not found")
+          }
+          const project = store.getProject(chat.projectId)
+          if (!project) {
+            throw new Error("Project not found")
+          }
+          const result = await resolvedDiffStore.discardFile({
+            chatId: command.chatId,
+            projectPath: project.localPath,
+            path: command.path,
+          })
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
+          if (result.snapshotChanged) {
+            broadcastSnapshots()
+          }
+          return
+        }
+        case "chat.ignoreDiffFile": {
+          const chat = store.getChat(command.chatId)
+          if (!chat) {
+            throw new Error("Chat not found")
+          }
+          const project = store.getProject(chat.projectId)
+          if (!project) {
+            throw new Error("Project not found")
+          }
+          const result = await resolvedDiffStore.ignoreFile({
+            chatId: command.chatId,
+            projectPath: project.localPath,
+            path: command.path,
+          })
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
+          if (result.snapshotChanged) {
+            broadcastSnapshots()
+          }
+          return
+        }
         case "chat.cancel": {
           await agent.cancel(command.chatId)
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })

package/src/shared/protocol.ts

@@ -78,8 +78,30 @@ export type ClientCommand =
       planMode?: boolean
     }
   | { type: "chat.refreshDiffs"; chatId: string }
+  | { type: "chat.listBranches"; chatId: string }
+  | { type: "chat.syncBranch"; chatId: string; action: "fetch" | "pull" | "publish" }
+  | {
+      type: "chat.checkoutBranch"
+      chatId: 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
+        }
+      bringChanges?: boolean
+    }
+  | { type: "chat.createBranch"; chatId: string; name: string; baseBranchName?: string }
   | { type: "chat.generateCommitMessage"; chatId: string; paths: string[] }
   | { type: "chat.commitDiffs"; chatId: string; paths: string[]; summary: string; description?: string; mode: DiffCommitMode }
+  | { type: "chat.discardDiffFile"; chatId: string; path: string }
+  | { type: "chat.ignoreDiffFile"; chatId: string; path: string }
   | { type: "chat.cancel"; chatId: string }
   | { type: "chat.stopDraining"; chatId: string }
   | { type: "chat.loadHistory"; chatId: string; beforeCursor: string; limit: number }

package/src/shared/types.ts

@@ -471,20 +471,123 @@ export interface ContextWindowUsageSnapshot {
 export interface ChatDiffFile {
   path: string
   changeType: "added" | "deleted" | "modified" | "renamed"
+  isUntracked: boolean
   patch: string
   mimeType?: string
   size?: number
 }
 
+export interface ChatBranchHistoryEntry {
+  sha: string
+  summary: string
+  description: string
+  authorName?: string
+  authoredAt: string
+  tags: string[]
+  githubUrl?: string
+}
+
+export interface ChatBranchHistorySnapshot {
+  entries: ChatBranchHistoryEntry[]
+}
+
+export type ChatBranchListEntryKind = "local" | "remote" | "pull_request"
+
+export interface ChatBranchListEntry {
+  id: string
+  kind: ChatBranchListEntryKind
+  name: string
+  displayName: string
+  updatedAt?: string
+  description?: string
+  remoteRef?: string
+  prNumber?: number
+  prTitle?: string
+  headRefName?: string
+  headLabel?: string
+  headRepoCloneUrl?: string
+  isCrossRepository?: boolean
+}
+
+export interface ChatBranchListResult {
+  currentBranchName?: string
+  defaultBranchName?: string
+  recent: ChatBranchListEntry[]
+  local: ChatBranchListEntry[]
+  remote: ChatBranchListEntry[]
+  pullRequests: ChatBranchListEntry[]
+  pullRequestsStatus: "available" | "unavailable" | "error"
+  pullRequestsError?: string
+}
+
 export interface ChatDiffSnapshot {
   status: "unknown" | "ready" | "no_repo"
   branchName?: string
+  defaultBranchName?: string
+  originRepoSlug?: string
   hasUpstream?: boolean
+  aheadCount?: number
+  behindCount?: number
+  lastFetchedAt?: string
   files: ChatDiffFile[]
+  branchHistory?: ChatBranchHistorySnapshot
 }
 
+export interface ChatSyncSuccess {
+  ok: true
+  action: "fetch" | "pull" | "publish"
+  branchName?: string
+  aheadCount?: number
+  behindCount?: number
+  snapshotChanged: boolean
+}
+
+export interface ChatSyncFailure {
+  ok: false
+  action: "fetch" | "pull" | "publish"
+  title: string
+  message: string
+  detail?: string
+  snapshotChanged?: boolean
+}
+
+export type ChatSyncResult = ChatSyncSuccess | ChatSyncFailure
+
 export type DiffCommitMode = "commit_and_push" | "commit_only"
 
+export interface ChatCheckoutBranchSuccess {
+  ok: true
+  branchName?: string
+  snapshotChanged: boolean
+}
+
+export interface ChatCheckoutBranchFailure {
+  ok: false
+  cancelled?: boolean
+  title: string
+  message: string
+  detail?: string
+  snapshotChanged?: boolean
+}
+
+export type ChatCheckoutBranchResult = ChatCheckoutBranchSuccess | ChatCheckoutBranchFailure
+
+export interface ChatCreateBranchSuccess {
+  ok: true
+  branchName: string
+  snapshotChanged: boolean
+}
+
+export interface ChatCreateBranchFailure {
+  ok: false
+  title: string
+  message: string
+  detail?: string
+  snapshotChanged?: boolean
+}
+
+export type ChatCreateBranchResult = ChatCreateBranchSuccess | ChatCreateBranchFailure
+
 export interface DiffCommitSuccess {
   ok: true
   mode: DiffCommitMode