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

package/dist/shared/@outfitter/cli-3b7ed3rm.d.ts

@@ -0,0 +1,97 @@
+/**
+* Tree rendering utilities.
+*
+* Renders hierarchical data as ASCII trees with box-drawing characters.
+*
+* @packageDocumentation
+*/
+/**
+* Available tree guide styles.
+*
+* - `single`: Standard Unicode box-drawing (default)
+* - `heavy`: Thick/bold box-drawing characters
+* - `double`: Double-line box-drawing characters
+* - `rounded`: Rounded corners (╰ instead of └)
+*/
+type TreeGuideStyle = "single" | "heavy" | "double" | "rounded";
+/**
+* Tree guide character sets for different visual styles.
+*/
+declare const TREE_GUIDES: Record<TreeGuideStyle, {
+	vertical: string;
+	fork: string;
+	end: string;
+}>;
+/**
+* Options for customizing tree rendering.
+*/
+interface TreeOptions {
+	/**
+	* Guide style for tree branches.
+	* @default "single"
+	*/
+	guide?: TreeGuideStyle;
+	/**
+	* Maximum depth to render (1 = root children only).
+	* @default undefined (unlimited)
+	*/
+	maxDepth?: number;
+	/**
+	* Custom function to render node labels.
+	* Receives the key, value, and current depth.
+	*
+	* @example
+	* ```typescript
+	* renderLabel: (key, value, depth) => {
+	*   if (value && typeof value === "object") {
+	*     return `📁 ${key}/`;
+	*   }
+	*   return `📄 ${key}`;
+	* }
+	* ```
+	*/
+	renderLabel?: (key: string, value: unknown, depth: number) => string;
+}
+/**
+* Renders hierarchical data as a tree with unicode box-drawing characters.
+*
+* Uses unicode characters for tree structure.
+* Nested objects are rendered as child nodes; leaf values (null, primitives)
+* are rendered as terminal nodes.
+*
+* @param tree - Hierarchical object to render
+* @param options - Customization options
+* @returns Formatted tree string with box-drawing characters
+*
+* @example
+* ```typescript
+* const tree = {
+*   src: {
+*     components: {
+*       Button: null,
+*       Input: null,
+*     },
+*     utils: null,
+*   },
+*   tests: null,
+* };
+*
+* console.log(renderTree(tree));
+* // ├── src
+* // │   ├── components
+* // │   │   ├── Button
+* // │   │   └── Input
+* // │   └── utils
+* // └── tests
+*
+* console.log(renderTree(tree, { guide: "rounded" }));
+* // ├── src
+* // │   ├── components
+* // │   │   ├── Button
+* // │   │   ╰── Input
+* // │   ╰── utils
+* // ╰── tests
+* ```
+*/
+declare function renderTree(tree: Record<string, unknown>, options?: TreeOptions): string;
+export { TreeGuideStyle, TREE_GUIDES, TreeOptions, renderTree };

package/dist/shared/@outfitter/cli-3dxmmy4c.d.ts

@@ -0,0 +1,20 @@
+import { VisualTheme } from "./cli-s0kkx9m1";
+/**
+* Default visual theme.
+*
+* Features:
+* - Single-line box-drawing borders (┌─┐)
+* - Standard status indicators
+* - Bullet delimiters
+* - Dots spinner
+*
+* @example
+* ```typescript
+* import { defaultTheme } from "@outfitter/cli/theme/presets";
+*
+* // Use default styling
+* const box = renderBox("Hello", { border: defaultTheme.border });
+* ```
+*/
+declare const defaultTheme: VisualTheme;
+export { defaultTheme };

package/dist/shared/@outfitter/cli-3f12z5kf.d.ts

@@ -0,0 +1,83 @@
+import { Validator } from "./cli-vstbkzky";
+import { Result } from "better-result";
+/**
+* Error returned when user cancels a prompt.
+*/
+interface CancelledError {
+	type: "cancelled";
+	message: string;
+}
+/**
+* Creates a cancelled error.
+*/
+declare function createCancelledError(message?: string): CancelledError;
+/**
+* Options for text prompts.
+*/
+interface TextPromptOptions {
+	/** Prompt message to display */
+	message: string;
+	/** Placeholder text */
+	placeholder?: string;
+	/** Default value */
+	defaultValue?: string;
+	/** Validation function */
+	validate?: Validator;
+}
+/**
+* Options for password prompts.
+*/
+interface PasswordPromptOptions {
+	/** Prompt message to display */
+	message: string;
+	/** Validation function */
+	validate?: Validator;
+	/** Mask character (default: •) */
+	mask?: string;
+}
+/**
+* Options for select prompts.
+*/
+interface SelectPromptOptions<T> {
+	/** Prompt message to display */
+	message: string;
+	/** Available options */
+	options: Array<{
+		value: T;
+		label: string;
+		hint?: string;
+	}>;
+	/** Initial selected index */
+	initialValue?: T;
+}
+/**
+* Options for multi-select prompts.
+*/
+interface MultiSelectPromptOptions<T> {
+	/** Prompt message to display */
+	message: string;
+	/** Available options */
+	options: Array<{
+		value: T;
+		label: string;
+		hint?: string;
+	}>;
+	/** Initially selected values */
+	initialValues?: T[];
+	/** Require at least one selection */
+	required?: boolean;
+}
+/**
+* Options for confirm prompts.
+*/
+interface ConfirmPromptOptions {
+	/** Prompt message to display */
+	message: string;
+	/** Initial value */
+	initialValue?: boolean;
+}
+/**
+* Type alias for prompt results.
+*/
+type PromptResult<T> = Promise<Result<T, CancelledError>>;
+export { CancelledError, createCancelledError, TextPromptOptions, PasswordPromptOptions, SelectPromptOptions, MultiSelectPromptOptions, ConfirmPromptOptions, PromptResult };

package/dist/shared/@outfitter/cli-3hp8qwx3.js

@@ -0,0 +1,11 @@
+// @bun
+// packages/cli/src/render/json.ts
+function renderJson(data) {
+  const json = JSON.stringify(data, null, 2);
+  return json;
+}
+function renderText(text) {
+  return text;
+}
+
+export { renderJson, renderText };

package/dist/shared/@outfitter/cli-3t2zaenc.d.ts

@@ -0,0 +1,59 @@
+import { GlyphPair, SemanticState, VisualTheme } from "./cli-s0kkx9m1";
+/**
+* Resolves a glyph pair to a single character based on terminal capability.
+*
+* Uses terminal detection to choose between unicode and fallback characters.
+* Can be overridden with the `forceUnicode` parameter.
+*
+* @param glyph - The glyph pair to resolve
+* @param forceUnicode - Override terminal detection (true = unicode, false = fallback)
+* @returns The appropriate character for the terminal
+*
+* @example
+* ```typescript
+* const bullet: GlyphPair = { unicode: "•", fallback: "*" };
+*
+* // Auto-detect terminal capability
+* resolveGlyph(bullet);       // "•" or "*" based on terminal
+*
+* // Force unicode
+* resolveGlyph(bullet, true);  // "•"
+*
+* // Force fallback
+* resolveGlyph(bullet, false); // "*"
+* ```
+*/
+declare function resolveGlyph(glyph: GlyphPair, forceUnicode?: boolean): string;
+/**
+* Resolves a semantic state to its visual marker character.
+*
+* Looks up the marker specification in the theme and returns the
+* appropriate character. Supports both indicator-type markers (from
+* the INDICATORS registry) and custom glyph pairs.
+*
+* @param theme - The visual theme containing marker definitions
+* @param state - The semantic state to resolve
+* @param forceUnicode - Override terminal detection
+* @returns The marker character for the given state
+*
+* @example
+* ```typescript
+* import { defaultTheme, resolveStateMarker } from "@outfitter/cli/theme";
+*
+* // Resolve success marker (indicator-type)
+* resolveStateMarker(defaultTheme, "success", true);  // "✔"
+* resolveStateMarker(defaultTheme, "success", false); // "[ok]"
+*
+* // Resolve with custom theme marker
+* const theme = createVisualTheme({
+*   overrides: {
+*     markers: {
+*       current: { type: "custom", glyph: { unicode: "★", fallback: "*" } }
+*     }
+*   }
+* });
+* resolveStateMarker(theme, "current", true); // "★"
+* ```
+*/
+declare function resolveStateMarker(theme: VisualTheme, state: SemanticState, forceUnicode?: boolean): string;
+export { resolveGlyph, resolveStateMarker };

package/dist/shared/@outfitter/cli-4cb5g831.d.ts

@@ -0,0 +1,147 @@
+/**
+* Regular expression pattern to match ANSI escape codes.
+*/
+declare const ANSI_REGEX: RegExp;
+/**
+* Removes ANSI escape codes from text.
+*
+* Useful for calculating visible string length or logging to files
+* where ANSI codes would appear as garbage.
+*
+* @param text - Text that may contain ANSI escape codes
+* @returns Text with all ANSI escape codes removed
+*
+* @example
+* ```typescript
+* const colored = "\x1b[32mGreen\x1b[0m text";
+* console.log(stripAnsi(colored)); // "Green text"
+* ```
+*/
+declare function stripAnsi(text: string): string;
+/**
+* Calculates the visible width of text, ignoring ANSI escape codes.
+*
+* Uses `Bun.stringWidth()` internally, which correctly handles:
+* - ANSI escape codes (ignored)
+* - Wide characters (CJK, emoji) counting as 2 columns
+* - Zero-width characters
+*
+* @param text - Text to measure (may contain ANSI codes)
+* @returns Visible width in terminal columns
+*
+* @example
+* ```typescript
+* getStringWidth("Hello");                    // 5
+* getStringWidth("\x1b[31mHello\x1b[0m");     // 5 (ANSI ignored)
+* getStringWidth("Hello");                    // 5
+* ```
+*/
+declare function getStringWidth(text: string): number;
+/**
+* Wraps text at a specified width, preserving ANSI escape codes.
+*
+* Performs word-wrapping at the specified column width while:
+* - Preserving ANSI escape codes across line breaks
+* - Respecting word boundaries (no mid-word breaks)
+* - Trimming trailing whitespace from lines
+*
+* Uses Bun's native `Bun.wrapAnsi()` for high performance.
+*
+* @param text - Text to wrap (may contain ANSI codes)
+* @param width - Maximum visible width per line
+* @returns Wrapped text with newlines
+*
+* @example
+* ```typescript
+* const long = "This is a long sentence that should be wrapped";
+* console.log(wrapText(long, 20));
+* // This is a long
+* // sentence that
+* // should be wrapped
+*
+* // ANSI codes are preserved across line breaks
+* const colored = "\x1b[32mGreen text that wraps\x1b[0m";
+* console.log(wrapText(colored, 10));
+* ```
+*/
+declare function wrapText(text: string, width: number): string;
+/**
+* Truncates text with ellipsis, respecting ANSI escape codes.
+*
+* Preserves ANSI escape sequences while truncating to visible width.
+* Adds "..." when text exceeds maxWidth. The ellipsis is included
+* in the maxWidth calculation.
+*
+* @param text - Text to truncate (may contain ANSI codes)
+* @param maxWidth - Maximum visible width including ellipsis
+* @returns Truncated text with ellipsis if needed
+*
+* @example
+* ```typescript
+* truncateText("Hello World", 8);  // "Hello..."
+* truncateText("Short", 10);       // "Short" (no change)
+*
+* // ANSI codes are preserved
+* truncateText("\x1b[32mGreen text\x1b[0m", 8);
+* // "\x1b[32mGreen\x1b[0m..."
+* ```
+*/
+declare function truncateText(text: string, maxWidth: number): string;
+/**
+* Pads text to a specified width with trailing spaces, handling ANSI codes.
+*
+* Uses {@link getStringWidth} to calculate visible width, ignoring ANSI
+* escape codes. If text is already at or exceeds the target width,
+* returns it unchanged.
+*
+* @param text - Text to pad (may contain ANSI codes)
+* @param width - Target visible width
+* @returns Text padded with trailing spaces to reach target width
+*
+* @example
+* ```typescript
+* padText("Hi", 10);                        // "Hi        "
+* padText("\x1b[32mHi\x1b[0m", 10);          // "\x1b[32mHi\x1b[0m        "
+* padText("Already long enough", 5);        // "Already long enough"
+* ```
+*/
+declare function padText(text: string, width: number): string;
+/**
+* Pluralizes a word based on count.
+*
+* Returns a string with the count and the appropriate singular or plural
+* form of the word. By default, adds 's' for plural. Custom plural forms
+* can be provided for irregular words.
+*
+* @param count - The number of items
+* @param singular - The singular form of the word
+* @param plural - Optional custom plural form (defaults to singular + 's')
+* @returns Formatted string with count and pluralized word
+*
+* @example
+* ```typescript
+* pluralize(1, "item");           // "1 item"
+* pluralize(5, "item");           // "5 items"
+* pluralize(0, "child", "children"); // "0 children"
+* ```
+*/
+declare function pluralize(count: number, singular: string, plural?: string): string;
+/**
+* Converts text to URL-safe slug.
+*
+* Transforms text into a lowercase, hyphen-separated string suitable
+* for URLs. Replaces ampersands with 'and', removes special characters,
+* and collapses multiple hyphens.
+*
+* @param text - Text to convert to slug
+* @returns URL-safe slug
+*
+* @example
+* ```typescript
+* slugify("Hello World!");       // "hello-world"
+* slugify("This & That");        // "this-and-that"
+* slugify("  Multiple   Spaces  "); // "multiple-spaces"
+* ```
+*/
+declare function slugify(text: string): string;
+export { ANSI_REGEX, stripAnsi, getStringWidth, wrapText, truncateText, padText, pluralize, slugify };

package/dist/shared/@outfitter/cli-4w2a1rfy.d.ts

@@ -0,0 +1,23 @@
+import { ConfirmPromptOptions, PromptResult } from "./cli-3f12z5kf";
+/**
+* Prompts for yes/no confirmation with Result wrapping.
+*
+* @param options - Confirm prompt options
+* @returns Ok with boolean or Err with CancelledError
+*
+* @example
+* ```typescript
+* import { promptConfirm } from "@outfitter/cli/prompt";
+*
+* const result = await promptConfirm({
+*   message: "Are you sure you want to continue?",
+*   initialValue: false,
+* });
+*
+* if (result.isOk() && result.value) {
+*   console.log("Continuing...");
+* }
+* ```
+*/
+declare function promptConfirm(options: ConfirmPromptOptions): PromptResult<boolean>;
+export { promptConfirm };

package/dist/shared/@outfitter/cli-4x6pqnez.js

@@ -0,0 +1,20 @@
+// @bun
+import {
+  createCancelledError
+} from "./cli-8bwaw3pz.js";
+
+// packages/cli/src/prompt/group.ts
+import { Result as R } from "better-result";
+async function promptGroup(steps) {
+  const result = {};
+  for (const [key, step] of Object.entries(steps)) {
+    const stepResult = await step();
+    if (stepResult.isErr()) {
+      return R.err(createCancelledError(stepResult.error.message));
+    }
+    result[key] = stepResult.value;
+  }
+  return R.ok(result);
+}
+
+export { promptGroup };

package/dist/shared/@outfitter/cli-671sxkhj.js

@@ -0,0 +1,146 @@
+// @bun
+import {
+  init_box,
+  normalizeBorders,
+  normalizePadding
+} from "./cli-vp88gxev.js";
+
+// packages/cli/src/render/layout.ts
+init_box();
+function getTerminalWidth() {
+  return process.stdout.columns ?? 80;
+}
+function getBoxOverhead(options) {
+  const pad = normalizePadding(options.padding, 1);
+  const borders = normalizeBorders(options.borders);
+  return {
+    horizontal: (borders.left ? 1 : 0) + (borders.right ? 1 : 0) + pad.left + pad.right,
+    vertical: (borders.top ? 1 : 0) + (borders.bottom ? 1 : 0) + pad.top + pad.bottom
+  };
+}
+function getContentWidth(options) {
+  const { horizontal } = getBoxOverhead(options);
+  if (options.width) {
+    const content = options.width - horizontal;
+    return Math.max(0, content);
+  }
+  return Math.max(0, getTerminalWidth() - horizontal);
+}
+function resolveWidth(mode, ctx) {
+  if (typeof mode === "number") {
+    return mode;
+  }
+  if (mode === "text") {
+    return 0;
+  }
+  if (mode === "full") {
+    return getTerminalWidth();
+  }
+  if (mode === "container") {
+    if (!ctx) {
+      throw new Error("container width mode requires LayoutContext");
+    }
+    return ctx.width;
+  }
+  const percent = Number.parseInt(mode.slice(0, -1), 10);
+  const baseWidth = ctx?.width ?? getTerminalWidth();
+  return Math.floor(baseWidth * (percent / 100));
+}
+function createLayoutContext(options, parent) {
+  const effectiveOptions = { ...options };
+  if (effectiveOptions.width === undefined && parent) {
+    effectiveOptions.width = parent.width;
+  }
+  const width = getContentWidth(effectiveOptions);
+  return {
+    width,
+    ...parent && { parent }
+  };
+}
+function getWidth(text) {
+  return Bun.stringWidth(text);
+}
+function splitLines(block) {
+  return block.split(`
+`);
+}
+function padToWidth(text, width) {
+  const currentWidth = getWidth(text);
+  if (currentWidth >= width)
+    return text;
+  return text + " ".repeat(width - currentWidth);
+}
+function createFilledArray(length, value) {
+  const result = [];
+  for (let i = 0;i < length; i++) {
+    result.push(value);
+  }
+  return result;
+}
+function joinHorizontal(blocks, options) {
+  if (blocks.length === 0)
+    return "";
+  const first = blocks[0];
+  if (first === undefined)
+    return "";
+  if (blocks.length === 1)
+    return first;
+  const gap = options?.gap ?? 0;
+  const align = options?.align ?? "top";
+  const gapString = " ".repeat(gap);
+  const blockLines = blocks.map(splitLines);
+  const maxHeight = Math.max(...blockLines.map((lines) => lines.length));
+  const blockWidths = blockLines.map((lines) => Math.max(...lines.map(getWidth)));
+  const paddedBlocks = blockLines.map((lines, blockIndex) => {
+    const width = blockWidths[blockIndex] ?? 0;
+    const height = lines.length;
+    const padding = maxHeight - height;
+    let topPadding;
+    switch (align) {
+      case "top":
+        topPadding = 0;
+        break;
+      case "center":
+        topPadding = Math.floor(padding / 2);
+        break;
+      case "bottom":
+        topPadding = padding;
+        break;
+      default: {
+        const _exhaustive = align;
+        topPadding = _exhaustive;
+      }
+    }
+    const bottomPadding = padding - topPadding;
+    const emptyLine = " ".repeat(width);
+    const paddedLines = [
+      ...createFilledArray(topPadding, emptyLine),
+      ...lines.map((line) => padToWidth(line, width)),
+      ...createFilledArray(bottomPadding, emptyLine)
+    ];
+    return paddedLines;
+  });
+  const resultLines = [];
+  for (let i = 0;i < maxHeight; i++) {
+    const lineSegments = paddedBlocks.map((block) => block[i] ?? "");
+    resultLines.push(lineSegments.join(gapString));
+  }
+  return resultLines.join(`
+`);
+}
+function joinVertical(blocks, options) {
+  if (blocks.length === 0)
+    return "";
+  const first = blocks[0];
+  if (first === undefined)
+    return "";
+  if (blocks.length === 1)
+    return first;
+  const gap = options?.gap ?? 0;
+  const gapLines = gap > 0 ? `
+`.repeat(gap) : "";
+  return blocks.join(`
+${gapLines}`);
+}
+
+export { getTerminalWidth, getBoxOverhead, getContentWidth, resolveWidth, createLayoutContext, joinHorizontal, joinVertical };

package/dist/shared/@outfitter/cli-6bztk73z.d.ts

@@ -0,0 +1,51 @@
+import { WidthMode } from "./cli-2g8bx1aq";
+/**
+* Separator style for headings.
+*/
+type SeparatorStyle = "=" | "-" | "─" | "━" | "═";
+/**
+* Width mode for headings.
+*
+* Note: Headings only support "text", "full", and numeric widths.
+* Use the shared WidthMode type for full container-relative support.
+*
+* @see WidthMode for the complete type definition
+*/
+type HeadingWidthMode = Extract<WidthMode, "text" | "full" | number>;
+/**
+* Case transformation for heading text.
+*/
+type CaseMode = "upper" | "lower" | "title" | "none";
+/**
+* Options for rendering a heading.
+*/
+interface HeadingOptions {
+	/** Separator character/style (default: "=") */
+	separator?: SeparatorStyle;
+	/** Width mode (default: "text") */
+	width?: HeadingWidthMode;
+	/** Case transformation (default: "upper") */
+	case?: CaseMode;
+}
+/**
+* Renders a section heading with a separator line below.
+*
+* @param text - The heading text
+* @param options - Rendering options
+* @returns Formatted heading string
+*
+* @example
+* ```typescript
+* import { renderHeading } from "@outfitter/cli/render";
+*
+* console.log(renderHeading("Theme Colors"));
+* // THEME COLORS
+* // ============
+*
+* console.log(renderHeading("Status", { separator: "─", case: "none" }));
+* // Status
+* // ──────
+* ```
+*/
+declare function renderHeading(text: string, options?: HeadingOptions): string;
+export { SeparatorStyle, HeadingWidthMode, CaseMode, HeadingOptions, renderHeading };

package/dist/shared/@outfitter/cli-6fxffp8k.js

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