docguard-cli 0.7.3 → 0.8.2

package/cli/commands/init.mjs

@@ -1,11 +1,13 @@
 /**
  * Init Command — Initialize CDD documentation from templates
+ * Interactive setup: asks which docs the user needs + suggests hooks.
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
-import { resolve, dirname, join } from 'node:path';
+import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { c, PROFILES } from '../docguard.mjs';
+import { createInterface } from 'node:readline';
+import { c, PROFILES } from '../shared.mjs';
 
 function detectProjectType(dir) {
   const pkgPath = resolve(dir, 'package.json');
@@ -29,7 +31,21 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const TEMPLATES_DIR = resolve(__dirname, '../../templates');
 
-export function runInit(projectDir, config, flags) {
+// ── Readline helper ──────────────────────────────────────────────────────
+
+function askQuestion(prompt) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(res => {
+    rl.question(prompt, answer => {
+      rl.close();
+      res(answer);
+    });
+  });
+}
+
+// ── Init Command ─────────────────────────────────────────────────────────
+
+export async function runInit(projectDir, config, flags) {
   const profileName = flags.profile || 'standard';
   const profile = PROFILES[profileName];
 
@@ -43,29 +59,63 @@ export function runInit(projectDir, config, flags) {
   console.log(`${c.dim}   Directory: ${projectDir}${c.reset}`);
   console.log(`${c.dim}   Profile:   ${profileName} — ${profile.description}${c.reset}\n`);
 
+  // Detect project type
+  const detectedType = detectProjectType(projectDir);
+  console.log(`  ${c.dim}Auto-detected project type: ${c.cyan}${detectedType}${c.reset}\n`);
+
+  // ── Doc catalog ────────────────────────────────────────────────────────
+  const allDocs = [
+    { key: 'ARCHITECTURE', file: 'docs-canonical/ARCHITECTURE.md', template: 'ARCHITECTURE.md.template', desc: 'System architecture, tech stack, layer boundaries', defaultYes: true },
+    { key: 'DATA-MODEL', file: 'docs-canonical/DATA-MODEL.md', template: 'DATA-MODEL.md.template', desc: 'Database schemas, entities, relationships', defaultYes: ['webapp', 'api'].includes(detectedType) },
+    { key: 'SECURITY', file: 'docs-canonical/SECURITY.md', template: 'SECURITY.md.template', desc: 'Auth, secrets, security controls', defaultYes: ['webapp', 'api'].includes(detectedType) },
+    { key: 'TEST-SPEC', file: 'docs-canonical/TEST-SPEC.md', template: 'TEST-SPEC.md.template', desc: 'Test strategy, coverage requirements', defaultYes: true },
+    { key: 'ENVIRONMENT', file: 'docs-canonical/ENVIRONMENT.md', template: 'ENVIRONMENT.md.template', desc: 'Environment variables, deployment config', defaultYes: ['webapp', 'api'].includes(detectedType) },
+  ];
+
+  let selectedDocs;
+
+  if (flags.skipPrompts || flags.force) {
+    // Non-interactive — use profile defaults
+    const profileCanonical = profile.requiredFiles?.canonical || allDocs.map(d => d.file);
+    selectedDocs = allDocs.filter(d => profileCanonical.includes(d.file));
+    console.log(`  ${c.dim}Non-interactive mode — using ${profileName} profile defaults${c.reset}\n`);
+  } else {
+    // Interactive — ask about each doc
+    console.log(`  ${c.bold}Which canonical docs does your project need?${c.reset}`);
+    console.log(`  ${c.dim}(press Enter for default, type y or n)${c.reset}\n`);
+
+    selectedDocs = [];
+    for (const doc of allDocs) {
+      const defaultLabel = doc.defaultYes ? 'Y/n' : 'y/N';
+      const answer = await askQuestion(`    ${doc.key} — ${doc.desc} [${defaultLabel}]: `);
+      const trimmed = answer.trim().toLowerCase();
+
+      const include = doc.defaultYes
+        ? (trimmed === '' || trimmed === 'y' || trimmed === 'yes')
+        : (trimmed === 'y' || trimmed === 'yes');
+
+      if (include) {
+        selectedDocs.push(doc);
+      }
+    }
+    console.log('');
+  }
+
+  // ── Create selected doc files ──────────────────────────────────────────
   const created = [];
   const skipped = [];
 
-  // Map template files to their destinations
-  const allMappings = [
-    { template: 'ARCHITECTURE.md.template', dest: 'docs-canonical/ARCHITECTURE.md' },
-    { template: 'DATA-MODEL.md.template', dest: 'docs-canonical/DATA-MODEL.md' },
-    { template: 'SECURITY.md.template', dest: 'docs-canonical/SECURITY.md' },
-    { template: 'TEST-SPEC.md.template', dest: 'docs-canonical/TEST-SPEC.md' },
-    { template: 'ENVIRONMENT.md.template', dest: 'docs-canonical/ENVIRONMENT.md' },
+  // Always create tracking files
+  const alwaysCreate = [
     { template: 'AGENTS.md.template', dest: 'AGENTS.md' },
     { template: 'CHANGELOG.md.template', dest: 'CHANGELOG.md' },
     { template: 'DRIFT-LOG.md.template', dest: 'DRIFT-LOG.md' },
   ];
 
-  // Filter based on profile — starter only gets required files
-  const profileRequiredFiles = profile.requiredFiles
-    ? new Set([...profile.requiredFiles.canonical, profile.requiredFiles.changelog, profile.requiredFiles.driftLog, ...profile.requiredFiles.agentFile])
-    : null;
-
-  const fileMappings = profileRequiredFiles
-    ? allMappings.filter(m => profileRequiredFiles.has(m.dest))
-    : allMappings;
+  const fileMappings = [
+    ...selectedDocs.map(d => ({ template: d.template, dest: d.file })),
+    ...alwaysCreate,
+  ];
 
   for (const mapping of fileMappings) {
     const destPath = resolve(projectDir, mapping.dest);
@@ -77,35 +127,26 @@ export function runInit(projectDir, config, flags) {
       continue;
     }
 
-    // Ensure directory exists
     const destDir = dirname(destPath);
     if (!existsSync(destDir)) {
       mkdirSync(destDir, { recursive: true });
     }
 
-    // Read template and write
     if (existsSync(templatePath)) {
       const content = readFileSync(templatePath, 'utf-8');
-      // Replace template date placeholder with today's date
       const today = new Date().toISOString().split('T')[0];
       const processed = content.replace(/YYYY-MM-DD/g, today);
       writeFileSync(destPath, processed, 'utf-8');
       created.push(mapping.dest);
       console.log(`  ${c.green}✅${c.reset} Created: ${c.cyan}${mapping.dest}${c.reset}`);
     } else {
-      console.log(
-        `  ${c.red}❌${c.reset} Template not found: ${mapping.template}`
-      );
+      console.log(`  ${c.red}❌${c.reset} Template not found: ${mapping.template}`);
     }
   }
 
-  // Create .docguard.json if it doesn't exist — auto-detect project type
+  // ── Create .docguard.json ──────────────────────────────────────────────
   const configPath = resolve(projectDir, '.docguard.json');
   if (!existsSync(configPath)) {
-    // Detect project type from package.json
-    const detectedType = detectProjectType(projectDir);
-
-    // Get appropriate defaults for this project type
     const typeDefaults = {
       cli:     { needsEnvVars: false, needsEnvExample: false, needsE2E: false, needsDatabase: false },
       library: { needsEnvVars: false, needsEnvExample: false, needsE2E: false, needsDatabase: false },
@@ -122,6 +163,9 @@ export function runInit(projectDir, config, flags) {
       profile: profileName,
       projectType: detectedType,
       projectTypeConfig: ptc,
+      requiredFiles: {
+        canonical: selectedDocs.map(d => d.file),
+      },
       validators: profile.validators || {
         structure: true,
         docsSync: true,
@@ -137,18 +181,17 @@ export function runInit(projectDir, config, flags) {
 
     writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + '\n', 'utf-8');
     created.push('.docguard.json');
-    console.log(`  ${c.green}✅${c.reset} Created: ${c.cyan}.docguard.json${c.reset} ${c.dim}(auto-detected: ${detectedType})${c.reset}`);
+    console.log(`  ${c.green}✅${c.reset} Created: ${c.cyan}.docguard.json${c.reset} ${c.dim}(${selectedDocs.length} docs selected, type: ${detectedType})${c.reset}`);
   } else {
     skipped.push('.docguard.json');
     console.log(`  ${c.yellow}⏭️${c.reset}  .docguard.json ${c.dim}(already exists)${c.reset}`);
   }
 
-  // Install slash commands for AI agents — detect which agents are in use
+  // ── Slash commands for AI agents ───────────────────────────────────────
   const commandsSourceDir = resolve(TEMPLATES_DIR, 'commands');
   if (existsSync(commandsSourceDir)) {
     const commandFiles = readdirSync(commandsSourceDir).filter(f => f.endsWith('.md'));
 
-    // Detect which AI agent directories exist in the project
     const agentDirs = [
       { name: 'GitHub Copilot', path: '.github/commands' },
       { name: 'Cursor', path: '.cursor/rules' },
@@ -157,12 +200,10 @@ export function runInit(projectDir, config, flags) {
       { name: 'Antigravity', path: '.agents/workflows' },
     ];
 
-    // Find which agent dirs already exist in the project
     const detected = agentDirs.filter(a =>
-      existsSync(resolve(projectDir, a.path.split('/')[0])) // check parent dir exists
+      existsSync(resolve(projectDir, a.path.split('/')[0]))
     );
 
-    // If none detected, default to .github/commands (most universal)
     const targets = detected.length > 0
       ? detected
       : [{ name: 'GitHub (default)', path: '.github/commands' }];
@@ -203,47 +244,44 @@ export function runInit(projectDir, config, flags) {
     }
   }
 
-  // Summary
+  // ── Summary ────────────────────────────────────────────────────────────
   console.log(`\n${c.bold}  ─────────────────────────────────────${c.reset}`);
   console.log(`  ${c.green}Created:${c.reset} ${created.length} files`);
   if (skipped.length > 0) {
     console.log(`  ${c.yellow}Skipped:${c.reset} ${skipped.length} files (already exist)`);
   }
 
-  if (flags.skipPrompts) {
-    // Simple instructions, no AI prompts
-    console.log(`\n  ${c.bold}Next steps:${c.reset}`);
-    console.log(`  ${c.dim}Run${c.reset} ${c.cyan}docguard diagnose${c.reset} ${c.dim}to get AI prompts for filling docs.${c.reset}`);
-    console.log(`  ${c.dim}Then verify:${c.reset} ${c.cyan}docguard guard${c.reset}\n`);
-  } else {
-    // Auto-populate: output AI research prompts for each created canonical doc
-    const createdDocs = created.filter(f => f.startsWith('docs-canonical/'));
-
-    if (createdDocs.length > 0) {
-      console.log(`\n  ${c.bold}🤖 AI Auto-Populate${c.reset}`);
-      console.log(`  ${c.dim}The files above are skeleton templates. Your AI agent should fill them.${c.reset}`);
-      console.log(`  ${c.dim}Run this single command to get a full remediation plan:${c.reset}\n`);
-      console.log(`  ${c.cyan}${c.bold}docguard diagnose${c.reset}\n`);
-      console.log(`  ${c.dim}Or generate prompts for individual docs:${c.reset}`);
-
-      const docNameMap = {
-        'docs-canonical/ARCHITECTURE.md': 'architecture',
-        'docs-canonical/DATA-MODEL.md': 'data-model',
-        'docs-canonical/SECURITY.md': 'security',
-        'docs-canonical/TEST-SPEC.md': 'test-spec',
-        'docs-canonical/ENVIRONMENT.md': 'environment',
-      };
-
-      for (const doc of createdDocs) {
-        const target = docNameMap[doc];
-        if (target) {
-          console.log(`  ${c.cyan}docguard fix --doc ${target}${c.reset}`);
-        }
+  // ── Hooks suggestion ──────────────────────────────────────────────────
+  console.log(`\n  ${c.bold}💡 Automation:${c.reset}`);
+  console.log(`  ${c.dim}Auto-guard on commit:${c.reset}  ${c.cyan}docguard hooks --type pre-commit${c.reset}`);
+  console.log(`  ${c.dim}Auto-guard on push:${c.reset}   ${c.cyan}docguard hooks --type pre-push${c.reset}`);
+
+  // ── Next steps ─────────────────────────────────────────────────────────
+  const createdDocs = created.filter(f => f.startsWith('docs-canonical/'));
+
+  if (createdDocs.length > 0) {
+    console.log(`\n  ${c.bold}🤖 AI Auto-Populate${c.reset}`);
+    console.log(`  ${c.dim}The files above are skeleton templates. Your AI agent should fill them.${c.reset}`);
+    console.log(`  ${c.dim}Run this single command to get a full remediation plan:${c.reset}\n`);
+    console.log(`  ${c.cyan}${c.bold}docguard diagnose${c.reset}\n`);
+    console.log(`  ${c.dim}Or generate prompts for individual docs:${c.reset}`);
+
+    const docNameMap = {
+      'docs-canonical/ARCHITECTURE.md': 'architecture',
+      'docs-canonical/DATA-MODEL.md': 'data-model',
+      'docs-canonical/SECURITY.md': 'security',
+      'docs-canonical/TEST-SPEC.md': 'test-spec',
+      'docs-canonical/ENVIRONMENT.md': 'environment',
+    };
+
+    for (const doc of createdDocs) {
+      const target = docNameMap[doc];
+      if (target) {
+        console.log(`  ${c.cyan}docguard fix --doc ${target}${c.reset}`);
       }
-      console.log(`\n  ${c.dim}Then verify:${c.reset} ${c.cyan}docguard guard${c.reset}\n`);
-    } else {
-      console.log(`\n  ${c.dim}Run${c.reset} ${c.cyan}docguard diagnose${c.reset} ${c.dim}to check for issues.${c.reset}\n`);
     }
+    console.log(`\n  ${c.dim}Then verify:${c.reset} ${c.cyan}docguard guard${c.reset}\n`);
+  } else {
+    console.log(`\n  ${c.dim}Run${c.reset} ${c.cyan}docguard diagnose${c.reset} ${c.dim}to check for issues.${c.reset}\n`);
   }
 }
-

package/cli/commands/publish.mjs

@@ -8,7 +8,7 @@
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { resolve, basename } from 'node:path';
-import { c } from '../docguard.mjs';
+import { c } from '../shared.mjs';
 
 const SUPPORTED_PLATFORMS = ['mintlify'];
 

package/cli/commands/score.mjs

@@ -6,7 +6,7 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { resolve, join, extname } from 'node:path';
 import { execSync } from 'node:child_process';
-import { c } from '../docguard.mjs';
+import { c } from '../shared.mjs';
 
 const WEIGHTS = {
   structure: 25,     // Required files exist
@@ -23,7 +23,7 @@ export function runScore(projectDir, config, flags) {
   console.log(`${c.bold}📊 DocGuard Score — ${config.projectName}${c.reset}`);
   console.log(`${c.dim}   Directory: ${projectDir}${c.reset}\n`);
 
-  const { scores, totalScore, grade } = calcAllScores(projectDir, config);
+  const { scores, totalScore, grade, details } = calcAllScores(projectDir, config);
 
   // ── Display Results ──
   if (flags.format === 'json') {
@@ -80,7 +80,7 @@ export function runScore(projectDir, config, flags) {
   if (weakest.length > 0) {
     console.log(`  ${c.bold}Top improvements:${c.reset}`);
     for (const [cat, score] of weakest) {
-      const suggestion = getSuggestion(cat, score);
+      const suggestion = getSuggestion(cat, score, details);
       console.log(`  ${c.yellow}→ ${cat}${c.reset}: ${suggestion}`);
     }
     console.log('');
@@ -130,6 +130,11 @@ export function runScore(projectDir, config, flags) {
     console.log(`  ${c.dim}Quality labels: HIGH (≥90%), MEDIUM (50-89%), LOW (<50%)${c.reset}`);
     console.log(`  ${c.dim}Methodology: CJE multi-signal composite (Lopez et al., TRACE, IEEE TMLCN 2026)${c.reset}\n`);
   }
+
+  // Badge snippet
+  const bColor = totalScore >= 90 ? 'brightgreen' : totalScore >= 80 ? 'green' : totalScore >= 70 ? 'yellowgreen' : totalScore >= 60 ? 'yellow' : totalScore >= 50 ? 'orange' : 'red';
+  const badgeUrl = `https://img.shields.io/badge/CDD_Score-${totalScore}%2F100_(${grade})-${bColor}`;
+  console.log(`  ${c.dim}📎 Badge: ![CDD Score](${badgeUrl})${c.reset}\n`);
 }
 
 /**
@@ -143,8 +148,12 @@ export function runScoreInternal(projectDir, config) {
 
 function calcAllScores(projectDir, config) {
   const scores = {};
+  const details = {}; // Per-category failure details for actionable suggestions
+
   scores.structure = calcStructureScore(projectDir, config);
-  scores.docQuality = calcDocQualityScore(projectDir, config);
+  const dqResult = calcDocQualityScore(projectDir, config);
+  scores.docQuality = dqResult.score;
+  details.docQuality = dqResult.failures;
   scores.testing = calcTestingScore(projectDir, config);
   scores.security = calcSecurityScore(projectDir, config);
   scores.environment = calcEnvironmentScore(projectDir, config);
@@ -158,7 +167,7 @@ function calcAllScores(projectDir, config) {
   }
   totalScore = Math.round(totalScore);
 
-  return { scores, totalScore, grade: getGrade(totalScore) };
+  return { scores, totalScore, grade: getGrade(totalScore), details };
 }
 
 // ── Scoring Functions ──────────────────────────────────────────────────────
@@ -196,32 +205,42 @@ function calcDocQualityScore(dir, config) {
 
   let found = 0;
   let total = 0;
+  const failures = []; // Track specific failures for actionable suggestions
 
   for (const [file, sections] of Object.entries(checks)) {
     const fullPath = resolve(dir, file);
-    if (!existsSync(fullPath)) continue;
+    if (!existsSync(fullPath)) {
+      failures.push({ file, issue: 'file missing' });
+      continue;
+    }
 
     const content = readFileSync(fullPath, 'utf-8');
+    const docName = file.replace('docs-canonical/', '').replace('.md', '').toLowerCase();
 
     for (const section of sections) {
       total++;
-      if (content.includes(section)) found++;
+      if (content.includes(section)) {
+        found++;
+      } else {
+        failures.push({ file, issue: `missing section: ${section}`, fixCmd: `docguard fix --doc ${docName}` });
+      }
     }
 
-    // Bonus: check if doc has docguard metadata
-    total++;
-    if (content.includes('docguard:version')) found++;
-
-    // Bonus: check if doc has more than just template placeholders
+    // Check if doc has more than just template placeholders
     total++;
     const lines = content.split('\n').filter(l => l.trim() && !l.startsWith('#') && !l.startsWith('|') && !l.startsWith('>') && !l.startsWith('<!--'));
-    if (lines.length > 5) found++;
+    if (lines.length > 5) {
+      found++;
+    } else {
+      failures.push({ file, issue: `thin content (${lines.length} lines — need >5)`, fixCmd: `docguard fix --doc ${docName}` });
+    }
   }
 
-  return total === 0 ? 0 : Math.round((found / total) * 100);
+  const score = total === 0 ? 0 : Math.round((found / total) * 100);
+  return { score, failures };
 }
 
-function calcTestingScore(dir) {
+function calcTestingScore(dir, config) {
   let score = 0;
 
   // Check test directory exists
@@ -232,10 +251,28 @@ function calcTestingScore(dir) {
   // Check test spec exists
   if (existsSync(resolve(dir, 'docs-canonical/TEST-SPEC.md'))) score += 30;
 
-  // Check for test config files
+  // Check for test config files OR built-in test runner
   const testConfigs = ['jest.config.js', 'jest.config.ts', 'vitest.config.ts', 'vitest.config.js', 'pytest.ini', 'setup.cfg', '.mocharc.yml'];
   const hasTestConfig = testConfigs.some(f => existsSync(resolve(dir, f)));
-  if (hasTestConfig) score += 15;
+
+  if (hasTestConfig) {
+    score += 15;
+  } else {
+    // Check if using node:test (no config needed) — look in package.json scripts
+    const ptc = config.projectTypeConfig || {};
+    const pkgPath = resolve(dir, 'package.json');
+    if (ptc.testFramework === 'node:test') {
+      score += 15; // Config says node:test — no config file needed
+    } else if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        const testScript = pkg.scripts?.test || '';
+        if (testScript.includes('node --test') || testScript.includes('node:test')) {
+          score += 15; // Using built-in test runner
+        }
+      } catch { /* skip */ }
+    }
+  }
 
   // Check for CI test step
   const ciFiles = ['.github/workflows/ci.yml', '.github/workflows/test.yml'];
@@ -245,8 +282,9 @@ function calcTestingScore(dir) {
   return Math.min(100, score);
 }
 
-function calcSecurityScore(dir) {
+function calcSecurityScore(dir, config) {
   let score = 0;
+  const ptc = config.projectTypeConfig || {};
 
   // SECURITY.md exists
   if (existsSync(resolve(dir, 'docs-canonical/SECURITY.md'))) score += 30;
@@ -262,17 +300,28 @@ function calcSecurityScore(dir) {
   // No .env file committed (check if .env exists but .gitignore covers it)
   if (!existsSync(resolve(dir, '.env')) || existsSync(gitignorePath)) score += 15;
 
-  // .env.example exists (safe template)
-  if (existsSync(resolve(dir, '.env.example'))) score += 15;
+  // .env.example exists (safe template) — only check if project needs env vars
+  if (ptc.needsEnvExample === false) {
+    score += 15; // Full marks — project doesn't need env vars
+  } else if (existsSync(resolve(dir, '.env.example'))) {
+    score += 15;
+  }
 
   return Math.min(100, score);
 }
 
-function calcEnvironmentScore(dir) {
+function calcEnvironmentScore(dir, config) {
   let score = 0;
+  const ptc = config.projectTypeConfig || {};
 
   if (existsSync(resolve(dir, 'docs-canonical/ENVIRONMENT.md'))) score += 40;
-  if (existsSync(resolve(dir, '.env.example'))) score += 30;
+
+  // .env.example — only check if project needs env vars
+  if (ptc.needsEnvExample === false) {
+    score += 30; // Full marks — project doesn't need env vars
+  } else if (existsSync(resolve(dir, '.env.example'))) {
+    score += 30;
+  }
 
   // Check for setup documentation
   const readmePath = resolve(dir, 'README.md');
@@ -352,16 +401,31 @@ function getGrade(score) {
   return 'F';
 }
 
-function getSuggestion(category, score) {
+function getSuggestion(category, score, details) {
+  // Dynamic, specific suggestions based on actual failures
+  if (category === 'docQuality' && details?.docQuality?.length > 0) {
+    const failures = details.docQuality;
+    // Group by doc
+    const byDoc = {};
+    for (const f of failures) {
+      const doc = f.file.replace('docs-canonical/', '');
+      if (!byDoc[doc]) byDoc[doc] = [];
+      byDoc[doc].push(f.issue);
+    }
+    const parts = Object.entries(byDoc).map(([doc, issues]) => `${doc}: ${issues.join(', ')}`);
+    const fixCmd = failures.find(f => f.fixCmd)?.fixCmd || 'docguard fix';
+    return `${parts.join(' | ')} → Run \`${fixCmd}\``;
+  }
+
   const suggestions = {
     structure: 'Run `docguard init` to create missing documentation',
-    docQuality: 'Fill in template sections — replace placeholders with real content',
+    docQuality: 'Run `docguard fix` to get AI prompts for each doc that needs content',
     testing: 'Add tests/ directory and configure TEST-SPEC.md',
-    security: 'Create SECURITY.md and add .env to .gitignore',
-    environment: 'Document env variables and create .env.example',
+    security: 'Create SECURITY.md and add .env to .gitignore → Run `docguard fix --doc security`',
+    environment: 'Document env variables and create .env.example → Run `docguard fix --doc environment`',
     drift: 'Create DRIFT-LOG.md and log any code deviations',
     changelog: 'Maintain CHANGELOG.md with [Unreleased] section',
-    architecture: 'Add layer boundaries and Mermaid diagrams to ARCHITECTURE.md',
+    architecture: 'Add layer boundaries and Mermaid diagrams → Run `docguard fix --doc architecture`',
   };
   return suggestions[category] || 'Review and improve this area';
 }

package/cli/commands/trace.mjs

@@ -8,7 +8,7 @@
 
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { resolve, join, extname, basename, relative } from 'node:path';
-import { c } from '../docguard.mjs';
+import { c } from '../shared.mjs';
 
 const IGNORE_DIRS = new Set([
   'node_modules', '.git', '.next', 'dist', 'build', 'coverage',

package/cli/commands/watch.mjs

@@ -9,7 +9,7 @@
 
 import { watch as fsWatch, existsSync, readdirSync, statSync } from 'node:fs';
 import { resolve, relative, extname } from 'node:path';
-import { c } from '../docguard.mjs';
+import { c } from '../shared.mjs';
 import { runGuardInternal } from './guard.mjs';
 
 const DEBOUNCE_MS = 500;