outfitter 0.2.4 → 0.2.6

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

@@ -0,0 +1,5 @@
+import { ScaffoldError } from "./outfitter-qfh36ddg";
+import { Result } from "@outfitter/contracts";
+declare function injectSharedConfig(targetDir: string): Result<void, ScaffoldError>;
+declare function rewriteLocalDependencies(targetDir: string): Result<void, ScaffoldError>;
+export { injectSharedConfig, rewriteLocalDependencies };

package/dist/shared/outfitter-ttjr95y9.js

@@ -0,0 +1,98 @@
+// @bun
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/engine/render-plan.ts
+import { relative } from "path";
+import { output } from "@outfitter/cli";
+async function renderOperationPlan(collector, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    await output(collector.toJSON(), { mode: structuredMode });
+    return;
+  }
+  const rootDir = options?.rootDir ?? process.cwd();
+  const operations = collector.getOperations();
+  const lines = ["[dry-run] Operation plan:", ""];
+  const fileCreates = operations.filter((op) => op.type === "file-create");
+  const fileOverwrites = operations.filter((op) => op.type === "file-overwrite");
+  const fileSkips = operations.filter((op) => op.type === "file-skip");
+  const dirCreates = operations.filter((op) => op.type === "dir-create");
+  const blockAdds = operations.filter((op) => op.type === "block-add");
+  const depAdds = operations.filter((op) => op.type === "dependency-add");
+  const configInjects = operations.filter((op) => op.type === "config-inject");
+  const installOps = operations.filter((op) => op.type === "install");
+  const gitOps = operations.filter((op) => op.type === "git");
+  if (fileCreates.length > 0) {
+    lines.push(`Create ${fileCreates.length} file(s):`);
+    for (const op of fileCreates) {
+      lines.push(`  + ${relative(rootDir, op.path)}`);
+    }
+    lines.push("");
+  }
+  if (fileOverwrites.length > 0) {
+    lines.push(`Overwrite ${fileOverwrites.length} file(s):`);
+    for (const op of fileOverwrites) {
+      lines.push(`  ~ ${relative(rootDir, op.path)}`);
+    }
+    lines.push("");
+  }
+  if (fileSkips.length > 0) {
+    lines.push(`Skip ${fileSkips.length} file(s):`);
+    for (const op of fileSkips) {
+      lines.push(`  - ${relative(rootDir, op.path)} (${op.reason})`);
+    }
+    lines.push("");
+  }
+  if (dirCreates.length > 0) {
+    lines.push(`Create ${dirCreates.length} directory(ies):`);
+    for (const op of dirCreates) {
+      lines.push(`  + ${relative(rootDir, op.path)}/`);
+    }
+    lines.push("");
+  }
+  if (depAdds.length > 0) {
+    lines.push(`Add ${depAdds.length} dependency(ies):`);
+    for (const dep of depAdds) {
+      const suffix = dep.section === "devDependencies" ? " (dev)" : "";
+      lines.push(`  + ${dep.name}@${dep.version}${suffix}`);
+    }
+    lines.push("");
+  }
+  if (blockAdds.length > 0) {
+    lines.push(`Add ${blockAdds.length} block(s):`);
+    for (const block of blockAdds) {
+      lines.push(`  + ${block.name}`);
+    }
+    lines.push("");
+  }
+  if (configInjects.length > 0) {
+    lines.push(`Config injections (${configInjects.length}):`);
+    for (const op of configInjects) {
+      lines.push(`  ~ ${relative(rootDir, op.target)} (${op.description})`);
+    }
+    lines.push("");
+  }
+  if (installOps.length > 0 || gitOps.length > 0) {
+    lines.push("Post-scaffold:");
+    for (const op of installOps) {
+      lines.push(`  $ ${op.command}`);
+    }
+    for (const op of gitOps) {
+      if (op.action === "init") {
+        lines.push("  $ git init");
+      } else if (op.action === "add-all") {
+        lines.push("  $ git add .");
+      } else {
+        lines.push(`  $ git commit -m "${op.message ?? ""}"`);
+      }
+    }
+    lines.push("");
+  }
+  const summary = collector.countByType();
+  lines.push(`Total operations: ${Object.values(summary).reduce((a, b) => a + b, 0)}`);
+  await output(lines, { mode: "human" });
+}
+
+export { renderOperationPlan };

package/dist/shared/outfitter-vh4xgb93.js

@@ -0,0 +1,35 @@
+// @bun
+// apps/outfitter/src/create/presets.ts
+var CREATE_PRESETS = {
+  basic: {
+    id: "basic",
+    template: "basic",
+    summary: "Minimal Bun + TypeScript project.",
+    defaultBlocks: ["scaffolding"]
+  },
+  cli: {
+    id: "cli",
+    template: "cli",
+    summary: "CLI starter with Outfitter command ergonomics.",
+    defaultBlocks: ["scaffolding"]
+  },
+  daemon: {
+    id: "daemon",
+    template: "daemon",
+    summary: "Daemon + control CLI starter.",
+    defaultBlocks: ["scaffolding"]
+  },
+  mcp: {
+    id: "mcp",
+    template: "mcp",
+    summary: "MCP server starter.",
+    defaultBlocks: ["scaffolding"]
+  }
+};
+var CREATE_PRESET_IDS = Object.keys(CREATE_PRESETS);
+function getCreatePreset(id) {
+  const presets = CREATE_PRESETS;
+  return presets[id];
+}
+
+export { CREATE_PRESETS, CREATE_PRESET_IDS, getCreatePreset };

package/dist/shared/outfitter-yvksv5qb.js

@@ -0,0 +1,322 @@
+// @bun
+// apps/outfitter/src/commands/upgrade-workspace.ts
+import { existsSync, readFileSync } from "fs";
+import { basename, dirname, join, resolve } from "path";
+import { InternalError, Result } from "@outfitter/contracts";
+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);
+}
+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 resolveWorkspacePatterns(pkg) {
+  const workspaces = pkg.workspaces;
+  let patterns;
+  if (Array.isArray(workspaces)) {
+    patterns = workspaces;
+  } else if (workspaces && typeof workspaces === "object" && !Array.isArray(workspaces)) {
+    const packages = workspaces.packages;
+    if (Array.isArray(packages)) {
+      patterns = packages;
+    } else {
+      return [];
+    }
+  } else {
+    return [];
+  }
+  return patterns.filter((p) => typeof p === "string").map(normalizeWorkspacePattern);
+}
+function normalizeWorkspacePattern(pattern) {
+  let value = pattern.trim().replaceAll("\\", "/");
+  if (value.length === 0)
+    return value;
+  if (value.endsWith("/")) {
+    value = value.slice(0, -1);
+  }
+  if (value.endsWith("package.json")) {
+    return value;
+  }
+  return `${value}/package.json`;
+}
+function collectWorkspaceManifests(rootDir) {
+  const resolvedRoot = resolve(rootDir);
+  const rootPackageJson = join(resolvedRoot, "package.json");
+  if (!existsSync(rootPackageJson)) {
+    return Result.err(InternalError.create("No package.json found at workspace root", {
+      rootDir: resolvedRoot
+    }));
+  }
+  let pkg;
+  try {
+    const raw = readFileSync(rootPackageJson, "utf-8");
+    pkg = JSON.parse(raw);
+  } catch {
+    return Result.err(InternalError.create("Invalid JSON in root package.json", {
+      rootDir: resolvedRoot
+    }));
+  }
+  const workspacePatterns = resolveWorkspacePatterns(pkg);
+  const files = new Set([rootPackageJson]);
+  for (const pattern of workspacePatterns) {
+    if (pattern.length === 0)
+      continue;
+    const glob = new Bun.Glob(pattern);
+    for (const entry of glob.scanSync({ cwd: resolvedRoot })) {
+      const absolute = resolve(resolvedRoot, entry);
+      if (existsSync(absolute) && basename(absolute) === "package.json") {
+        files.add(absolute);
+      }
+    }
+  }
+  return Result.ok(Array.from(files).sort((a, b) => a.localeCompare(b)));
+}
+function extractOutfitterDeps(manifestPath) {
+  let pkg;
+  try {
+    const raw = readFileSync(manifestPath, "utf-8");
+    pkg = JSON.parse(raw);
+  } catch {
+    return Result.err(InternalError.create("Failed to parse package.json", {
+      path: manifestPath
+    }));
+  }
+  const deps = {
+    ...pkg.dependencies ?? {},
+    ...pkg.devDependencies ?? {}
+  };
+  const packages = [];
+  for (const [name, version] of Object.entries(deps)) {
+    if (!name.startsWith("@outfitter/"))
+      continue;
+    if (version.startsWith("workspace:")) {
+      const wsVersion = version.slice("workspace:".length);
+      if (wsVersion === "*" || wsVersion === "~" || wsVersion === "^") {
+        continue;
+      }
+      const wsClean = wsVersion.replace(/^[\^~>=<]+/, "");
+      try {
+        if (!Bun.semver.satisfies(wsClean, "*"))
+          continue;
+      } catch {
+        continue;
+      }
+      packages.push({ name, version: wsClean });
+      continue;
+    }
+    const cleaned = version.replace(/^[\^~>=<]+/, "");
+    try {
+      if (!Bun.semver.satisfies(cleaned, "*"))
+        continue;
+    } catch {
+      continue;
+    }
+    packages.push({ name, version: cleaned });
+  }
+  return Result.ok(packages);
+}
+function getInstalledPackagesFromWorkspace(rootDir) {
+  const resolvedRoot = resolve(rootDir);
+  const wsRootResult = detectWorkspaceRoot(resolvedRoot);
+  if (wsRootResult.isErr())
+    return wsRootResult;
+  const effectiveRoot = wsRootResult.value ?? resolvedRoot;
+  let manifestPaths;
+  if (wsRootResult.value !== null) {
+    const manifestsResult = collectWorkspaceManifests(effectiveRoot);
+    if (manifestsResult.isErr())
+      return manifestsResult;
+    manifestPaths = manifestsResult.value;
+  } else {
+    const rootPkg = join(resolvedRoot, "package.json");
+    if (!existsSync(rootPkg)) {
+      return Result.err(InternalError.create("No package.json found", { cwd: resolvedRoot }));
+    }
+    manifestPaths = [rootPkg];
+  }
+  const packageVersionMap = new Map;
+  const manifestsByPackage = new Map;
+  for (const manifestPath of manifestPaths) {
+    const depsResult = extractOutfitterDeps(manifestPath);
+    if (depsResult.isErr())
+      return depsResult;
+    const deps = depsResult.value;
+    for (const dep of deps) {
+      let versionMap = packageVersionMap.get(dep.name);
+      if (!versionMap) {
+        versionMap = new Map;
+        packageVersionMap.set(dep.name, versionMap);
+      }
+      let manifests = versionMap.get(dep.version);
+      if (!manifests) {
+        manifests = [];
+        versionMap.set(dep.version, manifests);
+      }
+      manifests.push(manifestPath);
+      let pkgManifests = manifestsByPackage.get(dep.name);
+      if (!pkgManifests) {
+        pkgManifests = [];
+        manifestsByPackage.set(dep.name, pkgManifests);
+      }
+      pkgManifests.push(manifestPath);
+    }
+  }
+  const packages = [];
+  const conflicts = [];
+  for (const [name, versionMap] of packageVersionMap) {
+    const versions = Array.from(versionMap.entries()).map(([version, manifests]) => ({ version, manifests })).sort((a, b) => {
+      try {
+        return Bun.semver.order(a.version, b.version);
+      } catch {
+        return a.version.localeCompare(b.version);
+      }
+    });
+    if (versions.length > 1) {
+      conflicts.push({ name, versions });
+    }
+    const lowest = versions[0];
+    if (lowest) {
+      packages.push({ name, version: lowest.version });
+    }
+  }
+  packages.sort((a, b) => a.name.localeCompare(b.name));
+  return Result.ok({
+    packages,
+    conflicts,
+    manifestsByPackage,
+    manifestPaths,
+    workspaceRoot: wsRootResult.value
+  });
+}
+async function applyUpdatesToWorkspace(manifestPaths, manifestsByPackage, updates) {
+  const updateMap = new Map;
+  for (const u of updates) {
+    updateMap.set(u.name, u.latestVersion);
+  }
+  const manifestsToUpdate = new Set;
+  for (const u of updates) {
+    const manifests = manifestsByPackage.get(u.name);
+    if (manifests) {
+      for (const m of manifests) {
+        manifestsToUpdate.add(m);
+      }
+    }
+  }
+  for (const manifestPath of manifestPaths) {
+    if (!manifestsToUpdate.has(manifestPath))
+      continue;
+    let raw;
+    try {
+      raw = readFileSync(manifestPath, "utf-8");
+    } catch {
+      return Result.err(InternalError.create("Failed to read package.json for apply", {
+        path: manifestPath
+      }));
+    }
+    let pkg;
+    try {
+      pkg = JSON.parse(raw);
+    } catch {
+      return Result.err(InternalError.create("Invalid JSON in package.json", {
+        path: manifestPath
+      }));
+    }
+    let changed = false;
+    for (const section of ["dependencies", "devDependencies"]) {
+      const deps = pkg[section];
+      if (!deps)
+        continue;
+      for (const name of Object.keys(deps)) {
+        const newVersion = updateMap.get(name);
+        if (newVersion === undefined)
+          continue;
+        const currentSpecifier = deps[name];
+        if (currentSpecifier === undefined)
+          continue;
+        if (currentSpecifier.startsWith("workspace:") && ["*", "~", "^"].includes(currentSpecifier.slice("workspace:".length))) {
+          continue;
+        }
+        const prefix = getVersionPrefix(currentSpecifier);
+        deps[name] = `${prefix}${newVersion}`;
+        changed = true;
+      }
+    }
+    if (changed) {
+      try {
+        const updated = `${JSON.stringify(pkg, null, 2)}
+`;
+        await Bun.write(manifestPath, updated);
+      } catch {
+        return Result.err(InternalError.create("Failed to write updated package.json", {
+          path: manifestPath
+        }));
+      }
+    }
+  }
+  return Result.ok(undefined);
+}
+function getVersionPrefix(specifier) {
+  if (specifier.startsWith("workspace:")) {
+    const inner = specifier.slice("workspace:".length);
+    return `workspace:${getVersionPrefix(inner)}`;
+  }
+  const match = specifier.match(/^([\^~>=<]+)/);
+  return match?.[1] ?? "";
+}
+async function runInstall(cwd) {
+  try {
+    const proc = Bun.spawn(["bun", "install"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      return Result.err(InternalError.create("bun install failed", {
+        cwd,
+        exitCode,
+        stderr: stderr.trim()
+      }));
+    }
+  } catch {
+    return Result.err(InternalError.create("Failed to run bun install", { cwd }));
+  }
+  return Result.ok(undefined);
+}
+
+export { detectWorkspaceRoot, collectWorkspaceManifests, getInstalledPackagesFromWorkspace, applyUpdatesToWorkspace, runInstall };

package/dist/shared/outfitter-zwyvewr1.js

@@ -0,0 +1,36 @@
+// @bun
+// apps/outfitter/src/commands/docs-module-loader.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { pathToFileURL } from "url";
+var require2 = createRequire(import.meta.url);
+function resolveDocsEntrypoint() {
+  const packageJsonPath = require2.resolve("@outfitter/docs/package.json");
+  const packageRoot = dirname(packageJsonPath);
+  const srcEntrypoint = join(packageRoot, "src", "index.ts");
+  if (existsSync(srcEntrypoint)) {
+    return srcEntrypoint;
+  }
+  const distEntrypoint = join(packageRoot, "dist", "index.js");
+  if (existsSync(distEntrypoint)) {
+    return distEntrypoint;
+  }
+  throw new Error("Unable to resolve @outfitter/docs entrypoint (expected src/index.ts or dist/index.js).");
+}
+var docsModulePromise;
+async function loadDocsModule() {
+  if (!docsModulePromise) {
+    docsModulePromise = (async () => {
+      const entrypoint = resolveDocsEntrypoint();
+      const module = await import(pathToFileURL(entrypoint).href);
+      if (typeof module.createDocsCommand !== "function" || typeof module.executeCheckCommand !== "function" || typeof module.executeSyncCommand !== "function" || typeof module.executeExportCommand !== "function") {
+        throw new Error("Resolved @outfitter/docs entrypoint does not export required docs functions.");
+      }
+      return module;
+    })();
+  }
+  return await docsModulePromise;
+}
+
+export { loadDocsModule };

package/dist/targets/index.d.ts

@@ -0,0 +1,4 @@
+import "../shared/outfitter-y784nh31";
+import { INIT_TARGET_IDS, READY_TARGET_IDS, SCAFFOLD_TARGET_IDS, TARGET_IDS, TARGET_REGISTRY, getInitTarget, getReadyTarget, getScaffoldTarget, getTarget, listTargets, resolvePlacement } from "../shared/outfitter-33w361tc";
+import { TargetCategory, TargetDefinition, TargetId, TargetScope, TargetStatus } from "../shared/outfitter-k56rmt24";
+export { resolvePlacement, listTargets, getTarget, getScaffoldTarget, getReadyTarget, getInitTarget, TargetStatus, TargetScope, TargetId, TargetDefinition, TargetCategory, TARGET_REGISTRY, TARGET_IDS, SCAFFOLD_TARGET_IDS, READY_TARGET_IDS, INIT_TARGET_IDS };

package/dist/targets/index.js

@@ -0,0 +1,29 @@
+// @bun
+import"../shared/outfitter-ehp18x1n.js";
+import {
+  INIT_TARGET_IDS,
+  READY_TARGET_IDS,
+  SCAFFOLD_TARGET_IDS,
+  TARGET_IDS,
+  TARGET_REGISTRY,
+  getInitTarget,
+  getReadyTarget,
+  getScaffoldTarget,
+  getTarget,
+  listTargets,
+  resolvePlacement
+} from "../shared/outfitter-1dd0k853.js";
+import"../shared/outfitter-mdt37hqm.js";
+export {
+  resolvePlacement,
+  listTargets,
+  getTarget,
+  getScaffoldTarget,
+  getReadyTarget,
+  getInitTarget,
+  TARGET_REGISTRY,
+  TARGET_IDS,
+  SCAFFOLD_TARGET_IDS,
+  READY_TARGET_IDS,
+  INIT_TARGET_IDS
+};

package/dist/targets/registry.d.ts

@@ -0,0 +1,3 @@
+import { INIT_TARGET_IDS, READY_TARGET_IDS, SCAFFOLD_TARGET_IDS, TARGET_IDS, TARGET_REGISTRY, getInitTarget, getReadyTarget, getScaffoldTarget, getTarget, listTargets, resolvePlacement } from "../shared/outfitter-33w361tc";
+import "../shared/outfitter-k56rmt24";
+export { resolvePlacement, listTargets, getTarget, getScaffoldTarget, getReadyTarget, getInitTarget, TARGET_REGISTRY, TARGET_IDS, SCAFFOLD_TARGET_IDS, READY_TARGET_IDS, INIT_TARGET_IDS };

package/dist/targets/registry.js

@@ -0,0 +1,28 @@
+// @bun
+import {
+  INIT_TARGET_IDS,
+  READY_TARGET_IDS,
+  SCAFFOLD_TARGET_IDS,
+  TARGET_IDS,
+  TARGET_REGISTRY,
+  getInitTarget,
+  getReadyTarget,
+  getScaffoldTarget,
+  getTarget,
+  listTargets,
+  resolvePlacement
+} from "../shared/outfitter-1dd0k853.js";
+import"../shared/outfitter-mdt37hqm.js";
+export {
+  resolvePlacement,
+  listTargets,
+  getTarget,
+  getScaffoldTarget,
+  getReadyTarget,
+  getInitTarget,
+  TARGET_REGISTRY,
+  TARGET_IDS,
+  SCAFFOLD_TARGET_IDS,
+  READY_TARGET_IDS,
+  INIT_TARGET_IDS
+};

package/dist/targets/types.d.ts

@@ -0,0 +1,2 @@
+import { TargetCategory, TargetDefinition, TargetId, TargetScope, TargetStatus } from "../shared/outfitter-k56rmt24";
+export { TargetStatus, TargetScope, TargetId, TargetDefinition, TargetCategory };

package/dist/targets/types.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "outfitter",
   "description": "Outfitter umbrella CLI for scaffolding and project management",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "type": "module",
   "files": [
     "dist",
@@ -82,22 +82,28 @@
         "default": "./dist/commands/shared-deps.js"
       }
     },
-    "./commands/update": {
+    "./commands/upgrade": {
       "import": {
-        "types": "./dist/commands/update.d.ts",
-        "default": "./dist/commands/update.js"
+        "types": "./dist/commands/upgrade.d.ts",
+        "default": "./dist/commands/upgrade.js"
       }
     },
-    "./commands/update-planner": {
+    "./commands/upgrade-codemods": {
       "import": {
-        "types": "./dist/commands/update-planner.d.ts",
-        "default": "./dist/commands/update-planner.js"
+        "types": "./dist/commands/upgrade-codemods.d.ts",
+        "default": "./dist/commands/upgrade-codemods.js"
       }
     },
-    "./commands/update-workspace": {
+    "./commands/upgrade-planner": {
       "import": {
-        "types": "./dist/commands/update-workspace.d.ts",
-        "default": "./dist/commands/update-workspace.js"
+        "types": "./dist/commands/upgrade-planner.d.ts",
+        "default": "./dist/commands/upgrade-planner.js"
+      }
+    },
+    "./commands/upgrade-workspace": {
+      "import": {
+        "types": "./dist/commands/upgrade-workspace.d.ts",
+        "default": "./dist/commands/upgrade-workspace.js"
       }
     },
     "./create": {
@@ -233,17 +239,18 @@
     "typecheck": "tsc --noEmit",
     "sync:templates": "bun run ../../scripts/sync-templates.ts",
     "prepack": "bun run sync:templates",
+    "prepublishOnly": "bun ../../scripts/check-publish-manifest.ts",
     "clean": "rm -rf dist"
   },
   "dependencies": {
     "@clack/prompts": "^0.10.0",
-    "@outfitter/cli": "0.4.1",
+    "@outfitter/cli": "0.5.1",
     "@outfitter/tui": "0.2.0",
-    "@outfitter/config": "0.3.1",
-    "@outfitter/contracts": "0.3.0",
+    "@outfitter/config": "0.3.2",
+    "@outfitter/contracts": "0.4.0",
     "@outfitter/docs": "0.1.1",
     "@outfitter/logging": "0.4.0",
-    "@outfitter/tooling": "0.2.3",
+    "@outfitter/tooling": "0.2.4",
     "commander": "^14.0.2",
     "typescript": "^5.9.3",
     "zod": "^4.3.5"