@aiready/cli 0.12.11 → 0.12.14

package/src/__tests__/config-shape.test.ts

@@ -0,0 +1,106 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { analyzeUnified } from '../index';
+import { ToolRegistry, ToolName, SpokeOutputSchema } from '@aiready/core';
+
+describe('CLI Configuration Shape', () => {
+  beforeEach(() => {
+    ToolRegistry.clear();
+
+    // Register a mock provider that returns its input config in metadata
+    ToolRegistry.register({
+      id: ToolName.PatternDetect,
+      alias: ['patterns'],
+      analyze: async (options) =>
+        SpokeOutputSchema.parse({
+          results: [],
+          summary: { config: options },
+          metadata: {
+            toolName: ToolName.PatternDetect,
+            version: '1.0.0',
+            config: options,
+          },
+        }),
+      score: () => ({
+        toolName: ToolName.PatternDetect,
+        score: 80,
+        factors: [],
+        recommendations: [],
+        rawMetrics: {},
+      }),
+      defaultWeight: 10,
+    });
+  });
+
+  afterEach(() => {
+    ToolRegistry.clear();
+  });
+
+  it('should generate a strictly portable AIReadyConfig in summary', async () => {
+    const results = await analyzeUnified({
+      rootDir: '/tmp/fake-repo',
+      tools: [ToolName.PatternDetect],
+      exclude: ['**/node_modules/**'],
+      // Pass a tool-specific override
+      toolConfigs: {
+        [ToolName.PatternDetect]: {
+          minSimilarity: 0.9,
+          // This should be stripped
+          rootDir: '/tmp/fake-repo',
+        },
+      },
+    });
+
+    const config = results.summary.config;
+
+    // 1. Check top-level structure
+    expect(config).toHaveProperty('scan');
+    expect(config).toHaveProperty('tools');
+
+    // 2. Ensure rootDir is STRIPPED from top level
+    expect(config).not.toHaveProperty('rootDir');
+
+    // 3. Ensure internal keys are stripped from scan section
+    expect(config.scan).toHaveProperty('tools');
+    expect(config.scan).toHaveProperty('exclude');
+    expect(config.scan).not.toHaveProperty('rootDir');
+
+    // 4. Ensure recursive stripping in tools section
+    const patternConfig = config.tools[ToolName.PatternDetect];
+    expect(patternConfig).toHaveProperty('minSimilarity', 0.9);
+    expect(patternConfig).not.toHaveProperty('rootDir');
+    expect(patternConfig).not.toHaveProperty('onProgress');
+  });
+
+  it('should strip internal keys like useSmartDefaults and batchSize', async () => {
+    const results = await analyzeUnified({
+      rootDir: '/test',
+      tools: [ToolName.PatternDetect],
+      useSmartDefaults: true,
+      // @ts-ignore - testing internal key stripping
+      batchSize: 50,
+    });
+
+    const config = results.summary.config;
+
+    expect(config).not.toHaveProperty('useSmartDefaults');
+    expect(config.scan).not.toHaveProperty('useSmartDefaults');
+
+    // Check tool level too
+    const patternConfig = config.tools[ToolName.PatternDetect];
+    expect(patternConfig).not.toHaveProperty('useSmartDefaults');
+    expect(patternConfig).not.toHaveProperty('batchSize');
+  });
+
+  it('should produce a config that is compatible with tool specific collection', async () => {
+    // This test ensures that the toolConfigs collected from individual tools
+    // are also sanitized before being merged into the final report.
+    const results = await analyzeUnified({
+      rootDir: '/test',
+      tools: [ToolName.PatternDetect],
+    });
+
+    const toolConfigs = results.summary.toolConfigs;
+    expect(toolConfigs).toBeDefined();
+    expect(toolConfigs![ToolName.PatternDetect]).not.toHaveProperty('rootDir');
+  });
+});

package/src/commands/scan.ts

@@ -184,7 +184,7 @@ export async function scanAction(directory: string, options: ScanOptions) {
     const results = await analyzeUnified({
       ...finalOptions,
       progressCallback,
-      onProgress: () => { },
+      onProgress: () => {},
       suppressToolConfig: true,
     });
 
@@ -192,6 +192,9 @@ export async function scanAction(directory: string, options: ScanOptions) {
     console.log(
       `  Total issues (all tools): ${chalk.bold(String(results.summary.totalIssues || 0))}`
     );
+    console.log(
+      `  Execution time: ${chalk.bold(((Date.now() - startTime) / 1000).toFixed(2) + 's')}`
+    );
 
     let scoringResult: ScoringResult | undefined;
     if (options.score || finalOptions.scoring?.showBreakdown) {

package/src/index.ts

@@ -92,19 +92,44 @@ const TOOL_PACKAGE_MAP: Record<string, string> = {
 };
 
 /**
- * Sanitize tool configuration by removing global options (except rootDir)
+ * Deeply sanitizes a configuration object by removing infrastructure keys like rootDir.
+ * Works recursively to clean up nested tool configurations to ensure compatibility
+ * with the AIReadyConfig schema for portable configuration files.
  */
-function sanitizeToolConfig(config: any): any {
-  if (!config || typeof config !== 'object') return config;
-  const sanitized = { ...config };
-  GLOBAL_INFRA_OPTIONS.forEach((key: string) => {
-    if (key !== 'rootDir') {
-      delete (sanitized as any)[key];
+function sanitizeConfigRecursive(obj: any): any {
+  if (!obj || typeof obj !== 'object' || Array.isArray(obj)) return obj;
+
+  const sanitized: any = {};
+  const infraToStrip = [
+    'rootDir',
+    'onProgress',
+    'progressCallback',
+    'streamResults',
+    'batchSize',
+    'useSmartDefaults',
+  ];
+
+  for (const [key, value] of Object.entries(obj)) {
+    // Skip infrastructure keys that shouldn't be in a portable config file
+    if (infraToStrip.includes(key)) continue;
+
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      sanitized[key] = sanitizeConfigRecursive(value);
+    } else {
+      sanitized[key] = value;
     }
-  });
+  }
+
   return sanitized;
 }
 
+/**
+ * Sanitize tool configuration by removing global options to match AIReadyConfig schema
+ */
+function sanitizeToolConfig(config: any): any {
+  return sanitizeConfigRecursive(config);
+}
+
 /**
  * AIReady Unified Analysis
  * Orchestrates all registered tools via the ToolRegistry.
@@ -169,9 +194,9 @@ export async function analyzeUnified(
 
     try {
       // Sanitize options for metadata tracking (remove functions/internal keys)
-      const sanitizedConfig = { ...options };
-      delete (sanitizedConfig as any).onProgress;
-      delete (sanitizedConfig as any).progressCallback;
+      const sanitizedOptions = { ...options };
+      delete (sanitizedOptions as any).onProgress;
+      delete (sanitizedOptions as any).progressCallback;
 
       // 1. Start with sanitized global subset
       const toolOptions: any = {
@@ -181,15 +206,26 @@ export async function analyzeUnified(
       // 1. Pass through all known infra and fine-tuning options from root level
       [...GLOBAL_INFRA_OPTIONS, ...COMMON_FINE_TUNING_OPTIONS].forEach(
         (key) => {
-          if (key in options && key !== 'toolConfigs') {
+          if (key in options && key !== 'toolConfigs' && key !== 'tools') {
             toolOptions[key] = (options as any)[key];
           }
         }
       );
 
       // 3. Add tool-specific overrides
+      // Check priority:
+      // a) options.toolConfigs[toolId]
+      // b) options.tools[toolId] (if tools is an object, not the array of tool names)
+      // c) options[toolId] (legacy)
       if (options.toolConfigs?.[provider.id]) {
         Object.assign(toolOptions, options.toolConfigs[provider.id]);
+      } else if (
+        options.tools &&
+        !Array.isArray(options.tools) &&
+        typeof options.tools === 'object' &&
+        (options.tools as any)[provider.id]
+      ) {
+        Object.assign(toolOptions, (options.tools as any)[provider.id]);
       } else if ((options as any)[provider.id]) {
         // Fallback for legacy tool-specific keys
         Object.assign(toolOptions, (options as any)[provider.id]);
@@ -275,11 +311,17 @@ export async function analyzeUnified(
     }
   }
 
-  // Finalize configuration for metadata
-  result.summary.config = {
-    ...options,
-    toolConfigs: result.summary.toolConfigs,
-  };
+  // Finalize configuration for metadata to match AIReadyConfig schema
+  // We use sanitizeConfigRecursive to ensure no internal keys (like rootDir) remain
+  result.summary.config = sanitizeConfigRecursive({
+    scan: {
+      tools: requestedTools,
+      include: options.include,
+      exclude: options.exclude,
+    },
+    // Use 'tools' for tool-specific configurations to match AIReadyConfig
+    tools: result.summary.toolConfigs,
+  });
 
   result.summary.executionTime = Date.now() - startTime;
   return result;