@outfitter/cli 0.1.0-rc.2 → 0.1.0

package/dist/shared/@outfitter/cli-96b2p4td.d.ts

@@ -0,0 +1,56 @@
+import { SpinnerStyle } from "./cli-e5ms1y0x";
+import { ListStyle } from "./cli-b0tzqgnf";
+import { BorderStyle } from "./cli-fakncnjp";
+import { PrimitiveId, PrimitiveMeta, ThemeMethodMeta, VariantMeta } from "./cli-qjfc3j11";
+import { Theme } from "./cli-xsaheemc";
+/**
+* Type-safe metadata for all theme methods.
+*
+* Uses `keyof Theme` to ensure every theme method has metadata.
+* Adding a new method to Theme without updating this causes a compile error.
+*/
+declare const THEME_METHOD_META: Record<keyof Theme, ThemeMethodMeta>;
+/**
+* Gets theme methods grouped by category.
+*/
+declare function getThemeMethodsByCategory(): {
+	semantic: Array<keyof Theme>;
+	utility: Array<keyof Theme>;
+};
+/**
+* Type-safe metadata for all border styles.
+*/
+declare const BORDER_STYLE_META: Record<BorderStyle, VariantMeta<BorderStyle>>;
+/**
+* Gets all border styles as an array.
+*/
+declare function getBorderStyles(): BorderStyle[];
+/**
+* Type-safe metadata for all spinner styles.
+*/
+declare const SPINNER_STYLE_META: Record<SpinnerStyle, VariantMeta<SpinnerStyle>>;
+/**
+* Gets all spinner styles as an array.
+*/
+declare function getSpinnerStyles(): SpinnerStyle[];
+/**
+* Type-safe metadata for all list styles.
+*/
+declare const LIST_STYLE_META: Record<ListStyle, VariantMeta<ListStyle>>;
+/**
+* Gets all list styles as an array.
+*/
+declare function getListStyles(): ListStyle[];
+/**
+* Type-safe metadata for all primitives.
+*/
+declare const PRIMITIVE_META: Record<PrimitiveId, PrimitiveMeta>;
+/**
+* Gets all primitive IDs as an array.
+*/
+declare function getPrimitiveIds(): PrimitiveId[];
+/**
+* Gets metadata for a specific primitive.
+*/
+declare function getPrimitiveMeta(id: PrimitiveId): PrimitiveMeta;
+export { THEME_METHOD_META, getThemeMethodsByCategory, BORDER_STYLE_META, getBorderStyles, SPINNER_STYLE_META, getSpinnerStyles, LIST_STYLE_META, getListStyles, PRIMITIVE_META, getPrimitiveIds, getPrimitiveMeta };

package/dist/shared/@outfitter/cli-9khk3cbq.d.ts

@@ -0,0 +1,190 @@
+import { BoxOptions } from "./cli-8xsmsbbd";
+import { LayoutContext, WidthMode } from "./cli-2g8bx1aq";
+/**
+* Gets the current terminal width.
+*
+* Returns `process.stdout.columns` if available, otherwise falls back to 80
+* (standard terminal width).
+*
+* @returns Terminal width in characters
+*
+* @example
+* ```typescript
+* import { getTerminalWidth } from "@outfitter/cli/render";
+*
+* const width = getTerminalWidth();
+* console.log(`Terminal is ${width} columns wide`);
+* ```
+*/
+declare function getTerminalWidth(): number;
+/**
+* Calculates box overhead (borders + padding) for each axis.
+*
+* Returns the total character/line count consumed by borders and padding,
+* separate from content.
+*
+* @param options - Box options (padding, borders)
+* @returns Object with horizontal and vertical overhead
+*
+* @example
+* ```typescript
+* import { getBoxOverhead } from "@outfitter/cli/render";
+*
+* const overhead = getBoxOverhead({ padding: 1, border: "single" });
+* // { horizontal: 4, vertical: 2 }
+* // horizontal: left border (1) + left padding (1) + right padding (1) + right border (1)
+* // vertical: top border (1) + bottom border (1)
+* ```
+*/
+declare function getBoxOverhead(options: BoxOptions): {
+	horizontal: number;
+	vertical: number;
+};
+/**
+* Calculates available content width inside a box.
+*
+* Accounts for borders and padding to determine how much space remains
+* for content. Use this to size nested components appropriately.
+*
+* @param options - Box options (width, padding, borders)
+* @returns Available width in characters for content
+*
+* @example
+* ```typescript
+* import { getContentWidth, createBox, renderProgress } from "@outfitter/cli/render";
+*
+* const boxOpts = { width: 40, padding: 1, border: "single" };
+* const available = getContentWidth(boxOpts); // → 36
+*
+* const progress = renderProgress(0.5, { width: available });
+* const box = createBox(progress, boxOpts);
+* ```
+*/
+declare function getContentWidth(options: BoxOptions): number;
+/**
+* Resolves a width mode to a concrete character width.
+*
+* Width modes allow flexible sizing relative to terminal or container:
+* - `"text"` → 0 (content-sized, no constraint)
+* - `"full"` → terminal width
+* - `"container"` → container width (requires context)
+* - `number` → fixed width
+* - `"${number}%"` → percentage of container/terminal
+*
+* @param mode - Width specification
+* @param ctx - Layout context for container-relative modes
+* @returns Resolved width in characters
+* @throws Error if "container" mode used without context
+*
+* @example
+* ```typescript
+* import { resolveWidth, createLayoutContext } from "@outfitter/cli/render";
+*
+* resolveWidth("full");           // → 120 (terminal width)
+* resolveWidth(50);               // → 50
+* resolveWidth("50%");            // → 60 (half of terminal)
+*
+* const ctx = createLayoutContext({ width: 80, padding: 1 });
+* resolveWidth("50%", ctx);       // → 38 (half of context width)
+* resolveWidth("container", ctx); // → 76 (context width)
+* ```
+*/
+declare function resolveWidth(mode: WidthMode, ctx?: LayoutContext): number;
+/**
+* Creates a layout context from box options.
+*
+* Layout contexts propagate width information through nested components,
+* enabling relative sizing like `"50%"` or `"container"`.
+*
+* @param options - Box options defining the container
+* @param parent - Parent context for chained calculations
+* @returns New layout context with calculated content width
+*
+* @example
+* ```typescript
+* import { createLayoutContext, resolveWidth, createBox } from "@outfitter/cli/render";
+*
+* // Outer container
+* const outerOpts = { width: 80, padding: 1 };
+* const outerCtx = createLayoutContext(outerOpts);
+* // outerCtx.width = 76 (80 - 4 overhead)
+*
+* // Nested component at 50% width
+* const innerWidth = resolveWidth("50%", outerCtx);
+* const innerOpts = { width: innerWidth, padding: 1 };
+* const innerCtx = createLayoutContext(innerOpts, outerCtx);
+* // innerCtx.width = 34 (38 - 4 overhead)
+* ```
+*/
+declare function createLayoutContext(options: BoxOptions, parent?: LayoutContext): LayoutContext;
+/**
+* Vertical alignment for horizontal layout.
+*/
+type Alignment = "top" | "center" | "bottom";
+/**
+* Options for horizontal layout.
+*/
+interface HorizontalLayoutOptions {
+	/** Gap (in characters) between blocks */
+	gap?: number;
+	/** Vertical alignment of blocks */
+	align?: Alignment;
+}
+/**
+* Options for vertical layout.
+*/
+interface VerticalLayoutOptions {
+	/** Gap (in lines) between blocks */
+	gap?: number;
+}
+/**
+* Joins multiple text blocks horizontally (side by side).
+*
+* Handles blocks of different heights by aligning them according
+* to the `align` option. Blocks are padded to maintain alignment.
+*
+* @param blocks - Array of text blocks to join
+* @param options - Layout options
+* @returns Combined string with blocks side by side
+*
+* @example
+* ```typescript
+* import { joinHorizontal } from "@outfitter/cli/render";
+* import { renderBox } from "@outfitter/cli/render";
+*
+* const left = renderBox({ content: "Left", borderStyle: "single" });
+* const right = renderBox({ content: "Right", borderStyle: "single" });
+*
+* console.log(joinHorizontal([left, right], { gap: 2 }));
+* // ┌──────┐  ┌───────┐
+* // │ Left │  │ Right │
+* // └──────┘  └───────┘
+* ```
+*/
+declare function joinHorizontal(blocks: string[], options?: HorizontalLayoutOptions): string;
+/**
+* Joins multiple text blocks vertically (stacked).
+*
+* @param blocks - Array of text blocks to stack
+* @param options - Layout options
+* @returns Combined string with blocks stacked
+*
+* @example
+* ```typescript
+* import { joinVertical, renderHeading, renderSeparator } from "@outfitter/cli/render";
+*
+* const heading = renderHeading("Section Title");
+* const separator = renderSeparator({ width: 20 });
+* const content = "Some content here.";
+*
+* console.log(joinVertical([heading, separator, content], { gap: 1 }));
+* // SECTION TITLE
+* // =============
+* //
+* // ────────────────────
+* //
+* // Some content here.
+* ```
+*/
+declare function joinVertical(blocks: string[], options?: VerticalLayoutOptions): string;
+export { getTerminalWidth, getBoxOverhead, getContentWidth, resolveWidth, createLayoutContext, Alignment, HorizontalLayoutOptions, VerticalLayoutOptions, joinHorizontal, joinVertical };

package/dist/shared/@outfitter/cli-9mtjjykw.js

@@ -0,0 +1,67 @@
+// @bun
+import {
+  SPINNERS,
+  getSpinnerFrame,
+  renderSpinner
+} from "./cli-n9dbh0hp.js";
+import {
+  SPINNER_STYLE_META,
+  getSpinnerStyles
+} from "./cli-kc84wmch.js";
+import {
+  getExample
+} from "./cli-xep6v2c0.js";
+import {
+  demoSection
+} from "./cli-34fqr7bp.js";
+
+// packages/cli/src/demo/renderers/spinner.ts
+function renderSpinnerDemo(config, theme) {
+  const showCode = config.showCode ?? true;
+  const showDescriptions = config.showDescriptions ?? true;
+  const lines = [];
+  lines.push(demoSection("Spinner Styles"));
+  lines.push("");
+  if (showCode) {
+    lines.push('import { renderSpinner, SPINNERS } from "@outfitter/cli/render";');
+    lines.push("");
+  }
+  const message = getExample("spinnerMessage", config.examples);
+  const styles = getSpinnerStyles();
+  for (const style of styles) {
+    const meta = SPINNER_STYLE_META[style];
+    const spinner = SPINNERS[style];
+    lines.push(`${meta.label.toUpperCase()} (${style})`);
+    if (showDescriptions) {
+      lines.push(theme.muted(meta.description));
+    }
+    const frameDisplay = spinner.frames.join(" ");
+    lines.push(`  Frames: ${frameDisplay}`);
+    lines.push(`  Interval: ${spinner.interval}ms`);
+    const output = renderSpinner(style, message);
+    lines.push(`  Example: ${output}`);
+    lines.push("");
+  }
+  lines.push(demoSection("Usage"));
+  lines.push("");
+  if (showCode) {
+    lines.push("// Static render (for logs/non-TTY)");
+    lines.push(`renderSpinner("dots", "${message}");`);
+    lines.push("");
+    lines.push("// Get frame at specific time");
+    lines.push('getSpinnerFrame("dots", 0);     // First frame');
+    lines.push('getSpinnerFrame("dots", 160);   // Third frame');
+    lines.push("");
+  }
+  lines.push("Frame progression (dots style):");
+  const dotSpinner = SPINNERS.dots;
+  for (let i = 0;i < Math.min(5, dotSpinner.frames.length); i++) {
+    const elapsed = i * dotSpinner.interval;
+    const frame = getSpinnerFrame("dots", elapsed);
+    lines.push(`  ${elapsed}ms \u2192 ${frame}`);
+  }
+  return lines.join(`
+`);
+}
+
+export { renderSpinnerDemo };

package/dist/shared/@outfitter/{cli-ag0w4pk0.js → cli-9nbyj2bt.js}

@@ -1,24 +1,14 @@
 // @bun
 import {
+  init_detection,
   resolveColorEnv,
   supportsColor
-} from "./cli-jbj78ac5.js";
+} from "./cli-d9ad0rqj.js";
+import {
+  __esm
+} from "./cli-v1tzwxkt.js";
 
 // packages/cli/src/render/colors.ts
-var ANSI = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  italic: "\x1B[3m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  red: "\x1B[31m",
-  blue: "\x1B[34m",
-  cyan: "\x1B[36m",
-  magenta: "\x1B[35m",
-  white: "\x1B[37m",
-  gray: "\x1B[90m"
-};
 function createTheme() {
   const colorEnabled = supportsColor();
   const colorFn = (ansiCode) => (text) => {
@@ -34,7 +24,16 @@ function createTheme() {
     info: colorFn(ANSI.blue),
     primary: colorFn(""),
     secondary: colorFn(ANSI.gray),
-    muted: colorFn(ANSI.dim)
+    muted: colorFn(ANSI.dim),
+    accent: colorFn(ANSI.cyan),
+    highlight: colorFn(ANSI.bold),
+    link: colorFn(`${ANSI.cyan}${ANSI.underline}`),
+    destructive: colorFn(ANSI.brightRed),
+    subtle: colorFn(`${ANSI.dim}${ANSI.gray}`),
+    bold: colorFn(ANSI.bold),
+    italic: colorFn(ANSI.italic),
+    underline: colorFn(ANSI.underline),
+    dim: colorFn(ANSI.dim)
   };
 }
 function resolveTokenColorEnabled(options) {
@@ -61,10 +60,18 @@ function createTokens(options) {
       warning: "",
       error: "",
       info: "",
+      primary: "",
+      secondary: "",
       muted: "",
       accent: "",
-      primary: "",
-      secondary: ""
+      highlight: "",
+      link: "",
+      destructive: "",
+      subtle: "",
+      bold: "",
+      italic: "",
+      underline: "",
+      dim: ""
     };
   }
   return {
@@ -72,10 +79,18 @@ function createTokens(options) {
     warning: ANSI.yellow,
     error: ANSI.red,
     info: ANSI.blue,
+    primary: "",
+    secondary: ANSI.gray,
     muted: ANSI.dim,
     accent: ANSI.cyan,
-    primary: "",
-    secondary: ANSI.gray
+    highlight: ANSI.bold,
+    link: `${ANSI.cyan}${ANSI.underline}`,
+    destructive: ANSI.brightRed,
+    subtle: `${ANSI.dim}${ANSI.gray}`,
+    bold: ANSI.bold,
+    italic: ANSI.italic,
+    underline: ANSI.underline,
+    dim: ANSI.dim
   };
 }
 function applyColor(text, color) {
@@ -85,5 +100,29 @@ function applyColor(text, color) {
   const ansiCode = ANSI[color];
   return `${ansiCode}${text}${ANSI.reset}`;
 }
+var ANSI;
+var init_colors = __esm(() => {
+  init_detection();
+  ANSI = {
+    reset: "\x1B[0m",
+    bold: "\x1B[1m",
+    dim: "\x1B[2m",
+    italic: "\x1B[3m",
+    underline: "\x1B[4m",
+    green: "\x1B[32m",
+    yellow: "\x1B[33m",
+    red: "\x1B[31m",
+    blue: "\x1B[34m",
+    cyan: "\x1B[36m",
+    magenta: "\x1B[35m",
+    white: "\x1B[37m",
+    gray: "\x1B[90m",
+    brightCyan: "\x1B[96m",
+    brightRed: "\x1B[91m",
+    brightYellow: "\x1B[93m",
+    brightGreen: "\x1B[92m",
+    brightBlue: "\x1B[94m"
+  };
+});
 
-export { ANSI, createTheme, resolveTokenColorEnabled, createTokens, applyColor };
+export { ANSI, createTheme, resolveTokenColorEnabled, createTokens, applyColor, init_colors };

package/dist/shared/@outfitter/{cli-azzk8a1d.js → cli-afhjqmg3.js}

@@ -1,12 +1,16 @@
 // @bun
 import {
-  ANSI
-} from "./cli-ag0w4pk0.js";
+  ANSI,
+  init_colors
+} from "./cli-9nbyj2bt.js";
 import {
+  init_detection,
   supportsColor
-} from "./cli-jbj78ac5.js";
+} from "./cli-d9ad0rqj.js";
 
 // packages/cli/src/render/markdown.ts
+init_detection();
+init_colors();
 function renderMarkdown(markdown) {
   const colorEnabled = supportsColor();
   let result = markdown;

package/dist/shared/@outfitter/cli-an9j0h80.js

@@ -0,0 +1,117 @@
+// @bun
+import {
+  getStringWidth,
+  init_text,
+  padText,
+  truncateText
+} from "./cli-jjemfdta.js";
+import {
+  getBorderCharacters,
+  init_borders
+} from "./cli-85fg2vr5.js";
+
+// packages/cli/src/render/table.ts
+init_borders();
+init_text();
+function renderTable(data, options) {
+  if (data.length === 0) {
+    return "";
+  }
+  const allKeys = new Set;
+  for (const row of data) {
+    for (const key of Object.keys(row)) {
+      allKeys.add(key);
+    }
+  }
+  const keys = Array.from(allKeys);
+  const headers = options?.headers ?? {};
+  const getHeader = (key) => headers[key] ?? key;
+  const columnWidths = {};
+  for (const key of keys) {
+    const headerWidth = getStringWidth(getHeader(key));
+    let maxDataWidth = 0;
+    for (const row of data) {
+      const value = row[key];
+      const strValue = value === undefined || value === null ? "" : String(value);
+      const width = getStringWidth(strValue);
+      if (width > maxDataWidth) {
+        maxDataWidth = width;
+      }
+    }
+    const optionWidth = options?.columnWidths?.[key];
+    columnWidths[key] = optionWidth ?? Math.max(headerWidth, maxDataWidth);
+  }
+  const compact = options?.compact ?? false;
+  const borderStyle = compact ? "none" : options?.border ?? "single";
+  const chars = getBorderCharacters(borderStyle);
+  const hasBorders = borderStyle !== "none";
+  return hasBorders ? renderWithBorders(data, keys, columnWidths, getHeader, chars) : renderCompact(data, keys, columnWidths, getHeader);
+}
+function renderWithBorders(data, keys, columnWidths, getHeader, chars) {
+  const lines = [];
+  const colWidthsForBorder = keys.map((k) => (columnWidths[k] ?? 0) + 2);
+  lines.push(drawHorizontalBorder(chars, colWidthsForBorder, "top"));
+  lines.push(drawDataRow(keys.map((k) => getHeader(k)), keys.map((k) => columnWidths[k] ?? 0), chars.vertical));
+  lines.push(drawHorizontalBorder(chars, colWidthsForBorder, "middle"));
+  for (const row of data) {
+    const values = keys.map((k) => {
+      const value = row[k];
+      let strValue = value === undefined || value === null ? "" : String(value);
+      const width = columnWidths[k] ?? 0;
+      if (getStringWidth(strValue) > width) {
+        strValue = truncateText(strValue, width);
+      }
+      return strValue;
+    });
+    lines.push(drawDataRow(values, keys.map((k) => columnWidths[k] ?? 0), chars.vertical));
+  }
+  lines.push(drawHorizontalBorder(chars, colWidthsForBorder, "bottom"));
+  return lines.join(`
+`);
+}
+function renderCompact(data, keys, columnWidths, getHeader) {
+  const lines = [];
+  const headerValues = keys.map((k) => {
+    const header = getHeader(k);
+    const width = columnWidths[k] ?? 0;
+    return padText(header, width);
+  });
+  lines.push(headerValues.join("  "));
+  for (const row of data) {
+    const values = keys.map((k) => {
+      const value = row[k];
+      let strValue = value === undefined || value === null ? "" : String(value);
+      const width = columnWidths[k] ?? 0;
+      if (getStringWidth(strValue) > width) {
+        strValue = truncateText(strValue, width);
+      }
+      return padText(strValue, width);
+    });
+    lines.push(values.join("  "));
+  }
+  return lines.join(`
+`);
+}
+function drawHorizontalBorder(chars, colWidths, position) {
+  const positionChars = {
+    top: { left: chars.topLeft, right: chars.topRight, cross: chars.topT },
+    middle: { left: chars.leftT, right: chars.rightT, cross: chars.cross },
+    bottom: {
+      left: chars.bottomLeft,
+      right: chars.bottomRight,
+      cross: chars.bottomT
+    }
+  };
+  const { left, right, cross } = positionChars[position];
+  const segments = colWidths.map((w) => chars.horizontal.repeat(w));
+  return `${left}${segments.join(cross)}${right}`;
+}
+function drawDataRow(values, widths, vertical) {
+  const cells = values.map((value, i) => {
+    const width = widths[i] ?? 0;
+    return ` ${padText(value, width)} `;
+  });
+  return `${vertical}${cells.join(vertical)}${vertical}`;
+}
+
+export { renderTable };

package/dist/shared/@outfitter/cli-ay411nbr.js

@@ -0,0 +1,122 @@
+// @bun
+import {
+  TREE_GUIDES,
+  renderTree
+} from "./cli-b5c2k0d7.js";
+import {
+  getExample
+} from "./cli-xep6v2c0.js";
+import {
+  demoSection
+} from "./cli-34fqr7bp.js";
+
+// packages/cli/src/demo/renderers/tree.ts
+function renderTreeDemo(config, _theme) {
+  const showCode = config.showCode ?? true;
+  const lines = [];
+  lines.push(demoSection("Basic Tree"));
+  lines.push("");
+  if (showCode) {
+    lines.push('import { renderTree } from "@outfitter/cli/tree";');
+    lines.push("");
+  }
+  const treeData = getExample("treeData", config.examples);
+  if (showCode) {
+    lines.push("renderTree({");
+    lines.push("  src: {");
+    lines.push("    components: { Button: null, Input: null },");
+    lines.push("    utils: null,");
+    lines.push("  },");
+    lines.push("  tests: null,");
+    lines.push("})");
+    lines.push("");
+  }
+  lines.push(renderTree(treeData));
+  lines.push("");
+  lines.push(demoSection("Guide Styles"));
+  lines.push("");
+  const guideDemo = {
+    root: {
+      child1: {
+        leaf: null
+      },
+      child2: null
+    }
+  };
+  const guideStyles = [
+    "single",
+    "rounded",
+    "heavy",
+    "double"
+  ];
+  for (const style of guideStyles) {
+    const guide = TREE_GUIDES[style];
+    lines.push(`${style.toUpperCase()} (fork: "${guide.fork.trim()}", end: "${guide.end.trim()}")`);
+    lines.push("");
+    lines.push(renderTree(guideDemo, { guide: style }));
+    lines.push("");
+  }
+  lines.push(demoSection("Max Depth"));
+  lines.push("");
+  const deepTree = {
+    level1: {
+      level2: {
+        level3: {
+          level4: null
+        }
+      }
+    }
+  };
+  if (showCode) {
+    lines.push("renderTree(tree, { maxDepth: 2 })");
+    lines.push("");
+  }
+  lines.push("Full tree:");
+  lines.push(renderTree(deepTree));
+  lines.push("");
+  lines.push("With maxDepth: 2:");
+  lines.push(renderTree(deepTree, { maxDepth: 2 }));
+  lines.push("");
+  lines.push(demoSection("Custom Labels"));
+  lines.push("");
+  const fileTree = {
+    src: {
+      "index.ts": null,
+      components: {
+        "Button.tsx": null
+      }
+    },
+    "package.json": null
+  };
+  if (showCode) {
+    lines.push("renderTree(tree, {");
+    lines.push("  renderLabel: (key, value) => {");
+    lines.push("    if (value && typeof value === 'object') {");
+    lines.push("      return `\uD83D\uDCC1 ${key}/`;");
+    lines.push("    }");
+    lines.push("    return `\uD83D\uDCC4 ${key}`;");
+    lines.push("  }");
+    lines.push("})");
+    lines.push("");
+  }
+  lines.push(renderTree(fileTree, {
+    renderLabel: (key, value) => {
+      if (value && typeof value === "object") {
+        return `\uD83D\uDCC1 ${key}/`;
+      }
+      return `\uD83D\uDCC4 ${key}`;
+    }
+  }));
+  lines.push("");
+  lines.push(demoSection("Usage Notes"));
+  lines.push("");
+  lines.push("\u2022 Objects become branches with children");
+  lines.push("\u2022 null values become leaf nodes (terminal)");
+  lines.push("\u2022 Use guide option to change visual style");
+  lines.push("\u2022 Use maxDepth to limit rendering depth");
+  lines.push("\u2022 Use renderLabel for custom node formatting");
+  return lines.join(`
+`);
+}
+
+export { renderTreeDemo };