@blogic-cz/agent-tools 0.14.49 → 0.14.51

package/package.json

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

package/src/db-tool/index.ts

@@ -144,11 +144,94 @@ const envsCommand = Command.make(
   Command.withDescription("List configured database environments and the default (no network)"),
 );
 
+const ACTIVITY_SQL = `SELECT pid, usename AS "user", state,
+  date_trunc('second', now() - xact_start) AS xact_age,
+  date_trunc('second', now() - query_start) AS query_age,
+  wait_event_type, wait_event, left(query, 200) AS query
+FROM pg_stat_activity
+WHERE pid <> pg_backend_pid() AND state IS NOT NULL
+ORDER BY xact_start ASC NULLS LAST`;
+
+const LOCKS_SQL = `SELECT blocking.pid AS blocking_pid, blocking.usename AS blocking_user,
+  left(blocking.query, 150) AS blocking_query,
+  blocked.pid AS blocked_pid, blocked.usename AS blocked_user,
+  left(blocked.query, 150) AS blocked_query
+FROM pg_stat_activity blocked
+JOIN pg_stat_activity blocking ON blocking.pid = ANY(pg_blocking_pids(blocked.pid))
+ORDER BY blocking.pid, blocked.pid`;
+
+const GRANTS_SQL = `SELECT grantee, table_schema AS schema, 'table' AS kind, table_name AS object,
+  string_agg(privilege_type, ', ' ORDER BY privilege_type) AS privileges
+FROM information_schema.role_table_grants
+WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
+GROUP BY grantee, table_schema, table_name
+UNION ALL
+SELECT grantee, object_schema AS schema, 'sequence' AS kind, object_name AS object,
+  string_agg(privilege_type, ', ' ORDER BY privilege_type) AS privileges
+FROM information_schema.role_usage_grants
+WHERE object_type = 'SEQUENCE' AND object_schema NOT IN ('pg_catalog', 'information_schema')
+GROUP BY grantee, object_schema, object_name
+ORDER BY grantee, schema, kind, object`;
+
+const makeDiagnosticCommand = (name: string, description: string, sql: string) =>
+  Command.make(
+    name,
+    {
+      env: Flag.optional(Flag.string("env")).pipe(
+        Flag.withDescription(
+          "Target database environment name (e.g. local, test, prod). Falls back to defaultEnvironment in config.",
+        ),
+      ),
+      limit: Flag.optional(Flag.integer("limit")).pipe(
+        Flag.withDescription("Max rows to return (default 50). Use 0 for no cap."),
+      ),
+      format: formatOption,
+      profile: Flag.optional(Flag.string("profile")).pipe(
+        Flag.withDescription(
+          "Database profile name from agent-tools.json5 (if multiple configured)",
+        ),
+      ),
+    },
+    ({ env, limit, format }) =>
+      Effect.gen(function* () {
+        const resolvedEnv = yield* resolveEnv(env);
+        const db = yield* DbService;
+        const result = yield* db.executeQuery(resolvedEnv, sql, Option.getOrUndefined(limit));
+        yield* Console.log(formatOutput(result, format));
+      }),
+  ).pipe(Command.withDescription(description));
+
+const activityCommand = makeDiagnosticCommand(
+  "activity",
+  "Show live sessions from pg_stat_activity (state, transaction/query age, wait event), longest-running first",
+  ACTIVITY_SQL,
+);
+
+const locksCommand = makeDiagnosticCommand(
+  "locks",
+  "Show blocking chains (blocker -> blocked) from pg_blocking_pids + pg_stat_activity",
+  LOCKS_SQL,
+);
+
+const grantsCommand = makeDiagnosticCommand(
+  "grants",
+  "Show per-role table/sequence privileges by schema (excludes system schemas)",
+  GRANTS_SQL,
+);
+
 const commandsCommand = makeSchemaCommand(() => mainCommand);
 
 const mainCommand = Command.make("db-tool", {}).pipe(
   Command.withDescription("Database Query Tool for Coding Agents"),
-  Command.withSubcommands([sqlCommand, schemaCommand, envsCommand, commandsCommand]),
+  Command.withSubcommands([
+    sqlCommand,
+    schemaCommand,
+    activityCommand,
+    locksCommand,
+    grantsCommand,
+    envsCommand,
+    commandsCommand,
+  ]),
 );
 
 const cli = Command.run(mainCommand, {

package/src/gh-tool/index.ts

@@ -31,6 +31,7 @@ import {
   prIssueCommentsLatestCommand,
   prCommentCommand,
   prDiscussionSummaryCommand,
+  prFeedbackCommand,
   prReplyCommand,
   prResolveCommand,
   prReviewsCommand,
@@ -81,6 +82,7 @@ const prCommand = Command.make("pr", {}).pipe(
     prThreadsCommand,
     prCommentsCommand,
     prReviewsCommand,
+    prFeedbackCommand,
     prIssueCommentsCommand,
     prIssueCommentsLatestCommand,
     prCommentCommand,

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

@@ -44,6 +44,7 @@ import {
 import {
   fetchComments,
   fetchDiscussionSummary,
+  fetchFeedback,
   fetchIssueComments,
   fetchLatestIssueComment,
   fetchReviews,
@@ -102,13 +103,16 @@ export const parsePrNumbers = (input: string): readonly number[] =>
 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 [info, unresolvedThreads, visibleOpenThreads, summary, checks, reviews] = yield* Effect.all(
+    [
+      viewPR(prNumber),
+      fetchThreads(prNumber, true),
+      fetchThreads(prNumber, false, true),
+      fetchDiscussionSummary(prNumber),
+      fetchChecks(prNumber, false, false, 0),
+      fetchReviews(prNumber, null, null, null),
+    ],
+  );
   const classification = classifyReviewTriage(summary, checks);
 
   // Single merge-readiness verdict so agents stop re-stitching mergeable + checks + threads +
@@ -128,7 +132,16 @@ export const fetchReviewTriage = Effect.fn("pr.fetchReviewTriage")(function* (
     blocking,
   };
 
-  return { ready, classification, info, unresolvedThreads, visibleOpenThreads, summary, checks };
+  return {
+    ready,
+    classification,
+    info,
+    unresolvedThreads,
+    visibleOpenThreads,
+    summary,
+    checks,
+    reviews,
+  };
 });
 
 export const prViewCommand = Command.make(
@@ -650,6 +663,30 @@ export const prReviewsCommand = Command.make(
   ),
 );
 
+export const prFeedbackCommand = Command.make(
+  "feedback",
+  {
+    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 feedback = yield* fetchFeedback(Option.getOrNull(pr));
+        yield* logFormatted(feedback, format);
+      }),
+    ),
+).pipe(
+  Command.withDescription(
+    "Full review-response inventory in one call: submitted reviews + threads (with state) + inline comments + issue comments",
+  ),
+);
+
 export const prIssueCommentsCommand = Command.make(
   "issue-comments",
   {

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

@@ -7,6 +7,7 @@ export {
   prCreateCommand,
   prDiscussionSummaryCommand,
   prEditCommand,
+  prFeedbackCommand,
   prIssueCommentsCommand,
   prIssueCommentsLatestCommand,
   prListCommand,

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

@@ -464,6 +464,24 @@ export const fetchReviews = Effect.fn("pr.fetchReviews")(function* (
   return reviews;
 });
 
+/**
+ * Full review-response inventory for a PR in one call: submitted review summaries,
+ * all review threads with resolution state, inline review comments, and issue
+ * (discussion) comments. Collapses the four separate fetches agents otherwise stitch.
+ */
+export const fetchFeedback = Effect.fn("pr.fetchFeedback")(function* (pr: number | null) {
+  const resolvedPr = pr ?? (yield* viewPR(null)).number;
+
+  const [reviews, threads, inlineComments, issueComments] = yield* Effect.all([
+    fetchReviews(resolvedPr, null, null, null),
+    fetchThreads(resolvedPr, false),
+    fetchComments(resolvedPr, null),
+    fetchIssueComments(resolvedPr, null, null, null),
+  ]);
+
+  return { reviews, threads, inlineComments, issueComments };
+});
+
 export const fetchLatestIssueComment = Effect.fn("pr.fetchLatestIssueComment")(function* (
   pr: number | null,
   author: string | null,

package/src/gh-tool/workflow.ts

@@ -245,10 +245,39 @@ export const dispatchWorkflow = Effect.fn("workflow.dispatchWorkflow")(function*
 // then fall back to a one-shot snapshot so a timeout never returns nothing.
 const DEFAULT_WATCH_RUN_TIMEOUT_SECONDS = CI_CHECK_WATCH_TIMEOUT_MS / 1000;
 
+export const buildWatchResult = (
+  runId: number,
+  finalState: {
+    status: string;
+    conclusion: string | null;
+    jobs: ReadonlyArray<{ name: string; status: string; conclusion: string | null }>;
+  },
+  watchStdout: string | null,
+  frames: boolean,
+  timeoutSeconds: number,
+) => ({
+  runId,
+  status: finalState.status,
+  conclusion: finalState.conclusion,
+  jobs: finalState.jobs.map((job) => ({
+    name: job.name,
+    status: job.status,
+    conclusion: job.conclusion,
+  })),
+  ...(watchStdout === null
+    ? {
+        watchOutput: `(watch timed out after ${timeoutSeconds}s; status taken from snapshot — re-run to keep watching)`,
+      }
+    : frames
+      ? { watchOutput: watchStdout }
+      : {}),
+});
+
 const watchRun = Effect.fn("workflow.watchRun")(function* (
   runId: number,
   repo: string | null,
   timeoutSeconds: number,
+  frames: boolean,
 ) {
   const gh = yield* GitHubService;
 
@@ -277,20 +306,13 @@ const watchRun = Effect.fn("workflow.watchRun")(function* (
 
   const finalState = yield* viewRun(runId, repo);
 
-  return {
+  return buildWatchResult(
     runId,
-    status: finalState.status,
-    conclusion: finalState.conclusion,
-    jobs: finalState.jobs.map((job) => ({
-      name: job.name,
-      status: job.status,
-      conclusion: job.conclusion,
-    })),
-    watchOutput:
-      result === null
-        ? `(watch timed out after ${timeoutSeconds}s; status taken from snapshot — re-run to keep watching)`
-        : result.stdout,
-  };
+    finalState,
+    result === null ? null : result.stdout,
+    frames,
+    timeoutSeconds,
+  );
 });
 
 const fetchAnnotations = Effect.fn("workflow.fetchAnnotations")(function* (opts: {
@@ -712,6 +734,11 @@ export const workflowWatchCommand = Command.make(
   "watch",
   {
     format: formatOption,
+    frames: Flag.boolean("frames").pipe(
+      Flag.withDescription(
+        "Include the raw watch progress frames (large); omitted by default — final status/conclusion/jobs are always returned",
+      ),
+    ),
     repo: repoOption,
     run: Flag.integer("run").pipe(Flag.withDescription("Workflow run ID to watch")),
     timeout: Flag.integer("timeout").pipe(
@@ -725,10 +752,10 @@ export const workflowWatchCommand = Command.make(
       ),
     ),
   },
-  ({ format, repo, run, timeout }) =>
+  ({ format, frames, repo, run, timeout }) =>
     Effect.gen(function* () {
       const resolvedRepo = yield* resolveRepoArg(repo);
-      const result = yield* watchRun(run, resolvedRepo, timeout);
+      const result = yield* watchRun(run, resolvedRepo, timeout, frames);
       yield* logFormatted(result, format);
     }),
 ).pipe(Command.withDescription("Watch a workflow run until it completes, then show final status"));