outfitter 0.2.2 → 0.2.3

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

@@ -0,0 +1,4 @@
+import { EngineOptions, ScaffoldError, ScaffoldPlan, ScaffoldResult } from "./outfitter-qfh36ddg";
+import { Result } from "@outfitter/contracts";
+declare function executePlan(plan: ScaffoldPlan, options: EngineOptions): Promise<Result<ScaffoldResult, ScaffoldError>>;
+export { executePlan };

package/dist/shared/outfitter-gp4v5gkf.js

@@ -0,0 +1,322 @@
+// @bun
+import {
+  readManifest
+} from "./outfitter-mtbpabf3.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/check.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { output } from "@outfitter/cli/output";
+import { Result } from "@outfitter/contracts";
+import { RegistrySchema } from "@outfitter/tooling";
+import { createTheme } from "@outfitter/tui/render";
+class CheckError extends Error {
+  _tag = "CheckError";
+  constructor(message) {
+    super(message);
+    this.name = "CheckError";
+  }
+}
+function getRegistryPath() {
+  let currentDir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0;i < 10; i++) {
+    const registryPath = join(currentDir, "node_modules/@outfitter/tooling/registry/registry.json");
+    if (existsSync(registryPath)) {
+      return registryPath;
+    }
+    const monoRepoPath = join(currentDir, "packages/tooling/registry/registry.json");
+    if (existsSync(monoRepoPath)) {
+      return monoRepoPath;
+    }
+    currentDir = dirname(currentDir);
+  }
+  throw new CheckError("Could not find registry.json. Ensure @outfitter/tooling is installed.");
+}
+function readToolingVersion(registryPath) {
+  try {
+    const toolingRoot = dirname(dirname(registryPath));
+    const pkgPath = join(toolingRoot, "package.json");
+    const content = readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(content);
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function loadRegistry() {
+  try {
+    const registryPath = getRegistryPath();
+    const content = readFileSync(registryPath, "utf-8");
+    const parsed = JSON.parse(content);
+    const registry = RegistrySchema.parse(parsed);
+    const toolingVersion = readToolingVersion(registryPath);
+    return Result.ok({ registry, toolingVersion });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new CheckError(`Failed to load registry: ${message}`));
+  }
+}
+function resolveBlockFiles(registry, blockName, visited = new Set) {
+  if (visited.has(blockName)) {
+    return [];
+  }
+  visited.add(blockName);
+  const block = registry.blocks[blockName];
+  if (!block) {
+    return [];
+  }
+  const files = [];
+  if (block.extends && block.extends.length > 0) {
+    for (const extendedName of block.extends) {
+      files.push(...resolveBlockFiles(registry, extendedName, visited));
+    }
+  }
+  if (block.files) {
+    files.push(...block.files);
+  }
+  return files;
+}
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return a === b;
+  if (typeof a !== typeof b)
+    return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length)
+      return false;
+    for (let i = 0;i < a.length; i++) {
+      if (!deepEqual(a[i], b[i]))
+        return false;
+    }
+    return true;
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length)
+      return false;
+    for (const key of aKeys) {
+      if (!Object.hasOwn(bObj, key))
+        return false;
+      if (!deepEqual(aObj[key], bObj[key]))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function compareFileContent(filePath, localContent, registryContent) {
+  if (filePath.endsWith(".json") || filePath.endsWith(".jsonc")) {
+    try {
+      const cleanLocal = filePath.endsWith(".jsonc") ? stripJsoncComments(localContent) : localContent;
+      const cleanRegistry = filePath.endsWith(".jsonc") ? stripJsoncComments(registryContent) : registryContent;
+      const localParsed = JSON.parse(cleanLocal);
+      const registryParsed = JSON.parse(cleanRegistry);
+      return deepEqual(localParsed, registryParsed);
+    } catch {}
+  }
+  return localContent === registryContent;
+}
+function stripJsoncComments(content) {
+  return content.split(`
+`).map((line) => {
+    let inString = false;
+    for (let i = 0;i < line.length; i++) {
+      const char = line[i];
+      if (char === '"' && (i === 0 || line[i - 1] !== "\\")) {
+        inString = !inString;
+      }
+      if (!inString && char === "/" && line[i + 1] === "/") {
+        return line.slice(0, i).trimEnd();
+      }
+    }
+    return line;
+  }).filter((line) => line.trim() !== "").join(`
+`);
+}
+var BLOCK_FILE_MARKERS = {
+  biome: ["biome.json"],
+  lefthook: [".lefthook.yml"],
+  claude: [".claude/settings.json"],
+  markdownlint: [".markdownlint-cli2.jsonc"],
+  bootstrap: ["scripts/bootstrap.sh"]
+};
+function detectBlocksByFilePresence(cwd) {
+  const detected = [];
+  for (const [blockName, files] of Object.entries(BLOCK_FILE_MARKERS)) {
+    const hasAnyFile = files.some((filePath) => existsSync(join(cwd, filePath)));
+    if (hasAnyFile) {
+      detected.push(blockName);
+    }
+  }
+  return detected;
+}
+function checkBlock(cwd, blockName, registry, toolingVersion, installedFrom, verbose) {
+  const versionFields = {
+    ...installedFrom !== undefined ? { installedFrom } : {},
+    currentToolingVersion: toolingVersion
+  };
+  const files = resolveBlockFiles(registry, blockName);
+  if (files.length === 0 && !registry.blocks[blockName]) {
+    return {
+      name: blockName,
+      status: "missing",
+      ...versionFields
+    };
+  }
+  if (files.length === 0) {
+    return {
+      name: blockName,
+      status: "current",
+      ...versionFields
+    };
+  }
+  let allMissing = true;
+  let anyDrifted = false;
+  const driftedFiles = [];
+  for (const file of files) {
+    const localPath = join(cwd, file.path);
+    if (!existsSync(localPath)) {
+      anyDrifted = true;
+      if (verbose) {
+        driftedFiles.push({ path: file.path, reason: "missing" });
+      }
+      continue;
+    }
+    allMissing = false;
+    const localContent = readFileSync(localPath, "utf-8");
+    if (!compareFileContent(file.path, localContent, file.content)) {
+      anyDrifted = true;
+      if (verbose) {
+        driftedFiles.push({ path: file.path, reason: "modified" });
+      }
+    }
+  }
+  if (allMissing) {
+    return {
+      name: blockName,
+      status: "missing",
+      ...versionFields,
+      ...verbose && driftedFiles.length > 0 ? { driftedFiles } : {}
+    };
+  }
+  if (anyDrifted) {
+    return {
+      name: blockName,
+      status: "drifted",
+      ...versionFields,
+      ...verbose && driftedFiles.length > 0 ? { driftedFiles } : {}
+    };
+  }
+  return {
+    name: blockName,
+    status: "current",
+    ...versionFields
+  };
+}
+async function runCheck(options) {
+  const { cwd: rawCwd, verbose = false, block: blockFilter } = options;
+  const cwd = resolve(rawCwd);
+  const registryResult = loadRegistry();
+  if (registryResult.isErr()) {
+    return registryResult;
+  }
+  const { registry, toolingVersion } = registryResult.value;
+  const manifestResult = await readManifest(cwd);
+  if (manifestResult.isErr()) {
+    return Result.err(new CheckError(`Failed to read manifest: ${manifestResult.error.message}`));
+  }
+  const manifest = manifestResult.value;
+  let blocksToCheck;
+  if (manifest) {
+    blocksToCheck = Object.entries(manifest.blocks).map(([name, entry]) => ({
+      name,
+      installedFrom: entry.installedFrom
+    }));
+  } else {
+    const detected = detectBlocksByFilePresence(cwd);
+    blocksToCheck = detected.map((name) => ({
+      name,
+      installedFrom: undefined
+    }));
+  }
+  if (blockFilter) {
+    blocksToCheck = blocksToCheck.filter((b) => b.name === blockFilter);
+  }
+  const blocks = [];
+  for (const { name, installedFrom } of blocksToCheck) {
+    blocks.push(checkBlock(cwd, name, registry, toolingVersion, installedFrom, verbose));
+  }
+  const currentCount = blocks.filter((b) => b.status === "current").length;
+  const driftedCount = blocks.filter((b) => b.status === "drifted").length;
+  const missingCount = blocks.filter((b) => b.status === "missing").length;
+  return Result.ok({
+    blocks,
+    totalChecked: blocks.length,
+    currentCount,
+    driftedCount,
+    missingCount
+  });
+}
+async function printCheckResults(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    await output(result, { mode: structuredMode });
+    return;
+  }
+  const theme = createTheme();
+  const lines = [];
+  lines.push("");
+  lines.push("Outfitter Check");
+  lines.push("=".repeat(50));
+  lines.push("");
+  for (const block of result.blocks) {
+    let statusIcon;
+    switch (block.status) {
+      case "current":
+        statusIcon = theme.success("[PASS]");
+        break;
+      case "drifted":
+        statusIcon = theme.error("[DRIFT]");
+        break;
+      case "missing":
+        statusIcon = theme.warning("[MISSING]");
+        break;
+      default:
+        statusIcon = "[?]";
+    }
+    const versionInfo = block.installedFrom ? ` (installed from ${block.installedFrom})` : "";
+    lines.push(`${statusIcon} ${block.name}${versionInfo}`);
+    if (options?.verbose && block.driftedFiles) {
+      for (const file of block.driftedFiles) {
+        const reason = file.reason === "missing" ? "file missing" : "modified";
+        lines.push(`       ${theme.muted(`${file.path}: ${reason}`)}`);
+      }
+    }
+  }
+  lines.push("");
+  lines.push("=".repeat(50));
+  const summaryColor = result.driftedCount === 0 && result.missingCount === 0 ? theme.success : theme.error;
+  lines.push(summaryColor(`${result.currentCount}/${result.totalChecked} blocks current`));
+  if (result.driftedCount > 0) {
+    lines.push(theme.muted(`${result.driftedCount} block(s) have drifted`));
+  }
+  if (result.missingCount > 0) {
+    lines.push(theme.muted(`${result.missingCount} block(s) have missing files`));
+  }
+  if (result.driftedCount > 0 || result.missingCount > 0) {
+    lines.push("");
+    lines.push(theme.muted("Run 'outfitter add <block> --force' to restore registry defaults."));
+  }
+  await output(lines, { mode: "human" });
+}
+
+export { CheckError, runCheck, printCheckResults };

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

@@ -0,0 +1,14 @@
+import { EngineOptions, PlaceholderValues, ScaffoldError } from "./outfitter-qfh36ddg";
+import { Result } from "@outfitter/contracts";
+declare function getTemplatesDir(): string;
+declare function getOutputFilename(templateFilename: string): string;
+declare function isBinaryFile(filename: string): boolean;
+declare function replacePlaceholders(content: string, values: PlaceholderValues): string;
+declare function copyTemplateFiles(templateDir: string, targetDir: string, values: PlaceholderValues, options: EngineOptions, copyOptions?: {
+	readonly allowOverwrite?: boolean;
+	readonly overwritablePaths?: ReadonlySet<string>;
+	readonly writtenPaths?: Set<string>;
+	readonly skipFilter?: (relativePath: string) => boolean;
+	readonly relativePrefix?: string;
+}): Result<void, ScaffoldError>;
+export { getTemplatesDir, getOutputFilename, isBinaryFile, replacePlaceholders, copyTemplateFiles };

package/dist/shared/outfitter-hpymx4m9.js

@@ -0,0 +1,184 @@
+// @bun
+import {
+  loadDocsModule
+} from "./outfitter-zwyvewr1.js";
+
+// apps/outfitter/src/commands/repo.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join, resolve } from "path";
+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 resolveCwdOption(inputCwd) {
+  if (typeof inputCwd !== "string" || inputCwd.length === 0) {
+    return process.cwd();
+  }
+  return resolve(process.cwd(), inputCwd);
+}
+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 addDocsCheckSubcommand(command, options) {
+  command.command("docs").description("Check whether assembled package docs are in sync").option("--cwd <path>", "Workspace root to operate in").option("--packages-dir <path>", "Packages directory relative to workspace").option("--output-dir <path>", "Output directory relative to workspace").option("--mdx-mode <mode>", "MDX handling mode: strict or lossy").action(async (cmdOptions) => {
+    const code = await options.runDocsCheck({
+      ...cmdOptions,
+      ...cmdOptions.cwd ? { cwd: resolveCwdOption(cmdOptions.cwd) } : {}
+    }, options.io);
+    applyExitCode(code);
+  });
+}
+function addDocsSyncSubcommand(command, options) {
+  command.command("docs").description("Assemble package docs into docs/packages").option("--cwd <path>", "Workspace root to operate in").option("--packages-dir <path>", "Packages directory relative to workspace").option("--output-dir <path>", "Output directory relative to workspace").option("--mdx-mode <mode>", "MDX handling mode: strict or lossy").action(async (cmdOptions) => {
+    const code = await options.runDocsSync({
+      ...cmdOptions,
+      ...cmdOptions.cwd ? { cwd: resolveCwdOption(cmdOptions.cwd) } : {}
+    }, options.io);
+    applyExitCode(code);
+  });
+}
+function addDocsExportSubcommand(command, options) {
+  command.command("docs").description("Export docs artifacts for packages and LLM targets").option("--cwd <path>", "Workspace root to operate in").option("--packages-dir <path>", "Packages directory relative to workspace").option("--output-dir <path>", "Output directory relative to workspace").option("--mdx-mode <mode>", "MDX handling mode: strict or lossy").option("--llms-file <path>", "llms.txt output path relative to workspace").option("--llms-full-file <path>", "llms-full.txt output path relative to workspace").option("--target <target>", "Export target: packages, llms, llms-full, all", "all").action(async (cmdOptions) => {
+    const code = await options.runDocsExport({
+      ...cmdOptions,
+      ...cmdOptions.cwd ? { cwd: resolveCwdOption(cmdOptions.cwd) } : {}
+    }, options.io);
+    applyExitCode(code);
+  });
+}
+function addToolingCheckSubcommands(command, runToolingCommand) {
+  command.command("exports").description("Validate package.json exports match source entry points").option("--json", "Output results as JSON").option("--cwd <path>", "Workspace root to operate in").action(async (cmdOptions) => {
+    const args = [];
+    if (cmdOptions.json) {
+      args.push("--json");
+    }
+    const code = await runToolingCommand({
+      command: "check-exports",
+      args,
+      cwd: resolveCwdOption(cmdOptions.cwd)
+    });
+    applyExitCode(code);
+  });
+  command.command("readme").description("Validate README import examples match package exports").option("--json", "Output results as JSON").option("--cwd <path>", "Workspace root to operate in").action(async (cmdOptions) => {
+    const args = [];
+    if (cmdOptions.json) {
+      args.push("--json");
+    }
+    const code = await runToolingCommand({
+      command: "check-readme-imports",
+      args,
+      cwd: resolveCwdOption(cmdOptions.cwd)
+    });
+    applyExitCode(code);
+  });
+  command.command("registry").description("Validate packages with bunup --filter are registered in bunup.config.ts").option("--cwd <path>", "Workspace root to operate in").action(async (cmdOptions) => {
+    const code = await runToolingCommand({
+      command: "check-bunup-registry",
+      args: [],
+      cwd: resolveCwdOption(cmdOptions.cwd)
+    });
+    applyExitCode(code);
+  });
+  command.command("changeset").description("Validate PRs touching package source include a changeset").option("-s, --skip", "Skip changeset check").option("--cwd <path>", "Workspace root to operate in").action(async (cmdOptions) => {
+    const args = [];
+    if (cmdOptions.skip) {
+      args.push("--skip");
+    }
+    const code = await runToolingCommand({
+      command: "check-changeset",
+      args,
+      cwd: resolveCwdOption(cmdOptions.cwd)
+    });
+    applyExitCode(code);
+  });
+  command.command("tree").description("Assert working tree is clean (no modified or untracked files)").option("--paths <paths...>", "Limit check to specific paths").option("--cwd <path>", "Workspace root to operate in").action(async (cmdOptions) => {
+    const args = [];
+    if (Array.isArray(cmdOptions.paths) && cmdOptions.paths.length > 0) {
+      args.push("--paths", ...cmdOptions.paths);
+    }
+    const code = await runToolingCommand({
+      command: "check-clean-tree",
+      args,
+      cwd: resolveCwdOption(cmdOptions.cwd)
+    });
+    applyExitCode(code);
+  });
+  command.command("boundary-invocations").description("Validate root/app scripts do not execute packages/*/src entrypoints directly").option("--cwd <path>", "Workspace root to operate in").action(async (cmdOptions) => {
+    const code = await runToolingCommand({
+      command: "check-boundary-invocations",
+      args: [],
+      cwd: resolveCwdOption(cmdOptions.cwd)
+    });
+    applyExitCode(code);
+  });
+}
+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-hvsaxgcp.js

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

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

@@ -0,0 +1,22 @@
+import { ExecuteCheckCommandOptions, ExecuteExportCommandOptions, ExecuteSyncCommandOptions } from "./outfitter-dd0btgec";
+import { Command } from "commander";
+type RepoCheckSubject = "docs" | "exports" | "readme" | "registry" | "changeset" | "tree" | "boundary-invocations";
+interface RepoCommandIo {
+	readonly out?: (line: string) => void;
+	readonly err?: (line: string) => void;
+}
+interface RepoToolingInvocation {
+	readonly command: "check-exports" | "check-readme-imports" | "check-bunup-registry" | "check-changeset" | "check-clean-tree" | "check-boundary-invocations";
+	readonly args: readonly string[];
+	readonly cwd: string;
+}
+interface CreateRepoCommandOptions {
+	readonly commandName?: string;
+	readonly io?: RepoCommandIo;
+	readonly runDocsCheck?: (options: ExecuteCheckCommandOptions, io: Required<RepoCommandIo>) => Promise<number>;
+	readonly runDocsSync?: (options: ExecuteSyncCommandOptions, io: Required<RepoCommandIo>) => Promise<number>;
+	readonly runDocsExport?: (options: ExecuteExportCommandOptions, io: Required<RepoCommandIo>) => Promise<number>;
+	readonly runToolingCommand?: (input: RepoToolingInvocation) => Promise<number>;
+}
+declare function createRepoCommand(options?: CreateRepoCommandOptions): Command;
+export { RepoCheckSubject, RepoCommandIo, RepoToolingInvocation, CreateRepoCommandOptions, createRepoCommand };