@task-mcp/shared 1.0.22 → 1.0.24

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");
 }

package/src/utils/workspace.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, test } from "bun:test";
+import {
+  normalizeWorkspace,
+  detectWorkspaceSync,
+  detectWorkspace,
+  getWorkspaceFromPath,
+  getGitRepoRoot,
+  getGitRepoRootSync,
+} from "./workspace";
+
+describe("normalizeWorkspace", () => {
+  test("converts to lowercase", () => {
+    expect(normalizeWorkspace("MyProject")).toBe("myproject");
+  });
+
+  test("replaces spaces with hyphens", () => {
+    expect(normalizeWorkspace("my project")).toBe("my-project");
+  });
+
+  test("removes special characters", () => {
+    expect(normalizeWorkspace("my@project!")).toBe("myproject");
+  });
+
+  test("handles empty string", () => {
+    expect(normalizeWorkspace("")).toBe("default");
+  });
+
+  test("keeps hyphens and underscores", () => {
+    expect(normalizeWorkspace("my-project_name")).toBe("my-project_name");
+  });
+
+  test("trims leading and trailing hyphens", () => {
+    expect(normalizeWorkspace("--my-project--")).toBe("my-project");
+  });
+
+  test("handles multiple spaces", () => {
+    // Multiple spaces become multiple hyphens, then cleaned by special char removal
+    expect(normalizeWorkspace("my   project")).toBe("my-project");
+  });
+
+  test("handles mixed case with special chars", () => {
+    expect(normalizeWorkspace("My@Project#Name")).toBe("myprojectname");
+  });
+});
+
+describe("getWorkspaceFromPath", () => {
+  test("extracts workspace from path", () => {
+    expect(getWorkspaceFromPath("/home/user/projects/my-app")).toBe("my-app");
+  });
+
+  test("handles path with .tasks suffix", () => {
+    expect(getWorkspaceFromPath("/projects/my-app/.tasks")).toBe("my-app");
+  });
+
+  test("handles path with trailing slash", () => {
+    expect(getWorkspaceFromPath("/projects/my-app/.tasks/")).toBe("my-app");
+  });
+
+  test("normalizes the extracted name", () => {
+    expect(getWorkspaceFromPath("/projects/My App")).toBe("my-app");
+  });
+});
+
+describe("getGitRepoRootSync", () => {
+  test("returns string or null for current directory", () => {
+    const result = getGitRepoRootSync();
+    expect(result === null || typeof result === "string").toBe(true);
+  });
+
+  test("returns null for non-git directory", () => {
+    const result = getGitRepoRootSync("/tmp");
+    expect(result).toBeNull();
+  });
+});
+
+describe("getGitRepoRoot", () => {
+  test("returns string or null for current directory", async () => {
+    const result = await getGitRepoRoot();
+    expect(result === null || typeof result === "string").toBe(true);
+  });
+
+  test("returns null for non-git directory", async () => {
+    const result = await getGitRepoRoot("/tmp");
+    expect(result).toBeNull();
+  });
+});
+
+describe("detectWorkspaceSync", () => {
+  test("returns a workspace name", () => {
+    const workspace = detectWorkspaceSync();
+    expect(typeof workspace).toBe("string");
+    expect(workspace.length).toBeGreaterThan(0);
+  });
+
+  test("uses tasksDir path when provided and no git repo", () => {
+    // This tests the fallback to tasksDir when in a non-git directory
+    const workspace = detectWorkspaceSync("/some/path/my-project/.tasks");
+    expect(typeof workspace).toBe("string");
+  });
+
+  test("returns normalized workspace name", () => {
+    const workspace = detectWorkspaceSync();
+    // Should be lowercase with no special characters except - and _
+    expect(workspace).toMatch(/^[a-z0-9_-]+$/);
+  });
+});
+
+describe("detectWorkspace", () => {
+  test("returns a workspace name asynchronously", async () => {
+    const workspace = await detectWorkspace();
+    expect(typeof workspace).toBe("string");
+    expect(workspace.length).toBeGreaterThan(0);
+  });
+
+  test("uses tasksDir path when provided", async () => {
+    const workspace = await detectWorkspace("/some/path/test-project/.tasks");
+    expect(typeof workspace).toBe("string");
+  });
+
+  test("returns normalized workspace name", async () => {
+    const workspace = await detectWorkspace();
+    // Should be lowercase with no special characters except - and _
+    expect(workspace).toMatch(/^[a-z0-9_-]+$/);
+  });
+});