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

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

@@ -0,0 +1,253 @@
+import { Command } from "commander";
+import { CancelledError, ErrorCategory, ValidationError } from "@outfitter/contracts";
+import { Result } from "better-result";
+/**
+* Configuration for creating a CLI instance.
+*
+* @example
+* ```typescript
+* const config: CLIConfig = {
+*   name: "waymark",
+*   version: "1.0.0",
+*   description: "A note management CLI",
+* };
+* ```
+*/
+interface CLIConfig {
+	/** CLI name (used in help output and error messages) */
+	readonly name: string;
+	/** CLI version (displayed with --version) */
+	readonly version: string;
+	/** CLI description (displayed in help output) */
+	readonly description?: string;
+	/** Custom error handler */
+	readonly onError?: (error: Error) => void;
+	/** Custom exit handler (defaults to process.exit) */
+	readonly onExit?: (code: number) => never;
+}
+/**
+* CLI instance returned by createCLI.
+*/
+interface CLI {
+	/** Register a command with the CLI */
+	register(command: CommandBuilder | Command): this;
+	/** Parse arguments and execute the matched command */
+	parse(argv?: readonly string[]): Promise<void>;
+	/** Get the underlying Commander program */
+	readonly program: Command;
+}
+/**
+* Configuration for a single command.
+*/
+interface CommandConfig {
+	/** Command name and argument syntax (e.g., "list" or "get <id>") */
+	readonly name: string;
+	/** Command description */
+	readonly description?: string;
+	/** Command aliases */
+	readonly aliases?: readonly string[];
+	/** Whether to hide from help output */
+	readonly hidden?: boolean;
+}
+/**
+* Action function executed when a command is invoked.
+*
+* @typeParam TFlags - Type of parsed command flags
+*/
+type CommandAction<TFlags extends CommandFlags = CommandFlags> = (context: {
+	/** Parsed command-line arguments */
+	readonly args: readonly string[];
+	/** Parsed command flags */
+	readonly flags: TFlags;
+	/** Raw Commander command instance */
+	readonly command: Command;
+}) => Promise<void> | void;
+/**
+* Base type for command flags.
+* All flag types must extend this.
+*/
+type CommandFlags = Record<string, unknown>;
+/**
+* Builder interface for constructing commands fluently.
+*/
+interface CommandBuilder {
+	/** Set command description */
+	description(text: string): this;
+	/** Add a command option/flag */
+	option(flags: string, description: string, defaultValue?: unknown): this;
+	/** Add a required option */
+	requiredOption(flags: string, description: string, defaultValue?: unknown): this;
+	/** Add command aliases */
+	alias(alias: string): this;
+	/** Set the action handler */
+	action<TFlags extends CommandFlags = CommandFlags>(handler: CommandAction<TFlags>): this;
+	/** Build the underlying Commander command */
+	build(): Command;
+}
+/**
+* Available output modes for CLI commands.
+*/
+type OutputMode = "human" | "json" | "jsonl" | "tree" | "table";
+/**
+* Options for the output() function.
+*/
+interface OutputOptions {
+	/** Force a specific output mode (overrides flag detection) */
+	readonly mode?: OutputMode;
+	/** Stream to write to (defaults to stdout) */
+	readonly stream?: NodeJS.WritableStream;
+	/** Whether to pretty-print JSON output */
+	readonly pretty?: boolean;
+	/** Exit code to use after output (undefined = don't exit) */
+	readonly exitCode?: number;
+}
+/**
+* Options for collectIds() input utility.
+*
+* @example
+* ```typescript
+* const ids = await collectIds(args, {
+*   allowFile: true,   // @file expansion
+*   allowStdin: true,  // - reads from stdin
+* });
+* ```
+*/
+interface CollectIdsOptions {
+	/** Allow @file expansion (reads IDs from file) */
+	readonly allowFile?: boolean;
+	/** Allow glob patterns */
+	readonly allowGlob?: boolean;
+	/** Allow reading from stdin with "-" */
+	readonly allowStdin?: boolean;
+	/** Separator for comma-separated values */
+	readonly separator?: string;
+}
+/**
+* Options for expandFileArg() input utility.
+*/
+interface ExpandFileOptions {
+	/** Encoding for file reads (defaults to utf-8) */
+	readonly encoding?: BufferEncoding;
+	/** Maximum file size to read (in bytes) */
+	readonly maxSize?: number;
+	/** Whether to trim the file content */
+	readonly trim?: boolean;
+}
+/**
+* Options for parseGlob() input utility.
+*/
+interface ParseGlobOptions {
+	/** Current working directory for glob resolution */
+	readonly cwd?: string;
+	/** Whether to follow symlinks */
+	readonly followSymlinks?: boolean;
+	/** Patterns to exclude */
+	readonly ignore?: readonly string[];
+	/** Only match files (not directories) */
+	readonly onlyFiles?: boolean;
+	/** Only match directories (not files) */
+	readonly onlyDirectories?: boolean;
+}
+/**
+* Options for normalizeId().
+*/
+interface NormalizeIdOptions {
+	/** Whether to lowercase the ID */
+	readonly lowercase?: boolean;
+	/** Whether to trim whitespace */
+	readonly trim?: boolean;
+	/** Minimum length requirement */
+	readonly minLength?: number;
+	/** Maximum length requirement */
+	readonly maxLength?: number;
+	/** Pattern the ID must match */
+	readonly pattern?: RegExp;
+}
+/**
+* Options for confirmDestructive().
+*/
+interface ConfirmDestructiveOptions {
+	/** Message to display to the user */
+	readonly message: string;
+	/** Whether to bypass confirmation (e.g., --yes flag) */
+	readonly bypassFlag?: boolean;
+	/** Number of items affected (shown in confirmation) */
+	readonly itemCount?: number;
+}
+/**
+* Numeric or date range parsed from CLI input.
+*/
+type Range = NumericRange | DateRange;
+/**
+* Numeric range (e.g., "1-10").
+*/
+interface NumericRange {
+	readonly type: "number";
+	readonly min: number;
+	readonly max: number;
+}
+/**
+* Date range (e.g., "2024-01-01..2024-12-31").
+*/
+interface DateRange {
+	readonly type: "date";
+	readonly start: Date;
+	readonly end: Date;
+}
+/**
+* Filter expression parsed from CLI input.
+*/
+interface FilterExpression {
+	readonly field: string;
+	readonly value: string;
+	readonly operator?: "eq" | "ne" | "gt" | "lt" | "gte" | "lte" | "contains";
+}
+/**
+* Sort criteria parsed from CLI input.
+*/
+interface SortCriteria {
+	readonly field: string;
+	readonly direction: "asc" | "desc";
+}
+/**
+* Key-value pair parsed from CLI input.
+*/
+interface KeyValuePair {
+	readonly key: string;
+	readonly value: string;
+}
+/**
+* State for paginated command results.
+*/
+interface PaginationState {
+	/** Cursor for the next page */
+	readonly cursor: string;
+	/** Command that generated this state */
+	readonly command: string;
+	/** Context key for scoping pagination */
+	readonly context?: string;
+	/** Timestamp when state was created */
+	readonly timestamp: number;
+	/** Whether there are more results */
+	readonly hasMore: boolean;
+	/** Total count (if known) */
+	readonly total?: number;
+}
+/**
+* Options for cursor persistence operations.
+*/
+interface CursorOptions {
+	/** Command name for cursor scoping */
+	readonly command: string;
+	/** Context key for additional scoping */
+	readonly context?: string;
+	/** Tool name for XDG path resolution */
+	readonly toolName: string;
+	/** Maximum age in milliseconds before a cursor is treated as expired */
+	readonly maxAgeMs?: number;
+	/** Whether there are more results (defaults to true) */
+	readonly hasMore?: boolean;
+	/** Total count of results (if known) */
+	readonly total?: number;
+}
+export { CLIConfig, CLI, CommandConfig, CommandAction, CommandFlags, CommandBuilder, OutputMode, OutputOptions, CollectIdsOptions, ExpandFileOptions, ParseGlobOptions, NormalizeIdOptions, ConfirmDestructiveOptions, Range, NumericRange, DateRange, FilterExpression, SortCriteria, KeyValuePair, PaginationState, CursorOptions, CancelledError, ErrorCategory, ValidationError, Result };

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 };