npm - @aiready/core - Versions diffs - 0.9.22 → 0.9.25 - Mend

@aiready/core 0.9.22 → 0.9.25

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/index.js CHANGED Viewed

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,11 +17,20 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  DEFAULT_COST_CONFIG: () => DEFAULT_COST_CONFIG,
   DEFAULT_EXCLUDE: () => DEFAULT_EXCLUDE,
   DEFAULT_TOOL_WEIGHTS: () => DEFAULT_TOOL_WEIGHTS,
   LANGUAGE_EXTENSIONS: () => LANGUAGE_EXTENSIONS,
@@ -29,13 +40,20 @@ __export(index_exports, {
   PythonParser: () => PythonParser,
   TOOL_NAME_MAP: () => TOOL_NAME_MAP,
   TypeScriptParser: () => TypeScriptParser,
+  calculateComprehensionDifficulty: () => calculateComprehensionDifficulty,
   calculateImportSimilarity: () => calculateImportSimilarity,
+  calculateMonthlyCost: () => calculateMonthlyCost,
   calculateOverallScore: () => calculateOverallScore,
+  calculateProductivityImpact: () => calculateProductivityImpact,
   estimateTokens: () => estimateTokens,
   extractFunctions: () => extractFunctions,
   extractImports: () => extractImports,
+  formatAcceptanceRate: () => formatAcceptanceRate,
+  formatCost: () => formatCost,
+  formatHours: () => formatHours,
   formatScore: () => formatScore,
   formatToolScore: () => formatToolScore,
+  generateHTML: () => generateHTML,
   getElapsedTime: () => getElapsedTime,
   getFileExtension: () => getFileExtension,
   getParser: () => getParser,
@@ -54,6 +72,7 @@ __export(index_exports, {
   parseCode: () => parseCode,
   parseFileExports: () => parseFileExports,
   parseWeightString: () => parseWeightString,
+  predictAcceptanceRate: () => predictAcceptanceRate,
   readFileContent: () => readFileContent,
   resolveOutputPath: () => resolveOutputPath,
   scanFiles: () => scanFiles
@@ -96,6 +115,7 @@ var import_glob = require("glob");
 var import_promises = require("fs/promises");
 var import_fs = require("fs");
 var import_path = require("path");
+var import_ignore = __toESM(require("ignore"));
 var DEFAULT_EXCLUDE = [
   // Dependencies
   "**/node_modules/**",
@@ -164,6 +184,22 @@ async function scanFiles(options) {
     ignore: finalExclude,
     absolute: true
   });
+  const gitignorePath = (0, import_path.join)(rootDir || ".", ".gitignore");
+  if ((0, import_fs.existsSync)(gitignorePath)) {
+    try {
+      const gitTxt = await (0, import_promises.readFile)(gitignorePath, "utf-8");
+      const ig = (0, import_ignore.default)();
+      ig.add(gitTxt);
+      const filtered = files.filter((f) => {
+        let rel = (0, import_path.relative)(rootDir || ".", f).replace(/\\/g, "/");
+        if (rel === "") rel = f;
+        return !ig.ignores(rel);
+      });
+      return filtered;
+    } catch (e) {
+      return files;
+    }
+  }
   return files;
 }
 async function readFileContent(filePath) {
@@ -472,6 +508,172 @@ function getElapsedTime(startTime) {
   return ((Date.now() - startTime) / 1e3).toFixed(2);
 }
+// src/utils/visualization.ts
+function generateHTML(graph) {
+  const payload = JSON.stringify(graph, null, 2);
+  return `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>AIReady Visualization</title>
+    <style>
+      html,body { height: 100%; margin: 0; padding: 0; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #0f172a; color: #e2e8f0 }
+      #container { display:flex; height:100vh }
+      #panel { width: 320px; padding: 16px; background: #071130; box-shadow: -2px 0 8px rgba(0,0,0,0.3); overflow:auto }
+      #canvasWrap { flex:1; display:flex; align-items:center; justify-content:center }
+      canvas { background: #0b1220; border-radius:8px }
+      .stat { margin-bottom:12px }
+    </style>
+  </head>
+  <body>
+    <div id="container">
+      <div id="canvasWrap"><canvas id="canvas" width="1200" height="800"></canvas></div>
+      <div id="panel">
+        <h2>AIReady Visualization</h2>
+        <div class="stat"><strong>Files:</strong> <span id="stat-files"></span></div>
+        <div class="stat"><strong>Dependencies:</strong> <span id="stat-deps"></span></div>
+        <div class="stat"><strong>Legend</strong></div>
+        <div style="font-size:13px;line-height:1.3;color:#cbd5e1;margin-top:8px">
+          <div style="margin-bottom:8px"><span style="display:inline-block;width:12px;height:12px;background:#ff4d4f;margin-right:8px;border:1px solid rgba(255,255,255,0.06)"></span><strong>Critical</strong>: highest severity issues.</div>
+          <div style="margin-bottom:8px"><span style="display:inline-block;width:12px;height:12px;background:#ff9900;margin-right:8px;border:1px solid rgba(255,255,255,0.06)"></span><strong>Major</strong>: important issues.</div>
+          <div style="margin-bottom:8px"><span style="display:inline-block;width:12px;height:12px;background:#ffd666;margin-right:8px;border:1px solid rgba(255,255,255,0.06)"></span><strong>Minor</strong>: low priority issues.</div>
+          <div style="margin-bottom:8px"><span style="display:inline-block;width:12px;height:12px;background:#91d5ff;margin-right:8px;border:1px solid rgba(255,255,255,0.06)"></span><strong>Info</strong>: informational notes.</div>
+          <div style="margin-top:10px;color:#94a3b8"><strong>Node size</strong>: larger = higher token cost, more issues or dependency weight.</div>
+          <div style="margin-top:6px;color:#94a3b8"><strong>Proximity</strong>: nodes that are spatially close are more contextually related; relatedness is represented by distance and size rather than explicit edges.</div>
+          <div style="margin-top:6px;color:#94a3b8"><strong>Edge colors</strong>: <span style="color:#fb7e81">Similarity</span>, <span style="color:#84c1ff">Dependency</span>, <span style="color:#ffa500">Reference</span>, default <span style="color:#334155">Other</span>.</div>
+        </div>
+      </div>
+    </div>
+    <script>
+      const graphData = ${payload};
+      document.getElementById('stat-files').textContent = graphData.metadata.totalFiles;
+      document.getElementById('stat-deps').textContent = graphData.metadata.totalDependencies;
+      const canvas = document.getElementById('canvas');
+      const ctx = canvas.getContext('2d');
+      const nodes = graphData.nodes.map((n, i) => ({
+        ...n,
+        x: canvas.width / 2 + Math.cos(i / graphData.nodes.length * Math.PI * 2) * (Math.min(canvas.width, canvas.height) / 3),
+        y: canvas.height / 2 + Math.sin(i / graphData.nodes.length * Math.PI * 2) * (Math.min(canvas.width, canvas.height) / 3),
+      }));
+      function draw() {
+        ctx.clearRect(0, 0, canvas.width, canvas.height);
+        graphData.edges.forEach(edge => {
+          const s = nodes.find(n => n.id === edge.source);
+          const t = nodes.find(n => n.id === edge.target);
+          if (!s || !t) return;
+          if (edge.type === 'related') return;
+          if (edge.type === 'similarity') {
+            ctx.strokeStyle = '#fb7e81';
+            ctx.lineWidth = 1.2;
+          } else if (edge.type === 'dependency') {
+            ctx.strokeStyle = '#84c1ff';
+            ctx.lineWidth = 1.0;
+          } else if (edge.type === 'reference') {
+            ctx.strokeStyle = '#ffa500';
+            ctx.lineWidth = 0.9;
+          } else {
+            ctx.strokeStyle = '#334155';
+            ctx.lineWidth = 0.8;
+          }
+          ctx.beginPath();
+          ctx.moveTo(s.x, s.y);
+          ctx.lineTo(t.x, t.y);
+          ctx.stroke();
+        });
+        const groups = {};
+        nodes.forEach(n => {
+          const g = n.group || '__default';
+          if (!groups[g]) groups[g] = { minX: n.x, minY: n.y, maxX: n.x, maxY: n.y };
+          groups[g].minX = Math.min(groups[g].minX, n.x);
+          groups[g].minY = Math.min(groups[g].minY, n.y);
+          groups[g].maxX = Math.max(groups[g].maxX, n.x);
+          groups[g].maxY = Math.max(groups[g].maxY, n.y);
+        });
+        const groupRelations = {};
+        graphData.edges.forEach(edge => {
+          const sNode = nodes.find(n => n.id === edge.source);
+          const tNode = nodes.find(n => n.id === edge.target);
+          if (!sNode || !tNode) return;
+          const g1 = sNode.group || '__default';
+          const g2 = tNode.group || '__default';
+          if (g1 === g2) return;
+          const key = g1 < g2 ? g1 + '::' + g2 : g2 + '::' + g1;
+          groupRelations[key] = (groupRelations[key] || 0) + 1;
+        });
+        Object.keys(groupRelations).forEach(k => {
+          const count = groupRelations[k];
+          const [ga, gb] = k.split('::');
+          if (!groups[ga] || !groups[gb]) return;
+          const ax = (groups[ga].minX + groups[ga].maxX) / 2;
+          const ay = (groups[ga].minY + groups[ga].maxY) / 2;
+          const bx = (groups[gb].minX + groups[gb].maxX) / 2;
+          const by = (groups[gb].minY + groups[gb].maxY) / 2;
+          ctx.beginPath();
+          ctx.strokeStyle = 'rgba(148,163,184,0.25)';
+          ctx.lineWidth = Math.min(6, 0.6 + Math.sqrt(count));
+          ctx.moveTo(ax, ay);
+          ctx.lineTo(bx, by);
+          ctx.stroke();
+        });
+        Object.keys(groups).forEach(g => {
+          if (g === '__default') return;
+          const box = groups[g];
+          const pad = 16;
+          const x = box.minX - pad;
+          const y = box.minY - pad;
+          const w = (box.maxX - box.minX) + pad * 2;
+          const h = (box.maxY - box.minY) + pad * 2;
+          ctx.save();
+          ctx.fillStyle = 'rgba(30,64,175,0.04)';
+          ctx.strokeStyle = 'rgba(30,64,175,0.12)';
+          ctx.lineWidth = 1.2;
+          const r = 8;
+          ctx.beginPath();
+          ctx.moveTo(x + r, y);
+          ctx.arcTo(x + w, y, x + w, y + h, r);
+          ctx.arcTo(x + w, y + h, x, y + h, r);
+          ctx.arcTo(x, y + h, x, y, r);
+          ctx.arcTo(x, y, x + w, y, r);
+          ctx.closePath();
+          ctx.fill();
+          ctx.stroke();
+          ctx.restore();
+          ctx.fillStyle = '#94a3b8';
+          ctx.font = '11px sans-serif';
+          ctx.fillText(g, x + 8, y + 14);
+        });
+        nodes.forEach(n => {
+          const sizeVal = (n.size || n.value || 1);
+          const r = 6 + (sizeVal / 2);
+          ctx.beginPath();
+          ctx.fillStyle = n.color || '#60a5fa';
+          ctx.arc(n.x, n.y, r, 0, Math.PI * 2);
+          ctx.fill();
+          ctx.fillStyle = '#e2e8f0';
+          ctx.font = '11px sans-serif';
+          ctx.textAlign = 'center';
+          ctx.fillText(n.label || n.id.split('/').slice(-1)[0], n.x, n.y + r + 12);
+        });
+      }
+      draw();
+    </script>
+  </body>
+</html>`;
+}
 // src/scoring.ts
 var DEFAULT_TOOL_WEIGHTS = {
   "pattern-detect": 40,
@@ -616,6 +818,167 @@ function formatToolScore(output) {
   return result;
 }
+// src/business-metrics.ts
+var DEFAULT_COST_CONFIG = {
+  pricePer1KTokens: 0.01,
+  // $0.01 per 1K tokens (GPT-4)
+  queriesPerDevPerDay: 50,
+  // Average AI queries per developer
+  developerCount: 5,
+  // Default team size
+  daysPerMonth: 30
+};
+var SEVERITY_TIME_ESTIMATES = {
+  critical: 4,
+  // Complex architectural issues
+  major: 2,
+  // Significant refactoring needed
+  minor: 0.5,
+  // Simple naming/style fixes
+  info: 0.25
+  // Documentation improvements
+};
+var DEFAULT_HOURLY_RATE = 75;
+function calculateMonthlyCost(tokenWaste, config = {}) {
+  const cfg = { ...DEFAULT_COST_CONFIG, ...config };
+  const tokensPerDay = tokenWaste * cfg.queriesPerDevPerDay;
+  const tokensPerMonth = tokensPerDay * cfg.daysPerMonth;
+  const cost = tokensPerMonth / 1e3 * cfg.pricePer1KTokens;
+  return Math.round(cost * 100) / 100;
+}
+function calculateProductivityImpact(issues, hourlyRate = DEFAULT_HOURLY_RATE) {
+  const counts = {
+    critical: issues.filter((i) => i.severity === "critical").length,
+    major: issues.filter((i) => i.severity === "major").length,
+    minor: issues.filter((i) => i.severity === "minor").length,
+    info: issues.filter((i) => i.severity === "info").length
+  };
+  const hours = {
+    critical: counts.critical * SEVERITY_TIME_ESTIMATES.critical,
+    major: counts.major * SEVERITY_TIME_ESTIMATES.major,
+    minor: counts.minor * SEVERITY_TIME_ESTIMATES.minor,
+    info: counts.info * SEVERITY_TIME_ESTIMATES.info
+  };
+  const totalHours = hours.critical + hours.major + hours.minor + hours.info;
+  const totalCost = totalHours * hourlyRate;
+  return {
+    totalHours: Math.round(totalHours * 10) / 10,
+    hourlyRate,
+    totalCost: Math.round(totalCost),
+    bySeverity: {
+      critical: { hours: Math.round(hours.critical * 10) / 10, cost: Math.round(hours.critical * hourlyRate) },
+      major: { hours: Math.round(hours.major * 10) / 10, cost: Math.round(hours.major * hourlyRate) },
+      minor: { hours: Math.round(hours.minor * 10) / 10, cost: Math.round(hours.minor * hourlyRate) }
+    }
+  };
+}
+function predictAcceptanceRate(toolOutputs) {
+  const factors = [];
+  const patterns = toolOutputs.get("pattern-detect");
+  if (patterns) {
+    const patternImpact = (patterns.score - 50) * 0.3;
+    factors.push({
+      name: "Semantic Duplication",
+      impact: Math.round(patternImpact)
+    });
+  }
+  const context = toolOutputs.get("context-analyzer");
+  if (context) {
+    const contextImpact = (context.score - 50) * 0.4;
+    factors.push({
+      name: "Context Efficiency",
+      impact: Math.round(contextImpact)
+    });
+  }
+  const consistency = toolOutputs.get("consistency");
+  if (consistency) {
+    const consistencyImpact = (consistency.score - 50) * 0.3;
+    factors.push({
+      name: "Code Consistency",
+      impact: Math.round(consistencyImpact)
+    });
+  }
+  const baseRate = 0.65;
+  const totalImpact = factors.reduce((sum, f) => sum + f.impact / 100, 0);
+  const rate = Math.max(0.1, Math.min(0.95, baseRate + totalImpact));
+  const confidence = toolOutputs.size >= 3 ? 0.8 : toolOutputs.size >= 2 ? 0.6 : 0.4;
+  return {
+    rate: Math.round(rate * 100) / 100,
+    confidence,
+    factors
+  };
+}
+function calculateComprehensionDifficulty(contextBudget, importDepth, fragmentation, consistencyScore, totalFiles) {
+  const budgetFactor = Math.min(100, Math.max(0, (contextBudget - 5e3) / 250));
+  const depthFactor = Math.min(100, Math.max(0, (importDepth - 5) * 10));
+  const fragmentationFactor = Math.min(100, Math.max(0, (fragmentation - 0.3) * 250));
+  const consistencyFactor = Math.min(100, Math.max(0, 100 - consistencyScore));
+  const fileFactor = Math.min(100, Math.max(0, (totalFiles - 50) / 5));
+  const score = Math.round(
+    budgetFactor * 0.35 + depthFactor * 0.2 + fragmentationFactor * 0.2 + consistencyFactor * 0.15 + fileFactor * 0.1
+  );
+  let rating;
+  if (score < 20) rating = "trivial";
+  else if (score < 40) rating = "easy";
+  else if (score < 60) rating = "moderate";
+  else if (score < 80) rating = "difficult";
+  else rating = "expert";
+  return {
+    score,
+    rating,
+    factors: [
+      {
+        name: "Context Budget",
+        contribution: Math.round(budgetFactor * 0.35),
+        description: `${Math.round(contextBudget)} tokens required`
+      },
+      {
+        name: "Import Depth",
+        contribution: Math.round(depthFactor * 0.2),
+        description: `${importDepth.toFixed(1)} average levels`
+      },
+      {
+        name: "Code Fragmentation",
+        contribution: Math.round(fragmentationFactor * 0.2),
+        description: `${(fragmentation * 100).toFixed(0)}% fragmentation`
+      },
+      {
+        name: "Consistency",
+        contribution: Math.round(consistencyFactor * 0.15),
+        description: `${consistencyScore}/100 consistency score`
+      },
+      {
+        name: "Project Scale",
+        contribution: Math.round(fileFactor * 0.1),
+        description: `${totalFiles} files analyzed`
+      }
+    ]
+  };
+}
+function formatCost(cost) {
+  if (cost < 1) {
+    return `$${cost.toFixed(2)}`;
+  } else if (cost < 1e3) {
+    return `$${cost.toFixed(0)}`;
+  } else {
+    return `$${(cost / 1e3).toFixed(1)}k`;
+  }
+}
+function formatHours(hours) {
+  if (hours < 1) {
+    return `${Math.round(hours * 60)}min`;
+  } else if (hours < 8) {
+    return `${hours.toFixed(1)}h`;
+  } else if (hours < 40) {
+    return `${Math.round(hours)}h`;
+  } else {
+    return `${(hours / 40).toFixed(1)} weeks`;
+  }
+}
+function formatAcceptanceRate(rate) {
+  return `${Math.round(rate * 100)}%`;
+}
 // src/parsers/typescript-parser.ts
 var import_typescript_estree2 = require("@typescript-eslint/typescript-estree");
 var TypeScriptParser = class {
@@ -1097,6 +1460,7 @@ function getSupportedLanguages() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_COST_CONFIG,
   DEFAULT_EXCLUDE,
   DEFAULT_TOOL_WEIGHTS,
   LANGUAGE_EXTENSIONS,
@@ -1106,13 +1470,20 @@ function getSupportedLanguages() {
   PythonParser,
   TOOL_NAME_MAP,
   TypeScriptParser,
+  calculateComprehensionDifficulty,
   calculateImportSimilarity,
+  calculateMonthlyCost,
   calculateOverallScore,
+  calculateProductivityImpact,
   estimateTokens,
   extractFunctions,
   extractImports,
+  formatAcceptanceRate,
+  formatCost,
+  formatHours,
   formatScore,
   formatToolScore,
+  generateHTML,
   getElapsedTime,
   getFileExtension,
   getParser,
@@ -1131,6 +1502,7 @@ function getSupportedLanguages() {
   parseCode,
   parseFileExports,
   parseWeightString,
+  predictAcceptanceRate,
   readFileContent,
   resolveOutputPath,
   scanFiles