@blogic-cz/agent-tools 0.8.4 → 0.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blogic-cz/agent-tools",
-  "version": "0.8.4",
+  "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

@@ -236,6 +236,66 @@ const fetchAllThreadNodes = Effect.fn("pr.fetchAllThreadNodes")(function* (pr: n
   }
 });
 
+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,
+        path: comment.path,
+        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
 // ---------------------------------------------------------------------------
@@ -255,29 +315,16 @@ const mapRawIssueComment = (comment: RawIssueComment): IssueComment => ({
 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* fetchAllThreadNodes(resolvedPr);
-
-  const mapped: ReviewThread[] = threads
-    .map((node) => {
-      const comment = node.comments.nodes[0];
-      if (!comment) {
-        return null;
-      }
+  const threads = yield* fetchThreadState(resolvedPr);
 
-      return {
-        threadId: node.id,
-        commentId: comment.databaseId,
-        path: comment.path,
-        line: comment.line,
-        body: comment.body,
-        isResolved: node.isResolved,
-      };
-    })
-    .filter((thread): thread is ReviewThread => thread !== null);
+  if (visibleOpenOnly) {
+    return threads.filter((thread) => thread.isVisibleOpen);
+  }
 
-  return unresolvedOnly ? mapped.filter((t) => !t.isResolved) : mapped;
+  return unresolvedOnly ? threads.filter((thread) => !thread.isResolved) : threads;
 });
 
 /**
@@ -453,6 +500,7 @@ export const fetchDiscussionSummary = Effect.fn("pr.fetchDiscussionSummary")(fun
     latestIssueComment,
     reviewCommentsCount: reviewComments.length,
     reviewThreadsCount: threads.length,
+    visibleOpenReviewThreadsCount: threads.filter((thread) => thread.isVisibleOpen).length,
     repliedReviewThreadsCount: threads.length - unrepliedReviewThreadsCount,
     unrepliedReviewThreadsCount,
     resolvedUnrepliedReviewThreadsCount: threads.filter(

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 = {