@outfitter/tooling 0.3.3 → 0.3.4

package/dist/shared/@outfitter/tooling-ja1zg5yc.js

@@ -0,0 +1,214 @@
+// @bun
+// packages/tooling/src/cli/check-markdown-links.ts
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+var MD_LINK_RE = /\[([^\]]*)\]\(([^)]+)\)/g;
+var SKIP_PROTOCOLS = /^(https?:\/\/|mailto:|data:|tel:)/;
+var FENCE_RE = /^(\s*)((`{3,})|~{3,})(.*)$/;
+function stripInlineCodeSpans(line) {
+  let result = "";
+  let index = 0;
+  while (index < line.length) {
+    if (line[index] !== "`") {
+      result += line[index];
+      index += 1;
+      continue;
+    }
+    let tickCount = 1;
+    while (line[index + tickCount] === "`") {
+      tickCount += 1;
+    }
+    const opener = line.slice(index, index + tickCount);
+    index += tickCount;
+    let closingIndex = -1;
+    let cursor = index;
+    while (cursor < line.length) {
+      if (line[cursor] !== "`") {
+        cursor += 1;
+        continue;
+      }
+      let runLength = 1;
+      while (line[cursor + runLength] === "`") {
+        runLength += 1;
+      }
+      if (runLength === tickCount) {
+        closingIndex = cursor;
+        break;
+      }
+      cursor += runLength;
+    }
+    if (closingIndex === -1) {
+      result += opener;
+      continue;
+    }
+    index = closingIndex + tickCount;
+  }
+  return result;
+}
+function extractMarkdownLinks(content) {
+  const lines = content.split(`
+`);
+  const links = [];
+  let inCodeFence = false;
+  let fenceChar = "";
+  let fenceCount = 0;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    const fenceMatch = FENCE_RE.exec(trimmed);
+    if (fenceMatch) {
+      const marker = fenceMatch[2] ?? "";
+      const char = marker[0] ?? "`";
+      const count = marker.length;
+      if (!inCodeFence) {
+        inCodeFence = true;
+        fenceChar = char;
+        fenceCount = count;
+        continue;
+      }
+      if (char === fenceChar && count >= fenceCount && !(fenceMatch[4] ?? "").trim()) {
+        inCodeFence = false;
+        continue;
+      }
+    }
+    if (inCodeFence)
+      continue;
+    const stripped = stripInlineCodeSpans(line);
+    for (const match of stripped.matchAll(MD_LINK_RE)) {
+      let target = match[2];
+      if (SKIP_PROTOCOLS.test(target))
+        continue;
+      if (target.startsWith("#"))
+        continue;
+      const hashIndex = target.indexOf("#");
+      if (hashIndex !== -1) {
+        target = target.substring(0, hashIndex);
+      }
+      if (target === "")
+        continue;
+      links.push({ target, line: i + 1 });
+    }
+  }
+  return links;
+}
+async function validateLinks(rootDir, files) {
+  const broken = [];
+  for (const file of files) {
+    const absolutePath = resolve(rootDir, file);
+    const content = await Bun.file(absolutePath).text();
+    const links = extractMarkdownLinks(content);
+    const fileDir = dirname(absolutePath);
+    for (const link of links) {
+      if (link.target.startsWith("docs/packages/") || link.target.startsWith("./docs/packages/") || link.target.startsWith("../docs/packages/")) {
+        continue;
+      }
+      const resolvedTarget = resolve(fileDir, link.target);
+      const relativeFromRoot = resolvedTarget.substring(rootDir.length + 1);
+      if (relativeFromRoot.startsWith("docs/packages/")) {
+        continue;
+      }
+      if (!existsSync(resolvedTarget)) {
+        broken.push({
+          source: file,
+          target: link.target,
+          line: link.line
+        });
+      }
+    }
+  }
+  return broken;
+}
+var DEFAULT_PATTERNS = [
+  "docs/**/*.md",
+  "packages/*/README.md",
+  "AGENTS.md",
+  "CLAUDE.md",
+  "README.md",
+  ".claude/CLAUDE.md"
+];
+async function discoverFiles(rootDir, patterns) {
+  const files = new Set;
+  for (const pattern of patterns) {
+    const glob = new Bun.Glob(pattern);
+    for await (const match of glob.scan({ cwd: rootDir, absolute: false })) {
+      files.add(match);
+    }
+  }
+  return [...files].toSorted();
+}
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m"
+};
+async function runCheckMarkdownLinks(rootDir, patterns) {
+  const effectivePatterns = patterns ?? DEFAULT_PATTERNS;
+  const files = await discoverFiles(rootDir, effectivePatterns);
+  if (files.length === 0) {
+    process.stdout.write(`No markdown files found.
+`);
+    return 0;
+  }
+  const broken = await validateLinks(rootDir, files);
+  if (broken.length === 0) {
+    process.stdout.write(`${COLORS.green}All links valid across ${files.length} markdown file(s).${COLORS.reset}
+`);
+    return 0;
+  }
+  const bySource = new Map;
+  for (const link of broken) {
+    const existing = bySource.get(link.source);
+    if (existing) {
+      existing.push(link);
+    } else {
+      bySource.set(link.source, [link]);
+    }
+  }
+  process.stderr.write(`${COLORS.red}Found ${broken.length} broken link(s):${COLORS.reset}
+
+`);
+  for (const [source, links] of bySource) {
+    process.stderr.write(`  ${COLORS.yellow}${source}${COLORS.reset}
+`);
+    for (const link of links) {
+      process.stderr.write(`    ${COLORS.cyan}${link.line}${COLORS.reset}  ${COLORS.dim}${link.target}${COLORS.reset}
+`);
+    }
+    process.stderr.write(`
+`);
+  }
+  return 1;
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(`Usage: check-markdown-links [dirs/patterns...]
+
+Validates that relative links in markdown files resolve to existing files.
+
+Arguments:
+  dirs/patterns  Glob patterns to scan (defaults: docs/, packages/*/README.md, etc.)
+
+Options:
+  --help  Show this help message
+
+Exit codes:
+  0  All links valid
+  1  Broken links found
+`);
+    process.exitCode = 0;
+    return;
+  }
+  const cwd = process.cwd();
+  const patterns = args.length > 0 ? args.filter((a) => !a.startsWith("--")) : undefined;
+  const exitCode = await runCheckMarkdownLinks(cwd, patterns);
+  process.exitCode = exitCode;
+}
+if (import.meta.main) {
+  main();
+}
+
+export { extractMarkdownLinks, validateLinks, runCheckMarkdownLinks };

package/dist/shared/@outfitter/tooling-jnrs9rqd.js

@@ -0,0 +1,4 @@
+// @bun
+var __require = import.meta.require;
+
+export { __require };

package/dist/shared/@outfitter/tooling-mkynjra9.js

@@ -0,0 +1,23 @@
+// @bun
+// packages/tooling/src/bun-version-compat.ts
+function parseSemver(version) {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match?.[1] || !match[2] || !match[3]) {
+    return;
+  }
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10),
+    patch: Number.parseInt(match[3], 10)
+  };
+}
+function isTypesBunVersionCompatible(bunVersion, bunTypesVersion) {
+  const parsedBun = parseSemver(bunVersion);
+  const parsedTypes = parseSemver(bunTypesVersion);
+  if (!parsedBun || !parsedTypes) {
+    return bunVersion === bunTypesVersion;
+  }
+  return parsedBun.major === parsedTypes.major && parsedBun.minor === parsedTypes.minor && parsedTypes.patch <= parsedBun.patch;
+}
+
+export { parseSemver, isTypesBunVersionCompatible };

package/dist/shared/@outfitter/tooling-njw4z34x.d.ts

@@ -0,0 +1,140 @@
+import ts from "typescript";
+import { ZodType } from "zod";
+/** Coverage classification for a single declaration. */
+type CoverageLevel = "documented" | "partial" | "undocumented";
+/** Result for a single exported declaration. */
+interface DeclarationCoverage {
+	readonly name: string;
+	readonly kind: string;
+	readonly level: CoverageLevel;
+	readonly file: string;
+	readonly line: number;
+}
+/** Coverage summary statistics. */
+interface CoverageSummary {
+	readonly documented: number;
+	readonly partial: number;
+	readonly undocumented: number;
+	readonly total: number;
+	readonly percentage: number;
+}
+/** Per-package TSDoc coverage stats. */
+interface PackageCoverage {
+	readonly name: string;
+	readonly path: string;
+	readonly declarations: readonly DeclarationCoverage[];
+	readonly documented: number;
+	readonly partial: number;
+	readonly undocumented: number;
+	readonly total: number;
+	readonly percentage: number;
+}
+/** Aggregated result across all packages. */
+interface TsDocCheckResult {
+	readonly ok: boolean;
+	readonly packages: readonly PackageCoverage[];
+	readonly summary: CoverageSummary;
+}
+/** Zod schema for {@link CoverageLevel}. */
+declare const coverageLevelSchema: ZodType<CoverageLevel>;
+/** Zod schema for {@link DeclarationCoverage}. */
+declare const declarationCoverageSchema: ZodType<DeclarationCoverage>;
+/** Zod schema for {@link CoverageSummary}. */
+declare const coverageSummarySchema: ZodType<CoverageSummary>;
+/** Zod schema for {@link PackageCoverage}. */
+declare const packageCoverageSchema: ZodType<PackageCoverage>;
+/** Zod schema for {@link TsDocCheckResult}. */
+declare const tsDocCheckResultSchema: ZodType<TsDocCheckResult>;
+/** Options for the check-tsdoc command. */
+interface CheckTsDocOptions {
+	readonly strict?: boolean | undefined;
+	readonly json?: boolean | undefined;
+	readonly minCoverage?: number | undefined;
+	readonly cwd?: string | undefined;
+	readonly paths?: readonly string[] | undefined;
+}
+/**
+* Check whether a node is an exported declaration worth checking.
+*
+* Returns true for function, interface, type alias, class, enum, and variable
+* declarations that carry the `export` keyword. Re-exports (`{ ... } from`)
+* and `*` are excluded since TSDoc belongs at the definition site.
+*/
+declare function isExportedDeclaration(node: ts.Node): boolean;
+/**
+* Extract the name of a declaration node.
+*
+* For variable statements, returns the name of the first variable declarator.
+* Returns `undefined` for anonymous declarations (e.g., `function() {}`).
+*/
+declare function getDeclarationName(node: ts.Node): string | undefined;
+/**
+* Determine the kind label for a declaration node.
+*
+* Maps AST node types to human-readable kind strings used in coverage reports.
+*/
+declare function getDeclarationKind(node: ts.Node): string;
+/**
+* Classify a declaration's TSDoc coverage level.
+*
+* - `"documented"` -- has a JSDoc comment with a description. For interfaces
+*   and classes, all members must also have JSDoc comments.
+* - `"partial"` -- the declaration has a JSDoc comment but some members
+*   (in interfaces/classes) lack documentation.
+* - `"undocumented"` -- no JSDoc comment at all.
+*/
+declare function classifyDeclaration(node: ts.Node, sourceFile: ts.SourceFile): CoverageLevel;
+/**
+* Analyze all exported declarations in a source file for TSDoc coverage.
+*
+* Walks top-level statements, filters to exported declarations, and
+* classifies each for documentation coverage.
+*/
+declare function analyzeSourceFile(sourceFile: ts.SourceFile): DeclarationCoverage[];
+/**
+* Calculate aggregate coverage statistics from declaration results.
+*
+* Partial documentation counts as half coverage in the percentage calculation.
+* An empty array returns 100% (no declarations to check).
+*/
+declare function calculateCoverage(declarations: readonly DeclarationCoverage[]): {
+	documented: number;
+	partial: number;
+	undocumented: number;
+	total: number;
+	percentage: number;
+};
+/** Resolve whether JSON output mode is active. */
+declare function resolveJsonMode(options?: CheckTsDocOptions): boolean;
+/**
+* Analyze TSDoc coverage across workspace packages.
+*
+* Pure function that discovers packages, analyzes TSDoc coverage on exported
+* declarations, and returns the aggregated result. Does not print output or
+* call `process.exit()`.
+*
+* @param options - Analysis options (paths, strict mode, coverage threshold)
+* @returns Aggregated coverage result across all packages, or `null` if no packages found
+*/
+declare function analyzeCheckTsdoc(options?: CheckTsDocOptions): TsDocCheckResult | null;
+/**
+* Print a TSDoc coverage result in human-readable format.
+*
+* Renders a bar chart per package with summary statistics. Writes to stdout/stderr.
+*
+* @param result - The coverage result to print
+* @param options - Display options (strict mode, coverage threshold for warning)
+*/
+declare function printCheckTsdocHuman(result: TsDocCheckResult, options?: {
+	strict?: boolean | undefined;
+	minCoverage?: number | undefined;
+}): void;
+/**
+* Run check-tsdoc across workspace packages.
+*
+* Discovers packages with `src/index.ts` entry points, analyzes TSDoc
+* coverage on exported declarations, and reports per-package statistics.
+* Calls `process.exit()` on completion.
+*/
+declare function runCheckTsdoc(options?: CheckTsDocOptions): Promise<void>;
+export { CoverageLevel, DeclarationCoverage, CoverageSummary, PackageCoverage, TsDocCheckResult, coverageLevelSchema, declarationCoverageSchema, coverageSummarySchema, packageCoverageSchema, tsDocCheckResultSchema, CheckTsDocOptions, isExportedDeclaration, getDeclarationName, getDeclarationKind, classifyDeclaration, analyzeSourceFile, calculateCoverage, resolveJsonMode, analyzeCheckTsdoc, printCheckTsdocHuman, runCheckTsdoc };

package/dist/shared/@outfitter/tooling-pq47jv6t.js

@@ -0,0 +1,213 @@
+// @bun
+import {
+  isTypesBunVersionCompatible,
+  parseSemver
+} from "./tooling-mkynjra9.js";
+
+// packages/tooling/src/cli/upgrade-bun.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m"
+};
+function log(msg) {
+  process.stdout.write(`${msg}
+`);
+}
+function info(msg) {
+  process.stdout.write(`${COLORS.blue}\u25B8${COLORS.reset} ${msg}
+`);
+}
+function success(msg) {
+  process.stdout.write(`${COLORS.green}\u2713${COLORS.reset} ${msg}
+`);
+}
+function warn(msg) {
+  process.stdout.write(`${COLORS.yellow}!${COLORS.reset} ${msg}
+`);
+}
+async function fetchLatestVersion() {
+  const response = await fetch("https://api.github.com/repos/oven-sh/bun/releases/latest");
+  const data = await response.json();
+  const match = data.tag_name.match(/bun-v(.+)/);
+  if (!match?.[1]) {
+    throw new Error(`Could not parse version from tag: ${data.tag_name}`);
+  }
+  return match[1];
+}
+async function resolveTypesBunVersion(targetVersion) {
+  const response = await fetch("https://registry.npmjs.org/@types%2fbun");
+  if (!response.ok) {
+    throw new Error(`Failed to fetch @types/bun metadata: ${response.status}`);
+  }
+  const data = await response.json();
+  if (data.versions && Object.hasOwn(data.versions, targetVersion)) {
+    return targetVersion;
+  }
+  if (data.versions) {
+    const compatible = Object.keys(data.versions).filter((candidate) => isTypesBunVersionCompatible(targetVersion, candidate)).map((candidate) => ({
+      version: candidate,
+      parsed: parseSemver(candidate)
+    })).filter((candidate) => !!candidate.parsed).toSorted((left, right) => right.parsed.patch - left.parsed.patch);
+    const preferred = compatible[0];
+    if (preferred) {
+      return preferred.version;
+    }
+  }
+  const latest = data["dist-tags"]?.latest;
+  if (latest && isTypesBunVersionCompatible(targetVersion, latest)) {
+    return latest;
+  }
+  return targetVersion;
+}
+function findPackageJsonFiles(dir) {
+  const files = new Set;
+  const glob = new Bun.Glob("**/package.json");
+  for (const path of glob.scanSync({ cwd: dir })) {
+    if (!path.includes("node_modules")) {
+      files.add(join(dir, path));
+    }
+  }
+  const gitList = Bun.spawnSync(["git", "ls-files", "--cached", "--others", "--exclude-standard"], { cwd: dir });
+  if (gitList.exitCode === 0) {
+    const trackedAndUntrackedFiles = new TextDecoder().decode(gitList.stdout).split(`
+`).filter((path) => path.endsWith("package.json")).filter((path) => !path.includes("node_modules")).map((path) => join(dir, path)).filter((path) => existsSync(path));
+    for (const filePath of trackedAndUntrackedFiles) {
+      files.add(filePath);
+    }
+  }
+  return [...files].toSorted();
+}
+function updatePackageManager(filePath, version) {
+  const content = readFileSync(filePath, "utf-8");
+  const pattern = /"packageManager":\s*"bun@[\d.]+"/;
+  if (!pattern.test(content)) {
+    return false;
+  }
+  const updated = content.replace(pattern, `"packageManager": "bun@${version}"`);
+  if (updated !== content) {
+    writeFileSync(filePath, updated);
+    return true;
+  }
+  return false;
+}
+function updateEnginesBun(filePath, version) {
+  const content = readFileSync(filePath, "utf-8");
+  const pattern = /"bun":\s*">=[\d.]+"/;
+  if (!pattern.test(content)) {
+    return false;
+  }
+  const updated = content.replace(pattern, `"bun": ">=${version}"`);
+  if (updated !== content) {
+    writeFileSync(filePath, updated);
+    return true;
+  }
+  return false;
+}
+function updateTypesBun(filePath, version) {
+  const content = readFileSync(filePath, "utf-8");
+  const pattern = /"@types\/bun":\s*"\^[\d.]+"/;
+  if (!pattern.test(content)) {
+    return false;
+  }
+  const updated = content.replace(pattern, `"@types/bun": "^${version}"`);
+  if (updated !== content) {
+    writeFileSync(filePath, updated);
+    return true;
+  }
+  return false;
+}
+async function runUpgradeBun(targetVersion, options = {}) {
+  const cwd = process.cwd();
+  const bunVersionFile = join(cwd, ".bun-version");
+  let version = targetVersion;
+  if (!version) {
+    info("Fetching latest Bun version...");
+    version = await fetchLatestVersion();
+    log(`Latest version: ${version}`);
+  }
+  const currentVersion = existsSync(bunVersionFile) ? readFileSync(bunVersionFile, "utf-8").trim() : "unknown";
+  log(`Current version: ${currentVersion}`);
+  if (currentVersion === version) {
+    success(`Already on version ${version}`);
+    return;
+  }
+  log("");
+  info(`Upgrading Bun: ${currentVersion} \u2192 ${version}`);
+  log("");
+  let typesVersion = version;
+  try {
+    info("Resolving @types/bun version...");
+    typesVersion = await resolveTypesBunVersion(version);
+    if (typesVersion !== version) {
+      warn(`@types/bun ${version} is not published yet; using @types/bun ${typesVersion}`);
+    }
+  } catch (error) {
+    warn(`Could not resolve @types/bun metadata (${error instanceof Error ? error.message : "unknown error"}), defaulting to ${version}`);
+  }
+  writeFileSync(bunVersionFile, `${version}
+`);
+  success("Updated .bun-version");
+  const packageFiles = findPackageJsonFiles(cwd);
+  info("Updating packageManager...");
+  for (const file of packageFiles) {
+    if (updatePackageManager(file, version)) {
+      log(`  ${file.replace(`${cwd}/`, "")}`);
+    }
+  }
+  info("Updating engines.bun...");
+  for (const file of packageFiles) {
+    if (updateEnginesBun(file, version)) {
+      log(`  ${file.replace(`${cwd}/`, "")}`);
+    }
+  }
+  info("Updating @types/bun...");
+  for (const file of packageFiles) {
+    if (updateTypesBun(file, typesVersion)) {
+      log(`  ${file.replace(`${cwd}/`, "")}`);
+    }
+  }
+  if (options.install !== false) {
+    log("");
+    info(`Installing Bun ${version}...`);
+    const installResult = Bun.spawnSync([
+      "bash",
+      "-c",
+      `curl -fsSL https://bun.sh/install | bash -s "bun-v${version}"`
+    ]);
+    if (installResult.exitCode !== 0) {
+      warn("Could not install Bun automatically");
+      log("Install manually: curl -fsSL https://bun.sh/install | bash");
+    } else {
+      success(`Bun ${version} installed`);
+      log("");
+      info("Updating lockfile...");
+      const bunInstall = Bun.spawnSync(["bun", "install"], {
+        cwd,
+        env: {
+          ...process.env,
+          BUN_INSTALL: `${process.env["HOME"]}/.bun`,
+          PATH: `${process.env["HOME"]}/.bun/bin:${process.env["PATH"]}`
+        }
+      });
+      if (bunInstall.exitCode === 0) {
+        success("Lockfile updated");
+      } else {
+        warn("Could not update lockfile - run 'bun install' manually");
+      }
+    }
+  }
+  log("");
+  success("Done! Changes ready to commit:");
+  log("  - .bun-version");
+  log("  - package.json files (packageManager, engines.bun, @types/bun)");
+  log("  - bun.lock");
+  log("");
+  log(`Commit with: git add -A && git commit -m 'chore: upgrade Bun to ${version}'`);
+}
+
+export { runUpgradeBun };

package/dist/shared/@outfitter/tooling-sjm8nebx.d.ts

@@ -0,0 +1,109 @@
+import { ZodType } from "zod";
+/**
+* File entry in a block.
+*/
+interface FileEntry {
+	/** Destination path relative to project root */
+	path: string;
+	/** File contents (embedded in registry) */
+	content: string;
+	/** Whether to chmod +x after copying */
+	executable?: boolean | undefined;
+	/** Whether to process as a template (future) */
+	template?: boolean | undefined;
+}
+/**
+* Schema for a file entry in a block.
+* Represents a file that will be copied to the user's project.
+*/
+declare const FileEntrySchema: ZodType<FileEntry>;
+/**
+* Block in the registry.
+*/
+interface Block {
+	/** Block name (matches the key in blocks record) */
+	name: string;
+	/** Human-readable description */
+	description: string;
+	/** Files included in this block */
+	files?: FileEntry[] | undefined;
+	/** npm dependencies to add to package.json */
+	dependencies?: Record<string, string> | undefined;
+	/** npm devDependencies to add to package.json */
+	devDependencies?: Record<string, string> | undefined;
+	/** Other blocks this block extends (for composite blocks) */
+	extends?: string[] | undefined;
+}
+/**
+* Schema for a block in the registry.
+* A block is a collection of related files that can be added together.
+*/
+declare const BlockSchema: ZodType<Block>;
+/**
+* Complete registry structure.
+*/
+interface Registry {
+	/** Registry schema version */
+	version: string;
+	/** Map of block name to block definition */
+	blocks: Record<string, Block>;
+}
+/**
+* Schema for the complete registry.
+* Contains all available blocks with their files and metadata.
+*/
+declare const RegistrySchema: ZodType<Registry>;
+/**
+* Block definition used in the build script.
+* Specifies how to collect source files into a block.
+*/
+interface BlockDefinition {
+	/** Human-readable description */
+	description: string;
+	/** Source file paths (relative to repo root) */
+	files?: string[];
+	/** Remap source paths to destination paths */
+	remap?: Record<string, string>;
+	/** npm dependencies */
+	dependencies?: Record<string, string>;
+	/** npm devDependencies */
+	devDependencies?: Record<string, string>;
+	/** Other blocks this block extends */
+	extends?: string[];
+}
+/**
+* Configuration for the registry build.
+*/
+interface RegistryBuildConfig {
+	/** Registry schema version */
+	version: string;
+	/** Block definitions */
+	blocks: Record<string, BlockDefinition>;
+}
+/**
+* Result of adding a block to a project.
+*/
+interface AddBlockResult {
+	/** Files that were created */
+	created: string[];
+	/** Files that were skipped (already exist) */
+	skipped: string[];
+	/** Files that were overwritten (with --force) */
+	overwritten: string[];
+	/** Dependencies added to package.json */
+	dependencies: Record<string, string>;
+	/** devDependencies added to package.json */
+	devDependencies: Record<string, string>;
+}
+/**
+* Options for the add command.
+*/
+interface AddBlockOptions {
+	/** Overwrite existing files */
+	force?: boolean;
+	/** Show what would be added without making changes */
+	dryRun?: boolean;
+	/** Working directory (defaults to cwd) */
+	cwd?: string;
+}
+export { FileEntry, FileEntrySchema, Block, BlockSchema, Registry, RegistrySchema, BlockDefinition, RegistryBuildConfig, AddBlockResult, AddBlockOptions };