outfitter 0.2.1 → 0.2.3

package/dist/shared/outfitter-4s9meh3j.js

@@ -0,0 +1,221 @@
+// @bun
+// apps/outfitter/src/engine/post-scaffold.ts
+import { relative } from "path";
+import { Result } from "@outfitter/contracts";
+function detectGitState(cwd) {
+  try {
+    const result = Bun.spawnSync(["git", "rev-parse", "--show-toplevel"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "ignore"
+    });
+    return { isRepo: result.exitCode === 0 };
+  } catch {
+    return { isRepo: false };
+  }
+}
+async function runBunInstall(cwd, timeoutMs) {
+  try {
+    const proc = Bun.spawn(["bun", "install"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const timeoutPromise = new Promise((resolveTimeout) => {
+      const timer = setTimeout(() => resolveTimeout("timeout"), timeoutMs);
+      proc.exited.finally(() => clearTimeout(timer));
+    });
+    const race = await Promise.race([
+      proc.exited.then(() => "exit"),
+      timeoutPromise
+    ]);
+    if (race === "timeout") {
+      proc.kill();
+      return Result.err(`bun install timed out after ${timeoutMs}ms`);
+    }
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      return Result.err(stderr.trim() || `bun install exited with code ${exitCode}`);
+    }
+    return Result.ok(undefined);
+  } catch (error) {
+    return Result.err(error instanceof Error ? error.message : "Unknown error");
+  }
+}
+function runGitInit(cwd) {
+  try {
+    const result = Bun.spawnSync(["git", "init"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (result.exitCode !== 0) {
+      return Result.err(result.stderr.toString().trim());
+    }
+    return Result.ok(undefined);
+  } catch (error) {
+    return Result.err(error instanceof Error ? error.message : "Unknown error");
+  }
+}
+function hasGitUserConfig(cwd) {
+  try {
+    const name = Bun.spawnSync(["git", "config", "--get", "user.name"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "ignore"
+    });
+    if (name.exitCode !== 0 || name.stdout.toString().trim().length === 0) {
+      return false;
+    }
+    const email = Bun.spawnSync(["git", "config", "--get", "user.email"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "ignore"
+    });
+    return email.exitCode === 0 && email.stdout.toString().trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function runGitCommit(cwd, message) {
+  try {
+    const addResult = Bun.spawnSync(["git", "add", "."], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (addResult.exitCode !== 0) {
+      return Result.err(`git add failed: ${addResult.stderr.toString().trim()}`);
+    }
+    const commitResult = Bun.spawnSync(["git", "commit", "-m", message], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (commitResult.exitCode !== 0) {
+      return Result.err(`git commit failed: ${commitResult.stderr.toString().trim()}`);
+    }
+    return Result.ok(undefined);
+  } catch (error) {
+    return Result.err(error instanceof Error ? error.message : "Unknown error");
+  }
+}
+function computeNextSteps(options, installResult) {
+  const steps = [];
+  if (options.origin === "init") {
+    steps.push(`cd ${JSON.stringify(options.rootDir)}`);
+  }
+  if (installResult !== "success") {
+    steps.push("bun install");
+  }
+  if (options.structure === "workspace") {
+    const relProject = relative(options.rootDir, options.projectDir) || ".";
+    steps.push(`bun run --cwd ${JSON.stringify(relProject)} dev`);
+  } else {
+    steps.push("bun run dev");
+  }
+  return steps;
+}
+async function runPostScaffold(options, collector) {
+  if (process.env["OUTFITTER_DISABLE_POST_SCAFFOLD"] === "1") {
+    return Result.ok({
+      installResult: "skipped",
+      gitInitResult: "skipped",
+      gitCommitResult: "skipped",
+      nextSteps: computeNextSteps(options, "skipped")
+    });
+  }
+  let installResult = "skipped";
+  let installError;
+  if (!options.skipInstall) {
+    if (options.dryRun) {
+      collector?.add({
+        type: "install",
+        command: "bun install",
+        cwd: options.rootDir
+      });
+      installResult = "skipped";
+    } else {
+      const result = await runBunInstall(options.rootDir, options.installTimeoutMs);
+      if (result.isErr()) {
+        installResult = "failed";
+        installError = result.error;
+        process.stderr.write(`Warning: bun install failed: ${result.error}
+`);
+      } else {
+        installResult = "success";
+      }
+    }
+  }
+  let gitInitResult = "skipped";
+  let gitCommitResult = "skipped";
+  let gitError;
+  if (!options.skipGit && options.origin === "init") {
+    const gitState = detectGitState(options.rootDir);
+    if (options.dryRun) {
+      if (!gitState.isRepo) {
+        collector?.add({
+          type: "git",
+          action: "init",
+          cwd: options.rootDir
+        });
+      }
+      if (!options.skipCommit) {
+        collector?.add({
+          type: "git",
+          action: "add-all",
+          cwd: options.rootDir
+        });
+        collector?.add({
+          type: "git",
+          action: "commit",
+          cwd: options.rootDir,
+          message: "init: scaffold with outfitter"
+        });
+      }
+      gitInitResult = gitState.isRepo ? "already-repo" : "skipped";
+    } else {
+      if (gitState.isRepo) {
+        gitInitResult = "already-repo";
+      } else {
+        const result = runGitInit(options.rootDir);
+        if (result.isErr()) {
+          gitInitResult = "failed";
+          gitError = result.error;
+          process.stderr.write(`Warning: git init failed: ${result.error}
+`);
+        } else {
+          gitInitResult = "success";
+        }
+      }
+      if (!options.skipCommit && (gitInitResult === "success" || gitInitResult === "already-repo")) {
+        if (hasGitUserConfig(options.rootDir)) {
+          const commitResult = runGitCommit(options.rootDir, "init: scaffold with outfitter");
+          if (commitResult.isErr()) {
+            gitCommitResult = "failed";
+            gitError = commitResult.error;
+            process.stderr.write(`Warning: ${commitResult.error}
+`);
+          } else {
+            gitCommitResult = "success";
+          }
+        } else {
+          gitCommitResult = "skipped";
+          process.stderr.write(`Warning: git user.name/email not configured, skipping initial commit.
+`);
+        }
+      }
+    }
+  }
+  return Result.ok({
+    installResult,
+    installError,
+    gitInitResult,
+    gitCommitResult,
+    gitError,
+    nextSteps: computeNextSteps(options, installResult)
+  });
+}
+
+export { runPostScaffold };

package/dist/shared/outfitter-6a4bq054.js

@@ -0,0 +1,322 @@
+// @bun
+// apps/outfitter/src/commands/update-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-6bkqjk86.d.ts

@@ -0,0 +1,3 @@
+import { ActionRegistry } from "@outfitter/contracts";
+declare const outfitterActions: ActionRegistry;
+export { outfitterActions };

package/dist/shared/outfitter-6gc3g5wk.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/output";
+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-7cv5fg1m.js

@@ -0,0 +1,61 @@
+// @bun
+import {
+  runAdd
+} from "./outfitter-s6k8y2p4.js";
+import {
+  ScaffoldError
+} from "./outfitter-8y2dfx6n.js";
+
+// apps/outfitter/src/engine/blocks.ts
+import { Result } from "@outfitter/contracts";
+async function addBlocks(targetDir, blocks, options) {
+  const mergedResult = {
+    created: [],
+    skipped: [],
+    overwritten: [],
+    dependencies: {},
+    devDependencies: {}
+  };
+  for (const blockName of blocks) {
+    const result = await runAdd({
+      block: blockName,
+      force: options.force,
+      dryRun: Boolean(options.collector),
+      cwd: targetDir
+    });
+    if (result.isErr()) {
+      return Result.err(new ScaffoldError(`Failed to add block '${blockName}': ${result.error.message}`));
+    }
+    if (options.collector) {
+      options.collector.add({
+        type: "block-add",
+        name: blockName,
+        files: [...result.value.created, ...result.value.overwritten]
+      });
+      for (const [name, version] of Object.entries(result.value.dependencies)) {
+        options.collector.add({
+          type: "dependency-add",
+          name,
+          version,
+          section: "dependencies"
+        });
+      }
+      for (const [name, version] of Object.entries(result.value.devDependencies)) {
+        options.collector.add({
+          type: "dependency-add",
+          name,
+          version,
+          section: "devDependencies"
+        });
+      }
+    }
+    mergedResult.created.push(...result.value.created);
+    mergedResult.skipped.push(...result.value.skipped);
+    mergedResult.overwritten.push(...result.value.overwritten);
+    Object.assign(mergedResult.dependencies, result.value.dependencies);
+    Object.assign(mergedResult.devDependencies, result.value.devDependencies);
+  }
+  return Result.ok(mergedResult);
+}
+
+export { addBlocks };