feat(vs-code): Agent Manager - Code diff hunks to add context to comments in the PR view panel

.changeset/pr-comment-actions.md

@@ -0,0 +1,5 @@
+---
+"kilo-code": minor
+---
+
+Add Agent Manager PR comment actions: resolve/unresolve review threads, jump to comments section, and scroll-to-top for PR diff view.

packages/kilo-vscode/src/agent-manager/PRStatusPoller.ts

@@ -5,8 +5,8 @@ import { execWithShellEnv } from "./shell-env"
 import { execGhRead } from "./gh"
 import { classifyPRError } from "./git-import"
 import type { Semaphore } from "./semaphore"
-import { parsePRResult, checkStatus, formatCheckDuration, parseComments, parseReviewers } from "./am-pr-utils"
-import type { PRResult, GhThread, GhReviewRequest, GhReview } from "./am-pr-types"
+import { parsePRResult, checkStatus, formatCheckDuration, parseComments, parseReviewers } from "./pr/am-pr-utils"
+import type { PRResult, GhThread, GhReviewRequest, GhReview } from "./pr/am-pr-types"
 
 interface PRStatusPollerOptions {
   getWorktrees: () => Worktree[]
@@ -485,7 +485,9 @@ export class PRStatusPoller {
         repository(owner: $owner, name: $repo) {
           pullRequest(number: $number) {
             reviewThreads(first: 100) {
+              totalCount
               nodes {
+                id
                 isResolved
                 comments(first: 1) {
                   nodes {
@@ -496,6 +498,7 @@ export class PRStatusPoller {
                     line
                     url
                     createdAt
+                    diffHunk
                   }
                 }
               }
@@ -520,8 +523,10 @@ export class PRStatusPoller {
         { cwd, timeout: 15_000 },
       )
       const pr = JSON.parse(stdout)?.data?.repository?.pullRequest
-      const comments = parseComments((pr?.reviewThreads?.nodes ?? []) as GhThread[])
-      return { total: comments.length, unresolved: comments.filter((c) => !c.resolved).length, comments }
+      const threads = pr?.reviewThreads
+      const comments = parseComments((threads?.nodes ?? []) as GhThread[])
+      const totalCount = threads?.totalCount ?? comments.length
+      return { total: totalCount, unresolved: comments.filter((c) => !c.resolved).length, comments }
     } catch (err) {
       this.options.log("Failed to fetch PR comments:", err)
       return { total: 0, unresolved: 0, comments: [] }

packages/kilo-vscode/src/agent-manager/pr-status-bridge.ts

@@ -9,6 +9,7 @@ import type { AgentManagerOutMessage, PRStatus } from "./types"
 import type { Disposable } from "./host"
 import type { Semaphore } from "./semaphore"
 import { PRStatusPoller } from "./PRStatusPoller"
+import { resolveComment, unresolveComment } from "./pr/PRActions"
 
 interface PRBridgeHost {
   getWorktrees(): Worktree[]
@@ -85,6 +86,49 @@ export class PRStatusBridge {
       if (url) this.host.openExternal(url)
       return true
     }
+    const isResolve = m.type === "agentManager.resolveComment"
+    const isUnresolve = m.type === "agentManager.unresolveComment"
+    if (isResolve || isUnresolve) {
+      const id = m.worktreeId as string
+      const threadId = m.threadId as string
+      const wt = this.host.getWorktrees().find((w: Worktree) => w.id === id)
+      const cwd = wt?.path ?? this.host.getWorkspaceRoot()
+      const resultType = isResolve ? "agentManager.resolveCommentResult" : "agentManager.unresolveCommentResult"
+      if (!cwd) {
+        this.host.log("resolveComment: no cwd for worktree", id)
+        this.host.postToWebview({
+          type: resultType,
+          worktreeId: id,
+          threadId,
+          success: false,
+        })
+        return true
+      }
+      const action = isResolve ? resolveComment : unresolveComment
+      action(threadId, cwd).then(
+        () => {
+          this.host.postToWebview({
+            type: resultType,
+            worktreeId: id,
+            threadId,
+            success: true,
+          })
+          // Refresh PR data after successful mutation to get updated comment state
+          this.poller.refresh(id)
+        },
+        (err: unknown) => {
+          const msg = err instanceof Error ? err.message : String(err)
+          this.host.log(`${resultType} failed: ${msg}`)
+          this.host.postToWebview({
+            type: resultType,
+            worktreeId: id,
+            threadId,
+            success: false,
+          })
+        },
+      )
+      return true
+    }
     return false
   }
 

packages/kilo-vscode/src/agent-manager/pr/PRActions.ts

@@ -0,0 +1,30 @@
+import { execGhRead } from "../gh"
+import { GH_MUTATION_TIMEOUT } from "./pr-constants"
+
+export async function resolveComment(threadId: string, cwd: string): Promise<void> {
+  const mutation = `mutation($id: ID!) { resolveReviewThread(input: { threadId: $id }) { thread { isResolved } } }`
+  try {
+    await execGhRead(["api", "graphql", "-f", `query=${mutation}`, "-F", `id=${threadId}`], {
+      cwd,
+      timeout: GH_MUTATION_TIMEOUT,
+    })
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    const stderr = (err as Record<string, unknown>).stderr
+    throw new Error(`Could not resolve thread: ${msg}${stderr ? ` — ${stderr}` : ""}`)
+  }
+}
+
+export async function unresolveComment(threadId: string, cwd: string): Promise<void> {
+  const mutation = `mutation($id: ID!) { unresolveReviewThread(input: { threadId: $id }) { thread { isResolved } } }`
+  try {
+    await execGhRead(["api", "graphql", "-f", `query=${mutation}`, "-F", `id=${threadId}`], {
+      cwd,
+      timeout: GH_MUTATION_TIMEOUT,
+    })
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    const stderr = (err as Record<string, unknown>).stderr
+    throw new Error(`Could not unresolve thread: ${msg}${stderr ? ` — ${stderr}` : ""}`)
+  }
+}

packages/kilo-vscode/src/agent-manager/am-pr-types.ts → packages/kilo-vscode/src/agent-manager/pr/am-pr-types.ts

@@ -1,4 +1,4 @@
-import type { PRState, ReviewDecision } from "./types"
+import type { PRState, ReviewDecision } from "../types"
 
 // Raw shapes returned by `gh pr view --json`
 
@@ -14,8 +14,10 @@ export interface GhComment {
   line?: number
   url?: string
   createdAt?: string
+  diffHunk?: string
 }
 export interface GhThread {
+  id?: string
   isResolved?: boolean
   comments?: { nodes?: GhComment[] }
 }

packages/kilo-vscode/src/agent-manager/am-pr-utils.ts → packages/kilo-vscode/src/agent-manager/pr/am-pr-utils.ts

@@ -1,4 +1,4 @@
-import type { CheckStatus, PRComment, PRReviewer, ReviewerState } from "./types"
+import type { CheckStatus, PRComment, PRReviewer, ReviewerState } from "../types"
 import type { PRResult, GhThread, GhReviewRequest, GhReview } from "./am-pr-types"
 
 export function parsePRResult(json: string): PRResult | null {
@@ -73,6 +73,7 @@ export function parseComments(threads: GhThread[]): PRComment[] {
     if (!first) continue
     items.push({
       id: first.id,
+      threadId: thread.id ?? first.id,
       author: first.author?.login ?? "unknown",
       avatar: first.author?.avatarUrl,
       body: first.body ?? "",
@@ -81,6 +82,7 @@ export function parseComments(threads: GhThread[]): PRComment[] {
       url: first.url,
       resolved: thread.isResolved ?? false,
       createdAt: first.createdAt ? new Date(first.createdAt).getTime() : undefined,
+      diffHunk: first.diffHunk,
     })
   }
   return items

packages/kilo-vscode/src/agent-manager/pr/pr-constants.ts

@@ -0,0 +1,2 @@
+// Timeouts for gh CLI and GraphQL calls in PR actions
+export const GH_MUTATION_TIMEOUT = 15_000 // 15 seconds — gh api graphql mutations

packages/kilo-vscode/src/agent-manager/types.ts

@@ -61,6 +61,7 @@ export interface PRCheck {
 
 export interface PRComment {
   id: string
+  threadId: string
   author: string
   avatar?: string
   body: string
@@ -69,6 +70,7 @@ export interface PRComment {
   url?: string
   resolved: boolean
   createdAt?: number
+  diffHunk?: string
 }
 
 export type ReviewerState = "approved" | "changes_requested" | "pending" | "commented"
@@ -394,6 +396,14 @@ interface PRErrorOutMessage {
   error: "gh_missing" | "gh_auth" | "fetch_failed"
 }
 
+interface CommentActionResultMessage {
+  type: "agentManager.resolveCommentResult" | "agentManager.unresolveCommentResult"
+  worktreeId: string
+  threadId: string
+  success: boolean
+  error?: string
+}
+
 interface ActionOutMessage {
   type: "action"
   action: string
@@ -434,6 +444,7 @@ export type AgentManagerOutMessage =
   | DiffBranchesMessage
   | PRStatusOutMessage
   | PRErrorOutMessage
+  | CommentActionResultMessage
   | ActionOutMessage
   | RunStatusMessage
   | TerminalCreatedMessage
@@ -758,6 +769,12 @@ interface OpenPRIn {
   url?: string
 }
 
+interface CommentActionIn {
+  type: "agentManager.resolveComment" | "agentManager.unresolveComment"
+  worktreeId: string
+  threadId: string
+}
+
 interface OpenSessionsIn {
   type: "agentManager.openSessions"
   sessionIDs: string[]
@@ -1050,6 +1067,7 @@ export type AgentManagerInMessage =
   | SetDiffBaseBranchIn
   | RefreshPRIn
   | OpenPRIn
+  | CommentActionIn
   | OpenSessionsIn
   | VisibleSessionIn
   | OpenFileIn

packages/kilo-vscode/tests/unit/am-pr-status-bridge.test.ts

@@ -1,4 +1,10 @@
-import { describe, expect, it } from "bun:test"
+import { describe, expect, it, mock, beforeEach } from "bun:test"
+
+const resolveComment = mock(async (_threadId: string, _cwd: string) => {})
+const unresolveComment = mock(async (_threadId: string, _cwd: string) => {})
+
+mock.module("../../src/agent-manager/pr/PRActions", () => ({ resolveComment, unresolveComment }))
+
 import { PRStatusBridge } from "../../src/agent-manager/pr-status-bridge"
 import type { AgentManagerOutMessage, PRStatus } from "../../src/agent-manager/types"
 
@@ -9,14 +15,15 @@ const pr: PRStatus = {
   state: "open",
   review: null,
   checks: { status: "none", total: 0, passed: 0, failed: 0, pending: 0, checks: [] },
+  reviewers: [],
   additions: 0,
   deletions: 0,
   files: 0,
 }
 
 function harness(opts: { hasPersisted?: boolean } = {}) {
   const sent: AgentManagerOutMessage[] = []
-  const worktrees: { id: string; prUrl?: string }[] = []
+  const worktrees: { id: string; path: string; prUrl?: string }[] = [{ id: "wt1", path: "/repo/wt1" }]
   const bridge = PRStatusBridge.create({
     getWorktrees: () => worktrees as never,
     getWorkspaceRoot: () => "/repo",
@@ -186,3 +193,78 @@ describe("PRStatusBridge.reset", () => {
     expect(sent).toHaveLength(1)
   })
 })
+
+// --- resolveComment / unresolveComment message handling ---
+
+describe("PRStatusBridge.handleMessage resolveComment", () => {
+  beforeEach(() => {
+    resolveComment.mockReset()
+    unresolveComment.mockReset()
+  })
+
+  it("returns true for agentManager.resolveComment", () => {
+    const { bridge } = harness()
+    resolveComment.mockResolvedValueOnce(undefined)
+    expect(bridge.handleMessage({ type: "agentManager.resolveComment", worktreeId: "wt1", threadId: "PRT_1" })).toBe(
+      true,
+    )
+  })
+
+  it("returns true for agentManager.unresolveComment", () => {
+    const { bridge } = harness()
+    unresolveComment.mockResolvedValueOnce(undefined)
+    expect(bridge.handleMessage({ type: "agentManager.unresolveComment", worktreeId: "wt1", threadId: "PRT_1" })).toBe(
+      true,
+    )
+  })
+
+  it("posts resolveCommentResult with success:true on resolve success", async () => {
+    const { bridge, sent } = harness()
+    resolveComment.mockResolvedValueOnce(undefined)
+    bridge.handleMessage({ type: "agentManager.resolveComment", worktreeId: "wt1", threadId: "PRT_1" })
+    await Promise.resolve()
+    const result = sent.find((m) => m.type === "agentManager.resolveCommentResult")
+    expect(result).toEqual(
+      expect.objectContaining({
+        type: "agentManager.resolveCommentResult",
+        worktreeId: "wt1",
+        threadId: "PRT_1",
+        success: true,
+      }),
+    )
+  })
+
+  it("posts unresolveCommentResult with success:true on unresolve success", async () => {
+    const { bridge, sent } = harness()
+    unresolveComment.mockResolvedValueOnce(undefined)
+    bridge.handleMessage({ type: "agentManager.unresolveComment", worktreeId: "wt1", threadId: "PRT_1" })
+    await Promise.resolve()
+    const result = sent.find((m) => m.type === "agentManager.unresolveCommentResult")
+    expect(result).toEqual(expect.objectContaining({ success: true }))
+  })
+
+  it("posts resolveCommentResult with success:false on failure", async () => {
+    const { bridge, sent } = harness()
+    resolveComment.mockRejectedValueOnce(new Error("gh: Not Found"))
+    bridge.handleMessage({ type: "agentManager.resolveComment", worktreeId: "wt1", threadId: "PRT_1" })
+    await Promise.resolve()
+    const result = sent.find((m) => m.type === "agentManager.resolveCommentResult")
+    expect(result).toEqual(expect.objectContaining({ success: false }))
+  })
+
+  it("logs and returns early when no cwd found", () => {
+    const logged: unknown[] = []
+    const bridge = PRStatusBridge.create({
+      getWorktrees: () => [] as never,
+      getWorkspaceRoot: () => undefined,
+      postToWebview: () => {},
+      updateWorktreePR: () => {},
+      hasPersistedPR: () => false,
+      openExternal: () => {},
+      log: (...args) => logged.push(args),
+    })
+    bridge.handleMessage({ type: "agentManager.resolveComment", worktreeId: "wt-missing", threadId: "PRT_1" })
+    expect(resolveComment).not.toHaveBeenCalled()
+    expect(logged.length).toBeGreaterThan(0)
+  })
+})