@blogic-cz/agent-tools 0.7.0 → 0.8.0

package/package.json

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

package/src/az-tool/build.ts

@@ -4,6 +4,7 @@ import type { BuildJob, BuildLogs, BuildTimeline, JobSummary, PipelineRun } from
 
 import { AzParseError } from "./errors";
 import { AzService } from "./service";
+import { transformBuildLogContent, transformTimeline } from "./transformers";
 
 /**
  * Get build timeline with all records (jobs, stages, tasks, etc.)
@@ -59,7 +60,10 @@ export const getBuildTimeline = Effect.fn("Build.getBuildTimeline")(function* (b
     ),
   );
 
-  return parsed as BuildTimeline;
+  return {
+    ...parsed,
+    records: transformTimeline(parsed.records as BuildJob[]),
+  } as BuildTimeline;
 });
 
 /**
@@ -151,14 +155,14 @@ export const getBuildLogContent = Effect.fn("Build.getBuildLogContent")(function
   );
 
   if (typeof parsed === "string") {
-    return parsed;
+    return transformBuildLogContent(parsed);
   }
 
   if (!Array.isArray(parsed.value)) {
     return "";
   }
 
-  return parsed.value.join("\n");
+  return transformBuildLogContent(parsed.value.join("\n"));
 });
 
 /**

package/src/az-tool/service.ts

@@ -7,6 +7,7 @@ import type { AzureConfig } from "#config/types";
 import { DIRECT_AZ_COMMANDS, STANDALONE_AZ_COMMANDS } from "./config";
 import { AzSecurityError, AzCommandError, AzTimeoutError, AzParseError } from "./errors";
 import { isCommandAllowed, isInvokeAllowed } from "./security";
+import { transformCmdOutput } from "./transformers";
 import { ConfigService, getToolConfig } from "#config";
 
 export class AzService extends ServiceMap.Service<
@@ -144,7 +145,14 @@ export class AzService extends ServiceMap.Service<
           });
         }
 
-        return result.stdout;
+        const output = result.stdout.trim();
+        const transformed = transformCmdOutput(output);
+
+        if (typeof transformed === "string") {
+          return transformed;
+        }
+
+        return JSON.stringify(transformed);
       });
 
       const runInvoke = Effect.fn("AzService.runInvoke")(function* (params: InvokeParams) {

package/src/az-tool/transformers.ts

@@ -0,0 +1,127 @@
+import { deduplicateLines, parseTextTable } from "#shared";
+
+import type { BuildJob } from "./types";
+
+type ParsedTable = {
+  headers: string[];
+  rows: Record<string, string>[];
+};
+
+const TIMESTAMP_PREFIX_PATTERN = /^\d{4}-\d{2}-\d{2}T[\d:.]+Z\s+/;
+
+const TIMESTAMP_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}T[\d:.]+Z\s+$/;
+
+const ERROR_MARKER_PATTERN = /(##\[error\]|error:|Error:|ERROR|FAILED)/;
+
+function stripTimestampPrefix(line: string): string {
+  return line.replace(TIMESTAMP_PREFIX_PATTERN, "");
+}
+
+function isNoiseLine(line: string): boolean {
+  const trimmed = stripTimestampPrefix(line).trimStart();
+
+  if (trimmed.startsWith("##[section]")) {
+    return true;
+  }
+
+  if (trimmed.startsWith("##[debug]")) {
+    return true;
+  }
+
+  if (/^Downloading\b/i.test(trimmed)) {
+    return true;
+  }
+
+  return TIMESTAMP_ONLY_PATTERN.test(line);
+}
+
+function looksLikeTextTable(text: string): boolean {
+  const firstLine = text.split(/\r?\n/, 1)[0]?.trimEnd() ?? "";
+
+  if (firstLine.length === 0) {
+    return false;
+  }
+
+  return /^[A-Z][A-Z0-9_ -]*(\s{2,}[A-Z][A-Z0-9_ -]*)+$/.test(firstLine);
+}
+
+export function transformBuildLogContent(rawLog: string): string {
+  if (rawLog.length === 0) {
+    return "";
+  }
+
+  const hadTrailingNewline = rawLog.endsWith("\n");
+
+  const deduplicated = deduplicateLines(rawLog, {
+    normalizeTimestamps: true,
+    normalizeUUIDs: true,
+  });
+
+  const keptLines = deduplicated
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter((line) => line.length > 0)
+    .filter((line) => !isNoiseLine(line));
+
+  const errorLines: string[] = [];
+  const nonErrorLines: string[] = [];
+
+  for (const line of keptLines) {
+    if (ERROR_MARKER_PATTERN.test(line)) {
+      errorLines.push(line);
+    } else {
+      nonErrorLines.push(line);
+    }
+  }
+
+  const transformed = [...errorLines, ...nonErrorLines].join("\n");
+
+  if (hadTrailingNewline && transformed.length > 0) {
+    return `${transformed}\n`;
+  }
+
+  return transformed;
+}
+
+export function transformCmdOutput(
+  rawOutput: string,
+): string | Record<string, unknown> | unknown[] | ParsedTable {
+  if (rawOutput.length === 0) {
+    return "";
+  }
+
+  const trimmed = rawOutput.trim();
+
+  const parsedJson = (() => {
+    try {
+      return JSON.parse(trimmed) as unknown;
+    } catch {
+      return undefined;
+    }
+  })();
+
+  if (typeof parsedJson === "object" && parsedJson !== null) {
+    return parsedJson as Record<string, unknown> | unknown[];
+  }
+
+  if (looksLikeTextTable(trimmed)) {
+    return parseTextTable(trimmed);
+  }
+
+  const lineCount = trimmed.split(/\r?\n/).length;
+  if (lineCount > 50) {
+    return deduplicateLines(trimmed);
+  }
+
+  return trimmed;
+}
+
+export function transformTimeline(records: BuildJob[]): BuildJob[] {
+  return records.filter((record) => {
+    if (record.type === "Stage" || record.type === "Job") {
+      return true;
+    }
+
+    return (record.errorCount ?? 0) > 0 || (record.warningCount ?? 0) > 0;
+  });
+}

package/src/credential-guard/index.ts

@@ -392,8 +392,7 @@ export function createCredentialGuard(config?: CredentialGuardConfig): Credentia
           `\u{1F6AB} Access blocked: "${filePath}" is a sensitive file.\n\n` +
             `This file may contain credentials or secrets.\n` +
             `If you need this file's content, ask the user to provide relevant parts.\n\n` +
-            `Think this should be allowed? See https://github.com/blogic-cz/agent-tools — fork, extend the guard, and submit a PR.\n` +
-            `→ Skill "agent-tools"`,
+            `Think this should be allowed? See https://github.com/blogic-cz/agent-tools — fork, extend the guard, and submit a PR.`,
         );
       }
     }
@@ -409,8 +408,7 @@ export function createCredentialGuard(config?: CredentialGuardConfig): Credentia
               `\u{1F6AB} Secret detected: Potential ${detected.name} found in content.\n\n` +
                 `Matched: ${detected.match}\n\n` +
                 `Never commit secrets to code. Use environment variables or secret managers.\n\n` +
-                `Think this is a false positive? See https://github.com/blogic-cz/agent-tools — fork, fix the pattern, and submit a PR.\n` +
-                `→ Skill "agent-tools"`,
+                `Think this is a false positive? See https://github.com/blogic-cz/agent-tools — fork, fix the pattern, and submit a PR.`,
             );
           }
         }
@@ -425,8 +423,7 @@ export function createCredentialGuard(config?: CredentialGuardConfig): Credentia
           `\u{1F6AB} Command blocked: This command might expose secrets.\n\n` +
             `Command: ${command}\n\n` +
             `If you need environment info, ask the user directly.\n\n` +
-            `Think this is wrong? See https://github.com/blogic-cz/agent-tools — fork, adjust the patterns, and submit a PR.\n` +
-            `→ Skill "agent-tools"`,
+            `Think this is wrong? See https://github.com/blogic-cz/agent-tools — fork, adjust the patterns, and submit a PR.`,
         );
       }
 
@@ -436,20 +433,20 @@ export function createCredentialGuard(config?: CredentialGuardConfig): Credentia
           `\u{26A0}\u{FE0F} Sleep-polling detected.\n\n` +
             `Instead of polling with sleep, use the built-in watch command:\n\n` +
             `Use instead: ${sleepSuggestion}\n\n` +
-            `Watch commands block until completion — no polling needed.\n\n` +
-            `→ Skill "agent-tools"`,
+            `Watch commands block until completion — no polling needed.`,
         );
       }
 
       const blockedTool = getBlockedCliTool(command);
       if (blockedTool) {
+        const skillName = blockedTool.wrapper.replace("agent-tools-", "") + "-tool";
         throw new Error(
           `\u{1F6AB} Direct ${blockedTool.name} usage blocked.\n\n` +
             `AI agents must use wrapper tools for security and audit.\n\n` +
-            `Use instead: bun ${blockedTool.wrapper}\n\n` +
-            `Example: bun ${blockedTool.wrapper} --help\n\n` +
+            `Use instead: bun ${skillName}\n\n` +
+            `Example: bun ${skillName} --help\n\n` +
             `Think this tool should be allowed? See https://github.com/blogic-cz/agent-tools — fork, extend the whitelist, and submit a PR.\n` +
-            `→ Skill "agent-tools"`,
+            `→ Skill "${skillName}"`,
         );
       }
     }

package/src/db-tool/service.ts

@@ -14,6 +14,7 @@ import {
 } from "./errors";
 import { getColumns, getRelationships, getTableNames } from "./schema";
 import { detectSchemaError, isValidTableName, isMutationQuery } from "./security";
+import { transformQueryResult } from "./transformers";
 
 const LOCALHOST_HOSTS = new Set(["localhost", "127.0.0.1"]);
 
@@ -323,6 +324,7 @@ export class DbService extends ServiceMap.Service<
           sql: string,
           password: string,
           startTimeMs: number,
+          applyTransform = false,
         ) {
           const wrappedSql = `SELECT json_agg(t) FROM (${sql}) t;`;
           const command = buildPsqlCommand(config, wrappedSql, password, true);
@@ -376,7 +378,7 @@ export class DbService extends ServiceMap.Service<
             };
           }
 
-          const data = yield* Effect.try({
+          const rawData = yield* Effect.try({
             try: () => JSON.parse(trimmedOutput) as Record<string, unknown>[],
             catch: () =>
               new DbParseError({
@@ -385,11 +387,21 @@ export class DbService extends ServiceMap.Service<
               }),
           });
 
+          const transformed = applyTransform
+            ? transformQueryResult(rawData)
+            : {
+                data: rawData,
+                showing: rawData.length,
+                truncated: false,
+                total: rawData.length,
+              };
+
           return {
             success: true,
-            data,
-            rowCount: data.length,
+            data: transformed.data,
+            rowCount: transformed.showing,
             executionTimeMs: Number(endTime) - startTimeMs,
+            ...(transformed.truncated ? { truncated: true, total: transformed.total } : {}),
           };
         });
 
@@ -558,7 +570,7 @@ export class DbService extends ServiceMap.Service<
 
           const queryEffect = mutation
             ? executeMutationQuery(config, sql, password, Number(startTimeMs))
-            : executeSelectQuery(config, sql, password, Number(startTimeMs));
+            : executeSelectQuery(config, sql, password, Number(startTimeMs), true);
 
           return yield* runQueryWithOptionalTunnel(config, queryEffect);
         });

package/src/db-tool/transformers.ts

@@ -0,0 +1,38 @@
+import { stripEmptyColumns, truncateRows } from "#shared";
+
+export const DEFAULT_ROW_LIMIT = 50;
+export const MAX_VALUE_LENGTH = 200;
+
+export type TransformResult = {
+  data: Record<string, unknown>[];
+  truncated: boolean;
+  total: number;
+  showing: number;
+};
+
+function truncateValue(value: unknown): unknown {
+  if (typeof value !== "string") {
+    return value;
+  }
+
+  if (value.length <= MAX_VALUE_LENGTH) {
+    return value;
+  }
+
+  return `${value.slice(0, MAX_VALUE_LENGTH)}...`;
+}
+
+export function transformQueryResult(data: Record<string, unknown>[]): TransformResult {
+  const withoutEmptyColumns = stripEmptyColumns(data);
+  const truncatedValues = withoutEmptyColumns.map((record) =>
+    Object.fromEntries(Object.entries(record).map(([key, value]) => [key, truncateValue(value)])),
+  );
+  const { rows, truncated, total, showing } = truncateRows(truncatedValues, DEFAULT_ROW_LIMIT);
+
+  return {
+    data: rows,
+    truncated,
+    total,
+    showing,
+  };
+}

package/src/db-tool/types.ts

@@ -25,6 +25,8 @@ export type QueryResult = {
   availableColumns?: string[];
   hint?: string;
   schemaFile?: string;
+  truncated?: boolean;
+  total?: number;
 };
 
 export type SchemaErrorInfo = {

package/src/k8s-tool/index.ts

@@ -11,6 +11,13 @@ import { K8sService, K8sServiceLayer } from "./service";
 import { ConfigService, ConfigServiceLayer, getDefaultEnvironment, getToolConfig } from "#config";
 import type { K8sConfig } from "#config";
 import { K8sContextError } from "./errors";
+import {
+  transformDescribe,
+  transformGenericKubectl,
+  transformLogs,
+  transformPods,
+  transformTop,
+} from "./transformers";
 
 /**
  * Resolve environment from explicit --env flag, config defaultEnvironment, or fail with hint.
@@ -54,7 +61,7 @@ type CommonK8sCommandOptions = {
   readonly profile: Option.Option<string>;
 };
 
-const runK8sCommand = (command: string, options: CommonK8sCommandOptions) =>
+const executeK8sCommand = (command: string, options: CommonK8sCommandOptions) =>
   Effect.gen(function* () {
     const config = yield* ConfigService;
     const profileName = Option.getOrUndefined(options.profile);
@@ -69,8 +76,7 @@ const runK8sCommand = (command: string, options: CommonK8sCommandOptions) =>
           "echo '{ kubernetes: { default: { clusterId: \"my-cluster\" } } }' > agent-tools.json5",
         executionTimeMs: 0,
       };
-      yield* Console.log(formatOutput(result, options.format));
-      return;
+      return result;
     }
 
     const resolvedEnv = yield* resolveEnv(options.env, config);
@@ -126,7 +132,24 @@ const runK8sCommand = (command: string, options: CommonK8sCommandOptions) =>
       }),
     );
 
-    yield* Console.log(formatOutput({ ...result, environment: resolvedEnv }, options.format));
+    return { ...result, environment: resolvedEnv };
+  });
+
+const runK8sCommand = (command: string, options: CommonK8sCommandOptions) =>
+  Effect.gen(function* () {
+    const result = yield* executeK8sCommand(command, options);
+    yield* Console.log(formatOutput(result, options.format));
+  });
+
+const logTransformedResult = (
+  result: CommandResult,
+  format: CommonK8sCommandOptions["format"],
+  transform: (output: string) => string | Record<string, unknown>,
+) =>
+  Effect.gen(function* () {
+    const transformedResult =
+      typeof result.output === "string" ? { ...result, output: transform(result.output) } : result;
+    yield* Console.log(formatOutput(transformedResult, format));
   });
 
 const commonFlags = {
@@ -178,7 +201,13 @@ const kubectlCommand = Command.make(
       Flag.withDescription('kubectl command (without "kubectl" prefix)'),
     ),
   },
-  ({ cmd, dryRun, env, format, profile }) => runK8sCommand(cmd, { dryRun, env, format, profile }),
+  ({ cmd, dryRun, env, format, profile }) =>
+    Effect.gen(function* () {
+      const result = yield* executeK8sCommand(cmd, { dryRun, env, format, profile });
+      return yield* logTransformedResult(result, format, (output) =>
+        transformGenericKubectl(output, cmd),
+      );
+    }),
 ).pipe(
   Command.withDescription(
     `Kubernetes CLI Tool for Coding Agents
@@ -247,18 +276,18 @@ const podsCommand = Command.make(
       Flag.withDefault(false),
     ),
   },
-  ({ dryRun, env, format, label, namespace, profile, wide }) =>
+  ({ dryRun, env, format, label, namespace, profile }) =>
     Effect.gen(function* () {
       const resolvedNamespace = yield* resolveStructuredNamespace(namespace, env, profile);
-      const command = buildKubectlCommand("get pods", [
+      const command = buildKubectlCommand("get pods -o json", [
         Option.match(label, {
           onNone: () => "",
           onSome: (value) => `-l ${value}`,
         }),
         resolvedNamespace ? `-n ${resolvedNamespace}` : "",
-        wide ? "-o wide" : "",
       ]);
-      return yield* runK8sCommand(command, { dryRun, env, format, profile });
+      const result = yield* executeK8sCommand(command, { dryRun, env, format, profile });
+      return yield* logTransformedResult(result, format, transformPods);
     }),
 ).pipe(Command.withDescription("List pods (get pods) with optional namespace/label/wide output"));
 
@@ -297,7 +326,8 @@ const logsCommand = Command.make(
         }),
         follow ? "-f" : "",
       ]);
-      return yield* runK8sCommand(command, { dryRun, env, format, profile });
+      const result = yield* executeK8sCommand(command, { dryRun, env, format, profile });
+      return yield* logTransformedResult(result, format, transformLogs);
     }),
 ).pipe(Command.withDescription("Fetch pod logs with tail/follow/container selectors"));
 
@@ -320,7 +350,8 @@ const describeCommand = Command.make(
       const command = buildKubectlCommand(`describe ${resource} ${name}`, [
         resolvedNamespace ? `-n ${resolvedNamespace}` : "",
       ]);
-      return yield* runK8sCommand(command, { dryRun, env, format, profile });
+      const result = yield* executeK8sCommand(command, { dryRun, env, format, profile });
+      return yield* logTransformedResult(result, format, transformDescribe);
     }),
 ).pipe(Command.withDescription("Describe a Kubernetes resource by type and name"));
 
@@ -379,7 +410,8 @@ const topCommand = Command.make(
           onSome: (value) => `--sort-by=${value}`,
         }),
       ]);
-      return yield* runK8sCommand(command, { dryRun, env, format, profile });
+      const result = yield* executeK8sCommand(command, { dryRun, env, format, profile });
+      return yield* logTransformedResult(result, format, transformTop);
     }),
 ).pipe(Command.withDescription("Show pod CPU/memory usage (kubectl top pod)"));