@blogic-cz/agent-tools 0.8.15 → 0.8.16

package/package.json

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

@@ -21,6 +21,7 @@ import {
   detectPRStatus,
   editPR,
   fetchChecks,
+  fetchChecksForCommand,
   fetchFailedChecks,
   mergePR,
   rerunChecks,
@@ -200,7 +201,7 @@ export const prChecksCommand = Command.make(
   ({ failFast, format, pr, timeout, watch }) =>
     Effect.gen(function* () {
       const prNumber = Option.getOrNull(pr);
-      const checks = yield* fetchChecks(prNumber, watch, failFast, timeout);
+      const checks = yield* fetchChecksForCommand(prNumber, watch, failFast, timeout);
       yield* logFormatted(checks, format);
     }),
 ).pipe(Command.withDescription("Fetch CI check status for a PR (optionally watch with timeout)"));

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

@@ -1,6 +1,15 @@
 import { Console, Effect, Option } from "effect";
 
-import type { BranchPRDetail, CheckResult, MergeResult, MergeStrategy, PRInfo } from "#gh/types";
+import type {
+  BranchPRDetail,
+  CheckResult,
+  FailedCheckDetail,
+  FailedCheckRunContext,
+  MergeResult,
+  MergeStrategy,
+  PRInfo,
+  WorkflowRunDetail,
+} from "#gh/types";
 
 import { GitHubCommandError, GitHubMergeError, GitHubTimeoutError } from "#gh/errors";
 import { GitHubService } from "#gh/service";
@@ -8,6 +17,174 @@ import { GitHubService } from "#gh/service";
 import type { ButStatusJson, PRViewJsonResult } from "./helpers";
 import { runLocalCommand } from "./helpers";
 
+const CHECK_JSON_FIELDS = "name,state,bucket,link";
+const GITHUB_ACTIONS_RUN_ID_RE = /github\.com\/[^/]+\/[^/]+\/actions\/runs\/(\d+)/;
+
+const buildChecksCommand = (pr: number | null, includeWatch: boolean): string =>
+  `bun agent-tools-gh pr checks${pr !== null ? ` --pr ${pr}` : ""}${includeWatch ? " --watch" : ""}`;
+
+const buildChecksFailedCommand = (pr: number | null): string =>
+  `bun agent-tools-gh pr checks-failed${pr !== null ? ` --pr ${pr}` : ""}`;
+
+const extractRunIdFromCheckLink = (link: string): number | null => {
+  const match = link.match(GITHUB_ACTIONS_RUN_ID_RE);
+  if (!match?.[1]) {
+    return null;
+  }
+
+  const runId = Number(match[1]);
+  return Number.isFinite(runId) ? runId : null;
+};
+
+const fetchWorkflowRunFailureContext = Effect.fn("pr.fetchWorkflowRunFailureContext")(function* (
+  runId: number,
+) {
+  const gh = yield* GitHubService;
+
+  const run = yield* gh
+    .runGhJson<WorkflowRunDetail>([
+      "run",
+      "view",
+      String(runId),
+      "--json",
+      "databaseId,url,workflowName,status,conclusion,jobs",
+    ])
+    .pipe(Effect.catchTag("GitHubCommandError", () => Effect.succeed(null)));
+
+  if (run === null) {
+    return null;
+  }
+
+  const failedJobs = run.jobs
+    .filter((job) => job.conclusion === "failure" || job.status === "failure")
+    .map((job) => ({
+      name: job.name,
+      status: job.status,
+      conclusion: job.conclusion,
+      url: job.url,
+      failedSteps: job.steps
+        .filter((step) => step.conclusion === "failure" || step.status === "failure")
+        .map((step) => step.name),
+    }));
+
+  const context: FailedCheckRunContext = {
+    runId: run.databaseId,
+    url: run.url,
+    workflowName: run.workflowName,
+    status: run.status,
+    conclusion: run.conclusion,
+    failedJobs,
+  };
+
+  return context;
+});
+
+const fetchCheckResults = Effect.fn("pr.fetchCheckResults")(function* (pr: number | null) {
+  const gh = yield* GitHubService;
+
+  const args = ["pr", "checks"];
+  if (pr !== null) {
+    args.push(String(pr));
+  }
+
+  return yield* gh.runGhJson<CheckResult[]>([...args, "--json", CHECK_JSON_FIELDS]);
+});
+
+const buildFailedChecksReport = Effect.fn("pr.buildFailedChecksReport")(function* (
+  pr: number | null,
+  checks: CheckResult[],
+) {
+  const failedChecks = checks.filter((check) => check.bucket === "fail");
+  const pendingChecks = checks.filter((check) => check.bucket === "pending");
+  const passedChecks = checks.filter((check) => check.bucket === "pass");
+
+  const runIds = [
+    ...new Set(
+      failedChecks
+        .map((check) => extractRunIdFromCheckLink(check.link))
+        .filter((id) => id !== null),
+    ),
+  ];
+
+  const runContexts = new Map<number, FailedCheckRunContext | null>();
+  const contexts = yield* Effect.forEach(
+    runIds,
+    (runId) =>
+      fetchWorkflowRunFailureContext(runId).pipe(
+        Effect.map((context) => [runId, context] as const),
+      ),
+    { concurrency: "unbounded" },
+  );
+
+  for (const [runId, context] of contexts) {
+    runContexts.set(runId, context);
+  }
+
+  const enrichedFailedChecks: FailedCheckDetail[] = failedChecks.map((check) => {
+    const runId = extractRunIdFromCheckLink(check.link);
+    return {
+      ...check,
+      runId,
+      run: runId === null ? null : (runContexts.get(runId) ?? null),
+    };
+  });
+
+  const nextCommands = [
+    buildChecksFailedCommand(pr),
+    ...new Set(
+      enrichedFailedChecks.flatMap((check) => {
+        if (check.runId === null) {
+          return [];
+        }
+
+        const commands = [`bun agent-tools-gh workflow view --run ${check.runId}`];
+        const firstFailedJob = check.run?.failedJobs[0];
+        if (firstFailedJob) {
+          commands.push(
+            `bun agent-tools-gh workflow job-logs --run ${check.runId} --job ${JSON.stringify(firstFailedJob.name)} --failed-steps-only`,
+          );
+        }
+
+        return commands;
+      }),
+    ),
+    ...(pendingChecks.length > 0 ? [buildChecksCommand(pr, true)] : []),
+  ];
+
+  const message =
+    failedChecks.length === 0
+      ? pendingChecks.length > 0
+        ? `No failed checks yet; ${pendingChecks.length} check(s) are still running.`
+        : "No failed checks detected."
+      : pendingChecks.length > 0
+        ? `Detected ${failedChecks.length} failed check(s) while ${pendingChecks.length} check(s) are still running.`
+        : `Detected ${failedChecks.length} failed check(s).`;
+
+  const hint =
+    failedChecks.length === 0
+      ? pendingChecks.length > 0
+        ? "Wait for the remaining checks to finish, or use --watch to block until CI settles."
+        : "All current checks are green."
+      : pendingChecks.length > 0
+        ? "Inspect the failed workflow run first. Other checks are still running and may change overall merge readiness."
+        : "Inspect the failed workflow run and failed job logs to get the first concrete error, then rerun only if the failure is understood.";
+
+  return {
+    status: failedChecks.length > 0 ? "failed" : "no_failures",
+    message,
+    summary: {
+      total: checks.length,
+      failed: failedChecks.length,
+      pending: pendingChecks.length,
+      passed: passedChecks.length,
+    },
+    failedChecks: enrichedFailedChecks,
+    pendingChecks,
+    hint,
+    nextCommands,
+  };
+});
+
 export const viewPR = Effect.fn("pr.viewPR")(function* (prNumber: number | null) {
   const gh = yield* GitHubService;
 
@@ -446,22 +623,50 @@ export const fetchChecks = Effect.fn("pr.fetchChecks")(function* (
       }),
     );
 
-    return yield* gh.runGhJson<CheckResult[]>([...args, "--json", "name,state,bucket,link"]);
+    return yield* fetchCheckResults(pr);
   }
 
-  const results = yield* gh.runGhJson<CheckResult[]>([...args, "--json", "name,state,bucket,link"]);
+  const results = yield* fetchCheckResults(pr);
   if (results.some((c) => c.bucket === "pending")) {
     yield* Console.warn(
       `ℹ️  Some checks are still running. Prefer --watch to block until completion instead of polling:\n` +
-        `   bun agent-tools-gh pr checks${pr !== null ? ` --pr ${pr}` : ""} --watch`,
+        `   ${buildChecksCommand(pr, true)}`,
     );
   }
   return results;
 });
 
 export const fetchFailedChecks = Effect.fn("pr.fetchFailedChecks")(function* (pr: number | null) {
-  const checks = yield* fetchChecks(pr, false, false, 0);
-  return checks.filter((check) => check.bucket === "fail");
+  const checks = yield* fetchCheckResults(pr);
+  return yield* buildFailedChecksReport(pr, checks);
+});
+
+export const fetchChecksForCommand = Effect.fn("pr.fetchChecksForCommand")(function* (
+  pr: number | null,
+  watch: boolean,
+  failFast: boolean,
+  timeoutSeconds: number,
+) {
+  if (!watch) {
+    return yield* fetchChecks(pr, false, failFast, timeoutSeconds);
+  }
+
+  const watchedChecks = yield* fetchChecks(pr, true, failFast, timeoutSeconds).pipe(
+    Effect.catchTag("GitHubCommandError", (error) =>
+      Effect.succeed({ _tag: "command_error" as const, error }),
+    ),
+  );
+
+  if (Array.isArray(watchedChecks)) {
+    return watchedChecks;
+  }
+
+  const finalChecks = yield* fetchCheckResults(pr);
+  if (finalChecks.some((check) => check.bucket === "fail")) {
+    return yield* buildFailedChecksReport(pr, finalChecks);
+  }
+
+  return yield* Effect.fail(watchedChecks.error);
 });
 
 export const rerunChecks = Effect.fn("pr.rerunChecks")(function* (

package/src/gh-tool/types.ts

@@ -62,6 +62,62 @@ export type CheckResult = {
   link: string;
 };
 
+export type FailedCheckJob = {
+  name: string;
+  status: string;
+  conclusion: string | null;
+  url: string;
+  failedSteps: string[];
+};
+
+export type FailedCheckRunContext = {
+  runId: number;
+  url: string | null;
+  workflowName: string | null;
+  status: string;
+  conclusion: string | null;
+  failedJobs: FailedCheckJob[];
+};
+
+export type FailedCheckDetail = CheckResult & {
+  runId: number | null;
+  run: FailedCheckRunContext | null;
+};
+
+export type FailedChecksReport = {
+  status: "failed" | "no_failures";
+  message: string;
+  summary: {
+    total: number;
+    failed: number;
+    pending: number;
+    passed: number;
+  };
+  failedChecks: FailedCheckDetail[];
+  pendingChecks: CheckResult[];
+  hint: string;
+  nextCommands: string[];
+};
+
+export type WorkflowRunDetail = {
+  databaseId: number;
+  url: string;
+  workflowName: string | null;
+  status: string;
+  conclusion: string | null;
+  jobs: Array<{
+    name: string;
+    status: string;
+    conclusion: string | null;
+    url: string;
+    steps: Array<{
+      name: string;
+      status: string;
+      conclusion: string | null;
+    }>;
+  }>;
+};
+
 export type MergeResult = {
   merged: boolean;
   strategy: MergeStrategy;