@aiready/cli 0.10.6 → 0.12.0

package/dist/chunk-EQ2HQSTJ.mjs

@@ -1,414 +0,0 @@
-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 || [],
-      summary: report.summary || {}
-    };
-    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,
-      onProgress: options.onProgress
-    });
-    if (options.progressCallback) {
-      options.progressCallback({ tool: "deps-health", data: report });
-    }
-    result.dependencyHealth = {
-      results: report.results || [],
-      summary: report.summary || {}
-    };
-    result.summary.totalIssues += report.issues?.length || 0;
-  }
-  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 = {
-      results: report.results || [],
-      summary: report.summary || {}
-    };
-    result.summary.totalIssues += report.results?.reduce(
-      (sum, r) => sum + (r.issues?.length || 0),
-      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 = {
-      results: report.results || [],
-      summary: report.summary || {}
-    };
-    result.summary.totalIssues += report.issues?.length || 0;
-  }
-  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 = {
-      results: report.results || [],
-      summary: report.summary || {}
-    };
-    result.summary.totalIssues += report.issues?.length || 0;
-  }
-  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
-};