@blogic-cz/agent-tools 0.14.48 → 0.14.50

package/package.json

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

package/src/gh-tool/index.ts

@@ -31,8 +31,10 @@ import {
   prIssueCommentsLatestCommand,
   prCommentCommand,
   prDiscussionSummaryCommand,
+  prFeedbackCommand,
   prReplyCommand,
   prResolveCommand,
+  prReviewsCommand,
   prSubmitReviewCommand,
   prChecksCommand,
   prChecksFailedCommand,
@@ -79,6 +81,8 @@ const prCommand = Command.make("pr", {}).pipe(
     prWaitMergeableCommand,
     prThreadsCommand,
     prCommentsCommand,
+    prReviewsCommand,
+    prFeedbackCommand,
     prIssueCommentsCommand,
     prIssueCommentsLatestCommand,
     prCommentCommand,

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

@@ -44,8 +44,10 @@ import {
 import {
   fetchComments,
   fetchDiscussionSummary,
+  fetchFeedback,
   fetchIssueComments,
   fetchLatestIssueComment,
+  fetchReviews,
   fetchThreads,
   postIssueComment,
   replyToComment,
@@ -101,13 +103,16 @@ export const parsePrNumbers = (input: string): readonly number[] =>
 export const fetchReviewTriage = Effect.fn("pr.fetchReviewTriage")(function* (
   prNumber: number | null,
 ) {
-  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),
-  ]);
+  const [info, unresolvedThreads, visibleOpenThreads, summary, checks, reviews] = yield* Effect.all(
+    [
+      viewPR(prNumber),
+      fetchThreads(prNumber, true),
+      fetchThreads(prNumber, false, true),
+      fetchDiscussionSummary(prNumber),
+      fetchChecks(prNumber, false, false, 0),
+      fetchReviews(prNumber, null, null, null),
+    ],
+  );
   const classification = classifyReviewTriage(summary, checks);
 
   // Single merge-readiness verdict so agents stop re-stitching mergeable + checks + threads +
@@ -127,7 +132,16 @@ export const fetchReviewTriage = Effect.fn("pr.fetchReviewTriage")(function* (
     blocking,
   };
 
-  return { ready, classification, info, unresolvedThreads, visibleOpenThreads, summary, checks };
+  return {
+    ready,
+    classification,
+    info,
+    unresolvedThreads,
+    visibleOpenThreads,
+    summary,
+    checks,
+    reviews,
+  };
 });
 
 export const prViewCommand = Command.make(
@@ -606,6 +620,73 @@ export const prCommentsCommand = Command.make(
     ),
 ).pipe(Command.withDescription("Fetch review comments for a PR (optionally filter by --since)"));
 
+export const prReviewsCommand = Command.make(
+  "reviews",
+  {
+    author: Flag.string("author").pipe(
+      Flag.withDescription("Filter by author login substring"),
+      Flag.optional,
+    ),
+    bodyContains: Flag.string("body-contains").pipe(
+      Flag.withDescription("Filter reviews by body substring"),
+      Flag.optional,
+    ),
+    format: formatOption,
+    pr: Flag.integer("pr").pipe(
+      Flag.withDescription("PR number (default: current branch PR)"),
+      Flag.optional,
+    ),
+    repo: repoOption,
+    state: Flag.string("state").pipe(
+      Flag.withDescription(
+        "Filter by review state (APPROVED, CHANGES_REQUESTED, COMMENTED, DISMISSED)",
+      ),
+      Flag.optional,
+    ),
+  },
+  ({ author, bodyContains, format, pr, repo, state }) =>
+    withRepo(
+      repo,
+      Effect.gen(function* () {
+        const reviews = yield* fetchReviews(
+          Option.getOrNull(pr),
+          Option.getOrNull(author),
+          Option.getOrNull(bodyContains),
+          Option.getOrNull(state),
+        );
+        yield* logFormatted(reviews, format);
+      }),
+    ),
+).pipe(
+  Command.withDescription(
+    "Fetch submitted review summaries (state + body) for a PR — the review bodies that comments/issue-comments do not expose",
+  ),
+);
+
+export const prFeedbackCommand = Command.make(
+  "feedback",
+  {
+    format: formatOption,
+    pr: Flag.integer("pr").pipe(
+      Flag.withDescription("PR number (default: current branch PR)"),
+      Flag.optional,
+    ),
+    repo: repoOption,
+  },
+  ({ format, pr, repo }) =>
+    withRepo(
+      repo,
+      Effect.gen(function* () {
+        const feedback = yield* fetchFeedback(Option.getOrNull(pr));
+        yield* logFormatted(feedback, format);
+      }),
+    ),
+).pipe(
+  Command.withDescription(
+    "Full review-response inventory in one call: submitted reviews + threads (with state) + inline comments + issue comments",
+  ),
+);
+
 export const prIssueCommentsCommand = Command.make(
   "issue-comments",
   {

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

@@ -7,6 +7,7 @@ export {
   prCreateCommand,
   prDiscussionSummaryCommand,
   prEditCommand,
+  prFeedbackCommand,
   prIssueCommentsCommand,
   prIssueCommentsLatestCommand,
   prListCommand,
@@ -15,6 +16,7 @@ export {
   prRerunChecksCommand,
   prReplyAndResolveCommand,
   prResolveCommand,
+  prReviewsCommand,
   prStatusCommand,
   prSubmitReviewCommand,
   prThreadsCommand,

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

@@ -5,6 +5,7 @@ import type {
   IssueComment,
   IssueCommentId,
   IsoTimestamp,
+  PullRequestReview,
   ReviewComment,
   ReviewThread,
 } from "#gh/types";
@@ -158,6 +159,15 @@ type RawIssueComment = {
   html_url: string;
 };
 
+type RawPullRequestReview = {
+  id: number;
+  user: { login: string } | null;
+  state: string;
+  body: string | null;
+  submitted_at: string | null;
+  html_url: string;
+};
+
 type ReviewCommentById = {
   id: number;
   in_reply_to_id: number | null;
@@ -405,6 +415,73 @@ export const fetchIssueComments = Effect.fn("pr.fetchIssueComments")(function* (
   return comments;
 });
 
+/**
+ * Fetch submitted review summaries (state + top-level body) for a PR via REST API.
+ * Complements `comments` (inline review comments) and `issue-comments` (discussion),
+ * which never expose the submitted review body. Optional author/state/body filters.
+ */
+export const fetchReviews = Effect.fn("pr.fetchReviews")(function* (
+  pr: number | null,
+  author: string | null,
+  bodyContains: string | null,
+  state: string | null,
+) {
+  const service = yield* GitHubService;
+  const repoInfo = yield* service.getRepoInfo();
+
+  const resolvedPr = pr ?? (yield* viewPR(null)).number;
+
+  const raw = yield* fetchAllRestPages<RawPullRequestReview>(
+    `repos/${repoInfo.owner}/${repoInfo.name}/pulls/${resolvedPr}/reviews`,
+    "gh-tool pr reviews",
+    "Failed to parse response",
+  );
+
+  let reviews: PullRequestReview[] = raw.map((review) => ({
+    id: review.id,
+    author: review.user?.login ?? "unknown",
+    state: review.state,
+    body: review.body ?? "",
+    submittedAt: (review.submitted_at ?? null) as IsoTimestamp | null,
+    url: review.html_url,
+  }));
+
+  if (author !== null) {
+    const authorFilter = author.toLowerCase();
+    reviews = reviews.filter((review) => review.author.toLowerCase().includes(authorFilter));
+  }
+
+  if (state !== null) {
+    const stateFilter = state.toLowerCase();
+    reviews = reviews.filter((review) => review.state.toLowerCase() === stateFilter);
+  }
+
+  if (bodyContains !== null) {
+    const bodyFilter = bodyContains.toLowerCase();
+    reviews = reviews.filter((review) => review.body.toLowerCase().includes(bodyFilter));
+  }
+
+  return reviews;
+});
+
+/**
+ * Full review-response inventory for a PR in one call: submitted review summaries,
+ * all review threads with resolution state, inline review comments, and issue
+ * (discussion) comments. Collapses the four separate fetches agents otherwise stitch.
+ */
+export const fetchFeedback = Effect.fn("pr.fetchFeedback")(function* (pr: number | null) {
+  const resolvedPr = pr ?? (yield* viewPR(null)).number;
+
+  const [reviews, threads, inlineComments, issueComments] = yield* Effect.all([
+    fetchReviews(resolvedPr, null, null, null),
+    fetchThreads(resolvedPr, false),
+    fetchComments(resolvedPr, null),
+    fetchIssueComments(resolvedPr, null, null, null),
+  ]);
+
+  return { reviews, threads, inlineComments, issueComments };
+});
+
 export const fetchLatestIssueComment = Effect.fn("pr.fetchLatestIssueComment")(function* (
   pr: number | null,
   author: string | null,

package/src/gh-tool/types.ts

@@ -66,6 +66,15 @@ export type IssueComment = {
   url: GitHubIssueCommentUrl;
 };
 
+export type PullRequestReview = {
+  id: number;
+  author: string;
+  state: string;
+  body: string;
+  submittedAt: IsoTimestamp | null;
+  url: string;
+};
+
 export type CheckResult = {
   name: string;
   state: string;

package/src/gh-tool/workflow.ts

@@ -245,10 +245,39 @@ export const dispatchWorkflow = Effect.fn("workflow.dispatchWorkflow")(function*
 // then fall back to a one-shot snapshot so a timeout never returns nothing.
 const DEFAULT_WATCH_RUN_TIMEOUT_SECONDS = CI_CHECK_WATCH_TIMEOUT_MS / 1000;
 
+export const buildWatchResult = (
+  runId: number,
+  finalState: {
+    status: string;
+    conclusion: string | null;
+    jobs: ReadonlyArray<{ name: string; status: string; conclusion: string | null }>;
+  },
+  watchStdout: string | null,
+  frames: boolean,
+  timeoutSeconds: number,
+) => ({
+  runId,
+  status: finalState.status,
+  conclusion: finalState.conclusion,
+  jobs: finalState.jobs.map((job) => ({
+    name: job.name,
+    status: job.status,
+    conclusion: job.conclusion,
+  })),
+  ...(watchStdout === null
+    ? {
+        watchOutput: `(watch timed out after ${timeoutSeconds}s; status taken from snapshot — re-run to keep watching)`,
+      }
+    : frames
+      ? { watchOutput: watchStdout }
+      : {}),
+});
+
 const watchRun = Effect.fn("workflow.watchRun")(function* (
   runId: number,
   repo: string | null,
   timeoutSeconds: number,
+  frames: boolean,
 ) {
   const gh = yield* GitHubService;
 
@@ -277,20 +306,13 @@ const watchRun = Effect.fn("workflow.watchRun")(function* (
 
   const finalState = yield* viewRun(runId, repo);
 
-  return {
+  return buildWatchResult(
     runId,
-    status: finalState.status,
-    conclusion: finalState.conclusion,
-    jobs: finalState.jobs.map((job) => ({
-      name: job.name,
-      status: job.status,
-      conclusion: job.conclusion,
-    })),
-    watchOutput:
-      result === null
-        ? `(watch timed out after ${timeoutSeconds}s; status taken from snapshot — re-run to keep watching)`
-        : result.stdout,
-  };
+    finalState,
+    result === null ? null : result.stdout,
+    frames,
+    timeoutSeconds,
+  );
 });
 
 const fetchAnnotations = Effect.fn("workflow.fetchAnnotations")(function* (opts: {
@@ -712,6 +734,11 @@ export const workflowWatchCommand = Command.make(
   "watch",
   {
     format: formatOption,
+    frames: Flag.boolean("frames").pipe(
+      Flag.withDescription(
+        "Include the raw watch progress frames (large); omitted by default — final status/conclusion/jobs are always returned",
+      ),
+    ),
     repo: repoOption,
     run: Flag.integer("run").pipe(Flag.withDescription("Workflow run ID to watch")),
     timeout: Flag.integer("timeout").pipe(
@@ -725,10 +752,10 @@ export const workflowWatchCommand = Command.make(
       ),
     ),
   },
-  ({ format, repo, run, timeout }) =>
+  ({ format, frames, repo, run, timeout }) =>
     Effect.gen(function* () {
       const resolvedRepo = yield* resolveRepoArg(repo);
-      const result = yield* watchRun(run, resolvedRepo, timeout);
+      const result = yield* watchRun(run, resolvedRepo, timeout, frames);
       yield* logFormatted(result, format);
     }),
 ).pipe(Command.withDescription("Watch a workflow run until it completes, then show final status"));