outfitter 0.2.7 → 0.3.3

package/dist/shared/outfitter-tavatb5p.js

@@ -0,0 +1,166 @@
+// @bun
+import {
+  deriveBinName,
+  deriveProjectName,
+  executePlan,
+  isPathWithin,
+  resolveAuthor,
+  resolveYear,
+  scaffoldWorkspaceRoot,
+  validateProjectDirectoryName
+} from "./outfitter-q1g58t85.js";
+import {
+  runPostScaffold
+} from "./outfitter-4s9meh3j.js";
+import {
+  OperationCollector
+} from "./outfitter-1h7k8xxt.js";
+
+// apps/outfitter/src/commands/init-execution.ts
+import { existsSync } from "fs";
+import { basename, join, resolve } from "path";
+import { Result } from "@outfitter/contracts";
+function toExecutionErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "Unknown init error";
+}
+function buildInitPlan(target, input, projectDir, resolvedBinName) {
+  const blocks = input.includeTooling ? input.blocksOverride ?? [...target.defaultBlocks] : [];
+  return {
+    values: {
+      name: deriveProjectName(input.packageName),
+      projectName: deriveProjectName(input.packageName),
+      packageName: input.packageName,
+      binName: resolvedBinName,
+      version: "0.1.0",
+      description: "A new project created with Outfitter",
+      author: resolveAuthor(),
+      year: resolveYear()
+    },
+    changes: [
+      {
+        type: "copy-preset",
+        preset: target.presetDir,
+        targetDir: projectDir,
+        includeTooling: input.includeTooling,
+        overlayBaseTemplate: true
+      },
+      { type: "inject-shared-config" },
+      ...input.local ? [{ type: "rewrite-local-dependencies", mode: "workspace" }] : [],
+      ...blocks.length > 0 ? [{ type: "add-blocks", blocks }] : []
+    ]
+  };
+}
+async function executeInitPipeline(input, target, options) {
+  const projectName = deriveProjectName(input.packageName);
+  if (input.structure === "workspace") {
+    const invalidProjectName = validateProjectDirectoryName(projectName);
+    if (invalidProjectName) {
+      return Result.err(`Invalid workspace project name '${projectName}': ${invalidProjectName}`);
+    }
+  }
+  const collector = options.dryRun ? new OperationCollector : undefined;
+  const projectBaseDir = resolve(input.rootDir, target.placement);
+  const resolvedProjectDir = resolve(projectBaseDir, projectName);
+  if (input.structure === "workspace" && !isPathWithin(projectBaseDir, resolvedProjectDir)) {
+    return Result.err(`Invalid workspace project name '${projectName}': path escapes '${projectBaseDir}'`);
+  }
+  const projectDir = input.structure === "workspace" ? resolvedProjectDir : input.rootDir;
+  if (input.structure === "single") {
+    if (existsSync(join(input.rootDir, "package.json")) && !options.force) {
+      return Result.err(`Directory '${input.rootDir}' already has a package.json. Use --force to overwrite, or use 'outfitter add' for existing projects.`);
+    }
+  } else {
+    const workspaceName = input.workspaceName ?? basename(input.rootDir);
+    const workspacePackageJsonPath = join(input.rootDir, "package.json");
+    if (options.dryRun) {
+      if (existsSync(workspacePackageJsonPath) && !options.force) {
+        return Result.err(`Directory '${input.rootDir}' already has a package.json. Use --force to overwrite.`);
+      }
+      collector?.add({
+        type: "dir-create",
+        path: join(input.rootDir, "apps")
+      });
+      collector?.add({
+        type: "dir-create",
+        path: join(input.rootDir, "packages")
+      });
+      collector?.add(existsSync(workspacePackageJsonPath) ? {
+        type: "file-overwrite",
+        path: workspacePackageJsonPath,
+        source: "generated"
+      } : {
+        type: "file-create",
+        path: workspacePackageJsonPath,
+        source: "generated"
+      });
+      const readmePath = join(input.rootDir, "README.md");
+      if (options.force || !existsSync(readmePath)) {
+        collector?.add(existsSync(readmePath) ? {
+          type: "file-overwrite",
+          path: readmePath,
+          source: "generated"
+        } : {
+          type: "file-create",
+          path: readmePath,
+          source: "generated"
+        });
+      }
+      const gitignorePath = join(input.rootDir, ".gitignore");
+      if (options.force || !existsSync(gitignorePath)) {
+        collector?.add(existsSync(gitignorePath) ? {
+          type: "file-overwrite",
+          path: gitignorePath,
+          source: "generated"
+        } : {
+          type: "file-create",
+          path: gitignorePath,
+          source: "generated"
+        });
+      }
+    } else {
+      const workspaceResult = scaffoldWorkspaceRoot(input.rootDir, workspaceName, options.force);
+      if (workspaceResult.isErr()) {
+        return Result.err(workspaceResult.error.message);
+      }
+    }
+  }
+  const resolvedBinName = input.binName ?? deriveBinName(deriveProjectName(input.packageName));
+  const plan = buildInitPlan(target, input, projectDir, resolvedBinName);
+  const executeResult = await executePlan(plan, {
+    force: options.force,
+    ...collector ? { collector } : {}
+  });
+  if (executeResult.isErr()) {
+    return Result.err(toExecutionErrorMessage(executeResult.error));
+  }
+  const postScaffoldResult = await runPostScaffold({
+    rootDir: input.rootDir,
+    projectDir,
+    origin: "init",
+    target: input.preset,
+    structure: input.structure,
+    skipInstall: options.skipInstall,
+    skipGit: options.skipGit,
+    skipCommit: options.skipCommit,
+    dryRun: options.dryRun,
+    installTimeoutMs: options.installTimeout
+  }, collector);
+  if (postScaffoldResult.isErr()) {
+    return Result.err("Post-scaffold step failed");
+  }
+  return Result.ok({
+    structure: input.structure,
+    rootDir: input.rootDir,
+    projectDir,
+    preset: input.preset,
+    packageName: input.packageName,
+    blocksAdded: executeResult.value.blocksAdded,
+    postScaffold: postScaffoldResult.value,
+    ...collector ? { dryRunPlan: collector.toJSON() } : {}
+  });
+}
+
+export { executeInitPipeline };

package/dist/shared/outfitter-tqznjgbm.js

@@ -0,0 +1,44 @@
+// @bun
+import {
+  resolvePresetDependencyVersions
+} from "./outfitter-x39awx8g.js";
+
+// apps/outfitter/src/commands/shared-deps.ts
+import { getResolvedVersions } from "@outfitter/presets";
+var { all: resolvedVersions } = getResolvedVersions();
+function requireVersion(name) {
+  const version = resolvedVersions[name];
+  if (!version) {
+    throw new Error(`Missing resolved version for "${name}" in @outfitter/presets`);
+  }
+  return version;
+}
+function requireInternalVersion(name) {
+  const versions = resolvePresetDependencyVersions();
+  const version = versions.internal[name];
+  if (!version) {
+    throw new Error(`Missing internal version for "${name}" \u2014 not found in workspace packages or outfitter's own dependencies`);
+  }
+  return version;
+}
+var SHARED_DEV_DEPS = {
+  "@outfitter/oxlint-plugin": requireInternalVersion("@outfitter/oxlint-plugin"),
+  "@outfitter/tooling": requireInternalVersion("@outfitter/tooling"),
+  "@types/bun": requireVersion("@types/bun"),
+  lefthook: requireVersion("lefthook"),
+  oxfmt: requireVersion("oxfmt"),
+  oxlint: requireVersion("oxlint"),
+  typescript: requireVersion("typescript"),
+  ultracite: requireVersion("ultracite")
+};
+var SHARED_SCRIPTS = {
+  check: "ultracite check",
+  "clean:artifacts": "rm -rf dist .turbo",
+  "verify:ci": "bun run typecheck && bun run check && bun run build && bun run test",
+  lint: "oxlint .",
+  "lint:fix": "oxlint --fix .",
+  format: "oxfmt --write .",
+  typecheck: "tsc --noEmit"
+};
+
+export { SHARED_DEV_DEPS, SHARED_SCRIPTS };

package/dist/shared/{outfitter-yraebrmw.d.ts → outfitter-wcrp7d7m.d.ts}

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

package/dist/shared/outfitter-wkt0a0ra.js

@@ -0,0 +1,67 @@
+// @bun
+import {
+  outputModeSchema,
+  toActionInternalErrorFromUnknown
+} from "./outfitter-7n7vsz95.js";
+import {
+  runDemo
+} from "./outfitter-ksyvwmb5.js";
+import {
+  resolveOutputModeFromContext
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/actions/demo.ts
+import { defineAction, Result } from "@outfitter/contracts";
+import { z } from "zod";
+var demoInputSchema = z.object({
+  section: z.string().optional(),
+  list: z.boolean().optional(),
+  animate: z.boolean().optional(),
+  outputMode: outputModeSchema
+});
+var demoAction = defineAction({
+  id: "demo",
+  description: "Run the CLI demo app",
+  surfaces: ["cli"],
+  input: demoInputSchema,
+  cli: {
+    command: "demo [section]",
+    description: "Run the CLI demo app",
+    options: [
+      {
+        flags: "-l, --list",
+        description: "List available demo sections",
+        defaultValue: false
+      },
+      {
+        flags: "-a, --animate",
+        description: "Run animated demo (spinners only)",
+        defaultValue: false
+      }
+    ],
+    mapInput: (context) => {
+      const outputMode = resolveOutputModeFromContext(context.flags);
+      const section = context.args[0];
+      return {
+        ...section !== undefined ? { section } : {},
+        list: Boolean(context.flags["list"]),
+        animate: Boolean(context.flags["animate"]),
+        outputMode
+      };
+    }
+  },
+  handler: async (input) => {
+    const { outputMode, ...demoInput } = input;
+    try {
+      const result = await runDemo({ ...demoInput, outputMode });
+      if (result.exitCode !== 0) {
+        process.exit(result.exitCode);
+      }
+      return Result.ok(result);
+    } catch (error) {
+      return Result.err(toActionInternalErrorFromUnknown("demo", error, "Failed to run demo"));
+    }
+  }
+});
+
+export { demoAction };

package/dist/shared/{outfitter-ha89qf8q.js → outfitter-wrcqq29p.js}

@@ -2,11 +2,11 @@
 import {
   SHARED_DEV_DEPS,
   SHARED_SCRIPTS
-} from "./outfitter-20f6a2n4.js";
+} from "./outfitter-tqznjgbm.js";
 import {
   applyResolvedDependencyVersions,
-  resolveTemplateDependencyVersions
-} from "./outfitter-m44n0qzw.js";
+  resolvePresetDependencyVersions
+} from "./outfitter-x39awx8g.js";
 import {
   getWorkspacePatterns
 } from "./outfitter-1fy7byz5.js";
@@ -76,7 +76,7 @@ function injectSharedConfig(targetDir) {
   try {
     const content = readFileSync(packageJsonPath, "utf-8");
     const parsed = JSON.parse(content);
-    const dependencyVersions = resolveTemplateDependencyVersions();
+    const dependencyVersions = resolvePresetDependencyVersions();
     applyResolvedDependencyVersions(parsed, dependencyVersions);
     const existingDevDeps = parsed["devDependencies"] ?? {};
     parsed["devDependencies"] = { ...SHARED_DEV_DEPS, ...existingDevDeps };

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

@@ -0,0 +1,43 @@
+import { CliOutputMode } from "./outfitter-a79xrm12.js";
+import { InternalError, NotFoundError, Result } from "@outfitter/contracts";
+/** Validated input for the docs.show action handler. */
+interface DocsShowInput {
+	readonly cwd: string;
+	readonly id: string;
+	readonly jq?: string | undefined;
+	readonly outputMode: CliOutputMode;
+}
+/** Output shape for the docs.show action. */
+interface DocsShowOutput {
+	readonly content: string;
+	readonly entry: {
+		readonly id: string;
+		readonly kind: string;
+		readonly outputPath: string;
+		readonly package?: string;
+		readonly sourcePath: string;
+		readonly tags: string[];
+		readonly title: string;
+	};
+}
+/**
+* Show a specific documentation entry and its file content.
+*
+* Generates the docs map for the workspace, looks up the entry by ID,
+* and reads the source file content.
+*
+* @param input - Validated action input
+* @returns Result containing the entry metadata and content, or an error
+*/
+declare function runDocsShow(input: DocsShowInput): Promise<Result<DocsShowOutput, InternalError | NotFoundError>>;
+/**
+* Print docs show results in the appropriate output format.
+*
+* @param result - The docs show output
+* @param options - Output formatting options
+*/
+declare function printDocsShowResults(result: DocsShowOutput, options?: {
+	mode?: CliOutputMode;
+	jq?: string | undefined;
+}): Promise<void>;
+export { DocsShowInput, DocsShowOutput, runDocsShow, printDocsShowResults };

package/dist/shared/outfitter-x0vpb7tj.js

@@ -0,0 +1,126 @@
+// @bun
+import {
+  readMigrationDocsWithMetadata
+} from "./outfitter-fx1m251y.js";
+
+// apps/outfitter/src/commands/upgrade-codemods.ts
+import { existsSync } from "fs";
+import { isAbsolute, join, relative, resolve } from "path";
+import { InternalError, Result } from "@outfitter/contracts";
+var CODEMOD_PATHS = ["plugins/outfitter/shared/codemods"];
+function findCodemodsDir(cwd, binaryDir) {
+  for (const relativePath of CODEMOD_PATHS) {
+    const dir = join(cwd, relativePath);
+    if (existsSync(dir))
+      return dir;
+  }
+  let current = resolve(cwd);
+  const root = resolve("/");
+  while (current !== root) {
+    const parent = resolve(current, "..");
+    if (parent === current)
+      break;
+    current = parent;
+    for (const relativePath of CODEMOD_PATHS) {
+      const dir = join(current, relativePath);
+      if (existsSync(dir))
+        return dir;
+    }
+  }
+  const resolvedBinaryDir = binaryDir ?? resolve(import.meta.dir, "../../../..");
+  for (const relativePath of CODEMOD_PATHS) {
+    const dir = join(resolvedBinaryDir, relativePath);
+    if (existsSync(dir))
+      return dir;
+  }
+  return null;
+}
+function discoverCodemods(migrationsDir, codemodsDir, shortName, fromVersion, toVersion) {
+  const resolvedCodemodsDir = resolve(codemodsDir);
+  const docs = (() => {
+    try {
+      return readMigrationDocsWithMetadata(migrationsDir, shortName, fromVersion, toVersion);
+    } catch {
+      return [];
+    }
+  })();
+  const seen = new Set;
+  const codemods = [];
+  for (const doc of docs) {
+    if (!doc.frontmatter.changes)
+      continue;
+    for (const change of doc.frontmatter.changes) {
+      if (!change.codemod)
+        continue;
+      if (seen.has(change.codemod))
+        continue;
+      seen.add(change.codemod);
+      const absolutePath = resolveCodemodPath(resolvedCodemodsDir, change.codemod);
+      if (absolutePath === null)
+        continue;
+      if (!existsSync(absolutePath))
+        continue;
+      codemods.push({
+        relativePath: change.codemod,
+        absolutePath
+      });
+    }
+  }
+  return codemods;
+}
+function resolveCodemodPath(codemodsDir, relativePath) {
+  if (relativePath.trim().length === 0) {
+    return null;
+  }
+  if (isAbsolute(relativePath)) {
+    return null;
+  }
+  const resolvedPath = resolve(codemodsDir, relativePath);
+  const relPath = relative(codemodsDir, resolvedPath);
+  if (relPath === "" || relPath.startsWith("..") || isAbsolute(relPath)) {
+    return null;
+  }
+  return resolvedPath;
+}
+async function runCodemod(codemodPath, targetDir, dryRun) {
+  let mod;
+  try {
+    mod = await import(codemodPath);
+  } catch (error) {
+    return Result.err(InternalError.create("Failed to load codemod", {
+      codemodPath,
+      error: error instanceof Error ? error.message : String(error)
+    }));
+  }
+  if (typeof mod["transform"] !== "function") {
+    return Result.err(InternalError.create(`Codemod has no transform export: ${codemodPath}`, {
+      codemodPath
+    }));
+  }
+  const transform = mod["transform"];
+  try {
+    const result = await transform({ targetDir, dryRun });
+    if (!isCodemodResult(result)) {
+      return Result.err(InternalError.create("Codemod returned invalid result shape", {
+        codemodPath
+      }));
+    }
+    return Result.ok(result);
+  } catch (error) {
+    return Result.err(InternalError.create("Codemod execution failed", {
+      codemodPath,
+      error: error instanceof Error ? error.message : String(error)
+    }));
+  }
+}
+function isCodemodResult(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const candidate = value;
+  return isStringArray(candidate["changedFiles"]) && isStringArray(candidate["skippedFiles"]) && isStringArray(candidate["errors"]);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
+export { findCodemodsDir, discoverCodemods, runCodemod };

package/dist/shared/{outfitter-m44n0qzw.js → outfitter-x39awx8g.js}

@@ -3,6 +3,7 @@
 import { existsSync, readdirSync, readFileSync } from "fs";
 import { dirname, join, resolve } from "path";
 import { fileURLToPath } from "url";
+import { getResolvedVersions } from "@outfitter/presets";
 var DEPENDENCY_SECTIONS = [
   "dependencies",
   "devDependencies",
@@ -45,7 +46,7 @@ function findOutfitterPackageRoot() {
   }
   throw new Error(`Unable to find outfitter package root (walked 10 levels up from ${dirname(fileURLToPath(import.meta.url))}). ` + "Ensure this module is running from within the outfitter package tree.");
 }
-function collectDependencyRangesFromPackageJson(packageJson) {
+function collectOutfitterDepsFromPackageJson(packageJson) {
   const collected = {};
   for (const section of DEPENDENCY_SECTIONS) {
     const sectionValue = packageJson[section];
@@ -97,39 +98,23 @@ function collectWorkspacePackageRanges(packageRoot) {
   }
   return collected;
 }
-function loadTemplateVersionManifest(packageRoot) {
-  const manifestPath = join(packageRoot, "template-versions.json");
-  const parsed = readJsonFile(manifestPath);
-  if (!isRecord(parsed)) {
-    throw new Error("template-versions.json must be a JSON object");
-  }
-  const internalDependencies = parsed["internalDependencies"];
-  const externalDependencies = parsed["externalDependencies"];
-  if (!(isRecord(internalDependencies) && isRecord(externalDependencies))) {
-    throw new Error("template-versions.json must include internalDependencies and externalDependencies objects");
-  }
-  return {
-    internalDependencies: Object.fromEntries(Object.entries(internalDependencies).filter(([, value]) => typeof value === "string")),
-    externalDependencies: Object.fromEntries(Object.entries(externalDependencies).filter(([, value]) => typeof value === "string"))
-  };
-}
-function resolveTemplateDependencyVersions() {
+function resolvePresetDependencyVersions() {
   if (cachedResolvedVersions) {
     return cachedResolvedVersions;
   }
+  const { all: presetsVersions } = getResolvedVersions();
   const packageRoot = findOutfitterPackageRoot();
-  const manifest = loadTemplateVersionManifest(packageRoot);
   const packageJsonPath = join(packageRoot, "package.json");
   const raw = existsSync(packageJsonPath) ? readJsonFile(packageJsonPath) : undefined;
-  const fromOutfitterPackage = raw !== undefined && isRecord(raw) ? collectDependencyRangesFromPackageJson(raw) : {};
+  const fromOutfitterPackage = raw !== undefined && isRecord(raw) ? collectOutfitterDepsFromPackageJson(raw) : {};
   const fromWorkspacePackages = collectWorkspacePackageRanges(packageRoot);
-  const internal = {};
-  for (const [name, fallbackRange] of Object.entries(manifest.internalDependencies)) {
-    internal[name] = fromOutfitterPackage[name] ?? fromWorkspacePackages[name] ?? fallbackRange;
-  }
+  const internal = {
+    ...fromOutfitterPackage,
+    ...fromWorkspacePackages
+  };
   cachedResolvedVersions = {
     internal,
-    external: { ...manifest.externalDependencies }
+    external: { ...presetsVersions }
   };
   return cachedResolvedVersions;
 }
@@ -158,4 +143,4 @@ function applyResolvedDependencyVersions(parsedPackageJson, versions) {
   }
 }
 
-export { clearResolvedVersionsCache, resolveTemplateDependencyVersions, applyResolvedDependencyVersions };
+export { clearResolvedVersionsCache, resolvePresetDependencyVersions, applyResolvedDependencyVersions };