outfitter 0.2.7 → 0.3.3

package/dist/shared/outfitter-gyayfx5r.js

@@ -0,0 +1,156 @@
+// @bun
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/check-surface-map-format.ts
+import { spawnSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+import { Result } from "@outfitter/contracts";
+class CheckSurfaceMapFormatError extends Error {
+  _tag = "CheckSurfaceMapFormatError";
+  constructor(message) {
+    super(message);
+    this.name = "CheckSurfaceMapFormatError";
+  }
+}
+function canonicalizeJson(content, filePath) {
+  const parsed = JSON.parse(content);
+  const normalized = `${JSON.stringify(parsed, null, 2)}
+`;
+  const formatResult = spawnSync("bun", ["x", "oxfmt", "--stdin-filepath", filePath], {
+    encoding: "utf-8",
+    input: normalized
+  });
+  if (formatResult.status !== 0 || typeof formatResult.stdout !== "string" || formatResult.stdout.length === 0) {
+    return normalized;
+  }
+  return formatResult.stdout.endsWith(`
+`) ? formatResult.stdout : `${formatResult.stdout}
+`;
+}
+function checkSurfaceMapFormat(content, filePath) {
+  const expected = canonicalizeJson(content, filePath);
+  return {
+    filePath,
+    actual: content,
+    expected,
+    ok: content === expected
+  };
+}
+async function runCheckSurfaceMapFormat(options) {
+  try {
+    const filePath = join(resolve(options.cwd), ".outfitter", "surface.json");
+    if (!existsSync(filePath)) {
+      return Result.ok({
+        filePath,
+        format: null,
+        ok: false,
+        reason: "missing-file"
+      });
+    }
+    const content = readFileSync(filePath, "utf-8");
+    const formatResult = checkSurfaceMapFormat(content, filePath);
+    if (formatResult.ok) {
+      return Result.ok({
+        filePath,
+        format: formatResult,
+        ok: true,
+        reason: "ok"
+      });
+    }
+    return Result.ok({
+      filePath,
+      format: formatResult,
+      ok: false,
+      reason: "format-drift"
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to check surface map formatting";
+    return Result.err(new CheckSurfaceMapFormatError(message));
+  }
+}
+async function printCheckSurfaceMapFormatResult(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 === "missing-file") {
+    process.stderr.write(`[surface-map-format] Missing ${result.filePath}
+Run 'bun run apps/outfitter/src/cli.ts schema generate' from repo root.
+`);
+    return;
+  }
+  if (result.reason === "ok") {
+    process.stdout.write(`[surface-map-format] ${result.filePath} matches canonical formatting
+`);
+    return;
+  }
+  process.stderr.write([
+    `[surface-map-format] ${result.filePath} is not canonically formatted.`,
+    "Run 'bun run apps/outfitter/src/cli.ts schema generate' from repo root to rewrite .outfitter/surface.json."
+  ].join(`
+`));
+  process.stderr.write(`
+`);
+}
+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 CheckSurfaceMapFormatError("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 runCheckSurfaceMapFormatFromArgv(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 runCheckSurfaceMapFormat({ cwd: parsed.cwd });
+  if (result.isErr()) {
+    process.stderr.write(`${result.error.message}
+`);
+    return 1;
+  }
+  await printCheckSurfaceMapFormatResult(result.value, {
+    mode: parsed.outputMode
+  });
+  return result.value.ok ? 0 : 1;
+}
+if (import.meta.main) {
+  runCheckSurfaceMapFormatFromArgv(process.argv.slice(2)).then((exitCode) => {
+    process.exit(exitCode);
+  });
+}
+
+export { CheckSurfaceMapFormatError, canonicalizeJson, checkSurfaceMapFormat, runCheckSurfaceMapFormat, printCheckSurfaceMapFormatResult, runCheckSurfaceMapFormatFromArgv };

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

@@ -0,0 +1,23 @@
+import { CliOutputMode } from "./outfitter-a79xrm12.js";
+import { Result } from "@outfitter/contracts";
+import { CoverageLevel, TsDocCheckResult } from "@outfitter/tooling";
+/** Validated input for the check-tsdoc action handler. */
+interface CheckTsDocInput {
+	readonly cwd: string;
+	readonly emitOutput?: boolean;
+	readonly jq: string | undefined;
+	readonly level: CoverageLevel | undefined;
+	readonly minCoverage: number;
+	readonly outputMode: CliOutputMode;
+	readonly packages: readonly string[];
+	readonly strict: boolean;
+	readonly summary: boolean;
+}
+/**
+* Run TSDoc coverage analysis and format output.
+*
+* @param input - Validated action input
+* @returns Result containing the coverage analysis
+*/
+declare function runCheckTsdoc(input: CheckTsDocInput): Promise<Result<TsDocCheckResult, Error>>;
+export { CheckTsDocInput, runCheckTsdoc };

package/dist/shared/{outfitter-z5sx06qe.d.ts → outfitter-hcexcvxe.d.ts}

@@ -1,4 +1,4 @@
-import { OperationCollector } from "./outfitter-amc4jbs1.js";
+import { OperationCollector } from "./outfitter-xr6g13nz.js";
 import { Result } from "@outfitter/contracts";
 type ScaffoldOrigin = "init" | "scaffold";
 interface PostScaffoldOptions {

package/dist/shared/outfitter-hf5bj2gq.js

@@ -0,0 +1,117 @@
+// @bun
+import {
+  applyJq
+} from "./outfitter-5vx1bp7h.js";
+import {
+  loadDocsModule
+} from "./outfitter-svts4wk2.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/docs-search.ts
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import { output } from "@outfitter/cli";
+import { InternalError, Result } from "@outfitter/contracts";
+import { createTheme } from "@outfitter/tui/render";
+async function runDocsSearch(input) {
+  try {
+    const cwd = resolve(input.cwd);
+    const docsModule = await loadDocsModule();
+    const mapResult = await docsModule.generateDocsMap({ workspaceRoot: cwd });
+    if (mapResult.isErr()) {
+      return Result.err(new InternalError({
+        message: mapResult.error.message,
+        context: { action: "docs.search" }
+      }));
+    }
+    const rawMap = mapResult.value;
+    let entries = rawMap.entries;
+    if (input.kind) {
+      entries = entries.filter((entry) => entry.kind === input.kind);
+    }
+    if (input.package) {
+      entries = entries.filter((entry) => entry.package === input.package);
+    }
+    const queryLower = input.query.toLowerCase();
+    const matches = [];
+    for (const entry of entries) {
+      const sourcePath = resolve(cwd, entry.sourcePath);
+      try {
+        const content = await readFile(sourcePath, "utf8");
+        const lines = content.split(`
+`);
+        const matchLines = [];
+        for (const line of lines) {
+          if (line.toLowerCase().includes(queryLower)) {
+            matchLines.push(line);
+          }
+        }
+        if (matchLines.length > 0) {
+          matches.push({
+            id: entry.id,
+            kind: entry.kind,
+            title: entry.title,
+            sourcePath: entry.sourcePath,
+            outputPath: entry.outputPath,
+            ...entry.package !== undefined ? { package: entry.package } : {},
+            matchLines
+          });
+        }
+      } catch {}
+    }
+    return Result.ok({
+      matches,
+      query: input.query,
+      total: matches.length
+    });
+  } catch (error) {
+    return Result.err(new InternalError({
+      message: error instanceof Error ? error.message : "Failed to search docs",
+      context: { action: "docs.search" }
+    }));
+  }
+}
+async function printDocsSearchResults(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    if (options?.jq) {
+      const filtered = await applyJq(result, options.jq, {
+        compact: structuredMode === "jsonl"
+      });
+      process.stdout.write(filtered);
+    } else {
+      await output(result, { mode: structuredMode });
+    }
+    return;
+  }
+  const theme = createTheme();
+  const lines = [];
+  if (result.total === 0) {
+    lines.push(theme.muted(`No documentation entries matched "${result.query}".`));
+    await output(lines, { mode: "human" });
+    return;
+  }
+  lines.push("");
+  lines.push(`Search Results for "${result.query}" (${result.total})`);
+  lines.push("=".repeat(60));
+  lines.push("");
+  for (const match of result.matches) {
+    const pkg = match.package ? theme.muted(` [${match.package}]`) : "";
+    const kind = theme.muted(`(${match.kind})`);
+    lines.push(`  ${match.id} ${kind}${pkg}`);
+    lines.push(`    ${match.title}`);
+    lines.push(`    ${theme.muted(`${match.matchLines.length} matching line(s)`)}`);
+    for (const line of match.matchLines.slice(0, 3)) {
+      lines.push(`      ${theme.muted(line.trim())}`);
+    }
+    if (match.matchLines.length > 3) {
+      lines.push(`      ${theme.muted(`... and ${match.matchLines.length - 3} more`)}`);
+    }
+    lines.push("");
+  }
+  await output(lines, { mode: "human" });
+}
+
+export { runDocsSearch, printDocsSearchResults };

package/dist/shared/{outfitter-e9rrfekb.d.ts → outfitter-htx4asgr.d.ts}

@@ -8,8 +8,8 @@ type CreatePresetId = "basic" | "cli" | "daemon" | "mcp";
 interface CreatePresetDefinition {
 	readonly defaultBlocks: readonly string[];
 	readonly id: CreatePresetId;
+	readonly presetDir: CreatePresetId;
 	readonly summary: string;
-	readonly template: CreatePresetId;
 }
 interface CreateProjectInput {
 	readonly description?: string;
@@ -23,9 +23,10 @@ interface CreateProjectInput {
 	readonly year?: string;
 }
 type CreatePlanChange = {
-	readonly type: "copy-template";
-	readonly template: string;
+	readonly type: "copy-preset";
+	readonly preset: string;
 	readonly targetDir: string;
+	readonly includeTooling: boolean;
 	readonly overlayBaseTemplate: boolean;
 } | {
 	readonly type: "inject-shared-config";

package/dist/shared/outfitter-jkct38dh.js

@@ -0,0 +1,53 @@
+// @bun
+import {
+  scaffoldAction
+} from "./outfitter-xs94pkfe.js";
+import {
+  upgradeAction
+} from "./outfitter-rp89dafm.js";
+import {
+  createAction,
+  initAction,
+  initCliAction,
+  initDaemonAction,
+  initFullStackAction,
+  initLibraryAction,
+  initMcpAction
+} from "./outfitter-738z4c37.js";
+import {
+  docsApiAction,
+  docsExportAction,
+  docsListAction,
+  docsSearchAction,
+  docsShowAction
+} from "./outfitter-dx4hn4ta.js";
+import {
+  doctorAction
+} from "./outfitter-ex8gn945.js";
+import {
+  demoAction
+} from "./outfitter-wkt0a0ra.js";
+import {
+  checkAction,
+  checkTsdocAction
+} from "./outfitter-k6zyvg2n.js";
+import {
+  addAction,
+  listBlocksAction
+} from "./outfitter-3rcrvva8.js";
+import {
+  checkActionCeremonyAction,
+  checkDocsSentinelAction,
+  checkPresetVersionsAction,
+  checkPublishGuardrailsAction,
+  checkSurfaceMapAction,
+  checkSurfaceMapFormatAction
+} from "./outfitter-mstr60zz.js";
+
+// apps/outfitter/src/actions.ts
+import {
+  createActionRegistry
+} from "@outfitter/contracts";
+var outfitterActions = createActionRegistry().add(createAction).add(scaffoldAction).add(initAction).add(initCliAction).add(initMcpAction).add(initDaemonAction).add(initLibraryAction).add(initFullStackAction).add(demoAction).add(doctorAction).add(addAction).add(listBlocksAction).add(checkAction).add(checkTsdocAction).add(checkPublishGuardrailsAction).add(checkPresetVersionsAction).add(checkSurfaceMapAction).add(checkSurfaceMapFormatAction).add(checkDocsSentinelAction).add(checkActionCeremonyAction).add(upgradeAction).add(docsListAction).add(docsShowAction).add(docsSearchAction).add(docsApiAction).add(docsExportAction);
+
+export { outfitterActions };

package/dist/shared/outfitter-jwxggvz4.js

@@ -0,0 +1,42 @@
+// @bun
+import {
+  readMigrationDocsWithMetadata
+} from "./outfitter-fx1m251y.js";
+
+// apps/outfitter/src/commands/upgrade-migration-guides.ts
+function collectMigrationChanges(docs) {
+  const changes = [];
+  for (const doc of docs) {
+    if (doc.frontmatter.changes) {
+      changes.push(...doc.frontmatter.changes);
+    }
+  }
+  return changes.length > 0 ? changes : undefined;
+}
+function buildMigrationGuides(packages, migrationsDir) {
+  const guides = [];
+  for (const pkg of packages) {
+    if (!pkg.updateAvailable || pkg.latest === null) {
+      continue;
+    }
+    let steps = [];
+    let changes;
+    if (migrationsDir !== null) {
+      const shortName = pkg.name.replace("@outfitter/", "");
+      const docs = readMigrationDocsWithMetadata(migrationsDir, shortName, pkg.current, pkg.latest);
+      steps = docs.map((doc) => doc.body);
+      changes = collectMigrationChanges(docs);
+    }
+    guides.push({
+      packageName: pkg.name,
+      fromVersion: pkg.current,
+      toVersion: pkg.latest,
+      breaking: pkg.breaking,
+      steps,
+      ...changes !== undefined ? { changes } : {}
+    });
+  }
+  return guides;
+}
+
+export { buildMigrationGuides };