outfitter 0.2.4 → 0.2.6

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

@@ -0,0 +1,17 @@
+import { OutputMode } from "@outfitter/cli/types";
+type StructuredOutputMode = Extract<OutputMode, "json" | "jsonl">;
+/** Output modes resolvable from CLI flags and env vars. */
+type CliOutputMode = "human" | "json" | "jsonl";
+/**
+* Resolve output mode from CLI context (flags + env vars).
+*
+* Precedence: explicit flag > OUTFITTER_JSONL env > OUTFITTER_JSON env > "human"
+*
+* This function is pure -- no env var side effects.
+*/
+declare function resolveOutputModeFromContext(flags: Record<string, unknown>): CliOutputMode;
+/**
+* Resolve machine-readable output mode from explicit options first, then env.
+*/
+declare function resolveStructuredOutputMode(mode?: OutputMode): StructuredOutputMode | undefined;
+export { StructuredOutputMode, CliOutputMode, resolveOutputModeFromContext, resolveStructuredOutputMode };

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

@@ -0,0 +1,50 @@
+type Operation = {
+	readonly type: "file-create";
+	readonly path: string;
+	readonly source: "template" | "block" | "generated";
+} | {
+	readonly type: "file-overwrite";
+	readonly path: string;
+	readonly source: "template" | "block" | "generated";
+} | {
+	readonly type: "file-skip";
+	readonly path: string;
+	readonly reason: string;
+} | {
+	readonly type: "dir-create";
+	readonly path: string;
+} | {
+	readonly type: "dependency-add";
+	readonly name: string;
+	readonly version: string;
+	readonly section: "dependencies" | "devDependencies" | "peerDependencies";
+} | {
+	readonly type: "block-add";
+	readonly name: string;
+	readonly files: readonly string[];
+} | {
+	readonly type: "config-inject";
+	readonly target: string;
+	readonly description: string;
+} | {
+	readonly type: "git";
+	readonly action: "init" | "add-all" | "commit";
+	readonly cwd: string;
+	readonly message?: string | undefined;
+} | {
+	readonly type: "install";
+	readonly command: string;
+	readonly cwd: string;
+};
+declare class OperationCollector {
+	private readonly operations;
+	add(op: Operation): void;
+	getOperations(): readonly Operation[];
+	countByType(): Record<string, number>;
+	isEmpty(): boolean;
+	toJSON(): {
+		operations: readonly Operation[];
+		summary: Record<string, number>;
+	};
+}
+export { Operation, OperationCollector };

package/dist/shared/outfitter-ara3djt0.js

@@ -0,0 +1,73 @@
+// @bun
+import {
+  SHARED_DEV_DEPS,
+  SHARED_SCRIPTS
+} from "./outfitter-k112c427.js";
+import {
+  ScaffoldError
+} from "./outfitter-8y2dfx6n.js";
+
+// apps/outfitter/src/engine/config.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { Result } from "@outfitter/contracts";
+var DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+function injectSharedConfig(targetDir) {
+  const packageJsonPath = join(targetDir, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return Result.ok(undefined);
+  }
+  try {
+    const content = readFileSync(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(content);
+    const existingDevDeps = parsed["devDependencies"] ?? {};
+    parsed["devDependencies"] = { ...SHARED_DEV_DEPS, ...existingDevDeps };
+    const existingScripts = parsed["scripts"] ?? {};
+    parsed["scripts"] = { ...SHARED_SCRIPTS, ...existingScripts };
+    writeFileSync(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
+`, "utf-8");
+    return Result.ok(undefined);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new ScaffoldError(`Failed to inject shared config: ${message}`));
+  }
+}
+function rewriteLocalDependencies(targetDir) {
+  const packageJsonPath = join(targetDir, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return Result.ok(undefined);
+  }
+  try {
+    const content = readFileSync(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(content);
+    let updated = false;
+    for (const section of DEPENDENCY_SECTIONS) {
+      const deps = parsed[section];
+      if (!deps || typeof deps !== "object" || Array.isArray(deps)) {
+        continue;
+      }
+      const entries = deps;
+      for (const [name, version] of Object.entries(entries)) {
+        if (typeof version === "string" && name.startsWith("@outfitter/") && version !== "workspace:*") {
+          entries[name] = "workspace:*";
+          updated = true;
+        }
+      }
+    }
+    if (updated) {
+      writeFileSync(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
+`, "utf-8");
+    }
+    return Result.ok(undefined);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new ScaffoldError(`Failed to update local dependencies: ${message}`));
+  }
+}
+
+export { injectSharedConfig, rewriteLocalDependencies };

package/dist/shared/outfitter-avhm5z6w.js

@@ -0,0 +1,82 @@
+// @bun
+import {
+  getCreatePreset
+} from "./outfitter-vh4xgb93.js";
+import {
+  deriveBinName,
+  deriveProjectName
+} from "./outfitter-q9agarmb.js";
+
+// apps/outfitter/src/create/planner.ts
+import { Result, ValidationError } from "@outfitter/contracts";
+function derivePackageName(input) {
+  return (input.packageName ?? input.name).trim();
+}
+function planCreateProject(input) {
+  const packageName = derivePackageName(input);
+  if (packageName.length === 0) {
+    return Result.err(new ValidationError({
+      message: "Project name must not be empty",
+      field: "name"
+    }));
+  }
+  const targetDir = input.targetDir.trim();
+  if (targetDir.length === 0) {
+    return Result.err(new ValidationError({
+      message: "Target directory must not be empty",
+      field: "targetDir"
+    }));
+  }
+  if (packageName.startsWith("@") && !packageName.includes("/")) {
+    return Result.err(new ValidationError({
+      message: "Could not derive a project name from package name",
+      field: "packageName"
+    }));
+  }
+  const projectName = deriveProjectName(packageName);
+  if (projectName.length === 0) {
+    return Result.err(new ValidationError({
+      message: "Could not derive a project name from package name",
+      field: "packageName"
+    }));
+  }
+  const preset = getCreatePreset(input.preset);
+  if (!preset) {
+    return Result.err(new ValidationError({
+      message: `Unknown create preset '${input.preset}'`,
+      field: "preset"
+    }));
+  }
+  const includeTooling = input.includeTooling ?? true;
+  const defaultBlocks = includeTooling ? [...preset.defaultBlocks] : [];
+  const changes = [
+    {
+      type: "copy-template",
+      template: preset.template,
+      targetDir,
+      overlayBaseTemplate: true
+    },
+    { type: "inject-shared-config" }
+  ];
+  if (input.local) {
+    changes.push({ type: "rewrite-local-dependencies", mode: "workspace" });
+  }
+  if (defaultBlocks.length > 0) {
+    changes.push({ type: "add-blocks", blocks: defaultBlocks });
+  }
+  const plan = {
+    preset,
+    values: {
+      packageName,
+      projectName,
+      version: input.version?.trim() || "0.1.0",
+      description: input.description?.trim() || "A new project created with Outfitter",
+      binName: deriveBinName(projectName),
+      year: input.year ?? String(new Date().getFullYear())
+    },
+    changes
+  };
+  return Result.ok(plan);
+}
+
+export { planCreateProject };

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

@@ -0,0 +1,63 @@
+import { TargetId } from "./outfitter-k56rmt24";
+import { PostScaffoldResult } from "./outfitter-3weh61w7";
+import { OutputMode } from "@outfitter/cli/types";
+import { Result } from "@outfitter/contracts";
+import { AddBlockResult } from "@outfitter/tooling";
+import { Command } from "commander";
+type InitStructure = "single" | "workspace";
+type InitPresetId = Extract<TargetId, "minimal" | "cli" | "mcp" | "daemon">;
+/**
+* Options for the init command.
+*/
+interface InitOptions {
+	readonly targetDir: string;
+	readonly name: string | undefined;
+	readonly bin?: string | undefined;
+	readonly preset?: InitPresetId | undefined;
+	/** @deprecated Use `preset` instead. */
+	readonly template?: string | undefined;
+	readonly structure?: InitStructure | undefined;
+	readonly workspaceName?: string | undefined;
+	readonly local?: boolean | undefined;
+	readonly force: boolean;
+	readonly with?: string | undefined;
+	readonly noTooling?: boolean | undefined;
+	readonly yes?: boolean | undefined;
+	readonly dryRun?: boolean | undefined;
+	readonly skipInstall?: boolean | undefined;
+	readonly skipGit?: boolean | undefined;
+	readonly skipCommit?: boolean | undefined;
+	readonly installTimeout?: number | undefined;
+}
+/**
+* Result of running init.
+*/
+interface InitResult {
+	readonly structure: InitStructure;
+	readonly rootDir: string;
+	readonly projectDir: string;
+	readonly preset: InitPresetId;
+	readonly packageName: string;
+	readonly blocksAdded?: AddBlockResult | undefined;
+	readonly postScaffold: PostScaffoldResult;
+	readonly dryRunPlan?: {
+		readonly operations: readonly unknown[];
+		readonly summary: Record<string, number>;
+	} | undefined;
+}
+/**
+* Error returned when initialization fails.
+*/
+declare class InitError extends Error {
+	readonly _tag: "InitError";
+	constructor(message: string);
+}
+declare function runInit(options: InitOptions, presetOverride?: InitPresetId): Promise<Result<InitResult, InitError>>;
+declare function printInitResults(result: InitResult, options?: {
+	mode?: OutputMode;
+}): Promise<void>;
+/**
+* @deprecated Use action-registry CLI wiring via `buildCliCommands(outfitterActions, ...)`.
+*/
+declare function initCommand(program: Command): void;
+export { InitStructure, InitPresetId, InitOptions, InitResult, InitError, runInit, printInitResults, initCommand };

package/dist/shared/outfitter-bn9c8p2e.js

@@ -0,0 +1,204 @@
+// @bun
+import {
+  loadDocsModule
+} from "./outfitter-zwyvewr1.js";
+
+// apps/outfitter/src/commands/repo.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import {
+  booleanFlagPreset,
+  composePresets,
+  cwdPreset,
+  stringListFlagPreset
+} from "@outfitter/cli/flags";
+import {
+  resolveDocsCliOptions,
+  withDocsCommonOptions,
+  withDocsExportOptions
+} from "@outfitter/docs";
+import { Command } from "commander";
+var require2 = createRequire(import.meta.url);
+function getIo(options) {
+  return {
+    out: options?.io?.out ?? ((line) => process.stdout.write(`${line}
+`)),
+    err: options?.io?.err ?? ((line) => process.stderr.write(`${line}
+`))
+  };
+}
+function resolveToolingCliEntrypoint() {
+  const packageJsonPath = require2.resolve("@outfitter/tooling/package.json");
+  const packageRoot = dirname(packageJsonPath);
+  const srcEntrypoint = join(packageRoot, "src", "cli", "index.ts");
+  if (existsSync(srcEntrypoint)) {
+    return srcEntrypoint;
+  }
+  const distEntrypoint = join(packageRoot, "dist", "cli", "index.js");
+  if (existsSync(distEntrypoint)) {
+    return distEntrypoint;
+  }
+  throw new Error("Unable to resolve @outfitter/tooling CLI entrypoint (expected dist/cli/index.js or src/cli/index.ts).");
+}
+async function runDocsCheckDefault(options, io) {
+  const docsModule = await loadDocsModule();
+  return await docsModule.executeCheckCommand(options, io);
+}
+async function runDocsSyncDefault(options, io) {
+  const docsModule = await loadDocsModule();
+  return await docsModule.executeSyncCommand(options, io);
+}
+async function runDocsExportDefault(options, io) {
+  const docsModule = await loadDocsModule();
+  return await docsModule.executeExportCommand(options, io);
+}
+async function runToolingCommandDefault(input) {
+  const toolingCliEntrypoint = resolveToolingCliEntrypoint();
+  const child = Bun.spawn([process.execPath, toolingCliEntrypoint, input.command, ...input.args], {
+    cwd: input.cwd,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  return await child.exited;
+}
+function applyExitCode(code) {
+  if (code !== 0) {
+    process.exitCode = code;
+  }
+}
+function applyPresetOptions(command, preset) {
+  for (const option of preset.options) {
+    command.option(option.flags, option.description, option.defaultValue);
+  }
+  return command;
+}
+function addDocsCheckSubcommand(command, options) {
+  const docsCheckCommand = command.command("docs").description("Check whether assembled package docs are in sync");
+  withDocsCommonOptions(docsCheckCommand).action(async (cmdOptions) => {
+    const code = await options.runDocsCheck(resolveDocsCliOptions(cmdOptions), options.io);
+    applyExitCode(code);
+  });
+}
+function addDocsSyncSubcommand(command, options) {
+  const docsSyncCommand = command.command("docs").description("Assemble package docs into docs/packages");
+  withDocsCommonOptions(docsSyncCommand).action(async (cmdOptions) => {
+    const code = await options.runDocsSync(resolveDocsCliOptions(cmdOptions), options.io);
+    applyExitCode(code);
+  });
+}
+function addDocsExportSubcommand(command, options) {
+  const docsExportCommand = command.command("docs").description("Export docs artifacts for packages and LLM targets");
+  withDocsExportOptions(docsExportCommand).action(async (cmdOptions) => {
+    const code = await options.runDocsExport(resolveDocsCliOptions(cmdOptions), options.io);
+    applyExitCode(code);
+  });
+}
+function addToolingCheckSubcommands(command, runToolingCommand) {
+  const cwdFlag = cwdPreset();
+  const jsonFlag = booleanFlagPreset({
+    id: "repo-check-json",
+    key: "json",
+    flags: "--json",
+    description: "Output results as JSON"
+  });
+  const skipFlag = booleanFlagPreset({
+    id: "repo-check-skip",
+    key: "skip",
+    flags: "-s, --skip",
+    description: "Skip changeset check"
+  });
+  const pathsFlag = stringListFlagPreset({
+    id: "repo-check-paths",
+    key: "paths",
+    flags: "--paths <paths...>",
+    description: "Limit check to specific paths"
+  });
+  const toolingWithCwd = composePresets(cwdFlag);
+  const toolingWithJsonAndCwd = composePresets(jsonFlag, cwdFlag);
+  const toolingWithSkipAndCwd = composePresets(skipFlag, cwdFlag);
+  const toolingWithPathsAndCwd = composePresets(pathsFlag, cwdFlag);
+  function registerToolingCheckSubcommand(config) {
+    const subcommand = command.command(config.name).description(config.description);
+    applyPresetOptions(subcommand, config.preset);
+    subcommand.action(async (cmdOptions) => {
+      const resolved = config.preset.resolve(cmdOptions);
+      const cwd = resolveDocsCliOptions({ cwd: resolved.cwd }).cwd || process.cwd();
+      const code = await runToolingCommand({
+        command: config.toolingCommand,
+        args: config.buildArgs(resolved),
+        cwd
+      });
+      applyExitCode(code);
+    });
+  }
+  registerToolingCheckSubcommand({
+    name: "exports",
+    description: "Validate package.json exports match source entry points",
+    toolingCommand: "check-exports",
+    preset: toolingWithJsonAndCwd,
+    buildArgs: (resolved) => resolved["json"] ? ["--json"] : []
+  });
+  registerToolingCheckSubcommand({
+    name: "readme",
+    description: "Validate README import examples match package exports",
+    toolingCommand: "check-readme-imports",
+    preset: toolingWithJsonAndCwd,
+    buildArgs: (resolved) => resolved["json"] ? ["--json"] : []
+  });
+  registerToolingCheckSubcommand({
+    name: "registry",
+    description: "Validate packages with bunup --filter are registered in bunup.config.ts",
+    toolingCommand: "check-bunup-registry",
+    preset: toolingWithCwd,
+    buildArgs: () => []
+  });
+  registerToolingCheckSubcommand({
+    name: "changeset",
+    description: "Validate PRs touching package source include a changeset",
+    toolingCommand: "check-changeset",
+    preset: toolingWithSkipAndCwd,
+    buildArgs: (resolved) => resolved["skip"] ? ["--skip"] : []
+  });
+  registerToolingCheckSubcommand({
+    name: "tree",
+    description: "Assert working tree is clean (no modified or untracked files)",
+    toolingCommand: "check-clean-tree",
+    preset: toolingWithPathsAndCwd,
+    buildArgs: (resolved) => Array.isArray(resolved["paths"]) && resolved["paths"].length > 0 ? ["--paths", ...resolved["paths"]] : []
+  });
+  registerToolingCheckSubcommand({
+    name: "boundary-invocations",
+    description: "Validate root/app scripts do not execute packages/*/src entrypoints directly",
+    toolingCommand: "check-boundary-invocations",
+    preset: toolingWithCwd,
+    buildArgs: () => []
+  });
+}
+function createRepoCommand(options) {
+  const io = getIo(options);
+  const runDocsCheck = options?.runDocsCheck ?? runDocsCheckDefault;
+  const runDocsSync = options?.runDocsSync ?? runDocsSyncDefault;
+  const runDocsExport = options?.runDocsExport ?? runDocsExportDefault;
+  const runToolingCommand = options?.runToolingCommand ?? runToolingCommandDefault;
+  const command = new Command(options?.commandName ?? "repo");
+  command.description("Repository maintenance commands");
+  const checkCommand = command.command("check").description("Run repository checks by subject");
+  addDocsCheckSubcommand(checkCommand, { io, runDocsCheck });
+  addToolingCheckSubcommands(checkCommand, runToolingCommand);
+  const syncCommand = command.command("sync").description("Synchronize repository artifacts by subject");
+  addDocsSyncSubcommand(syncCommand, { io, runDocsSync });
+  const exportCommand = command.command("export").description("Export repository artifacts by subject");
+  addDocsExportSubcommand(exportCommand, { io, runDocsExport });
+  return command;
+}
+async function main() {
+  const command = createRepoCommand({ commandName: "repo" });
+  await command.parseAsync(process.argv, { from: "node" });
+}
+if (import.meta.main) {
+  main();
+}
+
+export { createRepoCommand };

package/dist/shared/outfitter-bpr28y54.js

@@ -0,0 +1,70 @@
+// @bun
+// apps/outfitter/src/commands/upgrade-planner.ts
+function getMajor(version) {
+  const parts = version.split(".");
+  return Number.parseInt(parts[0] ?? "0", 10);
+}
+function getMinor(version) {
+  const parts = version.split(".");
+  return Number.parseInt(parts[1] ?? "0", 10);
+}
+function isBreaking(currentVersion, latestVersion, breakingFlag) {
+  if (breakingFlag === true)
+    return true;
+  if (breakingFlag === false)
+    return false;
+  const currentMajor = getMajor(currentVersion);
+  const latestMajor = getMajor(latestVersion);
+  if (latestMajor > currentMajor) {
+    return true;
+  }
+  if (currentMajor === 0) {
+    const currentMinor = getMinor(currentVersion);
+    const latestMinor = getMinor(latestVersion);
+    if (latestMinor > currentMinor) {
+      return true;
+    }
+  }
+  return false;
+}
+function classify(currentVersion, latestVersion, breakingFlag) {
+  if (Bun.semver.order(latestVersion, currentVersion) <= 0) {
+    return "upToDate";
+  }
+  if (isBreaking(currentVersion, latestVersion, breakingFlag)) {
+    return "upgradableBreaking";
+  }
+  return "upgradableNonBreaking";
+}
+function analyzeUpgrades(installed, latest, migrationDocs) {
+  const packages = [];
+  for (const [name, currentVersion] of installed) {
+    const latestInfo = latest.get(name);
+    const latestVersion = latestInfo?.version ?? currentVersion;
+    const breakingFlag = latestInfo?.breaking;
+    const classification = classify(currentVersion, latestVersion, breakingFlag);
+    const breaking = classification === "upgradableBreaking";
+    const migrationDoc = migrationDocs?.get(name);
+    packages.push({
+      name,
+      currentVersion,
+      latestVersion,
+      classification,
+      breaking,
+      ...migrationDoc !== undefined ? { migrationDoc } : {}
+    });
+  }
+  packages.sort((a, b) => a.name.localeCompare(b.name));
+  const summary = {
+    upToDate: 0,
+    upgradableNonBreaking: 0,
+    upgradableBreaking: 0,
+    blocked: 0
+  };
+  for (const pkg of packages) {
+    summary[pkg.classification]++;
+  }
+  return { packages, summary };
+}
+
+export { analyzeUpgrades };

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

@@ -0,0 +1,48 @@
+import { PostScaffoldResult } from "./outfitter-3weh61w7";
+import { OutputMode } from "@outfitter/cli/types";
+import { Result } from "@outfitter/contracts";
+import { AddBlockResult } from "@outfitter/tooling";
+import { Command } from "commander";
+interface ScaffoldOptions {
+	readonly target: string;
+	readonly name?: string | undefined;
+	readonly force: boolean;
+	readonly skipInstall: boolean;
+	readonly dryRun: boolean;
+	readonly with?: string | undefined;
+	readonly noTooling?: boolean | undefined;
+	readonly local?: boolean | undefined;
+	readonly cwd: string;
+	readonly installTimeout?: number | undefined;
+}
+interface ScaffoldCommandResult {
+	readonly target: string;
+	readonly rootDir: string;
+	readonly targetDir: string;
+	readonly converted: boolean;
+	readonly movedExisting?: {
+		readonly from: string;
+		readonly to: string;
+		readonly name: string;
+	} | undefined;
+	readonly workspacePatternsUpdated: boolean;
+	readonly blocksAdded?: AddBlockResult | undefined;
+	readonly postScaffold: PostScaffoldResult;
+	readonly dryRunPlan?: {
+		readonly operations: readonly unknown[];
+		readonly summary: Record<string, number>;
+	} | undefined;
+}
+declare class ScaffoldCommandError extends Error {
+	readonly _tag: "ScaffoldCommandError";
+	constructor(message: string);
+}
+declare function runScaffold(options: ScaffoldOptions): Promise<Result<ScaffoldCommandResult, ScaffoldCommandError>>;
+declare function printScaffoldResults(result: ScaffoldCommandResult, options?: {
+	readonly mode?: OutputMode;
+}): Promise<void>;
+/**
+* @deprecated Use action-registry CLI wiring via `buildCliCommands(outfitterActions, ...)`.
+*/
+declare function scaffoldCommand(program: Command): void;
+export { ScaffoldOptions, ScaffoldCommandResult, ScaffoldCommandError, runScaffold, printScaffoldResults, scaffoldCommand };