@aiready/cli 0.10.3 → 0.10.6

package/dist/cli.js

@@ -87,11 +87,13 @@ async function analyzeUnified(options) {
     if (options.progressCallback) {
       options.progressCallback({ tool: "patterns", data: patternResult });
     }
-    result.patternDetect = {
+    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
@@ -109,10 +111,12 @@ async function analyzeUnified(options) {
       return b.fragmentationScore - a.fragmentationScore;
     });
     const { generateSummary: genContextSummary } = await import("@aiready/context-analyzer");
-    result.contextAnalyzer = {
+    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")) {
@@ -126,7 +130,7 @@ async function analyzeUnified(options) {
     if (options.progressCallback) {
       options.progressCallback({ tool: "consistency", data: report });
     }
-    result.consistency = {
+    result[import_core.ToolName.NamingConsistency] = {
       results: report.results ? sortBySeverity(report.results) : [],
       summary: report.summary
     };
@@ -143,11 +147,12 @@ async function analyzeUnified(options) {
     if (options.progressCallback) {
       options.progressCallback({ tool: "doc-drift", data: report });
     }
-    result.docDrift = {
-      results: report.results || [],
+    result[import_core.ToolName.DocDrift] = {
+      results: report.results || report.issues || [],
       summary: report.summary || {}
     };
-    result.summary.totalIssues += report.issues?.length || 0;
+    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");
@@ -160,11 +165,12 @@ async function analyzeUnified(options) {
     if (options.progressCallback) {
       options.progressCallback({ tool: "deps-health", data: report });
     }
-    result.dependencyHealth = {
-      results: report.results || [],
+    result[import_core.ToolName.DependencyHealth] = {
+      results: report.results || report.issues || [],
       summary: report.summary || {}
     };
-    result.summary.totalIssues += report.issues?.length || 0;
+    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");
@@ -177,13 +183,13 @@ async function analyzeUnified(options) {
     if (options.progressCallback) {
       options.progressCallback({ tool: "ai-signal-clarity", data: report });
     }
-    result.aiSignalClarity = {
+    result[import_core.ToolName.AiSignalClarity] = {
       ...report,
-      results: report.results || [],
+      results: report.results || report.issues || [],
       summary: report.summary || {}
     };
-    result.summary.totalIssues += report.results?.reduce(
-      (sum, r) => sum + (r.issues?.length || 0),
+    result.summary.totalIssues += (report.results || report.issues)?.reduce(
+      (sum, r) => sum + (r.issues?.length || 1),
       0
     ) || 0;
   }
@@ -198,12 +204,12 @@ async function analyzeUnified(options) {
     if (options.progressCallback) {
       options.progressCallback({ tool: "agent-grounding", data: report });
     }
-    result.agentGrounding = {
+    result[import_core.ToolName.AgentGrounding] = {
       ...report,
-      results: report.results || [],
+      results: report.results || report.issues || [],
       summary: report.summary || {}
     };
-    result.summary.totalIssues += report.issues?.length || 0;
+    result.summary.totalIssues += (report.issues || report.results || []).length;
   }
   if (tools.includes("testability")) {
     const { analyzeTestability } = await import("@aiready/testability");
@@ -216,12 +222,12 @@ async function analyzeUnified(options) {
     if (options.progressCallback) {
       options.progressCallback({ tool: "testability", data: report });
     }
-    result.testability = {
+    result[import_core.ToolName.TestabilityIndex] = {
       ...report,
-      results: report.results || [],
+      results: report.results || report.issues || [],
       summary: report.summary || {}
     };
-    result.summary.totalIssues += report.issues?.length || 0;
+    result.summary.totalIssues += (report.issues || report.results || []).length;
   }
   if (tools.includes("change-amplification")) {
     const { analyzeChangeAmplification } = await import("@aiready/change-amplification");
@@ -234,7 +240,7 @@ async function analyzeUnified(options) {
     if (options.progressCallback) {
       options.progressCallback({ tool: "change-amplification", data: report });
     }
-    result.changeAmplification = {
+    result[import_core.ToolName.ChangeAmplification] = {
       results: report.results || [],
       summary: report.summary || {}
     };
@@ -245,14 +251,15 @@ async function analyzeUnified(options) {
 }
 async function scoreUnified(results, options) {
   const toolScores = /* @__PURE__ */ new Map();
-  if (results.patternDetect) {
+  if (results[import_core.ToolName.PatternDetect]) {
+    const data = results[import_core.ToolName.PatternDetect];
     const { calculatePatternScore } = await import("@aiready/pattern-detect");
     try {
       const patternScore = calculatePatternScore(
-        results.patternDetect.duplicates,
-        results.patternDetect.results?.length || 0
+        data.duplicates,
+        data.results?.length || 0
       );
-      const wastedTokens = results.patternDetect.duplicates.reduce(
+      const wastedTokens = data.duplicates.reduce(
         (sum, d) => sum + (d.tokenCost || 0),
         0
       );
@@ -265,15 +272,16 @@ async function scoreUnified(results, options) {
           chattiness: 0
         }
       });
-      toolScores.set("pattern-detect", patternScore);
+      toolScores.set(import_core.ToolName.PatternDetect, patternScore);
     } catch (err) {
       void err;
     }
   }
-  if (results.contextAnalyzer) {
+  if (results[import_core.ToolName.ContextAnalyzer]) {
+    const data = results[import_core.ToolName.ContextAnalyzer];
     const { calculateContextScore } = await import("@aiready/context-analyzer");
     try {
-      const ctxSummary = results.contextAnalyzer.summary;
+      const ctxSummary = data.summary;
       const contextScore = calculateContextScore(ctxSummary);
       contextScore.tokenBudget = (0, import_core.calculateTokenBudget)({
         totalContextTokens: ctxSummary.totalTokens,
@@ -283,56 +291,62 @@ async function scoreUnified(results, options) {
           chattiness: 0
         }
       });
-      toolScores.set("context-analyzer", contextScore);
+      toolScores.set(import_core.ToolName.ContextAnalyzer, contextScore);
     } catch (err) {
       void err;
     }
   }
-  if (results.consistency) {
+  if (results[import_core.ToolName.NamingConsistency]) {
+    const data = results[import_core.ToolName.NamingConsistency];
     const { calculateConsistencyScore } = await import("@aiready/consistency");
     try {
-      const issues = results.consistency.results?.flatMap((r) => r.issues) || [];
-      const totalFiles = results.consistency.summary?.filesAnalyzed || 0;
+      const issues = data.results?.flatMap((r) => r.issues) || [];
+      const totalFiles = data.summary?.filesAnalyzed || 0;
       const consistencyScore = calculateConsistencyScore(issues, totalFiles);
-      toolScores.set("consistency", consistencyScore);
+      toolScores.set(import_core.ToolName.NamingConsistency, consistencyScore);
     } catch (err) {
       void err;
     }
   }
-  if (results.aiSignalClarity) {
+  if (results[import_core.ToolName.AiSignalClarity]) {
     const { calculateAiSignalClarityScore } = await import("@aiready/ai-signal-clarity");
     try {
-      const hrScore = calculateAiSignalClarityScore(results.aiSignalClarity);
-      toolScores.set("ai-signal-clarity", hrScore);
+      const hrScore = calculateAiSignalClarityScore(
+        results[import_core.ToolName.AiSignalClarity]
+      );
+      toolScores.set(import_core.ToolName.AiSignalClarity, hrScore);
     } catch (err) {
       void err;
     }
   }
-  if (results.agentGrounding) {
+  if (results[import_core.ToolName.AgentGrounding]) {
     const { calculateGroundingScore } = await import("@aiready/agent-grounding");
     try {
-      const agScore = calculateGroundingScore(results.agentGrounding);
-      toolScores.set("agent-grounding", agScore);
+      const agScore = calculateGroundingScore(results[import_core.ToolName.AgentGrounding]);
+      toolScores.set(import_core.ToolName.AgentGrounding, agScore);
     } catch (err) {
       void err;
     }
   }
-  if (results.testability) {
+  if (results[import_core.ToolName.TestabilityIndex]) {
     const { calculateTestabilityScore } = await import("@aiready/testability");
     try {
-      const tbScore = calculateTestabilityScore(results.testability);
-      toolScores.set("testability", tbScore);
+      const tbScore = calculateTestabilityScore(
+        results[import_core.ToolName.TestabilityIndex]
+      );
+      toolScores.set(import_core.ToolName.TestabilityIndex, tbScore);
     } catch (err) {
       void err;
     }
   }
-  if (results.docDrift) {
-    toolScores.set("doc-drift", {
-      toolName: "doc-drift",
-      score: results.docDrift.summary.score || results.docDrift.summary.totalScore || 0,
-      rawMetrics: results.docDrift.summary,
+  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: (results.docDrift.summary.recommendations || []).map(
+      recommendations: (data.summary.recommendations || []).map(
         (action) => ({
           action,
           estimatedImpact: 5,
@@ -341,30 +355,36 @@ async function scoreUnified(results, options) {
       )
     });
   }
-  if (results.dependencyHealth) {
-    toolScores.set("dependency-health", {
-      toolName: "dependency-health",
-      score: results.dependencyHealth.summary.score || 0,
-      rawMetrics: results.dependencyHealth.summary,
+  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: (results.dependencyHealth.summary.recommendations || []).map((action) => ({
-        action,
-        estimatedImpact: 5,
-        priority: "medium"
-      }))
+      recommendations: (data.summary.recommendations || []).map(
+        (action) => ({
+          action,
+          estimatedImpact: 5,
+          priority: "medium"
+        })
+      )
     });
   }
-  if (results.changeAmplification) {
-    toolScores.set("change-amplification", {
-      toolName: "change-amplification",
-      score: results.changeAmplification.summary.score || 0,
-      rawMetrics: results.changeAmplification.summary,
+  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: (results.changeAmplification.summary.recommendations || []).map((action) => ({
-        action,
-        estimatedImpact: 5,
-        priority: "medium"
-      }))
+      recommendations: (data.summary.recommendations || []).map(
+        (action) => ({
+          action,
+          estimatedImpact: 5,
+          priority: "medium"
+        })
+      )
     });
   }
   if (toolScores.size === 0) {
@@ -886,18 +906,18 @@ async function scanAction(directory, options) {
             topFiles.forEach(([file, issues], idx) => {
               const counts = issues.reduce(
                 (acc, it) => {
-                  const s = (it.severity || "info").toLowerCase();
+                  const s = (it.severity || import_core3.Severity.Info).toLowerCase();
                   acc[s] = (acc[s] || 0) + 1;
                   return acc;
                 },
                 {}
               );
               const sample = issues.find(
-                (it) => it.severity === "critical" || it.severity === "major"
+                (it) => it.severity === import_core3.Severity.Critical || it.severity === import_core3.Severity.Major
               ) || issues[0];
               const sampleMsg = sample ? ` \u2014 ${sample.message}` : "";
               console.log(
-                `   ${idx + 1}. ${file} \u2014 ${issues.length} issue(s) (critical:${counts.critical || 0} major:${counts.major || 0} minor:${counts.minor || 0} info:${counts.info || 0})${sampleMsg}`
+                `   ${idx + 1}. ${file} \u2014 ${issues.length} issue(s) (critical:${counts[import_core3.Severity.Critical] || 0} major:${counts[import_core3.Severity.Major] || 0} minor:${counts[import_core3.Severity.Minor] || 0} info:${counts[import_core3.Severity.Info] || 0})${sampleMsg}`
               );
             });
             const remaining = files.length - topFiles.length;
@@ -972,25 +992,25 @@ async function scanAction(directory, options) {
     console.log(
       `  Total issues (all tools): ${import_chalk3.default.bold(String(results.summary.totalIssues || 0))}`
     );
-    if (results.patternDetect) {
+    if (results[import_core3.ToolName.PatternDetect]) {
       console.log(
-        `  Duplicate patterns found: ${import_chalk3.default.bold(String(results.patternDetect.duplicates?.length || 0))}`
+        `  Duplicate patterns found: ${import_chalk3.default.bold(String(results[import_core3.ToolName.PatternDetect].duplicates?.length || 0))}`
       );
       console.log(
-        `  Pattern files with issues: ${import_chalk3.default.bold(String(results.patternDetect.results.length || 0))}`
+        `  Pattern files with issues: ${import_chalk3.default.bold(String(results[import_core3.ToolName.PatternDetect].results.length || 0))}`
       );
     }
-    if (results.contextAnalyzer)
+    if (results[import_core3.ToolName.ContextAnalyzer])
       console.log(
-        `  Context issues: ${import_chalk3.default.bold(String(results.contextAnalyzer.results.length || 0))}`
+        `  Context issues: ${import_chalk3.default.bold(String(results[import_core3.ToolName.ContextAnalyzer].results.length || 0))}`
       );
-    if (results.consistency)
+    if (results[import_core3.ToolName.NamingConsistency])
       console.log(
-        `  Consistency issues: ${import_chalk3.default.bold(String(results.consistency.summary?.totalIssues || 0))}`
+        `  Consistency issues: ${import_chalk3.default.bold(String(results[import_core3.ToolName.NamingConsistency].summary?.totalIssues || 0))}`
       );
-    if (results.changeAmplification)
+    if (results[import_core3.ToolName.ChangeAmplification])
       console.log(
-        `  Change amplification: ${import_chalk3.default.bold(String(results.changeAmplification.summary?.score || 0))}/100`
+        `  Change amplification: ${import_chalk3.default.bold(String(results[import_core3.ToolName.ChangeAmplification].summary?.score || 0))}/100`
       );
     console.log(import_chalk3.default.cyan("===========================\n"));
     const elapsedTime = (0, import_core3.getElapsedTime)(startTime);
@@ -1130,6 +1150,78 @@ async function scanAction(directory, options) {
         }
       }
     }
+    const mapToUnifiedReport = (res, scoring) => {
+      const allResults = [];
+      let totalFilesSet = /* @__PURE__ */ new Set();
+      let criticalCount = 0;
+      let majorCount = 0;
+      const collect = (spokeRes, defaultType = import_core3.IssueType.AiSignalClarity) => {
+        if (!spokeRes || !spokeRes.results) return;
+        spokeRes.results.forEach((r) => {
+          const fileName = r.fileName || r.file || "unknown";
+          totalFilesSet.add(fileName);
+          const normalizedResult = {
+            fileName,
+            issues: [],
+            metrics: r.metrics || { tokenCost: r.tokenCost || 0 }
+          };
+          if (r.issues && Array.isArray(r.issues)) {
+            r.issues.forEach((i) => {
+              const normalizedIssue = typeof i === "string" ? {
+                type: defaultType,
+                severity: r.severity || import_core3.Severity.Info,
+                message: i,
+                location: { file: fileName, line: 1 }
+              } : {
+                type: i.type || defaultType,
+                severity: i.severity || r.severity || import_core3.Severity.Info,
+                message: i.message || String(i),
+                location: i.location || { file: fileName, line: 1 },
+                suggestion: i.suggestion
+              };
+              if (normalizedIssue.severity === import_core3.Severity.Critical || normalizedIssue.severity === "critical")
+                criticalCount++;
+              if (normalizedIssue.severity === import_core3.Severity.Major || normalizedIssue.severity === "major")
+                majorCount++;
+              normalizedResult.issues.push(normalizedIssue);
+            });
+          } else if (r.severity) {
+            const normalizedIssue = {
+              type: defaultType,
+              severity: r.severity,
+              message: r.message || "General issue",
+              location: { file: fileName, line: 1 }
+            };
+            if (normalizedIssue.severity === import_core3.Severity.Critical || normalizedIssue.severity === "critical")
+              criticalCount++;
+            if (normalizedIssue.severity === import_core3.Severity.Major || normalizedIssue.severity === "major")
+              majorCount++;
+            normalizedResult.issues.push(normalizedIssue);
+          }
+          allResults.push(normalizedResult);
+        });
+      };
+      collect(res[import_core3.ToolName.PatternDetect], import_core3.IssueType.DuplicatePattern);
+      collect(res[import_core3.ToolName.ContextAnalyzer], import_core3.IssueType.ContextFragmentation);
+      collect(res[import_core3.ToolName.NamingConsistency], import_core3.IssueType.NamingInconsistency);
+      collect(res[import_core3.ToolName.DocDrift], import_core3.IssueType.DocDrift);
+      collect(res[import_core3.ToolName.DependencyHealth], import_core3.IssueType.DependencyHealth);
+      collect(res[import_core3.ToolName.AiSignalClarity], import_core3.IssueType.AiSignalClarity);
+      collect(res[import_core3.ToolName.AgentGrounding], import_core3.IssueType.AgentNavigationFailure);
+      collect(res[import_core3.ToolName.TestabilityIndex], import_core3.IssueType.LowTestability);
+      collect(res[import_core3.ToolName.ChangeAmplification], import_core3.IssueType.ChangeAmplification);
+      return {
+        ...res,
+        results: allResults,
+        summary: {
+          ...res.summary,
+          totalFiles: totalFilesSet.size,
+          criticalIssues: criticalCount,
+          majorIssues: majorCount
+        },
+        scoring
+      };
+    };
     const outputFormat = options.output || finalOptions.output?.format || "console";
     const userOutputFile = options.outputFile || finalOptions.output?.file;
     if (outputFormat === "json") {
@@ -1141,8 +1233,7 @@ async function scanAction(directory, options) {
         resolvedDir
       );
       const outputData = {
-        ...results,
-        scoring: scoringResult,
+        ...mapToUnifiedReport(results, scoringResult),
         repository: repoMetadata
       };
       (0, import_core3.handleJSONOutput)(
@@ -1167,8 +1258,7 @@ async function scanAction(directory, options) {
         resolvedDir
       );
       const outputData = {
-        ...results,
-        scoring: scoringResult,
+        ...mapToUnifiedReport(results, scoringResult),
         repository: repoMetadata
       };
       try {
@@ -1209,9 +1299,9 @@ async function scanAction(directory, options) {
             `::notice::AI Readiness Score: ${scoringResult.overall}/100 (threshold: ${threshold})`
           );
         }
-        if (results.patternDetect) {
-          const criticalPatterns = results.patternDetect.results.flatMap(
-            (p) => p.issues.filter((i) => i.severity === "critical")
+        if (results[import_core3.ToolName.PatternDetect]) {
+          const criticalPatterns = results[import_core3.ToolName.PatternDetect].results.flatMap(
+            (p) => p.issues.filter((i) => i.severity === import_core3.Severity.Critical)
           );
           criticalPatterns.slice(0, 10).forEach((issue) => {
             console.log(
@@ -1231,25 +1321,25 @@ async function scanAction(directory, options) {
         const minSeverity = severityLevels[failOnLevel] || 4;
         let criticalCount = 0;
         let majorCount = 0;
-        if (results.patternDetect) {
-          results.patternDetect.results.forEach((p) => {
+        if (results[import_core3.ToolName.PatternDetect]) {
+          results[import_core3.ToolName.PatternDetect].results.forEach((p) => {
             p.issues.forEach((i) => {
-              if (i.severity === "critical") criticalCount++;
-              if (i.severity === "major") majorCount++;
+              if (i.severity === import_core3.Severity.Critical) criticalCount++;
+              if (i.severity === import_core3.Severity.Major) majorCount++;
             });
           });
         }
-        if (results.contextAnalyzer) {
-          results.contextAnalyzer.results.forEach((c) => {
-            if (c.severity === "critical") criticalCount++;
-            if (c.severity === "major") majorCount++;
+        if (results[import_core3.ToolName.ContextAnalyzer]) {
+          results[import_core3.ToolName.ContextAnalyzer].results.forEach((c) => {
+            if (c.severity === import_core3.Severity.Critical) criticalCount++;
+            if (c.severity === import_core3.Severity.Major) majorCount++;
           });
         }
-        if (results.consistency) {
-          results.consistency.results.forEach((r) => {
+        if (results[import_core3.ToolName.NamingConsistency]) {
+          results[import_core3.ToolName.NamingConsistency].results.forEach((r) => {
             r.issues?.forEach((i) => {
-              if (i.severity === "critical") criticalCount++;
-              if (i.severity === "major") majorCount++;
+              if (i.severity === import_core3.Severity.Critical) criticalCount++;
+              if (i.severity === import_core3.Severity.Major) majorCount++;
             });
           });
         }