@blogic-cz/agent-tools 0.8.2 → 0.8.4

package/package.json

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

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

@@ -19,10 +19,10 @@ import { viewPR } from "./core";
 // ---------------------------------------------------------------------------
 
 const REVIEW_THREADS_QUERY = `
-  query($owner: String!, $name: String!, $pr: Int!) {
+  query($owner: String!, $name: String!, $pr: Int!, $after: String) {
     repository(owner: $owner, name: $name) {
       pullRequest(number: $pr) {
-        reviewThreads(first: 100) {
+        reviewThreads(first: 100, after: $after) {
           nodes {
             id
             isResolved
@@ -37,6 +37,10 @@ const REVIEW_THREADS_QUERY = `
               }
             }
           }
+          pageInfo {
+            hasNextPage
+            endCursor
+          }
         }
       }
     }
@@ -100,6 +104,10 @@ type ThreadsQueryResult = {
     pullRequest: {
       reviewThreads: {
         nodes: ThreadNode[];
+        pageInfo: {
+          hasNextPage: boolean;
+          endCursor: string | null;
+        };
       };
     };
   };
@@ -156,6 +164,78 @@ type ReviewCommentById = {
   pull_request_url: string;
 };
 
+const REST_PAGE_SIZE = 100;
+
+const parseJson = <T>(
+  stdout: string,
+  command: string,
+  parseFailurePrefix: string,
+): Effect.Effect<T, GitHubCommandError> =>
+  Effect.try({
+    try: () => JSON.parse(stdout) as T,
+    catch: (error) =>
+      new GitHubCommandError({
+        command,
+        exitCode: 0,
+        stderr: `${parseFailurePrefix}: ${error instanceof Error ? error.message : String(error)}`,
+        message: `${parseFailurePrefix}: ${error instanceof Error ? error.message : String(error)}`,
+      }),
+  });
+
+const fetchAllRestPages = Effect.fn("pr.fetchAllRestPages")(function* <T>(
+  endpoint: string,
+  command: string,
+  parseFailurePrefix: string,
+) {
+  const service = yield* GitHubService;
+
+  const results: T[] = [];
+  let page = 1;
+
+  while (true) {
+    const separator = endpoint.includes("?") ? "&" : "?";
+    const result = yield* service.runGh([
+      "api",
+      `${endpoint}${separator}per_page=${REST_PAGE_SIZE}&page=${page}`,
+    ]);
+
+    const rawPage = yield* parseJson<T[]>(result.stdout, command, parseFailurePrefix);
+    results.push(...rawPage);
+
+    if (rawPage.length < REST_PAGE_SIZE) {
+      return results;
+    }
+
+    page += 1;
+  }
+});
+
+const fetchAllThreadNodes = Effect.fn("pr.fetchAllThreadNodes")(function* (pr: number) {
+  const service = yield* GitHubService;
+  const repoInfo = yield* service.getRepoInfo();
+
+  const nodes: ThreadNode[] = [];
+  let after: string | null = null;
+
+  while (true) {
+    const response = (yield* service.runGraphQL(REVIEW_THREADS_QUERY, {
+      owner: repoInfo.owner,
+      name: repoInfo.name,
+      pr,
+      after,
+    })) as ThreadsQueryResult;
+
+    const page = response.repository.pullRequest.reviewThreads;
+    nodes.push(...page.nodes);
+
+    if (!page.pageInfo.hasNextPage || page.pageInfo.endCursor === null) {
+      return nodes;
+    }
+
+    after = page.pageInfo.endCursor;
+  }
+});
+
 // ---------------------------------------------------------------------------
 // Handlers
 // ---------------------------------------------------------------------------
@@ -176,18 +256,8 @@ export const fetchThreads = Effect.fn("pr.fetchThreads")(function* (
   pr: number | null,
   unresolvedOnly: boolean,
 ) {
-  const service = yield* GitHubService;
-  const repoInfo = yield* service.getRepoInfo();
-
   const resolvedPr = pr ?? (yield* viewPR(null)).number;
-
-  const response = (yield* service.runGraphQL(REVIEW_THREADS_QUERY, {
-    owner: repoInfo.owner,
-    name: repoInfo.name,
-    pr: resolvedPr,
-  })) as ThreadsQueryResult;
-
-  const threads = response.repository.pullRequest.reviewThreads.nodes;
+  const threads = yield* fetchAllThreadNodes(resolvedPr);
 
   const mapped: ReviewThread[] = threads
     .map((node) => {
@@ -223,21 +293,11 @@ export const fetchComments = Effect.fn("pr.fetchComments")(function* (
 
   const resolvedPr = pr ?? (yield* viewPR(null)).number;
 
-  const result = yield* service.runGh([
-    "api",
+  const raw = yield* fetchAllRestPages<RawReviewComment>(
     `repos/${repoInfo.owner}/${repoInfo.name}/pulls/${resolvedPr}/comments`,
-  ]);
-
-  const raw = yield* Effect.try({
-    try: () => JSON.parse(result.stdout) as RawReviewComment[],
-    catch: (error) =>
-      new GitHubCommandError({
-        command: "gh-tool pr comments",
-        exitCode: 0,
-        stderr: `Failed to parse response: ${error instanceof Error ? error.message : String(error)}`,
-        message: `Failed to parse response: ${error instanceof Error ? error.message : String(error)}`,
-      }),
-  });
+    "gh-tool pr comments",
+    "Failed to parse response",
+  );
 
   const comments: ReviewComment[] = raw.map((c) => ({
     id: c.id,
@@ -272,21 +332,11 @@ export const fetchIssueComments = Effect.fn("pr.fetchIssueComments")(function* (
 
   const resolvedPr = pr ?? (yield* viewPR(null)).number;
 
-  const result = yield* service.runGh([
-    "api",
+  const raw = yield* fetchAllRestPages<RawIssueComment>(
     `repos/${repoInfo.owner}/${repoInfo.name}/issues/${resolvedPr}/comments`,
-  ]);
-
-  const raw = yield* Effect.try({
-    try: () => JSON.parse(result.stdout) as RawIssueComment[],
-    catch: (error) =>
-      new GitHubCommandError({
-        command: "gh-tool pr issue-comments",
-        exitCode: 0,
-        stderr: `Failed to parse response: ${error instanceof Error ? error.message : String(error)}`,
-        message: `Failed to parse response: ${error instanceof Error ? error.message : String(error)}`,
-      }),
-  });
+    "gh-tool pr issue-comments",
+    "Failed to parse response",
+  );
 
   let comments = raw.map(mapRawIssueComment);
 
@@ -388,12 +438,30 @@ export const fetchDiscussionSummary = Effect.fn("pr.fetchDiscussionSummary")(fun
             : current,
         );
 
+  const repliedThreadCommentIds = new Set(
+    reviewComments
+      .filter((comment) => comment.inReplyToId !== null)
+      .map((comment) => comment.inReplyToId),
+  );
+
+  const unrepliedReviewThreadsCount = threads.filter(
+    (thread) => !repliedThreadCommentIds.has(thread.commentId),
+  ).length;
+
   return {
     issueCommentsCount: issueComments.length,
     latestIssueComment,
     reviewCommentsCount: reviewComments.length,
     reviewThreadsCount: threads.length,
+    repliedReviewThreadsCount: threads.length - unrepliedReviewThreadsCount,
+    unrepliedReviewThreadsCount,
+    resolvedUnrepliedReviewThreadsCount: threads.filter(
+      (thread) => thread.isResolved && !repliedThreadCommentIds.has(thread.commentId),
+    ).length,
     unresolvedReviewThreadsCount: threads.filter((thread) => !thread.isResolved).length,
+    unresolvedUnrepliedReviewThreadsCount: threads.filter(
+      (thread) => !thread.isResolved && !repliedThreadCommentIds.has(thread.commentId),
+    ).length,
   };
 });
 

package/src/gh-tool/service.ts

@@ -22,7 +22,7 @@ export class GitHubService extends ServiceMap.Service<
     readonly runGhJson: <T>(args: string[]) => Effect.Effect<T, GhError>;
     readonly runGraphQL: (
       query: string,
-      variables: Record<string, string | number>,
+      variables: Record<string, string | number | null>,
     ) => Effect.Effect<unknown, GhError>;
     readonly getRepoInfo: () => Effect.Effect<RepoInfo, GhError>;
   }
@@ -135,11 +135,15 @@ export class GitHubService extends ServiceMap.Service<
 
         const runGraphQL = Effect.fn("GitHubService.runGraphQL")(function* (
           query: string,
-          variables: Record<string, string | number>,
+          variables: Record<string, string | number | null>,
         ) {
           const args = ["api", "graphql", "-f", `query=${query}`];
 
           for (const [key, value] of Object.entries(variables)) {
+            if (value === null) {
+              continue;
+            }
+
             if (typeof value === "number") {
               args.push("-F", `${key}=${value}`);
             } else {

package/src/shared/index.ts

@@ -24,3 +24,5 @@ export {
   stripEmptyColumns,
   truncateRows,
 } from "./transform";
+
+export { transformLogOutput } from "./log-transform";

package/src/shared/log-transform.ts

@@ -0,0 +1,240 @@
+import { deduplicateLines } from "./transform";
+
+type LogLevel = "ERROR" | "WARN" | "INFO" | "DEBUG";
+
+type ParsedLogLine = {
+  level: LogLevel;
+  timestamp?: string;
+  message: string;
+  originalIndex: number;
+};
+
+const TIMESTAMP_FIELDS = ["timestamp", "ts", "time", "@timestamp", "datetime"] as const;
+const LEVEL_FIELDS = ["level", "severity", "lvl", "log.level"] as const;
+const MESSAGE_FIELDS = ["message", "msg", "log", "text"] as const;
+const ERROR_FIELDS = ["error", "err", "stack", "exception", "error.message"] as const;
+
+const LEVEL_ORDER: ReadonlyArray<LogLevel> = ["ERROR", "WARN", "INFO", "DEBUG"];
+
+function getByPath(obj: unknown, path: string): unknown {
+  if (typeof obj !== "object" || obj === null) {
+    return undefined;
+  }
+
+  if (!path.includes(".")) {
+    return (obj as Record<string, unknown>)[path];
+  }
+
+  const parts = path.split(".");
+  let current: unknown = obj;
+
+  for (const part of parts) {
+    if (typeof current !== "object" || current === null) {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[part];
+  }
+
+  return current;
+}
+
+function toText(value: unknown): string | undefined {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+  }
+
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+
+  if (value && typeof value === "object") {
+    if ("message" in value) {
+      const nestedMessage = toText((value as Record<string, unknown>).message);
+      if (nestedMessage) {
+        return nestedMessage;
+      }
+    }
+
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return undefined;
+    }
+  }
+
+  return undefined;
+}
+
+function formatTimestamp(value: unknown): string | undefined {
+  if (typeof value === "number" && value > 1_000_000_000_000) {
+    return new Date(value).toISOString();
+  }
+  if (typeof value === "number" && value > 1_000_000_000) {
+    return new Date(value * 1000).toISOString();
+  }
+  return undefined;
+}
+
+function firstMappedField(
+  obj: unknown,
+  fields: ReadonlyArray<string>,
+  isTimestamp = false,
+): string | undefined {
+  for (const field of fields) {
+    const raw = getByPath(obj, field);
+    if (isTimestamp) {
+      const formatted = formatTimestamp(raw);
+      if (formatted) return formatted;
+    }
+    const value = toText(raw);
+    if (value) {
+      return value;
+    }
+  }
+
+  return undefined;
+}
+
+// Pino numeric levels: 10=trace, 20=debug, 30=info, 40=warn, 50=error, 60=fatal
+function normalizeLevel(rawLevel: string | undefined): LogLevel {
+  const normalized = rawLevel?.trim().toLowerCase();
+
+  if (!normalized) {
+    return "INFO";
+  }
+
+  const numericLevel = Number(normalized);
+  if (Number.isFinite(numericLevel)) {
+    if (numericLevel >= 50) return "ERROR";
+    if (numericLevel >= 40) return "WARN";
+    if (numericLevel >= 30) return "INFO";
+    return "DEBUG";
+  }
+
+  if (normalized === "error" || normalized === "err" || normalized === "fatal") {
+    return "ERROR";
+  }
+
+  if (normalized === "warn" || normalized === "warning") {
+    return "WARN";
+  }
+
+  if (normalized === "info") {
+    return "INFO";
+  }
+
+  if (normalized === "debug" || normalized === "trace") {
+    return "DEBUG";
+  }
+
+  return "INFO";
+}
+
+function formatLine({ level, timestamp, message }: ParsedLogLine): string {
+  if (timestamp) {
+    return `[${timestamp}] [${level}] ${message}`;
+  }
+
+  return `[${level}] ${message}`;
+}
+
+function parseJsonLogLine(line: string, originalIndex: number): ParsedLogLine {
+  try {
+    const parsed = JSON.parse(line) as unknown;
+    const timestamp = firstMappedField(parsed, TIMESTAMP_FIELDS, true);
+    const level = normalizeLevel(firstMappedField(parsed, LEVEL_FIELDS));
+    const message =
+      firstMappedField(parsed, MESSAGE_FIELDS) ??
+      firstMappedField(parsed, ERROR_FIELDS) ??
+      line.trim();
+
+    return {
+      level,
+      timestamp,
+      message,
+      originalIndex,
+    };
+  } catch {
+    return {
+      level: "INFO",
+      message: line.trim(),
+      originalIndex,
+    };
+  }
+}
+
+function isJsonMode(lines: ReadonlyArray<string>): boolean {
+  const firstNonEmpty = lines.find((line) => line.trim().length > 0);
+  if (!firstNonEmpty) {
+    return false;
+  }
+
+  try {
+    const parsed = JSON.parse(firstNonEmpty) as unknown;
+    return typeof parsed === "object" && parsed !== null;
+  } catch {
+    return false;
+  }
+}
+
+function groupHeader(level: LogLevel, count: number): string {
+  switch (level) {
+    case "ERROR":
+      return `--- errors (${count}) ---`;
+    case "WARN":
+      return `--- warnings (${count}) ---`;
+    case "INFO":
+      return `--- info (${count}) ---`;
+    case "DEBUG":
+      return `--- debug (${count}) ---`;
+  }
+}
+
+function transformJsonLines(lines: ReadonlyArray<string>): string {
+  const parsedLines = lines
+    .map((line, originalIndex) => ({ line, originalIndex }))
+    .filter(({ line }) => line.trim().length > 0)
+    .map(({ line, originalIndex }) => parseJsonLogLine(line, originalIndex));
+
+  if (parsedLines.length === 0) {
+    return "";
+  }
+
+  const ordered = LEVEL_ORDER.flatMap((level) =>
+    parsedLines
+      .filter((entry) => entry.level === level)
+      .sort((a, b) => a.originalIndex - b.originalIndex),
+  );
+
+  const output: Array<string> = [];
+
+  for (const level of LEVEL_ORDER) {
+    const group = ordered.filter((entry) => entry.level === level);
+    if (group.length === 0) {
+      continue;
+    }
+
+    output.push(groupHeader(level, group.length));
+    output.push(...group.map(formatLine));
+  }
+
+  return deduplicateLines(output.join("\n"));
+}
+
+export function transformLogOutput(rawOutput: string): string {
+  if (rawOutput.length === 0) {
+    return "";
+  }
+
+  const lines = rawOutput.split(/\r?\n/);
+
+  if (isJsonMode(lines)) {
+    return transformJsonLines(lines);
+  }
+
+  return deduplicateLines(rawOutput, {
+    normalizeTimestamps: true,
+    normalizeUUIDs: true,
+  });
+}