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

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

@@ -0,0 +1,135 @@
+// @bun
+import {
+  renderTree
+} from "./cli-6xc869x1.js";
+import {
+  renderList
+} from "./cli-fheaaa6b.js";
+import {
+  renderTable
+} from "./cli-e0ecw3x1.js";
+import {
+  renderJson,
+  renderText
+} from "./cli-3hp8qwx3.js";
+import {
+  renderMarkdown
+} from "./cli-azzk8a1d.js";
+
+// packages/cli/src/render/shapes.ts
+function isCollection(shape) {
+  return shape.type === "collection";
+}
+function isHierarchy(shape) {
+  return shape.type === "hierarchy";
+}
+function isKeyValue(shape) {
+  return shape.type === "keyvalue";
+}
+function isResource(shape) {
+  return shape.type === "resource";
+}
+function treeNodeToRecord(node) {
+  if (node.children.length === 0) {
+    return { [node.name]: null };
+  }
+  const childRecord = {};
+  for (const child of node.children) {
+    const childObj = treeNodeToRecord(child);
+    Object.assign(childRecord, childObj);
+  }
+  return { [node.name]: childRecord };
+}
+function isPlainObject(item) {
+  return item !== null && typeof item === "object" && !Array.isArray(item);
+}
+var customRenderers = new Map;
+function registerRenderer(shapeType, renderer) {
+  customRenderers.set(shapeType, renderer);
+}
+function unregisterRenderer(shapeType) {
+  return customRenderers.delete(shapeType);
+}
+function clearRenderers() {
+  customRenderers.clear();
+}
+function render(shape, options) {
+  const customRenderer = customRenderers.get(shape.type);
+  if (customRenderer) {
+    return customRenderer(shape, options);
+  }
+  const format = options?.format;
+  if (format === "json") {
+    if (isCollection(shape)) {
+      return renderJson(shape.items);
+    }
+    if (isHierarchy(shape)) {
+      return renderJson(treeNodeToRecord(shape.root));
+    }
+    if (isKeyValue(shape)) {
+      return renderJson(shape.entries);
+    }
+    if (isResource(shape)) {
+      return renderJson(shape.data);
+    }
+  }
+  if (format === "list" && isCollection(shape)) {
+    const listItems = shape.items.map((item) => {
+      if (typeof item === "string") {
+        return item;
+      }
+      if (isPlainObject(item)) {
+        const name = item.name;
+        if (typeof name === "string") {
+          return name;
+        }
+        return JSON.stringify(item);
+      }
+      return String(item);
+    });
+    return renderList(listItems);
+  }
+  if (format === "table" && isCollection(shape)) {
+    const items = shape.items.filter(isPlainObject);
+    return renderTable(items, shape.headers ? { headers: shape.headers } : undefined);
+  }
+  if (format === "tree" && isHierarchy(shape)) {
+    return renderTree(treeNodeToRecord(shape.root));
+  }
+  if (format === "text" && isResource(shape)) {
+    return renderText(String(shape.data));
+  }
+  if (isCollection(shape)) {
+    const hasObjectItems = shape.items.every(isPlainObject);
+    if (hasObjectItems) {
+      const items = shape.items;
+      return renderTable(items, shape.headers ? { headers: shape.headers } : undefined);
+    }
+    const listItems = shape.items.map((item) => {
+      if (typeof item === "string") {
+        return item;
+      }
+      return String(item);
+    });
+    return renderList(listItems);
+  }
+  if (isHierarchy(shape)) {
+    return renderTree(treeNodeToRecord(shape.root));
+  }
+  if (isKeyValue(shape)) {
+    return renderJson(shape.entries);
+  }
+  if (isResource(shape)) {
+    const resourceFormat = shape.format ?? "json";
+    if (resourceFormat === "markdown") {
+      return renderMarkdown(String(shape.data));
+    }
+    if (resourceFormat === "text") {
+      return renderText(String(shape.data));
+    }
+    return renderJson(shape.data);
+  }
+  return renderJson(shape);
+}
+
+export { isCollection, isHierarchy, isKeyValue, isResource, treeNodeToRecord, isPlainObject, registerRenderer, unregisterRenderer, clearRenderers, render };

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

@@ -0,0 +1,152 @@
+// @bun
+// packages/cli/src/output.ts
+import {
+  safeStringify as contractsSafeStringify,
+  exitCodeMap
+} from "@outfitter/contracts";
+var DEFAULT_EXIT_CODE = 1;
+function writeWithBackpressure(stream, data) {
+  return new Promise((resolve, reject) => {
+    const canContinue = stream.write(data, (error) => {
+      if (error)
+        reject(error);
+    });
+    if (canContinue) {
+      resolve();
+    } else {
+      stream.once("drain", () => resolve());
+      stream.once("error", reject);
+    }
+  });
+}
+function detectMode(options) {
+  if (options?.mode) {
+    return options.mode;
+  }
+  const envJsonl = process.env["OUTFITTER_JSONL"];
+  const envJson = process.env["OUTFITTER_JSON"];
+  if (envJsonl === "1")
+    return "jsonl";
+  if (envJson === "1")
+    return "json";
+  if (envJsonl === "0" || envJson === "0")
+    return "human";
+  return process.stdout.isTTY ? "human" : "json";
+}
+function isValidCategory(category) {
+  return category in exitCodeMap;
+}
+function safeStringify(value, pretty) {
+  const wrappedValue = value === undefined ? null : value;
+  return contractsSafeStringify(wrappedValue, pretty ? 2 : undefined);
+}
+function formatHuman(data) {
+  if (data === null || data === undefined) {
+    return "";
+  }
+  if (typeof data === "string") {
+    return data;
+  }
+  if (typeof data === "number" || typeof data === "boolean") {
+    return String(data);
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => formatHuman(item)).join(`
+`);
+  }
+  if (typeof data === "object") {
+    const lines = [];
+    for (const [key, value] of Object.entries(data)) {
+      lines.push(`${key}: ${formatHuman(value)}`);
+    }
+    return lines.join(`
+`);
+  }
+  return String(data);
+}
+function getErrorProperties(error) {
+  const errorObj = error;
+  return {
+    _tag: errorObj._tag,
+    category: errorObj.category,
+    context: errorObj.context
+  };
+}
+function getExitCode(error) {
+  const { category } = getErrorProperties(error);
+  if (category !== undefined && isValidCategory(category)) {
+    return exitCodeMap[category];
+  }
+  return DEFAULT_EXIT_CODE;
+}
+function serializeErrorToJson(error) {
+  const { _tag, category, context } = getErrorProperties(error);
+  const result = {
+    message: error.message
+  };
+  if (_tag !== undefined) {
+    result._tag = _tag;
+  }
+  if (category !== undefined) {
+    result.category = category;
+  }
+  if (context !== undefined) {
+    result.context = context;
+  }
+  return JSON.stringify(result);
+}
+function formatErrorHuman(error) {
+  const { _tag } = getErrorProperties(error);
+  if (_tag) {
+    return `${_tag}: ${error.message}`;
+  }
+  return error.message;
+}
+async function output(data, options) {
+  const mode = detectMode(options);
+  const stream = options?.stream ?? process.stdout;
+  let outputText;
+  switch (mode) {
+    case "json": {
+      const jsonData = data === undefined ? null : data;
+      outputText = safeStringify(jsonData, options?.pretty);
+      break;
+    }
+    case "jsonl": {
+      if (Array.isArray(data)) {
+        if (data.length === 0) {
+          outputText = "";
+        } else {
+          outputText = data.map((item) => safeStringify(item)).join(`
+`);
+        }
+      } else {
+        outputText = safeStringify(data);
+      }
+      break;
+    }
+    default: {
+      outputText = formatHuman(data);
+      break;
+    }
+  }
+  if (outputText) {
+    await writeWithBackpressure(stream, `${outputText}
+`);
+  }
+}
+function exitWithError(error, options) {
+  const exitCode = getExitCode(error);
+  const mode = detectMode(options);
+  const isJsonMode = mode === "json" || mode === "jsonl";
+  if (isJsonMode) {
+    process.stderr.write(`${serializeErrorToJson(error)}
+`);
+  } else {
+    process.stderr.write(`${formatErrorHuman(error)}
+`);
+  }
+  process.exit(exitCode);
+}
+
+export { output, exitWithError };

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

@@ -0,0 +1,164 @@
+import { CollectIdsOptions, ConfirmDestructiveOptions, ExpandFileOptions, FilterExpression, KeyValuePair, NormalizeIdOptions, ParseGlobOptions, Range, SortCriteria } from "./cli-ttt7r0j7";
+import { CancelledError, ValidationError } from "@outfitter/contracts";
+import { Result } from "better-result";
+/**
+* Collect IDs from various input formats.
+*
+* Handles space-separated, comma-separated, repeated flags, @file, and stdin.
+*
+* @param input - Raw input from CLI arguments
+* @param options - Collection options
+* @returns Array of collected IDs
+*
+* @example
+* ```typescript
+* // All these produce the same result:
+* // wm show id1 id2 id3
+* // wm show id1,id2,id3
+* // wm show --ids id1 --ids id2
+* // wm show @ids.txt
+* const ids = await collectIds(args.ids, {
+*   allowFile: true,
+*   allowStdin: true,
+* });
+* ```
+*/
+declare function collectIds(input: string | readonly string[], options?: CollectIdsOptions): Promise<string[]>;
+/**
+* Expand @file references to file contents.
+*
+* If the input starts with @, reads the file and returns its contents.
+* Otherwise, returns the input unchanged.
+*
+* @param input - Raw input that may be a @file reference
+* @param options - Expansion options
+* @returns File contents or original input
+*
+* @example
+* ```typescript
+* // wm create @template.md
+* const content = await expandFileArg(args.content);
+* ```
+*/
+declare function expandFileArg(input: string, options?: ExpandFileOptions): Promise<string>;
+/**
+* Parse and expand glob patterns.
+*
+* Uses Bun.Glob with workspace constraints.
+*
+* @param pattern - Glob pattern to expand
+* @param options - Glob options
+* @returns Array of matched file paths
+*
+* @example
+* ```typescript
+* // wm index "src/**\/*.ts"
+* const files = await parseGlob(args.pattern, {
+*   cwd: workspaceRoot,
+*   ignore: ["node_modules/**"],
+* });
+* ```
+*/
+declare function parseGlob(pattern: string, options?: ParseGlobOptions): Promise<string[]>;
+/**
+* Parse key=value pairs from CLI input.
+*
+* @param input - Raw input containing key=value pairs
+* @returns Array of parsed key-value pairs
+*
+* @example
+* ```typescript
+* // --set key=value --set key2=value2
+* // --set key=value,key2=value2
+* const pairs = parseKeyValue(args.set);
+* // => [{ key: "key", value: "value" }, { key: "key2", value: "value2" }]
+* ```
+*/
+declare function parseKeyValue(input: string | readonly string[]): Result<KeyValuePair[], InstanceType<typeof ValidationError>>;
+/**
+* Parse range inputs (numeric or date).
+*
+* @param input - Range string (e.g., "1-10" or "2024-01-01..2024-12-31")
+* @param type - Type of range to parse
+* @returns Parsed range
+*
+* @example
+* ```typescript
+* parseRange("1-10", "number");
+* // => Result<{ type: "number", min: 1, max: 10 }, ValidationError>
+*
+* parseRange("2024-01-01..2024-12-31", "date");
+* // => Result<{ type: "date", start: Date, end: Date }, ValidationError>
+* ```
+*/
+declare function parseRange(input: string, type: "number" | "date"): Result<Range, InstanceType<typeof ValidationError>>;
+/**
+* Parse filter expressions from CLI input.
+*
+* @param input - Filter string (e.g., "status:active,priority:high")
+* @returns Array of parsed filter expressions
+*
+* @example
+* ```typescript
+* parseFilter("status:active,priority:high");
+* // => Result<[
+* //   { field: "status", value: "active" },
+* //   { field: "priority", value: "high" }
+* // ], ValidationError>
+* ```
+*/
+declare function parseFilter(input: string): Result<FilterExpression[], InstanceType<typeof ValidationError>>;
+/**
+* Parse sort specification from CLI input.
+*
+* @param input - Sort string (e.g., "modified:desc,title:asc")
+* @returns Array of parsed sort criteria
+*
+* @example
+* ```typescript
+* parseSortSpec("modified:desc,title:asc");
+* // => Result<[
+* //   { field: "modified", direction: "desc" },
+* //   { field: "title", direction: "asc" }
+* // ], ValidationError>
+* ```
+*/
+declare function parseSortSpec(input: string): Result<SortCriteria[], InstanceType<typeof ValidationError>>;
+/**
+* Normalize an identifier (trim, lowercase where appropriate).
+*
+* @param input - Raw identifier input
+* @param options - Normalization options
+* @returns Normalized identifier
+*
+* @example
+* ```typescript
+* normalizeId("  MY-ID  ", { lowercase: true, trim: true });
+* // => Result<"my-id", ValidationError>
+* ```
+*/
+declare function normalizeId(input: string, options?: NormalizeIdOptions): Result<string, InstanceType<typeof ValidationError>>;
+/**
+* Prompt for confirmation before destructive operations.
+*
+* Respects --yes flag for non-interactive mode.
+*
+* @param options - Confirmation options
+* @returns Whether the user confirmed
+*
+* @example
+* ```typescript
+* const confirmed = await confirmDestructive({
+*   message: "Delete 5 notes?",
+*   bypassFlag: flags.yes,
+*   itemCount: 5,
+* });
+*
+* if (confirmed.isErr()) {
+*   // User cancelled
+*   process.exit(0);
+* }
+* ```
+*/
+declare function confirmDestructive(options: ConfirmDestructiveOptions): Promise<Result<boolean, InstanceType<typeof CancelledError>>>;
+export { collectIds, expandFileArg, parseGlob, parseKeyValue, parseRange, parseFilter, parseSortSpec, normalizeId, confirmDestructive };

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

@@ -0,0 +1,26 @@
+/**
+* Date and time formatting utilities.
+*
+* Provides human-friendly relative time formatting.
+*
+* @packageDocumentation
+*/
+/**
+* Formats a date as a human-friendly relative time string.
+*
+* Converts timestamps to natural language like "just now", "5 minutes ago",
+* "yesterday", or "in 3 hours". Handles both past and future dates.
+*
+* @param date - Date to format (Date object, timestamp number, or ISO string)
+* @returns Human-friendly relative time string
+*
+* @example
+* ```typescript
+* formatRelative(new Date())              // "just now"
+* formatRelative(Date.now() - 30000)      // "30 seconds ago"
+* formatRelative(Date.now() - 3600000)    // "1 hour ago"
+* formatRelative(Date.now() + 300000)     // "in 5 minutes"
+* ```
+*/
+declare function formatRelative(date: Date | number | string): string;
+export { formatRelative };

package/dist/terminal/detection.d.ts

@@ -0,0 +1,2 @@
+import { TerminalOptions, getEnvValue, getTerminalWidth, hasNoColorEnv, isInteractive, resolveColorEnv, resolveForceColorEnv, supportsColor } from "../shared/@outfitter/cli-8aa1vhdn";
+export { supportsColor, resolveForceColorEnv, resolveColorEnv, isInteractive, hasNoColorEnv, getTerminalWidth, getEnvValue, TerminalOptions };

package/dist/terminal/detection.js

@@ -0,0 +1,20 @@
+// @bun
+import {
+  getEnvValue,
+  getTerminalWidth,
+  hasNoColorEnv,
+  isInteractive,
+  resolveColorEnv,
+  resolveForceColorEnv,
+  supportsColor
+} from "../shared/@outfitter/cli-jbj78ac5.js";
+import"../shared/@outfitter/cli-bt423m6y.js";
+export {
+  supportsColor,
+  resolveForceColorEnv,
+  resolveColorEnv,
+  isInteractive,
+  hasNoColorEnv,
+  getTerminalWidth,
+  getEnvValue
+};

package/dist/terminal/index.d.ts

@@ -0,0 +1,2 @@
+import { TerminalOptions, getEnvValue, getTerminalWidth, hasNoColorEnv, isInteractive, resolveColorEnv, resolveForceColorEnv, supportsColor } from "../shared/@outfitter/cli-8aa1vhdn";
+export { supportsColor, resolveForceColorEnv, resolveColorEnv, isInteractive, hasNoColorEnv, getTerminalWidth, getEnvValue, TerminalOptions };

package/dist/terminal/index.js

@@ -0,0 +1,20 @@
+// @bun
+import {
+  getEnvValue,
+  getTerminalWidth,
+  hasNoColorEnv,
+  isInteractive,
+  resolveColorEnv,
+  resolveForceColorEnv,
+  supportsColor
+} from "../shared/@outfitter/cli-jbj78ac5.js";
+import"../shared/@outfitter/cli-bt423m6y.js";
+export {
+  supportsColor,
+  resolveForceColorEnv,
+  resolveColorEnv,
+  isInteractive,
+  hasNoColorEnv,
+  getTerminalWidth,
+  getEnvValue
+};