outfitter 0.3.2 → 0.3.4

package/dist/shared/outfitter-1gmrtapz.js

@@ -0,0 +1,325 @@
+// @bun
+import {
+  checkTsdocOutputSchema
+} from "./outfitter-dmfac1w9.js";
+import {
+  resolveDocsOutputMode
+} from "./outfitter-ec83h4v2.js";
+import {
+  outputModeSchema,
+  resolveCwdFromPreset,
+  resolveStringFlag
+} from "./outfitter-7n7vsz95.js";
+import {
+  printDocsListResults,
+  runDocsList
+} from "./outfitter-yhb23pjc.js";
+import {
+  printDocsApiResults,
+  runDocsApi
+} from "./outfitter-cyhzstz0.js";
+import {
+  printDocsSearchResults,
+  runDocsSearch
+} from "./outfitter-hf5bj2gq.js";
+import {
+  printDocsExportResults,
+  runDocsExport
+} from "./outfitter-940h0x7b.js";
+import {
+  printDocsShowResults,
+  runDocsShow
+} from "./outfitter-c7sbs7es.js";
+
+// apps/outfitter/src/actions/docs.ts
+import { cwdPreset } from "@outfitter/cli/flags";
+import { jqPreset, outputModePreset } from "@outfitter/cli/query";
+import { defineAction, Result } from "@outfitter/contracts";
+import { z } from "zod";
+var docsListInputSchema = z.object({
+  cwd: z.string(),
+  kind: z.string().optional(),
+  package: z.string().optional(),
+  jq: z.string().optional(),
+  outputMode: outputModeSchema
+});
+var docsListCwd = cwdPreset();
+var docsListOutputMode = outputModePreset({ includeJsonl: true });
+var docsListJq = jqPreset();
+var docsListAction = defineAction({
+  id: "docs.list",
+  description: "List documentation entries from the docs map",
+  surfaces: ["cli"],
+  input: docsListInputSchema,
+  cli: {
+    group: "docs",
+    command: "list",
+    description: "List documentation entries from the docs map",
+    options: [
+      {
+        flags: "-k, --kind <kind>",
+        description: "Filter by doc kind (readme, guide, reference, architecture, release, convention, deep, generated)"
+      },
+      {
+        flags: "-p, --package <name>",
+        description: "Filter by package name"
+      },
+      ...docsListOutputMode.options,
+      ...docsListJq.options,
+      ...docsListCwd.options
+    ],
+    mapInput: (context) => {
+      const { outputMode: presetOutputMode } = docsListOutputMode.resolve(context.flags);
+      const { jq } = docsListJq.resolve(context.flags);
+      const outputMode = resolveDocsOutputMode(context.flags, presetOutputMode);
+      const kind = resolveStringFlag(context.flags["kind"]);
+      const pkg = resolveStringFlag(context.flags["package"]);
+      return {
+        cwd: resolveCwdFromPreset(context.flags, docsListCwd),
+        outputMode,
+        jq,
+        ...kind !== undefined ? { kind } : {},
+        ...pkg !== undefined ? { package: pkg } : {}
+      };
+    }
+  },
+  handler: async (input) => {
+    const { outputMode, jq } = input;
+    const result = await runDocsList(input);
+    if (result.isErr()) {
+      return result;
+    }
+    await printDocsListResults(result.value, { mode: outputMode, jq });
+    return Result.ok(result.value);
+  }
+});
+var docsShowInputSchema = z.object({
+  id: z.string(),
+  cwd: z.string(),
+  jq: z.string().optional(),
+  outputMode: outputModeSchema
+});
+var docsShowCwd = cwdPreset();
+var docsShowOutputMode = outputModePreset({ includeJsonl: true });
+var docsShowJq = jqPreset();
+var docsShowAction = defineAction({
+  id: "docs.show",
+  description: "Show a specific documentation entry and its content",
+  surfaces: ["cli"],
+  input: docsShowInputSchema,
+  cli: {
+    group: "docs",
+    command: "show <id>",
+    description: "Show a specific documentation entry and its content",
+    options: [
+      ...docsShowOutputMode.options,
+      ...docsShowJq.options,
+      ...docsShowCwd.options
+    ],
+    mapInput: (context) => {
+      const { outputMode: presetOutputMode } = docsShowOutputMode.resolve(context.flags);
+      const { jq } = docsShowJq.resolve(context.flags);
+      const outputMode = resolveDocsOutputMode(context.flags, presetOutputMode);
+      return {
+        id: context.args[0],
+        cwd: resolveCwdFromPreset(context.flags, docsShowCwd),
+        jq,
+        outputMode
+      };
+    }
+  },
+  handler: async (input) => {
+    const { outputMode, jq } = input;
+    const result = await runDocsShow(input);
+    if (result.isErr()) {
+      return result;
+    }
+    await printDocsShowResults(result.value, { mode: outputMode, jq });
+    return Result.ok(result.value);
+  }
+});
+var docsSearchInputSchema = z.object({
+  query: z.string(),
+  cwd: z.string(),
+  kind: z.string().optional(),
+  package: z.string().optional(),
+  jq: z.string().optional(),
+  outputMode: outputModeSchema
+});
+var docsSearchCwd = cwdPreset();
+var docsSearchOutputMode = outputModePreset({ includeJsonl: true });
+var docsSearchJq = jqPreset();
+var docsSearchAction = defineAction({
+  id: "docs.search",
+  description: "Search documentation content for a query string",
+  surfaces: ["cli"],
+  input: docsSearchInputSchema,
+  cli: {
+    group: "docs",
+    command: "search <query>",
+    description: "Search documentation content for a query string",
+    options: [
+      {
+        flags: "-k, --kind <kind>",
+        description: "Filter by doc kind (readme, guide, reference, architecture, release, convention, deep, generated)"
+      },
+      {
+        flags: "-p, --package <name>",
+        description: "Filter by package name"
+      },
+      ...docsSearchOutputMode.options,
+      ...docsSearchJq.options,
+      ...docsSearchCwd.options
+    ],
+    mapInput: (context) => {
+      const { outputMode: presetOutputMode } = docsSearchOutputMode.resolve(context.flags);
+      const { jq } = docsSearchJq.resolve(context.flags);
+      const outputMode = resolveDocsOutputMode(context.flags, presetOutputMode);
+      const kind = resolveStringFlag(context.flags["kind"]);
+      const pkg = resolveStringFlag(context.flags["package"]);
+      return {
+        query: context.args[0],
+        cwd: resolveCwdFromPreset(context.flags, docsSearchCwd),
+        outputMode,
+        jq,
+        ...kind !== undefined ? { kind } : {},
+        ...pkg !== undefined ? { package: pkg } : {}
+      };
+    }
+  },
+  handler: async (input) => {
+    const { outputMode, jq, ...searchInput } = input;
+    const result = await runDocsSearch({ ...searchInput, outputMode, jq });
+    if (result.isErr()) {
+      return result;
+    }
+    await printDocsSearchResults(result.value, { mode: outputMode, jq });
+    return Result.ok(result.value);
+  }
+});
+var docsApiInputSchema = z.object({
+  cwd: z.string(),
+  level: z.enum(["documented", "partial", "undocumented"]).optional(),
+  packages: z.array(z.string()),
+  jq: z.string().optional(),
+  outputMode: outputModeSchema
+});
+var docsApiCwd = cwdPreset();
+var docsApiOutputMode = outputModePreset({ includeJsonl: true });
+var docsApiJq = jqPreset();
+var docsApiAction = defineAction({
+  id: "docs.api",
+  description: "Extract API reference from TSDoc coverage data",
+  surfaces: ["cli"],
+  input: docsApiInputSchema,
+  output: checkTsdocOutputSchema,
+  cli: {
+    group: "docs",
+    command: "api",
+    description: "Extract API reference from TSDoc coverage data",
+    options: [
+      {
+        flags: "--level <level>",
+        description: "Filter declarations by coverage level (undocumented, partial, documented)"
+      },
+      {
+        flags: "--package <name>",
+        description: "Filter to specific package(s) by name (repeatable)"
+      },
+      ...docsApiOutputMode.options,
+      ...docsApiJq.options,
+      ...docsApiCwd.options
+    ],
+    mapInput: (context) => {
+      const { outputMode: presetOutputMode } = docsApiOutputMode.resolve(context.flags);
+      const { jq } = docsApiJq.resolve(context.flags);
+      const outputMode = resolveDocsOutputMode(context.flags, presetOutputMode);
+      const levelRaw = context.flags["level"];
+      const validLevels = new Set(["documented", "partial", "undocumented"]);
+      const level = typeof levelRaw === "string" && validLevels.has(levelRaw) ? levelRaw : undefined;
+      const pkgRaw = context.flags["package"];
+      let packages = [];
+      if (Array.isArray(pkgRaw)) {
+        packages = pkgRaw.filter((v) => typeof v === "string");
+      } else if (typeof pkgRaw === "string") {
+        packages = [pkgRaw];
+      }
+      return {
+        cwd: resolveCwdFromPreset(context.flags, docsApiCwd),
+        outputMode,
+        jq,
+        level,
+        packages
+      };
+    }
+  },
+  handler: async (input) => {
+    const { cwd, packages, level, outputMode, jq } = input;
+    const result = await runDocsApi({
+      cwd,
+      packages,
+      level,
+      outputMode,
+      jq
+    });
+    if (result.isErr()) {
+      return result;
+    }
+    await printDocsApiResults(result.value, { mode: outputMode, jq });
+    return Result.ok(result.value);
+  }
+});
+var docsExportTargetValues = [
+  "packages",
+  "llms",
+  "llms-full",
+  "all"
+];
+var docsExportInputSchema = z.object({
+  cwd: z.string(),
+  target: z.enum(docsExportTargetValues).default("all"),
+  outputMode: outputModeSchema
+});
+var docsExportCwd = cwdPreset();
+var docsExportOutputMode = outputModePreset({ includeJsonl: true });
+var docsExportAction = defineAction({
+  id: "docs.export",
+  description: "Export documentation to packages, llms.txt, or both",
+  surfaces: ["cli"],
+  input: docsExportInputSchema,
+  cli: {
+    group: "docs",
+    command: "export",
+    description: "Export documentation to packages, llms.txt, or both",
+    options: [
+      {
+        flags: "-t, --target <target>",
+        description: "Export target (packages|llms|llms-full|all, default: all)"
+      },
+      ...docsExportOutputMode.options,
+      ...docsExportCwd.options
+    ],
+    mapInput: (context) => {
+      const { outputMode: presetOutputMode } = docsExportOutputMode.resolve(context.flags);
+      const outputMode = resolveDocsOutputMode(context.flags, presetOutputMode);
+      const targetRaw = resolveStringFlag(context.flags["target"]);
+      const target = targetRaw ?? "all";
+      return {
+        cwd: resolveCwdFromPreset(context.flags, docsExportCwd),
+        target,
+        outputMode
+      };
+    }
+  },
+  handler: async (input) => {
+    const { outputMode, ...exportInput } = input;
+    const result = await runDocsExport({ ...exportInput, outputMode });
+    if (result.isErr()) {
+      return result;
+    }
+    await printDocsExportResults(result.value, { mode: outputMode });
+    return Result.ok(result.value);
+  }
+});
+
+export { docsListAction, docsShowAction, docsSearchAction, docsApiAction, docsExportAction };

package/dist/shared/outfitter-1h7k8xxt.js

@@ -0,0 +1,29 @@
+// @bun
+// apps/outfitter/src/engine/collector.ts
+class OperationCollector {
+  operations = [];
+  add(op) {
+    this.operations.push(op);
+  }
+  getOperations() {
+    return this.operations;
+  }
+  countByType() {
+    const counts = {};
+    for (const op of this.operations) {
+      counts[op.type] = (counts[op.type] ?? 0) + 1;
+    }
+    return counts;
+  }
+  isEmpty() {
+    return this.operations.length === 0;
+  }
+  toJSON() {
+    return {
+      operations: this.operations,
+      summary: this.countByType()
+    };
+  }
+}
+
+export { OperationCollector };

package/dist/shared/outfitter-1tfa9hke.d.ts

@@ -0,0 +1,55 @@
+import { Command } from "commander";
+type DocsMdxMode = "strict" | "lossy";
+interface DocsBaseOptions {
+	readonly cwd?: string;
+	readonly excludedFilenames?: readonly string[];
+	readonly mdxMode?: DocsMdxMode;
+	readonly outputDir?: string;
+	readonly packagesDir?: string;
+	readonly workspaceRoot?: string;
+}
+interface ExecuteCheckCommandOptions extends DocsBaseOptions {}
+interface ExecuteSyncCommandOptions extends DocsBaseOptions {}
+type DocsExportTarget = "packages" | "llms" | "llms-full" | "all";
+interface ExecuteExportCommandOptions extends DocsBaseOptions {
+	readonly llmsFile?: string;
+	readonly llmsFullFile?: string;
+	readonly target?: DocsExportTarget | string;
+}
+interface DocsCommandIo {
+	readonly err: (line: string) => void;
+	readonly out: (line: string) => void;
+}
+interface CreateDocsCommandOptions {
+	readonly commandName?: string;
+	readonly io?: {
+		readonly out?: (line: string) => void;
+		readonly err?: (line: string) => void;
+	};
+}
+interface DocsResultLike<TValue> {
+	readonly error: {
+		readonly message: string;
+	};
+	readonly isErr: () => boolean;
+	readonly value: TValue;
+}
+interface DocsMapLike {
+	readonly entries: readonly unknown[];
+}
+interface DocsModule {
+	createDocsCommand: (options?: CreateDocsCommandOptions) => Command;
+	executeCheckCommand: (options: ExecuteCheckCommandOptions, io: DocsCommandIo) => Promise<number>;
+	executeExportCommand: (options: ExecuteExportCommandOptions, io: DocsCommandIo) => Promise<number>;
+	executeSyncCommand: (options: ExecuteSyncCommandOptions, io: DocsCommandIo) => Promise<number>;
+	generateDocsMap: (options: {
+		readonly workspaceRoot: string;
+	}) => Promise<DocsResultLike<DocsMapLike>>;
+	generatePackageListSection: (workspaceRoot: string) => Promise<string>;
+	replaceSentinelSection: (input: string, sentinelId: string, replacement: string) => string;
+}
+/**
+* Load docs command module with source-first resolution in monorepo development.
+*/
+declare function loadDocsModule(): Promise<DocsModule>;
+export { ExecuteCheckCommandOptions, ExecuteSyncCommandOptions, DocsExportTarget, ExecuteExportCommandOptions, DocsCommandIo, CreateDocsCommandOptions, DocsModule, loadDocsModule };

package/dist/shared/outfitter-2nx0k4b3.d.ts

@@ -0,0 +1,4 @@
+import { ActionRegistry } from "@outfitter/contracts";
+/** Central action registry containing all Outfitter CLI commands. */
+declare const outfitterActions: ActionRegistry;
+export { outfitterActions };

package/dist/shared/outfitter-2ysjerp6.d.ts

@@ -0,0 +1,44 @@
+import { runCheckTsdoc } from "./outfitter-h0wmtxw8.js";
+import { CliOutputMode } from "./outfitter-a79xrm12.js";
+import { InternalError, Result, ValidationError } from "@outfitter/contracts";
+import { TsDocCheckResult } from "@outfitter/tooling";
+/** Validated input for the docs.api action handler. */
+interface DocsApiInput {
+	/** Workspace root used to resolve package paths. */
+	readonly cwd: string;
+	/** Optional jq expression applied to structured output. */
+	readonly jq?: string | undefined;
+	/** Filter declarations by documentation coverage level. */
+	readonly level?: "documented" | "partial" | "undocumented" | undefined;
+	readonly outputMode: CliOutputMode;
+	/** Package names to include; empty array means all packages. */
+	readonly packages: string[];
+}
+interface DocsApiDependencies {
+	readonly runCheckTsdoc?: typeof runCheckTsdoc;
+}
+/**
+* Extract API reference from TSDoc coverage data.
+*
+* Delegates to `runCheckTsdoc` with sensible defaults for documentation
+* output (non-strict, full declaration detail, no minimum coverage).
+*
+* @param input - Validated action input
+* @returns Result containing the TSDoc check result shaped as API reference
+*/
+declare function runDocsApi(input: DocsApiInput, dependencies?: DocsApiDependencies): Promise<Result<TsDocCheckResult, ValidationError | InternalError>>;
+/**
+* Print API reference results in the appropriate output format.
+*
+* For structured modes (JSON/JSONL), delegates to the standard output
+* helper. For human mode, formats as an API reference listing grouped
+* by package.
+*
+* @param result - The TSDoc check result
+* @param options - Output formatting options
+*/
+declare function printDocsApiResults(result: TsDocCheckResult, options?: {
+	mode?: CliOutputMode;
+	jq?: string | undefined;
+}): Promise<void>;
+export { DocsApiInput, runDocsApi, printDocsApiResults };

package/dist/shared/outfitter-2z61gp5w.js

@@ -0,0 +1,29 @@
+// @bun
+// apps/outfitter/src/commands/init-option-resolution.ts
+import { Result } from "@outfitter/contracts";
+function parseBlocks(withFlag) {
+  if (!withFlag) {
+    return;
+  }
+  const blocks = withFlag.split(",").map((value) => value.trim()).filter((value) => value.length > 0);
+  return blocks.length > 0 ? blocks : undefined;
+}
+function isBinaryPreset(preset) {
+  return preset === "cli" || preset === "daemon";
+}
+function isValidInitPreset(value) {
+  return value === "minimal" || value === "cli" || value === "mcp" || value === "daemon" || value === "library" || value === "full-stack";
+}
+function resolvePresetFromFlags(presetFromFlag, availablePresetIds) {
+  if (!presetFromFlag) {
+    return Result.ok(undefined);
+  }
+  const knownAvailablePresetIds = availablePresetIds.filter(isValidInitPreset);
+  const isKnownAndAvailable = isValidInitPreset(presetFromFlag) && knownAvailablePresetIds.includes(presetFromFlag);
+  if (!isKnownAndAvailable) {
+    return Result.err(`Unknown preset '${presetFromFlag}'. Available presets: ${knownAvailablePresetIds.join(", ")}`);
+  }
+  return Result.ok(presetFromFlag);
+}
+
+export { parseBlocks, isBinaryPreset, isValidInitPreset, resolvePresetFromFlags };

package/dist/shared/outfitter-34vg353f.d.ts

@@ -0,0 +1,82 @@
+import { PostScaffoldResult } from "./outfitter-hcexcvxe.js";
+import { OutputMode } from "@outfitter/cli/types";
+import { Result } from "@outfitter/contracts";
+import { AddBlockResult } from "@outfitter/tooling";
+import { Command } from "commander";
+/** Options for the scaffold command, corresponding to CLI flags and positional arguments. */
+interface ScaffoldOptions {
+	/** Working directory to scaffold in. */
+	readonly cwd: string;
+	/** Preview changes without writing to disk. */
+	readonly dryRun: boolean;
+	/** Overwrite existing files without prompting. */
+	readonly force: boolean;
+	/** Timeout in milliseconds for `bun install`. */
+	readonly installTimeout?: number | undefined;
+	/** Use `workspace:*` protocol for `@outfitter` dependencies. */
+	readonly local?: boolean | undefined;
+	/** Override the default target directory name. */
+	readonly name?: string | undefined;
+	/** Skip adding default tooling blocks. */
+	readonly noTooling?: boolean | undefined;
+	/** Skip running `bun install` after scaffolding. */
+	readonly skipInstall: boolean;
+	/** Target preset ID to scaffold (e.g. "cli", "mcp"). */
+	readonly target: string;
+	/** Comma-separated tooling block names to include. */
+	readonly with?: string | undefined;
+}
+/** Result of a successful `outfitter scaffold` run. */
+interface ScaffoldCommandResult {
+	/** Tooling blocks that were added, if any. */
+	readonly blocksAdded?: AddBlockResult | undefined;
+	/** Whether the project was converted from single-package to workspace. */
+	readonly converted: boolean;
+	/** Present only for dry-run invocations; contains the planned operations and summary counts. */
+	readonly dryRunPlan?: {
+		readonly operations: readonly unknown[];
+		readonly summary: Record<string, number>;
+	} | undefined;
+	/** Details of the existing package that was relocated during workspace conversion. */
+	readonly movedExisting?: {
+		readonly from: string;
+		readonly to: string;
+		readonly name: string;
+	} | undefined;
+	/** Results from post-scaffold steps (install, next-step hints). */
+	readonly postScaffold: PostScaffoldResult;
+	/** Absolute path to the workspace root. */
+	readonly rootDir: string;
+	/** The target preset ID that was scaffolded. */
+	readonly target: string;
+	/** Absolute path to the scaffolded target directory. */
+	readonly targetDir: string;
+	/** Whether a new workspace pattern was added to the root package.json. */
+	readonly workspacePatternsUpdated: boolean;
+}
+/** Error returned when scaffolding fails. */
+declare class ScaffoldCommandError extends Error {
+	readonly _tag: "ScaffoldCommandError";
+	/** @param message - Human-readable description of the scaffold failure. */
+	constructor(message: string);
+}
+/**
+* Runs the full scaffold flow: detects project structure, converts to workspace
+* if needed, executes the preset plan, and performs post-scaffold steps.
+*/
+declare function runScaffold(options: ScaffoldOptions): Promise<Result<ScaffoldCommandResult, ScaffoldCommandError>>;
+/**
+* Registers the `scaffold` command on a Commander program.
+* @deprecated Use action-registry CLI wiring via `buildCliCommands(outfitterActions, ...)`.
+*/
+declare function scaffoldCommand(program: Command): void;
+/** Options controlling how scaffold results are rendered (human-readable, JSON, or JSONL). */
+interface PrintScaffoldResultsOptions {
+	readonly mode?: OutputMode;
+}
+/**
+* Renders scaffold results to stdout. Handles dry-run plans, structured output modes,
+* and human-readable summaries including workspace conversion details and next steps.
+*/
+declare function printScaffoldResults(result: ScaffoldCommandResult, options?: PrintScaffoldResultsOptions): Promise<void>;
+export { PrintScaffoldResultsOptions, printScaffoldResults, ScaffoldOptions, ScaffoldCommandResult, ScaffoldCommandError, runScaffold, scaffoldCommand };

package/dist/shared/outfitter-3dq4r10s.d.ts

@@ -0,0 +1,24 @@
+import { ExecuteCheckCommandOptions, ExecuteExportCommandOptions, ExecuteSyncCommandOptions } from "./outfitter-1tfa9hke.js";
+import { Command } from "commander";
+declare const DOCS_COMMON_OPTION_FLAGS: readonly ["--cwd <path>", "--packages-dir <path>", "--output-dir <path>", "--mdx-mode <mode>"];
+declare const DOCS_EXPORT_OPTION_FLAGS: readonly ["--llms-file <path>", "--llms-full-file <path>", "--target <target>"];
+type RepoCheckSubject = "docs" | "exports" | "readme" | "registry" | "changeset" | "tree" | "boundary-invocations";
+interface RepoCommandIo {
+	readonly err?: (line: string) => void;
+	readonly out?: (line: string) => void;
+}
+interface RepoToolingInvocation {
+	readonly args: readonly string[];
+	readonly command: "check-exports" | "check-readme-imports" | "check-bunup-registry" | "check-changeset" | "check-clean-tree" | "check-boundary-invocations" | "check-markdown-links";
+	readonly cwd: string;
+}
+interface CreateRepoCommandOptions {
+	readonly commandName?: string;
+	readonly io?: RepoCommandIo;
+	readonly runDocsCheck?: (options: ExecuteCheckCommandOptions, io: Required<RepoCommandIo>) => Promise<number>;
+	readonly runDocsExport?: (options: ExecuteExportCommandOptions, io: Required<RepoCommandIo>) => Promise<number>;
+	readonly runDocsSync?: (options: ExecuteSyncCommandOptions, io: Required<RepoCommandIo>) => Promise<number>;
+	readonly runToolingCommand?: (input: RepoToolingInvocation) => Promise<number>;
+}
+declare function createRepoCommand(options?: CreateRepoCommandOptions): Command;
+export { DOCS_COMMON_OPTION_FLAGS, DOCS_EXPORT_OPTION_FLAGS, RepoCheckSubject, RepoCommandIo, RepoToolingInvocation, CreateRepoCommandOptions, createRepoCommand };