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

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

@@ -0,0 +1,54 @@
+/**
+* ANSI escape sequences for terminal control.
+*
+* @packageDocumentation
+*/
+/**
+* ANSI escape sequences for cursor and screen control.
+*
+* @example
+* ```typescript
+* import { ANSI } from "@outfitter/cli/streaming";
+*
+* // Move cursor up 2 lines and clear
+* process.stdout.write(ANSI.cursorUp(2) + ANSI.clearLine);
+*
+* // Hide cursor during animation
+* process.stdout.write(ANSI.hideCursor);
+* // ... do animation ...
+* process.stdout.write(ANSI.showCursor);
+* ```
+*/
+declare const ANSI: {
+	/** Move cursor up n lines */
+	readonly cursorUp: (n: number) => string;
+	/** Move cursor down n lines */
+	readonly cursorDown: (n: number) => string;
+	/** Move cursor right n columns */
+	readonly cursorRight: (n: number) => string;
+	/** Move cursor left n columns */
+	readonly cursorLeft: (n: number) => string;
+	/** Move cursor to beginning of line */
+	readonly cursorToStart: "\x1B[G";
+	/** Clear entire line */
+	readonly clearLine: "\x1B[2K";
+	/** Clear from cursor to end of screen */
+	readonly clearToEnd: "\x1B[0J";
+	/** Clear from cursor to beginning of screen */
+	readonly clearToStart: "\x1B[1J";
+	/** Clear entire screen */
+	readonly clearScreen: "\x1B[2J";
+	/** Hide cursor */
+	readonly hideCursor: "\x1B[?25l";
+	/** Show cursor */
+	readonly showCursor: "\x1B[?25h";
+	/** Save cursor position */
+	readonly saveCursor: "\x1B[s";
+	/** Restore cursor position */
+	readonly restoreCursor: "\x1B[u";
+	/** Carriage return (move to start of line) */
+	readonly carriageReturn: "\r";
+	/** New line */
+	readonly newLine: "\n";
+};
+export { ANSI };

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

@@ -0,0 +1,20 @@
+// @bun
+import {
+  defaultTheme
+} from "./cli-cs45xd6q.js";
+import {
+  BORDERS,
+  init_borders
+} from "./cli-85fg2vr5.js";
+
+// packages/cli/src/theme/presets/rounded.ts
+init_borders();
+var roundedTheme = {
+  ...defaultTheme,
+  name: "rounded",
+  border: "rounded",
+  borderChars: BORDERS.rounded,
+  treeGuide: "rounded"
+};
+
+export { roundedTheme };

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

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

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

@@ -0,0 +1,52 @@
+// @bun
+// packages/cli/src/demo/templates.ts
+var DEFAULT_EXAMPLES = {
+  success: "Operation completed",
+  warning: "Proceed with caution",
+  error: "Something went wrong",
+  info: "For your information",
+  primary: "Main content",
+  secondary: "Supporting text",
+  muted: "(optional)",
+  accent: "Highlighted item",
+  highlight: "Important",
+  link: "https://example.com",
+  destructive: "Delete forever",
+  subtle: "Fine print",
+  bold: "Strong emphasis",
+  italic: "Subtle emphasis",
+  underline: "Underlined text",
+  dim: "De-emphasized",
+  boxContent: "Hello, world!",
+  boxTitle: "Status",
+  spinnerMessage: "Loading...",
+  progressLabel: "Progress",
+  listItems: ["First item", "Second item", "Third item"],
+  tableData: [
+    { id: 1, name: "Alice", status: "Active" },
+    { id: 2, name: "Bob", status: "Pending" }
+  ],
+  treeData: {
+    src: {
+      components: {
+        Button: null,
+        Input: null
+      },
+      utils: null
+    },
+    tests: null
+  },
+  markdownSample: `# Heading
+
+Some **bold** and *italic* text.
+
+Use \`npm install\` to install.`
+};
+function getExample(key, custom) {
+  if (custom?.[key] !== undefined) {
+    return custom[key];
+  }
+  return DEFAULT_EXAMPLES[key];
+}
+
+export { DEFAULT_EXAMPLES, getExample };

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

@@ -0,0 +1,86 @@
+// @bun
+// packages/cli/src/render/list.ts
+function toLetter(n) {
+  return String.fromCharCode(96 + n);
+}
+function toRoman(n) {
+  const numerals = [
+    [10, "x"],
+    [9, "ix"],
+    [5, "v"],
+    [4, "iv"],
+    [1, "i"]
+  ];
+  let result = "";
+  let remaining = n;
+  for (const [value, symbol] of numerals) {
+    while (remaining >= value) {
+      result += symbol;
+      remaining -= value;
+    }
+  }
+  return result;
+}
+function getMarker(style, depth, index, isChecked) {
+  switch (style) {
+    case "bullet":
+      return "\u2022";
+    case "dash":
+      return "-";
+    case "number":
+      if (depth === 0) {
+        return `${index + 1}.`;
+      }
+      if (depth === 1) {
+        return `${toLetter(index + 1)}.`;
+      }
+      return `${toRoman(index + 1)}.`;
+    case "checkbox":
+      return isChecked ? "\u2611" : "\u2610";
+    default: {
+      const _exhaustive = style;
+      return _exhaustive;
+    }
+  }
+}
+function renderList(items, options) {
+  const style = options?.style ?? "dash";
+  const checkedSet = options?.checked ?? new Set;
+  const baseIndent = options?.indent ?? 2;
+  const lines = [];
+  let _globalIndex = 0;
+  const renderItem = (item, currentIndent, depth, indexAtDepth, currentStyle) => {
+    const indentStr = " ".repeat(currentIndent);
+    const text = typeof item === "string" ? item : item.text;
+    let isChecked = false;
+    if (currentStyle === "checkbox") {
+      if (typeof item !== "string" && item.checked !== undefined) {
+        isChecked = item.checked;
+      } else if (depth === 0) {
+        isChecked = checkedSet.has(indexAtDepth);
+      }
+    }
+    const marker = getMarker(currentStyle, depth, indexAtDepth, isChecked);
+    lines.push(`${indentStr}${marker} ${text}`);
+    _globalIndex++;
+    if (typeof item !== "string" && item.children) {
+      const childStyle = typeof item !== "string" && item.childStyle ? item.childStyle : currentStyle;
+      const childIndent = currentStyle === "number" ? currentIndent + marker.length + 1 : currentIndent + baseIndent;
+      const childDepth = childStyle !== currentStyle ? 0 : depth + 1;
+      let childIndex = 0;
+      for (const child of item.children) {
+        renderItem(child, childIndent, childDepth, childIndex, childStyle);
+        childIndex++;
+      }
+    }
+  };
+  let topIndex = 0;
+  for (const item of items) {
+    renderItem(item, 0, 0, topIndex, style);
+    topIndex++;
+  }
+  return lines.join(`
+`);
+}
+
+export { renderList };

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

@@ -0,0 +1,248 @@
+/**
+* ANSI escape code constants for terminal styling.
+*/
+declare const ANSI: {
+	readonly reset: "\x1B[0m";
+	readonly bold: "\x1B[1m";
+	readonly dim: "\x1B[2m";
+	readonly italic: "\x1B[3m";
+	readonly underline: "\x1B[4m";
+	readonly green: "\x1B[32m";
+	readonly yellow: "\x1B[33m";
+	readonly red: "\x1B[31m";
+	readonly blue: "\x1B[34m";
+	readonly cyan: "\x1B[36m";
+	readonly magenta: "\x1B[35m";
+	readonly white: "\x1B[37m";
+	readonly gray: "\x1B[90m";
+	readonly brightCyan: "\x1B[96m";
+	readonly brightRed: "\x1B[91m";
+	readonly brightYellow: "\x1B[93m";
+	readonly brightGreen: "\x1B[92m";
+	readonly brightBlue: "\x1B[94m";
+};
+/**
+* Theme interface with semantic and text color functions.
+*
+* Each function wraps text in ANSI escape codes when colors are supported.
+* When colors are not supported (NO_COLOR set, non-TTY), functions return the text unchanged.
+*
+* @example
+* ```typescript
+* const theme = createTheme();
+* console.log(theme.success("Done!"));       // Green text
+* console.log(theme.error("Failed!"));       // Red text
+* console.log(theme.muted("(optional)"));    // Dim text
+* ```
+*/
+interface Theme {
+	/** Applies green color for success messages */
+	success: (text: string) => string;
+	/** Applies yellow color for warning messages */
+	warning: (text: string) => string;
+	/** Applies red color for error messages */
+	error: (text: string) => string;
+	/** Applies blue color for informational messages */
+	info: (text: string) => string;
+	/** Returns text unchanged (primary/default text) */
+	primary: (text: string) => string;
+	/** Applies gray color for secondary text */
+	secondary: (text: string) => string;
+	/** Applies dim styling for de-emphasized text */
+	muted: (text: string) => string;
+	/** Applies cyan color for interactive elements and highlights */
+	accent: (text: string) => string;
+	/** Applies bold for strong emphasis */
+	highlight: (text: string) => string;
+	/** Applies cyan + underline for URLs and clickable references */
+	link: (text: string) => string;
+	/** Applies bright red for dangerous actions */
+	destructive: (text: string) => string;
+	/** Applies dim gray for less prominent text than muted */
+	subtle: (text: string) => string;
+	/** Applies bold styling */
+	bold: (text: string) => string;
+	/** Applies italic styling */
+	italic: (text: string) => string;
+	/** Applies underline styling */
+	underline: (text: string) => string;
+	/** Applies dim styling (alias for muted style) */
+	dim: (text: string) => string;
+}
+/**
+* Available color names for the {@link applyColor} function.
+*
+* @example
+* ```typescript
+* import { applyColor, ColorName } from "@outfitter/cli";
+*
+* const color: ColorName = "green";
+* console.log(applyColor("Success", color));
+* ```
+*/
+type ColorName = "green" | "yellow" | "red" | "blue" | "cyan" | "magenta" | "white" | "gray";
+/**
+* Semantic color tokens as raw ANSI escape code strings.
+*
+* Unlike {@link Theme} which provides wrapper functions, Tokens provides
+* raw ANSI codes that can be used directly in template strings.
+*
+* When colors are not supported (NO_COLOR set, colorLevel: 0), all tokens
+* are empty strings.
+*
+* @example
+* ```typescript
+* const tokens = createTokens();
+* const reset = "\x1b[0m";
+*
+* console.log(`${tokens.success}Operation completed${reset}`);
+* console.log(`${tokens.error}Failed to connect${reset}`);
+* console.log(`${tokens.muted}(optional step)${reset}`);
+* ```
+*/
+interface Tokens {
+	/** Green color for success messages */
+	success: string;
+	/** Yellow color for warning messages */
+	warning: string;
+	/** Red color for error messages */
+	error: string;
+	/** Blue color for informational messages */
+	info: string;
+	/** Default text color (typically empty string) */
+	primary: string;
+	/** Subdued color for secondary text */
+	secondary: string;
+	/** Dim/gray color for de-emphasized text */
+	muted: string;
+	/** Cyan color for interactive elements and highlights */
+	accent: string;
+	/** Bold for strong emphasis */
+	highlight: string;
+	/** Cyan + underline for URLs and clickable references */
+	link: string;
+	/** Bright red for dangerous actions */
+	destructive: string;
+	/** Dim gray for less prominent text than muted */
+	subtle: string;
+	/** Bold styling */
+	bold: string;
+	/** Italic styling */
+	italic: string;
+	/** Underline styling */
+	underline: string;
+	/** Dim styling */
+	dim: string;
+}
+/**
+* Configuration options for {@link createTokens}.
+*
+* @example
+* ```typescript
+* // Force colors even with NO_COLOR set
+* const tokens = createTokens({ forceColor: true });
+*
+* // Disable colors entirely
+* const noColorTokens = createTokens({ colorLevel: 0 });
+* ```
+*/
+interface TokenOptions {
+	/**
+	* Override NO_COLOR environment variable.
+	* When true, colors are enabled regardless of NO_COLOR.
+	*/
+	forceColor?: boolean;
+	/**
+	* Color support level:
+	* - 0: No color support (all tokens are empty strings)
+	* - 1: Basic ANSI colors (16 colors)
+	* - 2: 256 color support
+	* - 3: True color (16 million colors)
+	*
+	* When not specified, level is auto-detected from environment.
+	*/
+	colorLevel?: 0 | 1 | 2 | 3;
+}
+/**
+* Creates a theme with semantic and text color functions.
+*
+* The theme provides functions that wrap text in ANSI escape codes.
+* When colors are not supported (NO_COLOR set, non-TTY), functions
+* return the text unchanged.
+*
+* Color support is determined once at theme creation time using
+* {@link supportsColor}.
+*
+* @returns Theme object with color functions
+*
+* @example
+* ```typescript
+* const theme = createTheme();
+*
+* // Semantic colors
+* console.log(theme.success("Done!"));       // Green
+* console.log(theme.warning("Caution"));     // Yellow
+* console.log(theme.error("Failed!"));       // Red
+* console.log(theme.info("Note"));           // Blue
+*
+* // Text colors
+* console.log(theme.primary("Main text"));   // Default
+* console.log(theme.secondary("Alt text"));  // Gray
+* console.log(theme.muted("(optional)"));    // Dim
+* ```
+*/
+declare function createTheme(): Theme;
+/**
+* Resolves whether color tokens should be enabled based on options.
+*
+* @param options - Token options
+* @returns `true` if colors should be enabled
+*/
+declare function resolveTokenColorEnabled(options?: TokenOptions): boolean;
+/**
+* Creates semantic color tokens as raw ANSI escape code strings.
+*
+* Unlike {@link createTheme} which returns wrapper functions, this returns
+* raw ANSI codes that can be used directly in template strings. This is
+* useful for more complex string formatting scenarios.
+*
+* Color support is determined at token creation time using environment
+* detection (NO_COLOR, FORCE_COLOR) or explicit options.
+*
+* @param options - Optional configuration for color behavior
+* @returns Object with semantic color tokens as ANSI strings
+*
+* @example
+* ```typescript
+* const tokens = createTokens();
+* const reset = "\x1b[0m";
+*
+* // Use in template strings
+* console.log(`${tokens.success}Done!${reset}`);
+* console.log(`${tokens.error}Failed${reset}`);
+*
+* // Build complex formatted strings
+* const status = `${tokens.info}Status:${reset} ${tokens.success}OK${reset}`;
+* ```
+*/
+declare function createTokens(options?: TokenOptions): Tokens;
+/**
+* Applies a named color to text using ANSI escape codes.
+*
+* Returns plain text if colors are not supported (NO_COLOR set, non-TTY).
+* For semantic colors (success, error, etc.), use {@link createTheme} instead.
+*
+* @param text - The text to colorize
+* @param color - The color name to apply
+* @returns Text wrapped in ANSI escape codes, or plain text if colors not supported
+*
+* @example
+* ```typescript
+* console.log(applyColor("Success", "green"));
+* console.log(applyColor("Warning", "yellow"));
+* console.log(applyColor("Error", "red"));
+* console.log(applyColor("Info", "blue"));
+* ```
+*/
+declare function applyColor(text: string, color: ColorName): string;
+export { ANSI, Theme, ColorName, Tokens, TokenOptions, createTheme, resolveTokenColorEnabled, createTokens, applyColor };

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

@@ -0,0 +1,82 @@
+// @bun
+import {
+  getTerminalWidth
+} from "./cli-671sxkhj.js";
+
+// packages/cli/src/render/heading.ts
+var ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+function toTitleCase(text) {
+  return text.replace(/\w\S*/g, (word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
+}
+function applyCase(text, caseMode) {
+  if (caseMode === "none") {
+    return text;
+  }
+  const hasAnsi = ANSI_PATTERN.test(text);
+  ANSI_PATTERN.lastIndex = 0;
+  if (!hasAnsi) {
+    switch (caseMode) {
+      case "upper":
+        return text.toUpperCase();
+      case "lower":
+        return text.toLowerCase();
+      case "title":
+        return toTitleCase(text);
+      default: {
+        const _exhaustive = caseMode;
+        return _exhaustive;
+      }
+    }
+  }
+  const sequences = [];
+  for (const match of text.matchAll(ANSI_PATTERN)) {
+    sequences.push({ index: match.index, seq: match[0] });
+  }
+  const stripped = Bun.stripANSI(text);
+  let transformed;
+  switch (caseMode) {
+    case "upper":
+      transformed = stripped.toUpperCase();
+      break;
+    case "lower":
+      transformed = stripped.toLowerCase();
+      break;
+    case "title":
+      transformed = toTitleCase(stripped);
+      break;
+    default: {
+      const _exhaustive = caseMode;
+      return _exhaustive;
+    }
+  }
+  let result = transformed;
+  let offset = 0;
+  for (const { index, seq } of sequences) {
+    const insertPos = index + offset;
+    result = result.slice(0, insertPos) + seq + result.slice(insertPos);
+    offset += seq.length;
+  }
+  return result;
+}
+function getTextWidth(text) {
+  return Bun.stringWidth(text);
+}
+function renderHeading(text, options) {
+  const separator = options?.separator ?? "=";
+  const widthMode = options?.width ?? "text";
+  const caseMode = options?.case ?? "upper";
+  const transformedText = applyCase(text, caseMode);
+  let width;
+  if (widthMode === "text") {
+    width = getTextWidth(transformedText);
+  } else if (widthMode === "full") {
+    width = getTerminalWidth();
+  } else {
+    width = widthMode;
+  }
+  const separatorLine = separator.repeat(width);
+  return `${transformedText}
+${separatorLine}`;
+}
+
+export { renderHeading };

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

@@ -0,0 +1,48 @@
+import { MultiSelectPromptOptions, PromptResult, SelectPromptOptions } from "./cli-3f12z5kf";
+/**
+* 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/cli/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/cli/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 };