outfitter 0.2.7 → 0.3.3

package/dist/shared/outfitter-k6zyvg2n.js

@@ -0,0 +1,306 @@
+// @bun
+import {
+  actionInternalErr,
+  outputModeSchema,
+  resolveCwdFromPreset,
+  resolveOutputModeWithEnvFallback,
+  resolveStringFlag
+} from "./outfitter-7n7vsz95.js";
+import {
+  printCheckOrchestratorResults,
+  runCheckOrchestrator
+} from "./outfitter-84chvazx.js";
+import {
+  runCheckTsdoc
+} from "./outfitter-507ra35w.js";
+import {
+  printCheckResults,
+  runCheck
+} from "./outfitter-ssrtakh3.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/actions/check.ts
+import {
+  booleanFlagPreset,
+  cwdPreset,
+  verbosePreset
+} from "@outfitter/cli/flags";
+import { jqPreset, outputModePreset } from "@outfitter/cli/query";
+import {
+  defineAction,
+  Result,
+  ValidationError
+} from "@outfitter/contracts";
+import { z } from "zod";
+var checkOrchestratorModes = ["all", "ci", "pre-commit", "pre-push"];
+var checkInputSchema = z.object({
+  compact: z.boolean(),
+  cwd: z.string(),
+  manifestOnly: z.boolean(),
+  verbose: z.boolean(),
+  block: z.string().optional(),
+  mode: z.enum(checkOrchestratorModes).optional(),
+  stagedFiles: z.array(z.string()).optional(),
+  outputMode: outputModeSchema
+});
+var checkVerbose = verbosePreset();
+var checkCwd = cwdPreset();
+var checkOutputMode = outputModePreset();
+var checkCompact = booleanFlagPreset({
+  id: "checkCompact",
+  key: "compact",
+  flags: "--compact",
+  description: "Omit verbose fields in structured orchestrator output (steps keep id/label/exitCode/durationMs only)"
+});
+var checkVerboseOptions = checkVerbose.options.map((option) => option.flags === "-v, --verbose" ? { ...option, description: "Show diffs for drifted files" } : option);
+function resolveCheckMode(flags) {
+  const requestedModes = [];
+  if (flags["all"] === true) {
+    requestedModes.push("all");
+  }
+  if (flags["ci"] === true) {
+    requestedModes.push("ci");
+  }
+  if (flags["preCommit"] === true) {
+    requestedModes.push("pre-commit");
+  }
+  if (flags["prePush"] === true) {
+    requestedModes.push("pre-push");
+  }
+  if (requestedModes.length > 1) {
+    throw ValidationError.fromMessage("Use only one of --all, --ci, --pre-commit, or --pre-push.");
+  }
+  return requestedModes[0];
+}
+var checkAction = defineAction({
+  id: "check",
+  description: "Compare local config blocks against the registry for drift detection",
+  surfaces: ["cli"],
+  input: checkInputSchema,
+  cli: {
+    group: "check",
+    command: "[staged-files...]",
+    description: "Compare local config blocks against the registry for drift detection",
+    options: [
+      ...checkVerboseOptions,
+      {
+        flags: "--all",
+        description: "Run the full check orchestrator",
+        defaultValue: false
+      },
+      {
+        flags: "--ci",
+        description: "Run CI check orchestration (includes tests)",
+        defaultValue: false
+      },
+      {
+        flags: "--pre-commit",
+        description: "Run pre-commit check orchestration",
+        defaultValue: false
+      },
+      {
+        flags: "--pre-push",
+        description: "Run pre-push check orchestration",
+        defaultValue: false
+      },
+      {
+        flags: "-b, --block <name>",
+        description: "Check a specific block only"
+      },
+      {
+        flags: "--manifest-only",
+        description: "Only check manifest-tracked blocks (skip file-presence heuristic)",
+        defaultValue: false
+      },
+      ...checkCompact.options,
+      ...checkOutputMode.options,
+      ...checkCwd.options
+    ],
+    mapInput: (context) => {
+      const mode = resolveCheckMode(context.flags);
+      const { compact } = checkCompact.resolve(context.flags);
+      const { outputMode: presetOutputMode } = checkOutputMode.resolve(context.flags);
+      const block = resolveStringFlag(context.flags["block"]);
+      if (mode !== undefined && block !== undefined) {
+        throw ValidationError.fromMessage("--block cannot be combined with orchestrator mode flags.");
+      }
+      const stagedFiles = mode === "pre-commit" ? context.args.filter((arg) => typeof arg === "string" && arg.trim().length > 0) : undefined;
+      const outputMode = resolveOutputModeWithEnvFallback(context.flags, resolveStructuredOutputMode(presetOutputMode) ?? "human", { forceHumanWhenImplicit: mode !== undefined });
+      const { verbose } = checkVerbose.resolve(context.flags);
+      const manifestOnly = Boolean(context.flags["manifestOnly"]);
+      return {
+        compact,
+        cwd: resolveCwdFromPreset(context.flags, checkCwd),
+        manifestOnly,
+        verbose,
+        ...block !== undefined ? { block } : {},
+        ...mode !== undefined ? { mode } : {},
+        ...stagedFiles !== undefined ? { stagedFiles } : {},
+        outputMode
+      };
+    }
+  },
+  handler: async (input) => {
+    const { outputMode, mode, stagedFiles, compact, ...checkInput } = input;
+    if (mode !== undefined) {
+      const orchestratorResult = await runCheckOrchestrator({
+        cwd: checkInput.cwd,
+        mode,
+        ...stagedFiles && stagedFiles.length > 0 ? { stagedFiles } : {}
+      });
+      if (orchestratorResult.isErr()) {
+        return actionInternalErr("check", orchestratorResult.error);
+      }
+      await printCheckOrchestratorResults(orchestratorResult.value, {
+        compact,
+        mode: outputMode
+      });
+      if (!orchestratorResult.value.ok) {
+        process.exit(1);
+      }
+      return Result.ok(orchestratorResult.value);
+    }
+    const { block, ...baseCheckInput } = checkInput;
+    const result = await runCheck({
+      ...baseCheckInput,
+      ...block !== undefined ? { block } : {}
+    });
+    if (result.isErr()) {
+      return actionInternalErr("check", result.error);
+    }
+    await printCheckResults(result.value, {
+      mode: outputMode,
+      verbose: checkInput.verbose
+    });
+    if (result.value.driftedCount > 0 || result.value.missingCount > 0) {
+      process.exit(1);
+    }
+    return Result.ok(result.value);
+  }
+});
+var checkTsdocInputSchema = z.object({
+  strict: z.boolean(),
+  minCoverage: z.number(),
+  cwd: z.string(),
+  outputMode: outputModeSchema,
+  jq: z.string().optional(),
+  summary: z.boolean(),
+  level: z.enum(["documented", "partial", "undocumented"]).optional(),
+  packages: z.array(z.string())
+});
+var checkTsdocOutputSchema = z.object({
+  ok: z.boolean(),
+  packages: z.array(z.object({
+    name: z.string(),
+    path: z.string(),
+    declarations: z.array(z.object({
+      name: z.string(),
+      kind: z.string(),
+      level: z.enum(["documented", "partial", "undocumented"]),
+      file: z.string(),
+      line: z.number()
+    })),
+    documented: z.number(),
+    partial: z.number(),
+    undocumented: z.number(),
+    total: z.number(),
+    percentage: z.number()
+  })),
+  summary: z.object({
+    documented: z.number(),
+    partial: z.number(),
+    undocumented: z.number(),
+    total: z.number(),
+    percentage: z.number()
+  })
+});
+var checkTsdocOutputMode = outputModePreset({ includeJsonl: true });
+var checkTsdocJq = jqPreset();
+var checkTsdocAction = defineAction({
+  id: "check.tsdoc",
+  description: "Check TSDoc coverage on exported declarations",
+  surfaces: ["cli"],
+  input: checkTsdocInputSchema,
+  output: checkTsdocOutputSchema,
+  cli: {
+    group: "check",
+    command: "tsdoc",
+    description: "Check TSDoc coverage on exported declarations",
+    options: [
+      {
+        flags: "--strict",
+        description: "Fail if coverage is below the minimum threshold",
+        defaultValue: false
+      },
+      {
+        flags: "--min-coverage <percent>",
+        description: "Minimum coverage percentage (used with --strict)"
+      },
+      {
+        flags: "--summary",
+        description: "Omit per-declaration detail for compact output (~2KB vs ~64KB)",
+        defaultValue: false
+      },
+      {
+        flags: "--level <level>",
+        description: "Filter declarations by coverage level (undocumented, partial, documented)"
+      },
+      {
+        flags: "--package <name>",
+        description: "Filter to specific package(s) by name (repeatable)"
+      },
+      ...checkTsdocOutputMode.options,
+      ...checkTsdocJq.options
+    ],
+    mapInput: (context) => {
+      const { outputMode: presetOutputMode } = checkTsdocOutputMode.resolve(context.flags);
+      const { jq } = checkTsdocJq.resolve(context.flags);
+      const outputMode = resolveOutputModeWithEnvFallback(context.flags, resolveStructuredOutputMode(presetOutputMode) ?? "human");
+      const minCoverageRaw = context.flags["minCoverage"] ?? context.flags["min-coverage"];
+      let minCoverage = 0;
+      if (typeof minCoverageRaw === "string") {
+        minCoverage = Number.parseInt(minCoverageRaw, 10);
+      } else if (typeof minCoverageRaw === "number") {
+        minCoverage = minCoverageRaw;
+      }
+      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 {
+        strict: Boolean(context.flags["strict"]),
+        minCoverage,
+        cwd: process.cwd(),
+        outputMode,
+        jq,
+        summary: Boolean(context.flags["summary"]),
+        level,
+        packages
+      };
+    }
+  },
+  handler: async (input) => {
+    const { jq, level, ...tsdocInput } = input;
+    const result = await runCheckTsdoc({ ...tsdocInput, jq, level });
+    if (result.isErr()) {
+      if (result.error instanceof ValidationError) {
+        return Result.err(result.error);
+      }
+      return actionInternalErr("check.tsdoc", result.error);
+    }
+    if (!result.value.ok) {
+      process.exitCode = 1;
+    }
+    return Result.ok(result.value);
+  }
+});
+
+export { checkAction, checkTsdocOutputSchema, checkTsdocAction };

package/dist/shared/outfitter-mstr60zz.js

@@ -0,0 +1,215 @@
+// @bun
+import {
+  actionInternalErr,
+  outputModeSchema,
+  resolveCwdFromPreset,
+  resolveOutputModeWithEnvFallback
+} from "./outfitter-7n7vsz95.js";
+import {
+  printCheckDocsSentinelResult,
+  runCheckDocsSentinel
+} from "./outfitter-fj2v5ffz.js";
+import {
+  printCheckSurfaceMapFormatResult,
+  runCheckSurfaceMapFormat
+} from "./outfitter-gyayfx5r.js";
+import {
+  printCheckActionCeremonyResult,
+  runCheckActionCeremony
+} from "./outfitter-p2wn07b7.js";
+import {
+  printCheckSurfaceMapResult,
+  runCheckSurfaceMap
+} from "./outfitter-b9cpnr7e.js";
+import {
+  printCheckPresetVersionsResult,
+  runCheckPresetVersions
+} from "./outfitter-8ggmja91.js";
+import {
+  printCheckPublishGuardrailsResult,
+  runCheckPublishGuardrails
+} from "./outfitter-ssynegbs.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/actions/check-automation.ts
+import { cwdPreset } from "@outfitter/cli/flags";
+import { outputModePreset } from "@outfitter/cli/query";
+import { defineAction, Result } from "@outfitter/contracts";
+import { z } from "zod";
+var checkAutomationInputSchema = z.object({
+  cwd: z.string(),
+  outputMode: outputModeSchema
+});
+var checkAutomationOutput = outputModePreset();
+var checkAutomationCwd = cwdPreset();
+function mapCheckAutomationInput(context) {
+  const { outputMode: presetOutputMode } = checkAutomationOutput.resolve(context.flags);
+  const outputMode = resolveOutputModeWithEnvFallback(context.flags, resolveStructuredOutputMode(presetOutputMode) ?? "human");
+  return {
+    cwd: resolveCwdFromPreset(context.flags, checkAutomationCwd),
+    outputMode
+  };
+}
+var checkPublishGuardrailsAction = defineAction({
+  id: "check.publish-guardrails",
+  description: "Validate publishable package manifests enforce prepublishOnly guardrails",
+  surfaces: ["cli"],
+  input: checkAutomationInputSchema,
+  cli: {
+    group: "check",
+    command: "publish-guardrails",
+    description: "Validate publishable package manifests enforce prepublishOnly guardrails",
+    options: [
+      ...checkAutomationOutput.options,
+      ...checkAutomationCwd.options
+    ],
+    mapInput: mapCheckAutomationInput
+  },
+  handler: async (input) => {
+    const result = await runCheckPublishGuardrails({ cwd: input.cwd });
+    if (result.isErr()) {
+      return actionInternalErr("check.publish-guardrails", result.error);
+    }
+    await printCheckPublishGuardrailsResult(result.value, {
+      mode: input.outputMode
+    });
+    if (!result.value.ok) {
+      process.exit(1);
+    }
+    return Result.ok(result.value);
+  }
+});
+var checkPresetVersionsAction = defineAction({
+  id: "check.preset-versions",
+  description: "Validate preset dependency versions, registry versions, and Bun version consistency",
+  surfaces: ["cli"],
+  input: checkAutomationInputSchema,
+  cli: {
+    group: "check",
+    command: "preset-versions",
+    description: "Validate preset dependency versions, registry versions, and Bun version consistency",
+    options: [...checkAutomationOutput.options, ...checkAutomationCwd.options],
+    mapInput: mapCheckAutomationInput
+  },
+  handler: async (input) => {
+    const result = await runCheckPresetVersions({ cwd: input.cwd });
+    if (result.isErr()) {
+      return actionInternalErr("check.preset-versions", result.error);
+    }
+    await printCheckPresetVersionsResult(result.value, {
+      mode: input.outputMode
+    });
+    if (!result.value.ok) {
+      process.exit(1);
+    }
+    return Result.ok(result.value);
+  }
+});
+var checkSurfaceMapAction = defineAction({
+  id: "check.surface-map",
+  description: "Validate canonical surface map path usage (.outfitter/surface.json only)",
+  surfaces: ["cli"],
+  input: checkAutomationInputSchema,
+  cli: {
+    group: "check",
+    command: "surface-map",
+    description: "Validate canonical surface map path usage (.outfitter/surface.json only)",
+    options: [...checkAutomationOutput.options, ...checkAutomationCwd.options],
+    mapInput: mapCheckAutomationInput
+  },
+  handler: async (input) => {
+    const result = await runCheckSurfaceMap({ cwd: input.cwd });
+    if (result.isErr()) {
+      return actionInternalErr("check.surface-map", result.error);
+    }
+    await printCheckSurfaceMapResult(result.value, {
+      mode: input.outputMode
+    });
+    if (!result.value.ok) {
+      process.exit(1);
+    }
+    return Result.ok(result.value);
+  }
+});
+var checkSurfaceMapFormatAction = defineAction({
+  id: "check.surface-map-format",
+  description: "Validate canonical formatting for .outfitter/surface.json",
+  surfaces: ["cli"],
+  input: checkAutomationInputSchema,
+  cli: {
+    group: "check",
+    command: "surface-map-format",
+    description: "Validate canonical formatting for .outfitter/surface.json",
+    options: [...checkAutomationOutput.options, ...checkAutomationCwd.options],
+    mapInput: mapCheckAutomationInput
+  },
+  handler: async (input) => {
+    const result = await runCheckSurfaceMapFormat({ cwd: input.cwd });
+    if (result.isErr()) {
+      return actionInternalErr("check.surface-map-format", result.error);
+    }
+    await printCheckSurfaceMapFormatResult(result.value, {
+      mode: input.outputMode
+    });
+    if (!result.value.ok) {
+      process.exit(1);
+    }
+    return Result.ok(result.value);
+  }
+});
+var checkDocsSentinelAction = defineAction({
+  id: "check.docs-sentinel",
+  description: "Validate docs/README.md PACKAGE_LIST sentinel freshness",
+  surfaces: ["cli"],
+  input: checkAutomationInputSchema,
+  cli: {
+    group: "check",
+    command: "docs-sentinel",
+    description: "Validate docs/README.md PACKAGE_LIST sentinel freshness",
+    options: [...checkAutomationOutput.options, ...checkAutomationCwd.options],
+    mapInput: mapCheckAutomationInput
+  },
+  handler: async (input) => {
+    const result = await runCheckDocsSentinel({ cwd: input.cwd });
+    if (result.isErr()) {
+      return actionInternalErr("check.docs-sentinel", result.error);
+    }
+    await printCheckDocsSentinelResult(result.value, {
+      mode: input.outputMode
+    });
+    if (!result.value.ok) {
+      process.exit(1);
+    }
+    return Result.ok(result.value);
+  }
+});
+var checkActionCeremonyAction = defineAction({
+  id: "check.action-ceremony",
+  description: "Validate action ceremony guardrails in apps/outfitter/src/actions",
+  surfaces: ["cli"],
+  input: checkAutomationInputSchema,
+  cli: {
+    group: "check",
+    command: "action-ceremony",
+    description: "Validate action ceremony guardrails in apps/outfitter/src/actions",
+    options: [...checkAutomationOutput.options, ...checkAutomationCwd.options],
+    mapInput: mapCheckAutomationInput
+  },
+  handler: async (input) => {
+    const result = await runCheckActionCeremony({ cwd: input.cwd });
+    if (result.isErr()) {
+      return actionInternalErr("check.action-ceremony", result.error);
+    }
+    await printCheckActionCeremonyResult(result.value, {
+      mode: input.outputMode
+    });
+    if (!result.value.ok) {
+      process.exit(1);
+    }
+    return Result.ok(result.value);
+  }
+});
+
+export { checkPublishGuardrailsAction, checkPresetVersionsAction, checkSurfaceMapAction, checkSurfaceMapFormatAction, checkDocsSentinelAction, checkActionCeremonyAction };

package/dist/shared/outfitter-n0ed012k.js

@@ -0,0 +1,101 @@
+// @bun
+import {
+  renderOperationPlan
+} from "./outfitter-ttjr95y9.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+import {
+  OperationCollector
+} from "./outfitter-1h7k8xxt.js";
+
+// apps/outfitter/src/commands/init-output.ts
+import { realpath } from "fs/promises";
+import { output } from "@outfitter/cli";
+async function printInitResults(result, options) {
+  let rootDir = result.rootDir;
+  let projectDir = result.projectDir;
+  try {
+    rootDir = await realpath(rootDir);
+    projectDir = await realpath(projectDir);
+  } catch {}
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (result.dryRunPlan) {
+    if (structuredMode) {
+      await output({
+        rootDir,
+        projectDir,
+        structure: result.structure,
+        preset: result.preset,
+        packageName: result.packageName,
+        ...result.dryRunPlan
+      }, { mode: structuredMode });
+      return;
+    }
+    const collector = new OperationCollector;
+    for (const op of result.dryRunPlan.operations) {
+      collector.add(op);
+    }
+    await renderOperationPlan(collector, { rootDir });
+    return;
+  }
+  if (structuredMode) {
+    await output({
+      structure: result.structure,
+      rootDir,
+      projectDir,
+      preset: result.preset,
+      packageName: result.packageName,
+      blocksAdded: result.blocksAdded ?? null,
+      postScaffold: result.postScaffold,
+      nextSteps: result.postScaffold.nextSteps
+    }, { mode: structuredMode });
+    return;
+  }
+  const lines = [
+    `Project initialized successfully in ${rootDir}`,
+    `Structure: ${result.structure}`,
+    `Preset: ${result.preset}`
+  ];
+  if (result.structure === "workspace") {
+    lines.push(`Workspace project path: ${projectDir}`);
+  }
+  if (result.blocksAdded) {
+    const { created, skipped, dependencies, devDependencies } = result.blocksAdded;
+    if (created.length > 0) {
+      lines.push("", `Added ${created.length} tooling file(s):`);
+      for (const file of created) {
+        lines.push(`  \u2713 ${file}`);
+      }
+    }
+    if (skipped.length > 0) {
+      lines.push("", `Skipped ${skipped.length} existing file(s):`);
+      for (const file of skipped) {
+        lines.push(`  - ${file}`);
+      }
+    }
+    const depCount = Object.keys(dependencies).length + Object.keys(devDependencies).length;
+    if (depCount > 0) {
+      lines.push("", `Added ${depCount} package(s) to package.json:`);
+      for (const [name, version] of Object.entries(dependencies)) {
+        lines.push(`  + ${name}@${version}`);
+      }
+      for (const [name, version] of Object.entries(devDependencies)) {
+        lines.push(`  + ${name}@${version} (dev)`);
+      }
+    }
+  }
+  if (result.postScaffold.installResult === "failed") {
+    lines.push("", `Warning: bun install failed: ${result.postScaffold.installError ?? "unknown"}`);
+  }
+  if (result.postScaffold.gitInitResult === "failed") {
+    lines.push("", `Warning: git setup failed: ${result.postScaffold.gitError ?? "unknown"}`);
+  }
+  lines.push("", "Next steps:");
+  for (const step of result.postScaffold.nextSteps) {
+    lines.push(`  ${step}`);
+  }
+  await output(lines, { mode: "human" });
+}
+
+export { printInitResults };

package/dist/shared/outfitter-n13pqaft.js

@@ -0,0 +1,19 @@
+// @bun
+// apps/outfitter/src/commands/upgrade-latest-version.ts
+async function getLatestVersion(name) {
+  try {
+    const proc = Bun.spawn(["npm", "view", name, "version"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const stdout = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+    if (exitCode !== 0)
+      return null;
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export { getLatestVersion };

package/dist/shared/outfitter-nxvjxrmw.d.ts

@@ -0,0 +1,48 @@
+import { CliOutputMode } from "./outfitter-a79xrm12.js";
+import { InternalError, Result } from "@outfitter/contracts";
+/** Validated input for the docs.search action handler. */
+interface DocsSearchInput {
+	readonly cwd: string;
+	readonly jq?: string | undefined;
+	readonly kind?: string | undefined;
+	readonly outputMode: CliOutputMode;
+	readonly package?: string | undefined;
+	readonly query: string;
+}
+/** A single match found in a documentation file. */
+interface DocsSearchMatch {
+	readonly id: string;
+	readonly kind: string;
+	readonly matchLines: string[];
+	readonly outputPath: string;
+	readonly package?: string;
+	readonly sourcePath: string;
+	readonly title: string;
+}
+/** Output shape for the docs.search action. */
+interface DocsSearchOutput {
+	readonly matches: DocsSearchMatch[];
+	readonly query: string;
+	readonly total: number;
+}
+/**
+* Search documentation content for a query string.
+*
+* Generates the docs map for the workspace, reads each file's content,
+* and performs case-insensitive substring matching to find relevant lines.
+*
+* @param input - Validated action input
+* @returns Result containing the search matches or an error
+*/
+declare function runDocsSearch(input: DocsSearchInput): Promise<Result<DocsSearchOutput, InternalError>>;
+/**
+* Print docs search results in the appropriate output format.
+*
+* @param result - The docs search output
+* @param options - Output formatting options
+*/
+declare function printDocsSearchResults(result: DocsSearchOutput, options?: {
+	mode?: CliOutputMode;
+	jq?: string | undefined;
+}): Promise<void>;
+export { DocsSearchInput, DocsSearchMatch, DocsSearchOutput, runDocsSearch, printDocsSearchResults };