@blogic-cz/agent-tools 0.8.15 → 0.8.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blogic-cz/agent-tools",
-  "version": "0.8.15",
+  "version": "0.8.17",
   "description": "CLI tools for AI coding agent workflows — GitHub, database, Kubernetes, Azure DevOps, logs, sessions, and audit",
   "keywords": [
     "agent",
@@ -116,22 +116,26 @@
     "lint": "oxlint -c ./.oxlintrc.json --deny-warnings",
     "lint:fix": "oxlint -c ./.oxlintrc.json --fix",
     "session-tool": "bun src/session-tool/index.ts",
+    "update:packages": "bun update -i -r",
     "update:skills": "bun run .agents/skills/update-packages/references/skills-update-local.ts",
     "test": "vitest run"
   },
   "dependencies": {
-    "@effect/platform-bun": "4.0.0-beta.25",
+    "@effect/platform-bun": "4.0.0-beta.48",
     "@toon-format/toon": "2.1.0",
-    "effect": "4.0.0-beta.25"
+    "effect": "4.0.0-beta.48"
   },
   "devDependencies": {
-    "@effect/language-service": "0.77.0",
-    "@effect/vitest": "4.0.0-beta.25",
-    "@types/bun": "1.3.9",
-    "oxfmt": "0.35.0",
-    "oxlint": "1.50.0",
-    "typescript": "5.9.3",
-    "vitest": "^4.0.18"
+    "@effect/language-service": "0.85.1",
+    "@effect/vitest": "4.0.0-beta.48",
+    "@types/bun": "1.3.12",
+    "oxfmt": "0.44.0",
+    "oxlint": "1.59.0",
+    "typescript": "6.0.2",
+    "vitest": "^4.1.4"
+  },
+  "overrides": {
+    "@effect/platform-node-shared": "4.0.0-beta.48"
   },
   "engines": {
     "bun": ">=1.0.0"

package/src/az-tool/service.ts

@@ -1,5 +1,5 @@
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-import { Effect, Layer, ServiceMap, Stream, Option } from "effect";
+import { Context, Effect, Layer, Option, Stream } from "effect";
 
 import type { InvokeParams } from "./types";
 import type { AzureConfig } from "#config/types";
@@ -10,7 +10,7 @@ import { isCommandAllowed, isInvokeAllowed } from "./security";
 import { transformCmdOutput } from "./transformers";
 import { ConfigService, getToolConfig } from "#config";
 
-export class AzService extends ServiceMap.Service<
+export class AzService extends Context.Service<
   AzService,
   {
     readonly runCommand: (

package/src/config/loader.ts

@@ -1,6 +1,6 @@
 import { dirname } from "node:path";
 
-import { Data, Effect, Layer, Schema, ServiceMap } from "effect";
+import { Context, Data, Effect, Layer, Schema } from "effect";
 
 import type { AgentToolsConfig, GitHubRepoConfig } from "./types";
 
@@ -159,10 +159,9 @@ export async function loadConfig(): Promise<AgentToolsConfig | undefined> {
   return decodeConfig(parsed, configPath);
 }
 
-export class ConfigService extends ServiceMap.Service<
-  ConfigService,
-  AgentToolsConfig | undefined
->()("@agent-tools/ConfigService") {}
+export class ConfigService extends Context.Service<ConfigService, AgentToolsConfig | undefined>()(
+  "@agent-tools/ConfigService",
+) {}
 
 export class ConfigLoadError extends Data.TaggedError("ConfigLoadError")<{
   readonly cause: unknown;

package/src/db-tool/config-service.ts

@@ -1,4 +1,4 @@
-import { Effect, Layer, ServiceMap } from "effect";
+import { Context, Effect, Layer } from "effect";
 
 import { ConfigService, getToolConfig } from "#config";
 import type { DatabaseConfig } from "#config";
@@ -12,10 +12,9 @@ import type { DatabaseConfig } from "#config";
  *   const dbConfig = yield* DbConfigService;
  *   if (!dbConfig) { // no config }
  */
-export class DbConfigService extends ServiceMap.Service<
-  DbConfigService,
-  DatabaseConfig | undefined
->()("@agent-tools/DbConfigService") {}
+export class DbConfigService extends Context.Service<DbConfigService, DatabaseConfig | undefined>()(
+  "@agent-tools/DbConfigService",
+) {}
 
 /**
  * Creates a DbConfigService layer that resolves the database config

package/src/db-tool/service.ts

@@ -1,5 +1,5 @@
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-import { Clock, Duration, Effect, Layer, Ref, ServiceMap, Stream } from "effect";
+import { Clock, Context, Duration, Effect, Layer, Ref, Stream } from "effect";
 
 import type { DbConfig, QueryResult, SchemaMode } from "./types";
 
@@ -33,7 +33,7 @@ export function resolveDbAccessMode(
   };
 }
 
-export class DbService extends ServiceMap.Service<
+export class DbService extends Context.Service<
   DbService,
   {
     readonly executeQuery: (env: string, sql: string) => Effect.Effect<QueryResult, DbError>;

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 { Console, Effect, Option, Result } from "effect";
+
+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;
 
@@ -433,7 +610,7 @@ export const fetchChecks = Effect.fn("pr.fetchChecks")(function* (
     yield* gh.runGh(watchArgs).pipe(
       Effect.timeoutOrElse({
         duration: timeoutMs,
-        onTimeout: () =>
+        orElse: () =>
           Effect.fail(
             new GitHubTimeoutError({
               message: `CI check monitoring timed out after ${timeoutSeconds}s`,
@@ -446,22 +623,55 @@ 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.result,
+    Effect.flatMap((result) => {
+      if (Result.isFailure(result) && result.failure._tag !== "GitHubCommandError") {
+        return Effect.fail(result.failure);
+      }
+
+      return Effect.succeed(result);
+    }),
+  );
+
+  if (Result.isSuccess(watchedChecks)) {
+    return watchedChecks.success;
+  }
+
+  const finalChecks = yield* fetchCheckResults(pr);
+  if (finalChecks.some((check) => check.bucket === "fail")) {
+    return yield* buildFailedChecksReport(pr, finalChecks);
+  }
+
+  return yield* Effect.fail(watchedChecks.failure);
 });
 
 export const rerunChecks = Effect.fn("pr.rerunChecks")(function* (

package/src/gh-tool/service.ts

@@ -1,5 +1,5 @@
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-import { Effect, Layer, ServiceMap, Stream } from "effect";
+import { Context, Effect, Layer, Stream } from "effect";
 
 import type { RepoInfo } from "./types";
 
@@ -15,7 +15,7 @@ type GhResult = {
 
 type GhError = GitHubCommandError | GitHubAuthError | GitHubNotFoundError;
 
-export class GitHubService extends ServiceMap.Service<
+export class GitHubService extends Context.Service<
   GitHubService,
   {
     readonly runGh: (args: string[]) => Effect.Effect<GhResult, GhError>;

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;

package/src/k8s-tool/service.ts

@@ -1,5 +1,5 @@
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-import { Effect, Layer, Option, Ref, ServiceMap, Stream } from "effect";
+import { Context, Effect, Layer, Option, Ref, Stream } from "effect";
 
 import type { CommandResult, Environment } from "./types";
 
@@ -13,7 +13,7 @@ import { ConfigService, getToolConfig } from "#config";
 import type { K8sConfig } from "#config";
 import { isKubectlCommandAllowed } from "./security";
 
-export class K8sService extends ServiceMap.Service<
+export class K8sService extends Context.Service<
   K8sService,
   {
     readonly runCommand: (

package/src/logs-tool/service.ts

@@ -1,5 +1,5 @@
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-import { Effect, Layer, Result, ServiceMap, Stream } from "effect";
+import { Context, Effect, Layer, Result, Stream } from "effect";
 
 import type { Environment, LogFile, ReadOptions } from "./types";
 
@@ -47,7 +47,7 @@ export const sanitizeShellArg = (input: string): string => `'${input.replace(/'/
 
 const readCommandOutput = (output: unknown): string => (typeof output === "string" ? output : "");
 
-export class LogsService extends ServiceMap.Service<
+export class LogsService extends Context.Service<
   LogsService,
   {
     readonly listLogs: (env: Environment, profile?: string) => Effect.Effect<LogFile[], LogsError>;

package/src/session-tool/config.ts

@@ -1,4 +1,4 @@
-import { Effect, Layer, ServiceMap } from "effect";
+import { Context, Effect, Layer } from "effect";
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -38,7 +38,7 @@ export const resolveSessionsPath = Effect.gen(function* () {
 /**
  * Context tag for resolved paths (cached during effect execution).
  */
-export class ResolvedPaths extends ServiceMap.Service<
+export class ResolvedPaths extends Context.Service<
   ResolvedPaths,
   {
     readonly messagesPath: string;

package/src/session-tool/service.ts

@@ -1,4 +1,4 @@
-import { Effect, Layer, ServiceMap } from "effect";
+import { Context, Effect, Layer } from "effect";
 import { readdir } from "node:fs/promises";
 
 import type { MessageSummary, SessionInfo } from "./types";
@@ -142,7 +142,7 @@ const readJsonFilesFlat = (dir: string): Effect.Effect<FileEntry[], SessionError
       }),
   });
 
-export class SessionService extends ServiceMap.Service<
+export class SessionService extends Context.Service<
   SessionService,
   {
     readonly getSessionsForProject: (

package/src/shared/audit.ts

@@ -3,7 +3,7 @@ import { mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
 
-import { Cause, Effect, Layer, ServiceMap } from "effect";
+import { Cause, Context, Effect, Layer } from "effect";
 
 import { loadConfig } from "#config";
 
@@ -65,7 +65,7 @@ type TableInfoRow = {
   name: string;
 };
 
-export class AuditService extends ServiceMap.Service<AuditService, AuditServiceShape>()(
+export class AuditService extends Context.Service<AuditService, AuditServiceShape>()(
   "@agent-tools/AuditService",
 ) {}