@outfitter/cli 0.1.0-rc.2 → 0.1.0

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-dds0qqvm.d.ts → cli-4cb5g831.d.ts}

@@ -45,6 +45,8 @@ declare function getStringWidth(text: string): number;
 * - 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

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

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

@@ -0,0 +1,118 @@
+// @bun
+import {
+  INDICATORS,
+  getIndicator,
+  getProgressIndicator
+} from "./cli-p1m5dhrs.js";
+import {
+  demoSection,
+  demoSubsection
+} from "./cli-34fqr7bp.js";
+
+// packages/cli/src/demo/renderers/indicators.ts
+function renderIndicatorsDemo(config, _theme) {
+  const showCode = config.showCode ?? true;
+  const lines = [];
+  lines.push(demoSection("Indicators"));
+  lines.push("");
+  if (showCode) {
+    lines.push('import { getIndicator, getProgressIndicator, INDICATORS } from "@outfitter/cli/render";');
+    lines.push("");
+  }
+  lines.push("Semantic indicators with Unicode and ASCII fallback support.");
+  lines.push("");
+  lines.push(demoSubsection("Status"));
+  lines.push("");
+  for (const [name, indicator] of Object.entries(INDICATORS.status)) {
+    const colorInfo = indicator.color ? ` (${indicator.color})` : "";
+    lines.push(`  ${indicator.unicode}  ${name.padEnd(10)} \u2192 ${indicator.fallback}${colorInfo}`);
+  }
+  lines.push("");
+  if (showCode) {
+    lines.push('getIndicator("status", "success")  // ' + getIndicator("status", "success", true));
+    lines.push('getIndicator("status", "error")    // ' + getIndicator("status", "error", true));
+    lines.push("");
+  }
+  lines.push(demoSubsection("Markers"));
+  lines.push("");
+  const markerGroups = {
+    Circles: [
+      "circle",
+      "circleOutline",
+      "circleDotted",
+      "circleSmall",
+      "circleDot",
+      "circleDotOutline"
+    ],
+    Squares: ["square", "squareOutline", "squareSmall", "squareSmallOutline"],
+    Lozenges: ["lozenge", "lozengeOutline"],
+    Checkboxes: ["checkbox", "checkboxChecked", "checkboxCross"],
+    Pointers: ["pointer", "pointerSmall", "dash"]
+  };
+  for (const [groupName, names] of Object.entries(markerGroups)) {
+    lines.push(`  ${groupName}:`);
+    for (const name of names) {
+      const indicator = INDICATORS.marker[name];
+      if (indicator) {
+        lines.push(`    ${indicator.unicode}  ${name.padEnd(18)} \u2192 ${indicator.fallback}`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push(demoSubsection("Progress"));
+  lines.push("");
+  lines.push("  Circle:     \u25CB \u25D4 \u25D1 \u25D5 \u25CF");
+  lines.push("  Vertical:   \u2581 \u2582 \u2583 \u2584 \u2585 \u2586 \u2587 \u2588");
+  lines.push("  Horizontal: \u258F \u258E \u258D \u258C \u258B \u258A \u2589 \u2588");
+  lines.push("  Shade:      \u2591 \u2592 \u2593");
+  lines.push("");
+  if (showCode) {
+    lines.push("// Get progress indicator by percentage:");
+    lines.push('getProgressIndicator("circle", 50, 100)      // ' + getProgressIndicator("circle", 50, 100, true));
+    lines.push('getProgressIndicator("vertical", 6, 8)      // ' + getProgressIndicator("vertical", 6, 8, true));
+    lines.push('getProgressIndicator("horizontal", 4, 8)    // ' + getProgressIndicator("horizontal", 4, 8, true));
+    lines.push('getProgressIndicator("shade", 100, 100)     // ' + getProgressIndicator("shade", 100, 100, true));
+    lines.push("");
+  }
+  lines.push(demoSubsection("Triangles"));
+  lines.push("");
+  const triangleGroups = {
+    Up: ["up", "upSmall", "upOutline"],
+    Down: ["down", "downSmall", "downOutline"],
+    Left: ["left", "leftSmall", "leftOutline"],
+    Right: ["right", "rightSmall", "rightOutline"]
+  };
+  for (const [groupName, names] of Object.entries(triangleGroups)) {
+    const indicators = names.map((n) => INDICATORS.triangle[n]?.unicode ?? "").join("  ");
+    lines.push(`  ${groupName.padEnd(6)} ${indicators}`);
+  }
+  lines.push("");
+  lines.push(demoSubsection("Special"));
+  lines.push("");
+  for (const [name, indicator] of Object.entries(INDICATORS.special)) {
+    lines.push(`  ${indicator.unicode}  ${name.padEnd(14)} \u2192 ${indicator.fallback}`);
+  }
+  lines.push("");
+  lines.push(demoSubsection("Directional"));
+  lines.push("");
+  for (const [name, indicator] of Object.entries(INDICATORS.directional)) {
+    lines.push(`  ${indicator.unicode}  ${name.padEnd(16)} \u2192 ${indicator.fallback}`);
+  }
+  lines.push("");
+  lines.push(demoSubsection("Math"));
+  lines.push("");
+  for (const [name, indicator] of Object.entries(INDICATORS.math)) {
+    lines.push(`  ${indicator.unicode}  ${name.padEnd(16)} \u2192 ${indicator.fallback}`);
+  }
+  lines.push("");
+  lines.push(demoSubsection("Usage"));
+  lines.push("");
+  lines.push("\u2022 getIndicator(category, name) \u2014 auto-detects Unicode support");
+  lines.push("\u2022 getProgressIndicator(style, current, max) \u2014 maps value to step");
+  lines.push("\u2022 INDICATORS[category][name] \u2014 direct access to unicode/fallback");
+  lines.push("\u2022 Status indicators include semantic color hints");
+  return lines.join(`
+`);
+}
+
+export { renderIndicatorsDemo };

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

@@ -0,0 +1,61 @@
+import { PartialVisualTheme, VisualTheme } from "./cli-s0kkx9m1";
+/**
+* Options for creating a visual theme.
+*/
+interface CreateVisualThemeOptions {
+	/**
+	* Base theme to extend from.
+	* Properties not overridden will be inherited from this theme.
+	* @default defaultTheme
+	*/
+	extends?: VisualTheme;
+	/**
+	* Properties to override on the base/extended theme.
+	* Supports partial overrides for nested objects (colors, spacing, markers).
+	*/
+	overrides?: PartialVisualTheme;
+}
+/**
+* Creates a visual theme by extending and/or overriding a base theme.
+*
+* This is the primary factory for creating custom themes. You can:
+* - Start from scratch (no options → defaultTheme)
+* - Extend an existing preset
+* - Override specific properties
+* - Combine extension and overrides
+*
+* When changing the `border` property, `borderChars` is automatically
+* updated to match the new border style.
+*
+* @param options - Configuration for theme creation
+* @returns A complete VisualTheme
+*
+* @example
+* ```typescript
+* // Start with defaults
+* const theme = createVisualTheme();
+*
+* // Extend a preset
+* const rounded = createVisualTheme({ extends: roundedTheme });
+*
+* // Override specific properties
+* const custom = createVisualTheme({
+*   overrides: {
+*     border: "double",
+*     colors: { success: "\x1b[38;5;82m" },
+*     spacing: { boxPadding: 2 }
+*   }
+* });
+*
+* // Extend and override
+* const brandTheme = createVisualTheme({
+*   extends: roundedTheme,
+*   overrides: {
+*     name: "brand",
+*     colors: { accent: "\x1b[38;5;39m" }
+*   }
+* });
+* ```
+*/
+declare function createVisualTheme(options?: CreateVisualThemeOptions): VisualTheme;
+export { CreateVisualThemeOptions, createVisualTheme };

package/dist/shared/@outfitter/cli-74ba31gz.js

@@ -0,0 +1,134 @@
+// @bun
+import {
+  getThemeMethodsByCategory
+} from "./cli-kc84wmch.js";
+import {
+  getExample
+} from "./cli-xep6v2c0.js";
+import {
+  demoSection
+} from "./cli-34fqr7bp.js";
+import {
+  ANSI,
+  applyColor,
+  createTokens,
+  init_colors,
+  resolveTokenColorEnabled
+} from "./cli-9nbyj2bt.js";
+import {
+  hasNoColorEnv,
+  init_detection,
+  resolveForceColorEnv
+} from "./cli-d9ad0rqj.js";
+
+// packages/cli/src/demo/renderers/colors.ts
+init_colors();
+init_detection();
+function renderColorsDemo(config, theme) {
+  const showCode = config.showCode ?? true;
+  const tokens = createTokens();
+  const colorEnabled = resolveTokenColorEnabled();
+  const lines = [];
+  lines.push(demoSection("Theme Colors (createTheme)", { case: "none" }));
+  lines.push("");
+  if (showCode) {
+    lines.push('import { createTheme } from "@outfitter/cli/render";');
+    lines.push("const theme = createTheme();");
+    lines.push("");
+  }
+  const { semantic } = getThemeMethodsByCategory();
+  for (const method of semantic) {
+    const text = getExample(method, config.examples);
+    const fn = theme[method];
+    const output = fn(text);
+    const code = `theme.${method}("${text}")`;
+    lines.push(`${code.padEnd(42)} \u2192 ${output}`);
+  }
+  lines.push("");
+  lines.push(demoSection("Utility Methods"));
+  lines.push("");
+  const { utility } = getThemeMethodsByCategory();
+  for (const method of utility) {
+    const text = getExample(method, config.examples);
+    const fn = theme[method];
+    const output = fn(text);
+    const code = `theme.${method}("${text}")`;
+    lines.push(`${code.padEnd(42)} \u2192 ${output}`);
+  }
+  lines.push("");
+  lines.push(demoSection("Direct Colors (applyColor)", { case: "none" }));
+  lines.push("");
+  if (showCode) {
+    lines.push('import { applyColor } from "@outfitter/cli/render";');
+    lines.push("");
+  }
+  const colors = [
+    "green",
+    "yellow",
+    "red",
+    "blue",
+    "cyan",
+    "magenta",
+    "gray"
+  ];
+  for (const color of colors) {
+    const code = `applyColor("text", "${color}")`;
+    const output = applyColor("text", color);
+    lines.push(`${code.padEnd(32)} \u2192 ${output}`);
+  }
+  lines.push("");
+  lines.push(demoSection("Raw Tokens (createTokens)", { case: "none" }));
+  lines.push("");
+  if (showCode) {
+    lines.push('import { createTokens, ANSI } from "@outfitter/cli/render";');
+    lines.push("const t = createTokens();");
+    lines.push("");
+  }
+  const d = "$";
+  const tokenExamples = [
+    {
+      code: `\`${d}{t.success}Done${d}{ANSI.reset}\``,
+      token: tokens.success,
+      text: "Done"
+    },
+    {
+      code: `\`${d}{t.error}Fail${d}{ANSI.reset}\``,
+      token: tokens.error,
+      text: "Fail"
+    },
+    {
+      code: `\`${d}{t.warning}Warn${d}{ANSI.reset}\``,
+      token: tokens.warning,
+      text: "Warn"
+    },
+    {
+      code: `\`${d}{t.info}Info${d}{ANSI.reset}\``,
+      token: tokens.info,
+      text: "Info"
+    }
+  ];
+  for (const example of tokenExamples) {
+    const reset = example.token ? ANSI.reset : "";
+    const output = `${example.token}${example.text}${reset}`;
+    lines.push(`${example.code.padEnd(36)} \u2192 ${output}`);
+  }
+  lines.push("");
+  lines.push(demoSection("Environment"));
+  const noColor = hasNoColorEnv();
+  const forceColor = resolveForceColorEnv();
+  let forceColorDisplay;
+  if (forceColor === true) {
+    forceColorDisplay = theme.success("enabled");
+  } else if (forceColor === false) {
+    forceColorDisplay = theme.error("disabled");
+  } else {
+    forceColorDisplay = theme.muted("not set");
+  }
+  lines.push(`Colors: ${colorEnabled ? theme.success("enabled") : theme.muted("disabled")} ${theme.muted(colorEnabled ? "(TTY detected)" : "(non-TTY or NO_COLOR set)")}`);
+  lines.push(`NO_COLOR: ${noColor ? theme.warning("set") : theme.muted("not set")}`);
+  lines.push(`FORCE_COLOR: ${forceColorDisplay}`);
+  return lines.join(`
+`);
+}
+
+export { renderColorsDemo };