@aiready/cli 0.10.6 → 0.12.0

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -35,357 +25,137 @@ __export(index_exports, {
   scoreUnified: () => scoreUnified
 });
 module.exports = __toCommonJS(index_exports);
-var import_pattern_detect = require("@aiready/pattern-detect");
-var import_context_analyzer = require("@aiready/context-analyzer");
-var import_consistency = require("@aiready/consistency");
 var import_core = require("@aiready/core");
-var severityOrder = {
-  critical: 4,
-  major: 3,
-  minor: 2,
-  info: 1
+var TOOL_PACKAGE_MAP = {
+  [import_core.ToolName.PatternDetect]: "@aiready/pattern-detect",
+  [import_core.ToolName.ContextAnalyzer]: "@aiready/context-analyzer",
+  [import_core.ToolName.NamingConsistency]: "@aiready/consistency",
+  [import_core.ToolName.AiSignalClarity]: "@aiready/ai-signal-clarity",
+  [import_core.ToolName.AgentGrounding]: "@aiready/agent-grounding",
+  [import_core.ToolName.TestabilityIndex]: "@aiready/testability",
+  [import_core.ToolName.DocDrift]: "@aiready/doc-drift",
+  [import_core.ToolName.DependencyHealth]: "@aiready/deps",
+  [import_core.ToolName.ChangeAmplification]: "@aiready/change-amplification",
+  // Aliases handled by registry
+  patterns: "@aiready/pattern-detect",
+  context: "@aiready/context-analyzer",
+  consistency: "@aiready/consistency"
 };
-function sortBySeverity(results) {
-  return results.map((file) => {
-    const sortedIssues = [...file.issues].sort((a, b) => {
-      const severityDiff = (severityOrder[b.severity] || 0) - (severityOrder[a.severity] || 0);
-      if (severityDiff !== 0) return severityDiff;
-      return (a.location?.line || 0) - (b.location?.line || 0);
-    });
-    return { ...file, issues: sortedIssues };
-  }).sort((a, b) => {
-    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;
-    }
-    if (a.issues.length !== b.issues.length) {
-      return b.issues.length - a.issues.length;
-    }
-    return a.fileName.localeCompare(b.fileName);
-  });
-}
 async function analyzeUnified(options) {
   const startTime = Date.now();
-  const tools = options.tools || ["patterns", "context", "consistency"];
+  const requestedTools = options.tools || [
+    "patterns",
+    "context",
+    "consistency"
+  ];
   const result = {
     summary: {
       totalIssues: 0,
-      toolsRun: tools,
+      toolsRun: [],
       executionTime: 0
     }
   };
-  if (tools.includes("patterns")) {
-    const patternResult = await (0, import_pattern_detect.analyzePatterns)(options);
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "patterns", data: patternResult });
-    }
-    const output = {
-      results: sortBySeverity(patternResult.results),
-      summary: patternResult.summary || {},
-      duplicates: patternResult.duplicates || []
-    };
-    result[import_core.ToolName.PatternDetect] = output;
-    result.patternDetect = output;
-    result.summary.totalIssues += patternResult.results.reduce(
-      (sum, file) => sum + file.issues.length,
-      0
-    );
-  }
-  if (tools.includes("context")) {
-    const contextResults = await (0, import_context_analyzer.analyzeContext)(options);
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "context", data: contextResults });
-    }
-    const sorted = contextResults.sort((a, b) => {
-      const severityDiff = (severityOrder[b.severity] || 0) - (severityOrder[a.severity] || 0);
-      if (severityDiff !== 0) return severityDiff;
-      if (a.tokenCost !== b.tokenCost) return b.tokenCost - a.tokenCost;
-      return b.fragmentationScore - a.fragmentationScore;
-    });
-    const { generateSummary: genContextSummary } = await import("@aiready/context-analyzer");
-    const output = {
-      results: sorted,
-      summary: genContextSummary(sorted)
-    };
-    result[import_core.ToolName.ContextAnalyzer] = output;
-    result.contextAnalyzer = output;
-    result.summary.totalIssues += sorted.length;
-  }
-  if (tools.includes("consistency")) {
-    const consistencyOptions = {
-      rootDir: options.rootDir,
-      include: options.include,
-      exclude: options.exclude,
-      ...options.consistency || {}
-    };
-    const report = await (0, import_consistency.analyzeConsistency)(consistencyOptions);
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "consistency", data: report });
-    }
-    result[import_core.ToolName.NamingConsistency] = {
-      results: report.results ? sortBySeverity(report.results) : [],
-      summary: report.summary
-    };
-    result.summary.totalIssues += report.summary.totalIssues;
-  }
-  if (tools.includes("doc-drift")) {
-    const { analyzeDocDrift } = await import("@aiready/doc-drift");
-    const report = await analyzeDocDrift({
-      rootDir: options.rootDir,
-      include: options.include,
-      exclude: options.exclude,
-      onProgress: options.onProgress
-    });
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "doc-drift", data: report });
-    }
-    result[import_core.ToolName.DocDrift] = {
-      results: report.results || report.issues || [],
-      summary: report.summary || {}
-    };
-    const issueCount = report.issues?.length || (report.results ? report.results.length : 0);
-    result.summary.totalIssues += issueCount;
-  }
-  if (tools.includes("deps-health")) {
-    const { analyzeDeps } = await import("@aiready/deps");
-    const report = await analyzeDeps({
-      rootDir: options.rootDir,
-      include: options.include,
-      exclude: options.exclude,
-      onProgress: options.onProgress
-    });
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "deps-health", data: report });
-    }
-    result[import_core.ToolName.DependencyHealth] = {
-      results: report.results || report.issues || [],
-      summary: report.summary || {}
-    };
-    const issueCount = report.issues?.length || (report.results ? report.results.length : 0);
-    result.summary.totalIssues += issueCount;
-  }
-  if (tools.includes("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: "ai-signal-clarity", data: report });
-    }
-    result[import_core.ToolName.AiSignalClarity] = {
-      ...report,
-      results: report.results || report.issues || [],
-      summary: report.summary || {}
-    };
-    result.summary.totalIssues += (report.results || report.issues)?.reduce(
-      (sum, r) => sum + (r.issues?.length || 1),
-      0
-    ) || 0;
-  }
-  if (tools.includes("agent-grounding")) {
-    const { analyzeAgentGrounding } = await import("@aiready/agent-grounding");
-    const report = await analyzeAgentGrounding({
-      rootDir: options.rootDir,
-      include: options.include,
-      exclude: options.exclude,
-      onProgress: options.onProgress
-    });
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "agent-grounding", data: report });
-    }
-    result[import_core.ToolName.AgentGrounding] = {
-      ...report,
-      results: report.results || report.issues || [],
-      summary: report.summary || {}
-    };
-    result.summary.totalIssues += (report.issues || report.results || []).length;
-  }
-  if (tools.includes("testability")) {
-    const { analyzeTestability } = await import("@aiready/testability");
-    const report = await analyzeTestability({
-      rootDir: options.rootDir,
-      include: options.include,
-      exclude: options.exclude,
-      onProgress: options.onProgress
-    });
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "testability", data: report });
+  for (const toolName of requestedTools) {
+    let provider = import_core.ToolRegistry.find(toolName);
+    if (!provider) {
+      const packageName = TOOL_PACKAGE_MAP[toolName] || (toolName.startsWith("@aiready/") ? toolName : `@aiready/${toolName}`);
+      try {
+        await import(packageName);
+        provider = import_core.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
+        );
+      }
     }
-    result[import_core.ToolName.TestabilityIndex] = {
-      ...report,
-      results: report.results || report.issues || [],
-      summary: report.summary || {}
-    };
-    result.summary.totalIssues += (report.issues || report.results || []).length;
-  }
-  if (tools.includes("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: "change-amplification", data: report });
+    if (!provider) {
+      console.warn(
+        `\u26A0\uFE0F  Warning: Tool provider for '${toolName}' not found. Skipping.`
+      );
+      continue;
     }
-    result[import_core.ToolName.ChangeAmplification] = {
-      results: report.results || [],
-      summary: report.summary || {}
-    };
-    result.summary.totalIssues += report.summary?.totalIssues || 0;
-  }
-  result.summary.executionTime = Date.now() - startTime;
-  return result;
-}
-async function scoreUnified(results, options) {
-  const toolScores = /* @__PURE__ */ new Map();
-  if (results[import_core.ToolName.PatternDetect]) {
-    const data = results[import_core.ToolName.PatternDetect];
-    const { calculatePatternScore } = await import("@aiready/pattern-detect");
     try {
-      const patternScore = calculatePatternScore(
-        data.duplicates,
-        data.results?.length || 0
-      );
-      const wastedTokens = data.duplicates.reduce(
-        (sum, d) => sum + (d.tokenCost || 0),
+      const output = await provider.analyze(options);
+      if (options.progressCallback) {
+        options.progressCallback({ tool: provider.id, data: output });
+      }
+      result[provider.id] = output;
+      result.summary.toolsRun.push(provider.id);
+      const issueCount = output.results.reduce(
+        (sum, file) => sum + (file.issues?.length || 0),
         0
       );
-      patternScore.tokenBudget = (0, import_core.calculateTokenBudget)({
-        totalContextTokens: wastedTokens * 2,
-        // Estimated context
-        wastedTokens: {
-          duplication: wastedTokens,
-          fragmentation: 0,
-          chattiness: 0
-        }
-      });
-      toolScores.set(import_core.ToolName.PatternDetect, patternScore);
-    } catch (err) {
-      void err;
-    }
-  }
-  if (results[import_core.ToolName.ContextAnalyzer]) {
-    const data = results[import_core.ToolName.ContextAnalyzer];
-    const { calculateContextScore } = await import("@aiready/context-analyzer");
-    try {
-      const ctxSummary = data.summary;
-      const contextScore = calculateContextScore(ctxSummary);
-      contextScore.tokenBudget = (0, import_core.calculateTokenBudget)({
-        totalContextTokens: ctxSummary.totalTokens,
-        wastedTokens: {
-          duplication: 0,
-          fragmentation: ctxSummary.totalPotentialSavings || 0,
-          chattiness: 0
+      result.summary.totalIssues += issueCount;
+      if (provider.alias && Array.isArray(provider.alias)) {
+        for (const alias of provider.alias) {
+          if (!result[alias]) {
+            result[alias] = output;
+          }
         }
-      });
-      toolScores.set(import_core.ToolName.ContextAnalyzer, contextScore);
-    } catch (err) {
-      void err;
-    }
-  }
-  if (results[import_core.ToolName.NamingConsistency]) {
-    const data = results[import_core.ToolName.NamingConsistency];
-    const { calculateConsistencyScore } = await import("@aiready/consistency");
-    try {
-      const issues = data.results?.flatMap((r) => r.issues) || [];
-      const totalFiles = data.summary?.filesAnalyzed || 0;
-      const consistencyScore = calculateConsistencyScore(issues, totalFiles);
-      toolScores.set(import_core.ToolName.NamingConsistency, consistencyScore);
-    } catch (err) {
-      void err;
-    }
-  }
-  if (results[import_core.ToolName.AiSignalClarity]) {
-    const { calculateAiSignalClarityScore } = await import("@aiready/ai-signal-clarity");
-    try {
-      const hrScore = calculateAiSignalClarityScore(
-        results[import_core.ToolName.AiSignalClarity]
+      }
+      const camelCaseId = provider.id.replace(
+        /-([a-z])/g,
+        (g) => g[1].toUpperCase()
       );
-      toolScores.set(import_core.ToolName.AiSignalClarity, hrScore);
-    } catch (err) {
-      void err;
-    }
-  }
-  if (results[import_core.ToolName.AgentGrounding]) {
-    const { calculateGroundingScore } = await import("@aiready/agent-grounding");
-    try {
-      const agScore = calculateGroundingScore(results[import_core.ToolName.AgentGrounding]);
-      toolScores.set(import_core.ToolName.AgentGrounding, agScore);
+      if (camelCaseId !== provider.id && !result[camelCaseId]) {
+        result[camelCaseId] = output;
+      }
     } catch (err) {
-      void err;
+      console.error(`\u274C Error running tool '${provider.id}':`, err);
     }
   }
-  if (results[import_core.ToolName.TestabilityIndex]) {
-    const { calculateTestabilityScore } = await import("@aiready/testability");
+  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 = import_core.ToolRegistry.get(toolId);
+    if (!provider) continue;
+    const output = results[toolId];
+    if (!output) continue;
     try {
-      const tbScore = calculateTestabilityScore(
-        results[import_core.ToolName.TestabilityIndex]
-      );
-      toolScores.set(import_core.ToolName.TestabilityIndex, tbScore);
+      const toolScore = provider.score(output, options);
+      if (!toolScore.tokenBudget) {
+        if (toolId === import_core.ToolName.PatternDetect && output.duplicates) {
+          const wastedTokens = output.duplicates.reduce(
+            (sum, d) => sum + (d.tokenCost || 0),
+            0
+          );
+          toolScore.tokenBudget = (0, import_core.calculateTokenBudget)({
+            totalContextTokens: wastedTokens * 2,
+            wastedTokens: {
+              duplication: wastedTokens,
+              fragmentation: 0,
+              chattiness: 0
+            }
+          });
+        } else if (toolId === import_core.ToolName.ContextAnalyzer && output.summary) {
+          toolScore.tokenBudget = (0, import_core.calculateTokenBudget)({
+            totalContextTokens: output.summary.totalTokens,
+            wastedTokens: {
+              duplication: 0,
+              fragmentation: output.summary.totalPotentialSavings || 0,
+              chattiness: 0
+            }
+          });
+        }
+      }
+      toolScores.set(toolId, toolScore);
     } catch (err) {
-      void err;
+      console.error(`\u274C Error scoring tool '${toolId}':`, err);
     }
   }
-  if (results[import_core.ToolName.DocDrift]) {
-    const data = results[import_core.ToolName.DocDrift];
-    toolScores.set(import_core.ToolName.DocDrift, {
-      toolName: import_core.ToolName.DocDrift,
-      score: data.summary.score || data.summary.totalScore || 0,
-      rawMetrics: data.summary,
-      factors: [],
-      recommendations: (data.summary.recommendations || []).map(
-        (action) => ({
-          action,
-          estimatedImpact: 5,
-          priority: "medium"
-        })
-      )
-    });
-  }
-  if (results[import_core.ToolName.DependencyHealth]) {
-    const data = results[import_core.ToolName.DependencyHealth];
-    toolScores.set(import_core.ToolName.DependencyHealth, {
-      toolName: import_core.ToolName.DependencyHealth,
-      score: data.summary.score || 0,
-      rawMetrics: data.summary,
-      factors: [],
-      recommendations: (data.summary.recommendations || []).map(
-        (action) => ({
-          action,
-          estimatedImpact: 5,
-          priority: "medium"
-        })
-      )
-    });
-  }
-  if (results[import_core.ToolName.ChangeAmplification]) {
-    const data = results[import_core.ToolName.ChangeAmplification];
-    toolScores.set(import_core.ToolName.ChangeAmplification, {
-      toolName: import_core.ToolName.ChangeAmplification,
-      score: data.summary.score || 0,
-      rawMetrics: data.summary,
-      factors: [],
-      recommendations: (data.summary.recommendations || []).map(
-        (action) => ({
-          action,
-          estimatedImpact: 5,
-          priority: "medium"
-        })
-      )
-    });
-  }
   if (toolScores.size === 0) {
     return {
       overall: 0,
@@ -416,41 +186,16 @@ function generateUnifiedSummary(result) {
   output += `   Execution time: ${(summary.executionTime / 1e3).toFixed(2)}s
 
 `;
-  if (result[import_core.ToolName.PatternDetect]) {
-    output += `\u{1F50D} Pattern Analysis: ${result[import_core.ToolName.PatternDetect].results.length} issues
-`;
-  }
-  if (result[import_core.ToolName.ContextAnalyzer]) {
-    output += `\u{1F9E0} Context Analysis: ${result[import_core.ToolName.ContextAnalyzer].results.length} issues
-`;
-  }
-  if (result[import_core.ToolName.NamingConsistency]) {
-    output += `\u{1F3F7}\uFE0F Consistency Analysis: ${result[import_core.ToolName.NamingConsistency].summary.totalIssues} issues
-`;
-  }
-  if (result[import_core.ToolName.DocDrift]) {
-    output += `\u{1F4DD} Doc Drift Analysis: ${result[import_core.ToolName.DocDrift].results?.length || 0} issues
-`;
-  }
-  if (result[import_core.ToolName.DependencyHealth]) {
-    output += `\u{1F4E6} Dependency Health: ${result[import_core.ToolName.DependencyHealth].results?.length || 0} issues
-`;
-  }
-  if (result[import_core.ToolName.AiSignalClarity]) {
-    output += `\u{1F9E0} AI Signal Clarity: ${result[import_core.ToolName.AiSignalClarity].summary?.totalSignals || 0} signals
-`;
-  }
-  if (result[import_core.ToolName.AgentGrounding]) {
-    output += `\u{1F9ED} Agent Grounding: ${result[import_core.ToolName.AgentGrounding].results?.length || 0} issues
-`;
-  }
-  if (result[import_core.ToolName.TestabilityIndex]) {
-    output += `\u{1F9EA} Testability Index: ${result[import_core.ToolName.TestabilityIndex].results?.length || 0} issues
-`;
-  }
-  if (result[import_core.ToolName.ChangeAmplification]) {
-    output += `\u{1F4A5} Change Amplification: ${result[import_core.ToolName.ChangeAmplification].summary?.totalIssues || 0} cascading risks
+  for (const provider of import_core.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;
 }

package/dist/index.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/cli",
-  "version": "0.10.6",
+  "version": "0.12.0",
   "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/core": "0.19.5",
-    "@aiready/agent-grounding": "0.9.5",
-    "@aiready/consistency": "0.16.5",
-    "@aiready/context-analyzer": "0.17.5",
-    "@aiready/deps": "0.9.5",
-    "@aiready/ai-signal-clarity": "0.9.5",
-    "@aiready/change-amplification": "0.9.5",
-    "@aiready/visualizer": "0.2.6",
-    "@aiready/doc-drift": "0.9.5",
-    "@aiready/pattern-detect": "0.12.5",
-    "@aiready/testability": "0.2.5"
+    "@aiready/agent-grounding": "0.11.0",
+    "@aiready/context-analyzer": "0.19.0",
+    "@aiready/doc-drift": "0.11.0",
+    "@aiready/consistency": "0.18.0",
+    "@aiready/core": "0.21.0",
+    "@aiready/change-amplification": "0.11.0",
+    "@aiready/pattern-detect": "0.14.0",
+    "@aiready/ai-signal-clarity": "0.11.0",
+    "@aiready/testability": "0.4.0",
+    "@aiready/deps": "0.11.0",
+    "@aiready/visualizer": "0.4.0"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",