@blogic-cz/agent-tools 0.8.11 → 0.8.13

package/package.json

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

package/src/gh-tool/index.ts

@@ -9,10 +9,11 @@ import { ConfigServiceLayer } from "#config";
 import {
   issueCloseCommand,
   issueCommentCommand,
+  issueCommentsCommand,
   issueEditCommand,
   issueListCommand,
   issueReopenCommand,
-  issueTriageSummaryCommand,
+  issueTriageCommand,
   issueViewCommand,
 } from "./issue";
 import {
@@ -85,16 +86,17 @@ const prCommand = Command.make("pr", {}).pipe(
 
 const issueCommand = Command.make("issue", {}).pipe(
   Command.withDescription(
-    "Issue operations (list, view, close, reopen, comment, edit, triage-summary)",
+    "Issue operations (list, view, comments, triage, close, reopen, comment, edit)",
   ),
   Command.withSubcommands([
     issueListCommand,
     issueViewCommand,
+    issueCommentsCommand,
+    issueTriageCommand,
     issueCloseCommand,
     issueReopenCommand,
     issueCommentCommand,
     issueEditCommand,
-    issueTriageSummaryCommand,
   ]),
 );
 
@@ -147,18 +149,20 @@ WORKFLOW FOR AI AGENTS:
   5. Use 'pr checks' to monitor CI status
   6. Use 'pr merge' to merge (dry-run by default)
   7. Use 'issue list' to list open/closed issues
-  8. Use 'issue close --issue N --comment "reason"' to close issues
-   9. Use 'issue comment --issue N --body "text"' to comment on issues
-  10. Use 'repo info' to get repository metadata
-  11. Use 'workflow list' to list recent workflow runs
-  12. Use 'workflow view --run N' to inspect a specific run with jobs/steps
-  13. Use 'workflow logs --run N' to get logs (failed jobs by default)
-  14. Use 'workflow job-logs --run N --job "build-web-app"' to get clean parsed logs for a specific job
-  15. Use 'workflow annotations --run N' to list CI annotations (errors, warnings, notices)
-  16. Use 'workflow watch --run N' to watch until completion
-  17. Use 'release status' to inspect latest release + repository context
-  18. Use 'release create --tag vX.Y.Z --generate-notes' to publish a release
-  19. Use 'release edit/view/list/delete' to maintain existing releases`,
+  8. Use 'issue triage --issue N --verbosity full' to inspect one issue in one call
+  9. Use 'issue comments --issue N' to read issue discussion comments separately
+  10. Use 'issue close --issue N --comment "reason"' to close issues
+  11. Use 'issue comment --issue N --body "text"' to comment on issues
+  12. Use 'repo info' to get repository metadata
+  13. Use 'workflow list' to list recent workflow runs
+  14. Use 'workflow view --run N' to inspect a specific run with jobs/steps
+  15. Use 'workflow logs --run N' to get logs (failed jobs by default)
+  16. Use 'workflow job-logs --run N --job "build-web-app"' to get clean parsed logs for a specific job
+  17. Use 'workflow annotations --run N' to list CI annotations (errors, warnings, notices)
+  18. Use 'workflow watch --run N' to watch until completion
+  19. Use 'release status' to inspect latest release + repository context
+  20. Use 'release create --tag vX.Y.Z --generate-notes' to publish a release
+  21. Use 'release edit/view/list/delete' to maintain existing releases`,
   ),
   Command.withSubcommands([prCommand, issueCommand, repoCommand, workflowCommand, releaseCommand]),
 );

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

@@ -3,7 +3,15 @@ import { Effect, Option } from "effect";
 
 import { formatOption, logFormatted } from "#shared";
 
-import { closeIssue, commentOnIssue, editIssue, listIssues, reopenIssue, viewIssue } from "./core";
+import {
+  closeIssue,
+  commentOnIssue,
+  editIssue,
+  fetchIssueComments,
+  listIssues,
+  reopenIssue,
+  viewIssue,
+} from "./core";
 
 export const issueListCommand = Command.make(
   "list",
@@ -46,6 +54,36 @@ export const issueViewCommand = Command.make(
     }),
 ).pipe(Command.withDescription("View issue details"));
 
+export const issueCommentsCommand = Command.make(
+  "comments",
+  {
+    author: Flag.string("author").pipe(
+      Flag.withDescription("Filter by author login substring"),
+      Flag.optional,
+    ),
+    bodyContains: Flag.string("body-contains").pipe(
+      Flag.withDescription("Filter comments by body substring"),
+      Flag.optional,
+    ),
+    format: formatOption,
+    issue: Flag.integer("issue").pipe(Flag.withDescription("Issue number")),
+    since: Flag.string("since").pipe(
+      Flag.withDescription("ISO timestamp to filter comments created after"),
+      Flag.optional,
+    ),
+  },
+  ({ author, bodyContains, format, issue, since }) =>
+    Effect.gen(function* () {
+      const comments = yield* fetchIssueComments(
+        issue,
+        Option.getOrNull(since),
+        Option.getOrNull(author),
+        Option.getOrNull(bodyContains),
+      );
+      yield* logFormatted(comments, format);
+    }),
+).pipe(Command.withDescription("Fetch issue discussion comments"));
+
 export const issueCloseCommand = Command.make(
   "close",
   {

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

@@ -1,5 +1,7 @@
 import { Effect } from "effect";
 
+import type { GitHubIssueCommentUrl, IssueComment, IssueCommentId, IsoTimestamp } from "#gh/types";
+
 import { GitHubCommandError } from "#gh/errors";
 import { GitHubService } from "#gh/service";
 
@@ -32,6 +34,60 @@ export type RawIssueComment = {
   html_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("issue.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 mapRawIssueComment = (comment: RawIssueComment): IssueComment => ({
+  id: comment.id as IssueCommentId,
+  author: comment.user.login,
+  body: comment.body,
+  createdAt: comment.created_at as IsoTimestamp,
+  url: comment.html_url as GitHubIssueCommentUrl,
+});
+
 export const listIssues = Effect.fn("issue.listIssues")(function* (opts: {
   state: string;
   labels: string | null;
@@ -69,6 +125,41 @@ export const viewIssue = Effect.fn("issue.viewIssue")(function* (issueNumber: nu
   ]);
 });
 
+export const fetchIssueComments = Effect.fn("issue.fetchIssueComments")(function* (
+  issueNumber: number,
+  since: string | null,
+  author: string | null,
+  bodyContains: string | null,
+) {
+  const gh = yield* GitHubService;
+  const repoInfo = yield* gh.getRepoInfo();
+
+  const raw = yield* fetchAllRestPages<RawIssueComment>(
+    `repos/${repoInfo.owner}/${repoInfo.name}/issues/${issueNumber}/comments`,
+    "gh-tool issue comments",
+    "Failed to parse response",
+  );
+
+  let comments = raw.map(mapRawIssueComment);
+
+  if (since !== null) {
+    const sinceMs = new Date(since).getTime();
+    comments = comments.filter((comment) => new Date(comment.createdAt).getTime() >= sinceMs);
+  }
+
+  if (author !== null) {
+    const authorFilter = author.toLowerCase();
+    comments = comments.filter((comment) => comment.author.toLowerCase().includes(authorFilter));
+  }
+
+  if (bodyContains !== null) {
+    const bodyFilter = bodyContains.toLowerCase();
+    comments = comments.filter((comment) => comment.body.toLowerCase().includes(bodyFilter));
+  }
+
+  return comments;
+});
+
 export const closeIssue = Effect.fn("issue.closeIssue")(function* (opts: {
   issue: number;
   comment: string | null;

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

@@ -1,9 +1,10 @@
 export {
   issueCloseCommand,
   issueCommentCommand,
+  issueCommentsCommand,
   issueEditCommand,
   issueListCommand,
   issueReopenCommand,
   issueViewCommand,
 } from "./commands";
-export { issueTriageSummaryCommand } from "./triage";
+export { issueTriageCommand } from "./triage";

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

@@ -1,12 +1,15 @@
 import { Command, Flag } from "effect/unstable/cli";
-import { Effect } from "effect";
+import { Effect, Schema } from "effect";
+
+import type { IssueComment } from "#gh/types";
 
 import { formatOption, logFormatted } from "#shared";
 import { GitHubService } from "#gh/service";
 
-// ---------------------------------------------------------------------------
-// Raw types (gh CLI JSON output)
-// ---------------------------------------------------------------------------
+import { fetchIssueComments } from "./core";
+
+const TriageVerbosity = Schema.Literals(["compact", "full"]);
+type TriageVerbosity = typeof TriageVerbosity.Type;
 
 type RawTriageIssue = {
   number: number;
@@ -17,304 +20,119 @@ type RawTriageIssue = {
   assignees: Array<{ login: string }>;
   author: { login: string };
   body: string;
-  comments: Array<unknown>;
   createdAt: string;
+  closedAt: string | null;
 };
 
-type RawTriagePR = {
+type TriageIssue = {
   number: number;
   title: string;
   state: string;
   url: string;
-  labels: Array<{ name: string }>;
-  author: { login: string };
-  body: string;
-  headRefName: string;
-  baseRefName: string;
-  isDraft: boolean;
-  mergeable: string;
-  reviewDecision: string;
-  statusCheckRollup: Array<{
-    name: string;
-    status: string;
-    conclusion: string | null;
-    context: string;
-  }>;
-};
-
-// ---------------------------------------------------------------------------
-// Classification types
-// ---------------------------------------------------------------------------
-
-type IssueClassification = "QUESTION" | "BUG" | "FEATURE" | "OTHER";
-type PRClassification = "BUGFIX" | "OTHER";
-type Confidence = "HIGH" | "MEDIUM" | "LOW";
-
-// ---------------------------------------------------------------------------
-// Output types
-// ---------------------------------------------------------------------------
-
-type TriageIssue = {
-  number: number;
-  title: string;
-  author: string;
   labels: string[];
-  classification: IssueClassification;
-  confidence: Confidence;
-  body: string;
-  commentsCount: number;
+  assignees: string[];
+  author: string;
   createdAt: string;
-  url: string;
+  closedAt: string | null;
 };
 
-type TriagePR = {
-  number: number;
-  title: string;
-  author: string;
-  labels: string[];
-  classification: PRClassification;
-  confidence: Confidence;
-  headRefName: string;
-  baseRefName: string;
-  isDraft: boolean;
-  mergeable: string;
-  reviewDecision: string;
-  ciStatus: string;
+type CompactIssueTriage = {
+  issue: TriageIssue;
   body: string;
-  url: string;
+  commentsCount: number;
+  latestComment: IssueComment | null;
 };
 
-type TriageSummary = {
-  repo: string;
-  fetchedAt: string;
-  issues: TriageIssue[];
-  prs: TriagePR[];
-  summary: {
-    totalIssues: number;
-    totalPRs: number;
-    issuesByType: Record<string, number>;
-    prsByType: Record<string, number>;
-  };
+type FullIssueTriage = {
+  issue: TriageIssue;
+  body: string;
+  commentsCount: number;
+  comments: IssueComment[];
 };
 
-// ---------------------------------------------------------------------------
-// Classification logic (pure functions)
-// ---------------------------------------------------------------------------
-
-function classifyIssue(
-  labels: string[],
-  title: string,
-): { classification: IssueClassification; confidence: Confidence } {
-  const lowerLabels = new Set(labels.map((l) => l.toLowerCase()));
-  const lowerTitle = title.toLowerCase();
-
-  // Labels first — HIGH confidence
-  if (lowerLabels.has("bug")) {
-    return { classification: "BUG", confidence: "HIGH" };
-  }
-  if (lowerLabels.has("question") || lowerLabels.has("help wanted")) {
-    return { classification: "QUESTION", confidence: "HIGH" };
-  }
-  if (
-    lowerLabels.has("enhancement") ||
-    lowerLabels.has("feature") ||
-    lowerLabels.has("feature request")
-  ) {
-    return { classification: "FEATURE", confidence: "HIGH" };
-  }
-
-  // Title patterns — MEDIUM confidence
-  if (/\[bug\]/i.test(title) || /^bug:/i.test(title) || /^fix:/i.test(title)) {
-    return { classification: "BUG", confidence: "MEDIUM" };
-  }
-  if (
-    lowerTitle.includes("?") ||
-    /\[question\]/i.test(title) ||
-    /how to/i.test(title) ||
-    /is it possible/i.test(title)
-  ) {
-    return { classification: "QUESTION", confidence: "MEDIUM" };
-  }
-  if (
-    /\[feature\]/i.test(title) ||
-    /\[enhancement\]/i.test(title) ||
-    /\[rfe\]/i.test(title) ||
-    /^feat:/i.test(title)
-  ) {
-    return { classification: "FEATURE", confidence: "MEDIUM" };
-  }
-
-  // Default — LOW confidence
-  return { classification: "OTHER", confidence: "LOW" };
-}
-
-function classifyPR(
-  labels: string[],
-  title: string,
-  branch: string,
-): { classification: PRClassification; confidence: Confidence } {
-  const lowerLabels = new Set(labels.map((l) => l.toLowerCase()));
-
-  // Labels first — HIGH confidence
-  if (lowerLabels.has("bug")) {
-    return { classification: "BUGFIX", confidence: "HIGH" };
-  }
-
-  // Title/branch patterns — MEDIUM confidence
-  if (/^fix/i.test(title)) {
-    return { classification: "BUGFIX", confidence: "MEDIUM" };
-  }
-  if (branch.startsWith("fix/") || branch.startsWith("bugfix/")) {
-    return { classification: "BUGFIX", confidence: "MEDIUM" };
-  }
-
-  // Default — LOW confidence
-  return { classification: "OTHER", confidence: "LOW" };
-}
-
-function aggregateCIStatus(checks: RawTriagePR["statusCheckRollup"]): string {
-  if (checks.length === 0) return "UNKNOWN";
-  if (checks.some((c) => c.conclusion === "failure")) return "FAIL";
-  if (checks.some((c) => c.status !== "COMPLETED")) return "PENDING";
-  return "PASS";
-}
-
 function truncateBody(body: string, maxLength = 500): string {
   if (body.length <= maxLength) return body;
   return body.slice(0, maxLength) + "…";
 }
 
-// ---------------------------------------------------------------------------
-// Handler
-// ---------------------------------------------------------------------------
+function getLatestComment(comments: IssueComment[]): IssueComment | null {
+  if (comments.length === 0) {
+    return null;
+  }
 
-const fetchTriageSummary = Effect.fn("issue.fetchTriageSummary")(function* (opts: {
-  state: string;
-  limit: number;
+  return comments.reduce((current, next) =>
+    new Date(next.createdAt).getTime() > new Date(current.createdAt).getTime() ? next : current,
+  );
+}
+
+export const fetchIssueTriage = Effect.fn("issue.fetchIssueTriage")(function* (opts: {
+  issue: number;
+  verbosity: TriageVerbosity;
 }) {
   const gh = yield* GitHubService;
-  const repoInfo = yield* gh.getRepoInfo();
 
-  // Parallel fetch: issues + PRs
-  const [rawIssues, rawPRs] = yield* Effect.all(
+  const [rawIssue, comments] = yield* Effect.all(
     [
-      gh.runGhJson<RawTriageIssue[]>([
+      gh.runGhJson<RawTriageIssue>([
         "issue",
-        "list",
-        "--state",
-        opts.state,
-        "--limit",
-        String(opts.limit),
-        "--json",
-        "number,title,state,url,labels,assignees,author,body,comments,createdAt",
-      ]),
-      gh.runGhJson<RawTriagePR[]>([
-        "pr",
-        "list",
-        "--state",
-        opts.state,
-        "--limit",
-        String(opts.limit),
+        "view",
+        String(opts.issue),
         "--json",
-        "number,title,state,url,labels,author,body,headRefName,baseRefName,isDraft,mergeable,reviewDecision,statusCheckRollup",
+        "number,title,state,url,labels,assignees,author,body,createdAt,closedAt",
       ]),
+      fetchIssueComments(opts.issue, null, null, null),
     ],
     { concurrency: "unbounded" },
   );
 
-  // Classify + transform issues
-  const issues: TriageIssue[] = rawIssues.map((issue) => {
-    const labelNames = issue.labels.map((l) => l.name);
-    const { classification, confidence } = classifyIssue(labelNames, issue.title);
-
-    return {
-      number: issue.number,
-      title: issue.title,
-      author: issue.author.login,
-      labels: labelNames,
-      classification,
-      confidence,
-      body: truncateBody(issue.body),
-      commentsCount: issue.comments.length,
-      createdAt: issue.createdAt,
-      url: issue.url,
-    };
-  });
-
-  // Classify + transform PRs
-  const prs: TriagePR[] = rawPRs.map((pr) => {
-    const labelNames = pr.labels.map((l) => l.name);
-    const { classification, confidence } = classifyPR(labelNames, pr.title, pr.headRefName);
+  const issue: TriageIssue = {
+    number: rawIssue.number,
+    title: rawIssue.title,
+    state: rawIssue.state,
+    url: rawIssue.url,
+    labels: rawIssue.labels.map((label) => label.name),
+    assignees: rawIssue.assignees.map((assignee) => assignee.login),
+    author: rawIssue.author.login,
+    createdAt: rawIssue.createdAt,
+    closedAt: rawIssue.closedAt,
+  };
 
-    return {
-      number: pr.number,
-      title: pr.title,
-      author: pr.author.login,
-      labels: labelNames,
-      classification,
-      confidence,
-      headRefName: pr.headRefName,
-      baseRefName: pr.baseRefName,
-      isDraft: pr.isDraft,
-      mergeable: pr.mergeable,
-      reviewDecision: pr.reviewDecision,
-      ciStatus: aggregateCIStatus(pr.statusCheckRollup ?? []),
-      body: truncateBody(pr.body),
-      url: pr.url,
+  if (opts.verbosity === "full") {
+    const result: FullIssueTriage = {
+      issue,
+      body: rawIssue.body,
+      commentsCount: comments.length,
+      comments,
     };
-  });
 
-  // Build summary counters
-  const issuesByType: Record<string, number> = {};
-  for (const issue of issues) {
-    issuesByType[issue.classification] = (issuesByType[issue.classification] ?? 0) + 1;
+    return result;
   }
 
-  const prsByType: Record<string, number> = {};
-  for (const pr of prs) {
-    prsByType[pr.classification] = (prsByType[pr.classification] ?? 0) + 1;
-  }
-
-  const result: TriageSummary = {
-    repo: `${repoInfo.owner}/${repoInfo.name}`,
-    fetchedAt: new Date().toISOString(),
-    issues,
-    prs,
-    summary: {
-      totalIssues: issues.length,
-      totalPRs: prs.length,
-      issuesByType,
-      prsByType,
-    },
+  const result: CompactIssueTriage = {
+    issue,
+    body: truncateBody(rawIssue.body),
+    commentsCount: comments.length,
+    latestComment: getLatestComment(comments),
   };
 
   return result;
 });
 
-// ---------------------------------------------------------------------------
-// CLI Command
-// ---------------------------------------------------------------------------
-
-export const issueTriageSummaryCommand = Command.make(
-  "triage-summary",
+export const issueTriageCommand = Command.make(
+  "triage",
   {
     format: formatOption,
-    limit: Flag.integer("limit").pipe(
-      Flag.withDescription("Maximum number of issues and PRs to fetch"),
-      Flag.withDefault(100),
-    ),
-    state: Flag.choice("state", ["open", "closed", "all"]).pipe(
-      Flag.withDescription("Filter by state: open, closed, all"),
-      Flag.withDefault("open"),
+    issue: Flag.integer("issue").pipe(Flag.withDescription("Issue number")),
+    verbosity: Flag.choice("verbosity", ["compact", "full"] as const).pipe(
+      Flag.withDescription("Output detail level: compact or full"),
+      Flag.withDefault("compact"),
     ),
   },
-  ({ format, limit, state }) =>
+  ({ format, issue, verbosity }) =>
     Effect.gen(function* () {
-      const summary = yield* fetchTriageSummary({ limit, state });
-      yield* logFormatted(summary, format);
+      const result = yield* fetchIssueTriage({ issue, verbosity });
+      yield* logFormatted(result, format);
     }),
 ).pipe(
-  Command.withDescription(
-    "Composite: fetch all issues + PRs, classify each, return structured triage summary",
-  ),
+  Command.withDescription("Composite: fetch issue details and discussion comments in one call"),
 );

package/src/k8s-tool/transformers.ts

@@ -184,30 +184,65 @@ function parseDescribeSections(
   return sections;
 }
 
-function stripLowValueColumns(rows: Record<string, string>[]): Record<string, string>[] {
+type KubectlTableResult = {
+  headers: string[];
+  rows: Record<string, string>[];
+  uniform?: Record<string, string>;
+  stripped?: string[];
+};
+
+const PLACEHOLDER_VALUES = new Set(["<none>", "<pending>", "<unknown>", "<unset>", ""]);
+const ALWAYS_STRIP_COLUMNS = new Set(["SELECTOR", "LABELS", "NODE-SELECTORS", "NODE_SELECTORS"]);
+
+function isSelectorLikeValue(value: string): boolean {
+  if (!value.includes("=")) return false;
+  return value.includes("kubernetes.io/") || value.includes("k8s.io/") || value.includes(",");
+}
+
+function stripLowValueColumns(rows: Record<string, string>[]): {
+  rows: Record<string, string>[];
+  stripped: string[];
+} {
   if (rows.length === 0) {
-    return rows;
+    return { rows, stripped: [] };
   }
 
   const keys = Object.keys(rows[0] ?? {});
   const keysToRemove = new Set<string>();
 
   for (const key of keys) {
-    const allNone = rows.every((row) => {
-      const value = (row[key] ?? "").trim().toLowerCase();
-      return value === "<none>";
-    });
+    if (ALWAYS_STRIP_COLUMNS.has(key.toUpperCase())) {
+      keysToRemove.add(key);
+      continue;
+    }
+
+    const values = rows.map((row) => (row[key] ?? "").trim());
 
-    if (allNone) {
+    const allPlaceholder = values.every((v) => PLACEHOLDER_VALUES.has(v.toLowerCase()));
+    if (allPlaceholder) {
       keysToRemove.add(key);
+      continue;
+    }
+
+    const nonEmptyValues = values.filter(
+      (v) => v.length > 0 && !PLACEHOLDER_VALUES.has(v.toLowerCase()),
+    );
+    if (nonEmptyValues.length > 0) {
+      const avgLength =
+        nonEmptyValues.reduce((sum, v) => sum + v.length, 0) / nonEmptyValues.length;
+      const labelCount = nonEmptyValues.filter(isSelectorLikeValue).length;
+      if (avgLength > 50 && labelCount / nonEmptyValues.length > 0.5) {
+        keysToRemove.add(key);
+      }
     }
   }
 
   if (keysToRemove.size === 0) {
-    return rows;
+    return { rows, stripped: [] };
   }
 
-  return rows.map((row) => {
+  const stripped = keys.filter((k) => keysToRemove.has(k));
+  const filteredRows = rows.map((row) => {
     const filtered: Record<string, string> = {};
     for (const [key, value] of Object.entries(row)) {
       if (!keysToRemove.has(key)) {
@@ -216,6 +251,47 @@ function stripLowValueColumns(rows: Record<string, string>[]): Record<string, st
     }
     return filtered;
   });
+
+  return { rows: filteredRows, stripped };
+}
+
+function collapseUniformColumns(rows: Record<string, string>[]): {
+  rows: Record<string, string>[];
+  uniform: Record<string, string>;
+} {
+  if (rows.length <= 1) {
+    return { rows, uniform: {} };
+  }
+
+  const keys = Object.keys(rows[0] ?? {});
+  const uniform: Record<string, string> = {};
+  const keysToCollapse = new Set<string>();
+
+  for (const key of keys) {
+    const values = rows.map((row) => (row[key] ?? "").trim());
+    const firstValue = values[0] ?? "";
+
+    if (firstValue.length > 0 && values.every((v) => v === firstValue)) {
+      uniform[key] = firstValue;
+      keysToCollapse.add(key);
+    }
+  }
+
+  if (keysToCollapse.size === 0) {
+    return { rows, uniform: {} };
+  }
+
+  const cleanedRows = rows.map((row) => {
+    const filtered: Record<string, string> = {};
+    for (const [key, value] of Object.entries(row)) {
+      if (!keysToCollapse.has(key)) {
+        filtered[key] = value;
+      }
+    }
+    return filtered;
+  });
+
+  return { rows: cleanedRows, uniform };
 }
 
 export function transformPods(jsonOutput: string): PodSummary | string {
@@ -487,11 +563,17 @@ export function transformGenericKubectl(
     parsedTable.headers.every((header) => /^[A-Z0-9_()\-/]+$/.test(header));
 
   if (looksLikeTable) {
-    const rows = stripLowValueColumns(parsedTable.rows);
-    const headers = parsedTable.headers.filter((headerName) =>
-      rows.length === 0 ? true : rows.some((row) => headerName in row),
-    );
-    return { headers, rows };
+    const { rows: strippedRows, stripped } = stripLowValueColumns(parsedTable.rows);
+    const { rows: finalRows, uniform } = collapseUniformColumns(strippedRows);
+
+    const remainingKeys =
+      finalRows.length > 0 ? new Set(Object.keys(finalRows[0] ?? {})) : new Set<string>();
+    const headers = parsedTable.headers.filter((h) => remainingKeys.has(h));
+
+    const result: KubectlTableResult = { headers, rows: finalRows };
+    if (Object.keys(uniform).length > 0) result.uniform = uniform;
+    if (stripped.length > 0) result.stripped = stripped;
+    return result;
   }
 
   if (lines.length > 50) {