@outfitter/cli 0.1.0-rc.1

package/dist/input.d.ts

@@ -0,0 +1,278 @@
+/**
+* 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;
+}
+import { CancelledError as CancelledError2, ValidationError as ValidationError2 } from "@outfitter/contracts";
+import { Result as Result2 } 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[]): Result2<KeyValuePair[], InstanceType<typeof ValidationError2>>;
+/**
+* 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"): Result2<Range, InstanceType<typeof ValidationError2>>;
+/**
+* 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): Result2<FilterExpression[], InstanceType<typeof ValidationError2>>;
+/**
+* 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): Result2<SortCriteria[], InstanceType<typeof ValidationError2>>;
+/**
+* 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): Result2<string, InstanceType<typeof ValidationError2>>;
+/**
+* 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<Result2<boolean, InstanceType<typeof CancelledError2>>>;
+export { parseSortSpec, parseRange, parseKeyValue, parseGlob, parseFilter, normalizeId, expandFileArg, confirmDestructive, collectIds };

package/dist/input.js

@@ -0,0 +1,439 @@
+// @bun
+import {
+  __require,
+  __toESM
+} from "./shared/@outfitter/cli-4yy82cmp.js";
+
+// packages/cli/src/input.ts
+import path from "path";
+import { CancelledError, ValidationError } from "@outfitter/contracts";
+import { Err, Ok } from "better-result";
+function isSecurePath(filePath, allowAbsolute = false) {
+  if (filePath.includes("\x00")) {
+    return false;
+  }
+  if (filePath.includes("..")) {
+    return false;
+  }
+  const normalized = path.normalize(filePath);
+  if (!allowAbsolute && path.isAbsolute(normalized)) {
+    return false;
+  }
+  return true;
+}
+function isSecureGlobPattern(pattern) {
+  if (pattern.startsWith("..")) {
+    return false;
+  }
+  if (pattern.includes("/../")) {
+    return false;
+  }
+  return true;
+}
+function isWithinWorkspace(resolvedPath, workspaceRoot) {
+  const normalizedPath = path.normalize(resolvedPath);
+  const normalizedRoot = path.normalize(workspaceRoot);
+  return normalizedPath === normalizedRoot || normalizedPath.startsWith(normalizedRoot + path.sep);
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    if (typeof chunk === "string") {
+      chunks.push(chunk);
+    } else if (Buffer.isBuffer(chunk)) {
+      chunks.push(chunk.toString("utf-8"));
+    } else if (chunk instanceof Uint8Array) {
+      chunks.push(Buffer.from(chunk).toString("utf-8"));
+    }
+  }
+  return chunks.join("");
+}
+function splitIds(input) {
+  return input.split(",").flatMap((part) => part.trim().split(/\s+/)).map((id) => id.trim()).filter(Boolean);
+}
+async function isDirectory(path2) {
+  try {
+    const result = await Bun.$`test -d ${path2}`.quiet();
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function isFile(path2) {
+  try {
+    const result = await Bun.$`test -f ${path2}`.quiet();
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function collectIds(input, options) {
+  const { allowFile = true, allowStdin = true } = options ?? {};
+  const ids = [];
+  const inputs = Array.isArray(input) ? input : [input];
+  for (const item of inputs) {
+    if (!item)
+      continue;
+    if (item.startsWith("@")) {
+      const filePath = item.slice(1);
+      if (filePath === "-") {
+        if (!allowStdin) {
+          throw new Error("Reading from stdin is not allowed");
+        }
+        const stdinContent = await readStdin();
+        const stdinIds = stdinContent.split(`
+`).map((line) => line.trim()).filter(Boolean);
+        ids.push(...stdinIds);
+      } else {
+        if (!allowFile) {
+          throw new Error("File references are not allowed");
+        }
+        if (!isSecurePath(filePath, true)) {
+          throw new Error(`Security error: path traversal not allowed: ${filePath}`);
+        }
+        const file = Bun.file(filePath);
+        const exists = await file.exists();
+        if (!exists) {
+          throw new Error(`File not found: ${filePath}`);
+        }
+        const content = await file.text();
+        const fileIds = content.split(`
+`).map((line) => line.trim()).filter(Boolean);
+        ids.push(...fileIds);
+      }
+    } else {
+      ids.push(...splitIds(item));
+    }
+  }
+  return [...new Set(ids)];
+}
+async function expandFileArg(input, options) {
+  const {
+    encoding: _encoding = "utf-8",
+    maxSize,
+    trim = false
+  } = options ?? {};
+  if (!input.startsWith("@")) {
+    return input;
+  }
+  const filePath = input.slice(1);
+  if (filePath === "-") {
+    let content2 = await readStdin();
+    if (trim) {
+      content2 = content2.trim();
+    }
+    return content2;
+  }
+  if (!isSecurePath(filePath, true)) {
+    throw new Error(`Security error: path traversal not allowed: ${filePath}`);
+  }
+  const file = Bun.file(filePath);
+  const exists = await file.exists();
+  if (!exists) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  if (maxSize !== undefined) {
+    const size = file.size;
+    if (size > maxSize) {
+      throw new Error(`File exceeds maximum size of ${maxSize} bytes`);
+    }
+  }
+  let content = await file.text();
+  if (trim) {
+    content = content.trim();
+  }
+  return content;
+}
+async function parseGlob(pattern, options) {
+  const {
+    cwd = process.cwd(),
+    ignore = [],
+    onlyFiles = false,
+    onlyDirectories = false,
+    followSymlinks = false
+  } = options ?? {};
+  if (!isSecureGlobPattern(pattern)) {
+    throw new Error(`Security error: glob pattern may escape workspace: ${pattern}`);
+  }
+  const resolvedCwd = path.resolve(cwd);
+  const glob = new Bun.Glob(pattern);
+  const matches = [];
+  const scanOptions = {
+    cwd,
+    followSymlinks,
+    onlyFiles: onlyFiles === true
+  };
+  for await (const match of glob.scan(scanOptions)) {
+    const fullPath = path.resolve(cwd, match);
+    if (!isWithinWorkspace(fullPath, resolvedCwd)) {
+      continue;
+    }
+    let shouldIgnore = false;
+    for (const ignorePattern of ignore) {
+      const ignoreGlob = new Bun.Glob(ignorePattern);
+      if (ignoreGlob.match(match)) {
+        shouldIgnore = true;
+        break;
+      }
+    }
+    if (shouldIgnore)
+      continue;
+    if (onlyDirectories) {
+      const isDir = await isDirectory(fullPath);
+      if (!isDir)
+        continue;
+    }
+    if (onlyFiles) {
+      const isF = await isFile(fullPath);
+      if (!isF)
+        continue;
+    }
+    matches.push(match);
+  }
+  return matches;
+}
+function parseKeyValue(input) {
+  const pairs = [];
+  const inputs = Array.isArray(input) ? input : [input];
+  for (const item of inputs) {
+    if (!item)
+      continue;
+    const parts = item.split(",");
+    for (const part of parts) {
+      const trimmed = part.trim();
+      if (!trimmed)
+        continue;
+      const eqIndex = trimmed.indexOf("=");
+      if (eqIndex === -1) {
+        return new Err(new ValidationError({
+          message: `Missing '=' in key-value pair: ${trimmed}`
+        }));
+      }
+      const key = trimmed.slice(0, eqIndex).trim();
+      const value = trimmed.slice(eqIndex + 1);
+      if (!key) {
+        return new Err(new ValidationError({ message: "Empty key in key-value pair" }));
+      }
+      pairs.push({ key, value });
+    }
+  }
+  return new Ok(pairs);
+}
+function parseRange(input, type) {
+  const trimmed = input.trim();
+  if (type === "date") {
+    const parts = trimmed.split("..");
+    if (parts.length === 1) {
+      const dateStr = parts[0];
+      if (dateStr === undefined) {
+        return new Err(new ValidationError({ message: "Empty date input" }));
+      }
+      const date = new Date(dateStr.trim());
+      if (Number.isNaN(date.getTime())) {
+        return new Err(new ValidationError({ message: `Invalid date format: ${dateStr}` }));
+      }
+      return new Ok({ type: "date", start: date, end: date });
+    }
+    if (parts.length === 2) {
+      const startStr = parts[0];
+      const endStr = parts[1];
+      if (startStr === undefined || endStr === undefined) {
+        return new Err(new ValidationError({ message: "Invalid date range format" }));
+      }
+      const start = new Date(startStr.trim());
+      const end = new Date(endStr.trim());
+      if (Number.isNaN(start.getTime())) {
+        return new Err(new ValidationError({ message: `Invalid date format: ${startStr}` }));
+      }
+      if (Number.isNaN(end.getTime())) {
+        return new Err(new ValidationError({ message: `Invalid date format: ${endStr}` }));
+      }
+      if (start.getTime() > end.getTime()) {
+        return new Err(new ValidationError({
+          message: "Start date must be before or equal to end date"
+        }));
+      }
+      return new Ok({ type: "date", start, end });
+    }
+    return new Err(new ValidationError({ message: `Invalid date range format: ${input}` }));
+  }
+  const singleNum = Number(trimmed);
+  if (!(Number.isNaN(singleNum) || trimmed.includes("-", trimmed.startsWith("-") ? 1 : 0))) {
+    return new Ok({ type: "number", min: singleNum, max: singleNum });
+  }
+  let separatorIndex = -1;
+  for (let i = 1;i < trimmed.length; i++) {
+    const char = trimmed[i];
+    const prevChar = trimmed[i - 1];
+    if (char === "-" && prevChar !== undefined && /[\d\s]/.test(prevChar)) {
+      separatorIndex = i;
+      break;
+    }
+  }
+  if (separatorIndex === -1) {
+    return new Err(new ValidationError({ message: `Invalid numeric range format: ${input}` }));
+  }
+  const minStr = trimmed.slice(0, separatorIndex).trim();
+  const maxStr = trimmed.slice(separatorIndex + 1).trim();
+  const min = Number(minStr);
+  const max = Number(maxStr);
+  if (Number.isNaN(min)) {
+    return new Err(new ValidationError({ message: `Invalid number: ${minStr}` }));
+  }
+  if (Number.isNaN(max)) {
+    return new Err(new ValidationError({ message: `Invalid number: ${maxStr}` }));
+  }
+  if (min > max) {
+    return new Err(new ValidationError({ message: "Min must be less than or equal to max" }));
+  }
+  return new Ok({ type: "number", min, max });
+}
+function parseFilter(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return new Ok([]);
+  }
+  const filters = [];
+  const parts = trimmed.split(",");
+  for (const part of parts) {
+    let partTrimmed = part.trim();
+    if (!partTrimmed)
+      continue;
+    let isNegated = false;
+    if (partTrimmed.startsWith("!")) {
+      isNegated = true;
+      partTrimmed = partTrimmed.slice(1).trim();
+    }
+    const colonIndex = partTrimmed.indexOf(":");
+    if (colonIndex === -1) {
+      return new Err(new ValidationError({
+        message: `Missing ':' in filter expression: ${part.trim()}`
+      }));
+    }
+    const field = partTrimmed.slice(0, colonIndex).trim();
+    let value = partTrimmed.slice(colonIndex + 1).trim();
+    let operator;
+    if (isNegated) {
+      operator = "ne";
+    } else if (value.startsWith(">=")) {
+      operator = "gte";
+      value = value.slice(2).trim();
+    } else if (value.startsWith("<=")) {
+      operator = "lte";
+      value = value.slice(2).trim();
+    } else if (value.startsWith(">")) {
+      operator = "gt";
+      value = value.slice(1).trim();
+    } else if (value.startsWith("<")) {
+      operator = "lt";
+      value = value.slice(1).trim();
+    } else if (value.startsWith("~")) {
+      operator = "contains";
+      value = value.slice(1).trim();
+    }
+    const filter = { field, value };
+    if (operator) {
+      filter.operator = operator;
+    }
+    filters.push(filter);
+  }
+  return new Ok(filters);
+}
+function parseSortSpec(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return new Ok([]);
+  }
+  const criteria = [];
+  const parts = trimmed.split(",");
+  for (const part of parts) {
+    const partTrimmed = part.trim();
+    if (!partTrimmed)
+      continue;
+    const colonIndex = partTrimmed.indexOf(":");
+    if (colonIndex === -1) {
+      criteria.push({ field: partTrimmed, direction: "asc" });
+    } else {
+      const field = partTrimmed.slice(0, colonIndex).trim();
+      const direction = partTrimmed.slice(colonIndex + 1).trim().toLowerCase();
+      if (direction !== "asc" && direction !== "desc") {
+        return new Err(new ValidationError({
+          message: `Invalid sort direction: ${direction}. Must be 'asc' or 'desc'.`
+        }));
+      }
+      criteria.push({ field, direction });
+    }
+  }
+  return new Ok(criteria);
+}
+function normalizeId(input, options) {
+  const {
+    trim = false,
+    lowercase = false,
+    minLength,
+    maxLength,
+    pattern
+  } = options ?? {};
+  let normalized = input;
+  if (trim) {
+    normalized = normalized.trim();
+  }
+  if (lowercase) {
+    normalized = normalized.toLowerCase();
+  }
+  if (minLength !== undefined && normalized.length < minLength) {
+    return new Err(new ValidationError({
+      message: `ID must be at least ${minLength} characters long`,
+      field: "id"
+    }));
+  }
+  if (maxLength !== undefined && normalized.length > maxLength) {
+    return new Err(new ValidationError({
+      message: `ID must be at most ${maxLength} characters long`,
+      field: "id"
+    }));
+  }
+  if (pattern && !pattern.test(normalized)) {
+    return new Err(new ValidationError({
+      message: `ID does not match required pattern: ${pattern.source}`,
+      field: "id"
+    }));
+  }
+  return new Ok(normalized);
+}
+async function confirmDestructive(options) {
+  const { message, bypassFlag = false, itemCount } = options;
+  if (bypassFlag) {
+    return new Ok(true);
+  }
+  const isTTY = process.stdout.isTTY;
+  const isDumbTerminal = process.env["TERM"] === "dumb";
+  if (!isTTY || isDumbTerminal) {
+    return new Err(new CancelledError({
+      message: "Cannot prompt for confirmation in non-interactive mode. Use --yes to bypass."
+    }));
+  }
+  let promptMessage = message;
+  if (itemCount !== undefined) {
+    promptMessage = `${message} (${itemCount} items)`;
+  }
+  const { confirm, isCancel } = await import("@clack/prompts");
+  const response = await confirm({ message: promptMessage });
+  if (isCancel(response) || response === false) {
+    return new Err(new CancelledError({
+      message: "Operation cancelled by user."
+    }));
+  }
+  return new Ok(true);
+}
+export {
+  parseSortSpec,
+  parseRange,
+  parseKeyValue,
+  parseGlob,
+  parseFilter,
+  normalizeId,
+  expandFileArg,
+  confirmDestructive,
+  collectIds
+};