outfitter 0.2.1 → 0.2.3

package/dist/shared/outfitter-jyxwznk1.js

@@ -0,0 +1,404 @@
+// @bun
+import {
+  analyzeUpdates
+} from "./outfitter-qfgj5xpq.js";
+import {
+  applyUpdatesToWorkspace,
+  getInstalledPackagesFromWorkspace,
+  runInstall
+} from "./outfitter-6a4bq054.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/update.ts
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+import { output } from "@outfitter/cli/output";
+import { InternalError, Result } from "@outfitter/contracts";
+import { createTheme } from "@outfitter/tui/render";
+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;
+  }
+}
+var MIGRATION_DOC_PATHS = [
+  "plugins/outfitter/shared/migrations",
+  "node_modules/@outfitter/kit/shared/migrations"
+];
+function findMigrationDocsDir(cwd, binaryDir) {
+  for (const relative of MIGRATION_DOC_PATHS) {
+    const dir = join(cwd, relative);
+    if (existsSync(dir))
+      return dir;
+  }
+  let current = resolve(cwd);
+  const root = resolve("/");
+  while (current !== root) {
+    const parent = resolve(current, "..");
+    if (parent === current)
+      break;
+    current = parent;
+    for (const relative of MIGRATION_DOC_PATHS) {
+      const dir = join(current, relative);
+      if (existsSync(dir))
+        return dir;
+    }
+  }
+  const resolvedBinaryDir = binaryDir ?? resolve(import.meta.dir, "../../../..");
+  for (const relative of MIGRATION_DOC_PATHS) {
+    const dir = join(resolvedBinaryDir, relative);
+    if (existsSync(dir))
+      return dir;
+  }
+  return null;
+}
+function readMigrationDocs(migrationsDir, shortName, fromVersion, toVersion) {
+  const glob = new Bun.Glob(`outfitter-${shortName}-*.md`);
+  const versionPattern = new RegExp(`^outfitter-${shortName}-(\\d+\\.\\d+\\.\\d+)\\.md$`);
+  const docs = [];
+  for (const entry of glob.scanSync({ cwd: migrationsDir })) {
+    const match = entry.match(versionPattern);
+    if (!match?.[1])
+      continue;
+    const docVersion = match[1];
+    if (Bun.semver.order(docVersion, fromVersion) <= 0)
+      continue;
+    if (Bun.semver.order(docVersion, toVersion) > 0)
+      continue;
+    const filePath = join(migrationsDir, entry);
+    let content;
+    try {
+      content = readFileSync(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const body = content.replace(/^---\n[\s\S]*?\n---\n*/, "").trim();
+    if (body) {
+      docs.push({ version: docVersion, content: body });
+    }
+  }
+  docs.sort((a, b) => Bun.semver.order(a.version, b.version));
+  return docs.map((d) => d.content);
+}
+function readMigrationBreakingFlag(migrationsDir, shortName, version) {
+  const filePath = join(migrationsDir, `outfitter-${shortName}-${version}.md`);
+  if (!existsSync(filePath)) {
+    return;
+  }
+  let content;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch {
+    return;
+  }
+  const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!frontmatter?.[1]) {
+    return;
+  }
+  const breakingLine = frontmatter[1].split(/\r?\n/).find((line) => line.trimStart().startsWith("breaking:"));
+  if (breakingLine === undefined) {
+    return;
+  }
+  const rawValue = breakingLine.split(":").slice(1).join(":").trim();
+  if (rawValue === "true")
+    return true;
+  if (rawValue === "false")
+    return false;
+  return;
+}
+function buildMigrationGuides(packages, migrationsDir) {
+  const guides = [];
+  for (const pkg of packages) {
+    if (!pkg.updateAvailable || pkg.latest === null)
+      continue;
+    let steps = [];
+    if (migrationsDir !== null) {
+      const shortName = pkg.name.replace("@outfitter/", "");
+      const docs = readMigrationDocs(migrationsDir, shortName, pkg.current, pkg.latest);
+      steps = docs;
+    }
+    guides.push({
+      packageName: pkg.name,
+      fromVersion: pkg.current,
+      toVersion: pkg.latest,
+      breaking: pkg.breaking,
+      steps
+    });
+  }
+  return guides;
+}
+function getVersionPrefix(specifier) {
+  if (specifier.startsWith("workspace:")) {
+    const inner = specifier.slice("workspace:".length);
+    return `workspace:${getVersionPrefix(inner)}`;
+  }
+  const match = specifier.match(/^([\^~>=<]+)/);
+  return match?.[1] ?? "";
+}
+async function applyUpdates(cwd, updates) {
+  const pkgPath = join(cwd, "package.json");
+  let raw;
+  try {
+    raw = readFileSync(pkgPath, "utf-8");
+  } catch {
+    return Result.err(InternalError.create("Failed to read package.json for apply", { cwd }));
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(raw);
+  } catch {
+    return Result.err(InternalError.create("Invalid JSON in package.json", { cwd }));
+  }
+  const updateMap = new Map;
+  for (const u of updates) {
+    updateMap.set(u.name, u.latestVersion);
+  }
+  for (const section of ["dependencies", "devDependencies"]) {
+    const deps = pkg[section];
+    if (!deps)
+      continue;
+    for (const name of Object.keys(deps)) {
+      const newVersion = updateMap.get(name);
+      if (newVersion === undefined)
+        continue;
+      const currentSpecifier = deps[name];
+      if (currentSpecifier === undefined)
+        continue;
+      const prefix = getVersionPrefix(currentSpecifier);
+      deps[name] = `${prefix}${newVersion}`;
+    }
+  }
+  try {
+    const updated = `${JSON.stringify(pkg, null, 2)}
+`;
+    await Bun.write(pkgPath, updated);
+  } catch {
+    return Result.err(InternalError.create("Failed to write updated package.json", { cwd }));
+  }
+  try {
+    const proc = Bun.spawn(["bun", "install"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      return Result.err(InternalError.create("bun install failed", {
+        cwd,
+        exitCode,
+        stderr: stderr.trim()
+      }));
+    }
+  } catch {
+    return Result.err(InternalError.create("Failed to run bun install", { cwd }));
+  }
+  return Result.ok(undefined);
+}
+async function runUpdate(options) {
+  const cwd = resolve(options.cwd);
+  const migrationsDir = findMigrationDocsDir(cwd);
+  const migrationFlagsDir = findMigrationDocsDir(cwd, cwd);
+  const scanResult = getInstalledPackagesFromWorkspace(cwd);
+  if (scanResult.isErr())
+    return scanResult;
+  const scan = scanResult.value;
+  const installed = scan.packages;
+  const installRoot = scan.workspaceRoot ?? cwd;
+  if (installed.length === 0) {
+    return Result.ok({
+      packages: [],
+      total: 0,
+      updatesAvailable: 0,
+      hasBreaking: false,
+      applied: false,
+      appliedPackages: [],
+      skippedBreaking: []
+    });
+  }
+  const latestVersions = new Map;
+  const installedMap = new Map;
+  const npmFailures = new Set;
+  await Promise.all(installed.map(async (pkg) => {
+    installedMap.set(pkg.name, pkg.version);
+    const latest = await getLatestVersion(pkg.name);
+    if (latest !== null) {
+      const shortName = pkg.name.replace("@outfitter/", "");
+      const docBreaking = migrationFlagsDir !== null ? readMigrationBreakingFlag(migrationFlagsDir, shortName, latest) : undefined;
+      latestVersions.set(pkg.name, {
+        version: latest,
+        ...docBreaking !== undefined ? { breaking: docBreaking } : {}
+      });
+    } else {
+      npmFailures.add(pkg.name);
+    }
+  }));
+  const plan = analyzeUpdates(installedMap, latestVersions);
+  const packages = plan.packages.map((action) => ({
+    name: action.name,
+    current: action.currentVersion,
+    latest: npmFailures.has(action.name) ? null : action.latestVersion,
+    updateAvailable: action.classification === "upgradableNonBreaking" || action.classification === "upgradableBreaking",
+    breaking: action.breaking
+  }));
+  const updatesAvailable = packages.filter((p) => p.updateAvailable).length;
+  const hasBreaking = packages.some((p) => p.breaking);
+  const nonBreakingUpgradable = plan.packages.filter((a) => a.classification === "upgradableNonBreaking");
+  const breakingUpgradable = plan.packages.filter((a) => a.classification === "upgradableBreaking");
+  const includeBreaking = options.apply === true && options.breaking === true;
+  const packagesToApply = includeBreaking ? [...nonBreakingUpgradable, ...breakingUpgradable] : nonBreakingUpgradable;
+  const skippedBreaking = includeBreaking ? [] : breakingUpgradable.map((a) => a.name);
+  let applied = false;
+  const appliedPackages = [];
+  if (options.apply && packagesToApply.length > 0) {
+    if (scan.workspaceRoot !== null) {
+      const applyResult = await applyUpdatesToWorkspace(scan.manifestPaths, scan.manifestsByPackage, packagesToApply);
+      if (applyResult.isErr())
+        return applyResult;
+      const installResult = await runInstall(installRoot);
+      if (installResult.isErr())
+        return installResult;
+    } else {
+      const applyResult = await applyUpdates(cwd, packagesToApply);
+      if (applyResult.isErr())
+        return applyResult;
+    }
+    applied = true;
+    appliedPackages.push(...packagesToApply.map((a) => a.name));
+  }
+  let guidesData = options.guide === true ? buildMigrationGuides(packages, migrationsDir) : undefined;
+  if (guidesData !== undefined && options.guidePackages !== undefined && options.guidePackages.length > 0) {
+    const filterSet = new Set(options.guidePackages);
+    guidesData = guidesData.filter((g) => filterSet.has(g.packageName));
+  }
+  return Result.ok({
+    packages,
+    total: packages.length,
+    updatesAvailable,
+    hasBreaking,
+    applied,
+    appliedPackages,
+    skippedBreaking,
+    ...guidesData !== undefined ? { guides: guidesData } : {}
+  });
+}
+async function printUpdateResults(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    await output(result, { mode: structuredMode });
+    return;
+  }
+  const theme = createTheme();
+  const lines = ["", "Outfitter Update", "", "=".repeat(60)];
+  if (result.packages.length === 0) {
+    lines.push("No @outfitter/* packages found in package.json.");
+    await output(lines, { mode: "human" });
+    return;
+  }
+  lines.push(`  ${"Package".padEnd(28)} ${"Current".padEnd(10)} ${"Available".padEnd(10)} Migration`);
+  lines.push(`  ${"\u2500".repeat(28)} ${"\u2500".repeat(10)} ${"\u2500".repeat(10)} ${"\u2500".repeat(20)}`);
+  for (const pkg of result.packages) {
+    const name = pkg.name.padEnd(28);
+    const current = pkg.current.padEnd(10);
+    const available = (pkg.latest ?? "unknown").padEnd(10);
+    let migration;
+    if (pkg.latest === null) {
+      migration = theme.muted("lookup failed");
+    } else if (!pkg.updateAvailable) {
+      migration = theme.muted("up to date");
+    } else if (pkg.breaking) {
+      migration = theme.error("breaking");
+    } else {
+      migration = theme.success("non-breaking");
+    }
+    lines.push(`  ${name} ${current} ${available} ${migration}`);
+  }
+  lines.push("");
+  if (result.applied && result.appliedPackages.length > 0) {
+    const breakingApplied = result.appliedPackages.filter((name) => result.packages.some((p) => p.name === name && p.breaking));
+    const nonBreakingApplied = result.appliedPackages.filter((name) => !result.packages.some((p) => p.name === name && p.breaking));
+    if (nonBreakingApplied.length > 0) {
+      lines.push(theme.success(`Applied ${nonBreakingApplied.length} non-breaking update(s):`));
+      for (const name of nonBreakingApplied) {
+        lines.push(`  - ${name}`);
+      }
+      lines.push("");
+    }
+    if (breakingApplied.length > 0) {
+      lines.push(theme.error(`Applied ${breakingApplied.length} breaking update(s):`));
+      for (const name of breakingApplied) {
+        const pkg = result.packages.find((p) => p.name === name);
+        lines.push(`  - ${name} (${pkg?.current} -> ${pkg?.latest})`);
+      }
+      lines.push("", theme.muted("Review migration guides: 'outfitter update --guide'"));
+      lines.push("");
+    }
+  } else if (options?.applied !== undefined && options.applied === false) {
+    if (result.updatesAvailable === 0) {
+      lines.push(theme.success("All packages are up to date. Nothing to apply."));
+    } else if (result.appliedPackages.length === 0 && result.skippedBreaking.length > 0) {
+      lines.push(theme.muted("No non-breaking updates to apply. All available updates contain breaking changes."));
+    }
+  }
+  if (result.skippedBreaking.length > 0 && result.applied) {
+    lines.push(theme.error(`Skipped ${result.skippedBreaking.length} breaking update(s):`));
+    for (const name of result.skippedBreaking) {
+      lines.push(`  - ${name}`);
+    }
+    lines.push("", theme.muted("Use 'outfitter update --apply --breaking' to include breaking updates."));
+    lines.push("");
+  }
+  if (!result.applied) {
+    if (result.updatesAvailable > 0) {
+      lines.push(theme.muted("Run 'outfitter update --guide' for migration instructions."));
+    } else {
+      lines.push(theme.success("All packages are up to date."));
+    }
+  }
+  if (options?.guide && result.guides && result.guides.length > 0) {
+    lines.push("", "=".repeat(60), "", "Migration Guide", "");
+    for (const guide of result.guides) {
+      const label = guide.breaking ? theme.error("BREAKING") : theme.success("non-breaking");
+      lines.push(`${theme.info(guide.packageName)} ${guide.fromVersion} -> ${guide.toVersion} [${label}]`);
+      if (guide.steps.length > 0) {
+        for (const step of guide.steps) {
+          lines.push(`  ${step}`);
+        }
+      } else {
+        lines.push(`  ${theme.muted("No migration steps available. Check release notes.")}`);
+      }
+      lines.push("");
+    }
+  } else if (options?.guide && result.updatesAvailable > 0 && !result.guides) {
+    const cwd = options.cwd ?? process.cwd();
+    const migrationsDir = findMigrationDocsDir(cwd);
+    if (migrationsDir) {
+      lines.push("", "=".repeat(60), "", "Migration Guide", "");
+      for (const pkg of result.packages) {
+        if (!(pkg.updateAvailable && pkg.latest))
+          continue;
+        const shortName = pkg.name.replace("@outfitter/", "");
+        const docs = readMigrationDocs(migrationsDir, shortName, pkg.current, pkg.latest);
+        for (const doc of docs) {
+          lines.push(doc, "", "---", "");
+        }
+      }
+    } else {
+      lines.push("", theme.muted("Migration docs not found locally. See https://github.com/outfitter-dev/outfitter for migration guides."));
+    }
+  }
+  await output(lines, { mode: "human" });
+}
+
+export { findMigrationDocsDir, readMigrationDocs, readMigrationBreakingFlag, buildMigrationGuides, runUpdate, printUpdateResults };

package/dist/shared/outfitter-k112c427.js

@@ -0,0 +1,21 @@
+// @bun
+// apps/outfitter/src/commands/shared-deps.ts
+var SHARED_DEV_DEPS = {
+  "@biomejs/biome": "^2.3.12",
+  "@outfitter/tooling": "^0.2.1",
+  "@types/bun": "^1.3.7",
+  lefthook: "^2.0.16",
+  typescript: "^5.9.3",
+  ultracite: "^7.1.1"
+};
+var SHARED_SCRIPTS = {
+  check: "ultracite check",
+  "clean:artifacts": "rm -rf dist .turbo",
+  "verify:ci": "bun run typecheck && bun run check && bun run build && bun run test",
+  lint: "biome check .",
+  "lint:fix": "biome check . --write",
+  format: "biome format --write .",
+  typecheck: "tsc --noEmit"
+};
+
+export { SHARED_DEV_DEPS, SHARED_SCRIPTS };

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

@@ -0,0 +1,30 @@
+/**
+* Unique identifier for a scaffold target.
+*/
+type TargetId = "minimal" | "cli" | "mcp" | "daemon" | "api" | "worker" | "web" | "lib";
+/**
+* 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 id: TargetId;
+	readonly description: string;
+	readonly category: TargetCategory;
+	readonly placement: "apps" | "packages";
+	readonly templateDir: string;
+	readonly defaultBlocks: readonly string[];
+	readonly status: TargetStatus;
+	readonly scope: TargetScope;
+}
+export { TargetId, TargetCategory, TargetStatus, TargetScope, TargetDefinition };

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

@@ -0,0 +1,4 @@
+import { CreateProjectInput, CreateProjectPlan } from "./outfitter-e2zz5wv7";
+import { Result, ValidationError } from "@outfitter/contracts";
+declare function planCreateProject(input: CreateProjectInput): Result<CreateProjectPlan, ValidationError>;
+export { planCreateProject };

package/dist/shared/outfitter-mdt37hqm.js

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

package/dist/shared/outfitter-mtbpabf3.js

@@ -0,0 +1,91 @@
+// @bun
+import {
+  __require
+} from "./outfitter-mdt37hqm.js";
+
+// apps/outfitter/src/manifest.ts
+import { join } from "path";
+import {
+  InternalError,
+  Result,
+  ValidationError
+} from "@outfitter/contracts";
+import { z } from "zod";
+var OUTFITTER_DIR = ".outfitter";
+var MANIFEST_FILE = "manifest.json";
+var BlockEntrySchema = z.object({
+  installedFrom: z.string(),
+  installedAt: z.string().datetime()
+});
+var ManifestSchema = z.object({
+  version: z.literal(1),
+  blocks: z.record(z.string(), BlockEntrySchema)
+});
+function manifestPath(cwd) {
+  return join(cwd, OUTFITTER_DIR, MANIFEST_FILE);
+}
+async function readManifest(cwd) {
+  const path = manifestPath(cwd);
+  const file = Bun.file(path);
+  if (!await file.exists()) {
+    return Result.ok(null);
+  }
+  let raw;
+  try {
+    raw = await file.text();
+  } catch {
+    return Result.err(InternalError.create("Failed to read manifest file", { path }));
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return Result.err(ValidationError.create("manifest", "Invalid JSON in manifest file"));
+  }
+  const validated = ManifestSchema.safeParse(parsed);
+  if (!validated.success) {
+    return Result.err(ValidationError.create("manifest", "Manifest file does not match expected schema"));
+  }
+  return Result.ok(validated.data);
+}
+async function writeManifest(cwd, manifest) {
+  const dirPath = join(cwd, OUTFITTER_DIR);
+  const path = join(dirPath, MANIFEST_FILE);
+  try {
+    const { mkdirSync, existsSync, statSync } = await import("fs");
+    if (existsSync(dirPath)) {
+      if (!statSync(dirPath).isDirectory()) {
+        return Result.err(ValidationError.create("manifest", ".outfitter exists but is not a directory"));
+      }
+    } else {
+      mkdirSync(dirPath, { recursive: true });
+    }
+    const content = JSON.stringify(manifest, null, "\t");
+    await Bun.write(path, `${content}
+`);
+    return Result.ok(undefined);
+  } catch {
+    return Result.err(InternalError.create("Failed to write manifest file", { path }));
+  }
+}
+async function stampBlock(cwd, blockName, toolingVersion) {
+  const readResult = await readManifest(cwd);
+  if (readResult.isErr()) {
+    return readResult;
+  }
+  const existing = readResult.value;
+  const manifest = existing ?? { version: 1, blocks: {} };
+  const updated = {
+    ...manifest,
+    blocks: {
+      ...manifest.blocks,
+      [blockName]: {
+        installedFrom: toolingVersion,
+        installedAt: new Date().toISOString()
+      }
+    }
+  };
+  return writeManifest(cwd, updated);
+}
+
+export { BlockEntrySchema, ManifestSchema, readManifest, writeManifest, stampBlock };

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

@@ -0,0 +1,131 @@
+import { OutputMode } from "@outfitter/cli/types";
+import { Command } from "commander";
+/**
+* Options for the doctor command.
+*/
+interface DoctorOptions {
+	/** Working directory to check (defaults to cwd) */
+	readonly cwd: string;
+}
+/**
+* Result of a single health check.
+*/
+interface CheckResult {
+	/** Whether the check passed */
+	readonly passed: boolean;
+	/** Error message if check failed */
+	readonly error?: string;
+}
+/**
+* Bun version check result.
+*/
+interface BunVersionCheck extends CheckResult {
+	/** Current Bun version */
+	readonly version: string;
+	/** Required minimum version */
+	readonly required: string;
+}
+/**
+* Package.json validation result.
+*/
+interface PackageJsonCheck extends CheckResult {
+	/** Package name if found */
+	readonly name?: string;
+	/** Package version if found */
+	readonly version?: string;
+}
+/**
+* Dependencies check result.
+*/
+interface DependenciesCheck extends CheckResult {
+	/** Number of dependencies found */
+	readonly count?: number;
+	/** Missing dependencies if any */
+	readonly missing?: readonly string[];
+}
+/**
+* Config files check result.
+*/
+interface ConfigFilesCheck {
+	/** Whether tsconfig.json exists */
+	readonly tsconfig: boolean;
+	/** Whether biome.json exists */
+	readonly biome?: boolean;
+}
+/**
+* Directories check result.
+*/
+interface DirectoriesCheck {
+	/** Whether src directory exists */
+	readonly src: boolean;
+	/** Whether tests directory exists */
+	readonly tests?: boolean;
+}
+/**
+* Summary of all checks.
+*/
+interface DoctorSummary {
+	/** Number of passed checks */
+	readonly passed: number;
+	/** Number of failed checks */
+	readonly failed: number;
+	/** Total number of checks */
+	readonly total: number;
+}
+/**
+* Complete doctor result.
+*/
+interface DoctorResult {
+	/** Individual check results */
+	readonly checks: {
+		readonly bunVersion: BunVersionCheck;
+		readonly packageJson: PackageJsonCheck;
+		readonly dependencies: DependenciesCheck;
+		readonly configFiles: ConfigFilesCheck;
+		readonly directories: DirectoriesCheck;
+	};
+	/** Summary of all checks */
+	readonly summary: DoctorSummary;
+	/** Exit code (0 = all passed, 1 = some failed) */
+	readonly exitCode: number;
+}
+/**
+* Runs the doctor command programmatically.
+*
+* @param options - Doctor options
+* @returns Doctor result with all check results
+*
+* @example
+* ```typescript
+* const result = await runDoctor({ cwd: process.cwd() });
+*
+* if (result.exitCode === 0) {
+*   console.log("All checks passed!");
+* } else {
+*   console.log(`${result.summary.failed} checks failed`);
+* }
+* ```
+*/
+declare function runDoctor(options: DoctorOptions): DoctorResult;
+/**
+* Formats and outputs doctor results.
+*/
+declare function printDoctorResults(result: DoctorResult, options?: {
+	mode?: OutputMode;
+}): Promise<void>;
+/**
+* Registers the doctor command with the CLI program.
+*
+* @param program - Commander program instance
+*
+* @example
+* ```typescript
+* import { Command } from "commander";
+* import { doctorCommand } from "./commands/doctor.js";
+*
+* const program = new Command();
+* doctorCommand(program);
+* ```
+*/
+declare function doctorCommand(program: Command): void;
+export { DoctorOptions, CheckResult, BunVersionCheck, PackageJsonCheck, DependenciesCheck, ConfigFilesCheck, DirectoriesCheck, DoctorSummary, DoctorResult, runDoctor, printDoctorResults, doctorCommand };