@blogic-cz/agent-tools 0.8.14 → 0.8.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blogic-cz/agent-tools",
-  "version": "0.8.14",
+  "version": "0.8.16",
   "description": "CLI tools for AI coding agent workflows — GitHub, database, Kubernetes, Azure DevOps, logs, sessions, and audit",
   "keywords": [
     "agent",
@@ -112,8 +112,10 @@
     "check:ci": "bun check.ts ci",
     "format": "oxfmt",
     "format:check": "oxfmt --check",
+    "gh-tool": "bun src/gh-tool/index.ts",
     "lint": "oxlint -c ./.oxlintrc.json --deny-warnings",
     "lint:fix": "oxlint -c ./.oxlintrc.json --fix",
+    "session-tool": "bun src/session-tool/index.ts",
     "update:skills": "bun run .agents/skills/update-packages/references/skills-update-local.ts",
     "test": "vitest run"
   },

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

@@ -2,6 +2,7 @@ import { Command, Flag } from "effect/unstable/cli";
 import { Effect, Option } from "effect";
 
 import { formatOption, logFormatted } from "#shared";
+import { resolveOptionalTextInput, resolveRequiredTextInput } from "#gh/text-input";
 
 import {
   closeIssue,
@@ -91,6 +92,10 @@ export const issueCloseCommand = Command.make(
       Flag.withDescription("Comment to add when closing"),
       Flag.optional,
     ),
+    commentFile: Flag.string("comment-file").pipe(
+      Flag.withDescription("Read close comment from a file path or '-' for stdin"),
+      Flag.optional,
+    ),
     format: formatOption,
     issue: Flag.integer("issue").pipe(Flag.withDescription("Issue number to close")),
     reason: Flag.choice("reason", ["completed", "not planned"]).pipe(
@@ -98,10 +103,19 @@ export const issueCloseCommand = Command.make(
       Flag.withDefault("completed"),
     ),
   },
-  ({ comment, format, issue, reason }) =>
+  ({ comment, commentFile, format, issue, reason }) =>
     Effect.gen(function* () {
+      const resolvedComment = yield* resolveOptionalTextInput(
+        "gh-tool issue close",
+        Option.getOrNull(comment),
+        Option.getOrNull(commentFile),
+        "--comment",
+        "--comment-file",
+        "comment",
+      );
+
       const result = yield* closeIssue({
-        comment: Option.getOrNull(comment),
+        comment: resolvedComment,
         issue,
         reason,
       });
@@ -116,13 +130,26 @@ export const issueReopenCommand = Command.make(
       Flag.withDescription("Comment to add when reopening"),
       Flag.optional,
     ),
+    commentFile: Flag.string("comment-file").pipe(
+      Flag.withDescription("Read reopen comment from a file path or '-' for stdin"),
+      Flag.optional,
+    ),
     format: formatOption,
     issue: Flag.integer("issue").pipe(Flag.withDescription("Issue number to reopen")),
   },
-  ({ comment, format, issue }) =>
+  ({ comment, commentFile, format, issue }) =>
     Effect.gen(function* () {
+      const resolvedComment = yield* resolveOptionalTextInput(
+        "gh-tool issue reopen",
+        Option.getOrNull(comment),
+        Option.getOrNull(commentFile),
+        "--comment",
+        "--comment-file",
+        "comment",
+      );
+
       const result = yield* reopenIssue({
-        comment: Option.getOrNull(comment),
+        comment: resolvedComment,
         issue,
       });
       yield* logFormatted(result, format);
@@ -132,13 +159,26 @@ export const issueReopenCommand = Command.make(
 export const issueCommentCommand = Command.make(
   "comment",
   {
-    body: Flag.string("body").pipe(Flag.withDescription("Comment body text")),
+    body: Flag.string("body").pipe(Flag.withDescription("Comment body text"), Flag.optional),
+    bodyFile: Flag.string("body-file").pipe(
+      Flag.withDescription("Read comment body from a file path or '-' for stdin"),
+      Flag.optional,
+    ),
     format: formatOption,
     issue: Flag.integer("issue").pipe(Flag.withDescription("Issue number to comment on")),
   },
-  ({ body, format, issue }) =>
+  ({ body, bodyFile, format, issue }) =>
     Effect.gen(function* () {
-      const result = yield* commentOnIssue({ body, issue });
+      const resolvedBody = yield* resolveRequiredTextInput(
+        "gh-tool issue comment",
+        Option.getOrNull(body),
+        Option.getOrNull(bodyFile),
+        "--body",
+        "--body-file",
+        "body",
+      );
+
+      const result = yield* commentOnIssue({ body: resolvedBody, issue });
       yield* logFormatted(result, format);
     }),
 ).pipe(Command.withDescription("Post a comment on an issue"));
@@ -155,6 +195,10 @@ export const issueEditCommand = Command.make(
       Flag.optional,
     ),
     body: Flag.string("body").pipe(Flag.withDescription("New issue body"), Flag.optional),
+    bodyFile: Flag.string("body-file").pipe(
+      Flag.withDescription("Read issue body from a file path or '-' for stdin"),
+      Flag.optional,
+    ),
     format: formatOption,
     issue: Flag.integer("issue").pipe(Flag.withDescription("Issue number to edit")),
     removeAssignee: Flag.string("remove-assignee").pipe(
@@ -167,12 +211,31 @@ export const issueEditCommand = Command.make(
     ),
     title: Flag.string("title").pipe(Flag.withDescription("New issue title"), Flag.optional),
   },
-  ({ addAssignee, addLabels, body, format, issue, removeAssignee, removeLabels, title }) =>
+  ({
+    addAssignee,
+    addLabels,
+    body,
+    bodyFile,
+    format,
+    issue,
+    removeAssignee,
+    removeLabels,
+    title,
+  }) =>
     Effect.gen(function* () {
+      const resolvedBody = yield* resolveOptionalTextInput(
+        "gh-tool issue edit",
+        Option.getOrNull(body),
+        Option.getOrNull(bodyFile),
+        "--body",
+        "--body-file",
+        "body",
+      );
+
       const result = yield* editIssue({
         addAssignee: Option.getOrNull(addAssignee),
         addLabels: Option.getOrNull(addLabels),
-        body: Option.getOrNull(body),
+        body: resolvedBody,
         issue,
         removeAssignee: Option.getOrNull(removeAssignee),
         removeLabels: Option.getOrNull(removeLabels),

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

@@ -4,6 +4,11 @@ import { Effect, Option } from "effect";
 import type { PRStatusResult } from "#gh/types";
 
 import { formatOption, logFormatted } from "#shared";
+import {
+  resolveDefaultTextInput,
+  resolveOptionalTextInput,
+  resolveRequiredTextInput,
+} from "#gh/text-input";
 import {
   CI_CHECK_WATCH_TIMEOUT_MS,
   DEFAULT_DELETE_BRANCH,
@@ -16,6 +21,7 @@ import {
   detectPRStatus,
   editPR,
   fetchChecks,
+  fetchChecksForCommand,
   fetchFailedChecks,
   mergePR,
   rerunChecks,
@@ -70,9 +76,10 @@ export const prCreateCommand = Command.make(
       Flag.withDescription("Base branch for the PR"),
       Flag.withDefault("test"),
     ),
-    body: Flag.string("body").pipe(
-      Flag.withDescription("PR body/description"),
-      Flag.withDefault(""),
+    body: Flag.string("body").pipe(Flag.withDescription("PR body/description"), Flag.optional),
+    bodyFile: Flag.string("body-file").pipe(
+      Flag.withDescription("Read PR body from a file path or '-' for stdin"),
+      Flag.optional,
     ),
     draft: Flag.boolean("draft").pipe(
       Flag.withDescription("Create as draft PR"),
@@ -85,11 +92,21 @@ export const prCreateCommand = Command.make(
     ),
     title: Flag.string("title").pipe(Flag.withDescription("PR title")),
   },
-  ({ base, body, draft, format, head, title }) =>
+  ({ base, body, bodyFile, draft, format, head, title }) =>
     Effect.gen(function* () {
+      const resolvedBody = yield* resolveDefaultTextInput(
+        "gh-tool pr create",
+        Option.getOrNull(body),
+        Option.getOrNull(bodyFile),
+        "--body",
+        "--body-file",
+        "body",
+        "",
+      );
+
       const info = yield* createPR({
         base,
-        body,
+        body: resolvedBody,
         draft,
         head: Option.getOrNull(head),
         title,
@@ -102,16 +119,29 @@ export const prEditCommand = Command.make(
   "edit",
   {
     body: Flag.string("body").pipe(Flag.withDescription("New PR body/description"), Flag.optional),
+    bodyFile: Flag.string("body-file").pipe(
+      Flag.withDescription("Read PR body from a file path or '-' for stdin"),
+      Flag.optional,
+    ),
     format: formatOption,
     pr: Flag.integer("pr").pipe(Flag.withDescription("PR number to edit")),
     title: Flag.string("title").pipe(Flag.withDescription("New PR title"), Flag.optional),
   },
-  ({ body, format, pr, title }) =>
+  ({ body, bodyFile, format, pr, title }) =>
     Effect.gen(function* () {
+      const resolvedBody = yield* resolveOptionalTextInput(
+        "gh-tool pr edit",
+        Option.getOrNull(body),
+        Option.getOrNull(bodyFile),
+        "--body",
+        "--body-file",
+        "body",
+      );
+
       const info = yield* editPR({
         pr,
         title: Option.getOrNull(title),
-        body: Option.getOrNull(body),
+        body: resolvedBody,
       });
       yield* logFormatted(info, format);
     }),
@@ -171,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)"));
@@ -338,17 +368,32 @@ export const prIssueCommentsLatestCommand = Command.make(
 export const prCommentCommand = Command.make(
   "comment",
   {
-    body: Flag.string("body").pipe(Flag.withDescription("General PR comment body text")),
+    body: Flag.string("body").pipe(
+      Flag.withDescription("General PR comment body text"),
+      Flag.optional,
+    ),
+    bodyFile: Flag.string("body-file").pipe(
+      Flag.withDescription("Read general PR comment body from a file path or '-' for stdin"),
+      Flag.optional,
+    ),
     format: formatOption,
     pr: Flag.integer("pr").pipe(
       Flag.withDescription("PR number (default: current branch PR)"),
       Flag.optional,
     ),
   },
-  ({ body, format, pr }) =>
+  ({ body, bodyFile, format, pr }) =>
     Effect.gen(function* () {
       const prNumber = Option.getOrNull(pr);
-      const result = yield* postIssueComment(prNumber, body);
+      const resolvedBody = yield* resolveRequiredTextInput(
+        "gh-tool pr comment",
+        Option.getOrNull(body),
+        Option.getOrNull(bodyFile),
+        "--body",
+        "--body-file",
+        "body",
+      );
+      const result = yield* postIssueComment(prNumber, resolvedBody);
       yield* logFormatted(result, format);
     }),
 ).pipe(Command.withDescription("Post a general PR discussion comment"));
@@ -375,7 +420,11 @@ export const prDiscussionSummaryCommand = Command.make(
 export const prReplyCommand = Command.make(
   "reply",
   {
-    body: Flag.string("body").pipe(Flag.withDescription("Reply body text")),
+    body: Flag.string("body").pipe(Flag.withDescription("Reply body text"), Flag.optional),
+    bodyFile: Flag.string("body-file").pipe(
+      Flag.withDescription("Read reply body from a file path or '-' for stdin"),
+      Flag.optional,
+    ),
     commentId: Flag.integer("comment-id").pipe(
       Flag.withDescription("ID of the comment to reply to"),
     ),
@@ -385,10 +434,18 @@ export const prReplyCommand = Command.make(
       Flag.optional,
     ),
   },
-  ({ body, commentId, format, pr }) =>
+  ({ body, bodyFile, commentId, format, pr }) =>
     Effect.gen(function* () {
       const prNumber = Option.getOrNull(pr);
-      const result = yield* replyToComment(prNumber, commentId, body);
+      const resolvedBody = yield* resolveRequiredTextInput(
+        "gh-tool pr reply",
+        Option.getOrNull(body),
+        Option.getOrNull(bodyFile),
+        "--body",
+        "--body-file",
+        "body",
+      );
+      const result = yield* replyToComment(prNumber, commentId, resolvedBody);
       yield* logFormatted(result, format);
     }),
 ).pipe(Command.withDescription("Reply to an inline review comment"));
@@ -415,6 +472,10 @@ export const prSubmitReviewCommand = Command.make(
       Flag.withDescription("Optional review body text when submitting"),
       Flag.optional,
     ),
+    bodyFile: Flag.string("body-file").pipe(
+      Flag.withDescription("Read review body from a file path or '-' for stdin"),
+      Flag.optional,
+    ),
     format: formatOption,
     pr: Flag.integer("pr").pipe(
       Flag.withDescription("PR number (default: current branch PR)"),
@@ -427,11 +488,18 @@ export const prSubmitReviewCommand = Command.make(
       Flag.optional,
     ),
   },
-  ({ body, format, pr, reviewId }) =>
+  ({ body, bodyFile, format, pr, reviewId }) =>
     Effect.gen(function* () {
       const prNumber = Option.getOrNull(pr);
       const reviewIdValue = Option.getOrNull(reviewId);
-      const bodyValue = Option.getOrNull(body);
+      const bodyValue = yield* resolveOptionalTextInput(
+        "gh-tool pr submit-review",
+        Option.getOrNull(body),
+        Option.getOrNull(bodyFile),
+        "--body",
+        "--body-file",
+        "body",
+      );
       const result = yield* submitPendingReview(prNumber, reviewIdValue, bodyValue);
       yield* logFormatted(result, format);
     }),
@@ -471,7 +539,11 @@ export const prReviewTriageCommand = Command.make(
 export const prReplyAndResolveCommand = Command.make(
   "reply-and-resolve",
   {
-    body: Flag.string("body").pipe(Flag.withDescription("Reply body text")),
+    body: Flag.string("body").pipe(Flag.withDescription("Reply body text"), Flag.optional),
+    bodyFile: Flag.string("body-file").pipe(
+      Flag.withDescription("Read reply body from a file path or '-' for stdin"),
+      Flag.optional,
+    ),
     commentId: Flag.integer("comment-id").pipe(
       Flag.withDescription("ID of the comment to reply to"),
     ),
@@ -484,10 +556,18 @@ export const prReplyAndResolveCommand = Command.make(
       Flag.withDescription("GraphQL node ID of the thread to resolve"),
     ),
   },
-  ({ body, commentId, format, pr, threadId }) =>
+  ({ body, bodyFile, commentId, format, pr, threadId }) =>
     Effect.gen(function* () {
       const prNumber = Option.getOrNull(pr);
-      const replyResult = yield* replyToComment(prNumber, commentId, body);
+      const resolvedBody = yield* resolveRequiredTextInput(
+        "gh-tool pr reply-and-resolve",
+        Option.getOrNull(body),
+        Option.getOrNull(bodyFile),
+        "--body",
+        "--body-file",
+        "body",
+      );
+      const replyResult = yield* replyToComment(prNumber, commentId, resolvedBody);
       const resolveResult = yield* resolveThread(threadId);
       yield* logFormatted({ reply: replyResult, resolve: resolveResult }, format);
     }),

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/release.ts

@@ -2,6 +2,7 @@ import { Command, Flag } from "effect/unstable/cli";
 import { Effect, Option } from "effect";
 
 import { formatOption, logFormatted } from "#shared";
+import { resolveOptionalTextInput } from "#gh/text-input";
 import { GitHubService } from "./service";
 
 type ReleaseListItem = {
@@ -343,6 +344,10 @@ export const releaseCreateCommand = Command.make(
       Flag.withDescription("Release notes body (markdown)"),
       Flag.optional,
     ),
+    bodyFile: Flag.string("body-file").pipe(
+      Flag.withDescription("Read release notes body from a file path or '-' for stdin"),
+      Flag.optional,
+    ),
     draft: Flag.boolean("draft").pipe(
       Flag.withDescription("Create as draft release"),
       Flag.withDefault(false),
@@ -388,6 +393,7 @@ export const releaseCreateCommand = Command.make(
   },
   ({
     body,
+    bodyFile,
     draft,
     format,
     generateNotes,
@@ -402,10 +408,19 @@ export const releaseCreateCommand = Command.make(
     verifyTag,
   }) =>
     Effect.gen(function* () {
+      const resolvedBody = yield* resolveOptionalTextInput(
+        "gh-tool release create",
+        Option.getOrNull(body),
+        Option.getOrNull(bodyFile),
+        "--body",
+        "--body-file",
+        "body",
+      );
+
       const result = yield* createRelease({
         tag,
         title: Option.getOrNull(title),
-        body: Option.getOrNull(body),
+        body: resolvedBody,
         notesFile: Option.getOrNull(notesFile),
         draft,
         prerelease,
@@ -477,6 +492,10 @@ export const releaseEditCommand = Command.make(
       Flag.withDescription("New release notes body (markdown)"),
       Flag.optional,
     ),
+    bodyFile: Flag.string("body-file").pipe(
+      Flag.withDescription("Read release notes body from a file path or '-' for stdin"),
+      Flag.optional,
+    ),
     draft: Flag.boolean("draft").pipe(
       Flag.withDescription("Set draft status (true/false). Omit to keep current value"),
       Flag.optional,
@@ -497,12 +516,21 @@ export const releaseEditCommand = Command.make(
     tag: Flag.string("tag").pipe(Flag.withDescription("Release tag to edit (e.g., v1.2.3)")),
     title: Flag.string("title").pipe(Flag.withDescription("New release title"), Flag.optional),
   },
-  ({ body, draft, format, latest, prerelease, repo, tag, title }) =>
+  ({ body, bodyFile, draft, format, latest, prerelease, repo, tag, title }) =>
     Effect.gen(function* () {
+      const resolvedBody = yield* resolveOptionalTextInput(
+        "gh-tool release edit",
+        Option.getOrNull(body),
+        Option.getOrNull(bodyFile),
+        "--body",
+        "--body-file",
+        "body",
+      );
+
       const edited = yield* editRelease({
         tag,
         title: Option.getOrNull(title),
-        body: Option.getOrNull(body),
+        body: resolvedBody,
         draft: Option.getOrNull(draft),
         prerelease: Option.getOrNull(prerelease),
         latest: Option.getOrNull(latest),

package/src/gh-tool/text-input.ts

@@ -0,0 +1,146 @@
+import { Effect, Schema } from "effect";
+
+import { GitHubCommandError } from "#gh/errors";
+
+const STDIN_SENTINEL = "-";
+const SENSITIVE_PATH_PATTERNS = [/\.env(\..+)?$/, /\.envrc$/, /\.(pem|key|p12|pfx|cer|crt)$/i];
+const MissingMode = Schema.Literals(["error", "null", "default"]);
+
+const readTextFromStdin = () => Bun.stdin.text();
+
+const readTextFile = (filePath: string) => {
+  if (SENSITIVE_PATH_PATTERNS.some((pattern) => pattern.test(filePath))) {
+    return Promise.reject(new Error(`Refusing to read sensitive file: ${filePath}`));
+  }
+
+  return Bun.file(filePath).text();
+};
+
+const ensureResolvedText = (resolvedValue: string | null, context: string) => {
+  if (resolvedValue === null) {
+    throw new Error(`Invariant violation: ${context} resolved to null`);
+  }
+
+  return resolvedValue;
+};
+
+type ResolveTextInputOptions = {
+  command: string;
+  value: string | null;
+  fileValue: string | null;
+  valueFlag: string;
+  fileFlag: string;
+  missingMode: Schema.Schema.Type<typeof MissingMode>;
+  missingValue?: string;
+  label: string;
+};
+
+const resolveTextInputInternal = Effect.fn("gh.resolveTextInputInternal")(function* (
+  options: ResolveTextInputOptions,
+) {
+  const { command, fileFlag, fileValue, label, missingMode, missingValue, value, valueFlag } =
+    options;
+
+  if (value !== null && fileValue !== null) {
+    return yield* Effect.fail(
+      new GitHubCommandError({
+        command,
+        exitCode: 1,
+        stderr: `Provide exactly one of ${valueFlag} or ${fileFlag}`,
+        message: `Provide exactly one of ${valueFlag} or ${fileFlag}`,
+      }),
+    );
+  }
+
+  if (value !== null) {
+    return value;
+  }
+
+  if (fileValue !== null) {
+    const source = fileValue === STDIN_SENTINEL ? "stdin" : fileValue;
+
+    return yield* Effect.tryPromise({
+      try: () => (fileValue === STDIN_SENTINEL ? readTextFromStdin() : readTextFile(fileValue)),
+      catch: (error) =>
+        new GitHubCommandError({
+          command,
+          exitCode: 1,
+          stderr: `Failed to read ${label} from ${source}: ${error instanceof Error ? error.message : String(error)}`,
+          message: `Failed to read ${label} from ${source}: ${error instanceof Error ? error.message : String(error)}`,
+        }),
+    });
+  }
+
+  if (missingMode === "null") {
+    return null;
+  }
+
+  if (missingMode === "default") {
+    return missingValue ?? "";
+  }
+
+  return yield* Effect.fail(
+    new GitHubCommandError({
+      command,
+      exitCode: 1,
+      stderr: `Missing ${label}. Provide ${valueFlag} or ${fileFlag}`,
+      message: `Missing ${label}. Provide ${valueFlag} or ${fileFlag}`,
+    }),
+  );
+});
+
+export const resolveRequiredTextInput = (
+  command: string,
+  value: string | null,
+  fileValue: string | null,
+  valueFlag: string,
+  fileFlag: string,
+  label: string,
+): Effect.Effect<string, GitHubCommandError> =>
+  resolveTextInputInternal({
+    command,
+    value,
+    fileValue,
+    valueFlag,
+    fileFlag,
+    missingMode: "error",
+    label,
+  }).pipe(Effect.map((resolvedValue) => ensureResolvedText(resolvedValue, "required text input")));
+
+export const resolveOptionalTextInput = (
+  command: string,
+  value: string | null,
+  fileValue: string | null,
+  valueFlag: string,
+  fileFlag: string,
+  label: string,
+): Effect.Effect<string | null, GitHubCommandError> =>
+  resolveTextInputInternal({
+    command,
+    value,
+    fileValue,
+    valueFlag,
+    fileFlag,
+    missingMode: "null",
+    label,
+  });
+
+export const resolveDefaultTextInput = (
+  command: string,
+  value: string | null,
+  fileValue: string | null,
+  valueFlag: string,
+  fileFlag: string,
+  label: string,
+  defaultValue: string,
+): Effect.Effect<string, GitHubCommandError> =>
+  resolveTextInputInternal({
+    command,
+    value,
+    fileValue,
+    valueFlag,
+    fileFlag,
+    missingMode: "default",
+    missingValue: defaultValue,
+    label,
+  }).pipe(Effect.map((resolvedValue) => ensureResolvedText(resolvedValue, "default text input")));

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;