@outfitter/cli 0.1.0-rc.2 → 0.1.0

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

@@ -1,66 +0,0 @@
-/**
-* List rendering utilities.
-*
-* Renders arrays as bullet lists with optional nesting.
-*
-* @packageDocumentation
-*/
-/**
-* A list item with optional nested children for {@link renderList}.
-*
-* @example
-* ```typescript
-* const item: NestedListItem = {
-*   text: "Parent item",
-*   children: ["Child 1", "Child 2"],
-* };
-* ```
-*/
-interface NestedListItem {
-	/** The text content of this list item */
-	text: string;
-	/** Optional nested child items (strings or nested items) */
-	children?: Array<string | NestedListItem>;
-}
-/**
-* 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 bullet list with optional nesting.
-*
-* Supports both simple string items and nested items with children.
-* Nested items are indented with 2 spaces per level.
-*
-* @param items - Array of list items (strings or nested items)
-* @returns Formatted bullet list string
-*
-* @example
-* ```typescript
-* // Simple list
-* console.log(renderList(["First", "Second", "Third"]));
-* // - First
-* // - Second
-* // - Third
-*
-* // Nested list
-* console.log(renderList([
-*   "Parent item",
-*   { text: "Item with children", children: ["Child 1", "Child 2"] },
-* ]));
-* // - Parent item
-* // - Item with children
-* //   - Child 1
-* //   - Child 2
-* ```
-*/
-declare function renderList(items: ListItem[]): string;
-export { NestedListItem, ListItem, renderList };

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

@@ -1,64 +0,0 @@
-// @bun
-import {
-  getStringWidth,
-  padText,
-  truncateText
-} from "./cli-v9mjsvjh.js";
-
-// packages/cli/src/render/table.ts
-function renderTable(data, options) {
-  if (data.length === 0) {
-    return "";
-  }
-  const allKeys = new Set;
-  for (const row of data) {
-    for (const key of Object.keys(row)) {
-      allKeys.add(key);
-    }
-  }
-  const keys = Array.from(allKeys);
-  const headers = options?.headers ?? {};
-  const getHeader = (key) => headers[key] ?? key;
-  const columnWidths = {};
-  for (const key of keys) {
-    const headerWidth = getStringWidth(getHeader(key));
-    let maxDataWidth = 0;
-    for (const row of data) {
-      const value = row[key];
-      const strValue = value === undefined || value === null ? "" : String(value);
-      const width = getStringWidth(strValue);
-      if (width > maxDataWidth) {
-        maxDataWidth = width;
-      }
-    }
-    const optionWidth = options?.columnWidths?.[key];
-    columnWidths[key] = optionWidth ?? Math.max(headerWidth, maxDataWidth);
-  }
-  const lines = [];
-  const headerSep = `+${keys.map((k) => "-".repeat((columnWidths[k] ?? 0) + 2)).join("+")}+`;
-  const headerRow = `|${keys.map((k) => {
-    const header = getHeader(k);
-    const width = columnWidths[k] ?? 0;
-    return ` ${padText(header, width)} `;
-  }).join("|")}|`;
-  lines.push(headerSep);
-  lines.push(headerRow);
-  lines.push(headerSep);
-  for (const row of data) {
-    const rowStr = `|${keys.map((k) => {
-      const value = row[k];
-      let strValue = value === undefined || value === null ? "" : String(value);
-      const width = columnWidths[k] ?? 0;
-      if (getStringWidth(strValue) > width) {
-        strValue = truncateText(strValue, width);
-      }
-      return ` ${padText(strValue, width)} `;
-    }).join("|")}|`;
-    lines.push(rowStr);
-  }
-  lines.push(headerSep);
-  return lines.join(`
-`);
-}
-
-export { renderTable };

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

@@ -1,25 +0,0 @@
-// @bun
-// packages/cli/src/render/list.ts
-function renderList(items) {
-  const lines = [];
-  const renderItem = (item, indent) => {
-    const prefix = `${"  ".repeat(indent)}- `;
-    if (typeof item === "string") {
-      lines.push(prefix + item);
-    } else {
-      lines.push(prefix + item.text);
-      if (item.children) {
-        for (const child of item.children) {
-          renderItem(child, indent + 1);
-        }
-      }
-    }
-  };
-  for (const item of items) {
-    renderItem(item, 0);
-  }
-  return lines.join(`
-`);
-}
-
-export { renderList };

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

@@ -1,41 +0,0 @@
-/**
-* Tree rendering utilities.
-*
-* Renders hierarchical data as ASCII trees with box-drawing characters.
-*
-* @packageDocumentation
-*/
-/**
-* Renders hierarchical data as a tree with unicode box-drawing characters.
-*
-* Uses unicode characters (not, not, |, -) for tree structure.
-* Nested objects are rendered as child nodes; leaf values (null, primitives)
-* are rendered as terminal nodes.
-*
-* @param tree - Hierarchical object to render
-* @returns Formatted tree string with box-drawing characters
-*
-* @example
-* ```typescript
-* const tree = {
-*   src: {
-*     components: {
-*       Button: null,
-*       Input: null,
-*     },
-*     utils: null,
-*   },
-*   tests: null,
-* };
-*
-* console.log(renderTree(tree));
-* // +-- src
-* // |   +-- components
-* // |   |   +-- Button
-* // |   |   L-- Input
-* // |   L-- utils
-* // L-- tests
-* ```
-*/
-declare function renderTree(tree: Record<string, unknown>): string;
-export { renderTree };

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

@@ -1,172 +0,0 @@
-// @bun
-// packages/cli/src/actions.ts
-import {
-  createContext as createHandlerContext,
-  DEFAULT_REGISTRY_SURFACES,
-  validateInput
-} from "@outfitter/contracts";
-import { Command } from "commander";
-var ARGUMENT_PREFIXES = ["<", "["];
-function isArgumentToken(token) {
-  if (!token) {
-    return false;
-  }
-  return ARGUMENT_PREFIXES.some((prefix) => token.startsWith(prefix));
-}
-function splitCommandSpec(spec) {
-  const parts = spec.trim().split(/\s+/).filter(Boolean);
-  if (parts.length === 0) {
-    return { name: undefined, args: [] };
-  }
-  return { name: parts[0], args: parts.slice(1) };
-}
-function applyArguments(command, args) {
-  for (const arg of args) {
-    command.argument(arg);
-  }
-}
-function applyCliOptions(command, action) {
-  const options = action.cli?.options ?? [];
-  for (const option of options) {
-    if (option.required) {
-      command.requiredOption(option.flags, option.description, option.defaultValue);
-    } else {
-      command.option(option.flags, option.description, option.defaultValue);
-    }
-  }
-}
-function resolveDescription(action) {
-  return action.cli?.description ?? action.description ?? action.id;
-}
-function resolveAliases(action) {
-  return action.cli?.aliases ?? [];
-}
-function resolveCommandSpec(action) {
-  return action.cli?.command ?? action.id;
-}
-function resolveFlags(command) {
-  return command.optsWithGlobals?.() ?? command.opts();
-}
-function resolveInput(action, context) {
-  if (action.cli?.mapInput) {
-    return action.cli.mapInput(context);
-  }
-  const hasFlags = Object.keys(context.flags).length > 0;
-  if (!hasFlags && context.args.length === 0) {
-    return {};
-  }
-  return {
-    ...context.flags,
-    ...context.args.length > 0 ? { args: context.args } : {}
-  };
-}
-async function runAction(action, command, createContext) {
-  const flags = resolveFlags(command);
-  const args = command.args;
-  const inputContext = { args, flags };
-  const input = resolveInput(action, inputContext);
-  const validation = validateInput(action.input, input);
-  if (validation.isErr()) {
-    throw validation.error;
-  }
-  const ctx = createContext({ action, args, flags });
-  const result = await action.handler(validation.value, ctx);
-  if (result.isErr()) {
-    throw result.error;
-  }
-}
-function createCommand(action, createContext, spec) {
-  const commandSpec = spec ?? resolveCommandSpec(action);
-  const { name, args } = splitCommandSpec(commandSpec);
-  if (!name) {
-    throw new Error(`Missing CLI command name for action ${action.id}`);
-  }
-  const command = new Command(name);
-  command.description(resolveDescription(action));
-  applyCliOptions(command, action);
-  applyArguments(command, args);
-  for (const alias of resolveAliases(action)) {
-    command.alias(alias);
-  }
-  command.action(async (...argsList) => {
-    const commandInstance = argsList.at(-1);
-    await runAction(action, commandInstance, createContext);
-  });
-  return command;
-}
-function buildCliCommands(source, options = {}) {
-  const actions = isActionRegistry(source) ? source.list() : source;
-  const includeSurfaces = options.includeSurfaces ?? [
-    "cli"
-  ];
-  const commands = [];
-  const createContext = options.createContext ?? ((_input) => createHandlerContext({
-    cwd: process.cwd(),
-    env: process.env
-  }));
-  const grouped = new Map;
-  const ungrouped = [];
-  for (const action of actions) {
-    const surfaces = action.surfaces ?? DEFAULT_REGISTRY_SURFACES;
-    if (!surfaces.some((surface) => includeSurfaces.includes(surface))) {
-      continue;
-    }
-    const group = action.cli?.group;
-    if (group) {
-      const groupActions = grouped.get(group) ?? [];
-      groupActions.push(action);
-      grouped.set(group, groupActions);
-    } else {
-      ungrouped.push(action);
-    }
-  }
-  for (const action of ungrouped) {
-    commands.push(createCommand(action, createContext));
-  }
-  for (const [groupName, groupActions] of grouped.entries()) {
-    const groupCommand = new Command(groupName);
-    let baseAction;
-    const subcommands = [];
-    for (const action of groupActions) {
-      const spec = action.cli?.command?.trim() ?? "";
-      const { name, args } = splitCommandSpec(spec);
-      if (!name || isArgumentToken(name)) {
-        if (baseAction) {
-          throw new Error(`Group '${groupName}' defines multiple base actions: '${baseAction.id}' and '${action.id}'.`);
-        }
-        baseAction = action;
-        groupCommand.description(resolveDescription(action));
-        applyCliOptions(groupCommand, action);
-        applyArguments(groupCommand, name ? [name, ...args] : args);
-        for (const alias of resolveAliases(action)) {
-          groupCommand.alias(alias);
-        }
-        groupCommand.action(async (...argsList) => {
-          const commandInstance = argsList.at(-1);
-          await runAction(action, commandInstance, createContext);
-        });
-      } else {
-        subcommands.push(action);
-      }
-    }
-    for (const action of subcommands) {
-      const spec = resolveCommandSpec(action);
-      const { name, args } = splitCommandSpec(spec);
-      if (!name) {
-        continue;
-      }
-      const subcommand = createCommand(action, createContext, [name, ...args].join(" "));
-      groupCommand.addCommand(subcommand);
-    }
-    if (!baseAction) {
-      groupCommand.description(groupName);
-    }
-    commands.push(groupCommand);
-  }
-  return commands;
-}
-function isActionRegistry(source) {
-  return "list" in source;
-}
-
-export { buildCliCommands };

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

@@ -1,63 +0,0 @@
-import { CursorOptions, PaginationState } from "./cli-ttt7r0j7";
-/**
-* Load persisted pagination state for a command.
-*
-* @param options - Cursor options specifying command and context
-* @returns The pagination state if it exists, undefined otherwise
-*
-* @example
-* ```typescript
-* const state = loadCursor({
-*   command: "list",
-*   toolName: "waymark",
-* });
-*
-* if (state) {
-*   // Continue from last position
-*   const results = await listNotes({ cursor: state.cursor });
-* }
-* ```
-*/
-declare function loadCursor(options: CursorOptions): PaginationState | undefined;
-/**
-* Save pagination state for a command.
-*
-* The cursor is persisted to XDG state directory, scoped by
-* tool name, command, and optional context.
-*
-* @param cursor - The cursor string to persist
-* @param options - Cursor options specifying command and context
-*
-* @example
-* ```typescript
-* const results = await listNotes({ limit: 20 });
-*
-* if (results.hasMore) {
-*   saveCursor(results.cursor, {
-*     command: "list",
-*     toolName: "waymark",
-*   });
-* }
-* ```
-*/
-declare function saveCursor(cursor: string, options: CursorOptions): void;
-/**
-* Clear persisted pagination state for a command.
-*
-* Called when --reset flag is passed or when pagination completes.
-*
-* @param options - Cursor options specifying command and context
-*
-* @example
-* ```typescript
-* // User passed --reset flag
-* if (flags.reset) {
-*   clearCursor({
-*     command: "list",
-*     toolName: "waymark",
-*   });
-* }
-* ```
-*/
-declare function clearCursor(options: CursorOptions): void;
-export { loadCursor, saveCursor, clearCursor };

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

@@ -1,164 +0,0 @@
-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 };