@aiready/cli 0.9.40 → 0.9.43

package/src/commands/testability.ts

@@ -8,9 +8,10 @@ import type { ToolScoringOutput } from '@aiready/core';
 
 export async function testabilityAction(
   directory: string,
-  options: any,
+  options: any
 ): Promise<ToolScoringOutput | undefined> {
-  const { analyzeTestability, calculateTestabilityScore } = await import('@aiready/testability');
+  const { analyzeTestability, calculateTestabilityScore } =
+    await import('@aiready/testability');
 
   const config = await loadConfig(directory);
   const merged = mergeConfigWithDefaults(config, {
@@ -31,13 +32,13 @@ export async function testabilityAction(
   }
 
   const safetyIcons: Record<string, string> = {
-    'safe': '✅',
+    safe: '✅',
     'moderate-risk': '⚠️ ',
     'high-risk': '🔴',
     'blind-risk': '💀',
   };
-  const safetyColors: Record<string, Function> = {
-    'safe': chalk.green,
+  const safetyColors: Record<string, (s: string) => string> = {
+    safe: chalk.green,
     'moderate-risk': chalk.yellow,
     'high-risk': chalk.red,
     'blind-risk': chalk.bgRed.white,
@@ -47,13 +48,25 @@ export async function testabilityAction(
   const icon = safetyIcons[safety] ?? '❓';
   const color = safetyColors[safety] ?? chalk.white;
 
-  console.log(`  🧪 Testability:         ${chalk.bold(scoring.score + '/100')} (${report.summary.rating})`);
-  console.log(`     AI Change Safety:  ${color(`${icon} ${safety.toUpperCase()}`)}`);
-  console.log(chalk.dim(`     Coverage: ${Math.round(report.summary.coverageRatio * 100)}%  (${report.rawData.testFiles} test / ${report.rawData.sourceFiles} source files)`));
+  console.log(
+    `  🧪 Testability:         ${chalk.bold(scoring.score + '/100')} (${report.summary.rating})`
+  );
+  console.log(
+    `     AI Change Safety:  ${color(`${icon} ${safety.toUpperCase()}`)}`
+  );
+  console.log(
+    chalk.dim(
+      `     Coverage: ${Math.round(report.summary.coverageRatio * 100)}%  (${report.rawData.testFiles} test / ${report.rawData.sourceFiles} source files)`
+    )
+  );
 
   // Critical blind-risk banner in the unified output
   if (safety === 'blind-risk') {
-    console.log(chalk.red.bold('\n     ⚠️  NO TESTS — AI changes to this codebase are completely unverifiable!\n'));
+    console.log(
+      chalk.red.bold(
+        '\n     ⚠️  NO TESTS — AI changes to this codebase are completely unverifiable!\n'
+      )
+    );
   }
 
   return scoring;

package/src/commands/visualize.ts

@@ -18,20 +18,31 @@ interface VisualizeOptions {
   dev?: boolean;
 }
 
-export async function visualizeAction(directory: string, options: VisualizeOptions) {
+export async function visualizeAction(
+  directory: string,
+  options: VisualizeOptions
+) {
   try {
     const dirPath = resolvePath(process.cwd(), directory || '.');
-    let reportPath = options.report ? resolvePath(dirPath, options.report) : null;
-    
+    let reportPath = options.report
+      ? resolvePath(dirPath, options.report)
+      : null;
+
     // If report not provided or not found, try to find latest scan report
     if (!reportPath || !existsSync(reportPath)) {
       const latestScan = findLatestScanReport(dirPath);
       if (latestScan) {
         reportPath = latestScan;
-        console.log(chalk.dim(`Found latest report: ${latestScan.split('/').pop()}`));
+        console.log(
+          chalk.dim(`Found latest report: ${latestScan.split('/').pop()}`)
+        );
       } else {
         console.error(chalk.red('❌ No AI readiness report found'));
-        console.log(chalk.dim(`\nGenerate a report with:\n  aiready scan --output json\n\nOr specify a custom report:\n  aiready visualise --report <path-to-report.json>`));
+        console.log(
+          chalk.dim(
+            `\nGenerate a report with:\n  aiready scan --output json\n\nOr specify a custom report:\n  aiready visualise --report <path-to-report.json>`
+          )
+        );
         return;
       }
     }
@@ -42,39 +53,42 @@ export async function visualizeAction(directory: string, options: VisualizeOptio
     // Load config to extract graph caps
     const configPath = resolvePath(dirPath, 'aiready.json');
     let graphConfig = { maxNodes: 400, maxEdges: 600 };
-    
+
     if (existsSync(configPath)) {
       try {
         const rawConfig = JSON.parse(readFileSync(configPath, 'utf8'));
         if (rawConfig.visualizer?.graph) {
           graphConfig = {
-            maxNodes: rawConfig.visualizer.graph.maxNodes ?? graphConfig.maxNodes,
-            maxEdges: rawConfig.visualizer.graph.maxEdges ?? graphConfig.maxEdges,
+            maxNodes:
+              rawConfig.visualizer.graph.maxNodes ?? graphConfig.maxNodes,
+            maxEdges:
+              rawConfig.visualizer.graph.maxEdges ?? graphConfig.maxEdges,
           };
         }
       } catch (e) {
+        void e;
         // Silently ignore parse errors and use defaults
       }
     }
-    
+
     // Store config in env for vite middleware to pass to client
     const envVisualizerConfig = JSON.stringify(graphConfig);
     process.env.AIREADY_VISUALIZER_CONFIG = envVisualizerConfig;
 
-    console.log("Building graph from report...");
+    console.log('Building graph from report...');
     const { GraphBuilder } = await import('@aiready/visualizer/graph');
     const graph = GraphBuilder.buildFromReport(report, dirPath);
 
     // Check if --dev mode is requested and available
     let useDevMode = options.dev || false;
     let devServerStarted = false;
-    
+
     if (useDevMode) {
       try {
         const monorepoWebDir = resolvePath(dirPath, 'packages/visualizer');
         let webDir = '';
         let visualizerAvailable = false;
-        
+
         if (existsSync(monorepoWebDir)) {
           webDir = monorepoWebDir;
           visualizerAvailable = true;
@@ -82,41 +96,54 @@ export async function visualizeAction(directory: string, options: VisualizeOptio
           // Try to resolve installed @aiready/visualizer package from node_modules
           const nodemodulesLocations: string[] = [
             resolvePath(dirPath, 'node_modules', '@aiready', 'visualizer'),
-            resolvePath(process.cwd(), 'node_modules', '@aiready', 'visualizer'),
+            resolvePath(
+              process.cwd(),
+              'node_modules',
+              '@aiready',
+              'visualizer'
+            ),
           ];
-          
+
           // Walk up directory tree to find node_modules in parent directories
           let currentDir = dirPath;
           while (currentDir !== '/' && currentDir !== '.') {
-            nodemodulesLocations.push(resolvePath(currentDir, 'node_modules', '@aiready', 'visualizer'));
+            nodemodulesLocations.push(
+              resolvePath(currentDir, 'node_modules', '@aiready', 'visualizer')
+            );
             const parent = resolvePath(currentDir, '..');
             if (parent === currentDir) break;
             currentDir = parent;
           }
-          
+
           for (const location of nodemodulesLocations) {
-            if (existsSync(location) && existsSync(resolvePath(location, 'package.json'))) {
+            if (
+              existsSync(location) &&
+              existsSync(resolvePath(location, 'package.json'))
+            ) {
               webDir = location;
               visualizerAvailable = true;
               break;
             }
           }
-          
+
           // Fallback: try require.resolve
           if (!visualizerAvailable) {
             try {
-              const vizPkgPath = require.resolve('@aiready/visualizer/package.json');
+              const vizPkgPath =
+                require.resolve('@aiready/visualizer/package.json');
               webDir = resolvePath(vizPkgPath, '..');
               visualizerAvailable = true;
-            } catch (e) {
+            } catch (err) {
+              void err;
               // Visualizer not found
             }
           }
         }
-        
+
         // Check if web directory with vite config exists (required for dev mode)
-        const webViteConfigExists = webDir && existsSync(resolvePath(webDir, 'web', 'vite.config.ts'));
-        
+        const webViteConfigExists =
+          webDir && existsSync(resolvePath(webDir, 'web', 'vite.config.ts'));
+
         if (visualizerAvailable && webViteConfigExists) {
           // Dev mode is available - start Vite dev server
           const spawnCwd = webDir!;
@@ -132,10 +159,10 @@ export async function visualizeAction(directory: string, options: VisualizeOptio
               console.error('Failed to sync report:', e);
             }
           };
-          
+
           // Initial copy
           copyReportToViz();
-          
+
           // Watch source report for changes
           let watchTimeout: NodeJS.Timeout | null = null;
           const reportWatcher = watch(reportPath, () => {
@@ -143,45 +170,71 @@ export async function visualizeAction(directory: string, options: VisualizeOptio
             watchTimeout = setTimeout(copyReportToViz, 100);
           });
 
-          const envForSpawn = { 
-            ...process.env, 
+          const envForSpawn = {
+            ...process.env,
             AIREADY_REPORT_PATH: reportPath,
-            AIREADY_VISUALIZER_CONFIG: envVisualizerConfig 
+            AIREADY_VISUALIZER_CONFIG: envVisualizerConfig,
           };
-          const vite = spawn("pnpm", ["run", "dev:web"], { cwd: spawnCwd, stdio: "inherit", shell: true, env: envForSpawn });
+          const vite = spawn('pnpm', ['run', 'dev:web'], {
+            cwd: spawnCwd,
+            stdio: 'inherit',
+            shell: true,
+            env: envForSpawn,
+          });
           const onExit = () => {
-            try { reportWatcher.close(); } catch (e) {}
-            try { vite.kill(); } catch (e) {}
+            try {
+              reportWatcher.close();
+            } catch (err) {
+              void err;
+            }
+            try {
+              vite.kill();
+            } catch (err) {
+              void err;
+            }
             process.exit(0);
           };
-          process.on("SIGINT", onExit);
-          process.on("SIGTERM", onExit);
+          process.on('SIGINT', onExit);
+          process.on('SIGTERM', onExit);
           devServerStarted = true;
+          void devServerStarted;
           return;
         } else {
-          console.log(chalk.yellow('⚠️  Dev server not available (requires local @aiready/visualizer with web assets).'));
-          console.log(chalk.cyan('   Falling back to static HTML generation...\n'));
+          console.log(
+            chalk.yellow(
+              '⚠️  Dev server not available (requires local @aiready/visualizer with web assets).'
+            )
+          );
+          console.log(
+            chalk.cyan('   Falling back to static HTML generation...\n')
+          );
           useDevMode = false;
         }
       } catch (err) {
-        console.error("Failed to start dev server:", err);
-        console.log(chalk.cyan('   Falling back to static HTML generation...\n'));
+        console.error('Failed to start dev server:', err);
+        console.log(
+          chalk.cyan('   Falling back to static HTML generation...\n')
+        );
         useDevMode = false;
       }
     }
 
     // Generate static HTML (default behavior or fallback from failed --dev)
-    console.log("Generating HTML...");
+    console.log('Generating HTML...');
     const html = generateHTML(graph);
     const defaultOutput = 'visualization.html';
     const outPath = resolvePath(dirPath, options.output || defaultOutput);
     writeFileSync(outPath, html, 'utf8');
     console.log(chalk.green(`✅ Visualization written to: ${outPath}`));
-    
 
     if (options.open || options.serve) {
-      const opener = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
-      
+      const opener =
+        process.platform === 'darwin'
+          ? 'open'
+          : process.platform === 'win32'
+            ? 'start'
+            : 'xdg-open';
+
       if (options.serve) {
         try {
           const port = typeof options.serve === 'number' ? options.serve : 5173;
@@ -193,13 +246,16 @@ export async function visualizeAction(directory: string, options: VisualizeOptio
               const urlPath = req.url || '/';
               if (urlPath === '/' || urlPath === '/index.html') {
                 const content = await fsp.readFile(outPath, 'utf8');
-                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.writeHead(200, {
+                  'Content-Type': 'text/html; charset=utf-8',
+                });
                 res.end(content);
                 return;
               }
               res.writeHead(404, { 'Content-Type': 'text/plain' });
               res.end('Not found');
             } catch (e: any) {
+              void e;
               res.writeHead(500, { 'Content-Type': 'text/plain' });
               res.end('Server error');
             }
@@ -207,7 +263,9 @@ export async function visualizeAction(directory: string, options: VisualizeOptio
 
           server.listen(port, () => {
             const addr = `http://localhost:${port}/`;
-            console.log(chalk.cyan(`🌐 Local visualization server running at ${addr}`));
+            console.log(
+              chalk.cyan(`🌐 Local visualization server running at ${addr}`)
+            );
             spawn(opener, [`"${addr}"`], { shell: true });
           });
 
@@ -222,7 +280,6 @@ export async function visualizeAction(directory: string, options: VisualizeOptio
         spawn(opener, [`"${outPath}"`], { shell: true });
       }
     }
-
   } catch (err: any) {
     handleCLIError(err, 'Visualization');
   }
@@ -254,4 +311,4 @@ EXAMPLES:
 
 NOTES:
   - Same options as 'visualize'. Use --serve to host the static HTML, or --dev for live reload.
-`;
+`;

package/src/index.ts

@@ -3,13 +3,23 @@ import { analyzeContext } from '@aiready/context-analyzer';
 import { analyzeConsistency } from '@aiready/consistency';
 import type { AnalysisResult, ScanOptions } from '@aiready/core';
 import type { ContextAnalysisResult } from '@aiready/context-analyzer';
-import type { PatternDetectOptions, DuplicatePattern } from '@aiready/pattern-detect';
+import type { DuplicatePattern } from '@aiready/pattern-detect';
 import type { ConsistencyReport } from '@aiready/consistency';
 
 import type { ConsistencyOptions } from '@aiready/consistency';
 
 export interface UnifiedAnalysisOptions extends ScanOptions {
-  tools?: ('patterns' | 'context' | 'consistency' | 'doc-drift' | 'deps-health' | 'aiSignalClarity' | 'grounding' | 'testability' | 'changeAmplification')[];
+  tools?: (
+    | 'patterns'
+    | 'context'
+    | 'consistency'
+    | 'doc-drift'
+    | 'deps-health'
+    | 'aiSignalClarity'
+    | 'grounding'
+    | 'testability'
+    | 'changeAmplification'
+  )[];
   minSimilarity?: number;
   minLines?: number;
   maxCandidatesPerBlock?: number;
@@ -50,7 +60,8 @@ function sortBySeverity(results: AnalysisResult[]): AnalysisResult[] {
     .map((file) => {
       // Sort issues within each file by severity (most severe first)
       const sortedIssues = [...file.issues].sort((a, b) => {
-        const severityDiff = (severityOrder[b.severity] || 0) - (severityOrder[a.severity] || 0);
+        const severityDiff =
+          (severityOrder[b.severity] || 0) - (severityOrder[a.severity] || 0);
         if (severityDiff !== 0) return severityDiff;
         // If same severity, sort by line number
         return (a.location?.line || 0) - (b.location?.line || 0);
@@ -59,8 +70,14 @@ function sortBySeverity(results: AnalysisResult[]): AnalysisResult[] {
     })
     .sort((a, b) => {
       // Sort files by most severe issue first
-      const aMaxSeverity = Math.max(...a.issues.map((i) => severityOrder[i.severity] || 0), 0);
-      const bMaxSeverity = Math.max(...b.issues.map((i) => severityOrder[i.severity] || 0), 0);
+      const aMaxSeverity = Math.max(
+        ...a.issues.map((i) => severityOrder[i.severity] || 0),
+        0
+      );
+      const bMaxSeverity = Math.max(
+        ...b.issues.map((i) => severityOrder[i.severity] || 0),
+        0
+      );
       if (aMaxSeverity !== bMaxSeverity) {
         return bMaxSeverity - aMaxSeverity;
       }
@@ -113,7 +130,8 @@ export async function analyzeUnified(
     }
     // Sort context results by severity (most severe first)
     result.context = contextResults.sort((a, b) => {
-      const severityDiff = (severityOrder[b.severity] || 0) - (severityOrder[a.severity] || 0);
+      const severityDiff =
+        (severityOrder[b.severity] || 0) - (severityOrder[a.severity] || 0);
       if (severityDiff !== 0) return severityDiff;
       // If same severity, sort by token cost (higher cost first)
       if (a.tokenCost !== b.tokenCost) return b.tokenCost - a.tokenCost;
@@ -151,6 +169,7 @@ export async function analyzeUnified(
       rootDir: options.rootDir,
       include: options.include,
       exclude: options.exclude,
+      onProgress: options.onProgress,
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: 'doc-drift', data: report });
@@ -166,6 +185,7 @@ export async function analyzeUnified(
       rootDir: options.rootDir,
       include: options.include,
       exclude: options.exclude,
+      onProgress: options.onProgress,
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: 'deps-health', data: report });
@@ -176,17 +196,23 @@ export async function analyzeUnified(
 
   // Run AI Signal Clarity analysis
   if (tools.includes('aiSignalClarity')) {
-    const { analyzeAiSignalClarity } = await import('@aiready/ai-signal-clarity');
+    const { analyzeAiSignalClarity } =
+      await import('@aiready/ai-signal-clarity');
     const report = await analyzeAiSignalClarity({
       rootDir: options.rootDir,
       include: options.include,
       exclude: options.exclude,
+      onProgress: options.onProgress,
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: 'aiSignalClarity', data: report });
     }
     result.aiSignalClarity = report;
-    result.summary.totalIssues += report.results?.reduce((sum: number, r: any) => sum + (r.issues?.length || 0), 0) || 0;
+    result.summary.totalIssues +=
+      report.results?.reduce(
+        (sum: number, r: any) => sum + (r.issues?.length || 0),
+        0
+      ) || 0;
   }
 
   // Run Agent Grounding analysis
@@ -196,6 +222,7 @@ export async function analyzeUnified(
       rootDir: options.rootDir,
       include: options.include,
       exclude: options.exclude,
+      onProgress: options.onProgress,
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: 'grounding', data: report });
@@ -211,6 +238,7 @@ export async function analyzeUnified(
       rootDir: options.rootDir,
       include: options.include,
       exclude: options.exclude,
+      onProgress: options.onProgress,
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: 'testability', data: report });
@@ -221,11 +249,13 @@ export async function analyzeUnified(
 
   // Run Change Amplification analysis
   if (tools.includes('changeAmplification')) {
-    const { analyzeChangeAmplification } = await import('@aiready/change-amplification');
+    const { analyzeChangeAmplification } =
+      await import('@aiready/change-amplification');
     const report = await analyzeChangeAmplification({
       rootDir: options.rootDir,
       include: options.include,
       exclude: options.exclude,
+      onProgress: options.onProgress,
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: 'changeAmplification', data: report });
@@ -283,4 +313,4 @@ export function generateUnifiedSummary(result: UnifiedAnalysisResult): string {
   }
 
   return output;
-}
+}

package/src/utils/helpers.ts

@@ -3,7 +3,7 @@
  */
 
 import { resolve as resolvePath } from 'path';
-import { existsSync, readdirSync, statSync, readFileSync, copyFileSync } from 'fs';
+import { existsSync, readdirSync, statSync, readFileSync } from 'fs';
 import chalk from 'chalk';
 
 /**
@@ -25,35 +25,45 @@ export function findLatestScanReport(dirPath: string): string | null {
   if (!existsSync(aireadyDir)) {
     return null;
   }
-  
+
   // Search for new format first, then legacy format
-  let files = readdirSync(aireadyDir).filter(f => f.startsWith('aiready-report-') && f.endsWith('.json'));
+  let files = readdirSync(aireadyDir).filter(
+    (f) => f.startsWith('aiready-report-') && f.endsWith('.json')
+  );
   if (files.length === 0) {
-    files = readdirSync(aireadyDir).filter(f => f.startsWith('aiready-scan-') && f.endsWith('.json'));
+    files = readdirSync(aireadyDir).filter(
+      (f) => f.startsWith('aiready-scan-') && f.endsWith('.json')
+    );
   }
-  
+
   if (files.length === 0) {
     return null;
   }
-  
+
   // Sort by modification time, most recent first
   const sortedFiles = files
-    .map(f => ({ name: f, path: resolvePath(aireadyDir, f), mtime: statSync(resolvePath(aireadyDir, f)).mtime }))
+    .map((f) => ({
+      name: f,
+      path: resolvePath(aireadyDir, f),
+      mtime: statSync(resolvePath(aireadyDir, f)).mtime,
+    }))
     .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-  
+
   return sortedFiles[0].path;
 }
 
 /**
  * Warn if graph caps may be exceeded
  */
-export function warnIfGraphCapExceeded(report: any, dirPath: string) {
+export async function warnIfGraphCapExceeded(report: any, dirPath: string) {
   try {
     // Use dynamic import and loadConfig to get the raw visualizer config
-    const { loadConfig } = require('@aiready/core');
-    
+    // Use dynamic import instead of require
+    const { loadConfig } = await import('@aiready/core');
+    void loadConfig;
+
     let graphConfig = { maxNodes: 400, maxEdges: 600 };
-    
+
     // Try to read aiready.json synchronously
     const configPath = resolvePath(dirPath, 'aiready.json');
     if (existsSync(configPath)) {
@@ -61,47 +71,62 @@ export function warnIfGraphCapExceeded(report: any, dirPath: string) {
         const rawConfig = JSON.parse(readFileSync(configPath, 'utf8'));
         if (rawConfig.visualizer?.graph) {
           graphConfig = {
-            maxNodes: rawConfig.visualizer.graph.maxNodes ?? graphConfig.maxNodes,
-            maxEdges: rawConfig.visualizer.graph.maxEdges ?? graphConfig.maxEdges,
+            maxNodes:
+              rawConfig.visualizer.graph.maxNodes ?? graphConfig.maxNodes,
+            maxEdges:
+              rawConfig.visualizer.graph.maxEdges ?? graphConfig.maxEdges,
           };
         }
-      } catch (e) {
-        // Silently ignore parse errors and use defaults
+      } catch (err) {
+        void err;
       }
     }
-    
-    const nodeCount = (report.context?.length || 0) + (report.patterns?.length || 0);
-    const edgeCount = report.context?.reduce((sum: number, ctx: any) => {
-      const relCount = ctx.relatedFiles?.length || 0;
-      const depCount = ctx.dependencies?.length || 0;
-      return sum + relCount + depCount;
-    }, 0) || 0;
-    
+
+    const nodeCount =
+      (report.context?.length || 0) + (report.patterns?.length || 0);
+    const edgeCount =
+      report.context?.reduce((sum: number, ctx: any) => {
+        const relCount = ctx.relatedFiles?.length || 0;
+        const depCount = ctx.dependencies?.length || 0;
+        return sum + relCount + depCount;
+      }, 0) || 0;
+
     if (nodeCount > graphConfig.maxNodes || edgeCount > graphConfig.maxEdges) {
       console.log('');
-      console.log(chalk.yellow(`⚠️  Graph may be truncated at visualization time:`));
+      console.log(
+        chalk.yellow(`⚠️  Graph may be truncated at visualization time:`)
+      );
       if (nodeCount > graphConfig.maxNodes) {
-        console.log(chalk.dim(`   • Nodes: ${nodeCount} > limit ${graphConfig.maxNodes}`));
+        console.log(
+          chalk.dim(`   • Nodes: ${nodeCount} > limit ${graphConfig.maxNodes}`)
+        );
       }
       if (edgeCount > graphConfig.maxEdges) {
-        console.log(chalk.dim(`   • Edges: ${edgeCount} > limit ${graphConfig.maxEdges}`));
+        console.log(
+          chalk.dim(`   • Edges: ${edgeCount} > limit ${graphConfig.maxEdges}`)
+        );
       }
       console.log(chalk.dim(`   To increase limits, add to aiready.json:`));
       console.log(chalk.dim(`   {`));
       console.log(chalk.dim(`     "visualizer": {`));
-      console.log(chalk.dim(`       "graph": { "maxNodes": 2000, "maxEdges": 5000 }`));
+      console.log(
+        chalk.dim(`       "graph": { "maxNodes": 2000, "maxEdges": 5000 }`)
+      );
       console.log(chalk.dim(`     }`));
       console.log(chalk.dim(`   }`));
     }
-  } catch (e) {
-    // Silently fail on config read errors
+  } catch (err) {
+    void err;
   }
 }
 
 /**
  * Generate markdown report for consistency command
  */
-export function generateMarkdownReport(report: any, elapsedTime: string): string {
+export function generateMarkdownReport(
+  report: any,
+  elapsedTime: string
+): string {
   let markdown = `# Consistency Analysis Report\n\n`;
   markdown += `**Generated:** ${new Date().toISOString()}\n`;
   markdown += `**Analysis Time:** ${elapsedTime}s\n\n`;
@@ -130,4 +155,4 @@ export function truncateArray(arr: any[] | undefined, cap = 8): string {
   const shown = arr.slice(0, cap).map((v) => String(v));
   const more = arr.length - shown.length;
   return shown.join(', ') + (more > 0 ? `, ... (+${more} more)` : '');
-}
+}