@outfitter/cli 0.1.0-rc.2 → 0.1.0

package/dist/shared/@outfitter/cli-2vs2gxa8.js

@@ -1,429 +0,0 @@
-// @bun
-import {
-  __require
-} from "./cli-bt423m6y.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 { collectIds, expandFileArg, parseGlob, parseKeyValue, parseRange, parseFilter, parseSortSpec, normalizeId, confirmDestructive };

package/dist/shared/@outfitter/cli-2yq94zst.d.ts

@@ -1,39 +0,0 @@
-import { CommandBuilder } from "./cli-ttt7r0j7";
-/**
-* Create a new command builder with the given name.
-*
-* The command builder provides a fluent API for defining CLI commands
-* with typed flags, arguments, and actions.
-*
-* @param name - Command name and optional argument syntax (e.g., "list" or "get <id>")
-* @returns A CommandBuilder instance for fluent configuration
-*
-* @example
-* ```typescript
-* import { command, output } from "@outfitter/cli";
-*
-* const list = command("list")
-*   .description("List all notes")
-*   .option("--limit <n>", "Max results", "20")
-*   .option("--json", "Output as JSON")
-*   .option("--next", "Continue from last position")
-*   .action(async ({ flags }) => {
-*     const results = await listNotes(flags);
-*     output(results);
-*   });
-* ```
-*
-* @example
-* ```typescript
-* // Command with required argument
-* const get = command("get <id>")
-*   .description("Get a note by ID")
-*   .action(async ({ args }) => {
-*     const [id] = args;
-*     const note = await getNote(id);
-*     output(note);
-*   });
-* ```
-*/
-declare function command(name: string): CommandBuilder;
-export { command };

package/dist/shared/@outfitter/cli-6xc869x1.js

@@ -1,26 +0,0 @@
-// @bun
-// packages/cli/src/render/tree.ts
-function renderTree(tree) {
-  const lines = [];
-  const renderNode = (key, value, prefix, isLast) => {
-    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-    lines.push(prefix + connector + key);
-    if (value !== null && typeof value === "object") {
-      const entries2 = Object.entries(value);
-      const childPrefix = prefix + (isLast ? "    " : "\u2502   ");
-      entries2.forEach(([childKey, childValue], index) => {
-        const childIsLast = index === entries2.length - 1;
-        renderNode(childKey, childValue, childPrefix, childIsLast);
-      });
-    }
-  };
-  const entries = Object.entries(tree);
-  entries.forEach(([key, value], index) => {
-    const isLast = index === entries.length - 1;
-    renderNode(key, value, "", isLast);
-  });
-  return lines.join(`
-`);
-}
-
-export { renderTree };

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

@@ -1,85 +0,0 @@
-// @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-8r0bnyyx.js

@@ -1,43 +0,0 @@
-// @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-afecwfrn.d.ts

@@ -1,13 +0,0 @@
-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-bt423m6y.js

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