outfitter 0.3.2 → 0.3.3

package/dist/shared/outfitter-e84cr97g.js

@@ -0,0 +1,232 @@
+// @bun
+import {
+  loadDocsModule
+} from "./outfitter-svts4wk2.js";
+
+// apps/outfitter/src/commands/repo.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join, resolve } from "path";
+import {
+  booleanFlagPreset,
+  composePresets,
+  cwdPreset,
+  stringListFlagPreset
+} from "@outfitter/cli/flags";
+import { Command } from "commander";
+var require2 = createRequire(import.meta.url);
+var DOCS_COMMON_OPTION_FLAGS = [
+  "--cwd <path>",
+  "--packages-dir <path>",
+  "--output-dir <path>",
+  "--mdx-mode <mode>"
+];
+var DOCS_EXPORT_OPTION_FLAGS = [
+  "--llms-file <path>",
+  "--llms-full-file <path>",
+  "--target <target>"
+];
+function withDocsCommonOptions(command) {
+  return command.option(DOCS_COMMON_OPTION_FLAGS[0], "Workspace root to operate in").option(DOCS_COMMON_OPTION_FLAGS[1], "Packages directory relative to workspace").option(DOCS_COMMON_OPTION_FLAGS[2], "Output directory relative to workspace").option(DOCS_COMMON_OPTION_FLAGS[3], "MDX handling mode: strict or lossy");
+}
+function withDocsExportOptions(command) {
+  return withDocsCommonOptions(command).option(DOCS_EXPORT_OPTION_FLAGS[0], "llms.txt output path relative to workspace").option(DOCS_EXPORT_OPTION_FLAGS[1], "llms-full.txt output path relative to workspace").option(DOCS_EXPORT_OPTION_FLAGS[2], "Export target: packages, llms, llms-full, all", "all");
+}
+function resolveDocsCliOptions(options) {
+  if (typeof options.cwd !== "string" || options.cwd.length === 0) {
+    return options;
+  }
+  return {
+    ...options,
+    cwd: resolve(process.cwd(), options.cwd)
+  };
+}
+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 mirrors locally");
+  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: () => []
+  });
+  registerToolingCheckSubcommand({
+    name: "markdown-links",
+    description: "Validate relative links in markdown files resolve to existing files",
+    toolingCommand: "check-markdown-links",
+    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 { DOCS_COMMON_OPTION_FLAGS, DOCS_EXPORT_OPTION_FLAGS, createRepoCommand };

package/dist/shared/outfitter-ec83h4v2.js

@@ -0,0 +1,17 @@
+// @bun
+// apps/outfitter/src/actions/docs-output-mode.ts
+function resolveDocsOutputMode(flags, presetOutputMode) {
+  const explicitOutput = typeof flags["output"] === "string";
+  if (explicitOutput) {
+    return presetOutputMode === "json" || presetOutputMode === "jsonl" ? presetOutputMode : "human";
+  }
+  if (process.env["OUTFITTER_JSONL"] === "1") {
+    return "jsonl";
+  }
+  if (process.env["OUTFITTER_JSON"] === "1") {
+    return "json";
+  }
+  return "human";
+}
+
+export { resolveDocsOutputMode };

package/dist/shared/outfitter-eepj7rf7.js

@@ -0,0 +1,4 @@
+// @bun
+var __require = import.meta.require;
+
+export { __require };

package/dist/shared/outfitter-ekb6t1zz.js

@@ -0,0 +1,35 @@
+// @bun
+// apps/outfitter/src/create/presets.ts
+var CREATE_PRESETS = {
+  basic: {
+    id: "basic",
+    presetDir: "basic",
+    summary: "Minimal Bun + TypeScript project.",
+    defaultBlocks: ["scaffolding"]
+  },
+  cli: {
+    id: "cli",
+    presetDir: "cli",
+    summary: "CLI starter with Outfitter command ergonomics.",
+    defaultBlocks: ["scaffolding"]
+  },
+  daemon: {
+    id: "daemon",
+    presetDir: "daemon",
+    summary: "Daemon + control CLI starter.",
+    defaultBlocks: ["scaffolding"]
+  },
+  mcp: {
+    id: "mcp",
+    presetDir: "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-ex8gn945.js

@@ -0,0 +1,51 @@
+// @bun
+import {
+  outputModeSchema,
+  resolveCwdFromPreset
+} from "./outfitter-7n7vsz95.js";
+import {
+  printDoctorResults,
+  runDoctor
+} from "./outfitter-px5sv5gn.js";
+import {
+  resolveOutputModeFromContext
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/actions/doctor.ts
+import { cwdPreset } from "@outfitter/cli/flags";
+import { defineAction, Result } from "@outfitter/contracts";
+import { z } from "zod";
+var doctorInputSchema = z.object({
+  cwd: z.string(),
+  outputMode: outputModeSchema
+});
+var doctorCwd = cwdPreset();
+var doctorAction = defineAction({
+  id: "doctor",
+  description: "Validate environment and dependencies",
+  surfaces: ["cli"],
+  input: doctorInputSchema,
+  cli: {
+    command: "doctor",
+    description: "Validate environment and dependencies",
+    options: [...doctorCwd.options],
+    mapInput: (context) => {
+      const outputMode = resolveOutputModeFromContext(context.flags);
+      return {
+        cwd: resolveCwdFromPreset(context.flags, doctorCwd),
+        outputMode
+      };
+    }
+  },
+  handler: async (input) => {
+    const { outputMode, ...doctorInput } = input;
+    const result = await runDoctor(doctorInput);
+    await printDoctorResults(result, { mode: outputMode });
+    if (result.exitCode !== 0) {
+      process.exit(result.exitCode);
+    }
+    return Result.ok(result);
+  }
+});
+
+export { doctorAction };

package/dist/shared/outfitter-f3a70135.js

@@ -0,0 +1,75 @@
+// @bun
+// apps/outfitter/src/commands/upgrade-apply.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { InternalError, Result } from "@outfitter/contracts";
+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 applyUpdates(cwd, updates) {
+  const pkgPath = join(cwd, "package.json");
+  let raw;
+  try {
+    raw = readFileSync(pkgPath, "utf-8");
+  } catch {
+    return Result.err(InternalError.create("Failed to read package.json for apply", { cwd }));
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(raw);
+  } catch {
+    return Result.err(InternalError.create("Invalid JSON in package.json", { cwd }));
+  }
+  const updateMap = new Map;
+  for (const update of updates) {
+    updateMap.set(update.name, update.latestVersion);
+  }
+  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;
+      const prefix = getVersionPrefix(currentSpecifier);
+      deps[name] = `${prefix}${newVersion}`;
+    }
+  }
+  try {
+    const updated = `${JSON.stringify(pkg, null, 2)}
+`;
+    await Bun.write(pkgPath, updated);
+  } catch {
+    return Result.err(InternalError.create("Failed to write updated package.json", { 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 { applyUpdates };

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

@@ -0,0 +1,13 @@
+import { copyPresetFiles, replacePlaceholders } from "./outfitter-6rtcemk7.js";
+/**
+* @deprecated Use `getPresetsBaseDir` instead.
+*/
+declare function getTemplatesDir(): string;
+/**
+* @deprecated Use `copyPresetFiles` instead.
+*/
+declare function copyTemplateFiles(...args: Parameters<typeof copyPresetFiles>): ReturnType<typeof copyPresetFiles>;
+declare function getOutputFilename(templateFilename: string): string;
+declare function isBinaryFile(filename: string): boolean;
+declare function replacePlaceholders2(content: string, values: Parameters<typeof replacePlaceholders>[1]): string;
+export { getTemplatesDir, copyTemplateFiles, getOutputFilename, isBinaryFile, replacePlaceholders2 as replacePlaceholders };

package/dist/shared/outfitter-fj2v5ffz.js

@@ -0,0 +1,165 @@
+// @bun
+import {
+  loadDocsModule
+} from "./outfitter-svts4wk2.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/check-docs-sentinel.ts
+import { readFile } from "fs/promises";
+import { join, resolve } from "path";
+import { Result } from "@outfitter/contracts";
+var SECTION_ID = "PACKAGE_LIST";
+var BEGIN_TAG = `<!-- BEGIN:GENERATED:${SECTION_ID} -->`;
+var END_TAG = `<!-- END:GENERATED:${SECTION_ID} -->`;
+function escapeRegExpLiteral(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function replaceSentinelSectionFallback(input, sentinelId, replacement) {
+  const beginTag = `<!-- BEGIN:GENERATED:${sentinelId} -->`;
+  const endTag = `<!-- END:GENERATED:${sentinelId} -->`;
+  const pattern = new RegExp(`${escapeRegExpLiteral(beginTag)}[\\s\\S]*?${escapeRegExpLiteral(endTag)}`);
+  if (!pattern.test(input)) {
+    return input;
+  }
+  return input.replace(pattern, `${beginTag}
+${replacement}
+${endTag}`);
+}
+function extractSentinelBodies(input, sentinelId) {
+  const beginTag = `<!-- BEGIN:GENERATED:${sentinelId} -->`;
+  const endTag = `<!-- END:GENERATED:${sentinelId} -->`;
+  const pattern = new RegExp(`${escapeRegExpLiteral(beginTag)}[\\s\\n\\r]*([\\s\\S]*?)[\\s\\n\\r]*${escapeRegExpLiteral(endTag)}`, "g");
+  const bodies = [];
+  for (const match of input.matchAll(pattern)) {
+    const body = match[1];
+    if (typeof body === "string") {
+      bodies.push(body);
+    }
+  }
+  return bodies;
+}
+
+class CheckDocsSentinelError extends Error {
+  _tag = "CheckDocsSentinelError";
+  constructor(message) {
+    super(message);
+    this.name = "CheckDocsSentinelError";
+  }
+}
+function checkDocsReadmeSentinelContent(readmeContent, packageListContent, replaceSentinelSection = replaceSentinelSectionFallback) {
+  if (!(readmeContent.includes(BEGIN_TAG) && readmeContent.includes(END_TAG))) {
+    return { reason: "missing-markers", updatedContent: readmeContent };
+  }
+  const currentBodies = extractSentinelBodies(readmeContent, SECTION_ID);
+  const expectedBody = packageListContent.trim();
+  if (currentBodies.length > 0 && currentBodies.every((body) => body.trim() === expectedBody)) {
+    return { reason: "up-to-date", updatedContent: readmeContent };
+  }
+  const updatedContent = replaceSentinelSection(readmeContent, SECTION_ID, packageListContent);
+  if (updatedContent !== readmeContent) {
+    return { reason: "out-of-date", updatedContent };
+  }
+  return { reason: "up-to-date", updatedContent };
+}
+async function runCheckDocsSentinel(options) {
+  try {
+    const workspaceRoot = resolve(options.cwd);
+    const readmePath = join(workspaceRoot, "docs", "README.md");
+    const docsModule = await loadDocsModule();
+    const [readmeContent, packageListContent] = await Promise.all([
+      readFile(readmePath, "utf8"),
+      docsModule.generatePackageListSection(workspaceRoot)
+    ]);
+    const result = checkDocsReadmeSentinelContent(readmeContent, packageListContent, docsModule.replaceSentinelSection);
+    return Result.ok({
+      readmePath,
+      reason: result.reason,
+      updatedContent: result.updatedContent,
+      ok: result.reason === "up-to-date"
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to check docs README sentinel";
+    return Result.err(new CheckDocsSentinelError(message));
+  }
+}
+async function printCheckDocsSentinelResult(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    const serialized = structuredMode === "json" ? JSON.stringify(result, null, 2) : JSON.stringify(result);
+    process.stdout.write(`${serialized}
+`);
+    return;
+  }
+  if (result.reason === "up-to-date") {
+    process.stdout.write(`docs/README.md PACKAGE_LIST sentinel is up to date.
+`);
+    return;
+  }
+  if (result.reason === "missing-markers") {
+    process.stderr.write(`docs/README.md is missing PACKAGE_LIST sentinel markers.
+Run 'bun run docs:sync:readme' to regenerate sentinel sections.
+`);
+    return;
+  }
+  process.stderr.write(`docs/README.md PACKAGE_LIST sentinel is stale.
+Run 'bun run docs:sync:readme' to regenerate sentinel sections.
+`);
+}
+function parseCliArgs(argv) {
+  let cwd = process.cwd();
+  let outputMode = "human";
+  for (let index = 0;index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg === "--cwd") {
+      const value = argv[index + 1];
+      if (!value) {
+        throw new CheckDocsSentinelError("Missing value for --cwd");
+      }
+      cwd = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--json") {
+      outputMode = "json";
+      continue;
+    }
+    if (arg === "--jsonl") {
+      outputMode = "jsonl";
+      continue;
+    }
+  }
+  return {
+    cwd: resolve(cwd),
+    outputMode
+  };
+}
+async function runCheckDocsSentinelFromArgv(argv) {
+  let parsed;
+  try {
+    parsed = parseCliArgs(argv);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid command arguments";
+    process.stderr.write(`${message}
+`);
+    return 1;
+  }
+  const result = await runCheckDocsSentinel({ cwd: parsed.cwd });
+  if (result.isErr()) {
+    process.stderr.write(`${result.error.message}
+`);
+    return 1;
+  }
+  await printCheckDocsSentinelResult(result.value, {
+    mode: parsed.outputMode
+  });
+  return result.value.ok ? 0 : 1;
+}
+if (import.meta.main) {
+  runCheckDocsSentinelFromArgv(process.argv.slice(2)).then((exitCode) => {
+    process.exit(exitCode);
+  });
+}
+
+export { CheckDocsSentinelError, checkDocsReadmeSentinelContent, runCheckDocsSentinel, printCheckDocsSentinelResult, runCheckDocsSentinelFromArgv };