outfitter 0.2.6 → 0.2.7

package/dist/shared/outfitter-109s75x0.d.ts

@@ -0,0 +1,76 @@
+import { OutfitterError } from "@outfitter/contracts";
+import { Result } from "@outfitter/contracts";
+/** A package dependency found across workspace manifests. */
+interface WorkspacePackageEntry {
+	/** Full package name (e.g. "@outfitter/cli") */
+	readonly name: string;
+	/** Cleaned semver version (without range prefix) */
+	readonly version: string;
+}
+/** Version conflict: same package at different versions in different manifests. */
+interface VersionConflict {
+	/** Full package name */
+	readonly name: string;
+	/** All distinct versions found, with their manifest paths */
+	readonly versions: ReadonlyArray<{
+		readonly version: string;
+		readonly manifests: readonly string[];
+	}>;
+}
+/** Result of scanning a workspace for @outfitter/* packages. */
+interface WorkspaceScanResult {
+	/** Version conflicts found across manifests */
+	readonly conflicts: readonly VersionConflict[];
+	/** All manifest paths scanned */
+	readonly manifestPaths: readonly string[];
+	/** Maps package name to the manifest paths that contain it */
+	readonly manifestsByPackage: ReadonlyMap<string, readonly string[]>;
+	/** Deduplicated @outfitter/* packages (uses lowest version for conflicts) */
+	readonly packages: readonly WorkspacePackageEntry[];
+	/** Workspace root directory (null if not a workspace) */
+	readonly workspaceRoot: string | null;
+}
+/**
+* Walk up from `cwd` looking for a workspace root.
+*
+* Workspace root is identified by:
+* - `package.json` with a `workspaces` field (npm/yarn/bun)
+* - `pnpm-workspace.yaml` file
+*
+* Returns `null` (as Ok) if no workspace root found — this is not an error,
+* it means the project is a standalone package.
+*/
+declare function detectWorkspaceRoot(cwd: string): Result<string | null, OutfitterError>;
+/**
+* Collect all package.json files from a workspace root directory.
+*
+* Reads workspace patterns from the root package.json, resolves globs,
+* and returns sorted absolute paths to all matching package.json files.
+* Always includes the root package.json itself.
+*/
+declare function collectWorkspaceManifests(rootDir: string): Result<string[], OutfitterError>;
+/**
+* Scan all workspace manifests, collect @outfitter/* deps,
+* deduplicate, and detect version conflicts.
+*
+* For deduplication: when the same package appears at the same version
+* in multiple manifests, it appears once in the result.
+* When versions differ, the lowest version is used and a conflict is reported.
+*/
+declare function getInstalledPackagesFromWorkspace(rootDir: string): Result<WorkspaceScanResult, OutfitterError>;
+/**
+* Apply version updates to all manifests in a workspace that contain
+* the specified @outfitter/* packages.
+*
+* Preserves the existing version range prefix (^, ~, >=, etc.) in each manifest.
+* Does NOT run `bun install` — the caller is responsible for that.
+*/
+declare function applyUpdatesToWorkspace(manifestPaths: readonly string[], manifestsByPackage: ReadonlyMap<string, readonly string[]>, updates: readonly {
+	name: string;
+	latestVersion: string;
+}[]): Promise<Result<void, OutfitterError>>;
+/**
+* Run `bun install` at the given directory.
+*/
+declare function runInstall(cwd: string): Promise<Result<void, OutfitterError>>;
+export { WorkspacePackageEntry, VersionConflict, WorkspaceScanResult, detectWorkspaceRoot, collectWorkspaceManifests, getInstalledPackagesFromWorkspace, applyUpdatesToWorkspace, runInstall };

package/dist/shared/{outfitter-2np85etz.js → outfitter-1fy7byz5.js}

@@ -1,4 +1,7 @@
 // @bun
+import {
+  sanitizePackageName
+} from "./outfitter-4q1zfmvc.js";
 import {
   ScaffoldError
 } from "./outfitter-8y2dfx6n.js";
@@ -7,6 +10,62 @@ import {
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join, resolve } from "path";
 import { Result } from "@outfitter/contracts";
+function deriveWorkspaceScopeForExamples(workspaceName) {
+  const sanitized = sanitizePackageName(workspaceName);
+  if (sanitized.startsWith("@")) {
+    const separator = sanitized.indexOf("/");
+    if (separator > 1) {
+      return sanitized.slice(0, separator);
+    }
+    if (sanitized.length > 1) {
+      return sanitized;
+    }
+  }
+  if (sanitized.length > 0) {
+    return `@${sanitized}`;
+  }
+  return "@your-scope";
+}
+function buildWorkspaceRootReadme(workspaceName) {
+  const workspaceScope = deriveWorkspaceScopeForExamples(workspaceName);
+  return `# ${workspaceName}
+
+## Structure
+
+\`\`\`
+${workspaceName}/
+\u251C\u2500\u2500 apps/          # Runnable applications (CLI, MCP, daemon, API)
+\u251C\u2500\u2500 packages/      # Shared libraries
+\u2514\u2500\u2500 package.json   # Workspace root
+\`\`\`
+
+## Getting Started
+
+\`\`\`bash
+# Install all dependencies
+bun install
+
+# Build all packages
+bun run build
+
+# Run tests
+bun run test
+
+# Typecheck
+bun run typecheck
+\`\`\`
+
+## Adding Packages
+
+\`\`\`bash
+# Add a new app
+outfitter init --name ${workspaceScope}/my-app --preset cli
+
+# Add a shared library
+outfitter init --name ${workspaceScope}/my-lib --preset library
+\`\`\`
+`;
+}
 function buildWorkspaceRootPackageJson(workspaceName) {
   const workspacePackage = {
     name: workspaceName,
@@ -38,6 +97,10 @@ function scaffoldWorkspaceRoot(rootDir, workspaceName, force) {
     mkdirSync(join(rootDir, "apps"), { recursive: true });
     mkdirSync(join(rootDir, "packages"), { recursive: true });
     writeFileSync(packageJsonPath, buildWorkspaceRootPackageJson(workspaceName), "utf-8");
+    const readmePath = join(rootDir, "README.md");
+    if (force || !existsSync(readmePath)) {
+      writeFileSync(readmePath, buildWorkspaceRootReadme(workspaceName), "utf-8");
+    }
     const gitignorePath = join(rootDir, ".gitignore");
     if (force || !existsSync(gitignorePath)) {
       writeFileSync(gitignorePath, `node_modules
@@ -50,6 +113,18 @@ function scaffoldWorkspaceRoot(rootDir, workspaceName, force) {
     return Result.err(new ScaffoldError(`Failed to scaffold workspace root: ${message}`));
   }
 }
+function getWorkspacePatterns(workspaces) {
+  if (Array.isArray(workspaces)) {
+    return workspaces.filter((entry) => typeof entry === "string");
+  }
+  if (workspaces && typeof workspaces === "object" && !Array.isArray(workspaces)) {
+    const packages = workspaces.packages;
+    if (Array.isArray(packages)) {
+      return packages.filter((entry) => typeof entry === "string");
+    }
+  }
+  return [];
+}
 function hasWorkspacesField(pkg) {
   const workspaces = pkg.workspaces;
   if (Array.isArray(workspaces) && workspaces.length > 0) {
@@ -92,4 +167,4 @@ function detectWorkspaceRoot(cwd) {
   return Result.ok(null);
 }
 
-export { buildWorkspaceRootPackageJson, scaffoldWorkspaceRoot, detectWorkspaceRoot };
+export { buildWorkspaceRootReadme, buildWorkspaceRootPackageJson, scaffoldWorkspaceRoot, getWorkspacePatterns, hasWorkspacesField, detectWorkspaceRoot };

package/dist/shared/outfitter-20f6a2n4.js

@@ -0,0 +1,35 @@
+// @bun
+import {
+  resolveTemplateDependencyVersions
+} from "./outfitter-m44n0qzw.js";
+
+// apps/outfitter/src/commands/shared-deps.ts
+var _dependencyVersions;
+function getDependencyVersions() {
+  if (!_dependencyVersions) {
+    _dependencyVersions = resolveTemplateDependencyVersions();
+  }
+  return _dependencyVersions;
+}
+function pickVersion(source, name, fallback) {
+  return source[name] ?? fallback;
+}
+var SHARED_DEV_DEPS = {
+  "@biomejs/biome": pickVersion(getDependencyVersions().external, "@biomejs/biome", "^2.4.4"),
+  "@outfitter/tooling": pickVersion(getDependencyVersions().internal, "@outfitter/tooling", "^0.2.4"),
+  "@types/bun": pickVersion(getDependencyVersions().external, "@types/bun", "^1.3.9"),
+  lefthook: pickVersion(getDependencyVersions().external, "lefthook", "^2.1.1"),
+  typescript: pickVersion(getDependencyVersions().external, "typescript", "^5.9.3"),
+  ultracite: pickVersion(getDependencyVersions().external, "ultracite", "^7.2.3")
+};
+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-4q1zfmvc.js

@@ -0,0 +1,154 @@
+// @bun
+// apps/outfitter/src/engine/names.ts
+import { basename, isAbsolute, relative } from "path";
+function deriveProjectName(packageName) {
+  const trimmed = packageName.trim();
+  if (!trimmed.startsWith("@")) {
+    return trimmed;
+  }
+  const scopeSeparator = trimmed.indexOf("/");
+  if (scopeSeparator < 0) {
+    return trimmed;
+  }
+  return trimmed.slice(scopeSeparator + 1).trim();
+}
+function deriveBinName(projectName) {
+  return projectName.toLowerCase().replace(/\s+/g, "-");
+}
+function resolveAuthor() {
+  const fromEnv = process.env["GIT_AUTHOR_NAME"] ?? process.env["GIT_COMMITTER_NAME"] ?? process.env["AUTHOR"] ?? process.env["USER"] ?? process.env["USERNAME"];
+  if (fromEnv) {
+    return fromEnv;
+  }
+  try {
+    const result = Bun.spawnSync(["git", "config", "--get", "user.name"], {
+      stdout: "pipe",
+      stderr: "ignore"
+    });
+    if (result.exitCode === 0) {
+      const value = result.stdout.toString().trim();
+      return value.length > 0 ? value : "";
+    }
+  } catch {}
+  return "";
+}
+function resolveYear() {
+  return String(new Date().getFullYear());
+}
+function resolvePackageName(targetDir, name) {
+  return name ?? basename(targetDir);
+}
+var WINDOWS_ABSOLUTE_PATH_RE = /^[a-zA-Z]:[\\/]/;
+var PACKAGE_SEGMENT_RE = /^[a-z0-9._-]+$/;
+var RESERVED_PACKAGE_NAMES = new Set(["node_modules", "favicon.ico"]);
+function validateProjectDirectoryName(name) {
+  const trimmed = name.trim();
+  if (trimmed.length === 0) {
+    return "must not be empty";
+  }
+  if (trimmed === "." || trimmed === "..") {
+    return "must not be '.' or '..'";
+  }
+  if (isAbsolute(trimmed) || WINDOWS_ABSOLUTE_PATH_RE.test(trimmed)) {
+    return "must not be an absolute path";
+  }
+  if (trimmed.includes("/") || trimmed.includes("\\")) {
+    return "must not contain path separators";
+  }
+  return;
+}
+function isPathWithin(basePath, targetPath) {
+  const relativePath = relative(basePath, targetPath);
+  if (relativePath === "") {
+    return true;
+  }
+  if (isAbsolute(relativePath)) {
+    return false;
+  }
+  const segments = relativePath.split(/[\\/]/);
+  return !segments.includes("..");
+}
+function sanitizePackageSegment(value) {
+  return value.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^[._-]+|[._-]+$/g, "");
+}
+function sanitizePackageName(name) {
+  const trimmed = name.trim();
+  if (trimmed.startsWith("@")) {
+    const separator = trimmed.indexOf("/");
+    if (separator > 1 && separator < trimmed.length - 1) {
+      const scope = sanitizePackageSegment(trimmed.slice(1, separator));
+      const pkg = sanitizePackageSegment(trimmed.slice(separator + 1));
+      if (scope.length > 0 && pkg.length > 0) {
+        return `@${scope}/${pkg}`;
+      }
+      if (pkg.length > 0) {
+        return pkg;
+      }
+      if (scope.length > 0) {
+        return scope;
+      }
+      return "";
+    }
+  }
+  return sanitizePackageSegment(trimmed);
+}
+function validatePackageSegment(segment, kind) {
+  if (segment.length === 0) {
+    return `${kind} must not be empty`;
+  }
+  if (!PACKAGE_SEGMENT_RE.test(segment)) {
+    return `${kind} contains invalid characters`;
+  }
+  if (kind === "name" && (segment.startsWith(".") || segment.startsWith("_"))) {
+    return `${kind} must not start with '.' or '_'`;
+  }
+  return;
+}
+function validatePackageName(name) {
+  const trimmed = name.trim();
+  if (trimmed.length === 0) {
+    return "must not be empty";
+  }
+  if (trimmed.length > 214) {
+    return "must be 214 characters or fewer";
+  }
+  if (trimmed !== trimmed.toLowerCase()) {
+    return "must be lowercase";
+  }
+  if (/\s/.test(trimmed)) {
+    return "must not contain spaces";
+  }
+  if (trimmed.startsWith("@")) {
+    const separator = trimmed.indexOf("/");
+    if (separator <= 1 || separator === trimmed.length - 1) {
+      return "scoped names must be in the form @scope/name";
+    }
+    if (trimmed.indexOf("/", separator + 1) !== -1) {
+      return "scoped names must contain exactly one '/' separator";
+    }
+    const scope = trimmed.slice(1, separator);
+    const pkg = trimmed.slice(separator + 1);
+    const scopeError = validatePackageSegment(scope, "scope");
+    if (scopeError) {
+      return scopeError;
+    }
+    const nameError = validatePackageSegment(pkg, "name");
+    if (nameError) {
+      return nameError;
+    }
+    if (RESERVED_PACKAGE_NAMES.has(pkg)) {
+      return `'${pkg}' is a reserved package name`;
+    }
+    return;
+  }
+  const segmentError = validatePackageSegment(trimmed, "name");
+  if (segmentError) {
+    return segmentError;
+  }
+  if (RESERVED_PACKAGE_NAMES.has(trimmed)) {
+    return `'${trimmed}' is a reserved package name`;
+  }
+  return;
+}
+
+export { deriveProjectName, deriveBinName, resolveAuthor, resolveYear, resolvePackageName, validateProjectDirectoryName, isPathWithin, sanitizePackageName, validatePackageName };

package/dist/shared/{outfitter-66b25bj8.js → outfitter-5akzvppx.js}

@@ -1,4 +1,8 @@
 // @bun
+import {
+  injectSharedConfig,
+  rewriteLocalDependencies
+} from "./outfitter-ha89qf8q.js";
 import {
   copyTemplateFiles,
   getTemplatesDir
@@ -6,10 +10,6 @@ import {
 import {
   addBlocks
 } from "./outfitter-j833sxws.js";
-import {
-  injectSharedConfig,
-  rewriteLocalDependencies
-} from "./outfitter-ara3djt0.js";
 import {
   ScaffoldError
 } from "./outfitter-8y2dfx6n.js";

package/dist/shared/outfitter-5y646xzk.js

@@ -0,0 +1,301 @@
+// @bun
+import {
+  getWorkspacePatterns,
+  hasWorkspacesField
+} from "./outfitter-1fy7byz5.js";
+import {
+  validatePackageName
+} from "./outfitter-4q1zfmvc.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/doctor.ts
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+import { output } from "@outfitter/cli";
+import { createTheme } from "@outfitter/tui/render";
+var MIN_BUN_VERSION = "1.3.6";
+function checkBunVersion() {
+  const required = MIN_BUN_VERSION;
+  const current = Bun.version;
+  const passed = Bun.semver.satisfies(current, `>=${required}`);
+  return {
+    passed,
+    version: current,
+    required,
+    ...passed ? {} : {
+      error: `Bun version ${current} is below minimum required ${required}`
+    }
+  };
+}
+function readPackageJson(cwd) {
+  const packageJsonPath = join(cwd, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return { exists: false };
+  }
+  try {
+    const content = readFileSync(packageJsonPath, "utf-8");
+    return {
+      exists: true,
+      parsed: JSON.parse(content)
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      exists: true,
+      parseError: message
+    };
+  }
+}
+function checkPackageJson(packageJson) {
+  if (!packageJson.exists) {
+    return {
+      passed: false,
+      error: "package.json not found in current directory"
+    };
+  }
+  if (packageJson.parseError) {
+    return {
+      passed: false,
+      error: `package.json is invalid JSON: ${packageJson.parseError}`
+    };
+  }
+  const parsed = packageJson.parsed;
+  if (!parsed) {
+    return {
+      passed: false,
+      error: "package.json is invalid JSON"
+    };
+  }
+  if (typeof parsed["name"] !== "string" || parsed["name"].length === 0) {
+    return {
+      passed: false,
+      error: "package.json is missing required 'name' field"
+    };
+  }
+  if (typeof parsed["version"] !== "string" || parsed["version"].length === 0) {
+    return {
+      passed: false,
+      error: "package.json is missing required 'version' field"
+    };
+  }
+  const packageName = parsed["name"];
+  const packageVersion = parsed["version"];
+  const invalidPackageName = validatePackageName(packageName);
+  if (invalidPackageName) {
+    return {
+      passed: false,
+      name: packageName,
+      version: packageVersion,
+      error: `package.json has invalid package name '${packageName}': ${invalidPackageName}`
+    };
+  }
+  return {
+    passed: true,
+    name: packageName,
+    version: packageVersion
+  };
+}
+function checkDependencies(cwd, packageJson, rootCwd) {
+  if (!packageJson.exists) {
+    return { passed: true, count: 0 };
+  }
+  const parsed = packageJson.parsed;
+  if (!parsed) {
+    return { passed: true, count: 0 };
+  }
+  const dependencies = parsed["dependencies"];
+  const devDependencies = parsed["devDependencies"];
+  const allDeps = [
+    ...Object.keys(dependencies ?? {}),
+    ...Object.keys(devDependencies ?? {})
+  ];
+  if (allDeps.length === 0) {
+    return { passed: true, count: 0 };
+  }
+  const nodeModulesPath = join(cwd, "node_modules");
+  const rootNodeModulesPath = rootCwd ? join(rootCwd, "node_modules") : null;
+  if (!(existsSync(nodeModulesPath) || rootNodeModulesPath && existsSync(rootNodeModulesPath))) {
+    return {
+      passed: false,
+      count: allDeps.length,
+      error: "node_modules not found. Run 'bun install' to install dependencies."
+    };
+  }
+  const missing = [];
+  for (const dep of allDeps) {
+    const localDepPath = join(nodeModulesPath, dep);
+    if (existsSync(localDepPath)) {
+      continue;
+    }
+    if (rootNodeModulesPath && existsSync(join(rootNodeModulesPath, dep))) {
+      continue;
+    }
+    missing.push(dep);
+  }
+  if (missing.length > 0) {
+    return {
+      passed: false,
+      count: allDeps.length,
+      missing,
+      error: `Missing dependencies: ${missing.join(", ")}. Run 'bun install' to install.`
+    };
+  }
+  return { passed: true, count: allDeps.length };
+}
+function checkConfigFiles(cwd) {
+  return {
+    tsconfig: existsSync(join(cwd, "tsconfig.json"))
+  };
+}
+function checkDirectories(cwd) {
+  return {
+    src: existsSync(join(cwd, "src"))
+  };
+}
+function discoverWorkspaceMemberPaths(cwd, packageJson) {
+  const patterns = getWorkspacePatterns(packageJson["workspaces"]);
+  const memberPaths = new Set;
+  for (const pattern of patterns) {
+    const normalizedPattern = pattern.replace(/\/+$/, "");
+    const packageJsonPattern = normalizedPattern.endsWith("package.json") ? normalizedPattern : `${normalizedPattern}/package.json`;
+    const glob = new Bun.Glob(packageJsonPattern);
+    for (const match of glob.scanSync({ cwd, dot: false })) {
+      const normalizedMatch = match.replaceAll("\\", "/");
+      if (!normalizedMatch.endsWith("/package.json")) {
+        continue;
+      }
+      const path = normalizedMatch.slice(0, -"package.json".length - 1);
+      if (path.length > 0) {
+        memberPaths.add(path);
+      }
+    }
+  }
+  return [...memberPaths].sort();
+}
+function isWorkspaceRoot(packageJson) {
+  return packageJson ? hasWorkspacesField(packageJson) : false;
+}
+function runDoctorForCwd(cwd, options) {
+  const packageJsonRead = readPackageJson(cwd);
+  const wsRoot = isWorkspaceRoot(packageJsonRead.parsed);
+  const bunVersion = checkBunVersion();
+  const packageJson = checkPackageJson(packageJsonRead);
+  const dependencies = checkDependencies(cwd, packageJsonRead, options.rootCwd);
+  const configFiles = checkConfigFiles(cwd);
+  const directories = checkDirectories(cwd);
+  const normalizedConfigFiles = wsRoot ? { ...configFiles, tsconfig: true } : configFiles;
+  const normalizedDirectories = wsRoot ? { ...directories, src: true } : directories;
+  const checkResults = wsRoot ? [bunVersion.passed, packageJson.passed, dependencies.passed] : [
+    bunVersion.passed,
+    packageJson.passed,
+    dependencies.passed,
+    configFiles.tsconfig,
+    directories.src
+  ];
+  const passed = checkResults.filter(Boolean).length;
+  const failed = checkResults.length - passed;
+  const total = checkResults.length;
+  const workspaceMembers = options.includeWorkspaceMembers && wsRoot && packageJsonRead.parsed ? discoverWorkspaceMemberPaths(cwd, packageJsonRead.parsed).map((path) => {
+    const memberResult = runDoctorForCwd(join(cwd, path), {
+      includeWorkspaceMembers: false,
+      rootCwd: cwd
+    });
+    return {
+      path,
+      summary: memberResult.summary,
+      exitCode: memberResult.exitCode
+    };
+  }) : undefined;
+  return {
+    checks: {
+      bunVersion,
+      packageJson,
+      dependencies,
+      configFiles: normalizedConfigFiles,
+      directories: normalizedDirectories
+    },
+    summary: { passed, failed, total },
+    exitCode: failed > 0 ? 1 : 0,
+    ...wsRoot ? { isWorkspaceRoot: true } : {},
+    ...wsRoot ? {
+      skippedChecks: [
+        "checks.configFiles.tsconfig",
+        "checks.directories.src"
+      ]
+    } : {},
+    ...workspaceMembers && workspaceMembers.length > 0 ? { workspaceMembers } : {}
+  };
+}
+function runDoctor(options) {
+  const cwd = resolve(options.cwd);
+  return runDoctorForCwd(cwd, { includeWorkspaceMembers: true });
+}
+async function printDoctorResults(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    await output(result, { mode: structuredMode });
+    return;
+  }
+  const theme = createTheme();
+  const lines = ["", "Outfitter Doctor", "", "=".repeat(50)];
+  const bunIcon = result.checks.bunVersion.passed ? theme.success("[PASS]") : theme.error("[FAIL]");
+  lines.push(`${bunIcon} Bun Version: ${result.checks.bunVersion.version} (requires ${result.checks.bunVersion.required})`);
+  if (result.checks.bunVersion.error) {
+    lines.push(`       ${theme.muted(result.checks.bunVersion.error)}`);
+  }
+  const pkgIcon = result.checks.packageJson.passed ? theme.success("[PASS]") : theme.error("[FAIL]");
+  lines.push(`${pkgIcon} package.json`);
+  if (result.checks.packageJson.error) {
+    lines.push(`       ${theme.muted(result.checks.packageJson.error)}`);
+  } else if (result.checks.packageJson.name) {
+    lines.push(`       ${theme.muted(`${result.checks.packageJson.name}@${result.checks.packageJson.version}`)}`);
+  }
+  const depsIcon = result.checks.dependencies.passed ? theme.success("[PASS]") : theme.error("[FAIL]");
+  lines.push(`${depsIcon} Dependencies`);
+  if (result.checks.dependencies.error) {
+    lines.push(`       ${theme.muted(result.checks.dependencies.error)}`);
+  } else if (result.checks.dependencies.count !== undefined) {
+    lines.push(`       ${theme.muted(`${result.checks.dependencies.count} dependencies installed`)}`);
+  }
+  if (result.isWorkspaceRoot) {
+    lines.push(`${theme.muted("[SKIP]")} tsconfig.json`);
+    lines.push(`       ${theme.muted("Not checked at workspace root")}`);
+  } else {
+    const tsconfigIcon = result.checks.configFiles.tsconfig ? theme.success("[PASS]") : theme.warning("[WARN]");
+    lines.push(`${tsconfigIcon} tsconfig.json`);
+  }
+  if (result.isWorkspaceRoot) {
+    lines.push(`${theme.muted("[SKIP]")} src/ directory`);
+    lines.push(`       ${theme.muted("Not checked at workspace root")}`);
+  } else {
+    const srcIcon = result.checks.directories.src ? theme.success("[PASS]") : theme.warning("[WARN]");
+    lines.push(`${srcIcon} src/ directory`);
+  }
+  if (result.workspaceMembers && result.workspaceMembers.length > 0) {
+    lines.push("", "Members:");
+    for (const member of result.workspaceMembers) {
+      const memberIcon = member.exitCode === 0 ? theme.success("[PASS]") : theme.warning("[WARN]");
+      lines.push(`  ${memberIcon} ${member.path} ${member.summary.passed}/${member.summary.total} checks passed`);
+    }
+  }
+  lines.push("", "=".repeat(50));
+  const summaryColor = result.exitCode === 0 ? theme.success : theme.error;
+  lines.push(summaryColor(`${result.summary.passed}/${result.summary.total} checks passed`));
+  if (result.exitCode !== 0) {
+    lines.push("", theme.muted("Run 'outfitter doctor' after fixing issues to verify."));
+  }
+  await output(lines, { mode: "human" });
+}
+function doctorCommand(program) {
+  program.command("doctor").description("Validate environment and dependencies").action(async (_flags, command) => {
+    const resolvedFlags = command.optsWithGlobals();
+    const outputOptions = resolvedFlags.json ? { mode: "json" } : undefined;
+    const result = runDoctor({ cwd: process.cwd() });
+    await printDoctorResults(result, outputOptions);
+    process.exit(result.exitCode);
+  });
+}
+
+export { runDoctor, printDoctorResults, doctorCommand };