@antomanc/aginit 0.4.0 → 0.5.0

package/src/adapters/tool-ignores.ts

@@ -0,0 +1,158 @@
+import path from 'node:path';
+import { fileExists, readTextFile, safeWriteFile } from '../utils/fs.js';
+import { readPackageManifest } from '../config/validation.js';
+
+// Vendored skill sources ship third-party JS and Markdown that the project's own
+// linters and formatters must not check. No ignore convention is shared across tools,
+// so each tool below says where its ignores live and how to add to them.
+const VENDORED_DIRS = ['.agents', '.claude'];
+
+interface Project {
+  manifest: Record<string, any> | null;
+  has(dependency: string): boolean;
+  exists(file: string): boolean;
+}
+
+interface ToolIgnore {
+  /** The file holding this tool's ignores, when the project uses the tool. */
+  file(project: Project): string | undefined;
+  /** Vendored directories the file does not ignore yet. */
+  missing(text: string): string[];
+  /** The file with those directories ignored, or null when it cannot be edited safely. */
+  patch(text: string, dirs: string[]): string | null;
+  advice(file: string, dirs: string[]): string;
+}
+
+const configs = (base: string, extensions: string[]) => extensions.map((ext) => `${base}${ext}`);
+
+/** Gitignore-syntax files: append the directories. */
+function ignoreFile(name: string, used: (project: Project) => boolean): ToolIgnore {
+  return {
+    file: (project) => (used(project) ? name : undefined),
+    missing: (text) => {
+      const lines = text.split(/\r?\n/).map((line) => line.trim().replace(/^\/|\/(\*\*)?$/g, ''));
+      return VENDORED_DIRS.filter((dir) => !lines.includes(dir));
+    },
+    patch: (text, dirs) => {
+      const block = `# Vendored agent skills (aginit)\n${dirs.map((dir) => `${dir}/`).join('\n')}\n`;
+      return text.trim() ? `${text.trimEnd()}\n\n${block}` : block;
+    },
+    advice: (file, dirs) => `add ${dirs.map((dir) => `${dir}/`).join(' and ')} to ${file}`
+  };
+}
+
+const prettier = ignoreFile(
+  '.prettierignore',
+  (project) =>
+    project.has('prettier') ||
+    Boolean(project.manifest?.prettier) ||
+    [
+      ...configs('.prettierrc', ['', '.json', '.json5', '.yaml', '.yml', '.toml']),
+      ...configs('.prettierrc', ['.js', '.cjs', '.mjs', '.ts', '.cts', '.mts']),
+      ...configs('prettier.config', ['.js', '.cjs', '.mjs', '.ts', '.cts', '.mts'])
+    ].some(project.exists)
+);
+
+// Legacy ESLint and oxlint read .eslintignore; flat-config ESLint does not.
+const eslintIgnore = ignoreFile(
+  '.eslintignore',
+  (project) =>
+    project.has('oxlint') ||
+    Boolean(project.manifest?.eslintConfig) ||
+    configs('.eslintrc', ['', '.js', '.cjs', '.json', '.yaml', '.yml']).some(project.exists)
+);
+
+/** Flat ESLint config: extend a global ignores array if there is an unambiguous one,
+ * `globalIgnores([...])` or an object holding only `ignores`. */
+const eslintFlat: ToolIgnore = {
+  file: (project) =>
+    configs('eslint.config', ['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts']).find(project.exists),
+  missing: (text) => VENDORED_DIRS.filter((dir) => !text.includes(`${dir}/`)),
+  patch: (text, dirs) => {
+    const match =
+      /globalIgnores\(\s*\[/.exec(text) ??
+      /\{\s*ignores\s*:\s*\[(?=[^[\]]*\]\s*,?\s*\})/.exec(text);
+    if (!match) return null;
+    const at = match.index + match[0].length;
+    const rest = text.slice(at);
+    const quote =
+      /^\s*(['"`])/.exec(rest)?.[1] ??
+      ((text.match(/"/g)?.length ?? 0) > (text.match(/'/g)?.length ?? 0) ? '"' : "'");
+    const entries = dirs.map((dir) => `${quote}${dir}/**${quote}`);
+    const indent = /^(\s*\n[ \t]*)/.exec(rest)?.[1];
+    const insertion = indent
+      ? entries.map((entry) => `${indent}${entry},`).join('')
+      : entries.join(', ') + (/^\s*\]/.test(rest) ? '' : ', ');
+    return text.slice(0, at) + insertion + rest;
+  },
+  advice: (file, dirs) =>
+    `add { ignores: [${dirs.map((dir) => `'${dir}/**'`).join(', ')}] } to the exported array in ${file}`
+};
+
+/** Biome 2.2+: force-ignore the folders through files.includes. */
+const biome: ToolIgnore = {
+  file: (project) => ['biome.json', 'biome.jsonc'].find(project.exists),
+  missing: (text) => VENDORED_DIRS.filter((dir) => !text.includes(`**/${dir}`)),
+  patch: (text, dirs) => {
+    let config: Record<string, any>;
+    try {
+      config = JSON.parse(text); // a biome.jsonc with comments gets advice instead
+    } catch {
+      return null;
+    }
+    const includes = config.files?.includes ?? ['**'];
+    if (!Array.isArray(includes)) return null;
+    config.files = {
+      ...config.files,
+      includes: [...includes, ...dirs.map((dir) => `!!**/${dir}`)]
+    };
+    const json = JSON.stringify(config, null, /\n([ \t]+)"/.exec(text)?.[1] ?? 2) + '\n';
+    // Like Biome's formatter, keep the array on one line when it fits in 80 columns.
+    return json.replace(/^([ \t]*"includes": )\[[^\]]*\]/m, (block, key: string) => {
+      const inline = `${key}[${config.files.includes.map((p: string) => JSON.stringify(p)).join(', ')}]`;
+      return inline.replace(/\t/g, '  ').length <= 80 ? inline : block;
+    });
+  },
+  advice: (file, dirs) =>
+    `add ${dirs.map((dir) => `"!!**/${dir}"`).join(', ')} to files.includes in ${file}`
+};
+
+const TOOLS = [prettier, eslintIgnore, eslintFlat, biome];
+
+function pendingIgnores(targetDir: string) {
+  const manifest = readPackageManifest(targetDir);
+  const project: Project = {
+    manifest,
+    has: (name) => Boolean(manifest?.dependencies?.[name] || manifest?.devDependencies?.[name]),
+    exists: (file) => fileExists(path.join(targetDir, file))
+  };
+  return TOOLS.flatMap((tool) => {
+    const file = tool.file(project);
+    if (!file) return [];
+    const text = readTextFile(path.join(targetDir, file)) ?? '';
+    const missing = tool.missing(text);
+    return missing.length > 0 ? [{ tool, file, text, missing }] : [];
+  });
+}
+
+/** Keeps the project's linters and formatters off vendored skills. Returns the
+ * advice for configs that could not be edited safely. */
+export function ignoreVendoredSkills(
+  targetDir: string,
+  options: { dryRun?: boolean; silent?: boolean } = {}
+): string[] {
+  const { dryRun = false, silent = false } = options;
+  const advice: string[] = [];
+  for (const { tool, file, text, missing } of pendingIgnores(targetDir)) {
+    const patched = tool.patch(text, missing);
+    if (patched === null)
+      advice.push(`Linters check vendored skills: ${tool.advice(file, missing)}`);
+    else safeWriteFile(path.join(targetDir, file), patched, { overwrite: true, dryRun, silent });
+  }
+  return advice;
+}
+
+/** Doctor view: every config that still lets a linter or formatter see vendored skills. */
+export function vendoredSkillsExposure(targetDir: string): string[] {
+  return pendingIgnores(targetDir).map(({ tool, file, missing }) => tool.advice(file, missing));
+}

package/src/cli/capabilities.ts

@@ -0,0 +1,176 @@
+import path from 'node:path';
+import pc from 'picocolors';
+import { AGINIT_CONFIG_FILENAME, AginitConfig } from '../config/schema.js';
+import { readProjectConfig, validateConfig } from '../config/validation.js';
+import { resolvePlatformStack } from '../adapters/agent-docs.js';
+import { installAllSkills, removeSkills, skillAgents } from '../adapters/skills.js';
+import { uninstallGraft } from '../adapters/graft.js';
+import { ignoreVendoredSkills } from '../adapters/tool-ignores.js';
+import {
+  activeIds,
+  applyResolvedProfile,
+  CapabilityCategory,
+  CapabilityDescriptor,
+  catalogFor,
+  findCapability,
+  inferCapabilities,
+  ProfileFlags,
+  resolveCapabilities,
+  sourcesFor
+} from '../registry/index.js';
+import { SETUPS } from '../registry/setup.js';
+import { writeJsonFile } from '../utils/fs.js';
+import { logger } from '../utils/logger.js';
+import { missingBinaries, syncAgentDocs } from './new.js';
+
+const CATEGORY_ORDER: CapabilityCategory[] = [
+  'codebase-graph',
+  'methodology',
+  'discipline',
+  'design',
+  'ui-driver',
+  'testing-engine',
+  'context-guard',
+  'custom'
+];
+
+/** Print the registry grouped by category, marking what the project has enabled. */
+export function listCapabilities(targetDir: string = process.cwd()): void {
+  const config = readProjectConfig(targetDir);
+  const enabled = config ? activeIds(config) : new Set<string>();
+  logger.banner(
+    'Aginit — Capability registry',
+    config ? `Enabled in ${AGINIT_CONFIG_FILENAME}: ●` : `No ${AGINIT_CONFIG_FILENAME} here; showing the catalog`
+  );
+  const catalog = catalogFor(config);
+  for (const category of CATEGORY_ORDER) {
+    const entries = catalog.filter((c) => c.category === category);
+    if (entries.length === 0) continue;
+    console.log(pc.bold(pc.underline(category)));
+    for (const c of entries) {
+      const mark = enabled.has(c.id) ? pc.green('●') : pc.dim('○');
+      const platforms = c.supportedPlatforms.join(', ');
+      console.log(`  ${mark} ${pc.bold(c.id.padEnd(22))} ${c.description}`);
+      console.log(pc.dim(`      ${platforms} · ${c.license} · ${c.repoUrl}`));
+    }
+    console.log();
+  }
+}
+
+export interface ChangeOptions {
+  dryRun?: boolean;
+  silent?: boolean;
+}
+
+function requireConfig(targetDir: string): AginitConfig {
+  const config = readProjectConfig(targetDir);
+  if (!config)
+    throw new Error(`No ${AGINIT_CONFIG_FILENAME} in ${targetDir}. Run \`aginit init\` first.`);
+  return config;
+}
+
+/** Skill names to remove; a source installed whole is removed by its repo. */
+const skillsOf = (capabilities: CapabilityDescriptor[]) =>
+  capabilities.flatMap((c) =>
+    c.install.flatMap((s) => (s.kind !== 'skills-sh' ? [] : s.skills.length ? s.skills : [s.repo]))
+  );
+
+/**
+ * Enable or disable capabilities, then bring the project in line: config,
+ * skills (installed or removed through the Skills CLI), upstream setups,
+ * AGENTS.md and docs/agents/. Picking a methodology, design or UI driver
+ * replaces the current one in that category.
+ */
+export async function changeCapabilities(
+  targetDir: string,
+  change: { add?: string[]; remove?: string[] },
+  options: ChangeOptions = {}
+): Promise<boolean> {
+  const { dryRun = false, silent = false } = options;
+  const config = requireConfig(targetDir);
+  const { platform, stack } = resolvePlatformStack(config, targetDir);
+  const base = config.capabilities ?? inferCapabilities(config);
+  const previous = [...base, ...(config.customCapabilities ?? []).map((c) => c.id)];
+  const before = activeIds(config);
+
+  const flags: ProfileFlags = { addons: [], addSkills: [], without: [] };
+  for (const id of change.add ?? []) {
+    const capability = findCapability(id, config);
+    if (!capability) {
+      if (id.includes('/')) flags.addSkills!.push(id);
+      else throw new Error(`Unknown capability "${id}". Run \`aginit list\` to see the registry.`);
+    } else if (capability.category === 'methodology') flags.methodology = id;
+    else if (capability.category === 'design') flags.design = id;
+    else if (capability.category === 'ui-driver' && !capability.addon) flags.uiDriver = id;
+    else flags.addons!.push(id);
+  }
+  for (const id of change.remove ?? []) {
+    if (!findCapability(id, config))
+      throw new Error(`Unknown capability "${id}". Run \`aginit list\` to see the registry.`);
+    flags.without!.push(id);
+  }
+  const custom = config.customCapabilities ?? [];
+  const customIds = new Set(custom.map((c) => c.id));
+  const disabled = (config.disabledCapabilities ?? []).filter((id) => !(change.add ?? []).includes(id));
+  const resolved = resolveCapabilities(
+    { platform, stack, framework: config.framework, base, basePlatform: platform, flags, custom },
+    disabled
+  );
+  // A removed custom capability is gone, not disabled.
+  resolved.disabledCapabilities = resolved.disabledCapabilities.filter((id) => !customIds.has(id));
+  const next = validateConfig(
+    applyResolvedProfile({ ...config, platform, stack }, resolved, { skills: true, previous })
+  );
+  // Adding graft or playwright turns their legacy switch back on.
+  if (next.capabilities?.includes('graft')) next.codebase.graft = true;
+
+  const after = activeIds(next);
+  const nextCatalog = catalogFor(next);
+  const added = nextCatalog.filter((c) => after.has(c.id) && !before.has(c.id));
+  const removed = catalogFor(config).filter((c) => before.has(c.id) && !after.has(c.id));
+  if (added.length === 0 && removed.length === 0 && JSON.stringify(next) === JSON.stringify(config)) {
+    if (!silent) logger.info('Nothing to change.');
+    return true;
+  }
+  if (!silent) {
+    for (const c of added) logger.success(`Enabling ${c.id}`);
+    for (const c of removed) logger.warn(`Disabling ${c.id}`);
+  }
+
+  writeJsonFile(path.join(targetDir, AGINIT_CONFIG_FILENAME), next, { overwrite: true, dryRun, silent });
+  let ok = true;
+
+  ok = (await removeSkills(targetDir, skillsOf(removed), { dryRun, silent })) && ok;
+  if (removed.some((c) => c.id === 'graft')) await uninstallGraft(targetDir, { dryRun, silent });
+  const leftovers = removed.filter((c) =>
+    c.install.some((s) => s.kind === 'setup' && s.setup !== 'graft')
+  );
+  if (!silent)
+    for (const c of leftovers)
+      logger.dim(`${c.id}: files and global CLIs its setup created are left in place; remove them by hand.`);
+
+  const addedSources = sourcesFor(added);
+  if (addedSources.length > 0) {
+    const { failed } = await installAllSkills(targetDir, addedSources, {
+      agents: skillAgents(next),
+      dryRun,
+      silent
+    });
+    ok = failed.length === 0 && ok;
+    for (const line of ignoreVendoredSkills(targetDir, { dryRun, silent: true })) logger.warn(line);
+  }
+  for (const c of added)
+    for (const step of c.install)
+      if (step.kind === 'setup')
+        ok = (await SETUPS[step.setup]({ targetDir, config: next, platform, stack, dryRun, silent })) && ok;
+
+  syncAgentDocs(targetDir, next, { dryRun, silent });
+  if (!silent)
+    for (const { name, bin, install } of await missingBinaries(added, ['graft', 'agent-browser', 'e2e']))
+      logger.warn(`${name} needs the \`${bin}\` CLI: ${install}`);
+  if (!silent) {
+    if (ok) logger.success('Capabilities updated. AGENTS.md and docs/agents/ are in sync.');
+    else logger.warn('Capabilities updated with warnings. Resolve them and rerun `aginit init`.');
+  }
+  return ok;
+}

package/src/cli/doctor.ts

@@ -17,17 +17,67 @@ import {
 } from '../adapters/skills.js';
 import { claudeMarkdownImportsAgents } from '../adapters/agents-md.js';
 import {
-  agentBrowserConfigured,
   agentBrowserStubInstalled,
   findUsernsRestriction,
   runAgentBrowserDiagnostics
 } from '../adapters/agent-browser.js';
 import { readProjectConfig } from '../config/validation.js';
+import { vendoredSkillsExposure } from '../adapters/tool-ignores.js';
 import { logger } from '../utils/logger.js';
+import { activeCapabilities, activeIds, doctorChecks, isNodeStack } from '../registry/index.js';
+import { resolvePlatformStack } from '../adapters/agent-docs.js';
+
+/**
+ * One row per active capability, built from its registry entry: every skill
+ * file it installs, every CLI it drives and any artifact it declares.
+ */
+export async function capabilityChecks(
+  targetDir: string,
+  config: AginitConfig
+): Promise<CheckItem[]> {
+  const items: CheckItem[] = [];
+  for (const capability of activeCapabilities(config)) {
+    const problems: string[] = [];
+    const fixes: string[] = [];
+    const missingSkills: string[] = [];
+    const versions: string[] = [];
+    for (const check of doctorChecks(capability, config.skills.sources)) {
+      if (check.kind === 'file') {
+        if (fileExists(path.join(targetDir, check.path))) continue;
+        const skill = /^\.agents\/skills\/([^/]+)\/SKILL\.md$/.exec(check.path)?.[1];
+        if (skill) missingSkills.push(skill);
+        else {
+          problems.push(`${check.path} missing`);
+          fixes.push(check.fix);
+        }
+      } else if (!(await commandExists(check.bin))) {
+        problems.push(`${check.bin} CLI not found in PATH`);
+        fixes.push(check.fix);
+      } else {
+        const res = await runExecutable(check.bin, check.args, { silent: true, timeout: 30_000 });
+        versions.push(res.ok && res.stdout ? `${check.bin} ${res.stdout.split('\n')[0]}` : check.bin);
+      }
+    }
+    if (missingSkills.length) {
+      problems.unshift(`skills missing from .agents/skills/: ${missingSkills.join(', ')}`);
+      fixes.unshift('Run `aginit init` to reinstall the configured skills');
+    }
+    items.push({
+      name: `${capability.name} (${capability.category})`,
+      category: 'Capabilities',
+      ok: problems.length === 0,
+      detail: problems.length ? problems.join('; ') : `Ready${versions.length ? ` (${versions.join(', ')})` : ''}`,
+      suggestion: fixes.length ? fixes.join(' · ') : undefined
+    });
+  }
+  return items;
+}
+
+type CheckCategory = 'Environment' | 'AI Tooling' | 'Project Config' | 'Capabilities';
 
 interface CheckItem {
   name: string;
-  category: 'Environment' | 'AI Tooling' | 'Project Config';
+  category: CheckCategory;
   ok: boolean;
   version?: string;
   detail: string;
@@ -87,9 +137,14 @@ export async function runDoctor(targetDir: string = process.cwd()): Promise<void
     suggestion: nodeSuggestion
   });
 
-  // 2. Active Package Manager check (pnpm, npm, yarn, or bun)
-  const pmRes = await runExecutable(activePm, ['-v'], { silent: true });
-  checks.push({
+  // 2. Active Package Manager check (pnpm, npm, yarn, or bun); none for non-Node stacks
+  const { stack, platform } = projectConfig
+    ? resolvePlatformStack(projectConfig, targetDir)
+    : { stack: 'node' as const, platform: null };
+  const pmRes = isNodeStack(stack)
+    ? await runExecutable(activePm, ['-v'], { silent: true })
+    : null;
+  if (pmRes) checks.push({
     name: `${activePm} package manager`,
     category: 'Environment',
     ok: pmRes.ok,
@@ -132,22 +187,6 @@ export async function runDoctor(targetDir: string = process.cwd()): Promise<void
         : undefined
   });
 
-  // 4. Graft CLI check
-  const graftExists = await commandExists('graft');
-  let graftVersion = '';
-  if (graftExists) {
-    const gv = await runExecutable('graft', ['--version'], { silent: true });
-    graftVersion = gv.stdout;
-  }
-  checks.push({
-    name: 'Graft codebase graph CLI',
-    category: 'AI Tooling',
-    ok: graftExists,
-    version: graftVersion,
-    detail: graftExists ? `Installed globally (${graftVersion})` : 'Graft CLI not found in PATH',
-    suggestion: graftExists ? undefined : 'Install Graft: `npm install -g @nanonets/graft`'
-  });
-
   // 5. Codex CLI check
   const codexExists = await commandExists('codex');
   checks.push({
@@ -175,7 +214,7 @@ export async function runDoctor(targetDir: string = process.cwd()): Promise<void
     category: 'Project Config',
     ok: !!projectConfig,
     detail: projectConfig
-      ? `Preset: "${projectConfig.preset}" (v${projectConfig.schemaVersion || '1.0.0'}), pm: ${activePm}, agents: ${projectConfig.agents.primary}/${projectConfig.agents.secondary}${claudeCodeEnabled(projectConfig) ? '/claude-code' : ''}`
+      ? `Preset: "${projectConfig.preset}" (v${projectConfig.schemaVersion || '1.0.0'}), platform: ${platform} (${stack})${pmRes ? `, pm: ${activePm}` : ''}, agents: ${projectConfig.agents.primary}/${projectConfig.agents.secondary}${claudeCodeEnabled(projectConfig) ? '/claude-code' : ''}`
       : configError
         ? `Invalid configuration: ${configError}`
         : 'No aginit.config.json found in current directory',
@@ -226,6 +265,22 @@ export async function runDoctor(targetDir: string = process.cwd()): Promise<void
         : 'Run `aginit init` or `npx skills add ...` to install skills'
   });
 
+  // 9a. Vendored skills must stay out of the project's linters and formatters
+  if (installedSkills.length > 0) {
+    const exposure = vendoredSkillsExposure(targetDir);
+    checks.push({
+      name: 'Lint/format ignores for vendored skills',
+      category: 'Project Config',
+      ok: exposure.length === 0,
+      detail:
+        exposure.length === 0
+          ? 'Detected linters and formatters skip .agents/ and .claude/'
+          : 'Project linters or formatters will check vendored skill files',
+      suggestion:
+        exposure.length === 0 ? undefined : `Run \`aginit update\`, or ${exposure.join('; ')}`
+    });
+  }
+
   // 9b. Claude Code: skills linked into .claude/skills/ and AGENTS.md reachable
   if (projectConfig !== null && claudeCodeEnabled(projectConfig)) {
     if (!skillsDisabled && installedSkills.length > 0) {
@@ -273,47 +328,29 @@ export async function runDoctor(targetDir: string = process.cwd()): Promise<void
     });
   }
 
+  // 10. Registry: each active capability's checks (skill files, CLIs, artifacts)
+  if (projectConfig !== null) checks.push(...(await capabilityChecks(targetDir, projectConfig)));
+
   // 10. agent-browser runtime (only when the project ships the skill)
   const agentBrowserWanted =
     projectConfig !== null &&
-    (agentBrowserConfigured(projectConfig.skills.sources) || agentBrowserStubInstalled(targetDir));
-  if (agentBrowserWanted) {
-    const abExists = await commandExists('agent-browser');
-    let abVersion = '';
-    if (abExists) {
-      const av = await runExecutable('agent-browser', ['--version'], { silent: true });
-      abVersion = av.ok ? av.stdout : '';
-    }
-    checks.push({
-      name: 'agent-browser CLI',
-      category: 'AI Tooling',
-      ok: abExists,
-      version: abVersion,
-      detail: abExists
-        ? `Installed globally (${abVersion || 'version unknown'})`
-        : 'agent-browser skill is installed but the CLI is not in PATH',
-      suggestion: abExists
-        ? undefined
-        : 'Install the runtime: `npm i -g agent-browser && agent-browser install`'
-    });
-
-    if (abExists) {
-      const diagnostics = await runAgentBrowserDiagnostics();
-      if (diagnostics !== null) {
-        checks.push({
-          name: 'agent-browser browser runtime',
-          category: 'AI Tooling',
-          ok: diagnostics.length === 0,
-          detail:
-            diagnostics.length === 0
-              ? 'Upstream doctor reports browser and launch environment healthy'
-              : diagnostics.map((d) => d.message).join('; '),
-          suggestion:
-            diagnostics.length === 0
-              ? undefined
-              : (diagnostics.find((d) => d.fix)?.fix ?? 'Run `agent-browser doctor` for details')
-        });
-      }
+    (activeIds(projectConfig).has('agent-browser') || agentBrowserStubInstalled(targetDir));
+  if (agentBrowserWanted && (await commandExists('agent-browser'))) {
+    const diagnostics = await runAgentBrowserDiagnostics();
+    if (diagnostics !== null) {
+      checks.push({
+        name: 'agent-browser browser runtime',
+        category: 'AI Tooling',
+        ok: diagnostics.length === 0,
+        detail:
+          diagnostics.length === 0
+            ? 'Upstream doctor reports browser and launch environment healthy'
+            : diagnostics.map((d) => d.message).join('; '),
+        suggestion:
+          diagnostics.length === 0
+            ? undefined
+            : (diagnostics.find((d) => d.fix)?.fix ?? 'Run `agent-browser doctor` for details')
+      });
     }
   }
 
@@ -341,15 +378,12 @@ export async function runDoctor(targetDir: string = process.cwd()): Promise<void
   }
 
   // Print grouped results
-  const categories: Array<'Environment' | 'AI Tooling' | 'Project Config'> = [
-    'Environment',
-    'AI Tooling',
-    'Project Config'
-  ];
+  const categories: CheckCategory[] = ['Environment', 'AI Tooling', 'Project Config', 'Capabilities'];
 
   for (const cat of categories) {
-    console.log(pc.bold(pc.underline(cat)));
     const catChecks = checks.filter((c) => c.category === cat);
+    if (catChecks.length === 0) continue;
+    console.log(pc.bold(pc.underline(cat)));
     for (const c of catChecks) {
       const icon = c.ok ? pc.green('✓') : pc.yellow('⚠');
       const name = pc.bold(c.name);

package/src/cli/init.ts

@@ -24,7 +24,7 @@ export async function initCurrentDirectory(options: NewProjectOptions = {}): Pro
   else projectName = sanitizeProjectName(projectName);
 
   const packageManager =
-    options.packageManager ?? saved?.packageManager ?? detectPackageManager(currentDir) ?? 'pnpm';
+    options.packageManager ?? saved?.packageManager ?? detectPackageManager(currentDir) ?? undefined;
 
   return createProject(projectName, {
     ...options,