@apdesign/cursor-roi-tracker 0.5.2

package/src/ai-events.js

@@ -0,0 +1,659 @@
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+function loadAiEvents(repoRoot, branch, config) {
+  return loadAiEventsWithMeta(repoRoot, branch, config).events;
+}
+
+function loadAiEventsWithMeta(repoRoot, branch, config) {
+  const eventFiles = resolveEventFiles(repoRoot, branch, config.eventsDirectory);
+  if (!eventFiles.length) {
+    return {
+      events: [],
+      stats: {
+        filesRead: 0,
+        missingEventIdLines: 0,
+      },
+    };
+  }
+
+  const events = [];
+  const stats = {
+    filesRead: 0,
+    missingEventIdLines: 0,
+  };
+  for (const filePath of eventFiles) {
+    const text = fs.readFileSync(filePath, "utf8");
+    const parsed = parseEventsText(text, repoRoot, filePath);
+    events.push(...parsed.events);
+    stats.filesRead += 1;
+    stats.missingEventIdLines += parsed.missingEventIdLines;
+  }
+  return {
+    events: dedupeEvents(events),
+    stats,
+  };
+}
+
+function resolveEventFiles(repoRoot, branch, eventsDirectoryConfig) {
+  const roots = normalizeEventRoots(eventsDirectoryConfig);
+  const allCandidates = [];
+
+  for (const root of roots) {
+    const basePath = path.join(repoRoot, root);
+    allCandidates.push(...resolveCandidatesForRoot(basePath, branch));
+  }
+
+  return Array.from(new Set(allCandidates.filter((candidate) => fs.existsSync(candidate))));
+}
+
+function normalizeEventRoots(eventsDirectoryConfig) {
+  if (Array.isArray(eventsDirectoryConfig)) {
+    return eventsDirectoryConfig.map((item) => String(item || "").trim()).filter(Boolean);
+  }
+  const single = String(eventsDirectoryConfig || "").trim();
+  return single ? [single] : [];
+}
+
+function resolveCandidatesForRoot(basePath, branch) {
+  if (!fs.existsSync(basePath)) {
+    // Backward compatibility: allow file stem config
+    // (e.g. ".cursor/local-ai-events" -> ".cursor/local-ai-events.jsonl")
+    return [`${basePath}.jsonl`, `${basePath}.json`, basePath].filter((candidate) =>
+      isReadableFile(candidate)
+    );
+  }
+
+  if (fs.statSync(basePath).isFile()) {
+    return [basePath];
+  }
+
+  const explicitCandidates = [
+    path.join(basePath, `${branch}.jsonl`),
+    path.join(basePath, `${branch.replace(/[\\/]/g, "__")}.jsonl`),
+    path.join(basePath, "current.jsonl"),
+    path.join(basePath, `${branch}.json`),
+    path.join(basePath, `${branch.replace(/[\\/]/g, "__")}.json`),
+    path.join(basePath, "current.json"),
+  ];
+
+  const fallbackCandidates = fs
+    .readdirSync(basePath, { withFileTypes: true })
+    .filter((entry) => entry.isFile())
+    .map((entry) => entry.name)
+    .filter((name) => /\.(jsonl|json)$/i.test(name))
+    .map((name) => path.join(basePath, name));
+
+  return [...explicitCandidates, ...fallbackCandidates].filter((candidate) => isReadableFile(candidate));
+}
+
+function isReadableFile(filePath) {
+  return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+}
+
+function parseEventsText(text, repoRoot, sourceFile) {
+  const trimmed = String(text || "").trim();
+  if (!trimmed) {
+    return {
+      events: [],
+      missingEventIdLines: 0,
+    };
+  }
+
+  let missingEventIdLines = 0;
+  // Primary format: JSONL
+  const jsonlLines = trimmed.split("\n").map((item) => item.trim()).filter(Boolean);
+  const jsonlEvents = [];
+  for (const line of jsonlLines) {
+    try {
+      const normalized = normalizeEvent(JSON.parse(line), repoRoot, sourceFile);
+      if (!normalized) {
+        continue;
+      }
+      if (normalized.invalidReason === "missingEventId") {
+        missingEventIdLines += 1;
+        continue;
+      }
+      jsonlEvents.push(normalized);
+    } catch (_error) {
+      // ignore malformed line to keep parser fault-tolerant
+    }
+  }
+  if (jsonlLines.length > 0) {
+    return {
+      events: jsonlEvents,
+      missingEventIdLines,
+    };
+  }
+
+  // Fallback: JSON array / object wrapper
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) {
+      const events = [];
+      for (const item of parsed) {
+        const normalized = normalizeEvent(item, repoRoot, sourceFile);
+        if (!normalized) continue;
+        if (normalized.invalidReason === "missingEventId") {
+          missingEventIdLines += 1;
+          continue;
+        }
+        events.push(normalized);
+      }
+      return {
+        events,
+        missingEventIdLines,
+      };
+    }
+    if (Array.isArray(parsed?.events)) {
+      const events = [];
+      for (const item of parsed.events) {
+        const normalized = normalizeEvent(item, repoRoot, sourceFile);
+        if (!normalized) continue;
+        if (normalized.invalidReason === "missingEventId") {
+          missingEventIdLines += 1;
+          continue;
+        }
+        events.push(normalized);
+      }
+      return {
+        events,
+        missingEventIdLines,
+      };
+    }
+    const single = normalizeEvent(parsed, repoRoot, sourceFile);
+    if (!single || single.invalidReason) {
+      return {
+        events: [],
+        missingEventIdLines: missingEventIdLines + (single?.invalidReason === "missingEventId" ? 1 : 0),
+      };
+    }
+    return {
+      events: [single],
+      missingEventIdLines,
+    };
+  } catch (_error) {
+    return {
+      events: [],
+      missingEventIdLines,
+    };
+  }
+}
+
+function normalizeEvent(raw, repoRoot, sourceFile) {
+  const eventType = String(raw.type || "").trim();
+  const isProbeBulkInsert = eventType === "agent_bulk_insert";
+  const isProbePureDelete = eventType === "agent_pure_delete";
+  const isProbeEvent = isProbeBulkInsert || isProbePureDelete;
+  const eventId = String(raw.event_id || raw.eventId || "").trim();
+  if (!eventId && isProbeEvent) {
+    return { invalidReason: "missingEventId" };
+  }
+  const rawPath = String(
+    raw.relative_path || raw.relativePath || raw.file_path || raw.filePath || raw.path || ""
+  ).trim();
+  const relativePath = normalizeEventPath(rawPath, repoRoot);
+  const score = Number.isFinite(Number(raw.score)) ? Number(raw.score) : isProbeEvent ? 1 : Number.NaN;
+  const legacyStartLine = Number(raw.start_line ?? raw.startLine);
+  const legacyEndLine = Number(raw.end_line ?? raw.endLine);
+  const insertStartLine = Number(raw.insert_start_line ?? raw.insertStartLine);
+  const insertEndLine = Number(raw.insert_end_line ?? raw.insertEndLine);
+  const deleteStartLine = Number(raw.delete_start_line ?? raw.deleteStartLine);
+  const deleteEndLine = Number(raw.delete_end_line ?? raw.deleteEndLine);
+  const insertRangesFromLegacyRange = toRangeArrayFromStartEnd(legacyStartLine, legacyEndLine);
+  const insertRangesFromProbeRange = toRangeArrayFromStartEnd(insertStartLine, insertEndLine);
+  const deleteRangesFromProbeRange = toRangeArrayFromStartEnd(deleteStartLine, deleteEndLine);
+  const insertRangesOfficial = normalizeRanges(raw.insert_ranges || raw.insertRanges);
+  const deleteRangesOfficial = normalizeRanges(raw.delete_ranges || raw.deleteRanges);
+  const insertRangesProbe = mergeRanges([...insertRangesFromProbeRange, ...insertRangesFromLegacyRange]);
+  const deleteRangesProbe = mergeRanges(deleteRangesFromProbeRange);
+  const insertRanges = mergeRanges([
+    ...insertRangesOfficial,
+    ...insertRangesProbe,
+  ]);
+  const deleteRanges = mergeRanges([...deleteRangesOfficial, ...deleteRangesProbe]);
+  const ts = asNullableNumber(raw.timestamp);
+  if (!eventId || !relativePath || !Number.isFinite(score)) {
+    return null;
+  }
+
+  return {
+    eventId,
+    sourceFile: sourceFile || null,
+    relativePath,
+    score,
+    branchAtEvent: raw.branch_at_event || raw.branchAtEvent || null,
+    tsStart: asNullableNumber(raw.ts_start ?? raw.tsStart) ?? ts,
+    tsEnd: asNullableNumber(raw.ts_end ?? raw.tsEnd) ?? ts,
+    type: eventType || "unknown",
+    insertRanges,
+    insertRangesOfficial,
+    insertRangesProbe,
+    deleteRanges,
+    deleteRangesOfficial,
+    deleteRangesProbe,
+    insertLines: asNullableNumber(raw.insert_lines ?? raw.insertLines) ?? 0,
+    deletedLines: asNullableNumber(raw.deleted_lines ?? raw.deletedLines) ?? 0,
+    deletedTextHashes: normalizeStringArray(raw.deleted_text_hashes || raw.deletedTextHashes),
+    anchorHash: raw.anchor_hash || raw.anchorHash || null,
+    insertTextHashes: normalizeStringArray(raw.insert_text_hashes || raw.insertTextHashes),
+  };
+}
+
+function toRangeArrayFromStartEnd(startLine, endLine) {
+  if (!Number.isFinite(startLine) || !Number.isFinite(endLine) || endLine < startLine) {
+    return [];
+  }
+  return [{ startLine, count: endLine - startLine + 1 }];
+}
+
+function normalizeEventPath(filePath, repoRoot) {
+  const normalized = normalizePath(filePath);
+  if (!normalized) {
+    return "";
+  }
+  if (!path.isAbsolute(normalized)) {
+    return normalized.replace(/^\.\//, "");
+  }
+  const relative = path.relative(repoRoot, normalized).replace(/\\/g, "/");
+  if (!relative || relative.startsWith("../")) {
+    return normalized;
+  }
+  return relative.replace(/^\.\//, "");
+}
+
+function normalizeRanges(input) {
+  if (!Array.isArray(input)) {
+    return [];
+  }
+  return input
+    .map((item) => {
+      const start = Number(item.startLine ?? item.start ?? item.line);
+      const count = Number(item.count ?? item.lines ?? item.lineCount ?? 0);
+      if (!Number.isFinite(start) || !Number.isFinite(count) || count <= 0) {
+        return null;
+      }
+      return { startLine: start, count };
+    })
+    .filter(Boolean);
+}
+
+function normalizeStringArray(input) {
+  if (!Array.isArray(input)) {
+    return [];
+  }
+  return input
+    .map((item) => String(item || "").trim())
+    .filter(Boolean);
+}
+
+function asNullableNumber(value) {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : null;
+}
+
+function buildAiMetricsFromIntersections(fileMetrics, events, threshold) {
+  const byPath = new Map(fileMetrics.map((item) => [normalizePath(item.filePath), item]));
+  const aiBlocks = [];
+  const touchedFiles = new Set();
+  const seenAddedLinesByFile = new Map();
+  const seenDeletedLinesByFile = new Map();
+  const seenAiBlocks = new Set();
+  const deletedSourcePriorityForReplace = ["probe", "official", "fallback"];
+  const deletedSourcePriorityForPureDelete = ["official", "probe", "fallback"];
+
+  for (const event of events) {
+    if (event.score < threshold) {
+      continue;
+    }
+    const normalizedEventPath = normalizePath(event.relativePath);
+    const fileMetric =
+      byPath.get(normalizedEventPath) ||
+      byPath.get(normalizedEventPath.replace(/^\.\//, "")) ||
+      byPath.get(path.basename(normalizedEventPath));
+    if (!fileMetric) {
+      continue;
+    }
+
+    const newSideHunks = fileMetric.hunks.map((hunk) => ({
+      startLine: hunk.newStart,
+      count: hunk.newCount,
+    }));
+    const oldSideHunks = fileMetric.hunks.map((hunk) => ({
+      startLine: hunk.oldStart,
+      count: hunk.oldCount,
+    }));
+
+    const addedIntersections = intersectEventRangesWithHunks(event.insertRanges, newSideHunks);
+    const deletedAttribution = resolveDeletedAttribution({
+      event,
+      fileHunks: fileMetric.hunks,
+      oldSideHunks,
+      isPureDeleteEvent: event.type === "agent_pure_delete",
+      sourcePriority:
+        event.type === "agent_pure_delete"
+          ? deletedSourcePriorityForPureDelete
+          : deletedSourcePriorityForReplace,
+    });
+    const deletedIntersections = deletedAttribution.intersections;
+
+    const fileKey = normalizePath(fileMetric.filePath);
+    const addedLineSet = getOrCreateLineSet(seenAddedLinesByFile, fileKey);
+    const deletedLineSet = getOrCreateLineSet(seenDeletedLinesByFile, fileKey);
+    const uniqueAddedLines = countUniqueIntersectionLines(addedIntersections, addedLineSet);
+    const uniqueDeletedLines = countUniqueIntersectionLines(deletedIntersections, deletedLineSet);
+
+    if (uniqueAddedLines > 0 || uniqueDeletedLines > 0) {
+      touchedFiles.add(normalizePath(event.relativePath));
+      fileMetric.aiAddedLines = (fileMetric.aiAddedLines || 0) + uniqueAddedLines;
+      fileMetric.aiDeletedLines = (fileMetric.aiDeletedLines || 0) + uniqueDeletedLines;
+      fileMetric.aiTouched = true;
+      fileMetric.deletedAttribution = fileMetric.deletedAttribution || {
+        probe: 0,
+        official: 0,
+        fallback: 0,
+      };
+      if (uniqueDeletedLines > 0) {
+        fileMetric.deletedAttribution[deletedAttribution.source] += uniqueDeletedLines;
+      }
+
+      for (const intersection of addedIntersections) {
+        const key = `added:${normalizePath(event.relativePath)}:${intersection.startLine}:${intersection.count}`;
+        if (seenAiBlocks.has(key)) continue;
+        seenAiBlocks.add(key);
+        aiBlocks.push(
+          createAiBlock({
+            kind: "added",
+            filePath: event.relativePath,
+            newStart: intersection.startLine,
+            newCount: intersection.count,
+            event,
+          })
+        );
+      }
+
+      for (const intersection of deletedIntersections) {
+        const key = `deleted:${normalizePath(event.relativePath)}:${intersection.startLine}:${intersection.count}`;
+        if (seenAiBlocks.has(key)) continue;
+        seenAiBlocks.add(key);
+        aiBlocks.push(
+          createAiBlock({
+            kind: "deleted",
+            filePath: event.relativePath,
+            oldStart: intersection.startLine,
+            oldCount: intersection.count,
+            event,
+            deletedAttributionSource: deletedAttribution.source,
+          })
+        );
+      }
+    }
+  }
+
+  let aiAddedLines = 0;
+  let aiDeletedLines = 0;
+  for (const item of fileMetrics) {
+    aiAddedLines += item.aiAddedLines || 0;
+    aiDeletedLines += item.aiDeletedLines || 0;
+  }
+
+  return {
+    aiAddedLines,
+    aiDeletedLines,
+    aiTouchedFilesCount: touchedFiles.size,
+    aiBlocks,
+  };
+}
+
+function resolveDeletedAttribution({ event, fileHunks, oldSideHunks, isPureDeleteEvent, sourcePriority }) {
+  const bySource = {
+    probe: mergeRanges(event.deleteRangesProbe || []),
+    official: mergeRanges(event.deleteRangesOfficial || []),
+    fallback: [],
+  };
+
+  if (!isPureDeleteEvent) {
+    bySource.fallback = inferDeletedIntersectionsFromTouchedHunks(fileHunks, event.insertRanges);
+  }
+
+  for (const source of sourcePriority) {
+    const sourceRanges = bySource[source];
+    if (!sourceRanges || sourceRanges.length === 0) {
+      continue;
+    }
+    const intersections = applyGitCeilingToRanges(sourceRanges, oldSideHunks);
+    if (intersections.length > 0) {
+      return {
+        source,
+        intersections,
+      };
+    }
+  }
+
+  return {
+    source: "fallback",
+    intersections: [],
+  };
+}
+
+function getOrCreateLineSet(map, key) {
+  if (!map.has(key)) {
+    map.set(key, new Set());
+  }
+  return map.get(key);
+}
+
+function countUniqueIntersectionLines(intersections, seenLineSet) {
+  let uniqueCount = 0;
+  for (const intersection of intersections) {
+    const start = Number(intersection.startLine);
+    const count = Number(intersection.count);
+    if (!Number.isFinite(start) || !Number.isFinite(count) || count <= 0) {
+      continue;
+    }
+    for (let line = start; line < start + count; line += 1) {
+      if (seenLineSet.has(line)) continue;
+      seenLineSet.add(line);
+      uniqueCount += 1;
+    }
+  }
+  return uniqueCount;
+}
+
+function intersectEventRangesWithHunks(eventRanges, hunkRanges) {
+  const results = [];
+  const mergedEventRanges = mergeRanges(eventRanges || []);
+  const mergedHunks = mergeRanges((hunkRanges || []).filter((item) => Number(item.count) > 0));
+  for (const ev of mergedEventRanges) {
+    const evEnd = ev.startLine + ev.count;
+    for (const hunk of mergedHunks) {
+      const hunkEnd = hunk.startLine + hunk.count;
+      const overlapStart = Math.max(ev.startLine, hunk.startLine);
+      const overlapEnd = Math.min(evEnd, hunkEnd);
+      if (overlapStart < overlapEnd) {
+        results.push({ startLine: overlapStart, count: overlapEnd - overlapStart });
+      }
+    }
+  }
+  return mergeRanges(results);
+}
+
+function inferDeletedIntersectionsFromTouchedHunks(hunks, insertRanges) {
+  if (!Array.isArray(hunks) || !Array.isArray(insertRanges) || !insertRanges.length) {
+    return [];
+  }
+  const results = [];
+  for (const hunk of hunks) {
+    const newStart = Number(hunk.newStart);
+    const newCount = Number(hunk.newCount);
+    const oldStart = Number(hunk.oldStart);
+    const oldCount = Number(hunk.oldCount);
+    // Only modified hunks can contribute fallback deleted lines.
+    if (!Number.isFinite(oldStart) || !Number.isFinite(oldCount) || oldCount <= 0) continue;
+    if (!Number.isFinite(newStart) || !Number.isFinite(newCount) || newCount <= 0) continue;
+    const touchedRanges = intersectEventRangesWithHunks(insertRanges, [{ startLine: newStart, count: newCount }]);
+    if (!touchedRanges.length) continue;
+    for (const touched of touchedRanges) {
+      const mapped = mapTouchedNewRangeToOldRange({
+        touchedRange: touched,
+        newStart,
+        newCount,
+        oldStart,
+        oldCount,
+      });
+      if (mapped) {
+        results.push(mapped);
+      }
+    }
+  }
+  return mergeRanges(results);
+}
+
+function mapTouchedNewRangeToOldRange({ touchedRange, newStart, newCount, oldStart, oldCount }) {
+  const touchedStart = Number(touchedRange.startLine);
+  const touchedCount = Number(touchedRange.count);
+  if (!Number.isFinite(touchedStart) || !Number.isFinite(touchedCount) || touchedCount <= 0) {
+    return null;
+  }
+  const relativeStart = touchedStart - newStart;
+  const relativeRatio = relativeStart / Math.max(1, newCount);
+  const mappedStart = oldStart + Math.floor(relativeRatio * oldCount);
+  const mappedCount = Math.max(1, Math.round((touchedCount / Math.max(1, newCount)) * oldCount));
+  const maxOldEnd = oldStart + oldCount;
+  const clippedStart = Math.max(oldStart, Math.min(mappedStart, maxOldEnd - 1));
+  const clippedEnd = Math.min(maxOldEnd, clippedStart + mappedCount);
+  if (clippedEnd <= clippedStart) {
+    return null;
+  }
+  return {
+    startLine: clippedStart,
+    count: clippedEnd - clippedStart,
+  };
+}
+
+function mergeRanges(ranges) {
+  const normalized = (ranges || [])
+    .map((item) => {
+      const startLine = Number(item.startLine);
+      const count = Number(item.count);
+      if (!Number.isFinite(startLine) || !Number.isFinite(count) || count <= 0) {
+        return null;
+      }
+      return { startLine, count };
+    })
+    .filter(Boolean);
+  if (!normalized.length) return [];
+  const sorted = [...normalized].sort((a, b) => a.startLine - b.startLine);
+  const merged = [sorted[0]];
+  for (let i = 1; i < sorted.length; i += 1) {
+    const current = sorted[i];
+    const last = merged[merged.length - 1];
+    const lastEnd = last.startLine + last.count;
+    const currentEnd = current.startLine + current.count;
+    if (current.startLine <= lastEnd) {
+      last.count = Math.max(lastEnd, currentEnd) - last.startLine;
+    } else {
+      merged.push({ ...current });
+    }
+  }
+  return merged;
+}
+
+function applyGitCeilingToRanges(eventRanges, oldSideHunks) {
+  const intersections = intersectEventRangesWithHunks(eventRanges, oldSideHunks);
+  if (!intersections.length) {
+    return [];
+  }
+  const mergedIntersections = mergeRanges(intersections);
+  const sortedHunks = mergeRanges(oldSideHunks || []);
+  const capped = [];
+
+  for (const hunk of sortedHunks) {
+    let remaining = Number(hunk.count);
+    if (!Number.isFinite(remaining) || remaining <= 0) {
+      continue;
+    }
+    const overlaps = intersectEventRangesWithHunks(mergedIntersections, [hunk]);
+    for (const overlap of overlaps) {
+      if (remaining <= 0) {
+        break;
+      }
+      const keepCount = Math.min(overlap.count, remaining);
+      if (keepCount <= 0) {
+        continue;
+      }
+      capped.push({ startLine: overlap.startLine, count: keepCount });
+      remaining -= keepCount;
+    }
+  }
+
+  return mergeRanges(capped);
+}
+
+function sumIntersectionLines(intersections) {
+  let total = 0;
+  for (const item of intersections) {
+    total += item.count;
+  }
+  return total;
+}
+
+function createAiBlock({
+  kind,
+  filePath,
+  newStart,
+  newCount,
+  oldStart,
+  oldCount,
+  event,
+  deletedAttributionSource,
+}) {
+  const hashInput = `${event.eventId}:${filePath}:${kind}:${newStart || oldStart}:${newCount || oldCount}`;
+  const blockId = crypto.createHash("sha256").update(hashInput).digest("hex");
+
+  return {
+    blockId,
+    kind,
+    filePath,
+    newStart: newStart ?? null,
+    newCount: newCount ?? null,
+    oldStart: oldStart ?? null,
+    oldCount: oldCount ?? null,
+    blockHash: event.insertTextHashes?.[0] || event.deletedTextHashes?.[0] || null,
+    anchorHash: event.anchorHash,
+    aiScore: event.score,
+    deletedAttributionSource: deletedAttributionSource ?? null,
+    sourceEventId: event.eventId,
+    originalCommitSha: null,
+    tsStart: event.tsStart,
+    tsEnd: event.tsEnd,
+  };
+}
+
+function normalizePath(filePath) {
+  return String(filePath || "")
+    .replace(/\\/g, "/")
+    .replace(/^\.\//, "")
+    .trim();
+}
+
+function dedupeEvents(events) {
+  const seen = new Set();
+  const output = [];
+  for (const event of events) {
+    const key = `${event.eventId}:${event.relativePath}:${event.tsStart ?? ""}:${event.tsEnd ?? ""}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    output.push(event);
+  }
+  return output;
+}
+
+module.exports = {
+  loadAiEvents,
+  loadAiEventsWithMeta,
+  buildAiMetricsFromIntersections,
+};