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

package/dist/shared/@outfitter/cli-7km1e58p.js

@@ -0,0 +1,85 @@
+// @bun
+// packages/cli/src/pagination.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var UNSAFE_PATH_PATTERN = /(?:^|[\\/])\.\.(?:[\\/]|$)|^[\\/]|^[a-zA-Z]:/;
+function validatePathComponent(component, name) {
+  if (UNSAFE_PATH_PATTERN.test(component)) {
+    throw new Error(`Security: path traversal detected in ${name}`);
+  }
+}
+function getDefaultStateHome() {
+  const home = os.homedir();
+  switch (process.platform) {
+    case "darwin":
+      return path.join(home, "Library", "Application Support");
+    case "win32":
+      return process.env["LOCALAPPDATA"] ?? path.join(home, "AppData", "Local");
+    default:
+      return path.join(home, ".local", "state");
+  }
+}
+function getStatePath(options) {
+  validatePathComponent(options.command, "command");
+  validatePathComponent(options.toolName, "toolName");
+  if (options.context) {
+    validatePathComponent(options.context, "context");
+  }
+  const xdgState = process.env["XDG_STATE_HOME"] ?? getDefaultStateHome();
+  const parts = [xdgState, options.toolName, "cursors", options.command];
+  if (options.context) {
+    parts.push(options.context);
+  }
+  return path.join(...parts, "cursor.json");
+}
+function loadCursor(options) {
+  const statePath = getStatePath(options);
+  if (!fs.existsSync(statePath)) {
+    return;
+  }
+  try {
+    const content = fs.readFileSync(statePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null || typeof parsed["cursor"] !== "string") {
+      return;
+    }
+    const state = parsed;
+    if (options.maxAgeMs !== undefined) {
+      if (typeof state.timestamp !== "number") {
+        return;
+      }
+      const ageMs = Date.now() - state.timestamp;
+      if (ageMs > options.maxAgeMs) {
+        return;
+      }
+    }
+    return state;
+  } catch {
+    return;
+  }
+}
+function saveCursor(cursor, options) {
+  const statePath = getStatePath(options);
+  const stateDir = path.dirname(statePath);
+  fs.mkdirSync(stateDir, { recursive: true });
+  const state = {
+    cursor,
+    command: options.command,
+    timestamp: Date.now(),
+    hasMore: options.hasMore ?? true,
+    ...options.context && { context: options.context },
+    ...options.total !== undefined && { total: options.total }
+  };
+  fs.writeFileSync(statePath, JSON.stringify(state), "utf-8");
+}
+function clearCursor(options) {
+  const statePath = getStatePath(options);
+  try {
+    if (fs.existsSync(statePath)) {
+      fs.unlinkSync(statePath);
+    }
+  } catch {}
+}
+
+export { loadCursor, saveCursor, clearCursor };

package/dist/shared/@outfitter/cli-7na6p4fs.d.ts

@@ -0,0 +1,59 @@
+/**
+* Progress bar rendering utilities.
+*
+* Renders progress bars with filled and empty segments.
+*
+* @packageDocumentation
+*/
+/**
+* Configuration options for {@link renderProgress}.
+*
+* @example
+* ```typescript
+* const options: ProgressOptions = {
+*   current: 75,
+*   total: 100,
+*   width: 20,
+*   showPercent: true,
+* };
+* // Renders: [###############.....] 75%
+* ```
+*/
+interface ProgressOptions {
+	/** Current progress value */
+	current: number;
+	/** Total value (100% when current equals total) */
+	total: number;
+	/** Width of the progress bar in characters (default: 20) */
+	width?: number;
+	/** Whether to show percentage after the bar (default: false) */
+	showPercent?: boolean;
+}
+/**
+* Renders a progress bar with filled and empty segments.
+*
+* Uses unicode block characters: filled segments, empty segments.
+* Optionally displays percentage after the bar.
+*
+* Handles edge cases:
+* - `total <= 0`: Returns empty bar with 0%
+* - `current > total`: Caps at 100%
+* - `current < 0`: Floors at 0%
+*
+* @param options - Progress bar configuration
+* @returns Formatted progress bar string
+*
+* @example
+* ```typescript
+* renderProgress({ current: 50, total: 100 });
+* // [##########..........]
+*
+* renderProgress({ current: 75, total: 100, showPercent: true });
+* // [###############.....] 75%
+*
+* renderProgress({ current: 30, total: 100, width: 10 });
+* // [###.......]
+* ```
+*/
+declare function renderProgress(options: ProgressOptions): string;
+export { ProgressOptions, renderProgress };

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-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-8r0bnyyx.js

@@ -0,0 +1,43 @@
+// @bun
+// packages/cli/src/command.ts
+import { Command } from "commander";
+
+class CommandBuilderImpl {
+  command;
+  constructor(name) {
+    this.command = new Command(name);
+  }
+  description(text) {
+    this.command.description(text);
+    return this;
+  }
+  option(flags, description, defaultValue) {
+    this.command.option(flags, description, defaultValue);
+    return this;
+  }
+  requiredOption(flags, description, defaultValue) {
+    this.command.requiredOption(flags, description, defaultValue);
+    return this;
+  }
+  alias(alias) {
+    this.command.alias(alias);
+    return this;
+  }
+  action(handler) {
+    this.command.action(async (...args) => {
+      const command = args.at(-1);
+      const flags = command.optsWithGlobals?.() ?? command.opts();
+      const positional = command.args;
+      await handler({ args: positional, flags, command });
+    });
+    return this;
+  }
+  build() {
+    return this.command;
+  }
+}
+function command(name) {
+  return new CommandBuilderImpl(name);
+}
+
+export { command };

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

@@ -0,0 +1,64 @@
+import { Result, ValidationError } from "@outfitter/contracts";
+/**
+* Represents a date range with start and end dates.
+*/
+interface DateRange {
+	/** Start of the range (inclusive, at 00:00:00.000) */
+	start: Date;
+	/** End of the range (inclusive, at 23:59:59.999) */
+	end: Date;
+}
+/**
+* Returns a new Date set to the start of the day (00:00:00.000).
+*
+* @param date - The date to adjust
+* @returns A new Date object at 00:00:00.000 on the same day
+*
+* @example
+* ```typescript
+* startOfDay(new Date("2024-06-15T14:30:00Z"))
+* // Returns 2024-06-15T00:00:00.000 (local time)
+* ```
+*/
+declare function startOfDay(date: Date): Date;
+/**
+* Returns a new Date set to the end of the day (23:59:59.999).
+*
+* @param date - The date to adjust
+* @returns A new Date object at 23:59:59.999 on the same day
+*
+* @example
+* ```typescript
+* endOfDay(new Date("2024-06-15T14:30:00Z"))
+* // Returns 2024-06-15T23:59:59.999 (local time)
+* ```
+*/
+declare function endOfDay(date: Date): Date;
+/**
+* Parses date range strings into structured DateRange.
+*
+* Supported formats:
+* - `"today"` - Current day (00:00:00 to 23:59:59)
+* - `"yesterday"` - Previous day
+* - `"last week"` - Last 7 days
+* - `"last month"` - Last 30 days
+* - `"2024-01-01..2024-12-31"` - Explicit range
+* - `"2024-01-01"` - Single day
+*
+* @param input - The date range string to parse
+* @returns Result containing DateRange on success, or ValidationError on failure
+*
+* @example
+* ```typescript
+* parseDateRange("today")
+* // Ok({ start: today 00:00, end: today 23:59:59 })
+*
+* parseDateRange("2024-01-01..2024-12-31")
+* // Ok({ start: 2024-01-01 00:00, end: 2024-12-31 23:59:59 })
+*
+* parseDateRange("invalid")
+* // Err(ValidationError)
+* ```
+*/
+declare function parseDateRange(input: string): Result<DateRange, InstanceType<typeof ValidationError>>;
+export { DateRange, startOfDay, endOfDay, parseDateRange };

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

@@ -0,0 +1,13 @@
+import { ActionRegistry, ActionSurface, AnyActionSpec, HandlerContext } from "@outfitter/contracts";
+import { Command } from "commander";
+interface BuildCliCommandsOptions {
+	readonly createContext?: (input: {
+		action: AnyActionSpec;
+		args: readonly string[];
+		flags: Record<string, unknown>;
+	}) => HandlerContext;
+	readonly includeSurfaces?: readonly ActionSurface[];
+}
+type ActionSource = ActionRegistry | readonly AnyActionSpec[];
+declare function buildCliCommands(source: ActionSource, options?: BuildCliCommandsOptions): Command[];
+export { BuildCliCommandsOptions, buildCliCommands };

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

@@ -0,0 +1,89 @@
+// @bun
+import {
+  resolveColorEnv,
+  supportsColor
+} from "./cli-jbj78ac5.js";
+
+// packages/cli/src/render/colors.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  magenta: "\x1B[35m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+function createTheme() {
+  const colorEnabled = supportsColor();
+  const colorFn = (ansiCode) => (text) => {
+    if (!colorEnabled) {
+      return text;
+    }
+    return `${ansiCode}${text}${ANSI.reset}`;
+  };
+  return {
+    success: colorFn(ANSI.green),
+    warning: colorFn(ANSI.yellow),
+    error: colorFn(ANSI.red),
+    info: colorFn(ANSI.blue),
+    primary: colorFn(""),
+    secondary: colorFn(ANSI.gray),
+    muted: colorFn(ANSI.dim)
+  };
+}
+function resolveTokenColorEnabled(options) {
+  if (options?.colorLevel === 0) {
+    return false;
+  }
+  if (options?.forceColor === true) {
+    return true;
+  }
+  if (options?.colorLevel !== undefined) {
+    return options.colorLevel > 0;
+  }
+  const env = resolveColorEnv({ forceColorFirst: true });
+  if (env !== undefined) {
+    return env;
+  }
+  return process.stdout.isTTY ?? false;
+}
+function createTokens(options) {
+  const colorEnabled = resolveTokenColorEnabled(options);
+  if (!colorEnabled) {
+    return {
+      success: "",
+      warning: "",
+      error: "",
+      info: "",
+      muted: "",
+      accent: "",
+      primary: "",
+      secondary: ""
+    };
+  }
+  return {
+    success: ANSI.green,
+    warning: ANSI.yellow,
+    error: ANSI.red,
+    info: ANSI.blue,
+    muted: ANSI.dim,
+    accent: ANSI.cyan,
+    primary: "",
+    secondary: ANSI.gray
+  };
+}
+function applyColor(text, color) {
+  if (!supportsColor()) {
+    return text;
+  }
+  const ansiCode = ANSI[color];
+  return `${ansiCode}${text}${ANSI.reset}`;
+}
+
+export { ANSI, createTheme, resolveTokenColorEnabled, createTokens, applyColor };

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

@@ -0,0 +1,59 @@
+// @bun
+import {
+  ANSI
+} from "./cli-ag0w4pk0.js";
+import {
+  supportsColor
+} from "./cli-jbj78ac5.js";
+
+// packages/cli/src/render/markdown.ts
+function renderMarkdown(markdown) {
+  const colorEnabled = supportsColor();
+  let result = markdown;
+  result = result.replace(/```(\w*)\n([\s\S]*?)```/g, (_match, _lang, code) => {
+    const trimmed = code.trimEnd();
+    if (colorEnabled) {
+      return `${ANSI.dim}${trimmed}${ANSI.reset}`;
+    }
+    return trimmed;
+  });
+  result = result.replace(/^(#{1,6})\s+(.+)$/gm, (_match, _hashes, text) => {
+    if (colorEnabled) {
+      return `${ANSI.bold}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  result = result.replace(/\*\*(.+?)\*\*/g, (_match, text) => {
+    if (colorEnabled) {
+      return `${ANSI.bold}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  result = result.replace(/__(.+?)__/g, (_match, text) => {
+    if (colorEnabled) {
+      return `${ANSI.bold}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  result = result.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_match, text) => {
+    if (colorEnabled) {
+      return `${ANSI.italic}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  result = result.replace(/(?<!_)_([^_]+)_(?!_)/g, (_match, text) => {
+    if (colorEnabled) {
+      return `${ANSI.italic}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  result = result.replace(/`([^`]+)`/g, (_match, text) => {
+    if (colorEnabled) {
+      return `${ANSI.cyan}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  return result;
+}
+
+export { renderMarkdown };

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-bt423m6y.js

@@ -0,0 +1,4 @@
+// @bun
+var __require = import.meta.require;
+
+export { __require };