@outfitter/cli 0.1.0-rc.2 → 0.1.0

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

@@ -0,0 +1,98 @@
+/**
+* Indicator primitives for CLI output.
+*
+* Provides status symbols, selection indicators, list bullets, and progress
+* markers with unicode and ASCII fallback support.
+*
+* @packageDocumentation
+*/
+/**
+* Categories of indicators available.
+*/
+type IndicatorCategory = "status" | "marker" | "progress" | "triangle" | "special" | "directional" | "math";
+/**
+* An indicator with unicode and fallback representations.
+*/
+interface IndicatorSet {
+	/** Unicode character for modern terminals */
+	unicode: string;
+	/** ASCII fallback for limited terminals */
+	fallback: string;
+	/** Optional semantic color name */
+	color?: string;
+}
+/**
+* All available indicators organized by category.
+*
+* @example
+* ```typescript
+* import { INDICATORS, getIndicator } from "@outfitter/cli/render";
+*
+* // Access directly
+* console.log(INDICATORS.status.success.unicode); // "✔"
+*
+* // Or use helper
+* console.log(getIndicator("status", "success")); // "✔" or "[ok]"
+* ```
+*/
+declare const INDICATORS: Record<IndicatorCategory, Record<string, IndicatorSet>>;
+/**
+* Detects if the terminal supports Unicode characters.
+*
+* Checks for:
+* - CI environments (usually support unicode)
+* - Windows Terminal / ConEmu
+* - TERM containing xterm/vt100
+* - Locale settings
+*
+* @returns true if unicode is likely supported
+*/
+declare function isUnicodeSupported(): boolean;
+/**
+* Gets an indicator character with automatic unicode/fallback selection.
+*
+* @param category - The indicator category
+* @param name - The indicator name within the category
+* @param forceUnicode - Override unicode detection (useful for testing)
+* @returns The appropriate character for the current terminal
+*
+* @example
+* ```typescript
+* // Automatic detection
+* console.log(getIndicator("status", "success"));
+*
+* // Force unicode
+* console.log(getIndicator("status", "success", true)); // "✔"
+*
+* // Force fallback
+* console.log(getIndicator("status", "success", false)); // "[ok]"
+* ```
+*/
+declare function getIndicator(category: IndicatorCategory, name: string, forceUnicode?: boolean): string;
+/**
+* Progress indicator styles.
+*/
+type ProgressStyle = "circle" | "vertical" | "horizontal" | "shade";
+/**
+* Gets a progress indicator based on current/max values.
+*
+* @param style - The progress style (circle, vertical, horizontal, shade)
+* @param current - Current progress value
+* @param max - Maximum progress value
+* @param forceUnicode - Override unicode detection
+* @returns The appropriate progress indicator character
+*
+* @example
+* ```typescript
+* // Circle progress at 50%
+* getProgressIndicator("circle", 50, 100); // "◑"
+*
+* // Vertical block at 75%
+* getProgressIndicator("vertical", 6, 8); // "▆"
+*
+* // Horizontal bar at 100%
+* getProgressIndicator("horizontal", 1, 1); // "█"
+* ```
+*/
+declare function getProgressIndicator(style: ProgressStyle, current: number, max: number, forceUnicode?: boolean): string;
+export { IndicatorCategory, IndicatorSet, INDICATORS, isUnicodeSupported, getIndicator, ProgressStyle, getProgressIndicator };

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

@@ -0,0 +1,30 @@
+// @bun
+import {
+  defaultTheme
+} from "./cli-cs45xd6q.js";
+import {
+  BORDERS,
+  init_borders
+} from "./cli-85fg2vr5.js";
+
+// packages/cli/src/theme/presets/minimal.ts
+init_borders();
+var minimalTheme = {
+  ...defaultTheme,
+  name: "minimal",
+  border: "ascii",
+  borderChars: BORDERS.ascii,
+  treeGuide: "single",
+  delimiter: "bullet",
+  markers: {
+    ...defaultTheme.markers
+  },
+  listBullet: { unicode: "-", fallback: "-" },
+  checkbox: {
+    checked: { unicode: "[x]", fallback: "[x]" },
+    unchecked: { unicode: "[ ]", fallback: "[ ]" }
+  },
+  spinner: "line"
+};
+
+export { minimalTheme };

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

@@ -0,0 +1,126 @@
+// @bun
+import {
+  renderList
+} from "./cli-xg5y5fhk.js";
+import {
+  LIST_STYLE_META,
+  getListStyles
+} from "./cli-kc84wmch.js";
+import {
+  getExample
+} from "./cli-xep6v2c0.js";
+import {
+  demoSection
+} from "./cli-34fqr7bp.js";
+
+// packages/cli/src/demo/renderers/list.ts
+function renderListDemo(config, theme) {
+  const showCode = config.showCode ?? true;
+  const showDescriptions = config.showDescriptions ?? true;
+  const lines = [];
+  lines.push(demoSection("List Styles"));
+  lines.push("");
+  if (showCode) {
+    lines.push('import { renderList } from "@outfitter/cli/render";');
+    lines.push("");
+  }
+  const items = getExample("listItems", config.examples);
+  const styles = getListStyles();
+  for (const style of styles) {
+    const meta = LIST_STYLE_META[style];
+    lines.push(`${meta.label.toUpperCase()} STYLE`);
+    if (showDescriptions) {
+      lines.push(theme.muted(meta.description));
+    }
+    lines.push("");
+    if (showCode) {
+      lines.push(`renderList(items, { style: "${style}" })`);
+      lines.push("");
+    }
+    if (style === "checkbox") {
+      const output = renderList(items, {
+        style,
+        checked: new Set([1])
+      });
+      lines.push(output);
+    } else {
+      const output = renderList(items, { style });
+      lines.push(output);
+    }
+    lines.push("");
+  }
+  lines.push(demoSection("Nested Lists"));
+  lines.push("");
+  const nestedItems = [
+    "Top level item",
+    {
+      text: "Parent with children",
+      children: ["Child one", "Child two"]
+    },
+    "Another top level"
+  ];
+  if (showCode) {
+    lines.push("renderList([");
+    lines.push('  "Top level item",');
+    lines.push('  { text: "Parent with children", children: ["Child one", "Child two"] },');
+    lines.push('  "Another top level",');
+    lines.push("])");
+    lines.push("");
+  }
+  lines.push(renderList(nestedItems));
+  lines.push("");
+  lines.push(demoSection("Numbered with Nesting"));
+  lines.push("");
+  const numberedNested = [
+    {
+      text: "First section",
+      children: [
+        {
+          text: "Subsection A",
+          children: ["Detail i", "Detail ii"]
+        },
+        "Subsection B"
+      ]
+    },
+    "Second section"
+  ];
+  if (showCode) {
+    lines.push('renderList(items, { style: "number" })');
+    lines.push("");
+  }
+  lines.push(renderList(numberedNested, { style: "number" }));
+  lines.push("");
+  lines.push(demoSection("Mixed Styles"));
+  lines.push("");
+  if (showDescriptions) {
+    lines.push(theme.muted("Use childStyle to override style for children"));
+    lines.push("");
+  }
+  const mixedItems = [
+    {
+      text: "Requirements",
+      childStyle: "bullet",
+      children: ["Must be fast", "Must be reliable"]
+    },
+    {
+      text: "Tasks",
+      childStyle: "checkbox",
+      children: [
+        { text: "Write tests", checked: true },
+        { text: "Deploy to prod", checked: false }
+      ]
+    }
+  ];
+  if (showCode) {
+    lines.push("renderList([");
+    lines.push('  { text: "Requirements", childStyle: "bullet", children: [...] },');
+    lines.push('  { text: "Tasks", childStyle: "checkbox", children: [...] },');
+    lines.push('], { style: "number" })');
+    lines.push("");
+  }
+  lines.push(renderList(mixedItems, { style: "number" }));
+  return lines.join(`
+`);
+}
+
+export { renderListDemo };

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

@@ -0,0 +1,36 @@
+import { CancelledError, PromptResult } from "./cli-3f12z5kf";
+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/cli/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/cli-tvw1xrdj.js

@@ -0,0 +1,20 @@
+// @bun
+// packages/cli/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/cli-v1tzwxkt.js

@@ -0,0 +1,32 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+export { __toCommonJS, __export, __esm, __require };

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

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

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

@@ -0,0 +1,279 @@
+// @bun
+import {
+  getStringWidth,
+  init_text,
+  truncateText,
+  wrapText
+} from "./cli-jjemfdta.js";
+import {
+  getBorderCharacters,
+  init_borders
+} from "./cli-85fg2vr5.js";
+import {
+  __esm,
+  __export
+} from "./cli-v1tzwxkt.js";
+
+// packages/cli/src/render/box.ts
+var exports_box = {};
+__export(exports_box, {
+  renderBox: () => renderBox,
+  normalizePadding: () => normalizePadding,
+  normalizeMargin: () => normalizeMargin,
+  normalizeBorders: () => normalizeBorders,
+  createBox: () => createBox
+});
+function alignLine(line, width, align) {
+  const lineWidth = getStringWidth(line);
+  const padding = width - lineWidth;
+  if (padding <= 0) {
+    return line;
+  }
+  switch (align) {
+    case "center": {
+      const leftPad = Math.floor(padding / 2);
+      const rightPad = padding - leftPad;
+      return " ".repeat(leftPad) + line + " ".repeat(rightPad);
+    }
+    case "right":
+      return " ".repeat(padding) + line;
+    default:
+      return line + " ".repeat(padding);
+  }
+}
+function normalizePadding(padding, defaultValue) {
+  if (padding === undefined) {
+    return { top: 0, right: defaultValue, bottom: 0, left: defaultValue };
+  }
+  if (typeof padding === "number") {
+    return { top: 0, right: padding, bottom: 0, left: padding };
+  }
+  return {
+    top: padding.top ?? 0,
+    right: padding.right ?? defaultValue,
+    bottom: padding.bottom ?? 0,
+    left: padding.left ?? defaultValue
+  };
+}
+function normalizeMargin(margin, defaultValue) {
+  if (margin === undefined) {
+    return {
+      top: defaultValue,
+      right: defaultValue,
+      bottom: defaultValue,
+      left: defaultValue
+    };
+  }
+  if (typeof margin === "number") {
+    return { top: margin, right: margin, bottom: margin, left: margin };
+  }
+  return {
+    top: margin.top ?? defaultValue,
+    right: margin.right ?? defaultValue,
+    bottom: margin.bottom ?? defaultValue,
+    left: margin.left ?? defaultValue
+  };
+}
+function normalizeBorders(borders) {
+  if (borders === undefined) {
+    return { top: true, right: true, bottom: true, left: true };
+  }
+  return {
+    top: borders.top ?? true,
+    right: borders.right ?? true,
+    bottom: borders.bottom ?? true,
+    left: borders.left ?? true
+  };
+}
+function renderBox(content, options) {
+  const border = options?.border ?? "single";
+  const title = options?.title;
+  const align = options?.align ?? "left";
+  const fixedWidth = options?.width;
+  const sections = options?.sections;
+  const pad = normalizePadding(options?.padding, 1);
+  const margin = normalizeMargin(options?.margin, 0);
+  const borders = normalizeBorders(options?.borders);
+  const chars = getBorderCharacters(border);
+  let lines;
+  let sectionBoundaries = [];
+  if (sections && sections.length > 0) {
+    lines = [];
+    for (const [idx, section] of sections.entries()) {
+      const sectionLines = typeof section === "string" ? section.split(`
+`) : section;
+      lines.push(...sectionLines);
+      if (idx < sections.length - 1) {
+        sectionBoundaries.push(lines.length);
+      }
+    }
+  } else if (typeof content === "string") {
+    lines = content.split(`
+`);
+  } else {
+    lines = content;
+  }
+  const leftOverhead = (borders.left ? 1 : 0) + pad.left;
+  const rightOverhead = (borders.right ? 1 : 0) + pad.right;
+  const horizontalOverhead = leftOverhead + rightOverhead;
+  if (fixedWidth) {
+    const contentWidthForWrap = fixedWidth - horizontalOverhead;
+    if (contentWidthForWrap > 0) {
+      const wrappedLines = [];
+      const newBoundaries = [];
+      let boundaryIdx2 = 0;
+      let originalLineCount = 0;
+      for (const line of lines) {
+        if (getStringWidth(line) > contentWidthForWrap) {
+          const wrapped = wrapText(line, contentWidthForWrap);
+          wrappedLines.push(...wrapped.split(`
+`));
+        } else {
+          wrappedLines.push(line);
+        }
+        originalLineCount++;
+        const boundary = sectionBoundaries[boundaryIdx2];
+        if (boundary !== undefined && originalLineCount === boundary) {
+          newBoundaries.push(wrappedLines.length);
+          boundaryIdx2++;
+        }
+      }
+      lines = wrappedLines;
+      sectionBoundaries = newBoundaries;
+    }
+  }
+  let contentWidth = 0;
+  for (const line of lines) {
+    const w = getStringWidth(line);
+    if (w > contentWidth) {
+      contentWidth = w;
+    }
+  }
+  let boxWidth;
+  if (fixedWidth) {
+    boxWidth = fixedWidth;
+    contentWidth = fixedWidth - horizontalOverhead;
+  } else {
+    boxWidth = horizontalOverhead + contentWidth;
+    if (title && borders.top) {
+      const minBoxWidthForTitle = getStringWidth(title) + 4 + (borders.left ? 1 : 0) + (borders.right ? 1 : 0);
+      if (boxWidth < minBoxWidthForTitle) {
+        boxWidth = minBoxWidthForTitle;
+        contentWidth = boxWidth - horizontalOverhead;
+      }
+    }
+  }
+  const output = [];
+  const leftPaddingStr = " ".repeat(pad.left);
+  const rightPaddingStr = " ".repeat(pad.right);
+  const marginLeftStr = " ".repeat(margin.left);
+  const marginRightStr = " ".repeat(margin.right);
+  const buildContentLine = (lineContent) => {
+    const aligned = alignLine(lineContent, contentWidth, align);
+    const leftBorder = borders.left ? chars.vertical : "";
+    const rightBorder = borders.right ? chars.vertical : "";
+    return marginLeftStr + leftBorder + leftPaddingStr + aligned + rightPaddingStr + rightBorder + marginRightStr;
+  };
+  const innerWidth = boxWidth - (borders.left ? 1 : 0) - (borders.right ? 1 : 0);
+  for (let i = 0;i < margin.top; i++) {
+    output.push("");
+  }
+  if (borders.top) {
+    let topBorder;
+    if (title) {
+      const maxTitleWidth = Math.max(0, innerWidth - 4);
+      let displayTitle = title;
+      if (maxTitleWidth === 0) {
+        topBorder = marginLeftStr + (borders.left ? chars.topLeft : "") + chars.horizontal.repeat(Math.max(0, innerWidth)) + (borders.right ? chars.topRight : "") + marginRightStr;
+      } else {
+        if (getStringWidth(title) > maxTitleWidth) {
+          displayTitle = truncateText(title, maxTitleWidth);
+        }
+        const titlePart = `${chars.horizontal} ${displayTitle} `;
+        const remainingWidth = Math.max(0, innerWidth - getStringWidth(titlePart));
+        topBorder = marginLeftStr + (borders.left ? chars.topLeft : "") + titlePart + chars.horizontal.repeat(remainingWidth) + (borders.right ? chars.topRight : "") + marginRightStr;
+      }
+    } else {
+      topBorder = marginLeftStr + (borders.left ? chars.topLeft : "") + chars.horizontal.repeat(innerWidth) + (borders.right ? chars.topRight : "") + marginRightStr;
+    }
+    output.push(topBorder);
+  }
+  for (let i = 0;i < pad.top; i++) {
+    output.push(buildContentLine(""));
+  }
+  let boundaryIdx = 0;
+  for (const [idx, line] of lines.entries()) {
+    output.push(buildContentLine(line));
+    const boundary = sectionBoundaries[boundaryIdx];
+    if (boundary !== undefined && idx + 1 === boundary) {
+      const divider = marginLeftStr + (borders.left ? chars.leftT : "") + chars.horizontal.repeat(innerWidth) + (borders.right ? chars.rightT : "") + marginRightStr;
+      output.push(divider);
+      boundaryIdx++;
+    }
+  }
+  for (let i = 0;i < pad.bottom; i++) {
+    output.push(buildContentLine(""));
+  }
+  if (borders.bottom) {
+    const bottomBorder = marginLeftStr + (borders.left ? chars.bottomLeft : "") + chars.horizontal.repeat(innerWidth) + (borders.right ? chars.bottomRight : "") + marginRightStr;
+    output.push(bottomBorder);
+  }
+  for (let i = 0;i < margin.bottom; i++) {
+    output.push("");
+  }
+  return output.join(`
+`);
+}
+function isBox(value) {
+  return typeof value === "object" && value !== null && "output" in value && "width" in value && "height" in value && typeof value.output === "string" && typeof value.width === "number" && typeof value.height === "number";
+}
+function contentToLines(content) {
+  if (Array.isArray(content)) {
+    const lines = [];
+    for (const item of content) {
+      if (isBox(item)) {
+        lines.push(...item.output.split(`
+`));
+      } else if (Array.isArray(item)) {
+        lines.push(...item);
+      } else {
+        lines.push(...item.split(`
+`));
+      }
+    }
+    return lines;
+  }
+  if (isBox(content)) {
+    return content.output.split(`
+`);
+  }
+  if (typeof content === "string") {
+    return content.split(`
+`);
+  }
+  return content;
+}
+function createBox(content, options) {
+  const lines = contentToLines(content);
+  const output = renderBox(lines, options);
+  const outputLines = output.split(`
+`);
+  let maxWidth = 0;
+  for (const line of outputLines) {
+    const lineWidth = getStringWidth(line);
+    if (lineWidth > maxWidth) {
+      maxWidth = lineWidth;
+    }
+  }
+  return {
+    output,
+    width: maxWidth,
+    height: outputLines.length
+  };
+}
+var init_box = __esm(() => {
+  init_borders();
+  init_text();
+});
+
+export { normalizePadding, normalizeMargin, normalizeBorders, renderBox, createBox, exports_box, init_box };

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

@@ -0,0 +1,74 @@
+/**
+* Validator factories for prompt input validation.
+*
+* @packageDocumentation
+*/
+/**
+* A validator function that returns an error message or undefined.
+*/
+type Validator = (value: string) => string | undefined;
+/**
+* Collection of validator factory functions.
+*
+* @example
+* ```typescript
+* import { validators } from "@outfitter/cli/prompt";
+*
+* const validate = validators.compose(
+*   validators.required(),
+*   validators.minLength(3),
+*   validators.email()
+* );
+*
+* const error = validate("ab");
+* // "Minimum 3 characters"
+* ```
+*/
+declare const validators: {
+	/**
+	* Requires a non-empty value.
+	*
+	* @param message - Custom error message
+	* @returns Validator function
+	*/
+	required: (message?: string) => Validator;
+	/**
+	* Requires minimum character length.
+	*
+	* @param length - Minimum length
+	* @param message - Custom error message
+	* @returns Validator function
+	*/
+	minLength: (length: number, message?: string) => Validator;
+	/**
+	* Requires maximum character length.
+	*
+	* @param length - Maximum length
+	* @param message - Custom error message
+	* @returns Validator function
+	*/
+	maxLength: (length: number, message?: string) => Validator;
+	/**
+	* Requires value to match a regex pattern.
+	*
+	* @param regex - Pattern to match
+	* @param message - Error message when pattern doesn't match
+	* @returns Validator function
+	*/
+	pattern: (regex: RegExp, message: string) => Validator;
+	/**
+	* Validates email format.
+	*
+	* @param message - Custom error message
+	* @returns Validator function
+	*/
+	email: (message?: string) => Validator;
+	/**
+	* Composes multiple validators, returning the first error.
+	*
+	* @param fns - Validators to compose
+	* @returns Combined validator function
+	*/
+	compose: (...fns: Validator[]) => Validator;
+};
+export { Validator, validators };