@aiready/cli 0.7.8 → 0.7.9

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/cli@0.7.8 build /Users/pengcao/projects/aiready/packages/cli
+> @aiready/cli@0.7.9 build /Users/pengcao/projects/aiready/packages/cli
 > tsup src/index.ts src/cli.ts --format cjs,esm --dts
 
 CLI Building entry: src/cli.ts, src/index.ts
@@ -9,15 +9,15 @@
 CLI Target: es2020
 CJS Build start
 ESM Build start
-CJS dist/index.js 3.15 KB
-CJS dist/cli.js   27.05 KB
-CJS ⚡️ Build success in 56ms
-ESM dist/chunk-VOB7SA3E.mjs 2.02 KB
 ESM dist/index.mjs          138.00 B
+ESM dist/chunk-AGAMURT4.mjs 3.42 KB
 ESM dist/cli.mjs            21.98 KB
-ESM ⚡️ Build success in 56ms
+ESM ⚡️ Build success in 59ms
+CJS dist/cli.js   28.45 KB
+CJS dist/index.js 4.55 KB
+CJS ⚡️ Build success in 59ms
 DTS Build start
-DTS ⚡️ Build success in 645ms
+DTS ⚡️ Build success in 554ms
 DTS dist/cli.d.ts    20.00 B
 DTS dist/index.d.ts  991.00 B
 DTS dist/cli.d.mts   20.00 B

package/.turbo/turbo-test.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/cli@0.7.8 test /Users/pengcao/projects/aiready/packages/cli
+> @aiready/cli@0.7.9 test /Users/pengcao/projects/aiready/packages/cli
 > vitest run
 
 [?25l
@@ -11,15 +11,15 @@
 
  Test Files 0 passed (1)
       Tests 0 passed (0)
-   Start at 17:33:46
+   Start at 22:55:50
    Duration 0ms
 [?2026l[?2026h
  ❯ src/__tests__/cli.test.ts 0/3
 
  Test Files 0 passed (1)
       Tests 0 passed (3)
-   Start at 17:33:46
-   Duration 306ms
+   Start at 22:55:50
+   Duration 406ms
 [?2026l ✓ src/__tests__/cli.test.ts (3 tests) 2ms
    ✓ CLI Unified Analysis (3)
      ✓ should run unified analysis with both tools 1ms
@@ -28,7 +28,7 @@
 
  Test Files  1 passed (1)
       Tests  3 passed (3)
-   Start at  17:33:46
-   Duration  335ms (transform 58ms, setup 0ms, import 252ms, tests 2ms, environment 0ms)
+   Start at  22:55:50
+   Duration  467ms (transform 82ms, setup 0ms, import 366ms, tests 2ms, environment 0ms)
 
 [?25h

package/dist/chunk-AGAMURT4.mjs

@@ -0,0 +1,109 @@
+// src/index.ts
+import { analyzePatterns } from "@aiready/pattern-detect";
+import { analyzeContext } from "@aiready/context-analyzer";
+import { analyzeConsistency } from "@aiready/consistency";
+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);
+    result.patterns = sortBySeverity(patternResult.results);
+    result.summary.totalIssues += patternResult.results.reduce(
+      (sum, file) => sum + file.issues.length,
+      0
+    );
+  }
+  if (tools.includes("context")) {
+    const contextResults = await analyzeContext(options);
+    result.context = 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;
+  }
+  if (tools.includes("consistency")) {
+    const report = await analyzeConsistency({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude,
+      checkNaming: true,
+      checkPatterns: true,
+      minSeverity: "info"
+    });
+    if (report.results) {
+      report.results = sortBySeverity(report.results);
+    }
+    result.consistency = report;
+    result.summary.totalIssues += report.summary.totalIssues;
+  }
+  result.summary.executionTime = Date.now() - startTime;
+  return result;
+}
+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.patterns?.length) {
+    output += `\u{1F50D} Pattern Analysis: ${result.patterns.length} issues
+`;
+  }
+  if (result.context?.length) {
+    output += `\u{1F9E0} Context Analysis: ${result.context.length} issues
+`;
+  }
+  if (result.consistency) {
+    output += `\u{1F3F7}\uFE0F Consistency Analysis: ${result.consistency.summary.totalIssues} issues
+`;
+  }
+  return output;
+}
+
+export {
+  analyzeUnified,
+  generateUnifiedSummary
+};

package/dist/chunk-NWEWXOUT.mjs

@@ -0,0 +1,74 @@
+// src/index.ts
+import { analyzePatterns } from "@aiready/pattern-detect";
+import { analyzeContext } from "@aiready/context-analyzer";
+import { analyzeConsistency } from "@aiready/consistency";
+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);
+    result.patterns = patternResult.results;
+    result.summary.totalIssues += patternResult.results.reduce(
+      (sum, file) => sum + file.issues.length,
+      0
+    );
+  }
+  if (tools.includes("context")) {
+    result.context = await analyzeContext(options);
+    result.summary.totalIssues += result.context?.length || 0;
+  }
+  if (tools.includes("consistency")) {
+    const report = await analyzeConsistency({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude,
+      checkNaming: true,
+      checkPatterns: true,
+      minSeverity: "info"
+    });
+    result.consistency = report;
+    result.summary.totalIssues += report.summary.totalIssues;
+  }
+  result.summary.executionTime = Date.now() - startTime;
+  return result;
+}
+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.patterns?.length) {
+    output += `\u{1F50D} Pattern Analysis: ${result.patterns.length} issues
+`;
+  }
+  if (result.context?.length) {
+    output += `\u{1F9E0} Context Analysis: ${result.context.length} issues
+`;
+  }
+  if (result.consistency) {
+    output += `\u{1F3F7}\uFE0F Consistency Analysis: ${result.consistency.summary.totalIssues} issues
+`;
+  }
+  return output;
+}
+
+export {
+  analyzeUnified,
+  generateUnifiedSummary
+};

package/dist/chunk-Z3TLCO6U.mjs

@@ -0,0 +1,100 @@
+// src/index.ts
+import { analyzePatterns } from "@aiready/pattern-detect";
+import { analyzeContext } from "@aiready/context-analyzer";
+import { analyzeConsistency } from "@aiready/consistency";
+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);
+    result.patterns = sortBySeverity(patternResult.results);
+    result.summary.totalIssues += patternResult.results.reduce(
+      (sum, file) => sum + file.issues.length,
+      0
+    );
+  }
+  if (tools.includes("context")) {
+    result.context = await analyzeContext(options);
+    result.summary.totalIssues += result.context?.length || 0;
+  }
+  if (tools.includes("consistency")) {
+    const report = await analyzeConsistency({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude,
+      checkNaming: true,
+      checkPatterns: true,
+      minSeverity: "info"
+    });
+    result.consistency = report;
+    result.summary.totalIssues += report.summary.totalIssues;
+  }
+  result.summary.executionTime = Date.now() - startTime;
+  return result;
+}
+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.patterns?.length) {
+    output += `\u{1F50D} Pattern Analysis: ${result.patterns.length} issues
+`;
+  }
+  if (result.context?.length) {
+    output += `\u{1F9E0} Context Analysis: ${result.context.length} issues
+`;
+  }
+  if (result.consistency) {
+    output += `\u{1F3F7}\uFE0F Consistency Analysis: ${result.consistency.summary.totalIssues} issues
+`;
+  }
+  return output;
+}
+
+export {
+  analyzeUnified,
+  generateUnifiedSummary
+};

package/dist/cli.js

@@ -30,6 +30,32 @@ var import_commander = require("commander");
 var import_pattern_detect = require("@aiready/pattern-detect");
 var import_context_analyzer = require("@aiready/context-analyzer");
 var import_consistency = require("@aiready/consistency");
+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"];
@@ -42,11 +68,20 @@ async function analyzeUnified(options) {
   };
   if (tools.includes("patterns")) {
     const patternResult = await (0, import_pattern_detect.analyzePatterns)(options);
-    result.patterns = patternResult.results;
-    result.summary.totalIssues += patternResult.results.length;
+    result.patterns = sortBySeverity(patternResult.results);
+    result.summary.totalIssues += patternResult.results.reduce(
+      (sum, file) => sum + file.issues.length,
+      0
+    );
   }
   if (tools.includes("context")) {
-    result.context = await (0, import_context_analyzer.analyzeContext)(options);
+    const contextResults = await (0, import_context_analyzer.analyzeContext)(options);
+    result.context = 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;
   }
   if (tools.includes("consistency")) {
@@ -58,6 +93,9 @@ async function analyzeUnified(options) {
       checkPatterns: true,
       minSeverity: "info"
     });
+    if (report.results) {
+      report.results = sortBySeverity(report.results);
+    }
     result.consistency = report;
     result.summary.totalIssues += report.summary.totalIssues;
   }

package/dist/cli.mjs

@@ -2,7 +2,7 @@
 import {
   analyzeUnified,
   generateUnifiedSummary
-} from "./chunk-VOB7SA3E.mjs";
+} from "./chunk-AGAMURT4.mjs";
 
 // src/cli.ts
 import { Command } from "commander";

package/dist/index.js

@@ -27,6 +27,32 @@ 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 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"];
@@ -39,11 +65,20 @@ async function analyzeUnified(options) {
   };
   if (tools.includes("patterns")) {
     const patternResult = await (0, import_pattern_detect.analyzePatterns)(options);
-    result.patterns = patternResult.results;
-    result.summary.totalIssues += patternResult.results.length;
+    result.patterns = sortBySeverity(patternResult.results);
+    result.summary.totalIssues += patternResult.results.reduce(
+      (sum, file) => sum + file.issues.length,
+      0
+    );
   }
   if (tools.includes("context")) {
-    result.context = await (0, import_context_analyzer.analyzeContext)(options);
+    const contextResults = await (0, import_context_analyzer.analyzeContext)(options);
+    result.context = 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;
   }
   if (tools.includes("consistency")) {
@@ -55,6 +90,9 @@ async function analyzeUnified(options) {
       checkPatterns: true,
       minSeverity: "info"
     });
+    if (report.results) {
+      report.results = sortBySeverity(report.results);
+    }
     result.consistency = report;
     result.summary.totalIssues += report.summary.totalIssues;
   }

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import {
   analyzeUnified,
   generateUnifiedSummary
-} from "./chunk-VOB7SA3E.mjs";
+} from "./chunk-AGAMURT4.mjs";
 export {
   analyzeUnified,
   generateUnifiedSummary

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/cli",
-  "version": "0.7.8",
+  "version": "0.7.9",
   "description": "Unified CLI for AIReady analysis tools",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/index.ts

@@ -26,6 +26,42 @@ export interface UnifiedAnalysisResult {
   };
 }
 
+// Severity ordering (higher number = more severe)
+const severityOrder: Record<string, number> = {
+  critical: 4,
+  major: 3,
+  minor: 2,
+  info: 1,
+};
+
+function sortBySeverity(results: AnalysisResult[]): AnalysisResult[] {
+  return results
+    .map((file) => {
+      // Sort issues within each file by severity (most severe first)
+      const sortedIssues = [...file.issues].sort((a, b) => {
+        const severityDiff = (severityOrder[b.severity] || 0) - (severityOrder[a.severity] || 0);
+        if (severityDiff !== 0) return severityDiff;
+        // If same severity, sort by line number
+        return (a.location?.line || 0) - (b.location?.line || 0);
+      });
+      return { ...file, issues: sortedIssues };
+    })
+    .sort((a, b) => {
+      // Sort files by most severe issue first
+      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 same max severity, sort by number of issues
+      if (a.issues.length !== b.issues.length) {
+        return b.issues.length - a.issues.length;
+      }
+      // Finally, sort alphabetically by filename
+      return a.fileName.localeCompare(b.fileName);
+    });
+}
+
 export async function analyzeUnified(
   options: UnifiedAnalysisOptions
 ): Promise<UnifiedAnalysisResult> {
@@ -42,13 +78,27 @@ export async function analyzeUnified(
   // Run pattern detection
   if (tools.includes('patterns')) {
     const patternResult = await analyzePatterns(options);
-    result.patterns = patternResult.results;
-    result.summary.totalIssues += patternResult.results.length;
+    // Sort results by severity
+    result.patterns = sortBySeverity(patternResult.results);
+    // Count actual issues, not file count
+    result.summary.totalIssues += patternResult.results.reduce(
+      (sum, file) => sum + file.issues.length,
+      0
+    );
   }
 
   // Run context analysis
   if (tools.includes('context')) {
-    result.context = await analyzeContext(options);
+    const contextResults = await analyzeContext(options);
+    // Sort context results by severity (most severe first)
+    result.context = contextResults.sort((a, b) => {
+      const severityDiff = (severityOrder[b.severity] || 0) - (severityOrder[a.severity] || 0);
+      if (severityDiff !== 0) return severityDiff;
+      // If same severity, sort by token cost (higher cost first)
+      if (a.tokenCost !== b.tokenCost) return b.tokenCost - a.tokenCost;
+      // Finally, sort by fragmentation score (higher fragmentation first)
+      return b.fragmentationScore - a.fragmentationScore;
+    });
     result.summary.totalIssues += result.context?.length || 0;
   }
 
@@ -62,6 +112,10 @@ export async function analyzeUnified(
       checkPatterns: true,
       minSeverity: 'info',
     });
+    // Sort consistency results by severity
+    if (report.results) {
+      report.results = sortBySeverity(report.results);
+    }
     result.consistency = report;
     result.summary.totalIssues += report.summary.totalIssues;
   }