@kb-labs/shared-cli-ui 1.0.0

package/dist/index.js

@@ -0,0 +1,2516 @@
+import path from 'path';
+import { promises } from 'fs';
+
+// src/colors.ts
+var CSI = "\x1B[";
+var RESET = "\x1B[0m";
+var createColor = (...codes) => (text) => `${CSI}${codes.join(";")}m${text}${RESET}`;
+var accentBlue = "38;5;39";
+var accentViolet = "38;5;99";
+var accentTeal = "38;5;51";
+var accentIndigo = "38;5;63";
+var neutral = 37;
+var neutralMuted = 90;
+var colors = {
+  // Semantic colors
+  success: createColor(32),
+  error: createColor(31),
+  warning: createColor(33),
+  info: createColor(36),
+  // Accent palette (reused across CLI)
+  primary: createColor(accentBlue),
+  accent: createColor(accentViolet),
+  highlight: createColor(accentTeal),
+  secondary: createColor(accentIndigo),
+  emphasis: createColor("38;5;117"),
+  muted: createColor(neutralMuted),
+  foreground: createColor(neutral),
+  // Formatting helpers
+  dim: createColor(2),
+  bold: createColor(1),
+  underline: createColor(4),
+  inverse: createColor(7)
+};
+var symbolCharacters = {
+  success: "OK",
+  error: "ERR",
+  warning: "WARN",
+  info: "\u2139",
+  bullet: "\u2022",
+  clock: "TIME",
+  folder: "DIR",
+  package: "\u203A",
+  pointer: "\u203A",
+  section: "\u2502"
+};
+var symbols = {
+  success: colors.success(symbolCharacters.success),
+  error: colors.error(symbolCharacters.error),
+  warning: colors.warning(symbolCharacters.warning),
+  info: colors.info(symbolCharacters.info),
+  bullet: colors.muted(symbolCharacters.bullet),
+  clock: colors.info(symbolCharacters.clock),
+  folder: colors.primary(symbolCharacters.folder),
+  package: colors.accent(symbolCharacters.package),
+  pointer: colors.primary(symbolCharacters.pointer),
+  section: colors.primary(symbolCharacters.section)
+};
+var isTruthyEnv = (value) => {
+  if (!value) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized !== "" && normalized !== "0" && normalized !== "false" && normalized !== "off";
+};
+var supportsColor = (() => {
+  if (typeof process === "undefined") {
+    return false;
+  }
+  const forceColor = process.env.FORCE_COLOR;
+  if (isTruthyEnv(process.env.NO_COLOR)) {
+    return false;
+  }
+  if (isTruthyEnv(forceColor)) {
+    return true;
+  }
+  if (!process.stdout) {
+    return false;
+  }
+  if (process.stdout.isTTY === false) {
+    return false;
+  }
+  return true;
+})();
+var passthrough = (fn) => (text) => supportsColor ? fn(text) : text;
+var safeColors = {
+  success: passthrough(colors.success),
+  error: passthrough(colors.error),
+  warning: passthrough(colors.warning),
+  info: passthrough(colors.info),
+  accent: passthrough(colors.accent),
+  primary: passthrough(colors.primary),
+  highlight: passthrough(colors.highlight),
+  secondary: passthrough(colors.secondary),
+  emphasis: passthrough(colors.emphasis),
+  foreground: passthrough(colors.foreground),
+  muted: passthrough(colors.muted),
+  dim: passthrough(colors.dim),
+  bold: passthrough(colors.bold),
+  underline: passthrough(colors.underline),
+  inverse: passthrough(colors.inverse)
+};
+var safeSymbols = {
+  success: supportsColor ? symbols.success : "\u2713",
+  error: supportsColor ? symbols.error : "\u2717",
+  warning: supportsColor ? symbols.warning : "\u26A0",
+  info: supportsColor ? symbols.info : "\u2192",
+  bullet: supportsColor ? symbols.bullet : "\u2022",
+  clock: supportsColor ? symbols.clock : "time",
+  folder: supportsColor ? symbols.folder : "dir",
+  package: supportsColor ? symbols.package : "\u203A",
+  pointer: supportsColor ? symbols.pointer : ">",
+  section: supportsColor ? symbols.section : "|",
+  // Box-drawing characters for modern side border
+  separator: "\u2500",
+  // Horizontal line
+  border: "\u2502",
+  // Vertical line
+  topLeft: "\u250C",
+  // Top-left corner
+  topRight: "\u2510",
+  // Top-right corner
+  bottomLeft: "\u2514",
+  // Bottom-left corner
+  bottomRight: "\u2518",
+  // Bottom-right corner
+  leftT: "\u251C",
+  // Left T-junction
+  rightT: "\u2524"
+  // Right T-junction
+};
+
+// src/loader.ts
+var SPINNER_CHARS = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var Loader = class {
+  isActive = false;
+  options;
+  frameIndex = 0;
+  intervalId;
+  currentText;
+  // ← Реактивная переменная для текста
+  constructor(options = {}) {
+    this.options = {
+      text: "Loading...",
+      spinner: true,
+      jsonMode: false,
+      ...options
+    };
+    this.currentText = this.options.text ?? "Loading...";
+  }
+  start() {
+    if (this.options.jsonMode || this.isActive) {
+      return;
+    }
+    this.isActive = true;
+    if (this.options.spinner && !this.options.jsonMode) {
+      this.intervalId = setInterval(() => {
+        if (!this.isActive) {
+          this.clearInterval();
+          return;
+        }
+        const char = SPINNER_CHARS[this.frameIndex % SPINNER_CHARS.length];
+        process.stdout.write(`\r${char} ${this.currentText}`);
+        this.frameIndex++;
+      }, 200);
+    }
+  }
+  update(options) {
+    this.options = { ...this.options, ...options };
+    if (!this.isActive || this.options.jsonMode) {
+      return;
+    }
+    if (options.text !== void 0) {
+      this.currentText = options.text;
+    }
+    if (!this.intervalId) {
+      if (this.options.spinner) {
+        const text = this.options.text ?? "Loading...";
+        console.log(`${safeSymbols.info} ${text}`);
+      } else if (this.options.total !== void 0) {
+        this.updateProgress();
+      }
+    }
+  }
+  stop() {
+    this.isActive = false;
+    this.clearInterval();
+  }
+  succeed(message) {
+    this.stop();
+    if (!this.options.jsonMode && message) {
+      process.stdout.write(`\r\x1B[K${safeSymbols.success} ${message}
+`);
+    }
+  }
+  fail(message) {
+    this.stop();
+    if (!this.options.jsonMode && message) {
+      process.stdout.write(`\r\x1B[K${safeSymbols.error} ${message}
+`);
+    }
+  }
+  clearInterval() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+  }
+  updateProgress() {
+    if (this.options.total === void 0 || this.options.current === void 0) {
+      return;
+    }
+    const current = this.options.current;
+    const total = this.options.total;
+    const percentage = Math.round(current / total * 100);
+    const barLength = 20;
+    const filledLength = Math.round(current / total * barLength);
+    const bar = "\u2588".repeat(filledLength) + "\u2591".repeat(barLength - filledLength);
+    const text = this.options.text || "Progress";
+    process.stdout.write(`\r${safeColors.info("\u2192")} ${text}... ${bar} ${percentage}% (${current}/${total})`);
+  }
+};
+function createSpinner(text, jsonMode = false) {
+  return new Loader({ text, spinner: true, jsonMode });
+}
+function createProgressBar(text, total, jsonMode = false) {
+  return new Loader({ text, spinner: false, total, current: 0, jsonMode });
+}
+function showLoading(text, jsonMode = false) {
+  if (!jsonMode) {
+    console.log(`${safeColors.info("\u2192")} ${text}...`);
+  }
+}
+function showSuccess(text, jsonMode = false) {
+  if (!jsonMode) {
+    console.log(`${safeSymbols.success} ${text}`);
+  }
+}
+function showError(text, jsonMode = false) {
+  if (!jsonMode) {
+    console.log(`${safeSymbols.error} ${text}`);
+  }
+}
+function useLoader(text, options) {
+  return new Loader({ text, ...options });
+}
+
+// src/format.ts
+var ANSI_PATTERN = /\u001B\[[0-9;]*m/g;
+function stripAnsi(input) {
+  return input.replace(ANSI_PATTERN, "");
+}
+function hasAnsi(input) {
+  return /\u001B\[[0-9;]*m/.test(input);
+}
+function visibleLength(input) {
+  return stripAnsi(input).length;
+}
+function box(title, content = [], maxWidth) {
+  const lines = content.length > 0 ? content : [""];
+  const titleWidth = visibleLength(title);
+  const terminalWidth = typeof process !== "undefined" && process.stdout?.columns ? process.stdout.columns : 80;
+  const effectiveMaxWidth = maxWidth ?? Math.min(terminalWidth - 4, 120);
+  const bodyWidth = Math.min(
+    effectiveMaxWidth,
+    Math.max(titleWidth, ...lines.map((line) => visibleLength(line)))
+  );
+  const wrappedLines = [];
+  for (const line of lines) {
+    const lineLength = visibleLength(line);
+    if (lineLength <= bodyWidth) {
+      wrappedLines.push(line);
+    } else {
+      const words = line.split(/(\s+)/);
+      let currentLine = "";
+      for (const word of words) {
+        const testLine = currentLine + word;
+        if (visibleLength(testLine) <= bodyWidth) {
+          currentLine = testLine;
+        } else {
+          if (currentLine) {
+            wrappedLines.push(currentLine.trimEnd());
+          }
+          if (visibleLength(word) > bodyWidth) {
+            wrappedLines.push(truncate(word, bodyWidth));
+            currentLine = "";
+          } else {
+            currentLine = word;
+          }
+        }
+      }
+      if (currentLine) {
+        wrappedLines.push(currentLine.trimEnd());
+      }
+    }
+  }
+  const topBorder = `\u250C${"\u2500".repeat(bodyWidth + 2)}\u2510`;
+  const titleLine = `\u2502 ${safeColors.bold(title)}${" ".repeat(Math.max(0, bodyWidth - titleWidth))} \u2502`;
+  const bodyLines = wrappedLines.map((line) => {
+    const padding = Math.max(0, bodyWidth - visibleLength(line));
+    return `\u2502 ${line}${" ".repeat(padding)} \u2502`;
+  });
+  const bottomBorder = `\u2514${"\u2500".repeat(bodyWidth + 2)}\u2518`;
+  return [topBorder, titleLine, ...bodyLines, bottomBorder].join("\n");
+}
+function indent(lines, level = 1) {
+  const prefix = "  ".repeat(level);
+  return lines.map((line) => `${prefix}${line}`);
+}
+function section(header, content) {
+  return [
+    "",
+    safeColors.bold(header),
+    ...indent(content)
+  ];
+}
+function table(rows, headers) {
+  if (rows.length === 0) {
+    return [];
+  }
+  const allRows = headers ? [headers, ...rows] : rows;
+  if (allRows.length === 0) {
+    return [];
+  }
+  const columnWidths = allRows[0].map(
+    (_, colIndex) => Math.max(...allRows.map((row) => String(row[colIndex] || "").length))
+  );
+  return allRows.map((row) => {
+    return row.map(
+      (cell, colIndex) => String(cell || "").padEnd(columnWidths[colIndex] || 0)
+    ).join("  ");
+  });
+}
+function keyValue(pairs, options = {}) {
+  const { padKeys = true } = options;
+  return safeKeyValue(pairs, { pad: padKeys });
+}
+function bulletList(items) {
+  return items.map((item) => `${safeSymbols.bullet} ${item}`);
+}
+function safeKeyValue(pairs, options = {}) {
+  const { indent: indent2 = 0, pad: pad3 = true, valueColor } = options;
+  const keys = Object.keys(pairs);
+  if (keys.length === 0) {
+    return [];
+  }
+  const indentStr = " ".repeat(indent2);
+  const maxKeyLength = pad3 ? Math.max(...keys.map((key) => indent2 + stripAnsi(key).length)) : 0;
+  return keys.map((key) => {
+    const rawKey = key;
+    const rawValue = String(pairs[key] ?? "");
+    const keyLength = indent2 + stripAnsi(rawKey).length;
+    const padding = pad3 ? Math.max(0, maxKeyLength - keyLength) : 0;
+    const formattedKey = `${indentStr}${rawKey}${" ".repeat(padding)}`;
+    const computedValue = valueColor ? valueColor(rawValue, key) : rawValue;
+    const valueText = hasAnsi(computedValue) ? computedValue : safeColors.muted(computedValue);
+    return `${safeColors.bold(formattedKey)}: ${valueText}`;
+  });
+}
+var pad2 = (value) => value.toString().padStart(2, "0");
+var toDate = (value) => value instanceof Date ? new Date(value.getTime()) : new Date(value);
+var isValidDate = (date) => Number.isFinite(date.getTime());
+function getOffsetMinutes(date, timeZone) {
+  if (!timeZone) {
+    return -date.getTimezoneOffset();
+  }
+  const dtf = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hour12: false,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  const parts = dtf.formatToParts(date);
+  const lookup = Object.fromEntries(
+    parts.filter((part) => part.type !== "literal").map((part) => [part.type, Number(part.value)])
+  );
+  const year = lookup.year ?? date.getUTCFullYear();
+  const month = (lookup.month ?? date.getUTCMonth() + 1) - 1;
+  const day = lookup.day ?? date.getUTCDate();
+  const hour = lookup.hour ?? date.getUTCHours();
+  const minute = lookup.minute ?? date.getUTCMinutes();
+  const second = lookup.second ?? date.getUTCSeconds();
+  const asUTC = Date.UTC(year, month, day, hour, minute, second);
+  return Math.round((asUTC - date.getTime()) / 6e4);
+}
+function formatOffset(offsetMinutes) {
+  const sign = offsetMinutes >= 0 ? "+" : "-";
+  const absMinutes = Math.abs(offsetMinutes);
+  const hours = Math.floor(absMinutes / 60);
+  const minutes = absMinutes % 60;
+  return `${sign}${pad2(hours)}:${pad2(minutes)}`;
+}
+function getDateParts(date, timeZone) {
+  if (!timeZone) {
+    return {
+      year: date.getFullYear(),
+      month: date.getMonth() + 1,
+      day: date.getDate(),
+      hour: date.getHours(),
+      minute: date.getMinutes(),
+      second: date.getSeconds()
+    };
+  }
+  const dtf = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hour12: false,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  const parts = dtf.formatToParts(date);
+  const lookup = Object.fromEntries(
+    parts.filter((part) => part.type !== "literal").map((part) => [part.type, Number(part.value)])
+  );
+  return {
+    year: lookup.year ?? date.getUTCFullYear(),
+    month: lookup.month ?? date.getUTCMonth() + 1,
+    day: lookup.day ?? date.getUTCDate(),
+    hour: lookup.hour ?? date.getUTCHours(),
+    minute: lookup.minute ?? date.getUTCMinutes(),
+    second: lookup.second ?? date.getUTCSeconds()
+  };
+}
+function headline(text) {
+  return safeColors.primary(safeColors.bold(text));
+}
+function accentLabel(text) {
+  return safeColors.accent(safeColors.bold(text));
+}
+function muted(text) {
+  return safeColors.muted(text);
+}
+function formatSize(bytes) {
+  const units = ["B", "KB", "MB", "GB"];
+  let size = bytes;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  return `${size.toFixed(unitIndex === 0 ? 0 : 1)} ${units[unitIndex]}`;
+}
+function formatRelativeTime(timestamp) {
+  const now = /* @__PURE__ */ new Date();
+  const time = toDate(timestamp);
+  if (!isValidDate(time)) {
+    return "Invalid date";
+  }
+  const diffMs = now.getTime() - time.getTime();
+  const seconds = Math.floor(diffMs / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) {
+    return `${days} day${days > 1 ? "s" : ""} ago`;
+  } else if (hours > 0) {
+    return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+  } else if (minutes > 0) {
+    return `${minutes} minute${minutes > 1 ? "s" : ""} ago`;
+  } else {
+    return `${seconds} second${seconds > 1 ? "s" : ""} ago`;
+  }
+}
+function formatTimestamp(timestamp, options = {}) {
+  const {
+    mode = "local",
+    timeZone,
+    includeSeconds = false,
+    includeMilliseconds = true,
+    includeOffset = true
+  } = options;
+  const date = toDate(timestamp);
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  const offsetMinutes = includeOffset ? getOffsetMinutes(date, timeZone) : null;
+  const offsetSuffix = includeOffset && offsetMinutes !== null ? ` (${formatOffset(offsetMinutes)})` : "";
+  if (mode === "iso") {
+    const isoRaw = date.toISOString();
+    const iso = includeMilliseconds ? isoRaw : isoRaw.replace(/\.\d{3}Z$/, "Z");
+    return `${iso}${offsetSuffix}`;
+  }
+  const { year, month, day, hour, minute, second } = getDateParts(date, timeZone);
+  const base = [
+    `${year}-${pad2(month)}-${pad2(day)}`,
+    `${pad2(hour)}:${pad2(minute)}${includeSeconds ? `:${pad2(second)}` : ""}`
+  ].join(" ");
+  return `${base}${offsetSuffix}`;
+}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.substring(0, maxLength - 3) + "...";
+}
+function pad(text, width, align = "left") {
+  if (text.length >= width) {
+    return text;
+  }
+  const padding = width - text.length;
+  switch (align) {
+    case "right":
+      return " ".repeat(padding) + text;
+    case "center":
+      const leftPad = Math.floor(padding / 2);
+      const rightPad = padding - leftPad;
+      return " ".repeat(leftPad) + text + " ".repeat(rightPad);
+    default:
+      return text + " ".repeat(padding);
+  }
+}
+
+// src/command-output.ts
+function formatTiming(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  } else if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  } else {
+    const minutes = Math.floor(ms / 6e4);
+    const seconds = (ms % 6e4 / 1e3).toFixed(1);
+    return `${minutes}m ${seconds}s`;
+  }
+}
+function formatTimingBreakdown(timings) {
+  const lines = [];
+  const sortedEntries = Object.entries(timings).filter(([key]) => key !== "total").sort(([, a], [, b]) => b - a);
+  for (const [name, ms] of sortedEntries) {
+    const formattedName = name.charAt(0).toUpperCase() + name.slice(1);
+    lines.push(`${formattedName}: ${formatTiming(ms)}`);
+  }
+  if (timings.total !== void 0) {
+    lines.push(`Total: ${formatTiming(timings.total)}`);
+  }
+  return lines;
+}
+function formatCommandOutput(result) {
+  const sections = [];
+  const summaryLines = keyValue(result.summary);
+  sections.push(...summaryLines);
+  if (result.timing !== void 0) {
+    sections.push("");
+    if (typeof result.timing === "number") {
+      sections.push(`Time: ${formatTiming(result.timing)}`);
+    } else {
+      const timingLines = formatTimingBreakdown(result.timing);
+      sections.push(...timingLines);
+    }
+  }
+  if (result.warnings && result.warnings.length > 0) {
+    sections.push("");
+    sections.push(safeColors.warning("Warnings:"));
+    result.warnings.forEach(
+      (warning) => sections.push(`  ${safeColors.dim("\u2022")} ${warning}`)
+    );
+  }
+  if (result.errors && result.errors.length > 0) {
+    sections.push("");
+    sections.push(safeColors.error("Errors:"));
+    result.errors.forEach(
+      (error) => sections.push(`  ${safeColors.dim("\u2022")} ${error}`)
+    );
+  }
+  if (result.diagnostics && result.diagnostics.length > 0) {
+    sections.push("");
+    sections.push(safeColors.info("Diagnostics:"));
+    result.diagnostics.forEach(
+      (diagnostic) => sections.push(`  ${safeColors.dim("\u2022")} ${diagnostic}`)
+    );
+  }
+  if (result.suggestions && result.suggestions.length > 0) {
+    sections.push("");
+    sections.push(safeColors.info("Suggestions:"));
+    result.suggestions.forEach(
+      (suggestion) => sections.push(`  ${safeColors.dim("\u2022")} ${suggestion}`)
+    );
+  }
+  return box(result.title, sections);
+}
+function createSimpleResult(title, summary, timing) {
+  return {
+    title,
+    summary,
+    timing
+  };
+}
+function createDetailedResult(title, summary, options = {}) {
+  return {
+    title,
+    summary,
+    ...options
+  };
+}
+
+// src/timing-tracker.ts
+var TimingTracker = class {
+  start;
+  checkpoints = {};
+  constructor() {
+    this.start = Date.now();
+  }
+  /**
+   * Record a timing checkpoint
+   */
+  checkpoint(name) {
+    this.checkpoints[name] = Date.now() - this.start;
+  }
+  /**
+   * Get total elapsed time in milliseconds
+   */
+  total() {
+    return Date.now() - this.start;
+  }
+  /**
+   * Get timing breakdown including total
+   */
+  breakdown() {
+    return { ...this.checkpoints, total: this.total() };
+  }
+  /**
+   * Get timing breakdown without total
+   */
+  checkpointsOnly() {
+    return { ...this.checkpoints };
+  }
+  /**
+   * Reset the timer
+   */
+  reset() {
+    this.start = Date.now();
+    this.checkpoints = {};
+  }
+  /**
+   * Get elapsed time since last checkpoint or start
+   */
+  sinceLastCheckpoint() {
+    const lastCheckpointTime = Math.max(...Object.values(this.checkpoints), 0);
+    return Date.now() - this.start - lastCheckpointTime;
+  }
+  /**
+   * Get elapsed time since a specific checkpoint
+   */
+  sinceCheckpoint(checkpointName) {
+    const checkpointTime = this.checkpoints[checkpointName];
+    if (checkpointTime === void 0) {
+      return null;
+    }
+    return Date.now() - this.start - checkpointTime;
+  }
+};
+
+// src/command-suggestions.ts
+function createCommandRegistry(commands) {
+  const commandSet = new Set(commands);
+  const groups = /* @__PURE__ */ new Map();
+  for (const cmd of commands) {
+    const [group, ...rest] = cmd.split(":");
+    if (group && rest.length > 0) {
+      if (!groups.has(group)) {
+        groups.set(group, /* @__PURE__ */ new Set());
+      }
+      groups.get(group).add(rest.join(":"));
+    }
+  }
+  return {
+    commands: commandSet,
+    groups
+  };
+}
+function isCommandAvailable(command, registry) {
+  if (command.startsWith("kb ")) {
+    const parts = command.split(" ");
+    if (parts.length >= 3 && parts[1] && parts[2]) {
+      const group = parts[1];
+      const subcommand = parts[2];
+      const fullCommand = `${group}:${subcommand}`;
+      return registry.commands.has(fullCommand);
+    }
+  }
+  return registry.commands.has(command);
+}
+function validateSuggestions(suggestions, registry) {
+  return suggestions.map((suggestion) => ({
+    ...suggestion,
+    available: isCommandAvailable(suggestion.command, registry)
+  })).filter((suggestion) => suggestion.available);
+}
+function generateDevlinkSuggestions(warningCodes, context, registry) {
+  const suggestions = [];
+  if (warningCodes.has("LOCK_MISMATCH")) {
+    suggestions.push({
+      id: "SYNC_LOCK",
+      command: "kb devlink apply",
+      args: ["--yes"],
+      description: "Apply changes to sync manifests",
+      impact: "safe",
+      when: "LOCK_MISMATCH"
+    });
+  }
+  if (warningCodes.has("BACKUP_MISSING")) {
+    suggestions.push({
+      id: "CREATE_BACKUP",
+      command: "kb devlink freeze",
+      args: ["--replace"],
+      description: "Create a fresh backup",
+      impact: "safe",
+      when: "BACKUP_MISSING"
+    });
+  }
+  if (warningCodes.has("STALE_LOCK")) {
+    suggestions.push({
+      id: "REFRESH_LOCK",
+      command: "kb devlink freeze",
+      args: ["--pin=caret"],
+      description: "Refresh lock file",
+      impact: "safe",
+      when: "STALE_LOCK"
+    });
+  }
+  if (warningCodes.has("STALE_YALC_ARTIFACTS")) {
+    suggestions.push({
+      id: "CLEAN_YALC",
+      command: "kb devlink clean",
+      args: [],
+      description: "Remove yalc artifacts",
+      impact: "safe",
+      when: "STALE_YALC_ARTIFACTS"
+    });
+  }
+  if (warningCodes.has("PROTOCOL_CONFLICTS")) {
+    suggestions.push({
+      id: "FIX_PROTOCOLS",
+      command: "kb devlink clean",
+      args: ["--hard"],
+      description: "Reset all protocols and reapply",
+      impact: "disruptive",
+      when: "PROTOCOL_CONFLICTS"
+    });
+  }
+  if (context.undo?.available) {
+    suggestions.push({
+      id: "UNDO_LAST",
+      command: "kb devlink undo",
+      args: [],
+      description: "Revert last operation",
+      impact: "safe",
+      when: "BACKUP_AVAILABLE"
+    });
+  }
+  return validateSuggestions(suggestions, registry);
+}
+function generateQuickActions(hasWarnings, registry, group = "devlink") {
+  if (!hasWarnings) {
+    return [];
+  }
+  const quickActions = [
+    {
+      id: "QUICK_CLEAN",
+      command: `kb ${group} clean`,
+      args: [],
+      description: "Clean artifacts",
+      impact: "safe",
+      when: "QUICK_ACTIONS"
+    },
+    {
+      id: "QUICK_PLAN",
+      command: `kb ${group} plan`,
+      args: [],
+      description: "Create plan",
+      impact: "safe",
+      when: "QUICK_ACTIONS"
+    },
+    {
+      id: "QUICK_APPLY",
+      command: `kb ${group} apply`,
+      args: [],
+      description: "Apply changes",
+      impact: "safe",
+      when: "QUICK_ACTIONS"
+    }
+  ];
+  return validateSuggestions(quickActions, registry);
+}
+
+// src/command-discovery.ts
+var StaticCommandDiscovery = class {
+  constructor(commands) {
+    this.commands = commands;
+  }
+  async getAvailableCommands() {
+    return [...this.commands];
+  }
+  async getCommandInfo(commandId) {
+    if (!this.commands.includes(commandId)) {
+      return null;
+    }
+    const [group, name] = commandId.split(":");
+    return {
+      id: commandId,
+      group: group || "unknown",
+      name: name || commandId,
+      description: `Execute ${commandId}`,
+      available: true
+    };
+  }
+  async isCommandAvailable(commandId) {
+    return this.commands.includes(commandId);
+  }
+};
+function createCommandDiscovery(commands) {
+  return new StaticCommandDiscovery(commands);
+}
+
+// src/manifest-parser.ts
+function extractCommandIds(manifest) {
+  return manifest.map((cmd) => cmd.id);
+}
+function extractCommandGroups(manifest) {
+  const groups = /* @__PURE__ */ new Set();
+  manifest.forEach((cmd) => groups.add(cmd.group));
+  return Array.from(groups);
+}
+function findCommandsByGroup(manifest, group) {
+  return manifest.filter((cmd) => cmd.group === group);
+}
+function findCommandById(manifest, id) {
+  return manifest.find((cmd) => cmd.id === id);
+}
+function getCommandInfo(manifest, commandId) {
+  const cmd = findCommandById(manifest, commandId);
+  if (!cmd) {
+    return null;
+  }
+  const [group, name] = commandId.split(":");
+  return {
+    id: commandId,
+    group: group || "unknown",
+    name: name || commandId,
+    description: cmd.describe,
+    available: true
+  };
+}
+function generateGroupSuggestions(manifest, group, _warningCodes, _context) {
+  const groupCommands = findCommandsByGroup(manifest, group);
+  const suggestions = [];
+  for (const cmd of groupCommands) {
+    suggestions.push({
+      id: `${cmd.group.toUpperCase()}_${cmd.id.split(":")[1]?.toUpperCase() || "UNKNOWN"}`,
+      command: `kb ${cmd.group} ${cmd.id.split(":")[1] || ""}`,
+      args: [],
+      description: cmd.describe,
+      impact: "safe",
+      when: "GENERAL",
+      available: true
+    });
+    if (cmd.id.includes("init")) {
+      suggestions.push({
+        id: `${cmd.group.toUpperCase()}_INIT_FORCE`,
+        command: `kb ${cmd.group} ${cmd.id.split(":")[1] || ""}`,
+        args: ["--force"],
+        description: `${cmd.describe} (force)`,
+        impact: "disruptive",
+        when: "INIT_FAILED",
+        available: true
+      });
+    }
+    if (cmd.id.includes("clean") || cmd.id.includes("reset")) {
+      suggestions.push({
+        id: `${cmd.group.toUpperCase()}_CLEAN_HARD`,
+        command: `kb ${cmd.group} ${cmd.id.split(":")[1] || ""}`,
+        args: ["--hard"],
+        description: `${cmd.describe} (hard)`,
+        impact: "disruptive",
+        when: "CLEAN_NEEDED",
+        available: true
+      });
+    }
+  }
+  return suggestions;
+}
+
+// src/multi-cli-suggestions.ts
+var MultiCLISuggestions = class {
+  packages = /* @__PURE__ */ new Map();
+  globalRegistry = null;
+  /**
+   * Register a CLI package
+   */
+  registerPackage(pkg) {
+    this.packages.set(pkg.name, pkg);
+    this.globalRegistry = null;
+  }
+  /**
+   * Get or create global command registry
+   */
+  getGlobalRegistry() {
+    if (this.globalRegistry) {
+      return this.globalRegistry;
+    }
+    const allCommands = [];
+    for (const pkg of this.packages.values()) {
+      allCommands.push(...extractCommandIds(pkg.commands));
+    }
+    this.globalRegistry = createCommandRegistry(allCommands);
+    return this.globalRegistry;
+  }
+  /**
+   * Generate suggestions for a specific group
+   */
+  generateGroupSuggestions(group, context) {
+    const suggestions = [];
+    const registry = this.getGlobalRegistry();
+    const groupPackages = Array.from(this.packages.values()).filter((pkg) => pkg.group === group).sort((a, b) => b.priority - a.priority);
+    for (const pkg of groupPackages) {
+      const groupSuggestions = generateGroupSuggestions(
+        pkg.commands,
+        group,
+        context.warningCodes);
+      for (const suggestion of groupSuggestions) {
+        if (registry.commands.has(suggestion.command.replace("kb ", "").replace(" ", ":"))) {
+          suggestions.push({
+            id: suggestion.id,
+            command: suggestion.command,
+            args: suggestion.args,
+            description: suggestion.description,
+            impact: suggestion.impact,
+            when: suggestion.when,
+            available: true
+          });
+        }
+      }
+    }
+    return suggestions;
+  }
+  /**
+   * Generate all suggestions across all packages
+   */
+  generateAllSuggestions(context) {
+    const suggestions = [];
+    const registry = this.getGlobalRegistry();
+    if (this.packages.has("devlink")) {
+      const devlinkSuggestions = generateDevlinkSuggestions(
+        context.warningCodes,
+        { undo: context.undo },
+        registry
+      );
+      suggestions.push(...devlinkSuggestions);
+    }
+    const groups = /* @__PURE__ */ new Set();
+    for (const pkg of this.packages.values()) {
+      groups.add(pkg.group);
+    }
+    for (const group of groups) {
+      if (group !== "devlink") {
+        const groupSuggestions = this.generateGroupSuggestions(group, context);
+        suggestions.push(...groupSuggestions);
+      }
+    }
+    return suggestions;
+  }
+  /**
+   * Get available commands for a group
+   */
+  getAvailableCommands(group) {
+    const groupPackages = Array.from(this.packages.values()).filter((pkg) => pkg.group === group);
+    const commands = [];
+    for (const pkg of groupPackages) {
+      commands.push(...extractCommandIds(pkg.commands));
+    }
+    return commands;
+  }
+  /**
+   * Get all registered packages
+   */
+  getPackages() {
+    return Array.from(this.packages.values());
+  }
+};
+
+// src/dynamic-command-discovery.ts
+var DynamicCommandDiscovery = class {
+  constructor(manifestLoader, packageNames) {
+    this.manifestLoader = manifestLoader;
+    this.packageNames = packageNames;
+  }
+  manifestCache = /* @__PURE__ */ new Map();
+  commandCache = /* @__PURE__ */ new Map();
+  async getAvailableCommands() {
+    const allCommands = [];
+    for (const packageName of this.packageNames) {
+      try {
+        const manifest = await this.loadManifest(packageName);
+        const commands = manifest.map((cmd) => cmd.id);
+        allCommands.push(...commands);
+      } catch (error) {
+        console.warn(`Failed to load manifest for ${packageName}:`, error);
+      }
+    }
+    return allCommands;
+  }
+  async getCommandInfo(commandId) {
+    if (this.commandCache.has(commandId)) {
+      return this.commandCache.get(commandId);
+    }
+    for (const packageName of this.packageNames) {
+      try {
+        const manifest = await this.loadManifest(packageName);
+        const command = manifest.find((cmd) => cmd.id === commandId);
+        if (command) {
+          const [group, name] = commandId.split(":");
+          const info = {
+            id: commandId,
+            group: group || "unknown",
+            name: name || commandId,
+            description: command.describe || `Execute ${commandId}`,
+            available: true
+          };
+          this.commandCache.set(commandId, info);
+          return info;
+        }
+      } catch (error) {
+        console.warn(`Failed to load manifest for ${packageName}:`, error);
+      }
+    }
+    return null;
+  }
+  async isCommandAvailable(commandId) {
+    const info = await this.getCommandInfo(commandId);
+    return info !== null;
+  }
+  async loadManifest(packageName) {
+    if (this.manifestCache.has(packageName)) {
+      return this.manifestCache.get(packageName);
+    }
+    const manifest = await this.manifestLoader.loadManifest(packageName);
+    this.manifestCache.set(packageName, manifest);
+    return manifest;
+  }
+};
+function createKBLabsCommandDiscovery() {
+  const manifestLoader = {
+    async loadManifest(packageName) {
+      try {
+        const possiblePaths = [
+          `@kb-labs/${packageName}/cli.manifest.js`,
+          `@kb-labs/${packageName}/dist/cli.manifest.js`,
+          `@kb-labs/${packageName}/src/cli.manifest.js`
+        ];
+        for (const path2 of possiblePaths) {
+          try {
+            const manifest = await import(path2);
+            if (manifest.commands && Array.isArray(manifest.commands)) {
+              return manifest.commands;
+            }
+          } catch {
+            continue;
+          }
+        }
+        throw new Error(`No manifest found for ${packageName}`);
+      } catch (error) {
+        console.warn(`Failed to load manifest for ${packageName}:`, error);
+        return [];
+      }
+    }
+  };
+  const packageNames = [
+    "devlink-core",
+    "mind-cli",
+    "tox-cli",
+    "core-cli"
+  ];
+  return new DynamicCommandDiscovery(manifestLoader, packageNames);
+}
+function displayArtifacts(artifacts, options = {}) {
+  const {
+    showSize = true,
+    showTime = true,
+    showDescription = false,
+    maxItems = 10,
+    title = "Generated Artifacts",
+    groupBy = "none"
+  } = options;
+  if (artifacts.length === 0) {
+    return [];
+  }
+  let sortedArtifacts = artifacts;
+  if (groupBy === "time") {
+    sortedArtifacts = [...artifacts].sort(
+      (a, b) => (b.modified?.getTime() ?? 0) - (a.modified?.getTime() ?? 0)
+    );
+  } else if (groupBy === "type") {
+    sortedArtifacts = [...artifacts].sort((a, b) => a.name.localeCompare(b.name));
+  } else {
+    sortedArtifacts = [...artifacts].sort(
+      (a, b) => (b.modified?.getTime() ?? 0) - (a.modified?.getTime() ?? 0)
+    );
+  }
+  sortedArtifacts = sortedArtifacts.slice(0, maxItems);
+  const lines = [];
+  if (title) {
+    lines.push(safeColors.bold(title));
+  }
+  if (groupBy === "type") {
+    const grouped = sortedArtifacts.reduce((acc, artifact) => {
+      const type = artifact.name.split(" ")[0] || "Other";
+      if (!acc[type]) {
+        acc[type] = [];
+      }
+      acc[type].push(artifact);
+      return acc;
+    }, {});
+    Object.entries(grouped).forEach(([type, items], index) => {
+      if (index > 0 || title) {
+        lines.push("");
+      }
+      lines.push(...safeKeyValue({ [type]: "" }, { pad: false }));
+      items.forEach((artifact, artifactIndex) => {
+        if (artifactIndex > 0) {
+          lines.push("");
+        }
+        lines.push(...formatArtifactLines(artifact, {
+          showSize,
+          showTime,
+          showDescription,
+          indent: 2
+        }));
+      });
+    });
+    return lines;
+  }
+  sortedArtifacts.forEach((artifact, index) => {
+    if (index > 0) {
+      lines.push("");
+    }
+    lines.push(...formatArtifactLines(artifact, {
+      showSize,
+      showTime,
+      showDescription,
+      indent: 0
+    }));
+  });
+  return lines;
+}
+function formatArtifactLines(artifact, options) {
+  const { showSize, showTime, showDescription, indent: indent2 } = options;
+  const relativePath = path.relative(process.cwd(), artifact.path);
+  const lines = [];
+  lines.push(
+    ...safeKeyValue({ [artifact.name]: relativePath }, { pad: false, indent: indent2 })
+  );
+  if (showSize && artifact.size) {
+    lines.push(
+      ...safeKeyValue({ Size: formatSize(artifact.size) }, { pad: false, indent: indent2 + 2 })
+    );
+  }
+  if (showTime && artifact.modified) {
+    lines.push(
+      ...safeKeyValue({ Updated: formatRelativeTime(artifact.modified) }, { pad: false, indent: indent2 + 2 })
+    );
+  }
+  if (showDescription && artifact.description) {
+    lines.push(
+      ...safeKeyValue({ Note: artifact.description }, { pad: false, indent: indent2 + 2 })
+    );
+  }
+  return lines;
+}
+function displaySingleArtifact(artifact, title) {
+  const relativePath = path.relative(process.cwd(), artifact.path);
+  const lines = [];
+  if (title) {
+    lines.push("");
+    lines.push(safeColors.bold(title));
+  }
+  lines.push(`  ${safeColors.bold(artifact.name)}: ${safeColors.info(relativePath)}`);
+  if (artifact.size) {
+    lines.push(`    Size: ${formatSize(artifact.size)}`);
+  }
+  if (artifact.modified) {
+    lines.push(`    Modified: ${formatRelativeTime(artifact.modified)}`);
+  }
+  if (artifact.description) {
+    lines.push(`    Description: ${artifact.description}`);
+  }
+  return lines;
+}
+function displayArtifactsCompact(artifacts, options = {}) {
+  const {
+    maxItems = 5,
+    showSize = true,
+    sortByTime = true,
+    showTime = true,
+    title = "Artifacts"
+  } = options;
+  if (artifacts.length === 0) {
+    return [];
+  }
+  const sortedArtifacts = (sortByTime ? [...artifacts].sort((a, b) => (b.modified?.getTime() ?? 0) - (a.modified?.getTime() ?? 0)) : artifacts.slice()).slice(0, maxItems);
+  const lines = [];
+  lines.push(safeColors.bold(title));
+  sortedArtifacts.forEach((artifact, index) => {
+    if (index > 0) {
+      lines.push("");
+    }
+    lines.push(
+      ...formatArtifactLines(artifact, {
+        showSize,
+        showTime,
+        showDescription: false,
+        indent: 0
+      })
+    );
+  });
+  return lines;
+}
+async function discoverArtifacts(baseDir, patterns) {
+  const artifacts = [];
+  for (const artifact of patterns) {
+    const artifactPath = path.join(baseDir, artifact.pattern);
+    try {
+      await promises.access(artifactPath);
+      const stats = await promises.stat(artifactPath);
+      artifacts.push({
+        name: artifact.name,
+        path: artifactPath,
+        size: stats.size,
+        modified: stats.mtime,
+        description: artifact.description || ""
+      });
+    } catch {
+    }
+  }
+  return artifacts;
+}
+
+// src/table.ts
+function visualWidth(str) {
+  const ansiRegex = /\x1B\[[0-9;]*[a-zA-Z]/g;
+  const cleanStr = str.replace(ansiRegex, "");
+  const emojiRegex = /[\u{1F300}-\u{1F9FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]|[\u{1F600}-\u{1F64F}]|[\u{1F680}-\u{1F6FF}]|[\u{1F900}-\u{1F9FF}]|[\u{1FA00}-\u{1FA6F}]|[\u{1FA70}-\u{1FAFF}]|[\u{2190}-\u{21FF}]|[\u{2300}-\u{23FF}]|[\u{24C2}-\u{1F251}]|[\u{2B50}-\u{2B55}]|[\u{3030}-\u{303D}]|[\u{3297}-\u{3299}]|[\u{1F000}-\u{1F02F}]|[\u{1F0A0}-\u{1F0FF}]|[\u{1F100}-\u{1F1FF}]|[\u{1F200}-\u{1F2FF}]|[\u{1F300}-\u{1F5FF}]|[\u{1F600}-\u{1F64F}]|[\u{1F680}-\u{1F6FF}]|[\u{1F700}-\u{1F7FF}]|[\u{1F800}-\u{1F8FF}]|[\u{1F900}-\u{1F9FF}]|[\u{1FA00}-\u{1FA6F}]|[\u{1FA70}-\u{1FAFF}]|[\u{23F0}-\u{23FF}]|[\u{25A0}-\u{25FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]|[\u{FE00}-\u{FE0F}]|[\u{1F1E6}-\u{1F1FF}]|[\u{1F3FB}-\u{1F3FF}]|[\u{1F9B0}-\u{1F9B3}]|[\u{20E3}]|[\u{FE0F}]/gu;
+  const emojiMatches = cleanStr.match(emojiRegex);
+  const emojiCount = emojiMatches ? emojiMatches.length : 0;
+  return cleanStr.length - emojiCount + emojiCount * 2;
+}
+function padVisual(str, width, padChar = " ") {
+  const vWidth = visualWidth(str);
+  const padding = Math.max(0, width - vWidth);
+  return str + padChar.repeat(padding);
+}
+function formatTable(columns, rows, options = {}) {
+  const { header = true, separator = "\u2500", padding = 1 } = options;
+  const widths = columns.map((col, idx) => {
+    if (col.width !== void 0) {
+      return col.width;
+    }
+    let maxWidth = visualWidth(col.header);
+    for (const row of rows) {
+      if (row[idx]) {
+        maxWidth = Math.max(maxWidth, visualWidth(String(row[idx])));
+      }
+    }
+    return maxWidth;
+  });
+  const lines = [];
+  if (header) {
+    const headerCells = columns.map((col, idx) => {
+      const cell = col.header;
+      const width = widths[idx];
+      return padVisual(cell, width);
+    });
+    lines.push(headerCells.join(" ".repeat(padding)));
+    if (separator) {
+      const separatorLine = widths.map((w) => separator.repeat(w)).join(" ".repeat(padding));
+      lines.push(separatorLine);
+    }
+  }
+  for (const row of rows) {
+    const cells = columns.map((col, idx) => {
+      const cell = row[idx] !== void 0 ? String(row[idx]) : "";
+      const align = col.align || "left";
+      const width = widths[idx];
+      if (align === "right") {
+        const vWidth = visualWidth(cell);
+        const padding2 = Math.max(0, width - vWidth);
+        return " ".repeat(padding2) + cell;
+      } else if (align === "center") {
+        const vWidth = visualWidth(cell);
+        const padding2 = Math.max(0, width - vWidth);
+        const leftPad = Math.floor(padding2 / 2);
+        const rightPad = padding2 - leftPad;
+        return " ".repeat(leftPad) + cell + " ".repeat(rightPad);
+      } else {
+        return padVisual(cell, width);
+      }
+    });
+    lines.push(cells.join(" ".repeat(padding)));
+  }
+  return lines;
+}
+function formatKeyValueTable(data, options = {}) {
+  const keys = Object.keys(data);
+  if (keys.length === 0) {
+    return [];
+  }
+  const keyWidth = options.keyWidth || Math.max(...keys.map((k) => visualWidth(k)), 0);
+  const valueWidth = options.valueWidth || Math.max(...Object.values(data).map((v) => visualWidth(String(v))), 0);
+  return keys.map((key) => {
+    const value = String(data[key]);
+    return `${padVisual(key, keyWidth)}  ${padVisual(value, valueWidth)}`;
+  });
+}
+
+// src/debug/formatters/ai.ts
+function formatDebugEntryAI(entry) {
+  return JSON.stringify(entry, null, 2);
+}
+function formatDebugEntriesAI(entries) {
+  return JSON.stringify(entries, null, 2);
+}
+function shouldUseAIFormat(format, jsonMode) {
+  if (jsonMode) {
+    return true;
+  }
+  return format === "ai";
+}
+
+// src/debug/formatters/human.ts
+function formatTimestamp2(timestamp) {
+  const date = new Date(timestamp);
+  return date.toISOString();
+}
+function formatDuration(duration) {
+  if (duration < 1e3) {
+    return `${duration}ms`;
+  }
+  return `${(duration / 1e3).toFixed(2)}s`;
+}
+function formatDebugEntryHuman(entry, options = {}) {
+  const parts = [];
+  if (options.showTimestamp) {
+    parts.push(safeColors.dim(formatTimestamp2(entry.timestamp)));
+  }
+  parts.push(safeColors.bold(`[${entry.namespace}]`));
+  parts.push(entry.message);
+  if (options.showDuration && typeof entry.duration === "number") {
+    parts.push(safeColors.dim(`(${formatDuration(entry.duration)})`));
+  }
+  if (entry.level === "error") {
+    parts.push(safeColors.error(safeSymbols.error));
+  } else if (entry.level === "warn") {
+    parts.push(safeColors.warning(safeSymbols.warning));
+  }
+  return parts.join(" ");
+}
+function formatDebugEntriesHuman(entries, options = {}) {
+  if (entries.length === 0) {
+    return "";
+  }
+  const sorted = [...entries].sort((a, b) => a.timestamp - b.timestamp);
+  const lines = [];
+  if (options.groupBy === "namespace") {
+    const namespaces = /* @__PURE__ */ new Map();
+    for (const entry of sorted) {
+      if (!namespaces.has(entry.namespace)) {
+        namespaces.set(entry.namespace, []);
+      }
+      namespaces.get(entry.namespace).push(entry);
+    }
+    for (const [namespace, namespaceEntries] of namespaces) {
+      lines.push(safeColors.bold(namespace));
+      for (const entry of namespaceEntries) {
+        lines.push(`  ${formatDebugEntryHuman(entry, options)}`);
+      }
+      lines.push("");
+    }
+    return lines.join("\n").trimEnd();
+  }
+  if (options.groupBy === "group") {
+    const groups = /* @__PURE__ */ new Map();
+    for (const entry of sorted) {
+      const groupName = entry.group ?? "default";
+      if (!groups.has(groupName)) {
+        groups.set(groupName, []);
+      }
+      groups.get(groupName).push(entry);
+    }
+    for (const [groupName, groupEntries] of groups) {
+      lines.push(safeColors.bold(groupName));
+      for (const entry of groupEntries) {
+        lines.push(`  ${formatDebugEntryHuman(entry, options)}`);
+      }
+      lines.push("");
+    }
+    return lines.join("\n").trimEnd();
+  }
+  for (const entry of sorted) {
+    lines.push(formatDebugEntryHuman(entry, options));
+  }
+  return lines.join("\n");
+}
+
+// src/debug/utilities.ts
+function toRegex(pattern) {
+  if (!pattern.includes("*")) {
+    return new RegExp(`^${pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "i");
+  }
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`, "i");
+}
+function filterByNamespace(entries, pattern) {
+  const matcher = typeof pattern === "string" ? toRegex(pattern) : pattern;
+  return entries.filter((entry) => matcher.test(entry.namespace));
+}
+function filterByLevel(entries, level) {
+  const allowed = Array.isArray(level) ? new Set(level) : /* @__PURE__ */ new Set([level]);
+  return entries.filter((entry) => allowed.has(entry.level));
+}
+function filterByTimeRange(entries, from, to) {
+  return entries.filter((entry) => {
+    if (from !== void 0 && entry.timestamp < from) {
+      return false;
+    }
+    if (to !== void 0 && entry.timestamp > to) {
+      return false;
+    }
+    return true;
+  });
+}
+function searchInLogs(entries, query) {
+  const lowered = query.toLowerCase();
+  return entries.filter((entry) => {
+    if (entry.message.toLowerCase().includes(lowered)) {
+      return true;
+    }
+    if (entry.namespace.toLowerCase().includes(lowered)) {
+      return true;
+    }
+    if (entry.meta) {
+      const metaString = JSON.stringify(entry.meta).toLowerCase();
+      if (metaString.includes(lowered)) {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+function filterDebugEntries(entries, options) {
+  let filtered = [...entries];
+  if (options.namespace) {
+    filtered = filterByNamespace(filtered, options.namespace);
+  }
+  if (options.level) {
+    filtered = filterByLevel(filtered, options.level);
+  }
+  if (options.timeRange) {
+    filtered = filterByTimeRange(filtered, options.timeRange.from, options.timeRange.to);
+  }
+  if (options.search) {
+    filtered = searchInLogs(filtered, options.search);
+  }
+  if (options.traceId) {
+    filtered = filtered.filter((entry) => entry.traceId === options.traceId);
+  }
+  return filtered;
+}
+function groupByNamespace(entries) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!map.has(entry.namespace)) {
+      map.set(entry.namespace, []);
+    }
+    map.get(entry.namespace).push(entry);
+  }
+  return map;
+}
+function groupByGroup(entries) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const group = entry.group ?? "default";
+    if (!map.has(group)) {
+      map.set(group, []);
+    }
+    map.get(group).push(entry);
+  }
+  return map;
+}
+function createDebugTree(entries) {
+  if (entries.length === 0) {
+    return null;
+  }
+  const sorted = [...entries].sort((a, b) => a.timestamp - b.timestamp);
+  const nodes = /* @__PURE__ */ new Map();
+  let root = null;
+  function ensureNode(entry) {
+    if (entry.spanId && nodes.has(entry.spanId)) {
+      return nodes.get(entry.spanId);
+    }
+    const node = { entry, children: [], depth: 0 };
+    if (entry.spanId) {
+      nodes.set(entry.spanId, node);
+    }
+    return node;
+  }
+  for (const entry of sorted) {
+    const node = ensureNode(entry);
+    if (entry.parentSpanId && nodes.has(entry.parentSpanId)) {
+      const parent = nodes.get(entry.parentSpanId);
+      node.depth = parent.depth + 1;
+      parent.children.push(node);
+    } else if (root === null) {
+      root = node;
+    } else {
+      node.depth = root.depth + 1;
+      root.children.push(node);
+    }
+  }
+  return root;
+}
+function exportToJSON(entries, options = {}) {
+  const filtered = options.filter ? filterDebugEntries(entries, options.filter) : entries;
+  if (options.includeMeta === false) {
+    return JSON.stringify(
+      filtered.map(({ meta, ...rest }) => rest),
+      null,
+      2
+    );
+  }
+  return JSON.stringify(filtered, null, 2);
+}
+function exportToChromeFormat(entries, options = {}) {
+  const filtered = options.filter ? filterDebugEntries(entries, options.filter) : entries;
+  const traceEvents = filtered.map((entry) => ({
+    name: entry.message,
+    cat: entry.namespace,
+    ph: entry.level === "error" ? "E" : entry.level === "warn" ? "W" : "X",
+    ts: entry.timestamp * 1e3,
+    dur: (entry.duration ?? 0) * 1e3,
+    pid: 1,
+    tid: entry.spanId ?? entry.namespace,
+    args: entry.meta ?? {}
+  }));
+  return JSON.stringify({ traceEvents }, null, 2);
+}
+function exportToPlainText(entries, options = {}) {
+  const filtered = options.filter ? filterDebugEntries(entries, options.filter) : entries;
+  return formatDebugEntriesHuman(filtered, { groupBy: "namespace", showTimestamp: true, showDuration: true });
+}
+function exportDebugEntries(entries, options) {
+  const format = options.format ?? "json";
+  switch (format) {
+    case "chrome":
+      return exportToChromeFormat(entries, options);
+    case "text":
+      return exportToPlainText(entries, options);
+    case "json":
+    default:
+      return exportToJSON(entries, options);
+  }
+}
+function describeEntriesHuman(entries, options = {}) {
+  const filtered = filterDebugEntries(entries, options);
+  return formatDebugEntriesHuman(filtered, { showTimestamp: true, showDuration: true, groupBy: "namespace" });
+}
+function describeEntriesAI(entries, options = {}) {
+  const filtered = filterDebugEntries(entries, options);
+  return formatDebugEntriesAI(filtered);
+}
+function describeEntriesTimeline(entries, options = {}) {
+  const filtered = filterDebugEntries(entries, options);
+  return formatTimelineWithSummary(filtered);
+}
+
+// src/debug/formatters/timeline.ts
+function formatDuration2(duration) {
+  if (duration < 1e3) {
+    return `${duration}ms`;
+  }
+  return `${(duration / 1e3).toFixed(2)}s`;
+}
+function formatTimelineNode(node, isLast, prefix = "", maxDepth) {
+  const lines = [];
+  const connector = isLast ? "\u2514\u2500" : "\u251C\u2500";
+  const parts = [];
+  parts.push(safeColors.bold(`[${node.entry.namespace}]`));
+  parts.push(node.entry.message);
+  if (typeof node.entry.duration === "number") {
+    parts.push(safeColors.dim(`(${formatDuration2(node.entry.duration)})`));
+  }
+  if (node.entry.level === "error") {
+    parts.push(safeColors.error(safeSymbols.error));
+  } else if (node.entry.level === "warn") {
+    parts.push(safeColors.warning(safeSymbols.warning));
+  }
+  lines.push(`${prefix}${connector} ${parts.join(" ")}`.trimEnd());
+  if (maxDepth !== void 0 && node.depth + 1 >= maxDepth) {
+    return lines;
+  }
+  const childPrefix = prefix + (isLast ? "   " : "\u2502  ");
+  for (let index = 0; index < node.children.length; index++) {
+    const child = node.children[index];
+    if (!child) {
+      continue;
+    }
+    const childIsLast = index === node.children.length - 1;
+    lines.push(...formatTimelineNode(child, childIsLast, childPrefix, maxDepth));
+  }
+  return lines;
+}
+function formatTimeline(entries) {
+  if (entries.length === 0) {
+    return "";
+  }
+  const tree = createDebugTree(entries);
+  if (!tree) {
+    return "";
+  }
+  return formatTimelineNode(tree, true).join("\n");
+}
+function formatTimelineWithSummary(entries) {
+  const timeline = formatTimeline(entries);
+  if (timeline.length === 0) {
+    return "";
+  }
+  const totalDuration = entries.reduce((acc, entry) => acc + (entry.duration ?? 0), 0);
+  const errorCount = entries.filter((entry) => entry.level === "error").length;
+  const warnCount = entries.filter((entry) => entry.level === "warn").length;
+  const summaryParts = [];
+  if (totalDuration > 0) {
+    summaryParts.push(`Total: ${formatDuration2(totalDuration)}`);
+  }
+  if (errorCount > 0) {
+    summaryParts.push(safeColors.error(`${errorCount} errors`));
+  }
+  if (warnCount > 0) {
+    summaryParts.push(safeColors.warning(`${warnCount} warnings`));
+  }
+  if (summaryParts.length === 0) {
+    return timeline;
+  }
+  return `${timeline}
+
+${safeColors.bold("Summary:")} ${summaryParts.join(", ")}`;
+}
+
+// src/debug/components/output.ts
+function formatDebugOutput(entry, options = {}) {
+  if (shouldUseAIFormat(options.format)) {
+    return formatDebugEntryAI(entry);
+  }
+  return formatDebugEntryHuman(entry, options);
+}
+function formatDebugOutputs(entries, options = {}) {
+  if (shouldUseAIFormat(options.format)) {
+    return formatDebugEntriesAI(entries);
+  }
+  if (options.useTimeline) {
+    return formatTimelineWithSummary(entries);
+  }
+  return formatDebugEntriesHuman(entries, options);
+}
+var DebugSection = class {
+  entries = [];
+  title;
+  options;
+  constructor(title, options = {}) {
+    this.title = title;
+    this.options = options;
+  }
+  add(entry) {
+    this.entries.push(entry);
+  }
+  addAll(entries) {
+    this.entries.push(...entries);
+  }
+  clear() {
+    this.entries.length = 0;
+  }
+  format() {
+    if (this.entries.length === 0) {
+      return "";
+    }
+    const content = formatDebugOutputs(this.entries, this.options);
+    if (!content) {
+      return "";
+    }
+    if (shouldUseAIFormat(this.options.format)) {
+      return content;
+    }
+    return box(this.title, content.split("\n"));
+  }
+  get count() {
+    return this.entries.length;
+  }
+};
+var DebugOutput = class {
+  sections = /* @__PURE__ */ new Map();
+  globalEntries = [];
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  add(entry) {
+    this.globalEntries.push(entry);
+  }
+  addToSection(sectionName, entry) {
+    if (!this.sections.has(sectionName)) {
+      this.sections.set(sectionName, new DebugSection(sectionName, this.options));
+    }
+    this.sections.get(sectionName).add(entry);
+  }
+  getSection(sectionName) {
+    if (!this.sections.has(sectionName)) {
+      this.sections.set(sectionName, new DebugSection(sectionName, this.options));
+    }
+    return this.sections.get(sectionName);
+  }
+  format() {
+    const parts = [];
+    if (this.globalEntries.length > 0) {
+      const formatted = formatDebugOutputs(this.globalEntries, this.options);
+      if (formatted) {
+        parts.push(formatted);
+      }
+    }
+    for (const [, section2] of this.sections) {
+      const formatted = section2.format();
+      if (formatted) {
+        parts.push(formatted);
+      }
+    }
+    return parts.join("\n\n");
+  }
+  clear() {
+    this.globalEntries.length = 0;
+    this.sections.clear();
+  }
+  get totalCount() {
+    let count = this.globalEntries.length;
+    for (const section2 of this.sections.values()) {
+      count += section2.count;
+    }
+    return count;
+  }
+};
+
+// src/debug/components/tree.ts
+var DebugTree = class {
+  tree = null;
+  options;
+  constructor(entries, options = {}) {
+    this.options = options;
+    this.tree = createDebugTree(entries);
+  }
+  update(entries) {
+    this.tree = createDebugTree(entries);
+  }
+  format() {
+    if (!this.tree) {
+      return "";
+    }
+    const lines = formatTimelineNode(this.tree, true, "", this.options.maxDepth);
+    if (this.options.showSummary) {
+      const summary = this.getSummary();
+      if (summary) {
+        lines.push("", summary);
+      }
+    }
+    return lines.join("\n");
+  }
+  getSummary() {
+    if (!this.tree) {
+      return "";
+    }
+    const stats = this.collectStats(this.tree);
+    const parts = [];
+    if (stats.totalDuration > 0) {
+      parts.push(`total ${stats.totalDuration}ms`);
+    }
+    if (stats.errorCount > 0) {
+      parts.push(`${stats.errorCount} errors`);
+    }
+    if (stats.warnCount > 0) {
+      parts.push(`${stats.warnCount} warnings`);
+    }
+    parts.push(`${stats.nodeCount} nodes`);
+    return `Summary: ${parts.join(", ")}`;
+  }
+  collectStats(node) {
+    let totalDuration = node.entry.duration ?? 0;
+    let errorCount = node.entry.level === "error" ? 1 : 0;
+    let warnCount = node.entry.level === "warn" ? 1 : 0;
+    let nodeCount = 1;
+    for (const child of node.children) {
+      const childStats = this.collectStats(child);
+      totalDuration += childStats.totalDuration;
+      errorCount += childStats.errorCount;
+      warnCount += childStats.warnCount;
+      nodeCount += childStats.nodeCount;
+    }
+    return { totalDuration, errorCount, warnCount, nodeCount };
+  }
+  get root() {
+    return this.tree;
+  }
+};
+
+// src/debug/components/trace.ts
+var DebugTrace = class {
+  entries = [];
+  options;
+  constructor(entries = [], options = {}) {
+    this.entries.push(...entries);
+    this.options = options;
+  }
+  add(entry) {
+    this.entries.push(entry);
+  }
+  addAll(entries) {
+    this.entries.push(...entries);
+  }
+  clear() {
+    this.entries.length = 0;
+  }
+  format() {
+    if (this.entries.length === 0) {
+      return "";
+    }
+    const sorted = [...this.entries].sort((a, b) => a.timestamp - b.timestamp);
+    if (this.options.groupByPlugin) {
+      return this.formatGrouped(sorted);
+    }
+    return formatTimelineWithSummary(sorted);
+  }
+  formatGrouped(entries) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const plugin = entry.namespace.split(":")[0] ?? entry.namespace;
+      if (!groups.has(plugin)) {
+        groups.set(plugin, []);
+      }
+      groups.get(plugin).push(entry);
+    }
+    const parts = [];
+    for (const [plugin, pluginEntries] of groups) {
+      const tree = new DebugTree(pluginEntries, {
+        showSummary: this.options.showSummary,
+        maxDepth: this.options.maxDepth
+      });
+      const formatted = tree.format();
+      if (formatted) {
+        parts.push(`[${plugin}]`, formatted);
+      }
+    }
+    return parts.join("\n\n");
+  }
+  getStats() {
+    const plugins = /* @__PURE__ */ new Set();
+    let totalDuration = 0;
+    let errorCount = 0;
+    let warnCount = 0;
+    for (const entry of this.entries) {
+      const plugin = entry.namespace.split(":")[0] ?? entry.namespace;
+      plugins.add(plugin);
+      totalDuration += entry.duration ?? 0;
+      if (entry.level === "error") {
+        errorCount += 1;
+      } else if (entry.level === "warn") {
+        warnCount += 1;
+      }
+    }
+    return {
+      totalEntries: this.entries.length,
+      plugins: Array.from(plugins),
+      totalDuration,
+      errorCount,
+      warnCount
+    };
+  }
+};
+
+// src/command-runner.ts
+function createCommandRunner(options) {
+  return async (ctx, argv, flags) => {
+    const tracker = new TimingTracker();
+    const jsonMode = flags.json === true;
+    const quietMode = flags.quiet === true;
+    let runScope = null;
+    if (options.analytics !== void 0) {
+      try {
+        const analyticsModule = await import('@kb-labs/analytics-sdk-node');
+        if (analyticsModule.runScope) {
+          runScope = analyticsModule.runScope;
+        }
+      } catch {
+        runScope = null;
+      }
+    }
+    const execute = async () => {
+      tracker.checkpoint("start");
+      try {
+        const result2 = await options.execute(ctx, flags, tracker);
+        tracker.checkpoint("complete");
+        formatSuccessOutput(ctx, options.title, result2, tracker.total(), {
+          jsonMode,
+          quietMode
+        });
+        return 0;
+      } catch (error) {
+        tracker.checkpoint("error");
+        const message = error instanceof Error ? error.message : String(error);
+        formatErrorOutput(ctx, message, tracker.total(), {
+          jsonMode,
+          quietMode
+        });
+        return 1;
+      }
+    };
+    if (!runScope || !options.analytics) {
+      return execute();
+    }
+    const totalStart = Date.now();
+    const result = await runScope(
+      {
+        actor: options.analytics.actor,
+        ctx: { workspace: ctx.cwd }
+      },
+      async (emit) => {
+        await emit({
+          type: options.analytics.started,
+          payload: options.analytics.getPayload?.(flags) ?? {}
+        });
+        let exitCode = 0;
+        try {
+          exitCode = await execute();
+          await emit({
+            type: options.analytics.finished,
+            payload: {
+              ...options.analytics.getPayload?.(flags) ?? {},
+              durationMs: Date.now() - totalStart,
+              result: exitCode === 0 ? "success" : "error"
+            }
+          });
+        } catch (error) {
+          await emit({
+            type: options.analytics.finished,
+            payload: {
+              ...options.analytics.getPayload?.(flags) ?? {},
+              durationMs: Date.now() - totalStart,
+              result: "error",
+              error: error instanceof Error ? error.message : String(error)
+            }
+          });
+          throw error;
+        }
+        return exitCode;
+      }
+    );
+    return result;
+  };
+}
+function formatSuccessOutput(ctx, title, result, durationMs, flags) {
+  if (flags.jsonMode) {
+    const payload = {
+      ok: true,
+      summary: result.summary,
+      timing: result.timing ?? durationMs,
+      diagnostics: result.diagnostics,
+      warnings: result.warnings,
+      errors: result.errors
+    };
+    if (result.artifacts) {
+      payload.artifacts = result.artifacts;
+    }
+    if (result.data) {
+      Object.assign(payload, result.data);
+    }
+    ctx.presenter.json(payload);
+    return;
+  }
+  if (flags.quietMode) {
+    return;
+  }
+  const statusEntry = extractStatusEntry(result.summary);
+  const summaryForDisplay = statusEntry ? { ...result.summary } : result.summary;
+  if (statusEntry) {
+    delete summaryForDisplay[statusEntry.key];
+  }
+  const lines = [];
+  const summaryLines = keyValue(summaryForDisplay);
+  if (summaryLines.length > 0) {
+    lines.push(...summaryLines);
+  }
+  if (result.artifacts && result.artifacts.length > 0) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push(...displayArtifacts(result.artifacts, result.artifactsOptions));
+  }
+  const timing = result.timing ?? durationMs;
+  if (typeof timing !== "number") {
+    const entries = Object.entries(timing);
+    if (entries.length > 0) {
+      if (lines.length > 0) {
+        lines.push("");
+      }
+      lines.push(safeColors.bold("Timing"));
+      for (const [label, value] of entries) {
+        lines.push(...safeKeyValue({ [label]: formatTiming(value) }, { indent: 2, pad: false }));
+      }
+    }
+  }
+  if (result.diagnostics && result.diagnostics.length > 0) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push(safeColors.bold("Diagnostics"));
+    result.diagnostics.forEach((item) => lines.push(safeColors.muted(`- ${item}`)));
+  }
+  if (result.warnings && result.warnings.length > 0) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push(safeColors.bold("Warnings"));
+    result.warnings.forEach((item) => lines.push(safeColors.muted(`- ${item}`)));
+  }
+  if (result.errors && result.errors.length > 0) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push(safeColors.bold("Errors"));
+    result.errors.forEach((item) => lines.push(safeColors.muted(`- ${item}`)));
+  }
+  if (lines.length > 0) {
+    lines.push("");
+  }
+  lines.push(formatStatusLine(statusEntry?.value, durationMs));
+  ctx.presenter.write(box(title, lines));
+}
+function formatErrorOutput(ctx, errorMessage, durationMs, flags) {
+  if (flags.jsonMode) {
+    ctx.presenter.json({
+      ok: false,
+      error: errorMessage,
+      timing: durationMs
+    });
+    return;
+  }
+  if (flags.quietMode) {
+    return;
+  }
+  ctx.presenter.error(errorMessage);
+}
+function extractStatusEntry(summary) {
+  for (const [key, value] of Object.entries(summary)) {
+    if (typeof value === "string" && key.toLowerCase().includes("status")) {
+      return { key, value };
+    }
+  }
+  return null;
+}
+function formatStatusLine(statusValue, durationMs) {
+  const rawStatus = statusValue ?? "Done";
+  const normalized = rawStatus.toLowerCase();
+  let symbol = safeSymbols.success;
+  let colorize = safeColors.success;
+  if (normalized.includes("error") || normalized.includes("fail")) {
+    symbol = safeSymbols.error;
+    colorize = safeColors.error;
+  } else if (normalized.includes("partial") || normalized.includes("warn")) {
+    symbol = safeSymbols.warning;
+    colorize = safeColors.warning;
+  }
+  const statusText = hasAnsi(rawStatus) ? rawStatus : colorize(rawStatus);
+  return `${symbol} ${statusText} \xB7 ${safeColors.muted(formatTiming(durationMs))}`;
+}
+
+// src/utils/flags.ts
+function defineFlags(schema) {
+  return {
+    schema,
+    type: {},
+    parse: (input) => parseFlagsFromInput(input, schema)
+  };
+}
+function parseFlagsFromInput(input, schema) {
+  const result = {};
+  const rawInput = input;
+  for (const [key, spec] of Object.entries(schema)) {
+    const value = rawInput?.[key];
+    if (value === void 0) {
+      if ("default" in spec) {
+        result[key] = spec.default;
+      }
+      continue;
+    }
+    switch (spec.type) {
+      case "boolean":
+        result[key] = parseBoolean(value, key);
+        break;
+      case "string":
+        result[key] = parseString(value, key);
+        if (spec.validate && result[key] !== void 0) {
+          spec.validate(result[key]);
+        }
+        break;
+      case "number":
+        result[key] = parseNumber(value, key);
+        if (spec.validate && result[key] !== void 0) {
+          spec.validate(result[key]);
+        }
+        break;
+    }
+  }
+  return result;
+}
+function parseBoolean(value, flagName) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const lower = value.toLowerCase();
+    if (lower === "true" || lower === "1" || lower === "yes") {
+      return true;
+    }
+    if (lower === "false" || lower === "0" || lower === "no") {
+      return false;
+    }
+  }
+  throw new Error(
+    `Flag "${flagName}" must be boolean, got ${typeof value}. Use true/false or 1/0 or yes/no.`
+  );
+}
+function parseString(value, flagName) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  throw new Error(
+    `Flag "${flagName}" must be string, got ${typeof value}.`
+  );
+}
+function parseNumber(value, flagName) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error(`Flag "${flagName}" must be finite number, got ${value}.`);
+    }
+    return value;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    const parsed = Number(trimmed);
+    if (!Number.isFinite(parsed)) {
+      throw new Error(
+        `Flag "${flagName}" must be number, got invalid string "${value}".`
+      );
+    }
+    return parsed;
+  }
+  throw new Error(
+    `Flag "${flagName}" must be number, got ${typeof value}.`
+  );
+}
+function parseNumberFlag(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : void 0;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+      return void 0;
+    }
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function mergeFlags(input) {
+  if (!input.flags || typeof input.flags !== "object") {
+    return input;
+  }
+  return { ...input, ...input.flags };
+}
+
+// src/utils/env.ts
+function defineEnv(schema) {
+  return {
+    schema,
+    type: {},
+    parse: (runtime) => parseEnvFromRuntime(runtime, schema)
+  };
+}
+function parseEnvFromRuntime(runtime, schema) {
+  const result = {};
+  for (const [key, spec] of Object.entries(schema)) {
+    const rawValue = runtime.env(key);
+    if (rawValue === void 0) {
+      if ("default" in spec) {
+        result[key] = spec.default;
+      }
+      continue;
+    }
+    result[key] = parseEnvValue(rawValue, key, spec);
+  }
+  return result;
+}
+function parseEnvValue(value, key, spec) {
+  if (value === void 0) {
+    return void 0;
+  }
+  switch (spec.type) {
+    case "boolean":
+      return parseBoolean(value, key);
+    case "string":
+      const strValue = parseString(value, key);
+      if (spec.validate) {
+        spec.validate(strValue);
+      }
+      return strValue;
+    case "number":
+      const numValue = parseNumber(value, key);
+      if (spec.validate) {
+        spec.validate(numValue);
+      }
+      return numValue;
+    default:
+      return value;
+  }
+}
+
+// src/utils/context.ts
+function getContextCwd(input) {
+  if (input && typeof input.cwd === "string" && input.cwd.length > 0) {
+    return input.cwd;
+  }
+  return process.cwd();
+}
+
+// src/utils/path.ts
+function toPosixPath(input) {
+  return input.replace(/\\/g, "/");
+}
+
+// src/modern-format.ts
+function sideBorderBox(options) {
+  const { title, sections, footer, status, timing } = options;
+  const lines = [];
+  const titleLine = `${safeSymbols.topLeft}${safeSymbols.separator.repeat(2)} ${safeColors.primary(safeColors.bold(title))}`;
+  lines.push(titleLine);
+  lines.push(safeSymbols.border);
+  for (let i = 0; i < sections.length; i++) {
+    const section2 = sections[i];
+    if (!section2) {
+      continue;
+    }
+    if (section2.header) {
+      lines.push(`${safeSymbols.border} ${safeColors.bold(section2.header)}`);
+    }
+    for (const item of section2.items) {
+      lines.push(`${safeSymbols.border}  ${item}`);
+    }
+    if (i < sections.length - 1) {
+      lines.push(safeSymbols.border);
+    }
+  }
+  if (footer || status || timing !== void 0) {
+    lines.push(safeSymbols.border);
+    const footerParts = [];
+    if (footer) {
+      footerParts.push(footer);
+    } else if (status) {
+      const statusSymbol = getStatusSymbol(status);
+      const statusText = getStatusText(status);
+      const statusColor = getStatusColor(status);
+      footerParts.push(statusColor(`${statusSymbol} ${statusText}`));
+    }
+    if (timing !== void 0) {
+      footerParts.push(formatTiming2(timing));
+    }
+    const footerLine = `${safeSymbols.bottomLeft}${safeSymbols.separator.repeat(2)} ${footerParts.join(" / ")}`;
+    lines.push(footerLine);
+  }
+  return lines.join("\n");
+}
+function sectionHeader(text) {
+  return safeColors.bold(text);
+}
+function metricsList(metrics) {
+  const entries = Object.entries(metrics);
+  if (entries.length === 0) {
+    return [];
+  }
+  const maxKeyLength = Math.max(
+    ...entries.map(([key]) => stripAnsi(key).length)
+  );
+  return entries.map(([key, value]) => {
+    const keyLength = stripAnsi(key).length;
+    const padding = " ".repeat(maxKeyLength - keyLength + 2);
+    const formattedKey = safeColors.bold(key);
+    const formattedValue = safeColors.muted(String(value));
+    return `${formattedKey}:${padding}${formattedValue}`;
+  });
+}
+var bulletList2 = bulletList;
+var formatTiming2 = formatTiming;
+function statusLine(status, timing) {
+  const symbol = getStatusSymbol(status);
+  const text = getStatusText(status);
+  const color = getStatusColor(status);
+  const parts = [color(`${symbol} ${text}`)];
+  if (timing !== void 0) {
+    parts.push(formatTiming2(timing));
+  }
+  return parts.join(" / ");
+}
+function getStatusSymbol(status) {
+  switch (status) {
+    case "success":
+      return safeSymbols.success;
+    case "error":
+      return safeSymbols.error;
+    case "warning":
+      return safeSymbols.warning;
+    case "info":
+      return safeSymbols.info;
+  }
+}
+function getStatusText(status) {
+  switch (status) {
+    case "success":
+      return "Success";
+    case "error":
+      return "Failed";
+    case "warning":
+      return "Warning";
+    case "info":
+      return "Info";
+  }
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "success":
+      return safeColors.success;
+    case "error":
+      return safeColors.error;
+    case "warning":
+      return safeColors.warning;
+    case "info":
+      return safeColors.info;
+  }
+}
+function formatCommandHelp(options) {
+  const { title, description, longDescription, examples, flags, aliases } = options;
+  const sections = [];
+  if (description) {
+    sections.push({
+      header: "Description",
+      items: [description]
+    });
+  }
+  if (longDescription) {
+    sections.push({
+      header: "Details",
+      items: [longDescription]
+    });
+  }
+  if (aliases && aliases.length > 0) {
+    sections.push({
+      header: "Aliases",
+      items: aliases.map((a) => safeColors.muted(a))
+    });
+  }
+  if (flags && flags.length > 0) {
+    const flagItems = flags.map((flag) => {
+      const label = flag.alias ? `--${flag.name}, -${flag.alias}` : `--${flag.name}`;
+      const required = flag.required ? safeColors.warning(" (required)") : "";
+      const desc = flag.description ? safeColors.muted(` \u2014 ${flag.description}`) : "";
+      return `${safeColors.bold(label)}${required}${desc}`;
+    });
+    sections.push({
+      header: "Flags",
+      items: flagItems
+    });
+  }
+  if (examples && examples.length > 0) {
+    sections.push({
+      header: "Examples",
+      items: examples.map((ex) => safeColors.muted(`  ${ex}`))
+    });
+  }
+  return sideBorderBox({
+    title,
+    sections,
+    status: "info"
+  });
+}
+
+// src/command-result.ts
+function formatCommandResult(params) {
+  const {
+    title,
+    summary,
+    details = [],
+    warnings = [],
+    errors = [],
+    timing,
+    status,
+    jsonData
+  } = params;
+  const sections = [];
+  if (summary && Object.keys(summary).length > 0) {
+    sections.push({
+      header: "Summary",
+      items: metricsList(summary)
+    });
+  }
+  for (const detail of details) {
+    sections.push({
+      header: detail.section,
+      items: detail.items
+    });
+  }
+  if (warnings.length > 0) {
+    sections.push({
+      header: "\u26A0 Warnings",
+      items: bulletList2(warnings)
+    });
+  }
+  if (errors.length > 0) {
+    sections.push({
+      header: "\u2717 Errors",
+      items: bulletList2(errors)
+    });
+  }
+  const human = sideBorderBox({
+    title,
+    sections,
+    status,
+    timing
+  });
+  const json = {
+    ok: status === "success",
+    status,
+    ...summary && { summary },
+    ...details.length > 0 && {
+      details: details.reduce((acc, d) => {
+        acc[d.section] = d.items;
+        return acc;
+      }, {})
+    },
+    ...warnings.length > 0 && { warnings },
+    ...errors.length > 0 && { errors },
+    ...timing !== void 0 && { timingMs: timing },
+    ...jsonData && { data: jsonData }
+  };
+  return {
+    ok: status === "success",
+    status,
+    human,
+    json
+  };
+}
+function successResult(title, data) {
+  return formatCommandResult({
+    title,
+    summary: data?.summary,
+    details: data?.details,
+    timing: data?.timing,
+    status: "success",
+    jsonData: data?.json
+  });
+}
+function errorResult(title, error, options) {
+  const errorMessage = error instanceof Error ? error.message : error;
+  const errorStack = error instanceof Error ? error.stack : void 0;
+  return formatCommandResult({
+    title,
+    errors: [errorMessage],
+    details: options?.suggestions ? [{ section: "Suggestions", items: bulletList2(options.suggestions) }] : [],
+    timing: options?.timing,
+    status: "error",
+    jsonData: {
+      error: errorMessage,
+      ...errorStack && { stack: errorStack }
+    }
+  });
+}
+function warningResult(title, warnings, options) {
+  return formatCommandResult({
+    title,
+    warnings,
+    summary: options?.summary,
+    timing: options?.timing,
+    status: "warning"
+  });
+}
+function infoResult(title, data) {
+  return formatCommandResult({
+    title,
+    summary: data?.summary,
+    details: data?.details,
+    timing: data?.timing,
+    status: "info"
+  });
+}
+
+export { DebugOutput, DebugSection, DebugTrace, DebugTree, DynamicCommandDiscovery, Loader, MultiCLISuggestions, StaticCommandDiscovery, TimingTracker, accentLabel, box, bulletList, colors, createCommandDiscovery, createCommandRegistry, createCommandRunner, createDebugTree, createDetailedResult, createKBLabsCommandDiscovery, createProgressBar, createSimpleResult, createSpinner, defineEnv, defineFlags, describeEntriesAI, describeEntriesHuman, describeEntriesTimeline, discoverArtifacts, displayArtifacts, displayArtifactsCompact, displaySingleArtifact, errorResult, exportDebugEntries, exportToChromeFormat, exportToJSON, exportToPlainText, extractCommandGroups, extractCommandIds, filterByLevel, filterByNamespace, filterByTimeRange, filterDebugEntries, findCommandById, findCommandsByGroup, formatCommandHelp, formatCommandOutput, formatCommandResult, formatDebugEntriesAI, formatDebugEntriesHuman, formatDebugEntryAI, formatDebugEntryHuman, formatDebugOutput, formatDebugOutputs, formatKeyValueTable, formatRelativeTime, formatSize, formatTable, formatTimeline, formatTimelineNode, formatTimelineWithSummary, formatTimestamp, formatTiming, formatTimingBreakdown, generateDevlinkSuggestions, generateGroupSuggestions, generateQuickActions, getCommandInfo, getContextCwd, groupByGroup, groupByNamespace, hasAnsi, headline, indent, infoResult, isCommandAvailable, keyValue, mergeFlags, metricsList, muted, pad, parseBoolean, parseEnvFromRuntime, parseFlagsFromInput, parseNumber, parseNumberFlag, parseString, safeColors, safeKeyValue, safeSymbols, searchInLogs, section, sectionHeader, shouldUseAIFormat, showError, showLoading, showSuccess, sideBorderBox, statusLine, stripAnsi, successResult, supportsColor, symbols, table, toPosixPath, truncate, useLoader, validateSuggestions, warningResult };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map