@aiready/cli 0.10.3 → 0.10.4

package/.turbo/turbo-build.log

@@ -10,7 +10,7 @@
 CJS Build start
 ESM Build start
 
-[10:33:57 AM]  WARN  ▲ [WARNING] "import.meta" is not available with the "cjs" output format and will be empty [empty-import-meta]
+ WARN  ▲ [WARNING] "import.meta" is not available with the "cjs" output format and will be empty [empty-import-meta]                8:22:49 pm
 
     src/cli.ts:25:31:
       25 │   return dirname(fileURLToPath(import.meta.url));
@@ -20,10 +20,10 @@
 
 
 
-CJS dist/cli.js   90.15 KB
-CJS dist/index.js 14.84 KB
-CJS ⚡️ Build success in 33ms
+CJS dist/cli.js   93.97 KB
+CJS dist/index.js 15.13 KB
+CJS ⚡️ Build success in 29ms
 ESM dist/index.mjs          170.00 B
-ESM dist/chunk-VUCNUYI7.mjs 13.44 KB
-ESM dist/cli.mjs            73.91 KB
-ESM ⚡️ Build success in 33ms
+ESM dist/cli.mjs            77.08 KB
+ESM dist/chunk-R3O7QPKD.mjs 13.73 KB
+ESM ⚡️ Build success in 29ms

package/.turbo/turbo-test.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/cli@0.10.2 test /Users/pengcao/projects/aiready/packages/cli
+> @aiready/cli@0.10.3 test /Users/pengcao/projects/aiready/packages/cli
 > vitest run
 
 [?25l
@@ -10,7 +10,7 @@
 
  Test Files  1 passed (1)
       Tests  3 passed (3)
-   Start at  09:42:19
-   Duration  474ms (transform 102ms, setup 0ms, import 336ms, tests 2ms, environment 0ms)
+   Start at  20:23:07
+   Duration  426ms (transform 97ms, setup 0ms, import 295ms, tests 2ms, environment 0ms)
 
 [?25h

package/dist/chunk-R3O7QPKD.mjs

@@ -0,0 +1,419 @@
+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 { analyzePatterns } from "@aiready/pattern-detect";
+import { analyzeContext } from "@aiready/context-analyzer";
+import { analyzeConsistency } from "@aiready/consistency";
+import {
+  calculateOverallScore,
+  calculateTokenBudget
+} from "@aiready/core";
+var severityOrder = {
+  critical: 4,
+  major: 3,
+  minor: 2,
+  info: 1
+};
+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 result = {
+    summary: {
+      totalIssues: 0,
+      toolsRun: tools,
+      executionTime: 0
+    }
+  };
+  if (tools.includes("patterns")) {
+    const patternResult = await analyzePatterns(options);
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "patterns", data: patternResult });
+    }
+    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
+    );
+  }
+  if (tools.includes("context")) {
+    const contextResults = await 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");
+    result.contextAnalyzer = {
+      results: sorted,
+      summary: genContextSummary(sorted)
+    };
+    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 analyzeConsistency(consistencyOptions);
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "consistency", data: report });
+    }
+    result.consistency = {
+      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.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.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.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.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 });
+    }
+    result.testability = {
+      ...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 });
+    }
+    result.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.patternDetect) {
+    const { calculatePatternScore } = await import("@aiready/pattern-detect");
+    try {
+      const patternScore = calculatePatternScore(
+        results.patternDetect.duplicates,
+        results.patternDetect.results?.length || 0
+      );
+      const wastedTokens = results.patternDetect.duplicates.reduce(
+        (sum, d) => sum + (d.tokenCost || 0),
+        0
+      );
+      patternScore.tokenBudget = calculateTokenBudget({
+        totalContextTokens: wastedTokens * 2,
+        // Estimated context
+        wastedTokens: {
+          duplication: wastedTokens,
+          fragmentation: 0,
+          chattiness: 0
+        }
+      });
+      toolScores.set("pattern-detect", patternScore);
+    } catch (err) {
+      void err;
+    }
+  }
+  if (results.contextAnalyzer) {
+    const { calculateContextScore } = await import("@aiready/context-analyzer");
+    try {
+      const ctxSummary = results.contextAnalyzer.summary;
+      const contextScore = calculateContextScore(ctxSummary);
+      contextScore.tokenBudget = calculateTokenBudget({
+        totalContextTokens: ctxSummary.totalTokens,
+        wastedTokens: {
+          duplication: 0,
+          fragmentation: ctxSummary.totalPotentialSavings || 0,
+          chattiness: 0
+        }
+      });
+      toolScores.set("context-analyzer", contextScore);
+    } catch (err) {
+      void err;
+    }
+  }
+  if (results.consistency) {
+    const { calculateConsistencyScore } = await import("@aiready/consistency");
+    try {
+      const issues = results.consistency.results?.flatMap((r) => r.issues) || [];
+      const totalFiles = results.consistency.summary?.filesAnalyzed || 0;
+      const consistencyScore = calculateConsistencyScore(issues, totalFiles);
+      toolScores.set("consistency", consistencyScore);
+    } catch (err) {
+      void err;
+    }
+  }
+  if (results.aiSignalClarity) {
+    const { calculateAiSignalClarityScore } = await import("@aiready/ai-signal-clarity");
+    try {
+      const hrScore = calculateAiSignalClarityScore(results.aiSignalClarity);
+      toolScores.set("ai-signal-clarity", hrScore);
+    } catch (err) {
+      void err;
+    }
+  }
+  if (results.agentGrounding) {
+    const { calculateGroundingScore } = await import("@aiready/agent-grounding");
+    try {
+      const agScore = calculateGroundingScore(results.agentGrounding);
+      toolScores.set("agent-grounding", agScore);
+    } catch (err) {
+      void err;
+    }
+  }
+  if (results.testability) {
+    const { calculateTestabilityScore } = await import("@aiready/testability");
+    try {
+      const tbScore = calculateTestabilityScore(results.testability);
+      toolScores.set("testability", 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,
+      factors: [],
+      recommendations: (results.docDrift.summary.recommendations || []).map(
+        (action) => ({
+          action,
+          estimatedImpact: 5,
+          priority: "medium"
+        })
+      )
+    });
+  }
+  if (results.dependencyHealth) {
+    toolScores.set("dependency-health", {
+      toolName: "dependency-health",
+      score: results.dependencyHealth.summary.score || 0,
+      rawMetrics: results.dependencyHealth.summary,
+      factors: [],
+      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 || 0,
+      rawMetrics: results.changeAmplification.summary,
+      factors: [],
+      recommendations: (results.changeAmplification.summary.recommendations || []).map((action) => ({
+        action,
+        estimatedImpact: 5,
+        priority: "medium"
+      }))
+    });
+  }
+  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
+
+`;
+  if (result.patternDetect) {
+    output += `\u{1F50D} Pattern Analysis: ${result.patternDetect.results.length} issues
+`;
+  }
+  if (result.contextAnalyzer) {
+    output += `\u{1F9E0} Context Analysis: ${result.contextAnalyzer.results.length} issues
+`;
+  }
+  if (result.consistency) {
+    output += `\u{1F3F7}\uFE0F Consistency Analysis: ${result.consistency.summary.totalIssues} issues
+`;
+  }
+  if (result.docDrift) {
+    output += `\u{1F4DD} Doc Drift Analysis: ${result.docDrift.results?.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.agentGrounding) {
+    output += `\u{1F9ED} Agent Grounding: ${result.agentGrounding.results?.length || 0} issues
+`;
+  }
+  if (result.testability) {
+    output += `\u{1F9EA} Testability Index: ${result.testability.results?.length || 0} issues
+`;
+  }
+  if (result.changeAmplification) {
+    output += `\u{1F4A5} Change Amplification: ${result.changeAmplification.summary?.totalIssues || 0} cascading risks
+`;
+  }
+  return output;
+}
+
+export {
+  __require,
+  analyzeUnified,
+  scoreUnified,
+  generateUnifiedSummary
+};

package/dist/cli.js

@@ -144,10 +144,11 @@ async function analyzeUnified(options) {
       options.progressCallback({ tool: "doc-drift", data: report });
     }
     result.docDrift = {
-      results: report.results || [],
+      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");
@@ -161,10 +162,11 @@ async function analyzeUnified(options) {
       options.progressCallback({ tool: "deps-health", data: report });
     }
     result.dependencyHealth = {
-      results: report.results || [],
+      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");
@@ -179,11 +181,11 @@ async function analyzeUnified(options) {
     }
     result.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;
   }
@@ -200,10 +202,10 @@ async function analyzeUnified(options) {
     }
     result.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");
@@ -218,10 +220,10 @@ async function analyzeUnified(options) {
     }
     result.testability = {
       ...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");
@@ -886,18 +888,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;
@@ -1130,6 +1132,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.patternDetect, import_core3.IssueType.DuplicatePattern);
+      collect(res.contextAnalyzer, import_core3.IssueType.ContextFragmentation);
+      collect(res.consistency, import_core3.IssueType.NamingInconsistency);
+      collect(res.docDrift, import_core3.IssueType.DocDrift);
+      collect(res.dependencyHealth, import_core3.IssueType.DependencyHealth);
+      collect(res.aiSignalClarity, import_core3.IssueType.AiSignalClarity);
+      collect(res.agentGrounding, import_core3.IssueType.AgentNavigationFailure);
+      collect(res.testability, import_core3.IssueType.LowTestability);
+      collect(res.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 +1215,7 @@ async function scanAction(directory, options) {
         resolvedDir
       );
       const outputData = {
-        ...results,
-        scoring: scoringResult,
+        ...mapToUnifiedReport(results, scoringResult),
         repository: repoMetadata
       };
       (0, import_core3.handleJSONOutput)(
@@ -1167,8 +1240,7 @@ async function scanAction(directory, options) {
         resolvedDir
       );
       const outputData = {
-        ...results,
-        scoring: scoringResult,
+        ...mapToUnifiedReport(results, scoringResult),
         repository: repoMetadata
       };
       try {
@@ -1211,7 +1283,7 @@ async function scanAction(directory, options) {
         }
         if (results.patternDetect) {
           const criticalPatterns = results.patternDetect.results.flatMap(
-            (p) => p.issues.filter((i) => i.severity === "critical")
+            (p) => p.issues.filter((i) => i.severity === import_core3.Severity.Critical)
           );
           criticalPatterns.slice(0, 10).forEach((issue) => {
             console.log(
@@ -1234,22 +1306,22 @@ async function scanAction(directory, options) {
         if (results.patternDetect) {
           results.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 (c.severity === import_core3.Severity.Critical) criticalCount++;
+            if (c.severity === import_core3.Severity.Major) majorCount++;
           });
         }
         if (results.consistency) {
           results.consistency.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++;
             });
           });
         }