@aiready/cli 0.9.33 → 0.9.36

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/cli@0.9.33 build /Users/pengcao/projects/aiready/packages/cli
+> @aiready/cli@0.9.36 build /Users/pengcao/projects/aiready/packages/cli
 > tsup src/index.ts src/cli.ts --format cjs,esm
 
 CLI Building entry: src/cli.ts, src/index.ts
@@ -9,10 +9,28 @@
 CLI Target: es2020
 CJS Build start
 ESM Build start
-CJS dist/cli.js   64.03 KB
-CJS dist/index.js 4.93 KB
-CJS ⚡️ Build success in 231ms
-ESM dist/cli.mjs            56.83 KB
-ESM dist/chunk-5GZDRZ3T.mjs 4.17 KB
-ESM dist/index.mjs          138.00 B
-ESM ⚡️ Build success in 232ms
+
+[9:41:44 PM]  WARN  ▲ [WARNING] "import.meta" is not available with the "cjs" output format and will be empty [empty-import-meta]
+
+    src/cli.ts:22:31:
+      22 │   return dirname(fileURLToPath(import.meta.url));
+         ╵                                ~~~~~~~~~~~
+
+  You need to set the output format to "esm" for "import.meta" to work correctly.
+
+
+
+CJS dist/cli.js   77.14 KB
+CJS dist/index.js 6.63 KB
+CJS ⚡️ Build success in 28ms
+ESM dist/hallucination-risk-XU6E7IGN.mjs 135.00 B
+ESM dist/cli.mjs                         62.85 KB
+ESM dist/index.mjs                       169.00 B
+ESM dist/agent-grounding-DAOSU4MF.mjs    129.00 B
+ESM dist/chunk-XAF2EW5H.mjs              1.75 KB
+ESM dist/chunk-RBWLQRKR.mjs              1.39 KB
+ESM dist/chunk-Y6FXYEAI.mjs              390.00 B
+ESM dist/chunk-YIS6WTY5.mjs              1.41 KB
+ESM dist/testability-VDZJZ4MF.mjs        123.00 B
+ESM dist/chunk-N4SLON5K.mjs              4.91 KB
+ESM ⚡️ Build success in 28ms

package/.turbo/turbo-test.log

@@ -1,17 +1,17 @@
 
 
-> @aiready/cli@0.9.33 test /Users/pengcao/projects/aiready/packages/cli
+> @aiready/cli@0.9.36 test /Users/pengcao/projects/aiready/packages/cli
 > vitest run
 
 [?25l
  RUN  v4.0.18 /Users/pengcao/projects/aiready/packages/cli
 
- ✓ dist/__tests__/cli.test.js (3 tests) 7ms
- ✓ src/__tests__/cli.test.ts (3 tests) 6ms
+ ✓ src/__tests__/cli.test.ts (3 tests) 3ms
+ ✓ dist/__tests__/cli.test.js (3 tests) 3ms
 
  Test Files  2 passed (2)
       Tests  6 passed (6)
-   Start at  18:38:27
-   Duration  1.45s (transform 464ms, setup 0ms, import 2.25s, tests 13ms, environment 0ms)
+   Start at  21:42:04
+   Duration  1.60s (transform 926ms, setup 0ms, import 2.72s, tests 5ms, environment 0ms)
 
 [?25h

package/dist/agent-grounding-DAOSU4MF.mjs

@@ -0,0 +1,7 @@
+import {
+  agentGroundingAction
+} from "./chunk-YIS6WTY5.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  agentGroundingAction
+};

package/dist/chunk-G6SDH7ZS.mjs

@@ -0,0 +1,126 @@
+// 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);
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "patterns", data: patternResult });
+    }
+    result.patterns = sortBySeverity(patternResult.results);
+    result.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 });
+    }
+    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 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 });
+    }
+    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) {
+    output += `\u{1F50D} Pattern Analysis: ${result.patterns.length} issues
+`;
+  }
+  if (result.context) {
+    output += `\u{1F9E0} Context Analysis: ${result.context.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.issues?.length || 0} issues
+`;
+  }
+  if (result.deps) {
+    output += `\u{1F4E6} Dependency Health: ${result.deps.issues?.length || 0} issues
+`;
+  }
+  return output;
+}
+
+export {
+  analyzeUnified,
+  generateUnifiedSummary
+};

package/dist/chunk-N4SLON5K.mjs

@@ -0,0 +1,152 @@
+// 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);
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "patterns", data: patternResult });
+    }
+    result.patterns = sortBySeverity(patternResult.results);
+    result.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 });
+    }
+    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 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 });
+    }
+    if (report.results) {
+      report.results = sortBySeverity(report.results);
+    }
+    result.consistency = report;
+    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
+    });
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "doc-drift", data: report });
+    }
+    result.docDrift = report;
+    result.summary.totalIssues += report.issues?.length || 0;
+  }
+  if (tools.includes("deps-health")) {
+    const { analyzeDeps } = await import("@aiready/deps");
+    const report = await analyzeDeps({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude
+    });
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "deps-health", data: report });
+    }
+    result.deps = report;
+    result.summary.totalIssues += report.issues?.length || 0;
+  }
+  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) {
+    output += `\u{1F50D} Pattern Analysis: ${result.patterns.length} issues
+`;
+  }
+  if (result.context) {
+    output += `\u{1F9E0} Context Analysis: ${result.context.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.issues?.length || 0} issues
+`;
+  }
+  if (result.deps) {
+    output += `\u{1F4E6} Dependency Health: ${result.deps.issues?.length || 0} issues
+`;
+  }
+  return output;
+}
+
+export {
+  analyzeUnified,
+  generateUnifiedSummary
+};

package/dist/chunk-RBWLQRKR.mjs

@@ -0,0 +1,39 @@
+// src/commands/hallucination-risk.ts
+import chalk from "chalk";
+import { loadConfig, mergeConfigWithDefaults } from "@aiready/core";
+async function hallucinationRiskAction(directory, options) {
+  const { analyzeHallucinationRisk, calculateHallucinationScore } = await import("@aiready/hallucination-risk");
+  const config = await loadConfig(directory);
+  const merged = mergeConfigWithDefaults(config, {
+    minSeverity: "info"
+  });
+  const report = await analyzeHallucinationRisk({
+    rootDir: directory,
+    minSeverity: options.minSeverity ?? merged.minSeverity ?? "info",
+    include: options.include,
+    exclude: options.exclude
+  });
+  const scoring = calculateHallucinationScore(report);
+  if (options.output === "json") {
+    return scoring;
+  }
+  const { summary } = report;
+  const ratingColors = {
+    minimal: chalk.green,
+    low: chalk.cyan,
+    moderate: chalk.yellow,
+    high: chalk.red,
+    severe: chalk.bgRed.white
+  };
+  const color = ratingColors[summary.rating] ?? chalk.white;
+  console.log(`  \u{1F9E0} Hallucination Risk:  ${chalk.bold(scoring.score + "/100")} (${color(summary.rating)})`);
+  console.log(`     Top Risk: ${chalk.italic(summary.topRisk)}`);
+  if (summary.totalSignals > 0) {
+    console.log(chalk.dim(`     ${summary.criticalSignals} critical  ${summary.majorSignals} major  ${summary.minorSignals} minor signals`));
+  }
+  return scoring;
+}
+
+export {
+  hallucinationRiskAction
+};

package/dist/chunk-XAF2EW5H.mjs

@@ -0,0 +1,46 @@
+// src/commands/testability.ts
+import chalk from "chalk";
+import { loadConfig, mergeConfigWithDefaults } from "@aiready/core";
+async function testabilityAction(directory, options) {
+  const { analyzeTestability, calculateTestabilityScore } = await import("@aiready/testability");
+  const config = await loadConfig(directory);
+  const merged = mergeConfigWithDefaults(config, {
+    minCoverageRatio: 0.3
+  });
+  const report = await analyzeTestability({
+    rootDir: directory,
+    minCoverageRatio: options.minCoverageRatio ?? merged.minCoverageRatio,
+    include: options.include,
+    exclude: options.exclude
+  });
+  const scoring = calculateTestabilityScore(report);
+  if (options.output === "json") {
+    return scoring;
+  }
+  const safetyIcons = {
+    "safe": "\u2705",
+    "moderate-risk": "\u26A0\uFE0F ",
+    "high-risk": "\u{1F534}",
+    "blind-risk": "\u{1F480}"
+  };
+  const safetyColors = {
+    "safe": chalk.green,
+    "moderate-risk": chalk.yellow,
+    "high-risk": chalk.red,
+    "blind-risk": chalk.bgRed.white
+  };
+  const safety = report.summary.aiChangeSafetyRating;
+  const icon = safetyIcons[safety] ?? "\u2753";
+  const color = safetyColors[safety] ?? chalk.white;
+  console.log(`  \u{1F9EA} Testability:         ${chalk.bold(scoring.score + "/100")} (${report.summary.rating})`);
+  console.log(`     AI Change Safety:  ${color(`${icon} ${safety.toUpperCase()}`)}`);
+  console.log(chalk.dim(`     Coverage: ${Math.round(report.summary.coverageRatio * 100)}%  (${report.rawData.testFiles} test / ${report.rawData.sourceFiles} source files)`));
+  if (safety === "blind-risk") {
+    console.log(chalk.red.bold("\n     \u26A0\uFE0F  NO TESTS \u2014 AI changes to this codebase are completely unverifiable!\n"));
+  }
+  return scoring;
+}
+
+export {
+  testabilityAction
+};

package/dist/chunk-Y6FXYEAI.mjs

@@ -0,0 +1,10 @@
+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');
+});
+
+export {
+  __require
+};

package/dist/chunk-YIS6WTY5.mjs

@@ -0,0 +1,35 @@
+// src/commands/agent-grounding.ts
+import chalk from "chalk";
+import { loadConfig, mergeConfigWithDefaults } from "@aiready/core";
+async function agentGroundingAction(directory, options) {
+  const { analyzeAgentGrounding, calculateGroundingScore } = await import("@aiready/agent-grounding");
+  const config = await loadConfig(directory);
+  const merged = mergeConfigWithDefaults(config, {
+    maxRecommendedDepth: 4,
+    readmeStaleDays: 90
+  });
+  const report = await analyzeAgentGrounding({
+    rootDir: directory,
+    maxRecommendedDepth: options.maxDepth ?? merged.maxRecommendedDepth,
+    readmeStaleDays: options.readmeStaleDays ?? merged.readmeStaleDays,
+    include: options.include,
+    exclude: options.exclude
+  });
+  const scoring = calculateGroundingScore(report);
+  if (options.output === "json") {
+    return scoring;
+  }
+  const scoreColor = (s) => s >= 85 ? chalk.green : s >= 70 ? chalk.cyan : s >= 50 ? chalk.yellow : chalk.red;
+  console.log(`  \u{1F9ED} Agent Grounding:     ${chalk.bold(scoring.score + "/100")} (${report.summary.rating})`);
+  const dims = report.summary.dimensions;
+  const worstDim = Object.entries(dims).sort(([, a], [, b]) => a - b)[0];
+  if (worstDim && worstDim[1] < 70) {
+    const name = worstDim[0].replace(/([A-Z])/g, " $1").replace("Score", "").trim();
+    console.log(chalk.dim(`     Weakest dimension: ${name} (${worstDim[1]}/100)`));
+  }
+  return scoring;
+}
+
+export {
+  agentGroundingAction
+};