@blogic-cz/agent-tools 0.14.33 → 0.14.35

package/package.json

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

@@ -13,6 +13,7 @@ import {
   issueEditCommand,
   issueListCommand,
   issueReopenCommand,
+  issueSnapshotBatchCommand,
   issueTriageCommand,
   issueViewCommand,
 } from "./issue";
@@ -36,6 +37,7 @@ import {
   prChecksFailedCommand,
   prRerunChecksCommand,
   prReplyAndResolveCommand,
+  prReviewTriageBatchCommand,
   prReviewTriageCommand,
 } from "./pr/index";
 import { branchRenameCommand } from "./branch";
@@ -84,18 +86,20 @@ const prCommand = Command.make("pr", {}).pipe(
     prRerunChecksCommand,
     prReplyAndResolveCommand,
     prReviewTriageCommand,
+    prReviewTriageBatchCommand,
   ]),
 );
 
 const issueCommand = Command.make("issue", {}).pipe(
   Command.withDescription(
-    "Issue operations (list, view, comments, triage, close, reopen, comment, edit)",
+    "Issue operations (list, view, comments, triage, snapshot-batch, close, reopen, comment, edit)",
   ),
   Command.withSubcommands([
     issueListCommand,
     issueViewCommand,
     issueCommentsCommand,
     issueTriageCommand,
+    issueSnapshotBatchCommand,
     issueCloseCommand,
     issueReopenCommand,
     issueCommentCommand,

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

@@ -7,4 +7,4 @@ export {
   issueReopenCommand,
   issueViewCommand,
 } from "./commands";
-export { issueTriageCommand } from "./triage";
+export { issueSnapshotBatchCommand, issueTriageCommand } from "./triage";

package/src/gh-tool/issue/triage.ts

@@ -1,10 +1,11 @@
 import { Command, Flag } from "effect/unstable/cli";
 import { Effect, Option, Schema } from "effect";
 
-import type { IssueComment } from "#gh/types";
+import type { CheckResult, IssueComment, PRViewInfo, ReviewThread } from "#gh/types";
 
 import { formatOption, logFormatted } from "#shared";
 import { GitHubService } from "#gh/service";
+import { fetchReviewTriage } from "#gh/pr/commands";
 
 import { fetchIssueComments } from "./core";
 
@@ -61,6 +62,39 @@ type FullIssueTriage = {
   comments: IssueComment[];
 };
 
+type ReviewTriageSnapshot = {
+  readonly classification: {
+    readonly status: "clear" | "needs_investigation";
+    readonly reasons: readonly string[];
+  };
+  readonly info: PRViewInfo;
+  readonly unresolvedThreads: readonly ReviewThread[];
+  readonly visibleOpenThreads: readonly ReviewThread[];
+  readonly summary: {
+    readonly visibleOpenReviewThreadsCount: number;
+    readonly unrepliedReviewThreadsCount: number;
+    readonly unresolvedReviewThreadsCount: number;
+    readonly latestIssueComment: IssueComment | null;
+  };
+  readonly checks: readonly CheckResult[];
+};
+
+type IssueSnapshotClassification = {
+  readonly status: "clear" | "needs_investigation";
+  readonly reasons: readonly string[];
+};
+
+type IssueSnapshot = {
+  readonly issue: TriageIssue;
+  readonly body: string;
+  readonly commentsCount: number;
+  readonly comments: readonly IssueComment[];
+  readonly eligible: boolean;
+  readonly linkedPullRequestNumbers: readonly number[];
+  readonly linkedPullRequests: readonly ReviewTriageSnapshot[];
+  readonly classification: IssueSnapshotClassification;
+};
+
 function truncateBody(body: string, maxLength = 500): string {
   if (body.length <= maxLength) return body;
   return body.slice(0, maxLength) + "…";
@@ -129,6 +163,97 @@ export const fetchIssueTriage = Effect.fn("issue.fetchIssueTriage")(function* (o
   return result;
 });
 
+export const parseIssueNumbers = (input: string): readonly number[] =>
+  input
+    .split(",")
+    .map((part) => Number.parseInt(part.trim(), 10))
+    .filter((number) => Number.isInteger(number) && number > 0);
+
+export const collectLinkedPullRequestNumbers = (
+  body: string,
+  comments: readonly { readonly body: string }[],
+): readonly number[] => {
+  const text = [body, ...comments.map((comment) => comment.body)].join("\n");
+  const numbers = new Set<number>();
+  for (const match of text.matchAll(/(?:pull\/|\/pulls\/)(\d+)|\bPR\s+#?(\d+)/gi)) {
+    const number = Number.parseInt(match[1] ?? match[2] ?? "", 10);
+    if (Number.isInteger(number) && number > 0) {
+      numbers.add(number);
+    }
+  }
+
+  return Array.from(numbers).toSorted((left, right) => left - right);
+};
+
+function classifyIssueSnapshot(opts: {
+  eligible: boolean;
+  linkedPullRequestNumbers: readonly number[];
+  linkedPullRequests: readonly ReviewTriageSnapshot[];
+}): IssueSnapshotClassification {
+  const reasons = [
+    ...(!opts.eligible ? ["not_owned_by_automation_owner"] : []),
+    ...(opts.eligible && opts.linkedPullRequestNumbers.length === 0
+      ? ["no_linked_pull_request"]
+      : []),
+    ...opts.linkedPullRequests.flatMap((pr) =>
+      pr.classification.status === "needs_investigation"
+        ? pr.classification.reasons.map((reason) => `linked_pr_${pr.info.number}_${reason}`)
+        : [],
+    ),
+  ];
+  return { status: reasons.length > 0 ? "needs_investigation" : "clear", reasons };
+}
+
+export const fetchIssueSnapshot = Effect.fn("issue.fetchIssueSnapshot")(function* (opts: {
+  issue: number;
+  owner: string | null;
+}) {
+  const triage = yield* fetchIssueTriage({ issue: opts.issue, verbosity: "full" });
+  if (!("comments" in triage)) {
+    throw new Error("Expected full issue triage");
+  }
+
+  const owner = opts.owner?.toLowerCase() ?? null;
+  const eligible =
+    owner !== null &&
+    triage.issue.assignees.length === 1 &&
+    triage.issue.assignees[0]?.toLowerCase() === owner;
+  const linkedPullRequestNumbers = collectLinkedPullRequestNumbers(triage.body, triage.comments);
+  const linkedPullRequests = eligible
+    ? yield* Effect.all(
+        linkedPullRequestNumbers.map((prNumber) => fetchReviewTriage(prNumber)),
+        { concurrency: "unbounded" },
+      )
+    : [];
+  const classification = classifyIssueSnapshot({
+    eligible,
+    linkedPullRequestNumbers,
+    linkedPullRequests,
+  });
+
+  const result: IssueSnapshot = {
+    issue: triage.issue,
+    body: triage.body,
+    commentsCount: triage.commentsCount,
+    comments: triage.comments,
+    eligible,
+    linkedPullRequestNumbers,
+    linkedPullRequests,
+    classification,
+  };
+  return result;
+});
+
+export const fetchIssueSnapshotBatch = Effect.fn("issue.fetchIssueSnapshotBatch")(function* (opts: {
+  issues: readonly number[];
+  owner: string | null;
+}) {
+  return yield* Effect.all(
+    opts.issues.map((issue) => fetchIssueSnapshot({ issue, owner: opts.owner })),
+    { concurrency: "unbounded" },
+  );
+});
+
 export const issueTriageCommand = Command.make(
   "triage",
   {
@@ -151,3 +276,31 @@ export const issueTriageCommand = Command.make(
 ).pipe(
   Command.withDescription("Composite: fetch issue details and discussion comments in one call"),
 );
+
+export const issueSnapshotBatchCommand = Command.make(
+  "snapshot-batch",
+  {
+    format: formatOption,
+    issues: Flag.string("issues").pipe(Flag.withDescription("Comma-separated issue numbers")),
+    owner: Flag.string("owner").pipe(
+      Flag.withDescription("Automation owner login used to mark eligible issues"),
+      Flag.optional,
+    ),
+    repo: repoOption,
+  },
+  ({ format, issues, owner, repo }) =>
+    withRepo(
+      repo,
+      Effect.gen(function* () {
+        const result = yield* fetchIssueSnapshotBatch({
+          issues: parseIssueNumbers(issues),
+          owner: Option.getOrNull(owner),
+        });
+        yield* logFormatted(result, format);
+      }),
+    ),
+).pipe(
+  Command.withDescription(
+    "Composite: fetch full issue triage plus linked PR review-triage for multiple issues",
+  ),
+);

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

@@ -62,10 +62,15 @@ type ReviewTriageSummary = {
   readonly unresolvedReviewThreadsCount: number;
 };
 
+type ReviewTriageClassification = {
+  readonly status: "clear" | "needs_investigation";
+  readonly reasons: readonly string[];
+};
+
 export const classifyReviewTriage = (
   summary: ReviewTriageSummary,
   checks: readonly CheckResult[],
-) => {
+): ReviewTriageClassification => {
   const reasons = [
     ...(checks.some((check) => check.bucket === "fail") ? ["failed_checks"] : []),
     ...(summary.visibleOpenReviewThreadsCount > 0 ? ["visible_open_review_threads"] : []),
@@ -75,6 +80,26 @@ export const classifyReviewTriage = (
   return { status: reasons.length > 0 ? "needs_investigation" : "clear", reasons };
 };
 
+export const parsePrNumbers = (input: string): readonly number[] =>
+  input
+    .split(",")
+    .map((part) => Number.parseInt(part.trim(), 10))
+    .filter((number) => Number.isInteger(number) && number > 0);
+
+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 classification = classifyReviewTriage(summary, checks);
+  return { classification, info, unresolvedThreads, visibleOpenThreads, summary, checks };
+});
+
 export const prViewCommand = Command.make(
   "view",
   {
@@ -682,18 +707,8 @@ export const prReviewTriageCommand = Command.make(
       repo,
       Effect.gen(function* () {
         const prNumber = Option.getOrNull(pr);
-        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 classification = classifyReviewTriage(summary, checks);
-        yield* logFormatted(
-          { classification, info, unresolvedThreads, visibleOpenThreads, summary, checks },
-          format,
-        );
+        const result = yield* fetchReviewTriage(prNumber);
+        yield* logFormatted(result, format);
       }),
     ),
 ).pipe(
@@ -702,6 +717,30 @@ export const prReviewTriageCommand = Command.make(
   ),
 );
 
+export const prReviewTriageBatchCommand = Command.make(
+  "review-triage-batch",
+  {
+    format: formatOption,
+    prs: Flag.string("prs").pipe(Flag.withDescription("Comma-separated PR numbers")),
+    repo: repoOption,
+  },
+  ({ format, prs, repo }) =>
+    withRepo(
+      repo,
+      Effect.gen(function* () {
+        const results = yield* Effect.all(
+          parsePrNumbers(prs).map((prNumber) => fetchReviewTriage(prNumber)),
+          { concurrency: "unbounded" },
+        );
+        yield* logFormatted(results, format);
+      }),
+    ),
+).pipe(
+  Command.withDescription(
+    "Composite: fetch review-triage output for multiple PRs in one gh-tool invocation",
+  ),
+);
+
 export const prReplyAndResolveCommand = Command.make(
   "reply-and-resolve",
   {

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

@@ -18,5 +18,6 @@ export {
   prSubmitReviewCommand,
   prThreadsCommand,
   prReviewTriageCommand,
+  prReviewTriageBatchCommand,
   prViewCommand,
 } from "./commands";