@task-mcp/shared 1.0.21 → 1.0.23

package/src/utils/natural-language.ts

@@ -30,6 +30,170 @@ function validateInputLength(input: string): void {
   }
 }
 
+/**
+ * Extracted metadata from natural language input
+ */
+export interface ExtractedMetadata {
+  /** Extracted priority (!high, !medium, !low, !critical) */
+  priority?: Priority;
+  /** Extracted due date (today, tomorrow, next week, etc.) */
+  dueDate?: string;
+  /** Extracted tags (#tag) */
+  tags?: string[];
+  /** Extracted estimated time in minutes (~2h, ~30m) */
+  estimateMinutes?: number;
+  /** Remaining text after metadata extraction */
+  remaining: string;
+}
+
+/**
+ * Options for metadata extraction
+ */
+export interface ExtractMetadataOptions {
+  /** Extract priority markers (!high, !low, etc.) */
+  extractPriority?: boolean;
+  /** Extract date expressions (today, tomorrow, by Friday, etc.) */
+  extractDate?: boolean;
+  /** Extract hashtags (#tag) */
+  extractTags?: boolean;
+  /** Extract time estimates (~2h, ~30m) */
+  extractEstimate?: boolean;
+}
+
+const DEFAULT_EXTRACT_OPTIONS: ExtractMetadataOptions = {
+  extractPriority: true,
+  extractDate: true,
+  extractTags: true,
+  extractEstimate: true,
+};
+
+/**
+ * Extract metadata from natural language input
+ *
+ * Supports:
+ * - Priority: !high, !medium, !low, !critical, !높음, !보통, !낮음, !긴급
+ * - Date: today, tomorrow, next week, 내일, 오늘, by Friday, 금요일까지
+ * - Tags: #tag, #개발, #backend
+ * - Time estimate: ~2h, ~30m, ~1h30m (with ~ prefix)
+ *
+ * @param input - Raw natural language input
+ * @param options - Options to control which metadata types to extract
+ * @returns Extracted metadata and remaining text
+ *
+ * @example
+ * ```typescript
+ * const result = extractMetadata("Review PR tomorrow #dev !high ~2h");
+ * // {
+ * //   priority: "high",
+ * //   dueDate: "2025-01-01",
+ * //   tags: ["dev"],
+ * //   estimateMinutes: 120,
+ * //   remaining: "Review PR"
+ * // }
+ * ```
+ */
+export function extractMetadata(
+  input: string,
+  options: ExtractMetadataOptions = DEFAULT_EXTRACT_OPTIONS
+): ExtractedMetadata {
+  validateInputLength(input);
+  let remaining = input.trim();
+  const result: ExtractedMetadata = { remaining: "" };
+
+  // Extract priority (!high, !critical, !medium, !low, !높음, !보통, !낮음)
+  if (options.extractPriority !== false) {
+    const priorityMatch = remaining.match(/!([\p{L}\p{N}_]+)/gu);
+    if (priorityMatch) {
+      for (const match of priorityMatch) {
+        const priority = parsePriority(match.slice(1));
+        if (priority) {
+          result.priority = priority;
+          remaining = remaining.replace(match, "").trim();
+          break;
+        }
+      }
+    }
+  }
+
+  // Extract tags (#dev, #backend, #개발)
+  if (options.extractTags !== false) {
+    const tagMatches = remaining.match(/#([\p{L}\p{N}_]+)/gu);
+    if (tagMatches) {
+      result.tags = tagMatches.map((m) => m.slice(1));
+      for (const match of tagMatches) {
+        remaining = remaining.replace(match, "").trim();
+      }
+    }
+  }
+
+  // Extract due date patterns
+  if (options.extractDate !== false) {
+    // "by Friday", "by tomorrow", "until next week"
+    const byMatch = remaining.match(/\b(by|until|before)\s+(\w+(\s+\w+)?)/i);
+    if (byMatch) {
+      const dateStr = byMatch[2]!;
+      const date = parseRelativeDate(dateStr);
+      if (date) {
+        result.dueDate = formatDate(date);
+        remaining = remaining.replace(byMatch[0], "").trim();
+      }
+    }
+
+    // Korean date patterns: "내일까지", "금요일까지"
+    if (!result.dueDate) {
+      const koreanDueMatch = remaining.match(/(\S+)까지/);
+      if (koreanDueMatch) {
+        const dateStr = koreanDueMatch[1]!;
+        const date = parseRelativeDate(dateStr);
+        if (date) {
+          result.dueDate = formatDate(date);
+          remaining = remaining.replace(koreanDueMatch[0], "").trim();
+        }
+      }
+    }
+
+    // "tomorrow", "today" at the end
+    if (!result.dueDate) {
+      const dateWords = ["tomorrow", "today", "내일", "오늘", "모레"];
+      for (const word of dateWords) {
+        if (remaining.toLowerCase().endsWith(word)) {
+          const date = parseRelativeDate(word);
+          if (date) {
+            result.dueDate = formatDate(date);
+            remaining = remaining.slice(0, -word.length).trim();
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  // Extract time estimate (~2h, ~30m, ~1h30m)
+  if (options.extractEstimate !== false) {
+    const timeMatch = remaining.match(/~(\d+h\d+m|\d+h|\d+m)\b/);
+    if (timeMatch) {
+      let minutes = 0;
+      const hoursMatch = timeMatch[1]!.match(/(\d+)h/);
+      const minsMatch = timeMatch[1]!.match(/(\d+)m/);
+      if (hoursMatch) {
+        minutes += parseInt(hoursMatch[1]!, 10) * 60;
+      }
+      if (minsMatch) {
+        minutes += parseInt(minsMatch[1]!, 10);
+      }
+      if (minutes > 0) {
+        result.estimateMinutes = minutes;
+        remaining = remaining.replace(timeMatch[0], "").trim();
+      }
+    }
+  }
+
+  // Clean up extra spaces
+  result.remaining = remaining.replace(/\s+/g, " ").trim();
+
+  return result;
+}
+
 /**
  * Target type for parsed input
  */
@@ -94,21 +258,21 @@ export function parseInput(input: string): ParsedInput {
  * - "성능 개선 아이디어 #performance"
  */
 export function parseInboxInput(input: string): InboxCreateInput {
-  validateInputLength(input);
-  let remaining = input.trim();
+  // Inbox only extracts tags
+  const metadata = extractMetadata(input, {
+    extractPriority: false,
+    extractDate: false,
+    extractTags: true,
+    extractEstimate: false,
+  });
+
   const result: InboxCreateInput = { content: "" };
 
-  // Extract tags (#dev, #backend, #개발)
-  const tagMatches = remaining.match(/#([\p{L}\p{N}_]+)/gu);
-  if (tagMatches) {
-    result.tags = tagMatches.map((m) => m.slice(1));
-    for (const match of tagMatches) {
-      remaining = remaining.replace(match, "").trim();
-    }
+  if (metadata.tags) {
+    result.tags = metadata.tags;
   }
 
-  // Clean up and set content
-  result.content = remaining.replace(/\s+/g, " ").trim();
+  result.content = metadata.remaining;
 
   if (!result.content) {
     throw new InputValidationError(
@@ -123,7 +287,7 @@ export function parseInboxInput(input: string): InboxCreateInput {
  * Parse natural language task input
  *
  * Examples:
- * - "Review PR tomorrow #dev !high"
+ * - "Review PR tomorrow #dev !high ~2h"
  * - "내일까지 보고서 작성 #업무 !높음 @집중"
  * - "Fix bug by Friday #backend !critical"
  * - "Write tests every Monday #testing"
@@ -133,20 +297,7 @@ export function parseTaskInput(input: string): TaskCreateInput {
   let remaining = input.trim();
   const result: TaskCreateInput = { title: "" };
 
-  // Extract priority (!high, !critical, !medium, !low, !높음, !보통, !낮음)
-  const priorityMatch = remaining.match(/!([\p{L}\p{N}_]+)/gu);
-  if (priorityMatch) {
-    for (const match of priorityMatch) {
-      const priority = parsePriority(match.slice(1));
-      if (priority) {
-        result.priority = priority;
-        remaining = remaining.replace(match, "").trim();
-        break;
-      }
-    }
-  }
-
-  // Extract contexts (@focus, @review, @집중)
+  // Extract contexts first (@focus, @review, @집중) - task-specific
   const contextMatches = remaining.match(/@([\p{L}\p{N}_]+)/gu);
   if (contextMatches) {
     result.contexts = contextMatches.map((m) => m.slice(1));
@@ -155,57 +306,20 @@ export function parseTaskInput(input: string): TaskCreateInput {
     }
   }
 
-  // Extract tags (#dev, #backend, #개발)
-  const tagMatches = remaining.match(/#([\p{L}\p{N}_]+)/gu);
-  if (tagMatches) {
-    result.tags = tagMatches.map((m) => m.slice(1));
-    for (const match of tagMatches) {
-      remaining = remaining.replace(match, "").trim();
-    }
-  }
-
-  // Extract due date patterns
-  // "by Friday", "by tomorrow", "until next week"
-  const byMatch = remaining.match(/\b(by|until|before)\s+(\w+(\s+\w+)?)/i);
-  if (byMatch) {
-    const dateStr = byMatch[2]!;
-    const date = parseRelativeDate(dateStr);
-    if (date) {
-      result.dueDate = formatDate(date);
-      remaining = remaining.replace(byMatch[0], "").trim();
-    }
-  }
-
-  // Korean date patterns: "내일까지", "금요일까지"
-  const koreanDueMatch = remaining.match(/(\S+)까지/);
-  if (koreanDueMatch && !result.dueDate) {
-    const dateStr = koreanDueMatch[1]!;
-    const date = parseRelativeDate(dateStr);
-    if (date) {
-      result.dueDate = formatDate(date);
-      remaining = remaining.replace(koreanDueMatch[0], "").trim();
-    }
-  }
-
-  // "tomorrow", "today" at the end
-  const dateWords = ["tomorrow", "today", "내일", "오늘", "모레"];
-  for (const word of dateWords) {
-    if (remaining.toLowerCase().endsWith(word) && !result.dueDate) {
-      const date = parseRelativeDate(word);
-      if (date) {
-        result.dueDate = formatDate(date);
-        remaining = remaining.slice(0, -word.length).trim();
-      }
-    }
+  // Extract sortOrder (^1, ^10) - task-specific
+  const sortMatch = remaining.match(/\^(\d+)/);
+  if (sortMatch) {
+    result.sortOrder = parseInt(sortMatch[1]!, 10);
+    remaining = remaining.replace(sortMatch[0], "").trim();
   }
 
-  // Extract time estimate (30m, 2h, 1h30m)
-  // Pattern matches: "2h30m", "2h", "30m" (but not empty string)
-  const timeMatch = remaining.match(/\b(\d+h\d+m|\d+h|\d+m)\b/);
-  if (timeMatch) {
+  // Extract time estimate without ~ prefix for backward compatibility (30m, 2h, 1h30m)
+  // This handles the legacy format before extractMetadata handles ~prefix format
+  const legacyTimeMatch = remaining.match(/\b(\d+h\d+m|\d+h|\d+m)\b/);
+  if (legacyTimeMatch && !remaining.includes("~" + legacyTimeMatch[1])) {
     let minutes = 0;
-    const hoursMatch = timeMatch[0].match(/(\d+)h/);
-    const minsMatch = timeMatch[0].match(/(\d+)m/);
+    const hoursMatch = legacyTimeMatch[0].match(/(\d+)h/);
+    const minsMatch = legacyTimeMatch[0].match(/(\d+)m/);
     if (hoursMatch) {
       minutes += parseInt(hoursMatch[1]!, 10) * 60;
     }
@@ -214,20 +328,33 @@ export function parseTaskInput(input: string): TaskCreateInput {
     }
     if (minutes > 0) {
       result.estimate = { expected: minutes, confidence: "medium" };
-      remaining = remaining.replace(timeMatch[0], "").trim();
+      remaining = remaining.replace(legacyTimeMatch[0], "").trim();
     }
   }
 
-  // Extract sortOrder (^1, ^10, ^순서1)
-  // Used for manual ordering within task lists
-  const sortMatch = remaining.match(/\^(\d+)/);
-  if (sortMatch) {
-    result.sortOrder = parseInt(sortMatch[1]!, 10);
-    remaining = remaining.replace(sortMatch[0], "").trim();
+  // Use extractMetadata for common patterns
+  const metadata = extractMetadata(remaining, {
+    extractPriority: true,
+    extractDate: true,
+    extractTags: true,
+    extractEstimate: true,
+  });
+
+  // Apply extracted metadata
+  if (metadata.priority) {
+    result.priority = metadata.priority;
+  }
+  if (metadata.dueDate) {
+    result.dueDate = metadata.dueDate;
+  }
+  if (metadata.tags) {
+    result.tags = metadata.tags;
+  }
+  if (metadata.estimateMinutes && !result.estimate) {
+    result.estimate = { expected: metadata.estimateMinutes, confidence: "medium" };
   }
 
-  // Clean up extra spaces
-  result.title = remaining.replace(/\s+/g, " ").trim();
+  result.title = metadata.remaining;
 
   if (!result.title) {
     throw new InputValidationError(

package/src/utils/projection.ts

@@ -27,7 +27,7 @@ function assertNever(value: never): never {
 /**
  * Project a single task to the specified format
  */
-export function projectTask(task: Task, format: ResponseFormat): TaskSummary | TaskPreview | Task {
+export function formatTask(task: Task, format: ResponseFormat): TaskSummary | TaskPreview | Task {
   switch (format) {
     case "concise":
       return {
@@ -59,19 +59,19 @@ export function projectTask(task: Task, format: ResponseFormat): TaskSummary | T
 /**
  * Project multiple tasks with optional limit
  */
-export function projectTasks(
+export function formatTasks(
   tasks: Task[],
   format: ResponseFormat,
   limit?: number
 ): (TaskSummary | TaskPreview | Task)[] {
   const sliced = limit ? tasks.slice(0, limit) : tasks;
-  return sliced.map((task) => projectTask(task, format));
+  return sliced.map((task) => formatTask(task, format));
 }
 
 /**
  * Project tasks with pagination
  */
-export function projectTasksPaginated(
+export function formatTasksPaginated(
   tasks: Task[],
   format: ResponseFormat,
   limit: number = 20,
@@ -79,7 +79,7 @@ export function projectTasksPaginated(
 ): PaginatedResponse<TaskSummary | TaskPreview | Task> {
   const effectiveLimit = Math.min(limit, 100);
   const sliced = tasks.slice(offset, offset + effectiveLimit);
-  const projected = sliced.map((task) => projectTask(task, format));
+  const projected = sliced.map((task) => formatTask(task, format));
 
   return {
     items: projected,
@@ -93,7 +93,7 @@ export function projectTasksPaginated(
 /**
  * Project a single inbox item to the specified format
  */
-export function projectInboxItem(
+export function formatInboxItem(
   item: InboxItem,
   format: ResponseFormat
 ): InboxSummary | InboxPreview | InboxItem {
@@ -124,13 +124,13 @@ export function projectInboxItem(
 /**
  * Project multiple inbox items with optional limit
  */
-export function projectInboxItems(
+export function formatInboxItems(
   items: InboxItem[],
   format: ResponseFormat,
   limit?: number
 ): (InboxSummary | InboxPreview | InboxItem)[] {
   const sliced = limit ? items.slice(0, limit) : items;
-  return sliced.map((item) => projectInboxItem(item, format));
+  return sliced.map((item) => formatInboxItem(item, format));
 }
 
 /**

package/src/utils/terminal-ui.ts

@@ -185,11 +185,9 @@ export function isFullWidth(char: string): boolean {
     (code >= 0xffe0 && code <= 0xffe6) || // Fullwidth Symbols
     (code >= 0x20000 && code <= 0x2ffff) || // CJK Extension B, C, D, E, F
     (code >= 0x30000 && code <= 0x3ffff) || // CJK Extension G, H, I
-
     // Symbols (typically wide in terminals)
     (code >= 0x2600 && code <= 0x26ff) || // Misc Symbols (sun, moon, stars, etc.)
     (code >= 0x2700 && code <= 0x27bf) || // Dingbats
-
     // Emoji ranges (comprehensive coverage)
     (code >= 0x1f1e0 && code <= 0x1f1ff) || // Regional Indicator Symbols (flags)
     (code >= 0x1f300 && code <= 0x1f5ff) || // Misc Symbols & Pictographs
@@ -202,7 +200,6 @@ export function isFullWidth(char: string): boolean {
     (code >= 0x1fa00 && code <= 0x1fa6f) || // Chess Symbols
     (code >= 0x1fa70 && code <= 0x1faff) || // Symbols & Pictographs Extended-A
     (code >= 0x1fb00 && code <= 0x1fbff) || // Symbols for Legacy Computing
-
     // Additional emoji-related
     (code >= 0x231a && code <= 0x231b) || // Watch, Hourglass
     (code >= 0x23e9 && code <= 0x23f3) || // Media control symbols
@@ -278,7 +275,11 @@ export const visibleLength = displayWidth;
 /**
  * Pad string to width (accounting for display width)
  */
-export function pad(str: string, width: number, align: "left" | "right" | "center" = "left"): string {
+export function pad(
+  str: string,
+  width: number,
+  align: "left" | "right" | "center" = "left"
+): string {
   const len = displayWidth(str);
   const diff = width - len;
   if (diff <= 0) return str;
@@ -359,7 +360,8 @@ export function progressBar(
   const filledCount = Math.round((percent / 100) * width);
   const emptyCount = width - filledCount;
 
-  const bar = color(filled.repeat(filledCount), filledColor) + color(empty.repeat(emptyCount), emptyColor);
+  const bar =
+    color(filled.repeat(filledCount), filledColor) + color(empty.repeat(emptyCount), emptyColor);
 
   return showPercent ? `${bar} ${percent}%` : bar;
 }
@@ -383,7 +385,10 @@ export function box(content: string, options: BoxOptions = {}): string {
   const { padding = 1, borderColor = "cyan", title, rounded = true } = options;
 
   const lines = content.split("\n");
-  const maxLen = Math.max(...lines.map(l => displayWidth(stripAnsi(l))), title ? title.length + 2 : 0);
+  const maxLen = Math.max(
+    ...lines.map((l) => displayWidth(stripAnsi(l))),
+    title ? title.length + 2 : 0
+  );
   const innerWidth = options.width ? options.width - 2 - padding * 2 : maxLen + padding * 2;
 
   const tl = rounded ? BOX.rTopLeft : BOX.topLeft;
@@ -402,7 +407,10 @@ export function box(content: string, options: BoxOptions = {}): string {
     const remaining = innerWidth - titlePart.length;
     const leftPad = Math.floor(remaining / 2);
     const rightPad = remaining - leftPad;
-    top = applyBorder(tl + h.repeat(leftPad)) + c.bold(titlePart) + applyBorder(h.repeat(rightPad) + tr);
+    top =
+      applyBorder(tl + h.repeat(leftPad)) +
+      c.bold(titlePart) +
+      applyBorder(h.repeat(rightPad) + tr);
   } else {
     top = applyBorder(tl + h.repeat(innerWidth) + tr);
   }
@@ -412,10 +420,16 @@ export function box(content: string, options: BoxOptions = {}): string {
   const paddingLines = Array(padding).fill(padLine);
 
   // Content lines
-  const contentLines = lines.map(line => {
+  const contentLines = lines.map((line) => {
     const lineWidth = displayWidth(stripAnsi(line));
     const padRight = innerWidth - lineWidth - padding;
-    return applyBorder(v) + " ".repeat(padding) + line + " ".repeat(Math.max(0, padRight)) + applyBorder(v);
+    return (
+      applyBorder(v) +
+      " ".repeat(padding) +
+      line +
+      " ".repeat(Math.max(0, padRight)) +
+      applyBorder(v)
+    );
   });
 
   // Bottom border
@@ -452,16 +466,16 @@ export function drawBox(lines: string[], options: BoxOptions = {}): string[] {
     const rightBorder = remainingWidth - leftBorder;
     result.push(
       applyBorder(BOX.topLeft) +
-      applyBorder(BOX.horizontal.repeat(leftBorder)) +
-      c.label(titleStr) +
-      applyBorder(BOX.horizontal.repeat(rightBorder)) +
-      applyBorder(BOX.topRight)
+        applyBorder(BOX.horizontal.repeat(leftBorder)) +
+        c.label(titleStr) +
+        applyBorder(BOX.horizontal.repeat(rightBorder)) +
+        applyBorder(BOX.topRight)
     );
   } else {
     result.push(
       applyBorder(BOX.topLeft) +
-      applyBorder(BOX.horizontal.repeat(boxWidth - 2)) +
-      applyBorder(BOX.topRight)
+        applyBorder(BOX.horizontal.repeat(boxWidth - 2)) +
+        applyBorder(BOX.topRight)
     );
   }
 
@@ -469,18 +483,18 @@ export function drawBox(lines: string[], options: BoxOptions = {}): string[] {
   for (const line of lines) {
     result.push(
       applyBorder(BOX.vertical) +
-      padStr +
-      padEnd(line, innerWidth) +
-      padStr +
-      applyBorder(BOX.vertical)
+        padStr +
+        padEnd(line, innerWidth) +
+        padStr +
+        applyBorder(BOX.vertical)
     );
   }
 
   // Bottom border
   result.push(
     applyBorder(BOX.bottomLeft) +
-    applyBorder(BOX.horizontal.repeat(boxWidth - 2)) +
-    applyBorder(BOX.bottomRight)
+      applyBorder(BOX.horizontal.repeat(boxWidth - 2)) +
+      applyBorder(BOX.bottomRight)
   );
 
   return result;
@@ -494,9 +508,9 @@ export function drawBox(lines: string[], options: BoxOptions = {}): string[] {
  * Place multiple boxes side by side (string input, string output)
  */
 export function sideBySide(boxes: string[], gap: number = 2): string {
-  const boxLines = boxes.map(b => b.split("\n"));
-  const maxHeight = Math.max(...boxLines.map(lines => lines.length));
-  const boxWidths = boxLines.map(lines => Math.max(...lines.map(l => displayWidth(l))));
+  const boxLines = boxes.map((b) => b.split("\n"));
+  const maxHeight = Math.max(...boxLines.map((lines) => lines.length));
+  const boxWidths = boxLines.map((lines) => Math.max(...lines.map((l) => displayWidth(l))));
 
   // Pad each box to max height
   const paddedBoxLines = boxLines.map((lines, i) => {
@@ -504,7 +518,7 @@ export function sideBySide(boxes: string[], gap: number = 2): string {
     while (lines.length < maxHeight) {
       lines.push(" ".repeat(width));
     }
-    return lines.map(line => {
+    return lines.map((line) => {
       const lineWidth = displayWidth(line);
       if (lineWidth < width) {
         return line + " ".repeat(width - lineWidth);
@@ -518,7 +532,7 @@ export function sideBySide(boxes: string[], gap: number = 2): string {
   const gapStr = " ".repeat(gap);
 
   for (let i = 0; i < maxHeight; i++) {
-    const lineParts = paddedBoxLines.map(lines => lines[i] ?? "");
+    const lineParts = paddedBoxLines.map((lines) => lines[i] ?? "");
     result.push(lineParts.join(gapStr));
   }
 
@@ -529,14 +543,8 @@ export function sideBySide(boxes: string[], gap: number = 2): string {
  * Merge two boxes side by side (array input, array output)
  * For MCP server compatibility
  */
-export function sideBySideArrays(
-  leftLines: string[],
-  rightLines: string[],
-  gap = 2
-): string[] {
-  const leftWidth = leftLines.length > 0
-    ? Math.max(...leftLines.map(displayWidth))
-    : 0;
+export function sideBySideArrays(leftLines: string[], rightLines: string[], gap = 2): string[] {
+  const leftWidth = leftLines.length > 0 ? Math.max(...leftLines.map(displayWidth)) : 0;
 
   const maxLines = Math.max(leftLines.length, rightLines.length);
   const result: string[] = [];
@@ -580,10 +588,10 @@ export function table<T extends Record<string, unknown>>(
   const { headerColor = "cyan", borderColor = "gray" } = options;
 
   // Calculate column widths
-  const widths = columns.map(col => {
+  const widths = columns.map((col) => {
     const headerWidth = displayWidth(col.header);
     const maxDataWidth = Math.max(
-      ...data.map(row => {
+      ...data.map((row) => {
         const val = col.format ? col.format(row[col.key], row) : String(row[col.key] ?? "");
         return displayWidth(val);
       }),
@@ -601,10 +609,10 @@ export function table<T extends Record<string, unknown>>(
     .join(` ${border} `);
 
   // Separator
-  const separator = widths.map(w => hBorder.repeat(w)).join(color(`─${BOX.cross}─`, borderColor));
+  const separator = widths.map((w) => hBorder.repeat(w)).join(color(`─${BOX.cross}─`, borderColor));
 
   // Data rows
-  const dataRows = data.map(row =>
+  const dataRows = data.map((row) =>
     columns
       .map((col, i) => {
         const w = widths[i] ?? 0;
@@ -621,33 +629,24 @@ export function table<T extends Record<string, unknown>>(
  * Render table with full borders (array output)
  * For MCP server compatibility
  */
-export function renderTable(
-  columns: TableColumn[],
-  rows: Record<string, unknown>[]
-): string[] {
+export function renderTable(columns: TableColumn[], rows: Record<string, unknown>[]): string[] {
   const colWidths: number[] = columns.map((col) => {
     const headerWidth = col.header.length;
-    const maxValueWidth = Math.max(
-      ...rows.map((row) => String(row[col.key] ?? "").length)
-    );
+    const maxValueWidth = Math.max(...rows.map((row) => String(row[col.key] ?? "").length));
     return col.width ?? Math.max(headerWidth, maxValueWidth);
   });
 
   const result: string[] = [];
 
   // Header row
-  const headerCells = columns.map((col, i) =>
-    c.label(center(col.header, colWidths[i] ?? 0))
+  const headerCells = columns.map((col, i) => c.label(center(col.header, colWidths[i] ?? 0)));
+  result.push(
+    c.muted(BOX.vertical) + headerCells.join(c.muted(BOX.vertical)) + c.muted(BOX.vertical)
   );
-  result.push(c.muted(BOX.vertical) + headerCells.join(c.muted(BOX.vertical)) + c.muted(BOX.vertical));
 
   // Separator
   const separator = columns.map((_, i) => BOX.horizontal.repeat(colWidths[i] ?? 0));
-  result.push(
-    c.muted(BOX.teeRight) +
-    c.muted(separator.join(BOX.cross)) +
-    c.muted(BOX.teeLeft)
-  );
+  result.push(c.muted(BOX.teeRight) + c.muted(separator.join(BOX.cross)) + c.muted(BOX.teeLeft));
 
   // Data rows
   for (const row of rows) {
@@ -782,5 +781,5 @@ export function banner(text: string): string {
     }
   }
 
-  return lines.map(l => c.cyan(l)).join("\n");
+  return lines.map((l) => c.cyan(l)).join("\n");
 }