@aiready/cli 0.12.12 → 0.12.16

package/dist/chunk-VOKP7FGM.mjs

@@ -0,0 +1,303 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import {
+  ToolRegistry,
+  ToolName,
+  calculateOverallScore,
+  calculateTokenBudget,
+  GLOBAL_INFRA_OPTIONS,
+  COMMON_FINE_TUNING_OPTIONS,
+  initializeParsers
+} from "@aiready/core";
+import "@aiready/pattern-detect";
+import "@aiready/context-analyzer";
+import "@aiready/consistency";
+import "@aiready/ai-signal-clarity";
+import "@aiready/agent-grounding";
+import "@aiready/testability";
+import "@aiready/doc-drift";
+import "@aiready/deps";
+import "@aiready/change-amplification";
+var TOOL_PACKAGE_MAP = {
+  [ToolName.PatternDetect]: "@aiready/pattern-detect",
+  [ToolName.ContextAnalyzer]: "@aiready/context-analyzer",
+  [ToolName.NamingConsistency]: "@aiready/consistency",
+  [ToolName.AiSignalClarity]: "@aiready/ai-signal-clarity",
+  [ToolName.AgentGrounding]: "@aiready/agent-grounding",
+  [ToolName.TestabilityIndex]: "@aiready/testability",
+  [ToolName.DocDrift]: "@aiready/doc-drift",
+  [ToolName.DependencyHealth]: "@aiready/deps",
+  [ToolName.ChangeAmplification]: "@aiready/change-amplification",
+  // Aliases handled by registry
+  patterns: "@aiready/pattern-detect",
+  duplicates: "@aiready/pattern-detect",
+  context: "@aiready/context-analyzer",
+  fragmentation: "@aiready/context-analyzer",
+  consistency: "@aiready/consistency",
+  "ai-signal": "@aiready/ai-signal-clarity",
+  grounding: "@aiready/agent-grounding",
+  testability: "@aiready/testability",
+  "deps-health": "@aiready/deps",
+  "change-amp": "@aiready/change-amplification"
+};
+function sanitizeConfigRecursive(obj) {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return obj;
+  const sanitized = {};
+  const infraToStrip = [
+    "rootDir",
+    "onProgress",
+    "progressCallback",
+    "streamResults",
+    "batchSize",
+    "useSmartDefaults"
+  ];
+  for (const [key, value] of Object.entries(obj)) {
+    if (infraToStrip.includes(key)) continue;
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      sanitized[key] = sanitizeConfigRecursive(value);
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+function sanitizeToolConfig(config) {
+  return sanitizeConfigRecursive(config);
+}
+async function analyzeUnified(options) {
+  await initializeParsers();
+  const startTime = Date.now();
+  const requestedTools = options.tools || [
+    "patterns",
+    "context",
+    "consistency"
+  ];
+  const result = {
+    summary: {
+      totalIssues: 0,
+      criticalIssues: 0,
+      // Added as per instruction
+      majorIssues: 0,
+      // Added as per instruction
+      totalFiles: 0,
+      toolsRun: [],
+      executionTime: 0,
+      config: options,
+      toolConfigs: {}
+    }
+  };
+  for (const toolName of requestedTools) {
+    let provider = ToolRegistry.find(toolName);
+    if (!provider) {
+      const packageName = TOOL_PACKAGE_MAP[toolName] || (toolName.startsWith("@aiready/") ? toolName : `@aiready/${toolName}`);
+      try {
+        await import(packageName);
+        provider = ToolRegistry.find(toolName);
+        if (provider) {
+          console.log(
+            `\u2705 Successfully loaded tool provider: ${toolName} from ${packageName}`
+          );
+        } else {
+          console.log(
+            `\u26A0\uFE0F Loaded ${packageName} but provider ${toolName} still not found in registry.`
+          );
+        }
+      } catch (err) {
+        console.log(
+          `\u274C Failed to dynamically load tool ${toolName} (${packageName}):`,
+          err.message
+        );
+      }
+    }
+    if (!provider) {
+      console.warn(
+        `\u26A0\uFE0F  Warning: Tool provider for '${toolName}' not found. Skipping.`
+      );
+      continue;
+    }
+    try {
+      const sanitizedOptions = { ...options };
+      delete sanitizedOptions.onProgress;
+      delete sanitizedOptions.progressCallback;
+      const toolOptions = {
+        rootDir: options.rootDir
+        // Always include rootDir
+      };
+      [...GLOBAL_INFRA_OPTIONS, ...COMMON_FINE_TUNING_OPTIONS].forEach(
+        (key) => {
+          if (key in options && key !== "toolConfigs" && key !== "tools") {
+            toolOptions[key] = options[key];
+          }
+        }
+      );
+      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[provider.id]) {
+        Object.assign(toolOptions, options.tools[provider.id]);
+      } else if (options[provider.id]) {
+        Object.assign(toolOptions, options[provider.id]);
+      }
+      toolOptions.onProgress = (processed, total, message) => {
+        if (options.progressCallback) {
+          options.progressCallback({
+            tool: provider.id,
+            processed,
+            total,
+            message
+          });
+        }
+      };
+      const output = await provider.analyze(toolOptions);
+      if (output.metadata) {
+        output.metadata.config = sanitizeToolConfig(toolOptions);
+      }
+      if (options.progressCallback) {
+        options.progressCallback({ tool: provider.id, data: output });
+      }
+      result[provider.id] = output;
+      result.summary.toolsRun.push(provider.id);
+      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 {
+        result.summary.toolConfigs[provider.id] = sanitizeToolConfig(toolOptions);
+      }
+      const toolFiles = output.summary?.totalFiles || output.summary?.filesAnalyzed || 0;
+      if (toolFiles > result.summary.totalFiles) {
+        result.summary.totalFiles = toolFiles;
+      }
+      const issueCount = output.results.reduce(
+        (sum, file) => sum + (file.issues?.length || 0),
+        0
+      );
+      result.summary.totalIssues += issueCount;
+      if (provider.alias && Array.isArray(provider.alias)) {
+        for (const alias of provider.alias) {
+          if (!result[alias]) {
+            result[alias] = output;
+          }
+        }
+      }
+      const camelCaseId = provider.id.replace(
+        /-([a-z])/g,
+        (g) => g[1].toUpperCase()
+      );
+      if (camelCaseId !== provider.id && !result[camelCaseId]) {
+        result[camelCaseId] = output;
+      }
+    } catch (err) {
+      console.error(`\u274C Error running tool '${provider.id}':`, err);
+    }
+  }
+  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;
+}
+async function scoreUnified(results, options) {
+  const toolScores = /* @__PURE__ */ new Map();
+  for (const toolId of results.summary.toolsRun) {
+    const provider = ToolRegistry.get(toolId);
+    if (!provider) continue;
+    const output = results[toolId];
+    if (!output) continue;
+    try {
+      const toolScore = provider.score(output, options);
+      if (!toolScore.tokenBudget) {
+        if (toolId === ToolName.PatternDetect && output.duplicates) {
+          const wastedTokens = output.duplicates.reduce(
+            (sum, d) => sum + (d.tokenCost || 0),
+            0
+          );
+          toolScore.tokenBudget = calculateTokenBudget({
+            totalContextTokens: wastedTokens * 2,
+            wastedTokens: {
+              duplication: wastedTokens,
+              fragmentation: 0,
+              chattiness: 0
+            }
+          });
+        } else if (toolId === ToolName.ContextAnalyzer && output.summary) {
+          toolScore.tokenBudget = calculateTokenBudget({
+            totalContextTokens: output.summary.totalTokens,
+            wastedTokens: {
+              duplication: 0,
+              fragmentation: output.summary.totalPotentialSavings || 0,
+              chattiness: 0
+            }
+          });
+        }
+      }
+      toolScores.set(toolId, toolScore);
+    } catch (err) {
+      console.error(`\u274C Error scoring tool '${toolId}':`, err);
+    }
+  }
+  if (toolScores.size === 0) {
+    return {
+      overall: 0,
+      rating: "Critical",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      toolsUsed: [],
+      breakdown: [],
+      calculation: {
+        formula: "0 / 0 = 0",
+        weights: {},
+        normalized: "0 / 0 = 0"
+      }
+    };
+  }
+  return calculateOverallScore(toolScores, options, void 0);
+}
+function generateUnifiedSummary(result) {
+  const { summary } = result;
+  let output = `\u{1F680} AIReady Analysis Complete
+
+`;
+  output += `\u{1F4CA} Summary:
+`;
+  output += `   Tools run: ${summary.toolsRun.join(", ")}
+`;
+  output += `   Total issues found: ${summary.totalIssues}
+`;
+  output += `   Execution time: ${(summary.executionTime / 1e3).toFixed(2)}s
+
+`;
+  for (const provider of ToolRegistry.getAll()) {
+    const toolResult = result[provider.id];
+    if (toolResult) {
+      const issueCount = toolResult.results.reduce(
+        (sum, r) => sum + (r.issues?.length || 0),
+        0
+      );
+      output += `\u2022 ${provider.id}: ${issueCount} issues
+`;
+    }
+  }
+  return output;
+}
+
+export {
+  __require,
+  analyzeUnified,
+  scoreUnified,
+  generateUnifiedSummary
+};

package/dist/cli.js

@@ -68,17 +68,32 @@ var TOOL_PACKAGE_MAP = {
   "deps-health": "@aiready/deps",
   "change-amp": "@aiready/change-amplification"
 };
-function sanitizeToolConfig(config) {
-  if (!config || typeof config !== "object") return config;
-  const sanitized = { ...config };
-  import_core.GLOBAL_INFRA_OPTIONS.forEach((key) => {
-    if (key !== "rootDir") {
-      delete sanitized[key];
+function sanitizeConfigRecursive(obj) {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return obj;
+  const sanitized = {};
+  const infraToStrip = [
+    "rootDir",
+    "onProgress",
+    "progressCallback",
+    "streamResults",
+    "batchSize",
+    "useSmartDefaults"
+  ];
+  for (const [key, value] of Object.entries(obj)) {
+    if (infraToStrip.includes(key)) continue;
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      sanitized[key] = sanitizeConfigRecursive(value);
+    } else {
+      sanitized[key] = value;
     }
-  });
+  }
   return sanitized;
 }
+function sanitizeToolConfig(config) {
+  return sanitizeConfigRecursive(config);
+}
 async function analyzeUnified(options) {
+  await (0, import_core.initializeParsers)();
   const startTime = Date.now();
   const requestedTools = options.tools || [
     "patterns",
@@ -129,22 +144,24 @@ async function analyzeUnified(options) {
       continue;
     }
     try {
-      const sanitizedConfig = { ...options };
-      delete sanitizedConfig.onProgress;
-      delete sanitizedConfig.progressCallback;
+      const sanitizedOptions = { ...options };
+      delete sanitizedOptions.onProgress;
+      delete sanitizedOptions.progressCallback;
       const toolOptions = {
         rootDir: options.rootDir
         // Always include rootDir
       };
       [...import_core.GLOBAL_INFRA_OPTIONS, ...import_core.COMMON_FINE_TUNING_OPTIONS].forEach(
         (key) => {
-          if (key in options && key !== "toolConfigs") {
+          if (key in options && key !== "toolConfigs" && key !== "tools") {
             toolOptions[key] = options[key];
           }
         }
       );
       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[provider.id]) {
+        Object.assign(toolOptions, options.tools[provider.id]);
       } else if (options[provider.id]) {
         Object.assign(toolOptions, options[provider.id]);
       }
@@ -205,10 +222,15 @@ async function analyzeUnified(options) {
       console.error(`\u274C Error running tool '${provider.id}':`, err);
     }
   }
-  result.summary.config = {
-    ...options,
-    toolConfigs: result.summary.toolConfigs
-  };
+  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;
 }
@@ -608,6 +630,9 @@ async function scanAction(directory, options) {
     console.log(
       `  Total issues (all tools): ${import_chalk3.default.bold(String(results.summary.totalIssues || 0))}`
     );
+    console.log(
+      `  Execution time: ${import_chalk3.default.bold(((Date.now() - startTime) / 1e3).toFixed(2) + "s")}`
+    );
     let scoringResult;
     if (options.score || finalOptions.scoring?.showBreakdown) {
       scoringResult = await scoreUnified(results, finalOptions);

package/dist/cli.mjs

@@ -3,7 +3,7 @@ import {
   __require,
   analyzeUnified,
   scoreUnified
-} from "./chunk-OOQTTRPG.mjs";
+} from "./chunk-VOKP7FGM.mjs";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -370,6 +370,9 @@ async function scanAction(directory, options) {
     console.log(
       `  Total issues (all tools): ${chalk3.bold(String(results.summary.totalIssues || 0))}`
     );
+    console.log(
+      `  Execution time: ${chalk3.bold(((Date.now() - startTime) / 1e3).toFixed(2) + "s")}`
+    );
     let scoringResult;
     if (options.score || finalOptions.scoring?.showBreakdown) {
       scoringResult = await scoreUnified(results, finalOptions);

package/dist/index.js

@@ -57,17 +57,32 @@ var TOOL_PACKAGE_MAP = {
   "deps-health": "@aiready/deps",
   "change-amp": "@aiready/change-amplification"
 };
-function sanitizeToolConfig(config) {
-  if (!config || typeof config !== "object") return config;
-  const sanitized = { ...config };
-  import_core.GLOBAL_INFRA_OPTIONS.forEach((key) => {
-    if (key !== "rootDir") {
-      delete sanitized[key];
+function sanitizeConfigRecursive(obj) {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return obj;
+  const sanitized = {};
+  const infraToStrip = [
+    "rootDir",
+    "onProgress",
+    "progressCallback",
+    "streamResults",
+    "batchSize",
+    "useSmartDefaults"
+  ];
+  for (const [key, value] of Object.entries(obj)) {
+    if (infraToStrip.includes(key)) continue;
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      sanitized[key] = sanitizeConfigRecursive(value);
+    } else {
+      sanitized[key] = value;
     }
-  });
+  }
   return sanitized;
 }
+function sanitizeToolConfig(config) {
+  return sanitizeConfigRecursive(config);
+}
 async function analyzeUnified(options) {
+  await (0, import_core.initializeParsers)();
   const startTime = Date.now();
   const requestedTools = options.tools || [
     "patterns",
@@ -118,22 +133,24 @@ async function analyzeUnified(options) {
       continue;
     }
     try {
-      const sanitizedConfig = { ...options };
-      delete sanitizedConfig.onProgress;
-      delete sanitizedConfig.progressCallback;
+      const sanitizedOptions = { ...options };
+      delete sanitizedOptions.onProgress;
+      delete sanitizedOptions.progressCallback;
       const toolOptions = {
         rootDir: options.rootDir
         // Always include rootDir
       };
       [...import_core.GLOBAL_INFRA_OPTIONS, ...import_core.COMMON_FINE_TUNING_OPTIONS].forEach(
         (key) => {
-          if (key in options && key !== "toolConfigs") {
+          if (key in options && key !== "toolConfigs" && key !== "tools") {
             toolOptions[key] = options[key];
           }
         }
       );
       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[provider.id]) {
+        Object.assign(toolOptions, options.tools[provider.id]);
       } else if (options[provider.id]) {
         Object.assign(toolOptions, options[provider.id]);
       }
@@ -194,10 +211,15 @@ async function analyzeUnified(options) {
       console.error(`\u274C Error running tool '${provider.id}':`, err);
     }
   }
-  result.summary.config = {
-    ...options,
-    toolConfigs: result.summary.toolConfigs
-  };
+  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;
 }

package/dist/index.mjs

@@ -2,7 +2,7 @@ import {
   analyzeUnified,
   generateUnifiedSummary,
   scoreUnified
-} from "./chunk-OOQTTRPG.mjs";
+} from "./chunk-VOKP7FGM.mjs";
 export {
   analyzeUnified,
   generateUnifiedSummary,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/cli",
-  "version": "0.12.12",
+  "version": "0.12.16",
   "description": "Unified CLI for AIReady analysis tools",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -11,17 +11,17 @@
   "dependencies": {
     "chalk": "^5.3.0",
     "commander": "^14.0.0",
-    "@aiready/agent-grounding": "0.11.11",
-    "@aiready/consistency": "0.18.11",
-    "@aiready/core": "0.21.11",
-    "@aiready/deps": "0.11.11",
-    "@aiready/doc-drift": "0.11.11",
-    "@aiready/context-analyzer": "0.19.11",
-    "@aiready/change-amplification": "0.11.11",
-    "@aiready/pattern-detect": "0.14.11",
-    "@aiready/visualizer": "0.4.11",
-    "@aiready/testability": "0.4.11",
-    "@aiready/ai-signal-clarity": "0.11.11"
+    "@aiready/agent-grounding": "0.11.14",
+    "@aiready/consistency": "0.18.14",
+    "@aiready/context-analyzer": "0.19.14",
+    "@aiready/deps": "0.11.14",
+    "@aiready/doc-drift": "0.11.14",
+    "@aiready/change-amplification": "0.11.14",
+    "@aiready/pattern-detect": "0.14.14",
+    "@aiready/visualizer": "0.4.15",
+    "@aiready/ai-signal-clarity": "0.11.14",
+    "@aiready/testability": "0.4.14",
+    "@aiready/core": "0.21.14"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

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

@@ -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) {