@webstir-io/webstir 0.1.1 → 0.1.2

package/src/refresh.ts

@@ -1,5 +1,6 @@
 import path from 'node:path';
-import { mkdir, readdir, rm } from 'node:fs/promises';
+import { mkdir, readFile, readdir, rm } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
 
 import { scaffoldWorkspace } from './init.ts';
 import type { WorkspaceMode } from './types.ts';
@@ -24,10 +25,11 @@ export async function runRefresh(options: RunRefreshOptions): Promise<RefreshRes
   }
 
   const mode = parseWorkspaceMode(modeToken);
+  const metadata = await readWorkspaceManifestMetadata(workspaceRoot);
   await mkdir(workspaceRoot, { recursive: true });
   await emptyDirectory(workspaceRoot);
 
-  const result = await scaffoldWorkspace(mode, workspaceRoot, { force: true });
+  const result = await scaffoldWorkspace(mode, workspaceRoot, { force: true, metadata });
   return {
     workspaceRoot: result.workspaceRoot,
     mode: result.mode,
@@ -44,7 +46,12 @@ async function emptyDirectory(directoryPath: string): Promise<void> {
 
 function parseWorkspaceMode(value: string): WorkspaceMode {
   const normalized = value.trim().toLowerCase();
-  if (normalized === 'ssg' || normalized === 'spa' || normalized === 'api' || normalized === 'full') {
+  if (
+    normalized === 'ssg' ||
+    normalized === 'spa' ||
+    normalized === 'api' ||
+    normalized === 'full'
+  ) {
     return normalized;
   }
 
@@ -54,3 +61,22 @@ function parseWorkspaceMode(value: string): WorkspaceMode {
 
   throw new Error(`Unknown refresh mode "${value}". Expected ssg, spa, api, or full.`);
 }
+
+async function readWorkspaceManifestMetadata(
+  workspaceRoot: string,
+): Promise<{ readonly packageName?: string; readonly description?: string } | undefined> {
+  const packageJsonPath = path.join(workspaceRoot, 'package.json');
+  if (!existsSync(packageJsonPath)) {
+    return undefined;
+  }
+
+  const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8')) as {
+    readonly name?: string;
+    readonly description?: string;
+  };
+
+  return {
+    packageName: packageJson.name,
+    description: packageJson.description,
+  };
+}

package/src/repair.ts

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { chmod, copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { chmod, mkdir } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 
 import { getBackendScaffoldAssets } from '@webstir-io/webstir-backend';
@@ -47,12 +47,17 @@ export async function runRepair(options: RunRepairOptions): Promise<RepairResult
   const dryRun = options.rawArgs.includes('--dry-run');
   const workspace = await readWorkspaceDescriptor(options.workspaceRoot);
   const packageJsonPath = path.join(workspace.root, 'package.json');
-  const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8')) as RepairPackageJson;
+  const packageJson = JSON.parse(await readTextFile(packageJsonPath)) as RepairPackageJson;
   const enable = packageJson.webstir?.enable ?? {};
   const changes: string[] = [];
 
   await restoreScaffoldAssets(workspace.root, getRootScaffoldAssets(), changes, dryRun);
-  await restoreScaffoldAssets(workspace.root, await getModeScaffoldAssets(workspace.mode), changes, dryRun);
+  await restoreScaffoldAssets(
+    workspace.root,
+    filterModeScaffoldAssets(await getModeScaffoldAssets(workspace.mode), enable),
+    changes,
+    dryRun,
+  );
 
   if (enable.spa) {
     await restoreFeatureAssets(workspace.root, getSpaAssets(), changes, dryRun);
@@ -64,7 +69,13 @@ export async function runRepair(options: RunRepairOptions): Promise<RepairResult
   if (enable.search) {
     await restoreFeatureAssets(workspace.root, getSearchAssets(), changes, dryRun);
     await ensureCssLayerIncludes(workspace.root, 'features', changes, dryRun);
-    await ensureAppCssImport(workspace.root, './styles/features/search.css', './styles/components/buttons.css', changes, dryRun);
+    await ensureAppCssImport(
+      workspace.root,
+      './styles/features/search.css',
+      './styles/components/buttons.css',
+      changes,
+      dryRun,
+    );
     await ensureAppImport(workspace.root, './scripts/features/search.js', changes, dryRun);
     await ensureHtmlSearchMode(workspace.root, changes, dryRun);
   }
@@ -76,12 +87,14 @@ export async function runRepair(options: RunRepairOptions): Promise<RepairResult
       './styles/features/content-nav.css',
       './styles/components/buttons.css',
       changes,
-      dryRun
+      dryRun,
     );
     await ensureAppImport(workspace.root, './scripts/features/content-nav.js', changes, dryRun);
   }
-  if (enable.backend || workspace.mode === 'api' || workspace.mode === 'full') {
+  if (enable.backend) {
     await restoreBackendAssets(workspace.root, changes, dryRun);
+  }
+  if (enable.backend || workspace.mode === 'api' || workspace.mode === 'full') {
     await ensureBackendTsReference(workspace.root, changes, dryRun);
   }
   if (enable.githubPages) {
@@ -98,11 +111,24 @@ export async function runRepair(options: RunRepairOptions): Promise<RepairResult
   };
 }
 
+function filterModeScaffoldAssets(
+  assets: readonly { sourcePath: string; targetPath: string }[],
+  enable: RepairEnableFlags,
+): readonly { sourcePath: string; targetPath: string }[] {
+  if (!enable.backend) {
+    return assets;
+  }
+
+  return assets.filter(
+    (asset) => !normalizeRelativePath(asset.targetPath).startsWith('src/backend/'),
+  );
+}
+
 async function restoreScaffoldAssets(
   workspaceRoot: string,
   assets: readonly { sourcePath: string; targetPath: string }[],
   changes: string[],
-  dryRun: boolean
+  dryRun: boolean,
 ): Promise<void> {
   for (const asset of assets) {
     const targetPath = path.join(workspaceRoot, asset.targetPath);
@@ -112,7 +138,7 @@ async function restoreScaffoldAssets(
 
     if (!dryRun) {
       await mkdir(path.dirname(targetPath), { recursive: true });
-      await copyFile(asset.sourcePath, targetPath);
+      await Bun.write(targetPath, Bun.file(asset.sourcePath));
     }
 
     changes.push(relativeWorkspacePath(workspaceRoot, targetPath));
@@ -123,7 +149,7 @@ async function restoreFeatureAssets(
   workspaceRoot: string,
   assets: readonly StaticFeatureAsset[],
   changes: string[],
-  dryRun: boolean
+  dryRun: boolean,
 ): Promise<void> {
   for (const asset of assets) {
     const targetPath = path.join(workspaceRoot, asset.targetPath);
@@ -133,7 +159,7 @@ async function restoreFeatureAssets(
 
     if (!dryRun) {
       await mkdir(path.dirname(targetPath), { recursive: true });
-      await copyFile(asset.sourcePath, targetPath);
+      await Bun.write(targetPath, Bun.file(asset.sourcePath));
       if (asset.executable) {
         await chmod(targetPath, 0o755);
       }
@@ -143,7 +169,11 @@ async function restoreFeatureAssets(
   }
 }
 
-async function restoreBackendAssets(workspaceRoot: string, changes: string[], dryRun: boolean): Promise<void> {
+async function restoreBackendAssets(
+  workspaceRoot: string,
+  changes: string[],
+  dryRun: boolean,
+): Promise<void> {
   const assets = await getBackendScaffoldAssets();
   for (const asset of assets) {
     const targetPath = path.join(workspaceRoot, asset.targetPath);
@@ -153,7 +183,7 @@ async function restoreBackendAssets(workspaceRoot: string, changes: string[], dr
 
     if (!dryRun) {
       await mkdir(path.dirname(targetPath), { recursive: true });
-      await copyFile(asset.sourcePath, targetPath);
+      await Bun.write(targetPath, Bun.file(asset.sourcePath));
     }
 
     changes.push(relativeWorkspacePath(workspaceRoot, targetPath));
@@ -164,21 +194,21 @@ async function ensureAppImport(
   workspaceRoot: string,
   importPath: string,
   changes: string[],
-  dryRun: boolean
+  dryRun: boolean,
 ): Promise<void> {
   const appTsPath = path.join(workspaceRoot, 'src', 'frontend', 'app', 'app.ts');
   if (!existsSync(appTsPath)) {
     return;
   }
 
-  const source = await readFile(appTsPath, 'utf8');
+  const source = await readTextFile(appTsPath);
   const updated = ensureSideEffectImport(source, importPath);
   if (updated === source) {
     return;
   }
 
   if (!dryRun) {
-    await writeFile(appTsPath, updated, 'utf8');
+    await Bun.write(appTsPath, updated);
   }
   changes.push(relativeWorkspacePath(workspaceRoot, appTsPath));
 }
@@ -187,21 +217,21 @@ async function ensureCssLayerIncludes(
   workspaceRoot: string,
   layerName: string,
   changes: string[],
-  dryRun: boolean
+  dryRun: boolean,
 ): Promise<void> {
   const appCssPath = path.join(workspaceRoot, 'src', 'frontend', 'app', 'app.css');
   if (!existsSync(appCssPath)) {
     return;
   }
 
-  const source = await readFile(appCssPath, 'utf8');
+  const source = await readTextFile(appCssPath);
   const updated = ensureLayerIncludes(source, layerName);
   if (updated === source) {
     return;
   }
 
   if (!dryRun) {
-    await writeFile(appCssPath, updated, 'utf8');
+    await Bun.write(appCssPath, updated);
   }
   changes.push(relativeWorkspacePath(workspaceRoot, appCssPath));
 }
@@ -211,63 +241,72 @@ async function ensureAppCssImport(
   importPath: string,
   insertAfterImportPath: string,
   changes: string[],
-  dryRun: boolean
+  dryRun: boolean,
 ): Promise<void> {
   const appCssPath = path.join(workspaceRoot, 'src', 'frontend', 'app', 'app.css');
   if (!existsSync(appCssPath)) {
     return;
   }
 
-  const source = await readFile(appCssPath, 'utf8');
+  const source = await readTextFile(appCssPath);
   const updated = ensureImportIncludes(source, importPath, insertAfterImportPath);
   if (updated === source) {
     return;
   }
 
   if (!dryRun) {
-    await writeFile(appCssPath, updated, 'utf8');
+    await Bun.write(appCssPath, updated);
   }
   changes.push(relativeWorkspacePath(workspaceRoot, appCssPath));
 }
 
-async function ensureHtmlSearchMode(workspaceRoot: string, changes: string[], dryRun: boolean): Promise<void> {
+async function ensureHtmlSearchMode(
+  workspaceRoot: string,
+  changes: string[],
+  dryRun: boolean,
+): Promise<void> {
   const appHtmlPath = path.join(workspaceRoot, 'src', 'frontend', 'app', 'app.html');
   if (!existsSync(appHtmlPath)) {
     return;
   }
 
-  const source = await readFile(appHtmlPath, 'utf8');
+  const source = await readTextFile(appHtmlPath);
   if (source.includes('data-webstir-search-styles=')) {
     return;
   }
 
   const updated = source.replace(
     /<html\b(?![^>]*\bdata-webstir-search-styles=)/i,
-    '<html data-webstir-search-styles="css"'
+    '<html data-webstir-search-styles="css"',
   );
   if (updated === source) {
     return;
   }
 
   if (!dryRun) {
-    await writeFile(appHtmlPath, updated, 'utf8');
+    await Bun.write(appHtmlPath, updated);
   }
   changes.push(relativeWorkspacePath(workspaceRoot, appHtmlPath));
 }
 
-async function ensureBackendTsReference(workspaceRoot: string, changes: string[], dryRun: boolean): Promise<void> {
+async function ensureBackendTsReference(
+  workspaceRoot: string,
+  changes: string[],
+  dryRun: boolean,
+): Promise<void> {
   const tsconfigPath = path.join(workspaceRoot, 'base.tsconfig.json');
   if (!existsSync(tsconfigPath)) {
     return;
   }
 
-  const source = await readFile(tsconfigPath, 'utf8');
+  const source = await readTextFile(tsconfigPath);
   const root = JSON.parse(source) as Record<string, unknown>;
   const references = Array.isArray(root.references) ? [...root.references] : [];
-  const exists = references.some((entry) =>
-    typeof entry === 'object'
-    && entry !== null
-    && (entry as Record<string, unknown>).path === 'src/backend'
+  const exists = references.some(
+    (entry) =>
+      typeof entry === 'object' &&
+      entry !== null &&
+      (entry as Record<string, unknown>).path === 'src/backend',
   );
   if (exists) {
     return;
@@ -278,12 +317,16 @@ async function ensureBackendTsReference(workspaceRoot: string, changes: string[]
   const updated = `${JSON.stringify(root, null, 2)}\n`;
 
   if (!dryRun) {
-    await writeFile(tsconfigPath, updated, 'utf8');
+    await Bun.write(tsconfigPath, updated);
   }
   changes.push(relativeWorkspacePath(workspaceRoot, tsconfigPath));
 }
 
-async function ensureGithubPagesDeployScript(workspaceRoot: string, changes: string[], dryRun: boolean): Promise<void> {
+async function ensureGithubPagesDeployScript(
+  workspaceRoot: string,
+  changes: string[],
+  dryRun: boolean,
+): Promise<void> {
   const deployScriptPath = path.join(workspaceRoot, 'utils', 'deploy-gh-pages.sh');
   if (existsSync(deployScriptPath)) {
     return;
@@ -291,14 +334,18 @@ async function ensureGithubPagesDeployScript(workspaceRoot: string, changes: str
 
   if (!dryRun) {
     await mkdir(path.dirname(deployScriptPath), { recursive: true });
-    await writeFile(deployScriptPath, renderGithubPagesDeployScript(), 'utf8');
+    await Bun.write(deployScriptPath, renderGithubPagesDeployScript());
     await chmod(deployScriptPath, 0o755);
   }
   changes.push(relativeWorkspacePath(workspaceRoot, deployScriptPath));
 }
 
-async function ensureDeployScriptEntry(packageJsonPath: string, changes: string[], dryRun: boolean): Promise<void> {
-  const source = await readFile(packageJsonPath, 'utf8');
+async function ensureDeployScriptEntry(
+  packageJsonPath: string,
+  changes: string[],
+  dryRun: boolean,
+): Promise<void> {
+  const source = await readTextFile(packageJsonPath);
   const root = JSON.parse(source) as RepairPackageJson & Record<string, unknown>;
   const scripts = root.scripts && typeof root.scripts === 'object' ? { ...root.scripts } : {};
   if (typeof scripts.deploy === 'string') {
@@ -310,18 +357,22 @@ async function ensureDeployScriptEntry(packageJsonPath: string, changes: string[
   const updated = `${JSON.stringify(root, null, 2)}\n`;
 
   if (!dryRun) {
-    await writeFile(packageJsonPath, updated, 'utf8');
+    await Bun.write(packageJsonPath, updated);
   }
   changes.push(path.basename(packageJsonPath));
 }
 
-async function ensureFrontendConfigBasePath(workspaceRoot: string, changes: string[], dryRun: boolean): Promise<void> {
+async function ensureFrontendConfigBasePath(
+  workspaceRoot: string,
+  changes: string[],
+  dryRun: boolean,
+): Promise<void> {
   const configPath = path.join(workspaceRoot, 'src', 'frontend', 'frontend.config.json');
   let root: Record<string, unknown> = {};
 
   if (existsSync(configPath)) {
     try {
-      root = JSON.parse(await readFile(configPath, 'utf8')) as Record<string, unknown>;
+      root = JSON.parse(await readTextFile(configPath)) as Record<string, unknown>;
     } catch {
       root = {};
     }
@@ -338,11 +389,15 @@ async function ensureFrontendConfigBasePath(workspaceRoot: string, changes: stri
 
   if (!dryRun) {
     await mkdir(path.dirname(configPath), { recursive: true });
-    await writeFile(configPath, updated, 'utf8');
+    await Bun.write(configPath, updated);
   }
   changes.push(relativeWorkspacePath(workspaceRoot, configPath));
 }
 
+async function readTextFile(filePath: string): Promise<string> {
+  return await Bun.file(filePath).text();
+}
+
 function ensureSideEffectImport(source: string, importPath: string): string {
   const escaped = escapeRegExp(importPath);
   const pattern = new RegExp(`^\\s*import\\s+(['"])${escaped}\\1\\s*;?\\s*$`, 'm');
@@ -360,7 +415,10 @@ function ensureLayerIncludes(css: string, layerName: string): string {
     return css;
   }
 
-  const layers = match[1].split(',').map((layer) => layer.trim()).filter(Boolean);
+  const layers = match[1]
+    .split(',')
+    .map((layer) => layer.trim())
+    .filter(Boolean);
   if (layers.includes(layerName)) {
     return css;
   }
@@ -368,13 +426,18 @@ function ensureLayerIncludes(css: string, layerName: string): string {
   const updated = [...layers];
   const utilitiesIndex = updated.indexOf('utilities');
   const overridesIndex = updated.indexOf('overrides');
-  const insertIndex = utilitiesIndex >= 0 ? utilitiesIndex : overridesIndex >= 0 ? overridesIndex : updated.length;
+  const insertIndex =
+    utilitiesIndex >= 0 ? utilitiesIndex : overridesIndex >= 0 ? overridesIndex : updated.length;
   updated.splice(insertIndex, 0, layerName);
   const replacement = `@layer ${updated.join(', ')};`;
   return `${css.slice(0, match.index)}${replacement}${css.slice(match.index + match[0].length)}`;
 }
 
-function ensureImportIncludes(css: string, importPath: string, insertAfterImportPath: string): string {
+function ensureImportIncludes(
+  css: string,
+  importPath: string,
+  insertAfterImportPath: string,
+): string {
   if (css.includes(`@import "${importPath}"`) || css.includes(`@import '${importPath}'`)) {
     return css;
   }
@@ -399,6 +462,10 @@ function relativeWorkspacePath(workspaceRoot: string, absolutePath: string): str
   return path.relative(workspaceRoot, absolutePath).replaceAll(path.sep, '/');
 }
 
+function normalizeRelativePath(value: string): string {
+  return value.split(path.sep).join('/');
+}
+
 function asRecord(value: unknown): Record<string, unknown> {
   return value && typeof value === 'object' && !Array.isArray(value)
     ? { ...(value as Record<string, unknown>) }

package/src/runtime-filter.ts

@@ -0,0 +1,41 @@
+import type { TestManifest } from '@webstir-io/webstir-testing';
+
+export type RuntimeFilter = 'frontend' | 'backend' | null;
+
+export function normalizeRuntimeFilter(value: string | undefined | null): RuntimeFilter {
+  const normalized = (value ?? '').trim().toLowerCase();
+  if (!normalized || normalized === 'all') {
+    return null;
+  }
+
+  if (normalized === 'frontend' || normalized === 'backend') {
+    return normalized;
+  }
+
+  return null;
+}
+
+export function applyRuntimeFilter(manifest: TestManifest, runtime: RuntimeFilter): TestManifest {
+  if (!runtime) {
+    return manifest;
+  }
+
+  return {
+    ...manifest,
+    modules: manifest.modules.filter((module) => module.runtime === runtime),
+  };
+}
+
+export function describeRuntimeFilter(
+  runtime: RuntimeFilter,
+  before: number,
+  after: number,
+): string | null {
+  if (!runtime) {
+    return null;
+  }
+
+  const skipped = Math.max(before - after, 0);
+  const noun = after === 1 ? 'test' : 'tests';
+  return `Runtime filter '${runtime}' matched ${after} ${noun} (${skipped} skipped).`;
+}

package/src/runtime.ts

@@ -7,7 +7,7 @@ export type ModuleRuntimeMode = 'build' | 'publish' | 'test';
 export function createWorkspaceRuntimeEnv(
   workspaceRoot: string,
   mode: ModuleRuntimeMode,
-  env: Record<string, string | undefined> = process.env
+  env: Record<string, string | undefined> = process.env,
 ): Record<string, string | undefined> {
   const binPaths = [
     ...collectNodeModuleBins(workspaceRoot),

package/src/smoke.ts

@@ -1,10 +1,15 @@
 import os from 'node:os';
 import path from 'node:path';
-import { cp, mkdtemp, rm } from 'node:fs/promises';
+import { mkdtemp, rm } from 'node:fs/promises';
 
 import type { WorkspaceDescriptor } from './types.ts';
 
 import { runBackendInspect, type BackendInspectResult } from './backend-inspect.ts';
+import { runDoctor, type DoctorResult } from './doctor.ts';
+import {
+  materializeRepoLocalWorkspaceDependencies,
+  prepareExternalWorkspaceCopy,
+} from './external-workspace.ts';
 import { monorepoRoot } from './paths.ts';
 import { runBuild, type RunBuildOptions } from './build.ts';
 import { scaffoldWorkspace } from './init.ts';
@@ -18,7 +23,7 @@ export interface RunSmokeOptions {
 }
 
 export interface SmokePhaseResult {
-  readonly name: 'build' | 'test' | 'publish' | 'backend-inspect';
+  readonly name: 'build' | 'test' | 'publish' | 'doctor' | 'backend-inspect';
   readonly detail: string;
 }
 
@@ -68,6 +73,18 @@ export async function runSmoke(options: RunSmokeOptions = {}): Promise<SmokeResu
       detail: formatBuildDetail(publishResult),
     });
 
+    const doctorResult = await runDoctor({
+      workspaceRoot: workspace.root,
+      env,
+    });
+    if (!doctorResult.healthy) {
+      throw new Error('Smoke doctor phase reported issues.');
+    }
+    phases.push({
+      name: 'doctor',
+      detail: formatDoctorDetail(doctorResult),
+    });
+
     if (workspace.mode === 'api' || workspace.mode === 'full') {
       const backendInspect = await runBackendInspect({
         workspaceRoot: workspace.root,
@@ -94,14 +111,15 @@ export async function runSmoke(options: RunSmokeOptions = {}): Promise<SmokeResu
 
 function createSmokeEnv(
   workspaceRoot: string,
-  env: Record<string, string | undefined> = process.env
+  env: Record<string, string | undefined> = process.env,
 ): Record<string, string | undefined> {
   if (env.WEBSTIR_BACKEND_TYPECHECK) {
     return env;
   }
 
   const relativeToRepo = monorepoRoot ? path.relative(monorepoRoot, workspaceRoot) : '../external';
-  const isExternalWorkspace = !monorepoRoot || relativeToRepo.startsWith('..') || path.isAbsolute(relativeToRepo);
+  const isExternalWorkspace =
+    !monorepoRoot || relativeToRepo.startsWith('..') || path.isAbsolute(relativeToRepo);
   if (!isExternalWorkspace) {
     return env;
   }
@@ -119,30 +137,40 @@ async function prepareWorkspace(workspaceRoot?: string): Promise<{
   readonly source?: string;
 }> {
   if (workspaceRoot) {
+    const resolvedWorkspaceRoot = path.resolve(workspaceRoot);
+    const preparedExternalWorkspace = await prepareExternalWorkspaceCopy(
+      resolvedWorkspaceRoot,
+      'webstir-smoke-explicit-',
+      {
+        forceLocalPackages: true,
+      },
+    );
+    if (preparedExternalWorkspace) {
+      return {
+        workspaceRoot: preparedExternalWorkspace.workspaceRoot,
+        cleanupRoot: preparedExternalWorkspace.cleanupRoot,
+        usedTempWorkspace: false,
+      };
+    }
+
     return {
-      workspaceRoot: path.resolve(workspaceRoot),
+      workspaceRoot: resolvedWorkspaceRoot,
       usedTempWorkspace: false,
     };
   }
 
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'webstir-smoke-'));
   const tempWorkspace = path.join(tempRoot, 'full');
-  let source: string | undefined;
-
-  if (monorepoRoot) {
-    const sourceRoot = path.join(monorepoRoot, 'examples', 'demos', 'full');
-    await cp(sourceRoot, tempWorkspace, { recursive: true });
-    source = sourceRoot;
-  } else {
-    await scaffoldWorkspace('full', tempWorkspace, { force: true });
-    source = 'built-in full template';
-  }
+  await scaffoldWorkspace('full', tempWorkspace, { force: true });
+  await materializeRepoLocalWorkspaceDependencies(tempWorkspace, {
+    forceLocalPackages: true,
+  });
 
   return {
     workspaceRoot: tempWorkspace,
     cleanupRoot: tempRoot,
     usedTempWorkspace: true,
-    source,
+    source: 'built-in full template',
   };
 }
 
@@ -159,3 +187,7 @@ function formatTestDetail(result: TestCommandResult): string {
 function formatBackendInspectDetail(result: BackendInspectResult): string {
   return `${result.manifest.routes?.length ?? 0} routes, ${result.manifest.jobs?.length ?? 0} jobs`;
 }
+
+function formatDoctorDetail(result: DoctorResult): string {
+  return result.healthy ? 'healthy' : `${result.issues.length} issue(s)`;
+}