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

package/dist/shared/@outfitter/cli-85fg2vr5.js

@@ -0,0 +1,123 @@
+// @bun
+import {
+  __esm
+} from "./cli-v1tzwxkt.js";
+
+// packages/cli/src/render/borders.ts
+function getBorderCharacters(style) {
+  return BORDERS[style];
+}
+function drawHorizontalLine(width, chars, position, columnWidths) {
+  if (!chars.horizontal) {
+    return "";
+  }
+  const positionChars = {
+    top: { left: chars.topLeft, right: chars.topRight, cross: chars.topT },
+    middle: { left: chars.leftT, right: chars.rightT, cross: chars.cross },
+    bottom: {
+      left: chars.bottomLeft,
+      right: chars.bottomRight,
+      cross: chars.bottomT
+    }
+  };
+  const { left, right, cross: intersection } = positionChars[position];
+  if (!columnWidths || columnWidths.length <= 1) {
+    return `${left}${chars.horizontal.repeat(width)}${right}`;
+  }
+  const columnsWidth = columnWidths.reduce((sum, w) => sum + w, 0);
+  const intersectionsWidth = columnWidths.length - 1;
+  const actualWidth = columnsWidth + intersectionsWidth;
+  const adjustedWidths = [...columnWidths];
+  if (actualWidth !== width && adjustedWidths.length > 0) {
+    const lastIndex = adjustedWidths.length - 1;
+    const lastWidth = adjustedWidths[lastIndex] ?? 0;
+    adjustedWidths[lastIndex] = Math.max(0, lastWidth + (width - actualWidth));
+  }
+  const segments = adjustedWidths.map((colWidth) => chars.horizontal.repeat(colWidth));
+  return `${left}${segments.join(intersection)}${right}`;
+}
+var BORDERS;
+var init_borders = __esm(() => {
+  BORDERS = {
+    single: {
+      topLeft: "\u250C",
+      topRight: "\u2510",
+      bottomLeft: "\u2514",
+      bottomRight: "\u2518",
+      horizontal: "\u2500",
+      vertical: "\u2502",
+      topT: "\u252C",
+      bottomT: "\u2534",
+      leftT: "\u251C",
+      rightT: "\u2524",
+      cross: "\u253C"
+    },
+    double: {
+      topLeft: "\u2554",
+      topRight: "\u2557",
+      bottomLeft: "\u255A",
+      bottomRight: "\u255D",
+      horizontal: "\u2550",
+      vertical: "\u2551",
+      topT: "\u2566",
+      bottomT: "\u2569",
+      leftT: "\u2560",
+      rightT: "\u2563",
+      cross: "\u256C"
+    },
+    rounded: {
+      topLeft: "\u256D",
+      topRight: "\u256E",
+      bottomLeft: "\u2570",
+      bottomRight: "\u256F",
+      horizontal: "\u2500",
+      vertical: "\u2502",
+      topT: "\u252C",
+      bottomT: "\u2534",
+      leftT: "\u251C",
+      rightT: "\u2524",
+      cross: "\u253C"
+    },
+    heavy: {
+      topLeft: "\u250F",
+      topRight: "\u2513",
+      bottomLeft: "\u2517",
+      bottomRight: "\u251B",
+      horizontal: "\u2501",
+      vertical: "\u2503",
+      topT: "\u2533",
+      bottomT: "\u253B",
+      leftT: "\u2523",
+      rightT: "\u252B",
+      cross: "\u254B"
+    },
+    ascii: {
+      topLeft: "+",
+      topRight: "+",
+      bottomLeft: "+",
+      bottomRight: "+",
+      horizontal: "-",
+      vertical: "|",
+      topT: "+",
+      bottomT: "+",
+      leftT: "+",
+      rightT: "+",
+      cross: "+"
+    },
+    none: {
+      topLeft: "",
+      topRight: "",
+      bottomLeft: "",
+      bottomRight: "",
+      horizontal: "",
+      vertical: "",
+      topT: "",
+      bottomT: "",
+      leftT: "",
+      rightT: "",
+      cross: ""
+    }
+  };
+});
+
+export { BORDERS, getBorderCharacters, drawHorizontalLine, init_borders };

package/dist/shared/@outfitter/cli-8a8xrzhy.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/bold.ts
+init_borders();
+var boldTheme = {
+  ...defaultTheme,
+  name: "bold",
+  border: "heavy",
+  borderChars: BORDERS.heavy,
+  treeGuide: "heavy"
+};
+
+export { boldTheme };

package/dist/shared/@outfitter/cli-8aa1vhdn.d.ts

@@ -0,0 +1,119 @@
+/**
+* Options for terminal detection functions.
+*
+* These options allow overriding automatic detection for testing
+* or specific environments.
+*
+* @example
+* ```typescript
+* // Force TTY mode for testing
+* supportsColor({ isTTY: true });
+*
+* // Simulate CI environment
+* isInteractive({ isTTY: true, isCI: true }); // returns false
+* ```
+*/
+interface TerminalOptions {
+	/** Override TTY detection (uses process.stdout.isTTY if not specified) */
+	isTTY?: boolean;
+	/** Override CI detection (uses CI env variable if not specified) */
+	isCI?: boolean;
+}
+/**
+* Gets the value of an environment variable.
+*
+* @param key - Environment variable name
+* @returns The value if set, undefined otherwise
+*/
+declare function getEnvValue(key: "NO_COLOR" | "FORCE_COLOR"): string | undefined;
+/**
+* Checks if NO_COLOR environment variable is set.
+*
+* @returns `true` if NO_COLOR is set (even if empty)
+*/
+declare function hasNoColorEnv(): boolean;
+/**
+* Resolves the FORCE_COLOR environment variable.
+*
+* @returns `true` if colors should be forced, `false` if explicitly disabled, `undefined` if not set
+*/
+declare function resolveForceColorEnv(): boolean | undefined;
+/**
+* Resolves color environment variables with configurable priority.
+*
+* @param options - Options for resolution priority
+* @returns `true` if colors enabled, `false` if disabled, `undefined` if not determined by env
+*/
+declare function resolveColorEnv(options?: {
+	forceColorFirst?: boolean;
+}): boolean | undefined;
+/**
+* Checks if the current environment supports ANSI colors.
+*
+* Detection priority:
+* 1. `NO_COLOR` env variable - if set (even empty), returns false (per no-color.org)
+* 2. `FORCE_COLOR` env variable - if set, returns true (numeric levels > 0)
+* 3. Falls back to TTY detection via `process.stdout.isTTY`
+*
+* @param options - Optional overrides for TTY detection
+* @returns `true` if colors are supported, `false` otherwise
+*
+* @example
+* ```typescript
+* if (supportsColor()) {
+*   console.log("\x1b[32mGreen text\x1b[0m");
+* } else {
+*   console.log("Plain text");
+* }
+*
+* // With explicit TTY override for testing
+* supportsColor({ isTTY: true });  // true (unless NO_COLOR is set)
+* supportsColor({ isTTY: false }); // false (unless FORCE_COLOR is set)
+* ```
+*/
+declare function supportsColor(options?: TerminalOptions): boolean;
+/**
+* Gets the terminal width in columns.
+*
+* Returns `process.stdout.columns` when in a TTY, or 80 as a fallback
+* for non-TTY environments (pipes, CI, etc.).
+*
+* @param options - Optional overrides for TTY detection
+* @returns Terminal width in columns (default: 80 if not TTY)
+*
+* @example
+* ```typescript
+* const width = getTerminalWidth();
+* console.log(`Terminal is ${width} columns wide`);
+*
+* // Force non-TTY mode (always returns 80)
+* getTerminalWidth({ isTTY: false }); // 80
+* ```
+*/
+declare function getTerminalWidth(options?: TerminalOptions): number;
+/**
+* Checks if the terminal is interactive.
+*
+* A terminal is considered interactive when:
+* - It is a TTY (process.stdout.isTTY is true)
+* - It is NOT running in a CI environment (CI env variable is not set)
+*
+* Use this to decide whether to show interactive prompts or use
+* non-interactive fallbacks.
+*
+* @param options - Optional overrides for TTY and CI detection
+* @returns `true` if interactive prompts are safe to use
+*
+* @example
+* ```typescript
+* if (isInteractive()) {
+*   // Safe to use interactive prompts
+*   const answer = await prompt("Continue?");
+* } else {
+*   // Use non-interactive defaults
+*   console.log("Running in non-interactive mode");
+* }
+* ```
+*/
+declare function isInteractive(options?: TerminalOptions): boolean;
+export { TerminalOptions, getEnvValue, hasNoColorEnv, resolveForceColorEnv, resolveColorEnv, supportsColor, getTerminalWidth, isInteractive };

package/dist/shared/@outfitter/cli-8bwaw3pz.js

@@ -0,0 +1,7 @@
+// @bun
+// packages/cli/src/prompt/types.ts
+function createCancelledError(message = "User cancelled") {
+  return { type: "cancelled", message };
+}
+
+export { createCancelledError };

package/dist/shared/@outfitter/cli-8j5k6mr3.js

@@ -0,0 +1,71 @@
+// @bun
+// packages/cli/src/render/format-relative.ts
+function formatRelative(date) {
+  let timestamp;
+  if (date instanceof Date) {
+    timestamp = date.getTime();
+  } else if (typeof date === "number") {
+    timestamp = date;
+  } else {
+    const parsed = Date.parse(date);
+    if (Number.isNaN(parsed)) {
+      return "invalid date";
+    }
+    timestamp = parsed;
+  }
+  if (!Number.isFinite(timestamp)) {
+    return "invalid date";
+  }
+  const now = Date.now();
+  const diffMs = now - timestamp;
+  const absDiffMs = Math.abs(diffMs);
+  const isFuture = diffMs < 0;
+  const SECOND = 1000;
+  const MINUTE = 60 * SECOND;
+  const HOUR = 60 * MINUTE;
+  const DAY = 24 * HOUR;
+  const MONTH = 30 * DAY;
+  const YEAR = 365 * DAY;
+  if (absDiffMs < 10 * SECOND) {
+    return "just now";
+  }
+  if (absDiffMs < MINUTE) {
+    const seconds = Math.floor(absDiffMs / SECOND);
+    return isFuture ? `in ${seconds} seconds` : `${seconds} seconds ago`;
+  }
+  if (absDiffMs < HOUR) {
+    const minutes = Math.floor(absDiffMs / MINUTE);
+    if (minutes === 1) {
+      return isFuture ? "in 1 minute" : "1 minute ago";
+    }
+    return isFuture ? `in ${minutes} minutes` : `${minutes} minutes ago`;
+  }
+  if (absDiffMs < DAY) {
+    const hours = Math.floor(absDiffMs / HOUR);
+    if (hours === 1) {
+      return isFuture ? "in 1 hour" : "1 hour ago";
+    }
+    return isFuture ? `in ${hours} hours` : `${hours} hours ago`;
+  }
+  if (absDiffMs < 2 * DAY) {
+    return isFuture ? "tomorrow" : "yesterday";
+  }
+  if (absDiffMs < MONTH) {
+    const days = Math.floor(absDiffMs / DAY);
+    return isFuture ? `in ${days} days` : `${days} days ago`;
+  }
+  if (absDiffMs < YEAR) {
+    const months = Math.floor(absDiffMs / MONTH);
+    if (months === 1) {
+      return isFuture ? "in 1 month" : "1 month ago";
+    }
+    return isFuture ? `in ${months} months` : `${months} months ago`;
+  }
+  const years = Math.floor(absDiffMs / YEAR);
+  if (years === 1) {
+    return isFuture ? "in 1 year" : "1 year ago";
+  }
+  return isFuture ? `in ${years} years` : `${years} years ago`;
+}
+
+export { formatRelative };

package/dist/shared/@outfitter/cli-8rx4g3s5.d.ts

@@ -0,0 +1,41 @@
+import { PasswordPromptOptions, PromptResult, TextPromptOptions } from "./cli-3f12z5kf";
+/**
+* Prompts for text input with Result wrapping.
+*
+* @param options - Text prompt options
+* @returns Ok with value or Err with CancelledError
+*
+* @example
+* ```typescript
+* import { promptText } from "@outfitter/cli/prompt";
+*
+* const result = await promptText({
+*   message: "What is your name?",
+*   placeholder: "Enter your name",
+*   validate: (v) => v.length > 0 || "Name is required",
+* });
+*
+* if (result.isOk()) {
+*   console.log(`Hello, ${result.value}!`);
+* }
+* ```
+*/
+declare function promptText(options: TextPromptOptions): PromptResult<string>;
+/**
+* Prompts for password input with Result wrapping.
+*
+* @param options - Password prompt options
+* @returns Ok with value or Err with CancelledError
+*
+* @example
+* ```typescript
+* import { promptPassword } from "@outfitter/cli/prompt";
+*
+* const result = await promptPassword({
+*   message: "Enter your password:",
+*   validate: (v) => v.length >= 8 || "Password too short",
+* });
+* ```
+*/
+declare function promptPassword(options: PasswordPromptOptions): PromptResult<string>;
+export { promptText, promptPassword };

package/dist/shared/@outfitter/cli-8xsmsbbd.d.ts

@@ -0,0 +1,223 @@
+import { BorderStyle } from "./cli-fakncnjp";
+/**
+* Text alignment options for box content.
+*/
+type BoxAlign = "left" | "center" | "right";
+/**
+* Options for customizing box rendering.
+*
+* @example
+* ```typescript
+* // Box with title and rounded corners
+* renderBox("Content", {
+*   title: "Status",
+*   border: "rounded",
+*   padding: 1,
+* });
+*
+* // Fixed-width centered box
+* renderBox("Centered", {
+*   width: 40,
+*   align: "center",
+* });
+* ```
+*/
+/**
+* Spacing configuration for individual sides.
+*/
+interface BoxSpacing {
+	top?: number;
+	right?: number;
+	bottom?: number;
+	left?: number;
+}
+/**
+* Border visibility configuration for individual sides.
+*/
+interface BoxBorders {
+	top?: boolean;
+	right?: boolean;
+	bottom?: boolean;
+	left?: boolean;
+}
+interface BoxOptions {
+	/**
+	* Border style to use.
+	* @default "single"
+	*/
+	border?: BorderStyle;
+	/**
+	* Control which borders to render.
+	* @default { top: true, right: true, bottom: true, left: true }
+	*/
+	borders?: BoxBorders;
+	/**
+	* Internal padding (spaces between border and content).
+	* Can be a single number for all sides or an object for individual sides.
+	* @default 1
+	*/
+	padding?: number | BoxSpacing;
+	/**
+	* External margin (spacing outside the box).
+	* Can be a single number for all sides or an object for individual sides.
+	*/
+	margin?: number | BoxSpacing;
+	/**
+	* Fixed width for the box. If not specified, auto-fits to content.
+	*/
+	width?: number;
+	/**
+	* Optional title to display in the top border.
+	*/
+	title?: string;
+	/**
+	* Content alignment within the box.
+	* @default "left"
+	*/
+	align?: BoxAlign;
+	/**
+	* Content sections separated by internal dividers.
+	* Each section can be a string or string[].
+	* When provided, takes precedence over the content parameter.
+	*
+	* @example
+	* ```typescript
+	* renderBox("", {
+	*   sections: [
+	*     "Header",
+	*     ["Line 1", "Line 2"],
+	*     "Footer"
+	*   ],
+	*   border: "single"
+	* });
+	* // ┌─────────────────┐
+	* // │ Header          │
+	* // ├─────────────────┤
+	* // │ Line 1          │
+	* // │ Line 2          │
+	* // ├─────────────────┤
+	* // │ Footer          │
+	* // └─────────────────┘
+	* ```
+	*/
+	sections?: Array<string | string[]>;
+}
+/**
+* A rendered box with metadata for composition.
+*/
+interface Box {
+	/** Rendered string representation */
+	readonly output: string;
+	/** Width in characters */
+	readonly width: number;
+	/** Height in lines */
+	readonly height: number;
+}
+/**
+* Content that can be rendered inside a box.
+* - string: Plain text content
+* - string[]: Multi-line content
+* - Box: Nested box (rendered string with metadata)
+*/
+type BoxContent = string | string[] | Box;
+/**
+* Normalized spacing with all four sides defined.
+*/
+interface NormalizedSpacing {
+	top: number;
+	right: number;
+	bottom: number;
+	left: number;
+}
+/**
+* Normalized borders with all four sides defined.
+*/
+interface NormalizedBorders {
+	top: boolean;
+	right: boolean;
+	bottom: boolean;
+	left: boolean;
+}
+/**
+* Normalizes padding input to have all four sides.
+* For backward compatibility, when padding is a number it only applies to horizontal (left/right).
+* When padding is an object, all sides can be specified.
+*/
+declare function normalizePadding(padding: number | BoxSpacing | undefined, defaultValue: number): NormalizedSpacing;
+/**
+* Normalizes margin input to have all four sides.
+* When margin is a number, it applies to all sides.
+*/
+declare function normalizeMargin(margin: number | BoxSpacing | undefined, defaultValue: number): NormalizedSpacing;
+/**
+* Normalizes borders input to have all four sides.
+*/
+declare function normalizeBorders(borders: BoxBorders | undefined): NormalizedBorders;
+/**
+* Renders content within a bordered panel.
+*
+* Creates a box with Unicode borders around the content. Supports multiple
+* border styles, titles, padding, and alignment options.
+*
+* @param content - The content to render (string or array of strings)
+* @param options - Optional configuration for border style, padding, etc.
+* @returns Formatted box string
+*
+* @example
+* ```typescript
+* // Simple box
+* console.log(renderBox("Hello, world!"));
+* // ┌───────────────┐
+* // │ Hello, world! │
+* // └───────────────┘
+*
+* // Box with title
+* console.log(renderBox("All systems go", { title: "Status" }));
+* // ┌─ Status ──────┐
+* // │ All systems go │
+* // └────────────────┘
+*
+* // Rounded box with padding
+* console.log(renderBox(["Line 1", "Line 2"], {
+*   border: "rounded",
+*   padding: 2,
+* }));
+* // ╭──────────────╮
+* // │              │
+* // │  Line 1      │
+* // │  Line 2      │
+* // │              │
+* // ╰──────────────╯
+* ```
+*/
+declare function renderBox(content: string | string[], options?: BoxOptions): string;
+/**
+* Creates a Box object that can be composed with other boxes.
+*
+* Unlike `renderBox` which returns a string, `createBox` returns a Box object
+* with metadata (width, height) that enables nested composition.
+*
+* @param content - The content to render (string, string[], Box, or array of mixed)
+* @param options - Optional configuration for border style, padding, etc.
+* @returns Box object with output, width, and height
+*
+* @example
+* ```typescript
+* // Simple box
+* const box = createBox("Hello");
+* console.log(box.output);
+* console.log(`Width: ${box.width}, Height: ${box.height}`);
+*
+* // Nested boxes
+* const inner = createBox("Inner", { border: "rounded" });
+* const outer = createBox(inner, { border: "double", title: "Container" });
+* console.log(outer.output);
+* // ╔═ Container ═══════════════╗
+* // ║ ╭───────────────────────╮ ║
+* // ║ │ Inner                 │ ║
+* // ║ ╰───────────────────────╯ ║
+* // ╚═══════════════════════════╝
+* ```
+*/
+declare function createBox(content: BoxContent | BoxContent[], options?: BoxOptions): Box;
+export { BoxAlign, BoxSpacing, BoxBorders, BoxOptions, Box, BoxContent, NormalizedSpacing, NormalizedBorders, normalizePadding, normalizeMargin, normalizeBorders, renderBox, createBox };

package/dist/shared/@outfitter/cli-96b2p4td.d.ts

@@ -0,0 +1,56 @@
+import { SpinnerStyle } from "./cli-e5ms1y0x";
+import { ListStyle } from "./cli-b0tzqgnf";
+import { BorderStyle } from "./cli-fakncnjp";
+import { PrimitiveId, PrimitiveMeta, ThemeMethodMeta, VariantMeta } from "./cli-qjfc3j11";
+import { Theme } from "./cli-xsaheemc";
+/**
+* Type-safe metadata for all theme methods.
+*
+* Uses `keyof Theme` to ensure every theme method has metadata.
+* Adding a new method to Theme without updating this causes a compile error.
+*/
+declare const THEME_METHOD_META: Record<keyof Theme, ThemeMethodMeta>;
+/**
+* Gets theme methods grouped by category.
+*/
+declare function getThemeMethodsByCategory(): {
+	semantic: Array<keyof Theme>;
+	utility: Array<keyof Theme>;
+};
+/**
+* Type-safe metadata for all border styles.
+*/
+declare const BORDER_STYLE_META: Record<BorderStyle, VariantMeta<BorderStyle>>;
+/**
+* Gets all border styles as an array.
+*/
+declare function getBorderStyles(): BorderStyle[];
+/**
+* Type-safe metadata for all spinner styles.
+*/
+declare const SPINNER_STYLE_META: Record<SpinnerStyle, VariantMeta<SpinnerStyle>>;
+/**
+* Gets all spinner styles as an array.
+*/
+declare function getSpinnerStyles(): SpinnerStyle[];
+/**
+* Type-safe metadata for all list styles.
+*/
+declare const LIST_STYLE_META: Record<ListStyle, VariantMeta<ListStyle>>;
+/**
+* Gets all list styles as an array.
+*/
+declare function getListStyles(): ListStyle[];
+/**
+* Type-safe metadata for all primitives.
+*/
+declare const PRIMITIVE_META: Record<PrimitiveId, PrimitiveMeta>;
+/**
+* Gets all primitive IDs as an array.
+*/
+declare function getPrimitiveIds(): PrimitiveId[];
+/**
+* Gets metadata for a specific primitive.
+*/
+declare function getPrimitiveMeta(id: PrimitiveId): PrimitiveMeta;
+export { THEME_METHOD_META, getThemeMethodsByCategory, BORDER_STYLE_META, getBorderStyles, SPINNER_STYLE_META, getSpinnerStyles, LIST_STYLE_META, getListStyles, PRIMITIVE_META, getPrimitiveIds, getPrimitiveMeta };