outfitter 0.3.2 → 0.3.4

package/dist/shared/outfitter-mstr60zz.js

@@ -0,0 +1,215 @@
+// @bun
+import {
+  actionInternalErr,
+  outputModeSchema,
+  resolveCwdFromPreset,
+  resolveOutputModeWithEnvFallback
+} from "./outfitter-7n7vsz95.js";
+import {
+  printCheckDocsSentinelResult,
+  runCheckDocsSentinel
+} from "./outfitter-fj2v5ffz.js";
+import {
+  printCheckSurfaceMapFormatResult,
+  runCheckSurfaceMapFormat
+} from "./outfitter-gyayfx5r.js";
+import {
+  printCheckActionCeremonyResult,
+  runCheckActionCeremony
+} from "./outfitter-p2wn07b7.js";
+import {
+  printCheckSurfaceMapResult,
+  runCheckSurfaceMap
+} from "./outfitter-b9cpnr7e.js";
+import {
+  printCheckPresetVersionsResult,
+  runCheckPresetVersions
+} from "./outfitter-8ggmja91.js";
+import {
+  printCheckPublishGuardrailsResult,
+  runCheckPublishGuardrails
+} from "./outfitter-ssynegbs.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/actions/check-automation.ts
+import { cwdPreset } from "@outfitter/cli/flags";
+import { outputModePreset } from "@outfitter/cli/query";
+import { defineAction, Result } from "@outfitter/contracts";
+import { z } from "zod";
+var checkAutomationInputSchema = z.object({
+  cwd: z.string(),
+  outputMode: outputModeSchema
+});
+var checkAutomationOutput = outputModePreset();
+var checkAutomationCwd = cwdPreset();
+function mapCheckAutomationInput(context) {
+  const { outputMode: presetOutputMode } = checkAutomationOutput.resolve(context.flags);
+  const outputMode = resolveOutputModeWithEnvFallback(context.flags, resolveStructuredOutputMode(presetOutputMode) ?? "human");
+  return {
+    cwd: resolveCwdFromPreset(context.flags, checkAutomationCwd),
+    outputMode
+  };
+}
+var checkPublishGuardrailsAction = defineAction({
+  id: "check.publish-guardrails",
+  description: "Validate publishable package manifests enforce prepublishOnly guardrails",
+  surfaces: ["cli"],
+  input: checkAutomationInputSchema,
+  cli: {
+    group: "check",
+    command: "publish-guardrails",
+    description: "Validate publishable package manifests enforce prepublishOnly guardrails",
+    options: [
+      ...checkAutomationOutput.options,
+      ...checkAutomationCwd.options
+    ],
+    mapInput: mapCheckAutomationInput
+  },
+  handler: async (input) => {
+    const result = await runCheckPublishGuardrails({ cwd: input.cwd });
+    if (result.isErr()) {
+      return actionInternalErr("check.publish-guardrails", result.error);
+    }
+    await printCheckPublishGuardrailsResult(result.value, {
+      mode: input.outputMode
+    });
+    if (!result.value.ok) {
+      process.exit(1);
+    }
+    return Result.ok(result.value);
+  }
+});
+var checkPresetVersionsAction = defineAction({
+  id: "check.preset-versions",
+  description: "Validate preset dependency versions, registry versions, and Bun version consistency",
+  surfaces: ["cli"],
+  input: checkAutomationInputSchema,
+  cli: {
+    group: "check",
+    command: "preset-versions",
+    description: "Validate preset dependency versions, registry versions, and Bun version consistency",
+    options: [...checkAutomationOutput.options, ...checkAutomationCwd.options],
+    mapInput: mapCheckAutomationInput
+  },
+  handler: async (input) => {
+    const result = await runCheckPresetVersions({ cwd: input.cwd });
+    if (result.isErr()) {
+      return actionInternalErr("check.preset-versions", result.error);
+    }
+    await printCheckPresetVersionsResult(result.value, {
+      mode: input.outputMode
+    });
+    if (!result.value.ok) {
+      process.exit(1);
+    }
+    return Result.ok(result.value);
+  }
+});
+var checkSurfaceMapAction = defineAction({
+  id: "check.surface-map",
+  description: "Validate canonical surface map path usage (.outfitter/surface.json only)",
+  surfaces: ["cli"],
+  input: checkAutomationInputSchema,
+  cli: {
+    group: "check",
+    command: "surface-map",
+    description: "Validate canonical surface map path usage (.outfitter/surface.json only)",
+    options: [...checkAutomationOutput.options, ...checkAutomationCwd.options],
+    mapInput: mapCheckAutomationInput
+  },
+  handler: async (input) => {
+    const result = await runCheckSurfaceMap({ cwd: input.cwd });
+    if (result.isErr()) {
+      return actionInternalErr("check.surface-map", result.error);
+    }
+    await printCheckSurfaceMapResult(result.value, {
+      mode: input.outputMode
+    });
+    if (!result.value.ok) {
+      process.exit(1);
+    }
+    return Result.ok(result.value);
+  }
+});
+var checkSurfaceMapFormatAction = defineAction({
+  id: "check.surface-map-format",
+  description: "Validate canonical formatting for .outfitter/surface.json",
+  surfaces: ["cli"],
+  input: checkAutomationInputSchema,
+  cli: {
+    group: "check",
+    command: "surface-map-format",
+    description: "Validate canonical formatting for .outfitter/surface.json",
+    options: [...checkAutomationOutput.options, ...checkAutomationCwd.options],
+    mapInput: mapCheckAutomationInput
+  },
+  handler: async (input) => {
+    const result = await runCheckSurfaceMapFormat({ cwd: input.cwd });
+    if (result.isErr()) {
+      return actionInternalErr("check.surface-map-format", result.error);
+    }
+    await printCheckSurfaceMapFormatResult(result.value, {
+      mode: input.outputMode
+    });
+    if (!result.value.ok) {
+      process.exit(1);
+    }
+    return Result.ok(result.value);
+  }
+});
+var checkDocsSentinelAction = defineAction({
+  id: "check.docs-sentinel",
+  description: "Validate docs/README.md PACKAGE_LIST sentinel freshness",
+  surfaces: ["cli"],
+  input: checkAutomationInputSchema,
+  cli: {
+    group: "check",
+    command: "docs-sentinel",
+    description: "Validate docs/README.md PACKAGE_LIST sentinel freshness",
+    options: [...checkAutomationOutput.options, ...checkAutomationCwd.options],
+    mapInput: mapCheckAutomationInput
+  },
+  handler: async (input) => {
+    const result = await runCheckDocsSentinel({ cwd: input.cwd });
+    if (result.isErr()) {
+      return actionInternalErr("check.docs-sentinel", result.error);
+    }
+    await printCheckDocsSentinelResult(result.value, {
+      mode: input.outputMode
+    });
+    if (!result.value.ok) {
+      process.exit(1);
+    }
+    return Result.ok(result.value);
+  }
+});
+var checkActionCeremonyAction = defineAction({
+  id: "check.action-ceremony",
+  description: "Validate action ceremony guardrails in apps/outfitter/src/actions",
+  surfaces: ["cli"],
+  input: checkAutomationInputSchema,
+  cli: {
+    group: "check",
+    command: "action-ceremony",
+    description: "Validate action ceremony guardrails in apps/outfitter/src/actions",
+    options: [...checkAutomationOutput.options, ...checkAutomationCwd.options],
+    mapInput: mapCheckAutomationInput
+  },
+  handler: async (input) => {
+    const result = await runCheckActionCeremony({ cwd: input.cwd });
+    if (result.isErr()) {
+      return actionInternalErr("check.action-ceremony", result.error);
+    }
+    await printCheckActionCeremonyResult(result.value, {
+      mode: input.outputMode
+    });
+    if (!result.value.ok) {
+      process.exit(1);
+    }
+    return Result.ok(result.value);
+  }
+});
+
+export { checkPublishGuardrailsAction, checkPresetVersionsAction, checkSurfaceMapAction, checkSurfaceMapFormatAction, checkDocsSentinelAction, checkActionCeremonyAction };

package/dist/shared/outfitter-n0ed012k.js

@@ -0,0 +1,101 @@
+// @bun
+import {
+  renderOperationPlan
+} from "./outfitter-ttjr95y9.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+import {
+  OperationCollector
+} from "./outfitter-1h7k8xxt.js";
+
+// apps/outfitter/src/commands/init-output.ts
+import { realpath } from "fs/promises";
+import { output } from "@outfitter/cli";
+async function printInitResults(result, options) {
+  let rootDir = result.rootDir;
+  let projectDir = result.projectDir;
+  try {
+    rootDir = await realpath(rootDir);
+    projectDir = await realpath(projectDir);
+  } catch {}
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (result.dryRunPlan) {
+    if (structuredMode) {
+      await output({
+        rootDir,
+        projectDir,
+        structure: result.structure,
+        preset: result.preset,
+        packageName: result.packageName,
+        ...result.dryRunPlan
+      }, { mode: structuredMode });
+      return;
+    }
+    const collector = new OperationCollector;
+    for (const op of result.dryRunPlan.operations) {
+      collector.add(op);
+    }
+    await renderOperationPlan(collector, { rootDir });
+    return;
+  }
+  if (structuredMode) {
+    await output({
+      structure: result.structure,
+      rootDir,
+      projectDir,
+      preset: result.preset,
+      packageName: result.packageName,
+      blocksAdded: result.blocksAdded ?? null,
+      postScaffold: result.postScaffold,
+      nextSteps: result.postScaffold.nextSteps
+    }, { mode: structuredMode });
+    return;
+  }
+  const lines = [
+    `Project initialized successfully in ${rootDir}`,
+    `Structure: ${result.structure}`,
+    `Preset: ${result.preset}`
+  ];
+  if (result.structure === "workspace") {
+    lines.push(`Workspace project path: ${projectDir}`);
+  }
+  if (result.blocksAdded) {
+    const { created, skipped, dependencies, devDependencies } = result.blocksAdded;
+    if (created.length > 0) {
+      lines.push("", `Added ${created.length} tooling file(s):`);
+      for (const file of created) {
+        lines.push(`  \u2713 ${file}`);
+      }
+    }
+    if (skipped.length > 0) {
+      lines.push("", `Skipped ${skipped.length} existing file(s):`);
+      for (const file of skipped) {
+        lines.push(`  - ${file}`);
+      }
+    }
+    const depCount = Object.keys(dependencies).length + Object.keys(devDependencies).length;
+    if (depCount > 0) {
+      lines.push("", `Added ${depCount} package(s) to package.json:`);
+      for (const [name, version] of Object.entries(dependencies)) {
+        lines.push(`  + ${name}@${version}`);
+      }
+      for (const [name, version] of Object.entries(devDependencies)) {
+        lines.push(`  + ${name}@${version} (dev)`);
+      }
+    }
+  }
+  if (result.postScaffold.installResult === "failed") {
+    lines.push("", `Warning: bun install failed: ${result.postScaffold.installError ?? "unknown"}`);
+  }
+  if (result.postScaffold.gitInitResult === "failed") {
+    lines.push("", `Warning: git setup failed: ${result.postScaffold.gitError ?? "unknown"}`);
+  }
+  lines.push("", "Next steps:");
+  for (const step of result.postScaffold.nextSteps) {
+    lines.push(`  ${step}`);
+  }
+  await output(lines, { mode: "human" });
+}
+
+export { printInitResults };

package/dist/shared/outfitter-n13pqaft.js

@@ -0,0 +1,19 @@
+// @bun
+// apps/outfitter/src/commands/upgrade-latest-version.ts
+async function getLatestVersion(name) {
+  try {
+    const proc = Bun.spawn(["npm", "view", name, "version"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const stdout = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+    if (exitCode !== 0)
+      return null;
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export { getLatestVersion };

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

@@ -0,0 +1,48 @@
+import { CliOutputMode } from "./outfitter-a79xrm12.js";
+import { InternalError, Result } from "@outfitter/contracts";
+/** Validated input for the docs.search action handler. */
+interface DocsSearchInput {
+	readonly cwd: string;
+	readonly jq?: string | undefined;
+	readonly kind?: string | undefined;
+	readonly outputMode: CliOutputMode;
+	readonly package?: string | undefined;
+	readonly query: string;
+}
+/** A single match found in a documentation file. */
+interface DocsSearchMatch {
+	readonly id: string;
+	readonly kind: string;
+	readonly matchLines: string[];
+	readonly outputPath: string;
+	readonly package?: string;
+	readonly sourcePath: string;
+	readonly title: string;
+}
+/** Output shape for the docs.search action. */
+interface DocsSearchOutput {
+	readonly matches: DocsSearchMatch[];
+	readonly query: string;
+	readonly total: number;
+}
+/**
+* Search documentation content for a query string.
+*
+* Generates the docs map for the workspace, reads each file's content,
+* and performs case-insensitive substring matching to find relevant lines.
+*
+* @param input - Validated action input
+* @returns Result containing the search matches or an error
+*/
+declare function runDocsSearch(input: DocsSearchInput): Promise<Result<DocsSearchOutput, InternalError>>;
+/**
+* Print docs search results in the appropriate output format.
+*
+* @param result - The docs search output
+* @param options - Output formatting options
+*/
+declare function printDocsSearchResults(result: DocsSearchOutput, options?: {
+	mode?: CliOutputMode;
+	jq?: string | undefined;
+}): Promise<void>;
+export { DocsSearchInput, DocsSearchMatch, DocsSearchOutput, runDocsSearch, printDocsSearchResults };

package/dist/shared/outfitter-p2wn07b7.js

@@ -0,0 +1,160 @@
+// @bun
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/check-action-ceremony.ts
+import { readdirSync } from "fs";
+import { resolve } from "path";
+import { Result } from "@outfitter/contracts";
+var ACTIONS_RELATIVE_DIR = "apps/outfitter/src/actions";
+var CEREMONY_BUDGETS = [
+  {
+    id: "direct-defineAction-generics",
+    description: "Direct defineAction<T> invocations should stay constrained (prefer export-level typing)",
+    maxCount: 1,
+    pattern: /(?<!typeof\s)defineAction</g
+  },
+  {
+    id: "schema-zodtype-casts",
+    description: "Action-local schema casts should not expand without justification",
+    maxCount: 6,
+    pattern: /as z\.ZodType</g
+  },
+  {
+    id: "direct-internalerror-construction",
+    description: "Direct InternalError creation in action handlers should stay minimal (use shared adapter)",
+    maxCount: 1,
+    pattern: /new InternalError\(/g
+  }
+];
+
+class CheckActionCeremonyError extends Error {
+  _tag = "CheckActionCeremonyError";
+  constructor(message) {
+    super(message);
+    this.name = "CheckActionCeremonyError";
+  }
+}
+function countMatches(content, pattern) {
+  const matches = content.match(pattern);
+  return matches ? matches.length : 0;
+}
+function readActionSources(actionsDir) {
+  return readdirSync(actionsDir).filter((entry) => entry.endsWith(".ts")).map((entry) => resolve(actionsDir, entry));
+}
+async function runCheckActionCeremony(options) {
+  try {
+    const cwd = resolve(options.cwd);
+    const actionsDir = resolve(cwd, ACTIONS_RELATIVE_DIR);
+    const actionFiles = readActionSources(actionsDir);
+    const counts = Object.fromEntries(CEREMONY_BUDGETS.map((budget) => [budget.id, 0]));
+    for (const filePath of actionFiles) {
+      const file = Bun.file(filePath);
+      const content = await file.text();
+      for (const budget of CEREMONY_BUDGETS) {
+        if (budget.id === "direct-internalerror-construction" && filePath.endsWith("shared.ts")) {
+          continue;
+        }
+        counts[budget.id] = (counts[budget.id] ?? 0) + countMatches(content, budget.pattern);
+      }
+    }
+    const budgets = CEREMONY_BUDGETS.map((budget) => {
+      const count = counts[budget.id] ?? 0;
+      return {
+        id: budget.id,
+        description: budget.description,
+        count,
+        maxCount: budget.maxCount,
+        ok: count <= budget.maxCount
+      };
+    });
+    return Result.ok({
+      actionsDir,
+      budgets,
+      ok: budgets.every((budget) => budget.ok)
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to check action ceremony";
+    return Result.err(new CheckActionCeremonyError(message));
+  }
+}
+async function printCheckActionCeremonyResult(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;
+  }
+  process.stdout.write(`[action-ceremony] checked ${result.budgets.length} guardrails in ${result.actionsDir}
+`);
+  const failed = result.budgets.filter((budget) => !budget.ok);
+  if (failed.length === 0) {
+    process.stdout.write(`[action-ceremony] all ceremony guardrails are within budget
+`);
+    return;
+  }
+  process.stderr.write(`[action-ceremony] ceremony budget exceeded:
+`);
+  for (const budget of failed) {
+    process.stderr.write(`  - ${budget.id}: ${budget.count}/${budget.maxCount} (${budget.description})
+`);
+  }
+}
+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 CheckActionCeremonyError("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 runCheckActionCeremonyFromArgv(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 runCheckActionCeremony({ cwd: parsed.cwd });
+  if (result.isErr()) {
+    process.stderr.write(`${result.error.message}
+`);
+    return 1;
+  }
+  await printCheckActionCeremonyResult(result.value, {
+    mode: parsed.outputMode
+  });
+  return result.value.ok ? 0 : 1;
+}
+if (import.meta.main) {
+  runCheckActionCeremonyFromArgv(process.argv.slice(2)).then((exitCode) => {
+    process.exit(exitCode);
+  });
+}
+
+export { CheckActionCeremonyError, runCheckActionCeremony, printCheckActionCeremonyResult, runCheckActionCeremonyFromArgv };