@outfitter/cli 0.1.0-rc.1 → 0.1.0-rc.3

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-9nbyj2bt.js

@@ -0,0 +1,128 @@
+// @bun
+import {
+  init_detection,
+  resolveColorEnv,
+  supportsColor
+} from "./cli-d9ad0rqj.js";
+import {
+  __esm
+} from "./cli-v1tzwxkt.js";
+
+// packages/cli/src/render/colors.ts
+function createTheme() {
+  const colorEnabled = supportsColor();
+  const colorFn = (ansiCode) => (text) => {
+    if (!colorEnabled) {
+      return text;
+    }
+    return `${ansiCode}${text}${ANSI.reset}`;
+  };
+  return {
+    success: colorFn(ANSI.green),
+    warning: colorFn(ANSI.yellow),
+    error: colorFn(ANSI.red),
+    info: colorFn(ANSI.blue),
+    primary: colorFn(""),
+    secondary: colorFn(ANSI.gray),
+    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) {
+  if (options?.colorLevel === 0) {
+    return false;
+  }
+  if (options?.forceColor === true) {
+    return true;
+  }
+  if (options?.colorLevel !== undefined) {
+    return options.colorLevel > 0;
+  }
+  const env = resolveColorEnv({ forceColorFirst: true });
+  if (env !== undefined) {
+    return env;
+  }
+  return process.stdout.isTTY ?? false;
+}
+function createTokens(options) {
+  const colorEnabled = resolveTokenColorEnabled(options);
+  if (!colorEnabled) {
+    return {
+      success: "",
+      warning: "",
+      error: "",
+      info: "",
+      primary: "",
+      secondary: "",
+      muted: "",
+      accent: "",
+      highlight: "",
+      link: "",
+      destructive: "",
+      subtle: "",
+      bold: "",
+      italic: "",
+      underline: "",
+      dim: ""
+    };
+  }
+  return {
+    success: ANSI.green,
+    warning: ANSI.yellow,
+    error: ANSI.red,
+    info: ANSI.blue,
+    primary: "",
+    secondary: ANSI.gray,
+    muted: ANSI.dim,
+    accent: ANSI.cyan,
+    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) {
+  if (!supportsColor()) {
+    return text;
+  }
+  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, init_colors };

package/dist/shared/@outfitter/cli-a4q87517.d.ts

@@ -0,0 +1,64 @@
+import { Result, ValidationError } from "@outfitter/contracts";
+/**
+* Represents a date range with start and end dates.
+*/
+interface DateRange {
+	/** Start of the range (inclusive, at 00:00:00.000) */
+	start: Date;
+	/** End of the range (inclusive, at 23:59:59.999) */
+	end: Date;
+}
+/**
+* Returns a new Date set to the start of the day (00:00:00.000).
+*
+* @param date - The date to adjust
+* @returns A new Date object at 00:00:00.000 on the same day
+*
+* @example
+* ```typescript
+* startOfDay(new Date("2024-06-15T14:30:00Z"))
+* // Returns 2024-06-15T00:00:00.000 (local time)
+* ```
+*/
+declare function startOfDay(date: Date): Date;
+/**
+* Returns a new Date set to the end of the day (23:59:59.999).
+*
+* @param date - The date to adjust
+* @returns A new Date object at 23:59:59.999 on the same day
+*
+* @example
+* ```typescript
+* endOfDay(new Date("2024-06-15T14:30:00Z"))
+* // Returns 2024-06-15T23:59:59.999 (local time)
+* ```
+*/
+declare function endOfDay(date: Date): Date;
+/**
+* Parses date range strings into structured DateRange.
+*
+* Supported formats:
+* - `"today"` - Current day (00:00:00 to 23:59:59)
+* - `"yesterday"` - Previous day
+* - `"last week"` - Last 7 days
+* - `"last month"` - Last 30 days
+* - `"2024-01-01..2024-12-31"` - Explicit range
+* - `"2024-01-01"` - Single day
+*
+* @param input - The date range string to parse
+* @returns Result containing DateRange on success, or ValidationError on failure
+*
+* @example
+* ```typescript
+* parseDateRange("today")
+* // Ok({ start: today 00:00, end: today 23:59:59 })
+*
+* parseDateRange("2024-01-01..2024-12-31")
+* // Ok({ start: 2024-01-01 00:00, end: 2024-12-31 23:59:59 })
+*
+* parseDateRange("invalid")
+* // Err(ValidationError)
+* ```
+*/
+declare function parseDateRange(input: string): Result<DateRange, InstanceType<typeof ValidationError>>;
+export { DateRange, startOfDay, endOfDay, parseDateRange };

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

@@ -0,0 +1,63 @@
+// @bun
+import {
+  ANSI,
+  init_colors
+} from "./cli-9nbyj2bt.js";
+import {
+  init_detection,
+  supportsColor
+} from "./cli-d9ad0rqj.js";
+
+// packages/cli/src/render/markdown.ts
+init_detection();
+init_colors();
+function renderMarkdown(markdown) {
+  const colorEnabled = supportsColor();
+  let result = markdown;
+  result = result.replace(/```(\w*)\n([\s\S]*?)```/g, (_match, _lang, code) => {
+    const trimmed = code.trimEnd();
+    if (colorEnabled) {
+      return `${ANSI.dim}${trimmed}${ANSI.reset}`;
+    }
+    return trimmed;
+  });
+  result = result.replace(/^(#{1,6})\s+(.+)$/gm, (_match, _hashes, text) => {
+    if (colorEnabled) {
+      return `${ANSI.bold}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  result = result.replace(/\*\*(.+?)\*\*/g, (_match, text) => {
+    if (colorEnabled) {
+      return `${ANSI.bold}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  result = result.replace(/__(.+?)__/g, (_match, text) => {
+    if (colorEnabled) {
+      return `${ANSI.bold}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  result = result.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_match, text) => {
+    if (colorEnabled) {
+      return `${ANSI.italic}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  result = result.replace(/(?<!_)_([^_]+)_(?!_)/g, (_match, text) => {
+    if (colorEnabled) {
+      return `${ANSI.italic}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  result = result.replace(/`([^`]+)`/g, (_match, text) => {
+    if (colorEnabled) {
+      return `${ANSI.cyan}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  return result;
+}
+
+export { renderMarkdown };

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