outfitter 0.2.7 → 0.3.3

package/dist/shared/outfitter-84chvazx.js

@@ -0,0 +1,480 @@
+// @bun
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/check-orchestrator.ts
+import { resolve } from "path";
+import { Result } from "@outfitter/contracts";
+import { createTheme } from "@outfitter/tui/render";
+var SUCCESS_ADVISORY_PATTERNS = [
+  /\bwarn(?:ing)?\b/i,
+  /\bno changeset found\b/i,
+  /\bconsider adding one\b/i,
+  /\binvalid changeset package reference\b/i
+];
+
+class CheckOrchestratorError extends Error {
+  _tag = "CheckOrchestratorError";
+  constructor(message) {
+    super(message);
+    this.name = "CheckOrchestratorError";
+  }
+}
+function normalizePaths(paths) {
+  if (!paths || paths.length === 0) {
+    return [];
+  }
+  return paths.map((path) => path.trim()).filter((path) => path.length > 0).toSorted();
+}
+function shouldSyncAgentScaffolding(paths) {
+  return paths.some((path) => path === ".claude/settings.json" || path.startsWith(".claude/hooks/"));
+}
+function buildCheckOrchestratorPlan(options) {
+  const stagedFiles = normalizePaths(options.stagedFiles);
+  if (options.mode === "all" || options.mode === "ci") {
+    const steps = [
+      {
+        id: "block-drift",
+        label: "Block drift",
+        command: [
+          "bun",
+          "run",
+          "apps/outfitter/src/cli.ts",
+          "check",
+          "--manifest-only",
+          "--cwd",
+          "."
+        ]
+      },
+      {
+        id: "typecheck",
+        label: "Typecheck",
+        command: ["bun", "run", "typecheck", "--", "--only"]
+      },
+      {
+        id: "lint-and-format",
+        label: "Lint/Format checks",
+        command: ["bun", "run", "check"]
+      },
+      {
+        id: "publish-guardrails",
+        label: "Publish guardrails",
+        command: [
+          "bun",
+          "run",
+          "apps/outfitter/src/cli.ts",
+          "check",
+          "publish-guardrails",
+          "--cwd",
+          "."
+        ]
+      },
+      {
+        id: "changeset",
+        label: "Changeset",
+        command: [
+          "bun",
+          "run",
+          "apps/outfitter/src/commands/repo.ts",
+          "check",
+          "changeset",
+          "--cwd",
+          "."
+        ]
+      },
+      {
+        id: "registry",
+        label: "Bunup registry",
+        command: [
+          "bun",
+          "run",
+          "apps/outfitter/src/commands/repo.ts",
+          "check",
+          "registry",
+          "--cwd",
+          "."
+        ]
+      },
+      {
+        id: "preset-versions",
+        label: "Preset dependency versions",
+        command: [
+          "bun",
+          "run",
+          "apps/outfitter/src/cli.ts",
+          "check",
+          "preset-versions",
+          "--cwd",
+          "."
+        ]
+      },
+      {
+        id: "action-ceremony",
+        label: "Action ceremony guardrails",
+        command: [
+          "bun",
+          "run",
+          "apps/outfitter/src/cli.ts",
+          "check",
+          "action-ceremony",
+          "--cwd",
+          "."
+        ]
+      },
+      {
+        id: "docs-sentinel",
+        label: "Docs readme sentinel",
+        command: [
+          "bun",
+          "run",
+          "apps/outfitter/src/cli.ts",
+          "check",
+          "docs-sentinel",
+          "--cwd",
+          "."
+        ]
+      },
+      {
+        id: "docs-links",
+        label: "Markdown links",
+        command: [
+          "bun",
+          "run",
+          "apps/outfitter/src/commands/repo.ts",
+          "check",
+          "markdown-links",
+          "--cwd",
+          "."
+        ]
+      },
+      {
+        id: "exports",
+        label: "Exports",
+        command: [
+          "bun",
+          "run",
+          "apps/outfitter/src/commands/repo.ts",
+          "check",
+          "exports",
+          "--cwd",
+          "."
+        ]
+      },
+      {
+        id: "readme-imports",
+        label: "README imports",
+        command: [
+          "bun",
+          "run",
+          "apps/outfitter/src/commands/repo.ts",
+          "check",
+          "readme",
+          "--cwd",
+          "."
+        ]
+      },
+      {
+        id: "exports-normalized",
+        label: "Exports normalized",
+        command: ["bun", "run", "exports:check"]
+      },
+      {
+        id: "tree-clean",
+        label: "Working tree clean",
+        command: [
+          "bun",
+          "run",
+          "apps/outfitter/src/commands/repo.ts",
+          "check",
+          "tree",
+          "--cwd",
+          "."
+        ]
+      },
+      {
+        id: "boundary-invocations",
+        label: "Boundary invocations",
+        command: [
+          "bun",
+          "run",
+          "apps/outfitter/src/commands/repo.ts",
+          "check",
+          "boundary-invocations",
+          "--cwd",
+          "."
+        ]
+      },
+      {
+        id: "surface-map-canonical",
+        label: "Surface map canonical path",
+        command: [
+          "bun",
+          "run",
+          "apps/outfitter/src/cli.ts",
+          "check",
+          "surface-map",
+          "--cwd",
+          "."
+        ]
+      },
+      {
+        id: "surface-map-format",
+        label: "Surface map format",
+        command: [
+          "bun",
+          "run",
+          "apps/outfitter/src/cli.ts",
+          "check",
+          "surface-map-format",
+          "--cwd",
+          "."
+        ]
+      },
+      {
+        id: "schema-diff",
+        label: "Schema drift",
+        command: ["bun", "run", "schema:diff"]
+      }
+    ];
+    if (options.mode === "ci") {
+      steps.push({
+        id: "tests",
+        label: "Tests",
+        command: ["bun", "run", "test:ci"]
+      });
+    }
+    return steps;
+  }
+  if (options.mode === "pre-push") {
+    return [
+      {
+        id: "block-drift",
+        label: "Block drift",
+        command: [
+          "bun",
+          "run",
+          "apps/outfitter/src/cli.ts",
+          "check",
+          "--manifest-only",
+          "--cwd",
+          "."
+        ]
+      },
+      {
+        id: "pre-push-verify",
+        label: "Hook verify",
+        command: [
+          "bun",
+          "run",
+          "packages/tooling/src/cli/index.ts",
+          "pre-push"
+        ]
+      },
+      {
+        id: "schema-drift",
+        label: "Schema drift",
+        command: ["bun", "run", "apps/outfitter/src/cli.ts", "schema", "diff"]
+      }
+    ];
+  }
+  const hasStagedFiles = stagedFiles.length > 0;
+  const tsFiles = stagedFiles.filter((f) => /\.(ts|tsx)$/.test(f));
+  const preCommitSteps = [
+    {
+      id: "ultracite-fix",
+      label: "Ultracite fix",
+      command: hasStagedFiles ? ["bun", "x", "ultracite", "fix", ...stagedFiles] : ["bun", "x", "ultracite", "fix", "."]
+    },
+    {
+      id: "exports",
+      label: "Exports",
+      command: ["bun", "run", "check-exports"]
+    }
+  ];
+  if (tsFiles.length > 0) {
+    preCommitSteps.splice(1, 0, {
+      id: "typecheck",
+      label: "Typecheck",
+      command: ["./scripts/pre-commit-typecheck.sh", ...tsFiles]
+    });
+  } else if (!hasStagedFiles) {
+    preCommitSteps.splice(1, 0, {
+      id: "typecheck",
+      label: "Typecheck",
+      command: ["bun", "run", "typecheck", "--", "--only"]
+    });
+  }
+  if (shouldSyncAgentScaffolding(stagedFiles)) {
+    preCommitSteps.push({
+      id: "sync-agent-scaffolding",
+      label: "Sync agent scaffolding",
+      command: ["./scripts/sync-agent-scaffolding.sh"]
+    });
+  }
+  return preCommitSteps;
+}
+function parseTreePaths(statusOutput) {
+  return statusOutput.split(`
+`).filter((line) => line.length >= 3).map((line) => {
+    const payload = line.slice(3).trim();
+    const renameParts = payload.split(" -> ");
+    return renameParts.at(-1) ?? payload;
+  }).toSorted();
+}
+function readTreePaths(cwd) {
+  const result = Bun.spawnSync(["git", "status", "--porcelain"], {
+    cwd,
+    stderr: "ignore"
+  });
+  if (result.exitCode !== 0) {
+    return [];
+  }
+  return parseTreePaths(result.stdout.toString());
+}
+function diffTreePaths(before, after) {
+  const beforeSet = new Set(before);
+  return after.filter((path) => !beforeSet.has(path));
+}
+async function runStep(cwd, step) {
+  const startedAt = Date.now();
+  const processHandle = Bun.spawn([...step.command], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    processHandle.exited,
+    new Response(processHandle.stdout).text(),
+    new Response(processHandle.stderr).text()
+  ]);
+  return {
+    id: step.id,
+    label: step.label,
+    command: step.command,
+    exitCode,
+    stdout,
+    stderr,
+    durationMs: Date.now() - startedAt
+  };
+}
+function extractSuccessAdvisory(stderr) {
+  const lines = stderr.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0);
+  if (lines.length === 0) {
+    return;
+  }
+  const advisoryLines = lines.filter((line) => SUCCESS_ADVISORY_PATTERNS.some((pattern) => pattern.test(line)));
+  if (advisoryLines.length === 0) {
+    return;
+  }
+  const maxLines = 3;
+  const visibleLines = advisoryLines.slice(0, maxLines);
+  if (advisoryLines.length > maxLines) {
+    visibleLines.push(`...and ${advisoryLines.length - maxLines} more advisory line(s)`);
+  }
+  return visibleLines.join(`
+`);
+}
+async function runCheckOrchestrator(options) {
+  try {
+    const cwd = resolve(options.cwd);
+    const plan = buildCheckOrchestratorPlan({ ...options, cwd });
+    if (plan.length === 0) {
+      return Result.err(new CheckOrchestratorError("No checks configured for selected mode"));
+    }
+    const treeBefore = readTreePaths(cwd);
+    const stepResults = [];
+    for (const step of plan) {
+      const result = await runStep(cwd, step);
+      stepResults.push(result);
+      if (result.exitCode !== 0) {
+        break;
+      }
+    }
+    const treeAfter = readTreePaths(cwd);
+    const failedStepIds = stepResults.filter((step) => step.exitCode !== 0).map((step) => step.id);
+    const mutatedPaths = diffTreePaths(treeBefore, treeAfter);
+    const treeClean = mutatedPaths.length === 0;
+    const enforceCleanTree = options.mode !== "pre-commit";
+    return Result.ok({
+      mode: options.mode,
+      steps: stepResults,
+      failedStepIds,
+      mutatedPaths,
+      treeClean,
+      ok: failedStepIds.length === 0 && (!enforceCleanTree || enforceCleanTree && treeClean)
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new CheckOrchestratorError(`Failed to run check orchestrator: ${message}`));
+  }
+}
+function toCompactResult(result) {
+  return {
+    mode: result.mode,
+    ok: result.ok,
+    treeClean: result.treeClean,
+    failedStepIds: result.failedStepIds,
+    mutatedPaths: result.mutatedPaths,
+    steps: result.steps.map((step) => ({
+      id: step.id,
+      label: step.label,
+      exitCode: step.exitCode,
+      durationMs: step.durationMs
+    }))
+  };
+}
+async function printCheckOrchestratorResults(result, options = {}) {
+  const mode = resolveStructuredOutputMode(options.mode) ?? "human";
+  if (mode === "json" || mode === "jsonl") {
+    const payload = options.compact ? toCompactResult(result) : result;
+    process.stdout.write(`${JSON.stringify(payload)}
+`);
+    return;
+  }
+  const theme = createTheme();
+  process.stdout.write(`${theme.bold("Check Orchestrator")} (${result.mode})
+
+`);
+  for (const step of result.steps) {
+    const icon = step.exitCode === 0 ? theme.success("\u2713") : theme.error("\u2717");
+    const duration = `${step.durationMs}ms`;
+    process.stdout.write(`  ${icon} ${step.label} ${theme.muted(`(${duration})`)}
+`);
+    if (step.exitCode !== 0) {
+      const snippet = `${step.stdout}
+${step.stderr}`.trim();
+      if (snippet.length > 0) {
+        process.stdout.write(`${theme.muted(snippet)}
+`);
+      }
+    } else {
+      const advisory = extractSuccessAdvisory(step.stderr);
+      if (advisory) {
+        process.stdout.write(`    ${theme.warning("!")} ${theme.muted(advisory)}
+`);
+      }
+    }
+  }
+  if (!result.treeClean) {
+    process.stdout.write(`
+${theme.warning("Mutation traceability")}: working tree changed during run
+`);
+    for (const path of result.mutatedPaths) {
+      process.stdout.write(`  ${theme.muted(path)}
+`);
+    }
+  }
+  process.stdout.write(`
+`);
+  if (result.ok) {
+    process.stdout.write(`${theme.success("All orchestrated checks passed.")}
+`);
+  } else {
+    process.stdout.write(`${theme.error("Orchestrated checks failed.")} ${theme.muted(`(${result.failedStepIds.join(", ") || "tree-clean"})`)}
+`);
+  }
+}
+
+export { CheckOrchestratorError, buildCheckOrchestratorPlan, parseTreePaths, runCheckOrchestrator, printCheckOrchestratorResults };