@aiready/cli 0.12.8 → 0.12.10

package/src/index.ts

@@ -3,6 +3,7 @@ import {
   ToolName,
   calculateOverallScore,
   calculateTokenBudget,
+  GLOBAL_SCAN_OPTIONS,
 } from '@aiready/core';
 import type {
   AnalysisResult,
@@ -26,14 +27,22 @@ import '@aiready/change-amplification';
 export type { ToolScoringOutput, ScoringResult };
 
 export interface UnifiedAnalysisOptions extends ScanOptions {
+  rootDir: string;
   tools?: string[];
+  toolConfigs?: Record<string, any>;
   minSimilarity?: number;
   minLines?: number;
   maxCandidatesPerBlock?: number;
   minSharedTokens?: number;
   useSmartDefaults?: boolean;
   consistency?: any;
-  progressCallback?: (event: { tool: string; data: any }) => void;
+  progressCallback?: (event: {
+    tool: string;
+    data?: any;
+    processed?: number;
+    total?: number;
+    message?: string;
+  }) => void;
 }
 
 export interface UnifiedAnalysisResult {
@@ -41,9 +50,14 @@ export interface UnifiedAnalysisResult {
   [key: string]: any;
 
   summary: {
+    totalFiles: number;
     totalIssues: number;
+    criticalIssues: number;
+    majorIssues: number;
     toolsRun: string[];
     executionTime: number;
+    config?: any;
+    toolConfigs?: Record<string, any>;
   };
   scoring?: ScoringResult;
 }
@@ -68,20 +82,27 @@ const TOOL_PACKAGE_MAP: Record<string, string> = {
   context: '@aiready/context-analyzer',
   fragmentation: '@aiready/context-analyzer',
   consistency: '@aiready/consistency',
-  'naming-consistency': '@aiready/consistency',
   'ai-signal': '@aiready/ai-signal-clarity',
-  'ai-signal-clarity': '@aiready/ai-signal-clarity',
   grounding: '@aiready/agent-grounding',
-  'agent-grounding': '@aiready/agent-grounding',
   testability: '@aiready/testability',
-  'testability-index': '@aiready/testability',
-  'doc-drift': '@aiready/doc-drift',
   'deps-health': '@aiready/deps',
-  'dependency-health': '@aiready/deps',
   'change-amp': '@aiready/change-amplification',
-  'change-amplification': '@aiready/change-amplification',
 };
 
+/**
+ * Sanitize tool configuration by removing global options (except rootDir)
+ */
+function sanitizeToolConfig(config: any): any {
+  if (!config || typeof config !== 'object') return config;
+  const sanitized = { ...config };
+  GLOBAL_SCAN_OPTIONS.forEach((key: string) => {
+    if (key !== 'rootDir') {
+      delete (sanitized as any)[key];
+    }
+  });
+  return sanitized;
+}
+
 /**
  * AIReady Unified Analysis
  * Orchestrates all registered tools via the ToolRegistry.
@@ -99,9 +120,13 @@ export async function analyzeUnified(
   const result: UnifiedAnalysisResult = {
     summary: {
       totalIssues: 0,
+      criticalIssues: 0, // Added as per instruction
+      majorIssues: 0, // Added as per instruction
       totalFiles: 0,
       toolsRun: [],
       executionTime: 0,
+      config: options,
+      toolConfigs: {},
     },
   };
 
@@ -141,20 +166,54 @@ export async function analyzeUnified(
     }
 
     try {
-      const output = await provider.analyze({
-        ...options,
-        onProgress: (processed: number, total: number, message: string) => {
-          if (options.progressCallback) {
-            options.progressCallback({
-              tool: provider!.id,
-              processed,
-              total,
-              message,
-            });
-          }
-        },
+      // Sanitize options for metadata tracking (remove functions/internal keys)
+      const sanitizedConfig = { ...options };
+      delete (sanitizedConfig as any).onProgress;
+      delete (sanitizedConfig as any).progressCallback;
+
+      // 1. Start with sanitized global subset
+      const toolOptions: any = {
+        rootDir: options.rootDir, // Always include rootDir
+      };
+
+      // 2. Add other global options that tools might need
+      GLOBAL_SCAN_OPTIONS.forEach((key) => {
+        if (key in options && key !== 'toolConfigs') {
+          toolOptions[key] = (options as any)[key];
+        }
       });
 
+      // 3. Add tool-specific overrides
+      if (options.toolConfigs?.[provider.id]) {
+        Object.assign(toolOptions, options.toolConfigs[provider.id]);
+      } else if ((options as any)[provider.id]) {
+        // Fallback for legacy tool-specific keys
+        Object.assign(toolOptions, (options as any)[provider.id]);
+      }
+
+      // 4. Attach progress callback
+      toolOptions.onProgress = (
+        processed: number,
+        total: number,
+        message: string
+      ) => {
+        if (options.progressCallback) {
+          options.progressCallback({
+            tool: provider!.id,
+            processed,
+            total,
+            message,
+          });
+        }
+      };
+
+      const output = await provider.analyze(toolOptions);
+
+      // Inject sanitized configuration into metadata for audit
+      if (output.metadata) {
+        output.metadata.config = sanitizeToolConfig(toolOptions);
+      }
+
       if (options.progressCallback) {
         options.progressCallback({ tool: provider.id, data: output });
       }
@@ -162,6 +221,21 @@ export async function analyzeUnified(
       result[provider.id] = output;
       result.summary.toolsRun.push(provider.id);
 
+      // Collect tool-specific configuration for the audit log
+      if (output.summary?.config) {
+        result.summary.toolConfigs![provider.id] = sanitizeToolConfig(
+          output.summary.config
+        );
+      } else if (output.metadata?.config) {
+        result.summary.toolConfigs![provider.id] = sanitizeToolConfig(
+          output.metadata.config
+        );
+      } else {
+        // Fallback to our sanitized input options if spoke didn't return config
+        result.summary.toolConfigs![provider.id] =
+          sanitizeToolConfig(toolOptions);
+      }
+
       // Track total files analyzed across all tools
       const toolFiles =
         output.summary?.totalFiles || output.summary?.filesAnalyzed || 0;
@@ -197,6 +271,12 @@ export async function analyzeUnified(
     }
   }
 
+  // Finalize configuration for metadata
+  result.summary.config = {
+    ...options,
+    toolConfigs: result.summary.toolConfigs,
+  };
+
   result.summary.executionTime = Date.now() - startTime;
   return result;
 }