outfitter 0.3.2 → 0.3.3

package/dist/shared/outfitter-4s9meh3j.js

@@ -0,0 +1,221 @@
+// @bun
+// apps/outfitter/src/engine/post-scaffold.ts
+import { relative } from "path";
+import { Result } from "@outfitter/contracts";
+function detectGitState(cwd) {
+  try {
+    const result = Bun.spawnSync(["git", "rev-parse", "--show-toplevel"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "ignore"
+    });
+    return { isRepo: result.exitCode === 0 };
+  } catch {
+    return { isRepo: false };
+  }
+}
+async function runBunInstall(cwd, timeoutMs) {
+  try {
+    const proc = Bun.spawn(["bun", "install"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const timeoutPromise = new Promise((resolveTimeout) => {
+      const timer = setTimeout(() => resolveTimeout("timeout"), timeoutMs);
+      proc.exited.finally(() => clearTimeout(timer));
+    });
+    const race = await Promise.race([
+      proc.exited.then(() => "exit"),
+      timeoutPromise
+    ]);
+    if (race === "timeout") {
+      proc.kill();
+      return Result.err(`bun install timed out after ${timeoutMs}ms`);
+    }
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      return Result.err(stderr.trim() || `bun install exited with code ${exitCode}`);
+    }
+    return Result.ok(undefined);
+  } catch (error) {
+    return Result.err(error instanceof Error ? error.message : "Unknown error");
+  }
+}
+function runGitInit(cwd) {
+  try {
+    const result = Bun.spawnSync(["git", "init"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (result.exitCode !== 0) {
+      return Result.err(result.stderr.toString().trim());
+    }
+    return Result.ok(undefined);
+  } catch (error) {
+    return Result.err(error instanceof Error ? error.message : "Unknown error");
+  }
+}
+function hasGitUserConfig(cwd) {
+  try {
+    const name = Bun.spawnSync(["git", "config", "--get", "user.name"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "ignore"
+    });
+    if (name.exitCode !== 0 || name.stdout.toString().trim().length === 0) {
+      return false;
+    }
+    const email = Bun.spawnSync(["git", "config", "--get", "user.email"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "ignore"
+    });
+    return email.exitCode === 0 && email.stdout.toString().trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function runGitCommit(cwd, message) {
+  try {
+    const addResult = Bun.spawnSync(["git", "add", "."], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (addResult.exitCode !== 0) {
+      return Result.err(`git add failed: ${addResult.stderr.toString().trim()}`);
+    }
+    const commitResult = Bun.spawnSync(["git", "commit", "-m", message], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (commitResult.exitCode !== 0) {
+      return Result.err(`git commit failed: ${commitResult.stderr.toString().trim()}`);
+    }
+    return Result.ok(undefined);
+  } catch (error) {
+    return Result.err(error instanceof Error ? error.message : "Unknown error");
+  }
+}
+function computeNextSteps(options, installResult) {
+  const steps = [];
+  if (options.origin === "init") {
+    steps.push(`cd ${JSON.stringify(options.rootDir)}`);
+  }
+  if (installResult !== "success") {
+    steps.push("bun install");
+  }
+  if (options.structure === "workspace") {
+    const relProject = relative(options.rootDir, options.projectDir) || ".";
+    steps.push(`bun run --cwd ${JSON.stringify(relProject)} dev`);
+  } else {
+    steps.push("bun run dev");
+  }
+  return steps;
+}
+async function runPostScaffold(options, collector) {
+  if (process.env["OUTFITTER_DISABLE_POST_SCAFFOLD"] === "1") {
+    return Result.ok({
+      installResult: "skipped",
+      gitInitResult: "skipped",
+      gitCommitResult: "skipped",
+      nextSteps: computeNextSteps(options, "skipped")
+    });
+  }
+  let installResult = "skipped";
+  let installError;
+  if (!options.skipInstall) {
+    if (options.dryRun) {
+      collector?.add({
+        type: "install",
+        command: "bun install",
+        cwd: options.rootDir
+      });
+      installResult = "skipped";
+    } else {
+      const result = await runBunInstall(options.rootDir, options.installTimeoutMs);
+      if (result.isErr()) {
+        installResult = "failed";
+        installError = result.error;
+        process.stderr.write(`Warning: bun install failed: ${result.error}
+`);
+      } else {
+        installResult = "success";
+      }
+    }
+  }
+  let gitInitResult = "skipped";
+  let gitCommitResult = "skipped";
+  let gitError;
+  if (!options.skipGit && options.origin === "init") {
+    const gitState = detectGitState(options.rootDir);
+    if (options.dryRun) {
+      if (!gitState.isRepo) {
+        collector?.add({
+          type: "git",
+          action: "init",
+          cwd: options.rootDir
+        });
+      }
+      if (!options.skipCommit) {
+        collector?.add({
+          type: "git",
+          action: "add-all",
+          cwd: options.rootDir
+        });
+        collector?.add({
+          type: "git",
+          action: "commit",
+          cwd: options.rootDir,
+          message: "init: scaffold with outfitter"
+        });
+      }
+      gitInitResult = gitState.isRepo ? "already-repo" : "skipped";
+    } else {
+      if (gitState.isRepo) {
+        gitInitResult = "already-repo";
+      } else {
+        const result = runGitInit(options.rootDir);
+        if (result.isErr()) {
+          gitInitResult = "failed";
+          gitError = result.error;
+          process.stderr.write(`Warning: git init failed: ${result.error}
+`);
+        } else {
+          gitInitResult = "success";
+        }
+      }
+      if (!options.skipCommit && (gitInitResult === "success" || gitInitResult === "already-repo")) {
+        if (hasGitUserConfig(options.rootDir)) {
+          const commitResult = runGitCommit(options.rootDir, "init: scaffold with outfitter");
+          if (commitResult.isErr()) {
+            gitCommitResult = "failed";
+            gitError = commitResult.error;
+            process.stderr.write(`Warning: ${commitResult.error}
+`);
+          } else {
+            gitCommitResult = "success";
+          }
+        } else {
+          gitCommitResult = "skipped";
+          process.stderr.write(`Warning: git user.name/email not configured, skipping initial commit.
+`);
+        }
+      }
+    }
+  }
+  return Result.ok({
+    installResult,
+    installError,
+    gitInitResult,
+    gitCommitResult,
+    gitError,
+    nextSteps: computeNextSteps(options, installResult)
+  });
+}
+
+export { runPostScaffold };

package/dist/shared/outfitter-507ra35w.js

@@ -0,0 +1,285 @@
+// @bun
+import {
+  applyJq
+} from "./outfitter-5vx1bp7h.js";
+
+// apps/outfitter/src/commands/check-tsdoc.ts
+import { existsSync, readFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join, relative } from "path";
+import { pathToFileURL } from "url";
+import { Result, ValidationError } from "@outfitter/contracts";
+var require2 = createRequire(import.meta.url);
+var DEFAULT_TSDOC_DISCOVERY_PATTERNS = [
+  "packages/*/src/index.ts",
+  "apps/*/src/index.ts",
+  "src/index.ts"
+];
+function calculateCoverage(declarations) {
+  const total = declarations.length;
+  if (total === 0) {
+    return {
+      documented: 0,
+      partial: 0,
+      undocumented: 0,
+      total: 0,
+      percentage: 100
+    };
+  }
+  const documented = declarations.filter((d) => d.level === "documented").length;
+  const partial = declarations.filter((d) => d.level === "partial").length;
+  const undocumented = declarations.filter((d) => d.level === "undocumented").length;
+  const score = documented + partial * 0.5;
+  const percentage = Math.round(score / total * 100);
+  return { documented, partial, undocumented, total, percentage };
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return;
+  }
+}
+function readEntrypointsFromTsdocObject(value) {
+  const tsdoc = asRecord(value);
+  const entrypoints = tsdoc?.["entrypoints"];
+  if (!Array.isArray(entrypoints)) {
+    return;
+  }
+  const normalized = entrypoints.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  return normalized.length > 0 ? normalized : undefined;
+}
+function resolveConfiguredEntrypoints(cwd) {
+  const configPath = join(cwd, ".outfitter", "config.json");
+  if (existsSync(configPath)) {
+    const parsed = readJsonFile(configPath);
+    if (parsed) {
+      const fromRoot = readEntrypointsFromTsdocObject(parsed["tsdoc"]);
+      if (fromRoot) {
+        return {
+          entrypoints: fromRoot,
+          source: ".outfitter/config.json#tsdoc.entrypoints"
+        };
+      }
+      const fromOutfitter = readEntrypointsFromTsdocObject(asRecord(parsed["outfitter"])?.["tsdoc"]);
+      if (fromOutfitter) {
+        return {
+          entrypoints: fromOutfitter,
+          source: ".outfitter/config.json#outfitter.tsdoc.entrypoints"
+        };
+      }
+    }
+  }
+  const packageJsonPath = join(cwd, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return null;
+  }
+  const parsedPackageJson = readJsonFile(packageJsonPath);
+  const fromPackageJson = readEntrypointsFromTsdocObject(asRecord(parsedPackageJson?.["outfitter"])?.["tsdoc"]);
+  if (!fromPackageJson) {
+    return null;
+  }
+  return {
+    entrypoints: fromPackageJson,
+    source: "package.json#outfitter.tsdoc.entrypoints"
+  };
+}
+function derivePackagePathFromEntrypoint(match) {
+  const normalized = match.replaceAll("\\", "/");
+  if (normalized === "src/index.ts") {
+    return ".";
+  }
+  if (normalized.endsWith("/src/index.ts")) {
+    return normalized.slice(0, -"/src/index.ts".length);
+  }
+  const srcSegment = normalized.lastIndexOf("/src/");
+  if (srcSegment >= 0) {
+    return srcSegment === 0 ? "." : normalized.slice(0, srcSegment);
+  }
+  const separator = normalized.lastIndexOf("/");
+  return separator > 0 ? normalized.slice(0, separator) : ".";
+}
+function discoverPathsFromEntrypoints(cwd, entrypoints) {
+  const paths = new Set;
+  for (const pattern of entrypoints) {
+    const glob = new Bun.Glob(pattern);
+    for (const match of glob.scanSync({ cwd, dot: false })) {
+      paths.add(derivePackagePathFromEntrypoint(match));
+    }
+  }
+  return [...paths].toSorted();
+}
+function formatDiscoveryMessage(entrypoints, source) {
+  const patterns = entrypoints.join(", ");
+  return source ? `${patterns} (from ${source})` : patterns;
+}
+function recalculateCounts(pkg, declarations) {
+  const coverage = calculateCoverage(declarations);
+  return {
+    ...pkg,
+    declarations,
+    ...coverage
+  };
+}
+function filterResult(result, options) {
+  let packages = [...result.packages];
+  if (options.packageNames.length > 0) {
+    const names = new Set(options.packageNames);
+    packages = packages.filter((pkg) => names.has(pkg.name));
+  }
+  if (options.level) {
+    packages = packages.map((pkg) => {
+      const declarations = pkg.declarations.filter((d) => d.level === options.level);
+      return recalculateCounts(pkg, declarations);
+    });
+  }
+  const summary = calculateCoverage(packages.flatMap((pkg) => pkg.declarations));
+  const ok = options.strict ? summary.percentage >= options.minCoverage : true;
+  return {
+    ok,
+    packages,
+    summary
+  };
+}
+function summarizeResult(result) {
+  return {
+    ok: result.ok,
+    packages: result.packages.map((pkg) => ({
+      ...pkg,
+      declarations: []
+    })),
+    summary: result.summary
+  };
+}
+function emitJsonlLines(result, summary) {
+  const lines = [];
+  lines.push({ type: "meta", version: "1.0.0", ok: result.ok });
+  lines.push({ type: "summary", ...result.summary });
+  const sortedPackages = [...result.packages].toSorted((a, b) => a.name.localeCompare(b.name));
+  for (const pkg of sortedPackages) {
+    lines.push({
+      type: "package",
+      name: pkg.name,
+      percentage: pkg.percentage,
+      documented: pkg.documented,
+      partial: pkg.partial,
+      undocumented: pkg.undocumented,
+      total: pkg.total
+    });
+  }
+  if (!summary) {
+    for (const pkg of sortedPackages) {
+      for (const decl of pkg.declarations) {
+        lines.push({
+          type: "declaration",
+          package: pkg.name,
+          name: decl.name,
+          kind: decl.kind,
+          level: decl.level,
+          file: relative(pkg.path, decl.file),
+          line: decl.line
+        });
+      }
+    }
+  }
+  return lines;
+}
+function normalizeJsonlRecord(text) {
+  try {
+    return JSON.stringify(JSON.parse(text));
+  } catch {
+    return JSON.stringify(text);
+  }
+}
+var toolingCheckTsdocModule;
+function resolveToolingEntrypoint() {
+  const packageJsonPath = require2.resolve("@outfitter/tooling/package.json");
+  const packageRoot = dirname(packageJsonPath);
+  const srcEntrypoint = join(packageRoot, "src", "index.ts");
+  if (existsSync(srcEntrypoint)) {
+    return srcEntrypoint;
+  }
+  const distEntrypoint = join(packageRoot, "dist", "index.js");
+  if (existsSync(distEntrypoint)) {
+    return distEntrypoint;
+  }
+  throw new Error("Unable to resolve @outfitter/tooling entrypoint (expected src/index.ts or dist/index.js).");
+}
+function loadToolingCheckTsdocModule() {
+  if (!toolingCheckTsdocModule) {
+    toolingCheckTsdocModule = import(pathToFileURL(resolveToolingEntrypoint()).href);
+  }
+  return toolingCheckTsdocModule;
+}
+async function runCheckTsdoc(input) {
+  try {
+    const tooling = await loadToolingCheckTsdocModule();
+    const configuredEntrypoints = resolveConfiguredEntrypoints(input.cwd);
+    const configuredPaths = configuredEntrypoints ? discoverPathsFromEntrypoints(input.cwd, configuredEntrypoints.entrypoints) : [];
+    if (configuredEntrypoints && configuredPaths.length === 0) {
+      return Result.err(ValidationError.fromMessage(`No packages found. Searched ${formatDiscoveryMessage(configuredEntrypoints.entrypoints, configuredEntrypoints.source)}.`, { cwd: input.cwd }));
+    }
+    const rawResult = tooling.analyzeCheckTsdoc({
+      strict: input.strict,
+      minCoverage: input.minCoverage,
+      cwd: input.cwd,
+      ...configuredEntrypoints ? { paths: configuredPaths } : {}
+    });
+    if (!rawResult) {
+      const discoveryPatterns = configuredEntrypoints ? configuredEntrypoints.entrypoints : DEFAULT_TSDOC_DISCOVERY_PATTERNS;
+      const discoverySource = configuredEntrypoints?.source;
+      return Result.err(ValidationError.fromMessage(`No packages found. Searched ${formatDiscoveryMessage(discoveryPatterns, discoverySource)}. Use --package <path> to specify explicitly.`, { cwd: input.cwd }));
+    }
+    const hasFilters = input.level !== undefined || input.packages.length > 0;
+    const filteredResult = hasFilters ? filterResult(rawResult, {
+      level: input.level,
+      packageNames: input.packages,
+      strict: input.strict,
+      minCoverage: input.minCoverage
+    }) : rawResult;
+    const outputData = input.summary ? summarizeResult(filteredResult) : filteredResult;
+    if (input.emitOutput !== false) {
+      if (input.outputMode === "jsonl") {
+        const lines = emitJsonlLines(filteredResult, input.summary);
+        if (input.jq) {
+          for (const line of lines) {
+            const filtered = await applyJq(line, input.jq, { compact: true });
+            for (const rawLine of filtered.split(/\r?\n/)) {
+              const trimmed = rawLine.trim();
+              if (!trimmed) {
+                continue;
+              }
+              process.stdout.write(`${normalizeJsonlRecord(trimmed)}
+`);
+            }
+          }
+        } else {
+          for (const line of lines) {
+            process.stdout.write(`${JSON.stringify(line)}
+`);
+          }
+        }
+      } else if (input.jq) {
+        const filtered = await applyJq(outputData, input.jq);
+        process.stdout.write(filtered);
+      } else if (input.outputMode === "json") {
+        process.stdout.write(`${JSON.stringify(outputData, null, 2)}
+`);
+      } else {
+        tooling.printCheckTsdocHuman(outputData, {
+          strict: input.strict,
+          minCoverage: input.minCoverage
+        });
+      }
+    }
+    return Result.ok(outputData);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to run check-tsdoc";
+    return Result.err(new Error(message));
+  }
+}
+
+export { runCheckTsdoc };

package/dist/shared/outfitter-56jq0rh2.d.ts

@@ -0,0 +1,42 @@
+import { MigrationFrontmatter } from "./outfitter-y37yfehn.js";
+/** A migration doc with parsed frontmatter and body content. */
+interface MigrationDocWithMetadata {
+	readonly body: string;
+	readonly frontmatter: MigrationFrontmatter;
+	readonly version: string;
+}
+/**
+* Find migration docs directory, checking known locations.
+*
+* Searches:
+* 1. Relative to the target cwd
+* 2. Walking up parent directories from cwd (monorepo root detection)
+* 3. Relative to the outfitter binary itself (development mode)
+*/
+declare function findMigrationDocsDir(cwd: string, binaryDir?: string): string | null;
+/**
+* Read all migration docs for a package between two versions.
+*
+* Scans the migrations directory for docs matching the package name,
+* filters to versions greater than `fromVersion` and at most `toVersion`,
+* and returns their contents sorted by version ascending.
+*/
+declare function readMigrationDocs(migrationsDir: string, shortName: string, fromVersion: string, toVersion: string): string[];
+/**
+* Read the `breaking` flag for an exact migration doc version, if present.
+*
+* Returns:
+* - `true` or `false` when the frontmatter contains `breaking: ...`
+* - `undefined` when the doc is missing, unreadable, or has no valid flag
+*/
+declare function readMigrationBreakingFlag(migrationsDir: string, shortName: string, version: string): boolean | undefined;
+/**
+* Read all migration docs for a package between two versions,
+* returning parsed frontmatter alongside the body content.
+*
+* Like `readMigrationDocs` but returns structured metadata instead of
+* plain strings. Used by the codemod infrastructure to discover
+* machine-actionable changes.
+*/
+declare function readMigrationDocsWithMetadata(migrationsDir: string, shortName: string, fromVersion: string, toVersion: string): MigrationDocWithMetadata[];
+export { MigrationDocWithMetadata, findMigrationDocsDir, readMigrationDocs, readMigrationBreakingFlag, readMigrationDocsWithMetadata };

package/dist/shared/outfitter-58rn1sj1.d.ts

@@ -0,0 +1,30 @@
+/**
+* Unique identifier for a scaffold target.
+*/
+type TargetId = "minimal" | "cli" | "mcp" | "daemon" | "library" | "full-stack" | "api" | "worker" | "web";
+/**
+* Whether the target produces a runnable application or a library package.
+*/
+type TargetCategory = "runnable" | "library";
+/**
+* Whether the target has a working template or is a planned placeholder.
+*/
+type TargetStatus = "ready" | "stub";
+/**
+* Whether a target can be used with init, scaffold, or both.
+*/
+type TargetScope = "init-only" | "scaffold-only" | "both";
+/**
+* Complete definition for a scaffold target.
+*/
+interface TargetDefinition {
+	readonly category: TargetCategory;
+	readonly defaultBlocks: readonly string[];
+	readonly description: string;
+	readonly id: TargetId;
+	readonly placement: "apps" | "packages";
+	readonly presetDir: string;
+	readonly scope: TargetScope;
+	readonly status: TargetStatus;
+}
+export { TargetId, TargetCategory, TargetStatus, TargetScope, TargetDefinition };

package/dist/shared/outfitter-5d9wbzhh.d.ts

@@ -0,0 +1,19 @@
+import { TargetId } from "./outfitter-58rn1sj1.js";
+import { Result } from "@outfitter/contracts";
+/** Subset of target IDs that are valid presets for `outfitter init`. */
+type InitPresetId = Extract<TargetId, "minimal" | "cli" | "mcp" | "daemon" | "library" | "full-stack">;
+/**
+* Parses a comma-separated `--with` flag value into an array of block names.
+* @returns The parsed block names, or `undefined` if the flag is empty/absent.
+*/
+declare function parseBlocks(withFlag: string | undefined): readonly string[] | undefined;
+/** Returns `true` if the preset produces a project with a binary entry point. */
+declare function isBinaryPreset(preset: InitPresetId): boolean;
+/** Type guard that narrows a string to {@link InitPresetId}. */
+declare function isValidInitPreset(value: string): value is InitPresetId;
+/**
+* Validates and resolves a `--preset` flag value against the available preset list.
+* @returns The validated preset ID, `undefined` if no flag was provided, or an error for unknown presets.
+*/
+declare function resolvePresetFromFlags(presetFromFlag: string | undefined, availablePresetIds: readonly string[]): Result<InitPresetId | undefined, string>;
+export { InitPresetId, parseBlocks, isBinaryPreset, isValidInitPreset, resolvePresetFromFlags };