outfitter 0.3.2 → 0.3.4

package/dist/shared/outfitter-738z4c37.js

@@ -0,0 +1,262 @@
+// @bun
+import {
+  actionInternalErr,
+  outputModeSchema,
+  resolveBooleanFlagAlias,
+  resolveInstallTimeoutFlag,
+  resolveLocalFlag,
+  resolveNoToolingFlag,
+  resolveStringFlag
+} from "./outfitter-7n7vsz95.js";
+import {
+  runInit
+} from "./outfitter-6mpkh3zn.js";
+import {
+  printInitResults
+} from "./outfitter-n0ed012k.js";
+import {
+  resolveOutputModeFromContext
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/actions/init.ts
+import { actionCliPresets } from "@outfitter/cli/actions";
+import {
+  booleanFlagPreset,
+  dryRunPreset,
+  forcePreset
+} from "@outfitter/cli/flags";
+import {
+  defineAction,
+  InternalError,
+  Result
+} from "@outfitter/contracts";
+import { z } from "zod";
+var initPresetValues = [
+  "minimal",
+  "cli",
+  "mcp",
+  "daemon",
+  "library",
+  "full-stack",
+  "lib"
+];
+function normalizeInitPreset(preset) {
+  if (preset === undefined) {
+    return;
+  }
+  return preset === "lib" ? "library" : preset;
+}
+var initInputSchema = z.object({
+  targetDir: z.string(),
+  name: z.string().optional(),
+  bin: z.string().optional(),
+  preset: z.enum(initPresetValues).optional(),
+  structure: z.enum(["single", "workspace"]).optional(),
+  workspaceName: z.string().optional(),
+  local: z.boolean().optional(),
+  force: z.boolean(),
+  with: z.string().optional(),
+  noTooling: z.boolean().optional(),
+  yes: z.boolean().optional(),
+  dryRun: z.boolean().optional(),
+  skipInstall: z.boolean().optional(),
+  skipGit: z.boolean().optional(),
+  skipCommit: z.boolean().optional(),
+  installTimeout: z.number().optional(),
+  outputMode: outputModeSchema
+});
+var commonInitOptions = [
+  {
+    flags: "-n, --name <name>",
+    description: "Package name (defaults to directory name)"
+  },
+  {
+    flags: "-b, --bin <name>",
+    description: "Binary name (defaults to project name)"
+  },
+  {
+    flags: "--local",
+    description: "Use workspace:* for @outfitter dependencies"
+  },
+  {
+    flags: "--workspace",
+    description: "Alias for --local"
+  },
+  {
+    flags: "--with <blocks>",
+    description: "Tooling to add (comma-separated: scaffolding, claude, linter, lefthook, bootstrap)"
+  },
+  {
+    flags: "--no-tooling",
+    description: "Skip tooling setup"
+  }
+];
+var initSharedFlags = actionCliPresets(forcePreset(), dryRunPreset(), booleanFlagPreset({
+  id: "initYes",
+  key: "yes",
+  flags: "-y, --yes",
+  description: "Skip prompts and use defaults for missing values"
+}));
+function resolveInitOptions(context, presetOverride) {
+  const flags = context.flags;
+  const { force, dryRun, yes } = initSharedFlags.resolve(context);
+  const targetDir = context.args[0] ?? process.cwd();
+  const name = resolveStringFlag(flags.name);
+  const bin = resolveStringFlag(flags.bin);
+  const preset = normalizeInitPreset(presetOverride ?? resolveStringFlag(flags.preset));
+  const structure = resolveStringFlag(flags.structure);
+  const workspaceName = resolveStringFlag(flags.workspaceName);
+  const local = resolveLocalFlag(flags);
+  const withBlocks = resolveStringFlag(flags.with);
+  const noTooling = resolveNoToolingFlag(flags);
+  const skipInstall = resolveBooleanFlagAlias(context.flags, "skipInstall", "skip-install");
+  const skipGit = resolveBooleanFlagAlias(context.flags, "skipGit", "skip-git");
+  const skipCommit = resolveBooleanFlagAlias(context.flags, "skipCommit", "skip-commit");
+  const installTimeout = resolveInstallTimeoutFlag(flags.installTimeout);
+  const outputMode = resolveOutputModeFromContext(context.flags);
+  return {
+    targetDir,
+    name,
+    ...preset ? { preset } : {},
+    ...structure ? { structure } : {},
+    ...workspaceName ? { workspaceName } : {},
+    force,
+    ...local !== undefined ? { local } : {},
+    ...withBlocks ? { with: withBlocks } : {},
+    ...noTooling !== undefined ? { noTooling } : {},
+    ...bin ? { bin } : {},
+    ...yes ? { yes } : {},
+    ...dryRun ? { dryRun } : {},
+    ...skipInstall ? { skipInstall } : {},
+    ...skipGit ? { skipGit } : {},
+    ...skipCommit ? { skipCommit } : {},
+    ...installTimeout !== undefined ? { installTimeout } : {},
+    outputMode
+  };
+}
+function createInitAction(options) {
+  const presetOption = {
+    flags: "-p, --preset <preset>",
+    description: "Preset to use (minimal, cli, mcp, daemon, library, full-stack, lib)"
+  };
+  const initOptions = [...commonInitOptions];
+  initOptions.push(...initSharedFlags.options);
+  initOptions.push({
+    flags: "-s, --structure <mode>",
+    description: "Project structure (single|workspace)"
+  });
+  initOptions.push({
+    flags: "--workspace-name <name>",
+    description: "Workspace root package name"
+  });
+  initOptions.push({
+    flags: "--skip-install",
+    description: "Skip bun install",
+    defaultValue: false
+  });
+  initOptions.push({
+    flags: "--skip-git",
+    description: "Skip git init and initial commit",
+    defaultValue: false
+  });
+  initOptions.push({
+    flags: "--skip-commit",
+    description: "Skip initial commit only",
+    defaultValue: false
+  });
+  initOptions.push({
+    flags: "--install-timeout <ms>",
+    description: "bun install timeout in milliseconds"
+  });
+  if (options.includePresetOption) {
+    initOptions.push(presetOption);
+  }
+  return defineAction({
+    id: options.id,
+    description: options.description,
+    surfaces: ["cli"],
+    input: initInputSchema,
+    cli: {
+      group: "init",
+      command: options.command,
+      description: options.description,
+      options: initOptions,
+      mapInput: (context) => resolveInitOptions(context, options.presetOverride)
+    },
+    handler: async (input) => {
+      const { outputMode, ...initInput } = input;
+      const result = await runInit(initInput);
+      if (result.isErr()) {
+        return actionInternalErr(options.id, result.error);
+      }
+      await printInitResults(result.value, { mode: outputMode });
+      return Result.ok(result.value);
+    }
+  });
+}
+var createAction = defineAction({
+  id: "create",
+  description: "Removed - use 'outfitter init' instead",
+  surfaces: ["cli"],
+  input: z.object({}).passthrough(),
+  cli: {
+    command: "create [directory]",
+    description: "Removed - use 'outfitter init' instead",
+    options: [],
+    mapInput: () => ({})
+  },
+  handler: async () => Result.err(new InternalError({
+    message: [
+      "The 'create' command has been removed.",
+      "",
+      "Use 'outfitter init' instead. It supports everything 'create' did:",
+      "",
+      "  Interactive mode:    outfitter init my-project",
+      "  With preset:         outfitter init my-project --preset cli",
+      "  Skip prompts:        outfitter init my-project --preset cli --yes",
+      "  Workspace:           outfitter init my-project --preset cli --structure workspace",
+      "",
+      "See 'outfitter init --help' for full options."
+    ].join(`
+`),
+    context: { action: "create" }
+  }))
+});
+var initAction = createInitAction({
+  id: "init",
+  description: "Create a new Outfitter project",
+  command: "[directory]",
+  includePresetOption: true
+});
+var initCliAction = createInitAction({
+  id: "init.cli",
+  description: "Create a new CLI project",
+  command: "cli [directory]",
+  presetOverride: "cli"
+});
+var initMcpAction = createInitAction({
+  id: "init.mcp",
+  description: "Create a new MCP server",
+  command: "mcp [directory]",
+  presetOverride: "mcp"
+});
+var initDaemonAction = createInitAction({
+  id: "init.daemon",
+  description: "Create a new daemon project",
+  command: "daemon [directory]",
+  presetOverride: "daemon"
+});
+var initLibraryAction = createInitAction({
+  id: "init.library",
+  description: "Create a new library project",
+  command: "library [directory]",
+  presetOverride: "library"
+});
+var initFullStackAction = createInitAction({
+  id: "init.full-stack",
+  description: "Create a full-stack workspace",
+  command: "full-stack [directory]",
+  presetOverride: "full-stack"
+});
+
+export { createAction, initAction, initCliAction, initMcpAction, initDaemonAction, initLibraryAction, initFullStackAction };

package/dist/shared/outfitter-76k25svs.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).toSorted((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 })).toSorted((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-7n7vsz95.js

@@ -0,0 +1,101 @@
+// @bun
+// apps/outfitter/src/actions/shared.ts
+import { resolve } from "path";
+import { InternalError, Result } from "@outfitter/contracts";
+import { z } from "zod";
+var outputModeSchema = z.enum(["human", "json", "jsonl"]).default("human");
+function argvContainsOutputFlag(argv) {
+  for (let index = 0;index < argv.length; index++) {
+    const arg = argv[index];
+    if (!arg) {
+      continue;
+    }
+    if (arg === "-o" || arg === "--output") {
+      return true;
+    }
+    if (arg.startsWith("--output=") || arg.startsWith("-o=")) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasExplicitOutputFlag(flags, options = {}) {
+  const mode = flags["output"];
+  if (typeof mode !== "string") {
+    return false;
+  }
+  const defaultMode = options.defaultMode ?? "human";
+  if (mode !== defaultMode) {
+    return true;
+  }
+  return argvContainsOutputFlag(options.argv ?? process.argv.slice(2));
+}
+function resolveStringFlag(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function resolveNoToolingFlag(flags) {
+  if (typeof flags.noTooling === "boolean") {
+    return !flags.noTooling;
+  }
+  if (typeof flags.tooling === "boolean") {
+    if (!flags.tooling) {
+      return true;
+    }
+    return process.argv.includes("--tooling") ? false : undefined;
+  }
+  return;
+}
+function resolveLocalFlag(flags) {
+  if (flags.local === true || flags.workspace === true) {
+    return true;
+  }
+  return;
+}
+function resolveInstallTimeoutFlag(value) {
+  if (typeof value === "string") {
+    return Number.parseInt(value, 10);
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  return;
+}
+function resolveCwdFromPreset(flags, cwdPreset) {
+  const { cwd: rawCwd } = cwdPreset.resolve(flags);
+  return resolve(process.cwd(), rawCwd);
+}
+function resolveOutputModeWithEnvFallback(flags, explicitMode, options = {}) {
+  if (hasExplicitOutputFlag(flags)) {
+    return explicitMode;
+  }
+  if (options.forceHumanWhenImplicit) {
+    return "human";
+  }
+  if (process.env["OUTFITTER_JSONL"] === "1") {
+    return "jsonl";
+  }
+  if (process.env["OUTFITTER_JSON"] === "1") {
+    return "json";
+  }
+  return "human";
+}
+function resolveBooleanFlagAlias(flags, key, alias) {
+  return Boolean(flags[key] ?? flags[alias]);
+}
+function toActionInternalError(action, error) {
+  return new InternalError({
+    message: error.message,
+    context: { action }
+  });
+}
+function actionInternalErr(action, error) {
+  return Result.err(toActionInternalError(action, error));
+}
+function toActionInternalErrorFromUnknown(action, error, fallbackMessage) {
+  return new InternalError({
+    message: error instanceof Error ? error.message : fallbackMessage,
+    context: { action }
+  });
+}
+
+export { outputModeSchema, hasExplicitOutputFlag, resolveStringFlag, resolveNoToolingFlag, resolveLocalFlag, resolveInstallTimeoutFlag, resolveCwdFromPreset, resolveOutputModeWithEnvFallback, resolveBooleanFlagAlias, toActionInternalError, actionInternalErr, toActionInternalErrorFromUnknown };