@aiready/cli 0.9.47 → 0.10.0

package/.turbo/turbo-build.log

@@ -10,7 +10,7 @@
 CJS Build start
 ESM Build start
 
-[11:46:21 pm]  WARN  ▲ [WARNING] "import.meta" is not available with the "cjs" output format and will be empty [empty-import-meta]
+[4:11:53 PM]  WARN  ▲ [WARNING] "import.meta" is not available with the "cjs" output format and will be empty [empty-import-meta]
 
     src/cli.ts:25:31:
       25 │   return dirname(fileURLToPath(import.meta.url));
@@ -20,10 +20,10 @@
 
 
 
-CJS dist/cli.js   89.07 KB
-CJS dist/index.js 13.89 KB
-CJS ⚡️ Build success in 40ms
 ESM dist/index.mjs          170.00 B
-ESM dist/cli.mjs            73.70 KB
-ESM dist/chunk-6FOVC2OE.mjs 12.49 KB
-ESM ⚡️ Build success in 40ms
+ESM dist/chunk-EQ2HQSTJ.mjs 13.39 KB
+ESM dist/cli.mjs            73.88 KB
+ESM ⚡️ Build success in 29ms
+CJS dist/index.js 14.79 KB
+CJS dist/cli.js   90.07 KB
+CJS ⚡️ Build success in 29ms

package/.turbo/turbo-test.log

@@ -6,12 +6,11 @@
 [?25l
  RUN  v4.0.18 /Users/pengcao/projects/aiready/packages/cli
 
- ✓ src/__tests__/cli.test.ts (3 tests) 3ms
- ✓ dist/__tests__/cli.test.js (3 tests) 3ms
+ ✓ src/__tests__/cli.test.ts (3 tests) 2ms
 
- Test Files  2 passed (2)
-      Tests  6 passed (6)
-   Start at  23:46:53
-   Duration  1.91s (transform 370ms, setup 0ms, import 2.37s, tests 6ms, environment 0ms)
+ Test Files  1 passed (1)
+      Tests  3 passed (3)
+   Start at  16:12:25
+   Duration  327ms (transform 78ms, setup 0ms, import 243ms, tests 2ms, environment 0ms)
 
 [?25h

package/dist/{chunk-6FOVC2OE.mjs → chunk-EQ2HQSTJ.mjs}

@@ -60,8 +60,11 @@ async function analyzeUnified(options) {
     if (options.progressCallback) {
       options.progressCallback({ tool: "patterns", data: patternResult });
     }
-    result.patterns = sortBySeverity(patternResult.results);
-    result.duplicates = patternResult.duplicates;
+    result.patternDetect = {
+      results: sortBySeverity(patternResult.results),
+      summary: patternResult.summary || {},
+      duplicates: patternResult.duplicates || []
+    };
     result.summary.totalIssues += patternResult.results.reduce(
       (sum, file) => sum + file.issues.length,
       0
@@ -72,13 +75,18 @@ async function analyzeUnified(options) {
     if (options.progressCallback) {
       options.progressCallback({ tool: "context", data: contextResults });
     }
-    result.context = contextResults.sort((a, b) => {
+    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;
     });
-    result.summary.totalIssues += result.context?.length || 0;
+    const { generateSummary: genContextSummary } = await import("@aiready/context-analyzer");
+    result.contextAnalyzer = {
+      results: sorted,
+      summary: genContextSummary(sorted)
+    };
+    result.summary.totalIssues += sorted.length;
   }
   if (tools.includes("consistency")) {
     const consistencyOptions = {
@@ -91,10 +99,10 @@ async function analyzeUnified(options) {
     if (options.progressCallback) {
       options.progressCallback({ tool: "consistency", data: report });
     }
-    if (report.results) {
-      report.results = sortBySeverity(report.results);
-    }
-    result.consistency = report;
+    result.consistency = {
+      results: report.results ? sortBySeverity(report.results) : [],
+      summary: report.summary
+    };
     result.summary.totalIssues += report.summary.totalIssues;
   }
   if (tools.includes("doc-drift")) {
@@ -108,7 +116,10 @@ async function analyzeUnified(options) {
     if (options.progressCallback) {
       options.progressCallback({ tool: "doc-drift", data: report });
     }
-    result.docDrift = report;
+    result.docDrift = {
+      results: report.results || [],
+      summary: report.summary || {}
+    };
     result.summary.totalIssues += report.issues?.length || 0;
   }
   if (tools.includes("deps-health")) {
@@ -122,10 +133,13 @@ async function analyzeUnified(options) {
     if (options.progressCallback) {
       options.progressCallback({ tool: "deps-health", data: report });
     }
-    result.deps = report;
+    result.dependencyHealth = {
+      results: report.results || [],
+      summary: report.summary || {}
+    };
     result.summary.totalIssues += report.issues?.length || 0;
   }
-  if (tools.includes("aiSignalClarity")) {
+  if (tools.includes("ai-signal-clarity")) {
     const { analyzeAiSignalClarity } = await import("@aiready/ai-signal-clarity");
     const report = await analyzeAiSignalClarity({
       rootDir: options.rootDir,
@@ -134,15 +148,18 @@ async function analyzeUnified(options) {
       onProgress: options.onProgress
     });
     if (options.progressCallback) {
-      options.progressCallback({ tool: "aiSignalClarity", data: report });
+      options.progressCallback({ tool: "ai-signal-clarity", data: report });
     }
-    result.aiSignalClarity = report;
+    result.aiSignalClarity = {
+      results: report.results || [],
+      summary: report.summary || {}
+    };
     result.summary.totalIssues += report.results?.reduce(
       (sum, r) => sum + (r.issues?.length || 0),
       0
     ) || 0;
   }
-  if (tools.includes("grounding")) {
+  if (tools.includes("agent-grounding")) {
     const { analyzeAgentGrounding } = await import("@aiready/agent-grounding");
     const report = await analyzeAgentGrounding({
       rootDir: options.rootDir,
@@ -151,9 +168,12 @@ async function analyzeUnified(options) {
       onProgress: options.onProgress
     });
     if (options.progressCallback) {
-      options.progressCallback({ tool: "grounding", data: report });
+      options.progressCallback({ tool: "agent-grounding", data: report });
     }
-    result.grounding = report;
+    result.agentGrounding = {
+      results: report.results || [],
+      summary: report.summary || {}
+    };
     result.summary.totalIssues += report.issues?.length || 0;
   }
   if (tools.includes("testability")) {
@@ -167,10 +187,13 @@ async function analyzeUnified(options) {
     if (options.progressCallback) {
       options.progressCallback({ tool: "testability", data: report });
     }
-    result.testability = report;
+    result.testability = {
+      results: report.results || [],
+      summary: report.summary || {}
+    };
     result.summary.totalIssues += report.issues?.length || 0;
   }
-  if (tools.includes("changeAmplification")) {
+  if (tools.includes("change-amplification")) {
     const { analyzeChangeAmplification } = await import("@aiready/change-amplification");
     const report = await analyzeChangeAmplification({
       rootDir: options.rootDir,
@@ -179,9 +202,12 @@ async function analyzeUnified(options) {
       onProgress: options.onProgress
     });
     if (options.progressCallback) {
-      options.progressCallback({ tool: "changeAmplification", data: report });
+      options.progressCallback({ tool: "change-amplification", data: report });
     }
-    result.changeAmplification = report;
+    result.changeAmplification = {
+      results: report.results || [],
+      summary: report.summary || {}
+    };
     result.summary.totalIssues += report.summary?.totalIssues || 0;
   }
   result.summary.executionTime = Date.now() - startTime;
@@ -189,14 +215,14 @@ async function analyzeUnified(options) {
 }
 async function scoreUnified(results, options) {
   const toolScores = /* @__PURE__ */ new Map();
-  if (results.duplicates) {
+  if (results.patternDetect) {
     const { calculatePatternScore } = await import("@aiready/pattern-detect");
     try {
       const patternScore = calculatePatternScore(
-        results.duplicates,
-        results.patterns?.length || 0
+        results.patternDetect.duplicates,
+        results.patternDetect.results?.length || 0
       );
-      const wastedTokens = results.duplicates.reduce(
+      const wastedTokens = results.patternDetect.duplicates.reduce(
         (sum, d) => sum + (d.tokenCost || 0),
         0
       );
@@ -214,10 +240,10 @@ async function scoreUnified(results, options) {
       void err;
     }
   }
-  if (results.context) {
-    const { generateSummary: genContextSummary, calculateContextScore } = await import("@aiready/context-analyzer");
+  if (results.contextAnalyzer) {
+    const { calculateContextScore } = await import("@aiready/context-analyzer");
     try {
-      const ctxSummary = genContextSummary(results.context);
+      const ctxSummary = results.contextAnalyzer.summary;
       const contextScore = calculateContextScore(ctxSummary);
       contextScore.tokenBudget = calculateTokenBudget({
         totalContextTokens: ctxSummary.totalTokens,
@@ -252,10 +278,10 @@ async function scoreUnified(results, options) {
       void err;
     }
   }
-  if (results.grounding) {
+  if (results.agentGrounding) {
     const { calculateGroundingScore } = await import("@aiready/agent-grounding");
     try {
-      const agScore = calculateGroundingScore(results.grounding);
+      const agScore = calculateGroundingScore(results.agentGrounding);
       toolScores.set("agent-grounding", agScore);
     } catch (err) {
       void err;
@@ -273,10 +299,10 @@ async function scoreUnified(results, options) {
   if (results.docDrift) {
     toolScores.set("doc-drift", {
       toolName: "doc-drift",
-      score: results.docDrift.summary.score,
-      rawMetrics: results.docDrift.rawData,
+      score: results.docDrift.summary.score || results.docDrift.summary.totalScore || 0,
+      rawMetrics: results.docDrift.summary,
       factors: [],
-      recommendations: (results.docDrift.recommendations || []).map(
+      recommendations: (results.docDrift.summary.recommendations || []).map(
         (action) => ({
           action,
           estimatedImpact: 5,
@@ -285,34 +311,30 @@ async function scoreUnified(results, options) {
       )
     });
   }
-  if (results.deps) {
+  if (results.dependencyHealth) {
     toolScores.set("dependency-health", {
       toolName: "dependency-health",
-      score: results.deps.summary.score,
-      rawMetrics: results.deps.rawData,
+      score: results.dependencyHealth.summary.score || 0,
+      rawMetrics: results.dependencyHealth.summary,
       factors: [],
-      recommendations: (results.deps.recommendations || []).map(
-        (action) => ({
-          action,
-          estimatedImpact: 5,
-          priority: "medium"
-        })
-      )
+      recommendations: (results.dependencyHealth.summary.recommendations || []).map((action) => ({
+        action,
+        estimatedImpact: 5,
+        priority: "medium"
+      }))
     });
   }
   if (results.changeAmplification) {
     toolScores.set("change-amplification", {
       toolName: "change-amplification",
-      score: results.changeAmplification.summary.score,
-      rawMetrics: results.changeAmplification.rawData,
+      score: results.changeAmplification.summary.score || 0,
+      rawMetrics: results.changeAmplification.summary,
       factors: [],
-      recommendations: (results.changeAmplification.recommendations || []).map(
-        (action) => ({
-          action,
-          estimatedImpact: 5,
-          priority: "medium"
-        })
-      )
+      recommendations: (results.changeAmplification.summary.recommendations || []).map((action) => ({
+        action,
+        estimatedImpact: 5,
+        priority: "medium"
+      }))
     });
   }
   if (toolScores.size === 0) {
@@ -345,12 +367,12 @@ function generateUnifiedSummary(result) {
   output += `   Execution time: ${(summary.executionTime / 1e3).toFixed(2)}s
 
 `;
-  if (result.patterns) {
-    output += `\u{1F50D} Pattern Analysis: ${result.patterns.length} issues
+  if (result.patternDetect) {
+    output += `\u{1F50D} Pattern Analysis: ${result.patternDetect.results.length} issues
 `;
   }
-  if (result.context) {
-    output += `\u{1F9E0} Context Analysis: ${result.context.length} issues
+  if (result.contextAnalyzer) {
+    output += `\u{1F9E0} Context Analysis: ${result.contextAnalyzer.results.length} issues
 `;
   }
   if (result.consistency) {
@@ -358,23 +380,23 @@ function generateUnifiedSummary(result) {
 `;
   }
   if (result.docDrift) {
-    output += `\u{1F4DD} Doc Drift Analysis: ${result.docDrift.issues?.length || 0} issues
+    output += `\u{1F4DD} Doc Drift Analysis: ${result.docDrift.results?.length || 0} issues
 `;
   }
-  if (result.deps) {
-    output += `\u{1F4E6} Dependency Health: ${result.deps.issues?.length || 0} issues
+  if (result.dependencyHealth) {
+    output += `\u{1F4E6} Dependency Health: ${result.dependencyHealth.results?.length || 0} issues
 `;
   }
   if (result.aiSignalClarity) {
     output += `\u{1F9E0} AI Signal Clarity: ${result.aiSignalClarity.summary?.totalSignals || 0} signals
 `;
   }
-  if (result.grounding) {
-    output += `\u{1F9ED} Agent Grounding: ${result.grounding.issues?.length || 0} issues
+  if (result.agentGrounding) {
+    output += `\u{1F9ED} Agent Grounding: ${result.agentGrounding.results?.length || 0} issues
 `;
   }
   if (result.testability) {
-    output += `\u{1F9EA} Testability Index: ${result.testability.issues?.length || 0} issues
+    output += `\u{1F9EA} Testability Index: ${result.testability.results?.length || 0} issues
 `;
   }
   if (result.changeAmplification) {