outfitter 0.2.7 → 0.3.3

package/dist/shared/outfitter-8ggmja91.js

@@ -0,0 +1,301 @@
+// @bun
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/check-preset-versions.ts
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+import { Result } from "@outfitter/contracts";
+import { getResolvedVersions } from "@outfitter/presets";
+import { isTypesBunVersionCompatible } from "@outfitter/tooling";
+var DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+
+class CheckPresetVersionsError extends Error {
+  _tag = "CheckPresetVersionsError";
+  constructor(message) {
+    super(message);
+    this.name = "CheckPresetVersionsError";
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeVersionRange(version) {
+  const trimmed = version.trim();
+  const semverMatch = trimmed.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/);
+  if (semverMatch) {
+    return semverMatch[0];
+  }
+  return trimmed.replace(/^[\^~>=<]+/, "");
+}
+function validatePresetDeps(workspaceRoot, resolvedVersions, problems) {
+  const templateRoots = ["templates", "packages/presets/presets"];
+  const glob = new Bun.Glob("**/package.json.template");
+  for (const rootPath of templateRoots) {
+    const absoluteRoot = join(workspaceRoot, rootPath);
+    if (!existsSync(absoluteRoot)) {
+      continue;
+    }
+    for (const relativePath of glob.scanSync({
+      cwd: absoluteRoot,
+      absolute: false
+    })) {
+      const templatePath = join(rootPath, relativePath);
+      const absoluteTemplatePath = join(absoluteRoot, relativePath);
+      const parsed = JSON.parse(readFileSync(absoluteTemplatePath, "utf-8"));
+      if (!isRecord(parsed)) {
+        continue;
+      }
+      for (const section of DEPENDENCY_SECTIONS) {
+        const deps = parsed[section];
+        if (!isRecord(deps)) {
+          continue;
+        }
+        for (const [name, value] of Object.entries(deps)) {
+          if (typeof value !== "string") {
+            continue;
+          }
+          if (name.startsWith("@outfitter/")) {
+            if (value !== "workspace:*") {
+              problems.push(`${templatePath}: ${name} must use workspace:* (found ${value})`);
+            }
+            continue;
+          }
+          if (name.includes("{{") || value.startsWith("workspace:")) {
+            continue;
+          }
+          const expected = resolvedVersions[name];
+          if (!expected) {
+            problems.push(`${templatePath}: external dependency "${name}" is not declared in @outfitter/presets`);
+            continue;
+          }
+          if (normalizeVersionRange(value) !== normalizeVersionRange(expected)) {
+            problems.push(`${templatePath}: ${name} expected ${expected} (found ${value})`);
+          }
+        }
+      }
+    }
+  }
+}
+function validateRegistryVersions(workspaceRoot, resolvedVersions, problems) {
+  const registryPath = "packages/tooling/registry/registry.json";
+  const absoluteRegistryPath = join(workspaceRoot, registryPath);
+  let registry;
+  try {
+    registry = JSON.parse(readFileSync(absoluteRegistryPath, "utf-8"));
+  } catch {
+    problems.push(`Registry not found or unreadable: ${registryPath}`);
+    return;
+  }
+  if (!isRecord(registry)) {
+    problems.push(`Registry has invalid shape (expected object): ${registryPath}`);
+    return;
+  }
+  if (!isRecord(registry["blocks"])) {
+    problems.push(`Registry has invalid shape (missing object "blocks" field): ${registryPath}`);
+    return;
+  }
+  for (const [blockName, block] of Object.entries(registry["blocks"])) {
+    if (!isRecord(block)) {
+      continue;
+    }
+    const devDeps = block["devDependencies"];
+    if (!isRecord(devDeps)) {
+      continue;
+    }
+    for (const [name, value] of Object.entries(devDeps)) {
+      if (typeof value !== "string") {
+        continue;
+      }
+      if (name.startsWith("@outfitter/")) {
+        continue;
+      }
+      const expected = resolvedVersions[name];
+      if (expected && normalizeVersionRange(value) !== normalizeVersionRange(expected)) {
+        problems.push(`registry block "${blockName}": ${name} expected ${expected} (found ${value})`);
+      }
+    }
+  }
+}
+function readDependencyVersion(packageJson, section, name) {
+  const container = packageJson[section];
+  if (!isRecord(container)) {
+    return;
+  }
+  const value = container[name];
+  return typeof value === "string" ? value : undefined;
+}
+function validateBunVersionConsistency(workspaceRoot, problems) {
+  const bunVersionPath = join(workspaceRoot, ".bun-version");
+  const bunVersionFile = readFileSync(bunVersionPath, "utf-8").trim();
+  const rootPackagePath = join(workspaceRoot, "package.json");
+  const parsedRootPackage = JSON.parse(readFileSync(rootPackagePath, "utf-8"));
+  if (!isRecord(parsedRootPackage)) {
+    return;
+  }
+  const engines = parsedRootPackage["engines"];
+  if (isRecord(engines) && typeof engines["bun"] === "string") {
+    const engineBun = normalizeVersionRange(engines["bun"]);
+    if (engineBun !== bunVersionFile) {
+      problems.push(`Bun version drift: .bun-version is ${bunVersionFile} but engines.bun is ${engines["bun"]}`);
+    }
+  }
+  const packageManager = parsedRootPackage["packageManager"];
+  if (typeof packageManager === "string" && packageManager.startsWith("bun@")) {
+    const packageManagerVersion = normalizeVersionRange(packageManager);
+    if (packageManagerVersion !== bunVersionFile) {
+      problems.push(`Bun version drift: .bun-version is ${bunVersionFile} but packageManager is ${packageManager}`);
+    }
+  }
+  let bunTypesVersion;
+  const catalog = parsedRootPackage["catalog"];
+  if (isRecord(catalog) && typeof catalog["@types/bun"] === "string") {
+    bunTypesVersion = catalog["@types/bun"];
+  }
+  if (!bunTypesVersion) {
+    bunTypesVersion = readDependencyVersion(parsedRootPackage, "devDependencies", "@types/bun") ?? undefined;
+  }
+  if (bunTypesVersion) {
+    const normalizedTypesVersion = normalizeVersionRange(bunTypesVersion);
+    if (!isTypesBunVersionCompatible(bunVersionFile, normalizedTypesVersion)) {
+      problems.push(`Bun version drift: .bun-version is ${bunVersionFile} but @types/bun is ${bunTypesVersion}`);
+    }
+  }
+  const docsToValidate = [
+    "README.md",
+    "apps/outfitter/README.md",
+    "docs/getting-started.md"
+  ];
+  for (const docPath of docsToValidate) {
+    const absoluteDocPath = join(workspaceRoot, docPath);
+    if (!existsSync(absoluteDocPath)) {
+      continue;
+    }
+    const content = readFileSync(absoluteDocPath, "utf-8");
+    const match = content.match(/\bbun\b\s*(?:>=|>|=)\s*([\d.]+)/i);
+    if (match && match[1] !== bunVersionFile) {
+      problems.push(`Bun version drift: ${docPath} references Bun ${match[1]} but .bun-version is ${bunVersionFile}`);
+    }
+  }
+}
+function validateNoStaleFallbacks(workspaceRoot, problems) {
+  const filesToCheck = [
+    "apps/outfitter/src/commands/shared-deps.ts",
+    "packages/tooling/src/registry/build.ts"
+  ];
+  const fallbackPattern = /(?:\?\?|\|\|)\s*["']\^?[\d]+\.[\d]+\.[\d]+["']/;
+  for (const filePath of filesToCheck) {
+    const absoluteFilePath = join(workspaceRoot, filePath);
+    if (!existsSync(absoluteFilePath)) {
+      continue;
+    }
+    const content = readFileSync(absoluteFilePath, "utf-8");
+    for (const [index, line] of content.split(`
+`).entries()) {
+      if (fallbackPattern.test(line)) {
+        problems.push(`stale fallback: ${filePath}:${index + 1} contains hardcoded version fallback`);
+      }
+    }
+  }
+}
+async function runCheckPresetVersions(options) {
+  try {
+    const workspaceRoot = resolve(options.cwd);
+    const { all: resolvedVersions } = getResolvedVersions();
+    const problems = [];
+    validatePresetDeps(workspaceRoot, resolvedVersions, problems);
+    validateRegistryVersions(workspaceRoot, resolvedVersions, problems);
+    validateBunVersionConsistency(workspaceRoot, problems);
+    validateNoStaleFallbacks(workspaceRoot, problems);
+    return Result.ok({
+      workspaceRoot,
+      problems,
+      ok: problems.length === 0
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to check preset versions";
+    return Result.err(new CheckPresetVersionsError(message));
+  }
+}
+async function printCheckPresetVersionsResult(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    const serialized = structuredMode === "json" ? JSON.stringify(result, null, 2) : JSON.stringify(result);
+    process.stdout.write(`${serialized}
+`);
+    return;
+  }
+  if (result.ok) {
+    process.stdout.write(`All version checks passed.
+`);
+    return;
+  }
+  process.stderr.write(`Version drift detected (${result.problems.length} issue(s)):
+`);
+  for (const problem of result.problems) {
+    process.stderr.write(`- ${problem}
+`);
+  }
+}
+function parseCliArgs(argv) {
+  let cwd = process.cwd();
+  let outputMode = "human";
+  for (let index = 0;index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg === "--cwd") {
+      const value = argv[index + 1];
+      if (!value) {
+        throw new CheckPresetVersionsError("Missing value for --cwd");
+      }
+      cwd = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--json") {
+      outputMode = "json";
+      continue;
+    }
+    if (arg === "--jsonl") {
+      outputMode = "jsonl";
+      continue;
+    }
+  }
+  return {
+    cwd: resolve(cwd),
+    outputMode
+  };
+}
+async function runCheckPresetVersionsFromArgv(argv) {
+  let parsed;
+  try {
+    parsed = parseCliArgs(argv);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid command arguments";
+    process.stderr.write(`${message}
+`);
+    return 1;
+  }
+  const result = await runCheckPresetVersions({ cwd: parsed.cwd });
+  if (result.isErr()) {
+    process.stderr.write(`${result.error.message}
+`);
+    return 1;
+  }
+  await printCheckPresetVersionsResult(result.value, {
+    mode: parsed.outputMode
+  });
+  return result.value.ok ? 0 : 1;
+}
+if (import.meta.main) {
+  runCheckPresetVersionsFromArgv(process.argv.slice(2)).then((exitCode) => {
+    process.exit(exitCode);
+  });
+}
+
+export { CheckPresetVersionsError, runCheckPresetVersions, printCheckPresetVersionsResult, runCheckPresetVersionsFromArgv };

package/dist/shared/{outfitter-qakwgrrh.d.ts → outfitter-8kmak0wc.d.ts}

@@ -1,4 +1,4 @@
-import { EngineOptions, ScaffoldError, ScaffoldPlan, ScaffoldResult } from "./outfitter-n9g1zk4x.js";
+import { EngineOptions, ScaffoldError, ScaffoldPlan, ScaffoldResult } from "./outfitter-cyvr4r8d.js";
 import { Result } from "@outfitter/contracts";
 declare function executePlan(plan: ScaffoldPlan, options: EngineOptions): Promise<Result<ScaffoldResult, ScaffoldError>>;
 export { executePlan };

package/dist/shared/outfitter-940h0x7b.js

@@ -0,0 +1,71 @@
+// @bun
+import {
+  loadDocsModule
+} from "./outfitter-svts4wk2.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/docs-export.ts
+import { resolve } from "path";
+import { output } from "@outfitter/cli";
+import { InternalError, Result } from "@outfitter/contracts";
+async function runDocsExport(input, dependencies) {
+  try {
+    const loadDocs = dependencies?.loadDocsModule ?? loadDocsModule;
+    const cwd = resolve(input.cwd);
+    const docsModule = await loadDocs();
+    const messages = [];
+    const warnings = [];
+    const exitCode = await docsModule.executeExportCommand({
+      cwd,
+      target: input.target
+    }, {
+      out: (line) => messages.push(line),
+      err: (line) => warnings.push(line)
+    });
+    if (exitCode !== 0) {
+      return Result.err(new InternalError({
+        message: warnings.join(`
+`) || "Export failed",
+        context: { action: "docs.export", target: input.target }
+      }));
+    }
+    return Result.ok({
+      target: input.target,
+      messages,
+      warnings,
+      exitCode
+    });
+  } catch (error) {
+    return Result.err(new InternalError({
+      message: error instanceof Error ? error.message : "Failed to export docs",
+      context: { action: "docs.export" }
+    }));
+  }
+}
+async function printDocsExportResults(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    await output(result, { mode: structuredMode });
+    return;
+  }
+  const lines = [];
+  if (result.messages.length > 0) {
+    for (const msg of result.messages) {
+      lines.push(msg);
+    }
+  } else {
+    lines.push("Export completed.");
+  }
+  if (result.warnings.length > 0) {
+    lines.push("");
+    lines.push("Warnings:");
+    for (const warning of result.warnings) {
+      lines.push(`  ${warning}`);
+    }
+  }
+  await output(lines, { mode: "human" });
+}
+
+export { runDocsExport, printDocsExportResults };

package/dist/shared/{outfitter-fn20r49x.d.ts → outfitter-954y4mzx.d.ts}

@@ -1,4 +1,4 @@
-import { EngineOptions, ScaffoldError } from "./outfitter-n9g1zk4x.js";
+import { EngineOptions, ScaffoldError } from "./outfitter-cyvr4r8d.js";
 import { Result } from "@outfitter/contracts";
 import { AddBlockResult } from "@outfitter/tooling";
 declare function addBlocks(targetDir: string, blocks: readonly string[], options: EngineOptions): Promise<Result<AddBlockResult, ScaffoldError>>;

package/dist/shared/outfitter-b9cpnr7e.js

@@ -0,0 +1,110 @@
+// @bun
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/check-surface-map.ts
+import { resolve } from "path";
+import { Result } from "@outfitter/contracts";
+var LEGACY_SURFACE_MAP_PATH = "apps/outfitter/.outfitter/surface.json";
+var CANONICAL_SURFACE_MAP_PATH = ".outfitter/surface.json";
+
+class CheckSurfaceMapError extends Error {
+  _tag = "CheckSurfaceMapError";
+  constructor(message) {
+    super(message);
+    this.name = "CheckSurfaceMapError";
+  }
+}
+function isLegacySurfaceMapTracked(cwd) {
+  const check = Bun.spawnSync(["git", "ls-files", "--error-unmatch", LEGACY_SURFACE_MAP_PATH], {
+    cwd,
+    stdout: "ignore",
+    stderr: "ignore"
+  });
+  return check.exitCode === 0;
+}
+async function runCheckSurfaceMap(options) {
+  try {
+    const cwd = resolve(options.cwd);
+    const tracked = isLegacySurfaceMapTracked(cwd);
+    return Result.ok({
+      canonicalPath: CANONICAL_SURFACE_MAP_PATH,
+      legacyTrackedPath: LEGACY_SURFACE_MAP_PATH,
+      ok: !tracked
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to check canonical surface map path";
+    return Result.err(new CheckSurfaceMapError(message));
+  }
+}
+async function printCheckSurfaceMapResult(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    const serialized = structuredMode === "json" ? JSON.stringify(result, null, 2) : JSON.stringify(result);
+    process.stdout.write(`${serialized}
+`);
+    return;
+  }
+  if (result.ok) {
+    return;
+  }
+  process.stderr.write(`${result.legacyTrackedPath} must not be tracked. Canonical surface map is ${result.canonicalPath}.
+`);
+}
+function parseCliArgs(argv) {
+  let cwd = process.cwd();
+  let outputMode = "human";
+  for (let index = 0;index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg === "--cwd") {
+      const value = argv[index + 1];
+      if (!value) {
+        throw new CheckSurfaceMapError("Missing value for --cwd");
+      }
+      cwd = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--json") {
+      outputMode = "json";
+      continue;
+    }
+    if (arg === "--jsonl") {
+      outputMode = "jsonl";
+      continue;
+    }
+  }
+  return {
+    cwd: resolve(cwd),
+    outputMode
+  };
+}
+async function runCheckSurfaceMapFromArgv(argv) {
+  let parsed;
+  try {
+    parsed = parseCliArgs(argv);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid command arguments";
+    process.stderr.write(`${message}
+`);
+    return 1;
+  }
+  const result = await runCheckSurfaceMap({ cwd: parsed.cwd });
+  if (result.isErr()) {
+    process.stderr.write(`${result.error.message}
+`);
+    return 1;
+  }
+  await printCheckSurfaceMapResult(result.value, {
+    mode: parsed.outputMode
+  });
+  return result.value.ok ? 0 : 1;
+}
+if (import.meta.main) {
+  runCheckSurfaceMapFromArgv(process.argv.slice(2)).then((exitCode) => {
+    process.exit(exitCode);
+  });
+}
+
+export { CheckSurfaceMapError, runCheckSurfaceMap, printCheckSurfaceMapResult, runCheckSurfaceMapFromArgv };

package/dist/shared/outfitter-c7sbs7es.js

@@ -0,0 +1,92 @@
+// @bun
+import {
+  applyJq
+} from "./outfitter-5vx1bp7h.js";
+import {
+  loadDocsModule
+} from "./outfitter-svts4wk2.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/docs-show.ts
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import { output } from "@outfitter/cli";
+import { InternalError, NotFoundError, Result } from "@outfitter/contracts";
+async function runDocsShow(input) {
+  try {
+    const cwd = resolve(input.cwd);
+    const docsModule = await loadDocsModule();
+    const mapResult = await docsModule.generateDocsMap({ workspaceRoot: cwd });
+    if (mapResult.isErr()) {
+      return Result.err(new InternalError({
+        message: mapResult.error.message,
+        context: { action: "docs.show" }
+      }));
+    }
+    const rawMap = mapResult.value;
+    const entry = rawMap.entries.find((e) => e.id === input.id);
+    if (!entry) {
+      return Result.err(NotFoundError.create("doc", input.id, {
+        action: "docs.show",
+        availableIds: rawMap.entries.map((e) => e.id).slice(0, 10)
+      }));
+    }
+    const sourcePath = resolve(cwd, entry.sourcePath);
+    const content = await readFile(sourcePath, "utf8");
+    return Result.ok({
+      entry: {
+        id: entry.id,
+        kind: entry.kind,
+        title: entry.title,
+        sourcePath: entry.sourcePath,
+        outputPath: entry.outputPath,
+        ...entry.package !== undefined ? { package: entry.package } : {},
+        tags: entry.tags
+      },
+      content
+    });
+  } catch (error) {
+    return Result.err(new InternalError({
+      message: error instanceof Error ? error.message : "Failed to show doc",
+      context: { action: "docs.show" }
+    }));
+  }
+}
+async function printDocsShowResults(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    if (options?.jq) {
+      const filtered = await applyJq(result, options.jq, {
+        compact: structuredMode === "jsonl"
+      });
+      process.stdout.write(filtered);
+    } else {
+      await output(result, { mode: structuredMode });
+    }
+    return;
+  }
+  const lines = [];
+  lines.push("");
+  lines.push(result.entry.title);
+  lines.push("=".repeat(60));
+  lines.push("");
+  lines.push(`  ID:     ${result.entry.id}`);
+  lines.push(`  Kind:   ${result.entry.kind}`);
+  lines.push(`  Source: ${result.entry.sourcePath}`);
+  lines.push(`  Output: ${result.entry.outputPath}`);
+  if (result.entry.package) {
+    lines.push(`  Package: ${result.entry.package}`);
+  }
+  if (result.entry.tags.length > 0) {
+    lines.push(`  Tags:   ${result.entry.tags.join(", ")}`);
+  }
+  lines.push("");
+  lines.push("-".repeat(60));
+  lines.push("");
+  lines.push(result.content);
+  await output(lines, { mode: "human" });
+}
+
+export { runDocsShow, printDocsShowResults };

package/dist/shared/outfitter-cyhzstz0.js

@@ -0,0 +1,93 @@
+// @bun
+import {
+  runCheckTsdoc
+} from "./outfitter-507ra35w.js";
+import {
+  applyJq
+} from "./outfitter-5vx1bp7h.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/docs-api.ts
+import { relative } from "path";
+import { output } from "@outfitter/cli";
+import { InternalError, Result, ValidationError } from "@outfitter/contracts";
+import { createTheme } from "@outfitter/tui/render";
+async function runDocsApi(input, dependencies) {
+  const runCheck = dependencies?.runCheckTsdoc ?? runCheckTsdoc;
+  const result = await runCheck({
+    cwd: input.cwd,
+    emitOutput: false,
+    jq: input.jq,
+    level: input.level,
+    minCoverage: 0,
+    outputMode: input.outputMode,
+    packages: input.packages,
+    strict: false,
+    summary: false
+  });
+  if (result.isErr()) {
+    if (result.error instanceof ValidationError) {
+      return Result.err(result.error);
+    }
+    if (result.error instanceof InternalError) {
+      return Result.err(result.error);
+    }
+    return Result.err(new InternalError({
+      message: result.error.message,
+      context: { action: "docs.api" }
+    }));
+  }
+  return Result.ok(result.value);
+}
+async function printDocsApiResults(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    if (options?.jq) {
+      const filtered = await applyJq(result, options.jq, {
+        compact: structuredMode === "jsonl"
+      });
+      process.stdout.write(filtered);
+    } else {
+      await output(result, { mode: structuredMode });
+    }
+    return;
+  }
+  const theme = createTheme();
+  const lines = [];
+  const totalDeclarations = result.summary.total;
+  if (totalDeclarations === 0) {
+    lines.push(theme.muted("No API declarations found."));
+    await output(lines, { mode: "human" });
+    return;
+  }
+  lines.push("");
+  lines.push(`API Reference (${totalDeclarations} declarations)`);
+  lines.push("=".repeat(60));
+  const sortedPackages = [...result.packages].toSorted((a, b) => a.name.localeCompare(b.name));
+  for (const pkg of sortedPackages) {
+    if (pkg.declarations.length === 0) {
+      continue;
+    }
+    lines.push("");
+    lines.push(`${pkg.name} ${theme.muted(`(${pkg.percentage}% documented)`)}`);
+    lines.push("-".repeat(40));
+    for (const decl of pkg.declarations) {
+      let levelTag;
+      if (decl.level === "documented") {
+        levelTag = theme.success("[doc]");
+      } else if (decl.level === "partial") {
+        levelTag = theme.warning("[partial]");
+      } else {
+        levelTag = theme.error("[none]");
+      }
+      const location = theme.muted(`${relative(pkg.path, decl.file)}:${decl.line}`);
+      lines.push(`  ${levelTag} ${decl.kind} ${decl.name}  ${location}`);
+    }
+  }
+  lines.push("");
+  await output(lines, { mode: "human" });
+}
+
+export { runDocsApi, printDocsApiResults };

package/dist/shared/{outfitter-n9g1zk4x.d.ts → outfitter-cyvr4r8d.d.ts}

@@ -16,9 +16,10 @@ interface PlaceholderValues {
 * A single change operation in a scaffold plan.
 */
 type ScaffoldChange = {
-	readonly type: "copy-template";
-	readonly template: string;
+	readonly type: "copy-preset";
+	readonly preset: string;
 	readonly targetDir: string;
+	readonly includeTooling: boolean;
 	readonly overlayBaseTemplate: boolean;
 } | {
 	readonly type: "inject-shared-config";