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

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

@@ -0,0 +1,122 @@
+// @bun
+import {
+  TREE_GUIDES,
+  renderTree
+} from "./cli-b5c2k0d7.js";
+import {
+  getExample
+} from "./cli-xep6v2c0.js";
+import {
+  demoSection
+} from "./cli-34fqr7bp.js";
+
+// packages/cli/src/demo/renderers/tree.ts
+function renderTreeDemo(config, _theme) {
+  const showCode = config.showCode ?? true;
+  const lines = [];
+  lines.push(demoSection("Basic Tree"));
+  lines.push("");
+  if (showCode) {
+    lines.push('import { renderTree } from "@outfitter/cli/tree";');
+    lines.push("");
+  }
+  const treeData = getExample("treeData", config.examples);
+  if (showCode) {
+    lines.push("renderTree({");
+    lines.push("  src: {");
+    lines.push("    components: { Button: null, Input: null },");
+    lines.push("    utils: null,");
+    lines.push("  },");
+    lines.push("  tests: null,");
+    lines.push("})");
+    lines.push("");
+  }
+  lines.push(renderTree(treeData));
+  lines.push("");
+  lines.push(demoSection("Guide Styles"));
+  lines.push("");
+  const guideDemo = {
+    root: {
+      child1: {
+        leaf: null
+      },
+      child2: null
+    }
+  };
+  const guideStyles = [
+    "single",
+    "rounded",
+    "heavy",
+    "double"
+  ];
+  for (const style of guideStyles) {
+    const guide = TREE_GUIDES[style];
+    lines.push(`${style.toUpperCase()} (fork: "${guide.fork.trim()}", end: "${guide.end.trim()}")`);
+    lines.push("");
+    lines.push(renderTree(guideDemo, { guide: style }));
+    lines.push("");
+  }
+  lines.push(demoSection("Max Depth"));
+  lines.push("");
+  const deepTree = {
+    level1: {
+      level2: {
+        level3: {
+          level4: null
+        }
+      }
+    }
+  };
+  if (showCode) {
+    lines.push("renderTree(tree, { maxDepth: 2 })");
+    lines.push("");
+  }
+  lines.push("Full tree:");
+  lines.push(renderTree(deepTree));
+  lines.push("");
+  lines.push("With maxDepth: 2:");
+  lines.push(renderTree(deepTree, { maxDepth: 2 }));
+  lines.push("");
+  lines.push(demoSection("Custom Labels"));
+  lines.push("");
+  const fileTree = {
+    src: {
+      "index.ts": null,
+      components: {
+        "Button.tsx": null
+      }
+    },
+    "package.json": null
+  };
+  if (showCode) {
+    lines.push("renderTree(tree, {");
+    lines.push("  renderLabel: (key, value) => {");
+    lines.push("    if (value && typeof value === 'object') {");
+    lines.push("      return `\uD83D\uDCC1 ${key}/`;");
+    lines.push("    }");
+    lines.push("    return `\uD83D\uDCC4 ${key}`;");
+    lines.push("  }");
+    lines.push("})");
+    lines.push("");
+  }
+  lines.push(renderTree(fileTree, {
+    renderLabel: (key, value) => {
+      if (value && typeof value === "object") {
+        return `\uD83D\uDCC1 ${key}/`;
+      }
+      return `\uD83D\uDCC4 ${key}`;
+    }
+  }));
+  lines.push("");
+  lines.push(demoSection("Usage Notes"));
+  lines.push("");
+  lines.push("\u2022 Objects become branches with children");
+  lines.push("\u2022 null values become leaf nodes (terminal)");
+  lines.push("\u2022 Use guide option to change visual style");
+  lines.push("\u2022 Use maxDepth to limit rendering depth");
+  lines.push("\u2022 Use renderLabel for custom node formatting");
+  return lines.join(`
+`);
+}
+
+export { renderTreeDemo };

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

@@ -0,0 +1,132 @@
+/**
+* List rendering utilities.
+*
+* Renders arrays as bullet lists with optional nesting and multiple styles.
+*
+* @packageDocumentation
+*/
+/**
+* Available list styles for {@link renderList}.
+*
+* - `dash`: Uses - character (default)
+* - `bullet`: Uses • character
+* - `number`: Uses 1. for top-level, a. for nested, i. for deeply nested
+* - `checkbox`: Uses ☐ for unchecked, ☑ for checked
+*/
+type ListStyle = "dash" | "bullet" | "number" | "checkbox";
+/**
+* Options for customizing list rendering.
+*
+* @example
+* ```typescript
+* // Numbered list with custom indent
+* renderList(items, { style: "number", indent: 4 });
+*
+* // Checkbox list with some items checked
+* renderList(items, { style: "checkbox", checked: new Set([1, 3]) });
+* ```
+*/
+interface ListOptions {
+	/**
+	* The list style to use.
+	* @default "dash"
+	*/
+	style?: ListStyle;
+	/**
+	* Indices of checked top-level items (0-indexed) for checkbox style.
+	* Only applies to top-level items. For nested items, use the
+	* `checked` property on {@link NestedListItem} instead.
+	*/
+	checked?: Set<number>;
+	/**
+	* Number of spaces per indentation level.
+	* @default 2
+	*/
+	indent?: number;
+}
+/**
+* A list item with optional nested children for {@link renderList}.
+*
+* @example
+* ```typescript
+* const item: NestedListItem = {
+*   text: "Parent item",
+*   children: ["Child 1", "Child 2"],
+* };
+*
+* // Checkbox item with checked state
+* const checkboxItem: NestedListItem = {
+*   text: "Completed task",
+*   checked: true,
+* };
+*
+* // Mixed styles: numbered parent with bullet children
+* const mixedItem: NestedListItem = {
+*   text: "Section 1",
+*   childStyle: "bullet",
+*   children: ["Unordered item A", "Unordered item B"],
+* };
+* ```
+*/
+interface NestedListItem {
+	/** The text content of this list item */
+	text: string;
+	/** Optional nested child items (strings or nested items) */
+	children?: Array<string | NestedListItem>;
+	/** Whether this item is checked (for checkbox style) */
+	checked?: boolean;
+	/** Override style for children (enables mixed numbered/bullet lists) */
+	childStyle?: ListStyle;
+}
+/**
+* A list item that can be either a simple string or a nested item with children.
+*
+* @example
+* ```typescript
+* const items: ListItem[] = [
+*   "Simple item",
+*   { text: "Parent", children: ["Child 1", "Child 2"] },
+* ];
+* ```
+*/
+type ListItem = string | NestedListItem;
+/**
+* Renders items as a list with optional nesting and multiple styles.
+*
+* Supports both simple string items and nested items with children.
+* The default style uses dash (-) characters.
+*
+* For numbered lists, child items are indented to align with the parent's
+* content (after the marker), creating proper visual hierarchy.
+*
+* @param items - Array of list items (strings or nested items)
+* @param options - Optional configuration for style, checked items, and indent
+* @returns Formatted list string
+*
+* @example
+* ```typescript
+* // Simple dash list (default)
+* console.log(renderList(["First", "Second", "Third"]));
+* // - First
+* // - Second
+* // - Third
+*
+* // Numbered list with nesting
+* console.log(renderList([
+*   { text: "First section", children: [
+*     { text: "Subsection A", children: ["Detail i", "Detail ii"] },
+*   ]},
+* ], { style: "number" }));
+* // 1. First section
+* //    a. Subsection A
+* //       i. Detail i
+* //       ii. Detail ii
+*
+* // Checkbox list
+* console.log(renderList(["Todo 1", "Todo 2"], { style: "checkbox", checked: new Set([1]) }));
+* // ☐ Todo 1
+* // ☑ Todo 2
+* ```
+*/
+declare function renderList(items: ListItem[], options?: ListOptions): string;
+export { ListStyle, ListOptions, NestedListItem, ListItem, renderList };

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

@@ -0,0 +1,39 @@
+// @bun
+// packages/cli/src/render/tree.ts
+var TREE_GUIDES = {
+  single: { vertical: "\u2502   ", fork: "\u251C\u2500\u2500 ", end: "\u2514\u2500\u2500 " },
+  heavy: { vertical: "\u2503   ", fork: "\u2523\u2501\u2501 ", end: "\u2517\u2501\u2501 " },
+  double: { vertical: "\u2551   ", fork: "\u2560\u2550\u2550 ", end: "\u255A\u2550\u2550 " },
+  rounded: { vertical: "\u2502   ", fork: "\u251C\u2500\u2500 ", end: "\u2570\u2500\u2500 " }
+};
+function renderTree(tree, options) {
+  const guide = TREE_GUIDES[options?.guide ?? "single"];
+  const maxDepth = options?.maxDepth;
+  const renderLabel = options?.renderLabel ?? ((key) => key);
+  const lines = [];
+  const renderNode = (key, value, prefix, isLast, depth) => {
+    if (maxDepth !== undefined && depth >= maxDepth) {
+      return;
+    }
+    const connector = isLast ? guide.end : guide.fork;
+    const label = renderLabel(key, value, depth);
+    lines.push(prefix + connector + label);
+    if (value !== null && typeof value === "object") {
+      const entries2 = Object.entries(value);
+      const childPrefix = prefix + (isLast ? "    " : guide.vertical);
+      entries2.forEach(([childKey, childValue], index) => {
+        const childIsLast = index === entries2.length - 1;
+        renderNode(childKey, childValue, childPrefix, childIsLast, depth + 1);
+      });
+    }
+  };
+  const entries = Object.entries(tree);
+  entries.forEach(([key, value], index) => {
+    const isLast = index === entries.length - 1;
+    renderNode(key, value, "", isLast, 0);
+  });
+  return lines.join(`
+`);
+}
+
+export { TREE_GUIDES, renderTree };

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

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

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

@@ -0,0 +1,19 @@
+// @bun
+// packages/cli/src/render/progress.ts
+function renderProgress(options) {
+  const { current, total, width = 20, showPercent = false } = options;
+  if (total <= 0) {
+    const bar2 = "\u2591".repeat(width);
+    return showPercent ? `[${bar2}] 0%` : `[${bar2}]`;
+  }
+  const percent = Math.min(100, Math.max(0, current / total * 100));
+  const filled = Math.round(percent / 100 * width);
+  const empty = width - filled;
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+  if (showPercent) {
+    return `[${bar}] ${Math.round(percent)}%`;
+  }
+  return `[${bar}]`;
+}
+
+export { renderProgress };

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

@@ -0,0 +1,23 @@
+// @bun
+import {
+  createCancelledError
+} from "./cli-8bwaw3pz.js";
+
+// packages/cli/src/prompt/confirm.ts
+import { confirm, isCancel } from "@clack/prompts";
+import { Result } from "better-result";
+async function promptConfirm(options) {
+  const confirmOptions = {
+    message: options.message
+  };
+  if (options.initialValue !== undefined) {
+    confirmOptions.initialValue = options.initialValue;
+  }
+  const result = await confirm(confirmOptions);
+  if (isCancel(result)) {
+    return Result.err(createCancelledError());
+  }
+  return Result.ok(result);
+}
+
+export { promptConfirm };

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

@@ -0,0 +1,61 @@
+// @bun
+import {
+  createCancelledError
+} from "./cli-8bwaw3pz.js";
+
+// packages/cli/src/prompt/select.ts
+import { isCancel, multiselect, select } from "@clack/prompts";
+import { Result } from "better-result";
+async function promptSelect(options) {
+  const clackOptions = options.options.map((opt) => {
+    const mapped = {
+      value: opt.value,
+      label: opt.label
+    };
+    if (opt.hint !== undefined) {
+      mapped.hint = opt.hint;
+    }
+    return mapped;
+  });
+  const selectOptions = {
+    message: options.message,
+    options: clackOptions
+  };
+  if (options.initialValue !== undefined) {
+    selectOptions.initialValue = options.initialValue;
+  }
+  const result = await select(selectOptions);
+  if (isCancel(result)) {
+    return Result.err(createCancelledError());
+  }
+  return Result.ok(result);
+}
+async function promptMultiSelect(options) {
+  const clackOptions = options.options.map((opt) => {
+    const mapped = {
+      value: opt.value,
+      label: opt.label
+    };
+    if (opt.hint !== undefined) {
+      mapped.hint = opt.hint;
+    }
+    return mapped;
+  });
+  const multiselectOptions = {
+    message: options.message,
+    options: clackOptions
+  };
+  if (options.initialValues !== undefined) {
+    multiselectOptions.initialValues = options.initialValues;
+  }
+  if (options.required !== undefined) {
+    multiselectOptions.required = options.required;
+  }
+  const result = await multiselect(multiselectOptions);
+  if (isCancel(result)) {
+    return Result.err(createCancelledError());
+  }
+  return Result.ok(result);
+}
+
+export { promptSelect, promptMultiSelect };

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

@@ -0,0 +1,144 @@
+// @bun
+// packages/cli/src/render/date.ts
+import { Result, ValidationError } from "@outfitter/contracts";
+var ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+var NAMED_RANGES = ["today", "yesterday", "last week", "last month"];
+function startOfDay(date) {
+  const result = new Date(date);
+  result.setHours(0, 0, 0, 0);
+  return result;
+}
+function endOfDay(date) {
+  const result = new Date(date);
+  result.setHours(23, 59, 59, 999);
+  return result;
+}
+function isNamedRange(input) {
+  return NAMED_RANGES.includes(input);
+}
+function parseNamedRange(name) {
+  const now = new Date(Date.now());
+  switch (name) {
+    case "today": {
+      return {
+        start: startOfDay(now),
+        end: endOfDay(now)
+      };
+    }
+    case "yesterday": {
+      const yesterday = new Date(now);
+      yesterday.setDate(yesterday.getDate() - 1);
+      return {
+        start: startOfDay(yesterday),
+        end: endOfDay(yesterday)
+      };
+    }
+    case "last week": {
+      const weekAgo = new Date(now);
+      weekAgo.setDate(weekAgo.getDate() - 7);
+      return {
+        start: startOfDay(weekAgo),
+        end: endOfDay(now)
+      };
+    }
+    case "last month": {
+      const monthAgo = new Date(now);
+      monthAgo.setDate(monthAgo.getDate() - 30);
+      return {
+        start: startOfDay(monthAgo),
+        end: endOfDay(now)
+      };
+    }
+    default: {
+      const _exhaustive = name;
+      throw new Error(`Unhandled named range: ${_exhaustive}`);
+    }
+  }
+}
+function parseIsoDate(dateStr) {
+  if (!ISO_DATE_REGEX.test(dateStr)) {
+    return null;
+  }
+  const parts = dateStr.split("-");
+  const yearStr = parts[0];
+  const monthStr = parts[1];
+  const dayStr = parts[2];
+  if (yearStr === undefined || monthStr === undefined || dayStr === undefined) {
+    return null;
+  }
+  const year = Number.parseInt(yearStr, 10);
+  const month = Number.parseInt(monthStr, 10) - 1;
+  const day = Number.parseInt(dayStr, 10);
+  const date = new Date(year, month, day);
+  if (date.getFullYear() !== year || date.getMonth() !== month || date.getDate() !== day) {
+    return null;
+  }
+  return date;
+}
+function parseDateRange(input) {
+  const trimmed = input.trim();
+  if (trimmed === "") {
+    return Result.err(new ValidationError({
+      message: "Date range input cannot be empty",
+      field: "dateRange"
+    }));
+  }
+  const normalized = trimmed.toLowerCase();
+  if (isNamedRange(normalized)) {
+    return Result.ok(parseNamedRange(normalized));
+  }
+  if (trimmed.includes("..")) {
+    const parts = trimmed.split("..");
+    if (parts.length !== 2 || parts[0] === "" || parts[1] === "") {
+      return Result.err(new ValidationError({
+        message: 'Invalid date range format. Expected "YYYY-MM-DD..YYYY-MM-DD"',
+        field: "dateRange"
+      }));
+    }
+    const startStr = parts[0];
+    const endStr = parts[1];
+    if (startStr === undefined || endStr === undefined) {
+      return Result.err(new ValidationError({
+        message: 'Invalid date range format. Expected "YYYY-MM-DD..YYYY-MM-DD"',
+        field: "dateRange"
+      }));
+    }
+    const startDate = parseIsoDate(startStr);
+    const endDate = parseIsoDate(endStr);
+    if (startDate === null) {
+      return Result.err(new ValidationError({
+        message: `Invalid start date: "${startStr}". Expected format: YYYY-MM-DD`,
+        field: "dateRange"
+      }));
+    }
+    if (endDate === null) {
+      return Result.err(new ValidationError({
+        message: `Invalid end date: "${endStr}". Expected format: YYYY-MM-DD`,
+        field: "dateRange"
+      }));
+    }
+    if (startDate.getTime() > endDate.getTime()) {
+      return Result.err(new ValidationError({
+        message: "Invalid date range: start date must be before or equal to end date",
+        field: "dateRange"
+      }));
+    }
+    return Result.ok({
+      start: startOfDay(startDate),
+      end: endOfDay(endDate)
+    });
+  }
+  const singleDate = parseIsoDate(trimmed);
+  if (singleDate !== null) {
+    return Result.ok({
+      start: startOfDay(singleDate),
+      end: endOfDay(singleDate)
+    });
+  }
+  return Result.err(new ValidationError({
+    message: `Unrecognized date range: "${trimmed}". Expected "today", "yesterday", "last week", "last month", "YYYY-MM-DD", or "YYYY-MM-DD..YYYY-MM-DD"`,
+    field: "dateRange"
+  }));
+}
+
+export { startOfDay, endOfDay, parseDateRange };

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

@@ -0,0 +1,30 @@
+/**
+* Renders markdown to terminal with ANSI styling.
+*
+* Supports the following markdown elements:
+* - Headings (`# Heading`) - rendered bold
+* - Bold (`**text**` or `__text__`) - rendered bold
+* - Italic (`*text*` or `_text_`) - rendered italic
+* - Inline code (`` `code` ``) - rendered cyan
+* - Code blocks (` ``` `) - rendered dim
+*
+* When colors are not supported, markdown syntax is stripped
+* but text content is preserved.
+*
+* @param markdown - Markdown text to render
+* @returns Terminal-formatted string with ANSI codes
+*
+* @example
+* ```typescript
+* const md = `# Heading
+*
+* Some **bold** and *italic* text.
+*
+* Use \`npm install\` to install.
+* `;
+*
+* console.log(renderMarkdown(md));
+* ```
+*/
+declare function renderMarkdown(markdown: string): string;
+export { renderMarkdown };

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

@@ -0,0 +1,53 @@
+/**
+* Minimal writable stream interface.
+*/
+interface WritableStream {
+	write(str: string): boolean;
+	isTTY?: boolean;
+}
+/**
+* Options for creating a stream writer.
+*/
+interface StreamWriterOptions {
+	/** Target stream (defaults to process.stdout) */
+	stream?: WritableStream;
+}
+/**
+* Interface for managing in-place terminal output.
+*/
+interface StreamWriter {
+	/** Write content (replaces current content) */
+	write(content: string): void;
+	/** Update content in place */
+	update(content: string): void;
+	/** Persist current content and move to new line */
+	persist(): void;
+	/** Clear current content */
+	clear(): void;
+}
+/**
+* Creates a stream writer for in-place terminal updates.
+*
+* The writer tracks the number of lines written and can update them in place.
+* In non-TTY mode, it falls back to simple line-by-line output.
+*
+* @param options - Writer configuration
+* @returns StreamWriter instance
+*
+* @example
+* ```typescript
+* import { createStreamWriter } from "@outfitter/cli/streaming";
+*
+* const writer = createStreamWriter();
+*
+* writer.write("Processing...");
+* // Do some work
+* writer.update("Processing... 50%");
+* // Do more work
+* writer.update("Processing... 100%");
+* writer.persist();
+* writer.write("Done!");
+* ```
+*/
+declare function createStreamWriter(options?: StreamWriterOptions): StreamWriter;
+export { WritableStream, StreamWriterOptions, StreamWriter, createStreamWriter };

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

@@ -0,0 +1,42 @@
+/**
+* Formatting utilities for human-readable output.
+*
+* Provides functions to format durations and byte sizes.
+*
+* @packageDocumentation
+*/
+/**
+* Formats milliseconds as human-readable duration.
+*
+* Converts milliseconds to a compact, human-friendly format using
+* h (hours), m (minutes), s (seconds), or ms (milliseconds).
+*
+* @param ms - Duration in milliseconds
+* @returns Human-friendly duration string
+*
+* @example
+* ```typescript
+* formatDuration(150)     // "150ms"
+* formatDuration(45000)   // "45s"
+* formatDuration(9015000) // "2h 30m 15s"
+* ```
+*/
+declare function formatDuration(ms: number): string;
+/**
+* Formats bytes as human-readable size.
+*
+* Converts bytes to a compact format using appropriate units
+* (B, KB, MB, GB, TB). Uses 1024-based (binary) units.
+*
+* @param bytes - Size in bytes
+* @returns Human-friendly size string
+*
+* @example
+* ```typescript
+* formatBytes(500)        // "500 B"
+* formatBytes(1536)       // "1.5 KB"
+* formatBytes(1073741824) // "1 GB"
+* ```
+*/
+declare function formatBytes(bytes: number): string;
+export { formatDuration, formatBytes };