outfitter 0.2.5 → 0.2.6

package/dist/shared/outfitter-193jvzg4.d.ts

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

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

@@ -0,0 +1,194 @@
+// @bun
+// apps/outfitter/src/targets/registry.ts
+import { NotFoundError, Result, ValidationError } from "@outfitter/contracts";
+var TARGET_ALIASES = new Map([
+  ["basic", "minimal"]
+]);
+var TARGET_REGISTRY = new Map([
+  [
+    "minimal",
+    {
+      id: "minimal",
+      description: "Minimal Bun + TypeScript project",
+      category: "library",
+      placement: "packages",
+      templateDir: "minimal",
+      defaultBlocks: ["scaffolding"],
+      status: "ready",
+      scope: "init-only"
+    }
+  ],
+  [
+    "cli",
+    {
+      id: "cli",
+      description: "CLI application with Outfitter command ergonomics",
+      category: "runnable",
+      placement: "apps",
+      templateDir: "cli",
+      defaultBlocks: ["scaffolding"],
+      status: "ready",
+      scope: "both"
+    }
+  ],
+  [
+    "mcp",
+    {
+      id: "mcp",
+      description: "MCP server with typed tools and action registry",
+      category: "runnable",
+      placement: "apps",
+      templateDir: "mcp",
+      defaultBlocks: ["scaffolding"],
+      status: "ready",
+      scope: "both"
+    }
+  ],
+  [
+    "daemon",
+    {
+      id: "daemon",
+      description: "Background daemon with control CLI",
+      category: "runnable",
+      placement: "apps",
+      templateDir: "daemon",
+      defaultBlocks: ["scaffolding"],
+      status: "ready",
+      scope: "both"
+    }
+  ],
+  [
+    "api",
+    {
+      id: "api",
+      description: "HTTP API server (Hono)",
+      category: "runnable",
+      placement: "apps",
+      templateDir: "api",
+      defaultBlocks: ["scaffolding"],
+      status: "stub",
+      scope: "both"
+    }
+  ],
+  [
+    "worker",
+    {
+      id: "worker",
+      description: "Background job worker",
+      category: "runnable",
+      placement: "apps",
+      templateDir: "worker",
+      defaultBlocks: ["scaffolding"],
+      status: "stub",
+      scope: "both"
+    }
+  ],
+  [
+    "web",
+    {
+      id: "web",
+      description: "Web application (TanStack Start)",
+      category: "runnable",
+      placement: "apps",
+      templateDir: "web",
+      defaultBlocks: ["scaffolding"],
+      status: "stub",
+      scope: "both"
+    }
+  ],
+  [
+    "lib",
+    {
+      id: "lib",
+      description: "Shared library package",
+      category: "library",
+      placement: "packages",
+      templateDir: "lib",
+      defaultBlocks: ["scaffolding"],
+      status: "stub",
+      scope: "both"
+    }
+  ]
+]);
+var TARGET_IDS = [...TARGET_REGISTRY.keys()];
+var READY_TARGET_IDS = TARGET_IDS.filter((id) => TARGET_REGISTRY.get(id)?.status === "ready");
+var INIT_TARGET_IDS = TARGET_IDS.filter((id) => {
+  const target = TARGET_REGISTRY.get(id);
+  return target?.status === "ready" && target.scope !== "scaffold-only";
+});
+var SCAFFOLD_TARGET_IDS = TARGET_IDS.filter((id) => {
+  const target = TARGET_REGISTRY.get(id);
+  return target?.status === "ready" && target.scope !== "init-only";
+});
+function getTarget(id) {
+  const resolvedId = TARGET_ALIASES.get(id) ?? id;
+  const target = TARGET_REGISTRY.get(resolvedId);
+  if (!target) {
+    return Result.err(new NotFoundError({
+      message: `Unknown target '${id}'. Available targets: ${TARGET_IDS.join(", ")}`,
+      resourceType: "target",
+      resourceId: id
+    }));
+  }
+  return Result.ok(target);
+}
+function getReadyTarget(id) {
+  const targetResult = getTarget(id);
+  if (targetResult.isErr()) {
+    return targetResult;
+  }
+  const target = targetResult.value;
+  if (target.status === "stub") {
+    return Result.err(new ValidationError({
+      message: `Target '${id}' is not yet available. ` + "It is planned but the template has not been implemented. " + `Ready targets: ${READY_TARGET_IDS.join(", ")}`,
+      field: "target"
+    }));
+  }
+  return Result.ok(target);
+}
+function getInitTarget(id) {
+  const targetResult = getReadyTarget(id);
+  if (targetResult.isErr()) {
+    return targetResult;
+  }
+  const target = targetResult.value;
+  if (target.scope === "scaffold-only") {
+    return Result.err(new ValidationError({
+      message: `Target '${id}' cannot be used with init. Use 'outfitter scaffold ${id}' instead.`,
+      field: "target"
+    }));
+  }
+  return Result.ok(target);
+}
+function getScaffoldTarget(id) {
+  const targetResult = getReadyTarget(id);
+  if (targetResult.isErr()) {
+    return targetResult;
+  }
+  const target = targetResult.value;
+  if (target.scope === "init-only") {
+    return Result.err(new ValidationError({
+      message: `Target '${id}' cannot be scaffolded into an existing project. ` + `It is only available for new project creation via 'outfitter init'.`,
+      field: "target"
+    }));
+  }
+  return Result.ok(target);
+}
+function resolvePlacement(target) {
+  return target.placement;
+}
+function listTargets(filter) {
+  let targets = [...TARGET_REGISTRY.values()];
+  if (filter?.status) {
+    targets = targets.filter((target) => target.status === filter.status);
+  }
+  if (filter?.scope) {
+    targets = targets.filter((target) => target.scope === filter.scope);
+  }
+  if (filter?.category) {
+    targets = targets.filter((target) => target.category === filter.category);
+  }
+  return targets;
+}
+
+export { TARGET_REGISTRY, TARGET_IDS, READY_TARGET_IDS, INIT_TARGET_IDS, SCAFFOLD_TARGET_IDS, getTarget, getReadyTarget, getInitTarget, getScaffoldTarget, resolvePlacement, listTargets };

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

@@ -0,0 +1,322 @@
+// @bun
+import {
+  readManifest
+} from "./outfitter-mtbpabf3.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/check.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { output } from "@outfitter/cli";
+import { Result } from "@outfitter/contracts";
+import { RegistrySchema } from "@outfitter/tooling";
+import { createTheme } from "@outfitter/tui/render";
+class CheckError extends Error {
+  _tag = "CheckError";
+  constructor(message) {
+    super(message);
+    this.name = "CheckError";
+  }
+}
+function getRegistryPath() {
+  let currentDir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0;i < 10; i++) {
+    const registryPath = join(currentDir, "node_modules/@outfitter/tooling/registry/registry.json");
+    if (existsSync(registryPath)) {
+      return registryPath;
+    }
+    const monoRepoPath = join(currentDir, "packages/tooling/registry/registry.json");
+    if (existsSync(monoRepoPath)) {
+      return monoRepoPath;
+    }
+    currentDir = dirname(currentDir);
+  }
+  throw new CheckError("Could not find registry.json. Ensure @outfitter/tooling is installed.");
+}
+function readToolingVersion(registryPath) {
+  try {
+    const toolingRoot = dirname(dirname(registryPath));
+    const pkgPath = join(toolingRoot, "package.json");
+    const content = readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(content);
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function loadRegistry() {
+  try {
+    const registryPath = getRegistryPath();
+    const content = readFileSync(registryPath, "utf-8");
+    const parsed = JSON.parse(content);
+    const registry = RegistrySchema.parse(parsed);
+    const toolingVersion = readToolingVersion(registryPath);
+    return Result.ok({ registry, toolingVersion });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new CheckError(`Failed to load registry: ${message}`));
+  }
+}
+function resolveBlockFiles(registry, blockName, visited = new Set) {
+  if (visited.has(blockName)) {
+    return [];
+  }
+  visited.add(blockName);
+  const block = registry.blocks[blockName];
+  if (!block) {
+    return [];
+  }
+  const files = [];
+  if (block.extends && block.extends.length > 0) {
+    for (const extendedName of block.extends) {
+      files.push(...resolveBlockFiles(registry, extendedName, visited));
+    }
+  }
+  if (block.files) {
+    files.push(...block.files);
+  }
+  return files;
+}
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return a === b;
+  if (typeof a !== typeof b)
+    return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length)
+      return false;
+    for (let i = 0;i < a.length; i++) {
+      if (!deepEqual(a[i], b[i]))
+        return false;
+    }
+    return true;
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length)
+      return false;
+    for (const key of aKeys) {
+      if (!Object.hasOwn(bObj, key))
+        return false;
+      if (!deepEqual(aObj[key], bObj[key]))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function compareFileContent(filePath, localContent, registryContent) {
+  if (filePath.endsWith(".json") || filePath.endsWith(".jsonc")) {
+    try {
+      const cleanLocal = filePath.endsWith(".jsonc") ? stripJsoncComments(localContent) : localContent;
+      const cleanRegistry = filePath.endsWith(".jsonc") ? stripJsoncComments(registryContent) : registryContent;
+      const localParsed = JSON.parse(cleanLocal);
+      const registryParsed = JSON.parse(cleanRegistry);
+      return deepEqual(localParsed, registryParsed);
+    } catch {}
+  }
+  return localContent === registryContent;
+}
+function stripJsoncComments(content) {
+  return content.split(`
+`).map((line) => {
+    let inString = false;
+    for (let i = 0;i < line.length; i++) {
+      const char = line[i];
+      if (char === '"' && (i === 0 || line[i - 1] !== "\\")) {
+        inString = !inString;
+      }
+      if (!inString && char === "/" && line[i + 1] === "/") {
+        return line.slice(0, i).trimEnd();
+      }
+    }
+    return line;
+  }).filter((line) => line.trim() !== "").join(`
+`);
+}
+var BLOCK_FILE_MARKERS = {
+  biome: ["biome.json"],
+  lefthook: [".lefthook.yml"],
+  claude: [".claude/settings.json"],
+  markdownlint: [".markdownlint-cli2.jsonc"],
+  bootstrap: ["scripts/bootstrap.sh"]
+};
+function detectBlocksByFilePresence(cwd) {
+  const detected = [];
+  for (const [blockName, files] of Object.entries(BLOCK_FILE_MARKERS)) {
+    const hasAnyFile = files.some((filePath) => existsSync(join(cwd, filePath)));
+    if (hasAnyFile) {
+      detected.push(blockName);
+    }
+  }
+  return detected;
+}
+function checkBlock(cwd, blockName, registry, toolingVersion, installedFrom, verbose) {
+  const versionFields = {
+    ...installedFrom !== undefined ? { installedFrom } : {},
+    currentToolingVersion: toolingVersion
+  };
+  const files = resolveBlockFiles(registry, blockName);
+  if (files.length === 0 && !registry.blocks[blockName]) {
+    return {
+      name: blockName,
+      status: "missing",
+      ...versionFields
+    };
+  }
+  if (files.length === 0) {
+    return {
+      name: blockName,
+      status: "current",
+      ...versionFields
+    };
+  }
+  let allMissing = true;
+  let anyDrifted = false;
+  const driftedFiles = [];
+  for (const file of files) {
+    const localPath = join(cwd, file.path);
+    if (!existsSync(localPath)) {
+      anyDrifted = true;
+      if (verbose) {
+        driftedFiles.push({ path: file.path, reason: "missing" });
+      }
+      continue;
+    }
+    allMissing = false;
+    const localContent = readFileSync(localPath, "utf-8");
+    if (!compareFileContent(file.path, localContent, file.content)) {
+      anyDrifted = true;
+      if (verbose) {
+        driftedFiles.push({ path: file.path, reason: "modified" });
+      }
+    }
+  }
+  if (allMissing) {
+    return {
+      name: blockName,
+      status: "missing",
+      ...versionFields,
+      ...verbose && driftedFiles.length > 0 ? { driftedFiles } : {}
+    };
+  }
+  if (anyDrifted) {
+    return {
+      name: blockName,
+      status: "drifted",
+      ...versionFields,
+      ...verbose && driftedFiles.length > 0 ? { driftedFiles } : {}
+    };
+  }
+  return {
+    name: blockName,
+    status: "current",
+    ...versionFields
+  };
+}
+async function runCheck(options) {
+  const { cwd: rawCwd, verbose = false, block: blockFilter } = options;
+  const cwd = resolve(rawCwd);
+  const registryResult = loadRegistry();
+  if (registryResult.isErr()) {
+    return registryResult;
+  }
+  const { registry, toolingVersion } = registryResult.value;
+  const manifestResult = await readManifest(cwd);
+  if (manifestResult.isErr()) {
+    return Result.err(new CheckError(`Failed to read manifest: ${manifestResult.error.message}`));
+  }
+  const manifest = manifestResult.value;
+  let blocksToCheck;
+  if (manifest) {
+    blocksToCheck = Object.entries(manifest.blocks).map(([name, entry]) => ({
+      name,
+      installedFrom: entry.installedFrom
+    }));
+  } else {
+    const detected = detectBlocksByFilePresence(cwd);
+    blocksToCheck = detected.map((name) => ({
+      name,
+      installedFrom: undefined
+    }));
+  }
+  if (blockFilter) {
+    blocksToCheck = blocksToCheck.filter((b) => b.name === blockFilter);
+  }
+  const blocks = [];
+  for (const { name, installedFrom } of blocksToCheck) {
+    blocks.push(checkBlock(cwd, name, registry, toolingVersion, installedFrom, verbose));
+  }
+  const currentCount = blocks.filter((b) => b.status === "current").length;
+  const driftedCount = blocks.filter((b) => b.status === "drifted").length;
+  const missingCount = blocks.filter((b) => b.status === "missing").length;
+  return Result.ok({
+    blocks,
+    totalChecked: blocks.length,
+    currentCount,
+    driftedCount,
+    missingCount
+  });
+}
+async function printCheckResults(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    await output(result, { mode: structuredMode });
+    return;
+  }
+  const theme = createTheme();
+  const lines = [];
+  lines.push("");
+  lines.push("Outfitter Check");
+  lines.push("=".repeat(50));
+  lines.push("");
+  for (const block of result.blocks) {
+    let statusIcon;
+    switch (block.status) {
+      case "current":
+        statusIcon = theme.success("[PASS]");
+        break;
+      case "drifted":
+        statusIcon = theme.error("[DRIFT]");
+        break;
+      case "missing":
+        statusIcon = theme.warning("[MISSING]");
+        break;
+      default:
+        statusIcon = "[?]";
+    }
+    const versionInfo = block.installedFrom ? ` (installed from ${block.installedFrom})` : "";
+    lines.push(`${statusIcon} ${block.name}${versionInfo}`);
+    if (options?.verbose && block.driftedFiles) {
+      for (const file of block.driftedFiles) {
+        const reason = file.reason === "missing" ? "file missing" : "modified";
+        lines.push(`       ${theme.muted(`${file.path}: ${reason}`)}`);
+      }
+    }
+  }
+  lines.push("");
+  lines.push("=".repeat(50));
+  const summaryColor = result.driftedCount === 0 && result.missingCount === 0 ? theme.success : theme.error;
+  lines.push(summaryColor(`${result.currentCount}/${result.totalChecked} blocks current`));
+  if (result.driftedCount > 0) {
+    lines.push(theme.muted(`${result.driftedCount} block(s) have drifted`));
+  }
+  if (result.missingCount > 0) {
+    lines.push(theme.muted(`${result.missingCount} block(s) have missing files`));
+  }
+  if (result.driftedCount > 0 || result.missingCount > 0) {
+    lines.push("");
+    lines.push(theme.muted("Run 'outfitter add <block> --force' to restore registry defaults."));
+  }
+  await output(lines, { mode: "human" });
+}
+
+export { CheckError, runCheck, printCheckResults };

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-2ngep1h2.d.ts

@@ -0,0 +1,5 @@
+import { CreatePresetDefinition, CreatePresetId } from "./outfitter-e2zz5wv7";
+declare const CREATE_PRESETS: Readonly<Record<CreatePresetId, CreatePresetDefinition>>;
+declare const CREATE_PRESET_IDS: CreatePresetId[];
+declare function getCreatePreset(id: string): CreatePresetDefinition | undefined;
+export { CREATE_PRESETS, CREATE_PRESET_IDS, getCreatePreset };

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

@@ -0,0 +1,95 @@
+// @bun
+import {
+  ScaffoldError
+} from "./outfitter-8y2dfx6n.js";
+
+// apps/outfitter/src/engine/workspace.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { Result } from "@outfitter/contracts";
+function buildWorkspaceRootPackageJson(workspaceName) {
+  const workspacePackage = {
+    name: workspaceName,
+    private: true,
+    version: "0.1.0",
+    workspaces: ["apps/*", "packages/*"],
+    scripts: {
+      build: "bun run --filter '*' build",
+      dev: "bun run --filter '*' dev",
+      test: "bun run --filter '*' test",
+      typecheck: "bun run --filter '*' typecheck",
+      lint: "bun run --filter '*' lint",
+      "lint:fix": "bun run --filter '*' lint:fix",
+      format: "bun run --filter '*' format"
+    }
+  };
+  return `${JSON.stringify(workspacePackage, null, 2)}
+`;
+}
+function scaffoldWorkspaceRoot(rootDir, workspaceName, force) {
+  const packageJsonPath = join(rootDir, "package.json");
+  if (existsSync(packageJsonPath) && !force) {
+    return Result.err(new ScaffoldError(`Directory '${rootDir}' already has a package.json. Use --force to overwrite.`));
+  }
+  try {
+    if (!existsSync(rootDir)) {
+      mkdirSync(rootDir, { recursive: true });
+    }
+    mkdirSync(join(rootDir, "apps"), { recursive: true });
+    mkdirSync(join(rootDir, "packages"), { recursive: true });
+    writeFileSync(packageJsonPath, buildWorkspaceRootPackageJson(workspaceName), "utf-8");
+    const gitignorePath = join(rootDir, ".gitignore");
+    if (force || !existsSync(gitignorePath)) {
+      writeFileSync(gitignorePath, `node_modules
+**/dist
+`, "utf-8");
+    }
+    return Result.ok(undefined);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new ScaffoldError(`Failed to scaffold workspace root: ${message}`));
+  }
+}
+function hasWorkspacesField(pkg) {
+  const workspaces = pkg.workspaces;
+  if (Array.isArray(workspaces) && workspaces.length > 0) {
+    return true;
+  }
+  if (workspaces && typeof workspaces === "object" && !Array.isArray(workspaces)) {
+    const packages = workspaces.packages;
+    if (Array.isArray(packages) && packages.length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function detectWorkspaceRoot(cwd) {
+  let current = resolve(cwd);
+  const root = resolve("/");
+  while (true) {
+    if (existsSync(join(current, "pnpm-workspace.yaml"))) {
+      return Result.ok(current);
+    }
+    const pkgPath = join(current, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const raw = readFileSync(pkgPath, "utf-8");
+        const pkg = JSON.parse(raw);
+        if (hasWorkspacesField(pkg)) {
+          return Result.ok(current);
+        }
+      } catch {}
+    }
+    if (current === root) {
+      break;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return Result.ok(null);
+}
+
+export { buildWorkspaceRootPackageJson, scaffoldWorkspaceRoot, detectWorkspaceRoot };

package/dist/shared/outfitter-33w361tc.d.ts

@@ -0,0 +1,18 @@
+import { TargetCategory, TargetDefinition, TargetId, TargetScope, TargetStatus } from "./outfitter-k56rmt24";
+import { NotFoundError, Result, ValidationError } from "@outfitter/contracts";
+declare const TARGET_REGISTRY: ReadonlyMap<TargetId, TargetDefinition>;
+declare const TARGET_IDS: readonly TargetId[];
+declare const READY_TARGET_IDS: readonly TargetId[];
+declare const INIT_TARGET_IDS: readonly TargetId[];
+declare const SCAFFOLD_TARGET_IDS: readonly TargetId[];
+declare function getTarget(id: string): Result<TargetDefinition, NotFoundError>;
+declare function getReadyTarget(id: string): Result<TargetDefinition, NotFoundError | ValidationError>;
+declare function getInitTarget(id: string): Result<TargetDefinition, NotFoundError | ValidationError>;
+declare function getScaffoldTarget(id: string): Result<TargetDefinition, NotFoundError | ValidationError>;
+declare function resolvePlacement(target: TargetDefinition): "apps" | "packages";
+declare function listTargets(filter?: {
+	readonly status?: TargetStatus;
+	readonly scope?: TargetScope;
+	readonly category?: TargetCategory;
+}): readonly TargetDefinition[];
+export { TARGET_REGISTRY, TARGET_IDS, READY_TARGET_IDS, INIT_TARGET_IDS, SCAFFOLD_TARGET_IDS, getTarget, getReadyTarget, getInitTarget, getScaffoldTarget, resolvePlacement, listTargets };

package/dist/shared/outfitter-344t1r38.js

@@ -0,0 +1 @@
+// @bun

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

@@ -0,0 +1,25 @@
+import { OperationCollector } from "./outfitter-amc4jbs1";
+import { Result } from "@outfitter/contracts";
+type ScaffoldOrigin = "init" | "scaffold";
+interface PostScaffoldOptions {
+	readonly rootDir: string;
+	readonly projectDir: string;
+	readonly origin: ScaffoldOrigin;
+	readonly target: string;
+	readonly structure: "single" | "workspace";
+	readonly skipInstall: boolean;
+	readonly skipGit: boolean;
+	readonly skipCommit: boolean;
+	readonly dryRun: boolean;
+	readonly installTimeoutMs: number;
+}
+interface PostScaffoldResult {
+	readonly installResult: "success" | "failed" | "skipped";
+	readonly installError?: string | undefined;
+	readonly gitInitResult: "success" | "failed" | "skipped" | "already-repo";
+	readonly gitCommitResult: "success" | "failed" | "skipped";
+	readonly gitError?: string | undefined;
+	readonly nextSteps: readonly string[];
+}
+declare function runPostScaffold(options: PostScaffoldOptions, collector?: OperationCollector): Promise<Result<PostScaffoldResult, never>>;
+export { PostScaffoldOptions, PostScaffoldResult, runPostScaffold };