@outfitter/tui 0.2.0

package/dist/shared/@outfitter/tui-pdwbbzwr.js

@@ -0,0 +1,179 @@
+// @bun
+// packages/tui/src/render/indicators.ts
+var INDICATORS = {
+  status: {
+    success: { unicode: "\u2714", fallback: "[ok]", color: "green" },
+    error: { unicode: "\u2716", fallback: "[x]", color: "red" },
+    warning: { unicode: "\u26A0", fallback: "[!]", color: "yellow" },
+    info: { unicode: "\u2139", fallback: "[i]", color: "blue" }
+  },
+  marker: {
+    circle: { unicode: "\u25CF", fallback: "*" },
+    circleOutline: { unicode: "\u25CB", fallback: "o" },
+    circleDotted: { unicode: "\u25CC", fallback: "o" },
+    circleSmall: { unicode: "\u2022", fallback: "\xB7" },
+    circleDot: { unicode: "\u25C9", fallback: "(*)" },
+    circleDotOutline: { unicode: "\u25EF", fallback: "( )" },
+    square: { unicode: "\u25A0", fallback: "[#]" },
+    squareOutline: { unicode: "\u25A1", fallback: "[ ]" },
+    squareSmall: { unicode: "\u25FC", fallback: "[#]" },
+    squareSmallOutline: { unicode: "\u25FB", fallback: "[ ]" },
+    lozenge: { unicode: "\u25C6", fallback: "\u2666" },
+    lozengeOutline: { unicode: "\u25C7", fallback: "\u25CA" },
+    lozengeDot: { unicode: "\u25C8", fallback: "\u2666\u2666" },
+    dash: { unicode: "\u2013", fallback: "-" },
+    pointer: { unicode: "\u276F", fallback: ">" },
+    pointerSmall: { unicode: "\u203A", fallback: ">" },
+    checkbox: { unicode: "\u2610", fallback: "[ ]" },
+    checkboxChecked: { unicode: "\u2611", fallback: "[x]" },
+    checkboxCross: { unicode: "\u2612", fallback: "[X]" }
+  },
+  progress: {
+    circleEmpty: { unicode: "\u25CB", fallback: "." },
+    circleQuarter: { unicode: "\u25D4", fallback: "o" },
+    circleHalf: { unicode: "\u25D1", fallback: "O" },
+    circleThree: { unicode: "\u25D5", fallback: "0" },
+    circleFull: { unicode: "\u25CF", fallback: "@" },
+    vertical1: { unicode: "\u2581", fallback: "_" },
+    vertical2: { unicode: "\u2582", fallback: "_" },
+    vertical3: { unicode: "\u2583", fallback: "=" },
+    vertical4: { unicode: "\u2584", fallback: "=" },
+    vertical5: { unicode: "\u2585", fallback: "#" },
+    vertical6: { unicode: "\u2586", fallback: "#" },
+    vertical7: { unicode: "\u2587", fallback: "#" },
+    verticalFull: { unicode: "\u2588", fallback: "#" },
+    horizontal1: { unicode: "\u258F", fallback: "|" },
+    horizontal2: { unicode: "\u258E", fallback: "|" },
+    horizontal3: { unicode: "\u258D", fallback: "|" },
+    horizontal4: { unicode: "\u258C", fallback: "|" },
+    horizontal5: { unicode: "\u258B", fallback: "|" },
+    horizontal6: { unicode: "\u258A", fallback: "|" },
+    horizontal7: { unicode: "\u2589", fallback: "|" },
+    horizontalFull: { unicode: "\u2588", fallback: "#" },
+    shadeLight: { unicode: "\u2591", fallback: "." },
+    shadeMedium: { unicode: "\u2592", fallback: ":" },
+    shadeDark: { unicode: "\u2593", fallback: "#" }
+  },
+  triangle: {
+    up: { unicode: "\u25B2", fallback: "^" },
+    upSmall: { unicode: "\u25B4", fallback: "^" },
+    upOutline: { unicode: "\u25B3", fallback: "^" },
+    down: { unicode: "\u25BC", fallback: "v" },
+    downSmall: { unicode: "\u25BE", fallback: "v" },
+    downOutline: { unicode: "\u25BD", fallback: "v" },
+    left: { unicode: "\u25C0", fallback: "<" },
+    leftSmall: { unicode: "\u25C2", fallback: "<" },
+    leftOutline: { unicode: "\u25C1", fallback: "<" },
+    right: { unicode: "\u25B6", fallback: ">" },
+    rightSmall: { unicode: "\u25B8", fallback: ">" },
+    rightOutline: { unicode: "\u25B7", fallback: ">" }
+  },
+  special: {
+    star: { unicode: "\u2605", fallback: "*" },
+    starOutline: { unicode: "\u2606", fallback: "*" },
+    heart: { unicode: "\u2665", fallback: "<3" },
+    heartOutline: { unicode: "\u2661", fallback: "<3" },
+    flag: { unicode: "\u2691", fallback: "[F]" },
+    flagOutline: { unicode: "\u2690", fallback: "[f]" },
+    gear: { unicode: "\u2699", fallback: "[*]" }
+  },
+  directional: {
+    arrowUp: { unicode: "\u2191", fallback: "^" },
+    arrowDown: { unicode: "\u2193", fallback: "v" },
+    arrowLeft: { unicode: "\u2190", fallback: "<-" },
+    arrowRight: { unicode: "\u2192", fallback: "->" },
+    arrowLeftRight: { unicode: "\u2194", fallback: "<->" },
+    arrowUpDown: { unicode: "\u2195", fallback: "^v" }
+  },
+  math: {
+    almostEqual: { unicode: "\u2248", fallback: "~=" },
+    notEqual: { unicode: "\u2260", fallback: "!=" },
+    lessOrEqual: { unicode: "\u2264", fallback: "<=" },
+    greaterOrEqual: { unicode: "\u2265", fallback: ">=" },
+    identical: { unicode: "\u2261", fallback: "===" },
+    infinity: { unicode: "\u221E", fallback: "inf" }
+  }
+};
+function isUnicodeSupported() {
+  if (process.env["CI"]) {
+    return true;
+  }
+  if (process.env["WT_SESSION"]) {
+    return true;
+  }
+  if (process.env["ConEmuTask"]) {
+    return true;
+  }
+  const term = process.env["TERM"] ?? "";
+  if (term === "xterm-256color" || term === "xterm" || term.includes("256color") || term.includes("truecolor")) {
+    return true;
+  }
+  const lang = process.env["LANG"] ?? process.env["LC_ALL"] ?? "";
+  if (lang.toLowerCase().includes("utf-8") || lang.toLowerCase().includes("utf8")) {
+    return true;
+  }
+  if (process.platform !== "win32") {
+    return true;
+  }
+  return false;
+}
+function getIndicator(category, name, forceUnicode) {
+  const indicator = INDICATORS[category][name];
+  if (!indicator) {
+    return "";
+  }
+  const useUnicode = forceUnicode ?? isUnicodeSupported();
+  return useUnicode ? indicator.unicode : indicator.fallback;
+}
+var PROGRESS_SEQUENCES = {
+  circle: [
+    "circleEmpty",
+    "circleQuarter",
+    "circleHalf",
+    "circleThree",
+    "circleFull"
+  ],
+  vertical: [
+    "vertical1",
+    "vertical2",
+    "vertical3",
+    "vertical4",
+    "vertical5",
+    "vertical6",
+    "vertical7",
+    "verticalFull"
+  ],
+  horizontal: [
+    "horizontal1",
+    "horizontal2",
+    "horizontal3",
+    "horizontal4",
+    "horizontal5",
+    "horizontal6",
+    "horizontal7",
+    "horizontalFull"
+  ],
+  shade: ["shadeLight", "shadeMedium", "shadeDark"]
+};
+function getProgressIndicator(style, current, max, forceUnicode) {
+  const sequence = PROGRESS_SEQUENCES[style];
+  const steps = sequence.length;
+  const ratio = max <= 0 ? 0 : Math.max(0, Math.min(1, current / max));
+  const index = Math.round(ratio * (steps - 1));
+  const name = sequence[index];
+  if (name === undefined) {
+    return "";
+  }
+  return getIndicator("progress", name, forceUnicode);
+}
+var SEVERITY_MARKERS = {
+  minor: "lozengeOutline",
+  moderate: "lozenge",
+  severe: "lozengeDot"
+};
+function getSeverityIndicator(level, forceUnicode) {
+  const name = SEVERITY_MARKERS[level];
+  return getIndicator("marker", name, forceUnicode);
+}
+
+export { INDICATORS, isUnicodeSupported, getIndicator, getProgressIndicator, getSeverityIndicator };

package/dist/shared/@outfitter/tui-qb07rtct.js

@@ -0,0 +1,19 @@
+// @bun
+// packages/tui/src/render/progress.ts
+function renderProgress(options) {
+  const { current, total, width = 20, showPercent = false } = options;
+  if (total <= 0) {
+    const bar2 = "\u2591".repeat(width);
+    return showPercent ? `[${bar2}] 0%` : `[${bar2}]`;
+  }
+  const percent = Math.min(100, Math.max(0, current / total * 100));
+  const filled = Math.round(percent / 100 * width);
+  const empty = width - filled;
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+  if (showPercent) {
+    return `[${bar}] ${Math.round(percent)}%`;
+  }
+  return `[${bar}]`;
+}
+
+export { renderProgress };

package/dist/shared/@outfitter/tui-qkyazctw.d.ts

@@ -0,0 +1,36 @@
+import { CancelledError, PromptResult } from "./tui-c56sxcm8";
+import { Result } from "better-result";
+/**
+* A step in a prompt group.
+*/
+type PromptStep<T> = () => PromptResult<T>;
+/**
+* Collects multiple prompts into a single result object.
+*
+* If any prompt is cancelled, the entire group fails with CancelledError.
+*
+* @param steps - Object of named prompt steps
+* @returns Ok with collected values or Err with CancelledError
+*
+* @example
+* ```typescript
+* import { promptGroup, promptText, promptSelect } from "@outfitter/tui/prompt";
+*
+* const result = await promptGroup({
+*   name: () => promptText({ message: "Name:" }),
+*   role: () => promptSelect({
+*     message: "Role:",
+*     options: [
+*       { value: "admin", label: "Admin" },
+*       { value: "user", label: "User" },
+*     ],
+*   }),
+* });
+*
+* if (result.isOk()) {
+*   console.log(`Creating ${result.value.role}: ${result.value.name}`);
+* }
+* ```
+*/
+declare function promptGroup<T extends Record<string, unknown>>(steps: { [K in keyof T] : PromptStep<T[K]> }): Promise<Result<T, CancelledError>>;
+export { PromptStep, promptGroup };

package/dist/shared/@outfitter/tui-qn1rgz9v.d.ts

@@ -0,0 +1,93 @@
+import { LayoutContext } from "./tui-75bztyfp";
+import { VisualTheme } from "./tui-8j1gbehy";
+/**
+* Layout context extended with theme information.
+*
+* Allows themes to cascade through component hierarchies. Children
+* inherit their parent's theme unless explicitly overridden.
+*
+* @example
+* ```typescript
+* import { createThemedContext, roundedTheme } from "@outfitter/tui/theme";
+*
+* // Create root context with theme
+* const ctx = createThemedContext({ theme: roundedTheme, width: 80 });
+*
+* // Child inherits theme from parent
+* const childCtx = createThemedContext({ width: 40, parent: ctx });
+* console.log(childCtx.theme.border); // "rounded" (inherited)
+*
+* // Child can override theme
+* const overrideCtx = createThemedContext({
+*   theme: boldTheme,
+*   width: 40,
+*   parent: ctx
+* });
+* console.log(overrideCtx.theme.border); // "heavy"
+* ```
+*/
+interface ThemedLayoutContext extends LayoutContext {
+	/** The visual theme for this context */
+	readonly theme: VisualTheme;
+}
+/**
+* Options for creating a themed layout context.
+*/
+interface ThemedContextOptions {
+	/** Visual theme (inherited from parent if not specified) */
+	theme?: VisualTheme;
+	/** Available width in characters */
+	width?: number;
+	/** Parent context for inheritance */
+	parent?: ThemedLayoutContext;
+}
+/**
+* Creates a themed layout context with cascading inheritance.
+*
+* Theme inheritance rules:
+* 1. Explicit theme → use it
+* 2. Parent exists → inherit parent's theme
+* 3. No theme or parent → use defaultTheme
+*
+* Width inheritance rules:
+* 1. Explicit width → use it
+* 2. Parent exists → inherit parent's width
+* 3. No width or parent → use terminal width (via getTerminalWidth)
+*
+* @param options - Context configuration
+* @returns A ThemedLayoutContext with resolved theme and width
+*
+* @example
+* ```typescript
+* // Root context with explicit theme and width
+* const root = createThemedContext({ theme: roundedTheme, width: 100 });
+*
+* // Child with inherited theme, explicit width
+* const child = createThemedContext({ width: 50, parent: root });
+*
+* // Nested child with overridden theme
+* const nested = createThemedContext({
+*   theme: boldTheme,
+*   parent: child
+* });
+* ```
+*/
+declare function createThemedContext(options: ThemedContextOptions): ThemedLayoutContext;
+/**
+* Gets the theme from a context, with fallback to defaultTheme.
+*
+* Useful when you have an optional context and need a theme.
+*
+* @param ctx - Optional themed context
+* @returns The context's theme or defaultTheme if no context
+*
+* @example
+* ```typescript
+* function renderComponent(ctx?: ThemedLayoutContext) {
+*   const theme = getContextTheme(ctx);
+*   // theme is always defined
+* }
+* ```
+*/
+declare function getContextTheme(ctx?: ThemedLayoutContext): VisualTheme;
+export { ThemedLayoutContext, ThemedContextOptions, createThemedContext, getContextTheme };

package/dist/shared/@outfitter/tui-qs3fhwp8.js

@@ -0,0 +1,43 @@
+// @bun
+import {
+  createCancelledError
+} from "./tui-kcxv8txp.js";
+
+// packages/tui/src/prompt/text.ts
+import { isCancel, password, text } from "@clack/prompts";
+import { Result } from "better-result";
+async function promptText(options) {
+  const textOptions = {
+    message: options.message
+  };
+  if (options.placeholder !== undefined) {
+    textOptions.placeholder = options.placeholder;
+  }
+  if (options.defaultValue !== undefined) {
+    textOptions.defaultValue = options.defaultValue;
+  }
+  if (options.validate !== undefined) {
+    textOptions.validate = options.validate;
+  }
+  const result = await text(textOptions);
+  if (isCancel(result)) {
+    return Result.err(createCancelledError());
+  }
+  return Result.ok(result);
+}
+async function promptPassword(options) {
+  const passwordOptions = {
+    message: options.message,
+    mask: options.mask ?? "\u2022"
+  };
+  if (options.validate !== undefined) {
+    passwordOptions.validate = options.validate;
+  }
+  const result = await password(passwordOptions);
+  if (isCancel(result)) {
+    return Result.err(createCancelledError());
+  }
+  return Result.ok(result);
+}
+
+export { promptText, promptPassword };

package/dist/shared/@outfitter/tui-r8hywf9m.d.ts

@@ -0,0 +1,48 @@
+import { MultiSelectPromptOptions, PromptResult, SelectPromptOptions } from "./tui-c56sxcm8";
+/**
+* Prompts for single selection with Result wrapping.
+*
+* @param options - Select prompt options
+* @returns Ok with selected value or Err with CancelledError
+*
+* @example
+* ```typescript
+* import { promptSelect } from "@outfitter/tui/prompt";
+*
+* const result = await promptSelect({
+*   message: "Pick a color:",
+*   options: [
+*     { value: "red", label: "Red", hint: "A warm color" },
+*     { value: "blue", label: "Blue", hint: "A cool color" },
+*   ],
+* });
+*
+* if (result.isOk()) {
+*   console.log(`You picked: ${result.value}`);
+* }
+* ```
+*/
+declare function promptSelect<T>(options: SelectPromptOptions<T>): PromptResult<T>;
+/**
+* Prompts for multiple selections with Result wrapping.
+*
+* @param options - Multi-select prompt options
+* @returns Ok with array of selected values or Err with CancelledError
+*
+* @example
+* ```typescript
+* import { promptMultiSelect } from "@outfitter/tui/prompt";
+*
+* const result = await promptMultiSelect({
+*   message: "Select toppings:",
+*   options: [
+*     { value: "cheese", label: "Cheese" },
+*     { value: "pepperoni", label: "Pepperoni" },
+*     { value: "mushrooms", label: "Mushrooms" },
+*   ],
+*   required: true,
+* });
+* ```
+*/
+declare function promptMultiSelect<T>(options: MultiSelectPromptOptions<T>): PromptResult<T[]>;
+export { promptSelect, promptMultiSelect };

package/dist/shared/@outfitter/tui-rbbcc034.js

@@ -0,0 +1,20 @@
+// @bun
+// packages/tui/src/demo/types.ts
+function isPrimitiveId(value) {
+  const validIds = [
+    "colors",
+    "borders",
+    "spinner",
+    "list",
+    "box",
+    "table",
+    "progress",
+    "tree",
+    "text",
+    "markdown",
+    "indicators"
+  ];
+  return validIds.includes(value);
+}
+
+export { isPrimitiveId };

package/dist/shared/@outfitter/tui-rgkerz72.js

@@ -0,0 +1,85 @@
+// @bun
+import {
+  ANSI
+} from "./tui-2wfat6jb.js";
+
+// packages/tui/src/streaming/writer.ts
+function createStreamWriter(options = {}) {
+  const stream = options.stream ?? process.stdout;
+  const isTTY = stream.isTTY ?? false;
+  let currentLineCount = 0;
+  let hasContent = false;
+  const write = (content) => {
+    if (!isTTY) {
+      stream.write(content);
+      hasContent = true;
+      return;
+    }
+    if (hasContent) {
+      clear();
+    }
+    stream.write(content);
+    currentLineCount = content.split(`
+`).length;
+    hasContent = true;
+  };
+  const update = (content) => {
+    if (!isTTY) {
+      stream.write(`
+${content}`);
+      hasContent = true;
+      return;
+    }
+    if (currentLineCount > 0) {
+      stream.write(ANSI.carriageReturn);
+      if (currentLineCount > 1) {
+        stream.write(ANSI.cursorUp(currentLineCount - 1));
+      }
+      for (let i = 0;i < currentLineCount; i++) {
+        stream.write(ANSI.clearLine);
+        if (i < currentLineCount - 1) {
+          stream.write(ANSI.cursorDown(1));
+        }
+      }
+      if (currentLineCount > 1) {
+        stream.write(ANSI.cursorUp(currentLineCount - 1));
+      }
+      stream.write(ANSI.carriageReturn);
+    }
+    stream.write(content);
+    currentLineCount = content.split(`
+`).length;
+    hasContent = true;
+  };
+  const persist = () => {
+    if (!hasContent)
+      return;
+    stream.write(`
+`);
+    currentLineCount = 0;
+    hasContent = false;
+  };
+  const clear = () => {
+    if (!(isTTY && hasContent)) {
+      hasContent = false;
+      currentLineCount = 0;
+      return;
+    }
+    stream.write(ANSI.carriageReturn);
+    if (currentLineCount > 1) {
+      stream.write(ANSI.cursorUp(currentLineCount - 1));
+    }
+    stream.write(ANSI.clearLine);
+    for (let i = 1;i < currentLineCount; i++) {
+      stream.write(ANSI.cursorDown(1) + ANSI.clearLine);
+    }
+    if (currentLineCount > 1) {
+      stream.write(ANSI.cursorUp(currentLineCount - 1));
+    }
+    currentLineCount = 0;
+    hasContent = false;
+  };
+  return { write, update, persist, clear };
+}
+
+export { createStreamWriter };

package/dist/shared/@outfitter/tui-rh52sycm.d.ts

@@ -0,0 +1,45 @@
+import { WidthMode } from "./tui-75bztyfp";
+/**
+* Width mode for separators.
+*
+* Separators only support "text", "full", and numeric widths.
+* Container-relative modes require context, which separators don't use.
+*/
+type SeparatorWidthMode = Extract<WidthMode, "text" | "full" | number>;
+/**
+* Separator style for dividers.
+* Single characters repeat to fill width.
+* Two-character patterns (like "- ") alternate to create dashed effect.
+*/
+type DividerStyle = "─" | "━" | "═" | "- " | "· ";
+/**
+* Options for rendering a separator.
+*/
+interface SeparatorOptions {
+	/** Separator style (default: "─") */
+	style?: DividerStyle;
+	/** Width mode (default: 40) */
+	width?: SeparatorWidthMode;
+}
+/**
+* Renders a horizontal separator line.
+*
+* @param options - Rendering options
+* @returns Formatted separator string
+*
+* @example
+* ```typescript
+* import { renderSeparator } from "@outfitter/tui/render";
+*
+* console.log(renderSeparator());
+* // ────────────────────────────────────────
+*
+* console.log(renderSeparator({ style: "━", width: 20 }));
+* // ━━━━━━━━━━━━━━━━━━━━
+*
+* console.log(renderSeparator({ style: "- ", width: 20 }));
+* // - - - - - - - - - -
+* ```
+*/
+declare function renderSeparator(options?: SeparatorOptions): string;
+export { DividerStyle, SeparatorOptions, renderSeparator };

package/dist/shared/@outfitter/tui-rr924x4z.d.ts

@@ -0,0 +1,59 @@
+/**
+* Progress bar rendering utilities.
+*
+* Renders progress bars with filled and empty segments.
+*
+* @packageDocumentation
+*/
+/**
+* Configuration options for {@link renderProgress}.
+*
+* @example
+* ```typescript
+* const options: ProgressOptions = {
+*   current: 75,
+*   total: 100,
+*   width: 20,
+*   showPercent: true,
+* };
+* // Renders: [###############.....] 75%
+* ```
+*/
+interface ProgressOptions {
+	/** Current progress value */
+	current: number;
+	/** Total value (100% when current equals total) */
+	total: number;
+	/** Width of the progress bar in characters (default: 20) */
+	width?: number;
+	/** Whether to show percentage after the bar (default: false) */
+	showPercent?: boolean;
+}
+/**
+* Renders a progress bar with filled and empty segments.
+*
+* Uses unicode block characters: filled segments, empty segments.
+* Optionally displays percentage after the bar.
+*
+* Handles edge cases:
+* - `total <= 0`: Returns empty bar with 0%
+* - `current > total`: Caps at 100%
+* - `current < 0`: Floors at 0%
+*
+* @param options - Progress bar configuration
+* @returns Formatted progress bar string
+*
+* @example
+* ```typescript
+* renderProgress({ current: 50, total: 100 });
+* // [##########..........]
+*
+* renderProgress({ current: 75, total: 100, showPercent: true });
+* // [###############.....] 75%
+*
+* renderProgress({ current: 30, total: 100, width: 10 });
+* // [###.......]
+* ```
+*/
+declare function renderProgress(options: ProgressOptions): string;
+export { ProgressOptions, renderProgress };

package/dist/shared/@outfitter/tui-rwpdjrt3.js

@@ -0,0 +1,20 @@
+// @bun
+import {
+  defaultTheme
+} from "./tui-0mpqnyc1.js";
+import {
+  BORDERS,
+  init_borders
+} from "./tui-2pwhzg55.js";
+
+// packages/tui/src/theme/presets/bold.ts
+init_borders();
+var boldTheme = {
+  ...defaultTheme,
+  name: "bold",
+  border: "heavy",
+  borderChars: BORDERS.heavy,
+  treeGuide: "heavy"
+};
+
+export { boldTheme };

package/dist/shared/@outfitter/tui-rx9xq9s7.d.ts

@@ -0,0 +1,26 @@
+/**
+* Date and time formatting utilities.
+*
+* Provides human-friendly relative time formatting.
+*
+* @packageDocumentation
+*/
+/**
+* Formats a date as a human-friendly relative time string.
+*
+* Converts timestamps to natural language like "just now", "5 minutes ago",
+* "yesterday", or "in 3 hours". Handles both past and future dates.
+*
+* @param date - Date to format (Date object, timestamp number, or ISO string)
+* @returns Human-friendly relative time string
+*
+* @example
+* ```typescript
+* formatRelative(new Date())              // "just now"
+* formatRelative(Date.now() - 30000)      // "30 seconds ago"
+* formatRelative(Date.now() - 3600000)    // "1 hour ago"
+* formatRelative(Date.now() + 300000)     // "in 5 minutes"
+* ```
+*/
+declare function formatRelative(date: Date | number | string): string;
+export { formatRelative };

package/dist/shared/@outfitter/tui-sk05ye6g.js

@@ -0,0 +1 @@
+// @bun