@blogic-cz/agent-tools 0.14.53 → 0.14.55

package/package.json

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

package/src/db-tool/service.ts

@@ -53,6 +53,16 @@ export function resolveDbAccessMode(
   };
 }
 
+export function isFullyReadOnly(
+  config: Pick<DbConfig, "allowMutations" | "allowedMutations" | "allowedMutationTargets">,
+): boolean {
+  return (
+    !config.allowMutations &&
+    config.allowedMutations.length === 0 &&
+    Object.keys(config.allowedMutationTargets).length === 0
+  );
+}
+
 // Re-exported from the shared probe so existing `#db/service` consumers keep working.
 export { buildApiProbeArgs } from "#shared/k8s-probe";
 
@@ -393,6 +403,9 @@ export class DbService extends Context.Service<
             env: {
               ...process.env,
               ...(password ? { PGPASSWORD: password } : {}),
+              ...(isFullyReadOnly(config)
+                ? { PGOPTIONS: "-c default_transaction_read_only=on" }
+                : {}),
             } as Record<string, string>,
           });
         };

package/src/gh-tool/index.ts

@@ -35,6 +35,7 @@ import {
   prReplyCommand,
   prResolveCommand,
   prReviewsCommand,
+  prLastHumanReviewerCommand,
   prSubmitReviewCommand,
   prChecksCommand,
   prChecksFailedCommand,
@@ -82,6 +83,7 @@ const prCommand = Command.make("pr", {}).pipe(
     prThreadsCommand,
     prCommentsCommand,
     prReviewsCommand,
+    prLastHumanReviewerCommand,
     prFeedbackCommand,
     prIssueCommentsCommand,
     prIssueCommentsLatestCommand,

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

@@ -46,6 +46,7 @@ import {
   fetchDiscussionSummary,
   fetchFeedback,
   fetchIssueComments,
+  fetchLastHumanReviewer,
   fetchLatestIssueComment,
   fetchReviews,
   fetchThreads,
@@ -520,13 +521,19 @@ export const prChecksFailedCommand = Command.make(
       Flag.optional,
     ),
     repo: repoOption,
+    withLogs: Flag.boolean("with-logs").pipe(
+      Flag.withDescription(
+        "Inline the failed-step logs for each failed check so no follow-up job-logs call is needed",
+      ),
+      Flag.withDefault(false),
+    ),
   },
-  ({ format, pr, repo }) =>
+  ({ format, pr, repo, withLogs }) =>
     withRepo(
       repo,
       Effect.gen(function* () {
         const prNumber = Option.getOrNull(pr);
-        const checks = yield* fetchFailedChecks(prNumber);
+        const checks = yield* fetchFailedChecks(prNumber, withLogs);
         yield* logFormatted(checks, format);
       }),
     ),
@@ -620,6 +627,30 @@ export const prCommentsCommand = Command.make(
     ),
 ).pipe(Command.withDescription("Fetch review comments for a PR (optionally filter by --since)"));
 
+export const prLastHumanReviewerCommand = Command.make(
+  "last-human-reviewer",
+  {
+    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 result = yield* fetchLastHumanReviewer(Option.getOrNull(pr));
+        yield* logFormatted(result, format);
+      }),
+    ),
+).pipe(
+  Command.withDescription(
+    "Report the most recent human (non-bot) reviewer, when they reviewed, and the current requested reviewers",
+  ),
+);
+
 export const prReviewsCommand = Command.make(
   "reviews",
   {

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

@@ -17,6 +17,7 @@ import { GitHubService } from "#gh/service";
 
 import type { ButStatusJson, PRViewJsonResult } from "./helpers";
 import { runLocalCommand } from "./helpers";
+import { fetchJobLogs } from "#gh/workflow";
 
 const CHECK_JSON_FIELDS = "name,state,bucket,link";
 const GITHUB_ACTIONS_RUN_ID_RE = /github\.com\/[^/]+\/[^/]+\/actions\/runs\/(\d+)/;
@@ -104,6 +105,16 @@ const getCheckJobNameCandidates = (checkName: string): string[] => {
   return [...new Set([exact, suffix].filter((value): value is string => value !== undefined))];
 };
 
+const failedJobsMatchingCheck = <Job extends { name: string }>(
+  checkName: string,
+  failedJobs: readonly Job[],
+): Job[] => {
+  const candidates = getCheckJobNameCandidates(checkName);
+  return failedJobs.filter((job) =>
+    candidates.some((candidate) => job.name.toLowerCase() === candidate.toLowerCase()),
+  );
+};
+
 const resolveJobIdsForFailedChecks = (
   checks: CheckResult[],
   jobs: WorkflowRunJobsForRerun["jobs"],
@@ -112,10 +123,7 @@ const resolveJobIdsForFailedChecks = (
   const jobIds = new Set<number>();
 
   for (const check of checks) {
-    const candidates = getCheckJobNameCandidates(check.name);
-    const matches = failedJobs.filter((job) =>
-      candidates.some((candidate) => job.name.toLowerCase() === candidate.toLowerCase()),
-    );
+    const matches = failedJobsMatchingCheck(check.name, failedJobs);
 
     if (matches.length !== 1) {
       return null;
@@ -127,6 +135,14 @@ const resolveJobIdsForFailedChecks = (
   return [...jobIds];
 };
 
+const matchFailedJobForCheck = <Job extends { name: string }>(
+  checkName: string,
+  failedJobs: readonly Job[],
+): Job | null => {
+  const matches = failedJobsMatchingCheck(checkName, failedJobs);
+  return matches.length === 1 ? matches[0] : null;
+};
+
 const fetchWorkflowRunFailureContext = Effect.fn("pr.fetchWorkflowRunFailureContext")(function* (
   runId: number,
 ) {
@@ -149,6 +165,7 @@ const fetchWorkflowRunFailureContext = Effect.fn("pr.fetchWorkflowRunFailureCont
   const failedJobs = run.jobs
     .filter((job) => job.conclusion === "failure" || job.status === "failure")
     .map((job) => ({
+      databaseId: job.databaseId,
       name: job.name,
       status: job.status,
       conclusion: job.conclusion,
@@ -184,6 +201,7 @@ const fetchCheckResults = Effect.fn("pr.fetchCheckResults")(function* (pr: numbe
 const buildFailedChecksReport = Effect.fn("pr.buildFailedChecksReport")(function* (
   pr: number | null,
   checks: CheckResult[],
+  options: { withLogs: boolean } = { withLogs: false },
 ) {
   const failedChecks = checks.filter((check) => check.bucket === "fail");
   const pendingChecks = checks.filter((check) => check.bucket === "pending");
@@ -211,14 +229,40 @@ const buildFailedChecksReport = Effect.fn("pr.buildFailedChecksReport")(function
     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 enrichedFailedChecks: FailedCheckDetail[] = yield* Effect.forEach(
+    failedChecks,
+    (check) =>
+      Effect.gen(function* () {
+        const runId = extractRunIdFromCheckLink(check.link);
+        const run = runId === null ? null : (runContexts.get(runId) ?? null);
+        const detail: FailedCheckDetail = { ...check, runId, run };
+
+        if (!options.withLogs || runId === null) {
+          return detail;
+        }
+
+        const matchedJob = run ? matchFailedJobForCheck(check.name, run.failedJobs) : null;
+        if (!matchedJob) {
+          return detail;
+        }
+
+        const failedStepLogs = yield* fetchJobLogs({
+          runId,
+          job: matchedJob.name,
+          jobId: matchedJob.databaseId,
+          failedStepNames: matchedJob.failedSteps,
+          failedStepsOnly: true,
+          format: "text",
+          repo: null,
+        }).pipe(
+          Effect.map((result) => ("formatted" in result ? result.formatted : "")),
+          Effect.catch(() => Effect.succeed("")),
+        );
+
+        return failedStepLogs && failedStepLogs.length > 0 ? { ...detail, failedStepLogs } : detail;
+      }),
+    { concurrency: 5 },
+  );
 
   const nextCommands = [
     buildChecksFailedCommand(pr),
@@ -902,9 +946,12 @@ export const fetchChecks = Effect.fn("pr.fetchChecks")(function* (
   return results;
 });
 
-export const fetchFailedChecks = Effect.fn("pr.fetchFailedChecks")(function* (pr: number | null) {
+export const fetchFailedChecks = Effect.fn("pr.fetchFailedChecks")(function* (
+  pr: number | null,
+  withLogs = false,
+) {
   const checks = yield* fetchCheckResults(pr);
-  return yield* buildFailedChecksReport(pr, checks);
+  return yield* buildFailedChecksReport(pr, checks, { withLogs });
 });
 
 export const fetchChecksForCommand = Effect.fn("pr.fetchChecksForCommand")(function* (

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

@@ -10,6 +10,7 @@ export {
   prFeedbackCommand,
   prIssueCommentsCommand,
   prIssueCommentsLatestCommand,
+  prLastHumanReviewerCommand,
   prListCommand,
   prMergeCommand,
   prReplyCommand,

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

@@ -81,6 +81,53 @@ const SUBMIT_REVIEW_MUTATION = `
   }
 `;
 
+const LAST_HUMAN_REVIEWER_QUERY = `
+  query($owner: String!, $name: String!, $pr: Int!) {
+    repository(owner: $owner, name: $name) {
+      pullRequest(number: $pr) {
+        reviewRequests(first: 100) {
+          nodes {
+            requestedReviewer {
+              __typename
+              ... on User { login }
+              ... on Team { name }
+              ... on Bot { login }
+            }
+          }
+        }
+        reviews(last: 100) {
+          nodes {
+            author { login }
+            state
+            submittedAt
+          }
+        }
+        timelineItems(first: 250, itemTypes: [REVIEW_REQUESTED_EVENT, REVIEW_REQUEST_REMOVED_EVENT]) {
+          nodes {
+            __typename
+            ... on ReviewRequestedEvent {
+              requestedReviewer {
+                __typename
+                ... on User { login }
+                ... on Team { name }
+                ... on Bot { login }
+              }
+            }
+            ... on ReviewRequestRemovedEvent {
+              requestedReviewer {
+                __typename
+                ... on User { login }
+                ... on Team { name }
+                ... on Bot { login }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+
 // ---------------------------------------------------------------------------
 // Internal types
 // ---------------------------------------------------------------------------
@@ -141,6 +188,35 @@ type SubmitReviewResult = {
   };
 };
 
+type RequestedReviewerNode = {
+  __typename: string;
+  login?: string;
+  name?: string;
+} | null;
+
+type LastHumanReviewerQueryResult = {
+  repository: {
+    pullRequest: {
+      reviewRequests: {
+        nodes: Array<{ requestedReviewer: RequestedReviewerNode }>;
+      };
+      reviews: {
+        nodes: Array<{
+          author: { login: string } | null;
+          state: string;
+          submittedAt: string | null;
+        }>;
+      };
+      timelineItems: {
+        nodes: Array<{
+          __typename: string;
+          requestedReviewer: RequestedReviewerNode;
+        }>;
+      };
+    };
+  };
+};
+
 type RawReviewComment = {
   id: number;
   in_reply_to_id: number | null;
@@ -259,7 +335,7 @@ const enrichThreads = (threads: ThreadNode[], reviewComments: ReviewComment[]):
     repliesByRootCommentId.set(comment.inReplyToId, replies);
   }
 
-  return threads
+  const mapped = threads
     .map((node) => {
       const comment = node.comments.nodes[0];
       if (!comment) {
@@ -295,6 +371,24 @@ const enrichThreads = (threads: ThreadNode[], reviewComments: ReviewComment[]):
       };
     })
     .filter((thread): thread is ReviewThread => thread !== null);
+
+  const dedupedByKey = new Map<string, number>();
+  const deduped: ReviewThread[] = [];
+  for (const thread of mapped) {
+    const key = `${thread.path}${thread.line}${thread.body.trim()}`;
+    const existingIndex = dedupedByKey.get(key);
+    if (existingIndex === undefined) {
+      dedupedByKey.set(key, deduped.length);
+      deduped.push(thread);
+      continue;
+    }
+    const existing = deduped[existingIndex];
+    if (existing !== undefined && existing.isResolved && !thread.isResolved) {
+      deduped[existingIndex] = thread;
+    }
+  }
+
+  return deduped;
 };
 
 const fetchThreadState = Effect.fn("pr.fetchThreadState")(function* (pr: number) {
@@ -768,3 +862,83 @@ export const submitPendingReview = Effect.fn("pr.submitPendingReview")(function*
     state: result.submitPullRequestReview.pullRequestReview.state,
   };
 });
+
+const AUTOMATION_LOGINS = new Set(["claude", "github-actions", "dependabot"]);
+
+const isHumanLogin = (login: string): boolean => {
+  const lower = login.toLowerCase();
+  if (lower.endsWith("[bot]")) {
+    return false;
+  }
+  return !AUTOMATION_LOGINS.has(lower);
+};
+
+const requestedReviewerLogin = (reviewer: RequestedReviewerNode): string | null =>
+  reviewer === null ? null : (reviewer.login ?? reviewer.name ?? null);
+
+export const fetchLastHumanReviewer = Effect.fn("pr.fetchLastHumanReviewer")(function* (
+  pr: number | null,
+) {
+  const service = yield* GitHubService;
+  const repoInfo = yield* service.getRepoInfo();
+
+  const resolvedPr = pr ?? (yield* viewPR(null)).number;
+
+  const response = (yield* service.runGraphQL(LAST_HUMAN_REVIEWER_QUERY, {
+    owner: repoInfo.owner,
+    name: repoInfo.name,
+    pr: resolvedPr,
+  })) as LastHumanReviewerQueryResult;
+
+  const prNode = response.repository.pullRequest;
+
+  const requestedFromTimeline: string[] = [];
+  for (const item of prNode.timelineItems.nodes) {
+    const login = requestedReviewerLogin(item.requestedReviewer);
+    if (login === null) {
+      continue;
+    }
+    if (item.__typename === "ReviewRequestedEvent") {
+      if (!requestedFromTimeline.includes(login)) {
+        requestedFromTimeline.push(login);
+      }
+    } else {
+      const index = requestedFromTimeline.indexOf(login);
+      if (index !== -1) {
+        requestedFromTimeline.splice(index, 1);
+      }
+    }
+  }
+
+  const currentRequestedReviewers =
+    requestedFromTimeline.length > 0
+      ? requestedFromTimeline
+      : prNode.reviewRequests.nodes
+          .map((node) => requestedReviewerLogin(node.requestedReviewer))
+          .filter((login): login is string => login !== null);
+
+  const latestHumanReview = prNode.reviews.nodes.reduce<{ login: string; at: string } | null>(
+    (latest, review) => {
+      if (review.author === null || review.submittedAt === null) {
+        return latest;
+      }
+      if (!isHumanLogin(review.author.login)) {
+        return latest;
+      }
+      if (
+        latest === null ||
+        new Date(review.submittedAt).getTime() > new Date(latest.at).getTime()
+      ) {
+        return { login: review.author.login, at: review.submittedAt };
+      }
+      return latest;
+    },
+    null,
+  );
+
+  return {
+    currentRequestedReviewers,
+    lastHumanReviewer: latestHumanReview?.login ?? null,
+    lastHumanReviewAt: latestHumanReview?.at ?? null,
+  };
+});

package/src/gh-tool/types.ts

@@ -83,6 +83,7 @@ export type CheckResult = {
 };
 
 export type FailedCheckJob = {
+  databaseId: number;
   name: string;
   status: string;
   conclusion: string | null;
@@ -102,6 +103,7 @@ export type FailedCheckRunContext = {
 export type FailedCheckDetail = CheckResult & {
   runId: number | null;
   run: FailedCheckRunContext | null;
+  failedStepLogs?: string;
 };
 
 export type FailedChecksReport = {
@@ -126,6 +128,7 @@ export type WorkflowRunDetail = {
   status: string;
   conclusion: string | null;
   jobs: Array<{
+    databaseId: number;
     name: string;
     status: string;
     conclusion: string | null;

package/src/gh-tool/workflow.ts

@@ -494,9 +494,11 @@ const filterFailedStepEntries = Effect.fn("workflow.filterFailedStepEntries")(fu
   return entries.filter((e) => failedStepNames.has(e.step));
 });
 
-const fetchJobLogs = Effect.fn("workflow.fetchJobLogs")(function* (opts: {
+export const fetchJobLogs = Effect.fn("workflow.fetchJobLogs")(function* (opts: {
   runId: number;
   job: string;
+  jobId?: number | null;
+  failedStepNames?: readonly string[] | null;
   failedStepsOnly: boolean;
   format: string;
   repo: string | null;
@@ -523,7 +525,7 @@ const fetchJobLogs = Effect.fn("workflow.fetchJobLogs")(function* (opts: {
     repoName = info.name;
   }
 
-  const jobId = yield* resolveJobId(opts.runId, opts.job, opts.repo);
+  const jobId = opts.jobId ?? (yield* resolveJobId(opts.runId, opts.job, opts.repo));
 
   // Fetch raw logs via API (follows 302 redirect automatically)
   const raw = yield* gh
@@ -539,7 +541,12 @@ const fetchJobLogs = Effect.fn("workflow.fetchJobLogs")(function* (opts: {
   let entries = parseRawJobLogs(raw);
 
   if (opts.failedStepsOnly) {
-    entries = yield* filterFailedStepEntries(opts.runId, jobId, entries, opts.repo);
+    if (Array.isArray(opts.failedStepNames) && opts.failedStepNames.length > 0) {
+      const wanted = new Set(opts.failedStepNames);
+      entries = entries.filter((e) => wanted.has(e.step));
+    } else {
+      entries = yield* filterFailedStepEntries(opts.runId, jobId, entries, opts.repo);
+    }
   }
 
   if (opts.format === "json") {