@blogic-cz/agent-tools 0.8.3 → 0.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blogic-cz/agent-tools",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "CLI tools for AI coding agent workflows — GitHub, database, Kubernetes, Azure DevOps, logs, sessions, and audit",
   "keywords": [
     "agent",

package/src/gh-tool/pr/commands.ts

@@ -228,14 +228,24 @@ export const prThreadsCommand = Command.make(
       Flag.withDescription("Only show unresolved threads"),
       Flag.withDefault(true),
     ),
+    visibleOpenOnly: Flag.boolean("visible-open-only").pipe(
+      Flag.withDescription(
+        "Show threads that still look open to humans: unresolved threads plus resolved threads with no reply",
+      ),
+      Flag.withDefault(false),
+    ),
   },
-  ({ format, pr, unresolvedOnly }) =>
+  ({ format, pr, unresolvedOnly, visibleOpenOnly }) =>
     Effect.gen(function* () {
       const prNumber = Option.getOrNull(pr);
-      const threads = yield* fetchThreads(prNumber, unresolvedOnly);
+      const threads = yield* fetchThreads(prNumber, unresolvedOnly, visibleOpenOnly);
       yield* logFormatted(threads, format);
     }),
-).pipe(Command.withDescription("Fetch review threads for a PR (unresolved by default)"));
+).pipe(
+  Command.withDescription(
+    "Fetch review threads for a PR (unresolved by default, or use --visible-open-only for reply-aware human-visible open items)",
+  ),
+);
 
 export const prCommentsCommand = Command.make(
   "comments",
@@ -443,17 +453,18 @@ export const prReviewTriageCommand = Command.make(
   ({ format, pr }) =>
     Effect.gen(function* () {
       const prNumber = Option.getOrNull(pr);
-      const [info, threads, summary, checks] = yield* Effect.all([
+      const [info, unresolvedThreads, visibleOpenThreads, summary, checks] = yield* Effect.all([
         viewPR(prNumber),
         fetchThreads(prNumber, true),
+        fetchThreads(prNumber, false, true),
         fetchDiscussionSummary(prNumber),
         fetchChecks(prNumber, false, false, 0),
       ]);
-      yield* logFormatted({ info, unresolvedThreads: threads, summary, checks }, format);
+      yield* logFormatted({ info, unresolvedThreads, visibleOpenThreads, summary, checks }, format);
     }),
 ).pipe(
   Command.withDescription(
-    "Composite: PR info + unresolved threads + discussion summary + checks status in one call",
+    "Composite: PR info + unresolved threads + visible-open threads + discussion summary + checks status in one call",
   ),
 );
 

package/src/gh-tool/pr/review.ts

@@ -19,10 +19,10 @@ import { viewPR } from "./core";
 // ---------------------------------------------------------------------------
 
 const REVIEW_THREADS_QUERY = `
-  query($owner: String!, $name: String!, $pr: Int!) {
+  query($owner: String!, $name: String!, $pr: Int!, $after: String) {
     repository(owner: $owner, name: $name) {
       pullRequest(number: $pr) {
-        reviewThreads(first: 100) {
+        reviewThreads(first: 100, after: $after) {
           nodes {
             id
             isResolved
@@ -37,6 +37,10 @@ const REVIEW_THREADS_QUERY = `
               }
             }
           }
+          pageInfo {
+            hasNextPage
+            endCursor
+          }
         }
       }
     }
@@ -100,6 +104,10 @@ type ThreadsQueryResult = {
     pullRequest: {
       reviewThreads: {
         nodes: ThreadNode[];
+        pageInfo: {
+          hasNextPage: boolean;
+          endCursor: string | null;
+        };
       };
     };
   };
@@ -156,46 +164,111 @@ type ReviewCommentById = {
   pull_request_url: string;
 };
 
-// ---------------------------------------------------------------------------
-// Handlers
-// ---------------------------------------------------------------------------
+const REST_PAGE_SIZE = 100;
 
-const mapRawIssueComment = (comment: RawIssueComment): IssueComment => ({
-  id: comment.id as IssueCommentId,
-  author: comment.user.login,
-  body: comment.body,
-  createdAt: comment.created_at as IsoTimestamp,
-  url: comment.html_url as GitHubIssueCommentUrl,
-});
+const parseJson = <T>(
+  stdout: string,
+  command: string,
+  parseFailurePrefix: string,
+): Effect.Effect<T, GitHubCommandError> =>
+  Effect.try({
+    try: () => JSON.parse(stdout) as T,
+    catch: (error) =>
+      new GitHubCommandError({
+        command,
+        exitCode: 0,
+        stderr: `${parseFailurePrefix}: ${error instanceof Error ? error.message : String(error)}`,
+        message: `${parseFailurePrefix}: ${error instanceof Error ? error.message : String(error)}`,
+      }),
+  });
 
-/**
- * Fetch review threads for a PR via GraphQL.
- * Filters to unresolved threads when unresolvedOnly is true.
- */
-export const fetchThreads = Effect.fn("pr.fetchThreads")(function* (
-  pr: number | null,
-  unresolvedOnly: boolean,
+const fetchAllRestPages = Effect.fn("pr.fetchAllRestPages")(function* <T>(
+  endpoint: string,
+  command: string,
+  parseFailurePrefix: string,
 ) {
   const service = yield* GitHubService;
+
+  const results: T[] = [];
+  let page = 1;
+
+  while (true) {
+    const separator = endpoint.includes("?") ? "&" : "?";
+    const result = yield* service.runGh([
+      "api",
+      `${endpoint}${separator}per_page=${REST_PAGE_SIZE}&page=${page}`,
+    ]);
+
+    const rawPage = yield* parseJson<T[]>(result.stdout, command, parseFailurePrefix);
+    results.push(...rawPage);
+
+    if (rawPage.length < REST_PAGE_SIZE) {
+      return results;
+    }
+
+    page += 1;
+  }
+});
+
+const fetchAllThreadNodes = Effect.fn("pr.fetchAllThreadNodes")(function* (pr: number) {
+  const service = yield* GitHubService;
   const repoInfo = yield* service.getRepoInfo();
 
-  const resolvedPr = pr ?? (yield* viewPR(null)).number;
+  const nodes: ThreadNode[] = [];
+  let after: string | null = null;
 
-  const response = (yield* service.runGraphQL(REVIEW_THREADS_QUERY, {
-    owner: repoInfo.owner,
-    name: repoInfo.name,
-    pr: resolvedPr,
-  })) as ThreadsQueryResult;
+  while (true) {
+    const response = (yield* service.runGraphQL(REVIEW_THREADS_QUERY, {
+      owner: repoInfo.owner,
+      name: repoInfo.name,
+      pr,
+      after,
+    })) as ThreadsQueryResult;
 
-  const threads = response.repository.pullRequest.reviewThreads.nodes;
+    const page = response.repository.pullRequest.reviewThreads;
+    nodes.push(...page.nodes);
 
-  const mapped: ReviewThread[] = threads
+    if (!page.pageInfo.hasNextPage || page.pageInfo.endCursor === null) {
+      return nodes;
+    }
+
+    after = page.pageInfo.endCursor;
+  }
+});
+
+const enrichThreads = (threads: ThreadNode[], reviewComments: ReviewComment[]): ReviewThread[] => {
+  const repliesByRootCommentId = new Map<number, ReviewComment[]>();
+
+  for (const comment of reviewComments) {
+    if (comment.inReplyToId === null) {
+      continue;
+    }
+
+    const replies = repliesByRootCommentId.get(comment.inReplyToId) ?? [];
+    replies.push(comment);
+    repliesByRootCommentId.set(comment.inReplyToId, replies);
+  }
+
+  return threads
     .map((node) => {
       const comment = node.comments.nodes[0];
       if (!comment) {
         return null;
       }
 
+      const replies = repliesByRootCommentId.get(comment.databaseId) ?? [];
+      const lastReply = replies.reduce<ReviewComment | null>((latest, current) => {
+        if (latest === null) {
+          return current;
+        }
+
+        return new Date(current.createdAt).getTime() > new Date(latest.createdAt).getTime()
+          ? current
+          : latest;
+      }, null);
+      const hasReply = replies.length > 0;
+      const needsHumanReply = !hasReply;
+
       return {
         threadId: node.id,
         commentId: comment.databaseId,
@@ -203,11 +276,55 @@ export const fetchThreads = Effect.fn("pr.fetchThreads")(function* (
         line: comment.line,
         body: comment.body,
         isResolved: node.isResolved,
+        hasReply,
+        replyCount: replies.length,
+        needsHumanReply,
+        isVisibleOpen: !node.isResolved || needsHumanReply,
+        lastReplyAuthor: lastReply?.author ?? null,
+        lastReplyAt: lastReply?.createdAt ?? null,
       };
     })
     .filter((thread): thread is ReviewThread => thread !== null);
+};
+
+const fetchThreadState = Effect.fn("pr.fetchThreadState")(function* (pr: number) {
+  const [threads, reviewComments] = yield* Effect.all([
+    fetchAllThreadNodes(pr),
+    fetchComments(pr, null),
+  ]);
+
+  return enrichThreads(threads, reviewComments);
+});
+
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+
+const mapRawIssueComment = (comment: RawIssueComment): IssueComment => ({
+  id: comment.id as IssueCommentId,
+  author: comment.user.login,
+  body: comment.body,
+  createdAt: comment.created_at as IsoTimestamp,
+  url: comment.html_url as GitHubIssueCommentUrl,
+});
+
+/**
+ * Fetch review threads for a PR via GraphQL.
+ * Filters to unresolved threads when unresolvedOnly is true.
+ */
+export const fetchThreads = Effect.fn("pr.fetchThreads")(function* (
+  pr: number | null,
+  unresolvedOnly: boolean,
+  visibleOpenOnly = false,
+) {
+  const resolvedPr = pr ?? (yield* viewPR(null)).number;
+  const threads = yield* fetchThreadState(resolvedPr);
+
+  if (visibleOpenOnly) {
+    return threads.filter((thread) => thread.isVisibleOpen);
+  }
 
-  return unresolvedOnly ? mapped.filter((t) => !t.isResolved) : mapped;
+  return unresolvedOnly ? threads.filter((thread) => !thread.isResolved) : threads;
 });
 
 /**
@@ -223,21 +340,11 @@ export const fetchComments = Effect.fn("pr.fetchComments")(function* (
 
   const resolvedPr = pr ?? (yield* viewPR(null)).number;
 
-  const result = yield* service.runGh([
-    "api",
+  const raw = yield* fetchAllRestPages<RawReviewComment>(
     `repos/${repoInfo.owner}/${repoInfo.name}/pulls/${resolvedPr}/comments`,
-  ]);
-
-  const raw = yield* Effect.try({
-    try: () => JSON.parse(result.stdout) as RawReviewComment[],
-    catch: (error) =>
-      new GitHubCommandError({
-        command: "gh-tool pr comments",
-        exitCode: 0,
-        stderr: `Failed to parse response: ${error instanceof Error ? error.message : String(error)}`,
-        message: `Failed to parse response: ${error instanceof Error ? error.message : String(error)}`,
-      }),
-  });
+    "gh-tool pr comments",
+    "Failed to parse response",
+  );
 
   const comments: ReviewComment[] = raw.map((c) => ({
     id: c.id,
@@ -272,21 +379,11 @@ export const fetchIssueComments = Effect.fn("pr.fetchIssueComments")(function* (
 
   const resolvedPr = pr ?? (yield* viewPR(null)).number;
 
-  const result = yield* service.runGh([
-    "api",
+  const raw = yield* fetchAllRestPages<RawIssueComment>(
     `repos/${repoInfo.owner}/${repoInfo.name}/issues/${resolvedPr}/comments`,
-  ]);
-
-  const raw = yield* Effect.try({
-    try: () => JSON.parse(result.stdout) as RawIssueComment[],
-    catch: (error) =>
-      new GitHubCommandError({
-        command: "gh-tool pr issue-comments",
-        exitCode: 0,
-        stderr: `Failed to parse response: ${error instanceof Error ? error.message : String(error)}`,
-        message: `Failed to parse response: ${error instanceof Error ? error.message : String(error)}`,
-      }),
-  });
+    "gh-tool pr issue-comments",
+    "Failed to parse response",
+  );
 
   let comments = raw.map(mapRawIssueComment);
 
@@ -388,12 +485,31 @@ export const fetchDiscussionSummary = Effect.fn("pr.fetchDiscussionSummary")(fun
             : current,
         );
 
+  const repliedThreadCommentIds = new Set(
+    reviewComments
+      .filter((comment) => comment.inReplyToId !== null)
+      .map((comment) => comment.inReplyToId),
+  );
+
+  const unrepliedReviewThreadsCount = threads.filter(
+    (thread) => !repliedThreadCommentIds.has(thread.commentId),
+  ).length;
+
   return {
     issueCommentsCount: issueComments.length,
     latestIssueComment,
     reviewCommentsCount: reviewComments.length,
     reviewThreadsCount: threads.length,
+    visibleOpenReviewThreadsCount: threads.filter((thread) => thread.isVisibleOpen).length,
+    repliedReviewThreadsCount: threads.length - unrepliedReviewThreadsCount,
+    unrepliedReviewThreadsCount,
+    resolvedUnrepliedReviewThreadsCount: threads.filter(
+      (thread) => thread.isResolved && !repliedThreadCommentIds.has(thread.commentId),
+    ).length,
     unresolvedReviewThreadsCount: threads.filter((thread) => !thread.isResolved).length,
+    unresolvedUnrepliedReviewThreadsCount: threads.filter(
+      (thread) => !thread.isResolved && !repliedThreadCommentIds.has(thread.commentId),
+    ).length,
   };
 });
 

package/src/gh-tool/service.ts

@@ -22,7 +22,7 @@ export class GitHubService extends ServiceMap.Service<
     readonly runGhJson: <T>(args: string[]) => Effect.Effect<T, GhError>;
     readonly runGraphQL: (
       query: string,
-      variables: Record<string, string | number>,
+      variables: Record<string, string | number | null>,
     ) => Effect.Effect<unknown, GhError>;
     readonly getRepoInfo: () => Effect.Effect<RepoInfo, GhError>;
   }
@@ -135,11 +135,15 @@ export class GitHubService extends ServiceMap.Service<
 
         const runGraphQL = Effect.fn("GitHubService.runGraphQL")(function* (
           query: string,
-          variables: Record<string, string | number>,
+          variables: Record<string, string | number | null>,
         ) {
           const args = ["api", "graphql", "-f", `query=${query}`];
 
           for (const [key, value] of Object.entries(variables)) {
+            if (value === null) {
+              continue;
+            }
+
             if (typeof value === "number") {
               args.push("-F", `${key}=${value}`);
             } else {

package/src/gh-tool/types.ts

@@ -20,6 +20,12 @@ export type ReviewThread = {
   line: number;
   body: string;
   isResolved: boolean;
+  hasReply: boolean;
+  replyCount: number;
+  needsHumanReply: boolean;
+  isVisibleOpen: boolean;
+  lastReplyAuthor: string | null;
+  lastReplyAt: string | null;
 };
 
 export type ReviewComment = {