@apdesign/cursor-roi-tracker 0.5.2

package/src/cli-pre-commit.js

@@ -0,0 +1,233 @@
+const path = require("path");
+const { loadConfig, createPathFilters } = require("./config");
+const { CLI_VERSION } = require("./constants");
+const { parseUnifiedDiff } = require("./diff-parser");
+const {
+  getRepoRoot,
+  getBranch,
+  getAuthor,
+  getAuthorEmail,
+  getRemoteUrl,
+  maskRemoteUrl,
+  isMergeCommitInProgress,
+  listStagedFiles,
+  getStagedUnifiedDiff,
+} = require("./git");
+const { loadAiEventsWithMeta, buildAiMetricsFromIntersections } = require("./ai-events");
+const { writePendingReport, writeErrorStatus } = require("./report");
+const { extractTaskSerials, resolveMemberMatch, ratio } = require("./metrics");
+const { acquireMutexLock, releaseMutexLock, resolveEventLockPath } = require("./mutex-lock");
+
+async function runPreCommit() {
+  let repoRoot = process.cwd();
+  try {
+    repoRoot = getRepoRoot(process.cwd());
+    const branch = getBranch(repoRoot);
+    const author = getAuthor(repoRoot);
+    const authorEmail = getAuthorEmail(repoRoot);
+    const remoteUrl = maskRemoteUrl(getRemoteUrl(repoRoot));
+    const config = loadConfig(repoRoot);
+
+    if (isMergeCommitInProgress(repoRoot)) {
+      const skipped = createSkippedReport({
+        repoRoot,
+        branch,
+        author,
+        authorEmail,
+        remoteUrl,
+        reason: "mergeCommit",
+      });
+      writePendingReport(repoRoot, skipped);
+      return;
+    }
+
+    const isSourceFile = createPathFilters(config);
+    const stagedFiles = listStagedFiles(repoRoot);
+    const sourceFiles = stagedFiles.filter((item) => isSourceFile(item));
+
+    if (!sourceFiles.length) {
+      const emptyReport = createBaseReport({
+        repoRoot,
+        branch,
+        author,
+        authorEmail,
+        remoteUrl,
+      });
+      emptyReport.sourceFiles = [];
+      emptyReport.skipped = "noSourceFiles";
+      writePendingReport(repoRoot, emptyReport);
+      return;
+    }
+
+    const diffText = getStagedUnifiedDiff(repoRoot, sourceFiles);
+    const parsed = parseUnifiedDiff(diffText);
+
+    const lockHandle = await acquireMutexLock(resolveEventLockPath(repoRoot));
+    let eventsResult;
+    try {
+      eventsResult = loadAiEventsWithMeta(repoRoot, branch, config);
+    } finally {
+      await releaseMutexLock(lockHandle);
+    }
+    const events = eventsResult.events;
+    const aiMetrics = buildAiMetricsFromIntersections(
+      parsed.fileMetrics,
+      events,
+      config.highThreshold
+    );
+    const taskSerials = extractTaskSerials(branch);
+    const member = resolveMemberMatch(repoRoot, config, author);
+
+    const report = createBaseReport({
+      repoRoot,
+      branch,
+      author,
+      authorEmail,
+      remoteUrl,
+    });
+    report.sourceFiles = sourceFiles;
+    report.totalAddedLines = parsed.totalAddedLines;
+    report.totalDeletedLines = parsed.totalDeletedLines;
+    report.affectedFilesCount = parsed.affectedFilesCount;
+    report.aiAddedLines = aiMetrics.aiAddedLines;
+    report.aiDeletedLines = aiMetrics.aiDeletedLines;
+    report.aiTouchedFilesCount = aiMetrics.aiTouchedFilesCount;
+    report.aiPenetrationAdded = ratio(report.aiAddedLines, report.totalAddedLines);
+    report.aiPenetrationChanged = ratio(
+      report.aiAddedLines + report.aiDeletedLines,
+      report.totalAddedLines + report.totalDeletedLines
+    );
+    report.taskSerials = taskSerials;
+    report.memberMatched = member.memberMatched;
+    report.matchedMemberName = member.matchedMemberName;
+    report.cleanupPlan = buildCleanupPlan(events, aiMetrics.aiBlocks);
+    report.eventReadStats = {
+      filesRead: eventsResult.stats.filesRead,
+      missingEventIdLines: eventsResult.stats.missingEventIdLines,
+      readAtMs: Date.now(),
+    };
+    report.fileMetrics = parsed.fileMetrics.map((item) => ({
+      filePath: item.filePath,
+      language: extToLanguage(item.filePath),
+      addedLines: item.addedLines,
+      deletedLines: item.deletedLines,
+      aiAddedLines: item.aiAddedLines,
+      aiDeletedLines: item.aiDeletedLines,
+      aiTouched: item.aiTouched,
+      deletedAttribution: item.deletedAttribution || undefined,
+      hunks: item.hunks,
+    }));
+    report.aiBlocks = aiMetrics.aiBlocks;
+
+    if (config.configError) {
+      report.errorStatus = { code: "CONFIG_PARSE_ERROR", message: config.configError };
+      writeErrorStatus(repoRoot, report.errorStatus, {
+        stage: "pre-commit",
+        branch,
+        author,
+      });
+    } else if (!events.length) {
+      // No AI events means AI metrics are expected to be 0; surface this explicitly.
+      const eventPaths = Array.isArray(config.eventsDirectory)
+        ? config.eventsDirectory.join(", ")
+        : String(config.eventsDirectory || "");
+      report.errorStatus = {
+        code: "AI_EVENTS_NOT_FOUND",
+        message: `No AI events found under ${eventPaths}; AI metrics set to 0.`,
+      };
+    } else if (eventsResult.stats.missingEventIdLines > 0) {
+      report.errorStatus = {
+        code: "AI_EVENTS_MISSING_EVENT_ID",
+        message: `${eventsResult.stats.missingEventIdLines} probe event lines missing eventId were ignored.`,
+      };
+    }
+
+    writePendingReport(repoRoot, report);
+  } catch (error) {
+    const errorStatus = {
+      code: "PRE_COMMIT_COLLECT_ERROR",
+      message: error?.message || "unknown error",
+    };
+    writeErrorStatus(repoRoot, errorStatus, { stage: "pre-commit" });
+  }
+}
+
+function buildCleanupPlan(events, aiBlocks) {
+  const consumedEventIds = new Set(
+    (Array.isArray(aiBlocks) ? aiBlocks : [])
+      .map((item) => String(item?.sourceEventId || "").trim())
+      .filter(Boolean)
+  );
+  if (!consumedEventIds.size) {
+    return [];
+  }
+
+  const consumedBySource = new Map();
+  for (const event of Array.isArray(events) ? events : []) {
+    const eventId = String(event?.eventId || "").trim();
+    if (!eventId || !consumedEventIds.has(eventId)) {
+      continue;
+    }
+    const sourceFile = String(event?.sourceFile || "").trim();
+    if (!sourceFile) {
+      continue;
+    }
+    if (!consumedBySource.has(sourceFile)) {
+      consumedBySource.set(sourceFile, new Set());
+    }
+    consumedBySource.get(sourceFile).add(eventId);
+  }
+
+  return Array.from(consumedBySource.entries()).map(([sourceFile, ids]) => ({
+    sourceFile,
+    consumedEventIds: Array.from(ids),
+  }));
+}
+
+function createBaseReport({ repoRoot, branch, author, authorEmail, remoteUrl }) {
+  return {
+    schemaVersion: "0.1.0",
+    cliVersion: CLI_VERSION,
+    generatedAt: Date.now(),
+    repoRoot,
+    repoName: path.basename(repoRoot),
+    branch,
+    remoteUrl: remoteUrl || null,
+    commitSha: null,
+    commitTime: null,
+    author,
+    authorEmail,
+    totalAddedLines: 0,
+    totalDeletedLines: 0,
+    affectedFilesCount: 0,
+    aiAddedLines: 0,
+    aiDeletedLines: 0,
+    aiTouchedFilesCount: 0,
+    aiPenetrationAdded: null,
+    aiPenetrationChanged: null,
+    taskSerials: [],
+    memberMatched: false,
+    matchedMemberName: null,
+    cleanupPlan: [],
+    eventReadStats: null,
+    fileMetrics: [],
+    aiBlocks: [],
+    errorStatus: null,
+  };
+}
+
+function createSkippedReport({ repoRoot, branch, author, authorEmail, remoteUrl, reason }) {
+  return {
+    ...createBaseReport({ repoRoot, branch, author, authorEmail, remoteUrl }),
+    skipped: reason,
+  };
+}
+
+function extToLanguage(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return ext ? ext.slice(1) : null;
+}
+
+module.exports = {
+  runPreCommit,
+};

package/src/config.js

@@ -0,0 +1,108 @@
+const fs = require("fs");
+const path = require("path");
+const {
+  CONFIG_FILE_NAME,
+  DEFAULT_EXCLUDE_PATTERNS,
+  DEFAULT_SOURCE_EXTENSIONS,
+} = require("./constants");
+
+function loadConfig(repoRoot) {
+  const defaults = {
+    highThreshold: 0.85,
+    sourceExtensions: DEFAULT_SOURCE_EXTENSIONS,
+    excludeRegexes: DEFAULT_EXCLUDE_PATTERNS.map((item) => item.source),
+    eventsDirectory: [".cursor/animus-ai-events.jsonl", ".cursor/local-ai-events"],
+    membersFile: null,
+    serverBaseUrl: null,
+    silentTokenPath: "/api/cursor-board/auth/silent-token",
+    commitReportPath: "/api/cursor-board/commit-reports",
+    requestTimeoutMs: 5000,
+  };
+
+  const configPath = path.join(repoRoot, CONFIG_FILE_NAME);
+  if (!fs.existsSync(configPath)) {
+    return defaults;
+  }
+
+  try {
+    const parsed = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    return {
+      highThreshold:
+        typeof parsed.highThreshold === "number"
+          ? parsed.highThreshold
+          : defaults.highThreshold,
+      sourceExtensions: Array.isArray(parsed.sourceExtensions)
+        ? parsed.sourceExtensions
+        : defaults.sourceExtensions,
+      excludeRegexes: Array.isArray(parsed.excludeRegexes)
+        ? parsed.excludeRegexes
+        : defaults.excludeRegexes,
+      eventsDirectory: normalizeEventsDirectoryConfig(parsed.eventsDirectory, defaults.eventsDirectory),
+      membersFile:
+        typeof parsed.membersFile === "string" ? parsed.membersFile : defaults.membersFile,
+      serverBaseUrl:
+        typeof parsed.serverBaseUrl === "string"
+          ? parsed.serverBaseUrl
+          : defaults.serverBaseUrl,
+      silentTokenPath:
+        typeof parsed.silentTokenPath === "string"
+          ? parsed.silentTokenPath
+          : defaults.silentTokenPath,
+      commitReportPath:
+        typeof parsed.commitReportPath === "string"
+          ? parsed.commitReportPath
+          : defaults.commitReportPath,
+      requestTimeoutMs:
+        Number.isFinite(Number(parsed.requestTimeoutMs)) && Number(parsed.requestTimeoutMs) > 0
+          ? Number(parsed.requestTimeoutMs)
+          : defaults.requestTimeoutMs,
+    };
+  } catch (error) {
+    return { ...defaults, configError: error.message };
+  }
+}
+
+function normalizeEventsDirectoryConfig(input, fallback) {
+  if (typeof input === "string" && input.trim()) {
+    return [input.trim()];
+  }
+  if (Array.isArray(input)) {
+    const items = input.map((item) => String(item || "").trim()).filter(Boolean);
+    if (items.length) {
+      return items;
+    }
+  }
+  return Array.isArray(fallback) ? [...fallback] : [String(fallback || "").trim()].filter(Boolean);
+}
+
+function createPathFilters(config) {
+  const extSet = new Set(
+    (config.sourceExtensions || []).map((ext) => ext.toLowerCase().trim()).filter(Boolean)
+  );
+  const excludes = (config.excludeRegexes || [])
+    .map((pattern) => {
+      try {
+        return new RegExp(pattern, "i");
+      } catch (_error) {
+        return null;
+      }
+    })
+    .filter(Boolean);
+
+  return function isSourceFile(filePath) {
+    const normalized = filePath.replace(/\\/g, "/");
+    if (!normalized || normalized === "/dev/null") {
+      return false;
+    }
+    if (excludes.some((regex) => regex.test(normalized))) {
+      return false;
+    }
+    const extension = path.extname(normalized).toLowerCase();
+    return extSet.has(extension);
+  };
+}
+
+module.exports = {
+  loadConfig,
+  createPathFilters,
+};

package/src/constants.js

@@ -0,0 +1,61 @@
+const path = require("path");
+const { version: CLI_VERSION = "0.0.0" } = require("../package.json");
+
+const DEFAULT_SOURCE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".vue",
+  ".css",
+  ".scss",
+  ".less",
+  ".html",
+  ".json",
+  ".mdx",
+  ".py",
+  ".go",
+  ".java",
+  ".kt",
+  ".rs",
+  ".swift",
+  ".rb",
+  ".php",
+  ".c",
+  ".cc",
+  ".cpp",
+  ".h",
+  ".hpp",
+];
+
+const DEFAULT_EXCLUDE_PATTERNS = [
+  /(^|\/)dist\//i,
+  /(^|\/)build\//i,
+  /(^|\/)coverage\//i,
+  /\.min\./i,
+  /(^|\/).*lock(\.json)?$/i,
+  /(^|\/)pnpm-lock\.yaml$/i,
+  /(^|\/)yarn\.lock$/i,
+  /(^|\/)bun\.lockb?$/i,
+  /(^|\/)package-lock\.json$/i,
+  /(^|\/)generated\//i,
+];
+
+const CONFIG_FILE_NAME = ".cursor-roi-tracker.json";
+const CURSOR_DIR = ".cursor";
+const PENDING_REPORT_PATH = path.join(CURSOR_DIR, "ai-commit-report.pending.json");
+const FINAL_REPORT_PATH = path.join(CURSOR_DIR, "ai-commit-report.final.json");
+const HISTORY_PATH = path.join(CURSOR_DIR, "ai-commit-history.jsonl");
+const ERROR_HISTORY_PATH = path.join(CURSOR_DIR, "ai-commit-errors.jsonl");
+
+module.exports = {
+  DEFAULT_SOURCE_EXTENSIONS,
+  DEFAULT_EXCLUDE_PATTERNS,
+  CONFIG_FILE_NAME,
+  CURSOR_DIR,
+  CLI_VERSION,
+  PENDING_REPORT_PATH,
+  FINAL_REPORT_PATH,
+  HISTORY_PATH,
+  ERROR_HISTORY_PATH,
+};

package/src/diff-parser.js

@@ -0,0 +1,99 @@
+function parseUnifiedDiff(diffText) {
+  const fileMetrics = [];
+  let currentFile = null;
+
+  const lines = String(diffText || "").split("\n");
+
+  for (const line of lines) {
+    if (line.startsWith("diff --git")) {
+      if (currentFile) {
+        fileMetrics.push(finalizeFile(currentFile));
+      }
+      currentFile = null;
+      continue;
+    }
+
+    if (line.startsWith("+++ b/")) {
+      const filePath = line.slice("+++ b/".length).trim();
+      currentFile = {
+        filePath,
+        addedLines: 0,
+        deletedLines: 0,
+        hunks: [],
+      };
+      continue;
+    }
+
+    if (line.startsWith("+++ /dev/null")) {
+      currentFile = null;
+      continue;
+    }
+
+    if (!currentFile) {
+      continue;
+    }
+
+    if (line.startsWith("@@ ")) {
+      const hunk = parseHunkHeader(line);
+      if (hunk) {
+        currentFile.hunks.push(hunk);
+      }
+      continue;
+    }
+
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      currentFile.addedLines += 1;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      currentFile.deletedLines += 1;
+    }
+  }
+
+  if (currentFile) {
+    fileMetrics.push(finalizeFile(currentFile));
+  }
+
+  let totalAddedLines = 0;
+  let totalDeletedLines = 0;
+  for (const item of fileMetrics) {
+    totalAddedLines += item.addedLines;
+    totalDeletedLines += item.deletedLines;
+  }
+
+  return {
+    fileMetrics,
+    totalAddedLines,
+    totalDeletedLines,
+    affectedFilesCount: fileMetrics.length,
+  };
+}
+
+function parseHunkHeader(line) {
+  const match = line.match(
+    /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/
+  );
+  if (!match) {
+    return null;
+  }
+  return {
+    oldStart: Number(match[1]),
+    oldCount: Number(match[2] ?? 1),
+    newStart: Number(match[3]),
+    newCount: Number(match[4] ?? 1),
+  };
+}
+
+function finalizeFile(file) {
+  return {
+    filePath: file.filePath,
+    addedLines: file.addedLines,
+    deletedLines: file.deletedLines,
+    aiAddedLines: 0,
+    aiDeletedLines: 0,
+    aiTouched: false,
+    hunks: file.hunks,
+  };
+}
+
+module.exports = {
+  parseUnifiedDiff,
+};

package/src/event-store.js

@@ -0,0 +1,91 @@
+const fs = require("fs");
+const path = require("path");
+const { acquireMutexLock, releaseMutexLock, resolveEventLockPath } = require("./mutex-lock");
+
+async function compactConsumedEvents(repoRoot, cleanupPlan) {
+  if (!Array.isArray(cleanupPlan) || cleanupPlan.length === 0) {
+    return { compactedFiles: 0, removedEvents: 0, parseErrors: 0 };
+  }
+
+  const lockPath = resolveEventLockPath(repoRoot);
+  const lockHandle = await acquireMutexLock(lockPath);
+  try {
+    let compactedFiles = 0;
+    let removedEvents = 0;
+    let parseErrors = 0;
+
+    for (const entry of cleanupPlan) {
+      const result = await compactSingleSource(repoRoot, entry);
+      compactedFiles += result.compacted ? 1 : 0;
+      removedEvents += result.removedEvents;
+      parseErrors += result.parseErrors;
+    }
+
+    return { compactedFiles, removedEvents, parseErrors };
+  } finally {
+    await releaseMutexLock(lockHandle);
+  }
+}
+
+async function compactSingleSource(repoRoot, entry) {
+  const sourceFile = String(entry?.sourceFile || "").trim();
+  if (!sourceFile) {
+    return { compacted: false, removedEvents: 0, parseErrors: 0 };
+  }
+  const consumedIds = new Set(
+    Array.isArray(entry?.consumedEventIds)
+      ? entry.consumedEventIds.map((item) => String(item || "").trim()).filter(Boolean)
+      : []
+  );
+  if (!consumedIds.size) {
+    return { compacted: false, removedEvents: 0, parseErrors: 0 };
+  }
+
+  const filePath = path.isAbsolute(sourceFile) ? sourceFile : path.join(repoRoot, sourceFile);
+  if (!fs.existsSync(filePath)) {
+    return { compacted: false, removedEvents: 0, parseErrors: 0 };
+  }
+
+  const originalText = await fs.promises.readFile(filePath, "utf8");
+  const hadTrailingNewline = originalText.endsWith("\n");
+  const lines = originalText.split("\n");
+  const keptLines = [];
+  let removedEvents = 0;
+  let parseErrors = 0;
+
+  for (const line of lines) {
+    if (!line.trim()) {
+      keptLines.push(line);
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(line);
+      const eventId = String(parsed?.eventId || parsed?.event_id || "").trim();
+      if (eventId && consumedIds.has(eventId)) {
+        removedEvents += 1;
+        continue;
+      }
+      keptLines.push(line);
+    } catch (_error) {
+      parseErrors += 1;
+      keptLines.push(line);
+    }
+  }
+
+  if (removedEvents <= 0) {
+    return { compacted: false, removedEvents: 0, parseErrors };
+  }
+
+  let nextText = keptLines.join("\n");
+  if (hadTrailingNewline && nextText && !nextText.endsWith("\n")) {
+    nextText += "\n";
+  }
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await fs.promises.writeFile(tempPath, nextText, "utf8");
+  await fs.promises.rename(tempPath, filePath);
+  return { compacted: true, removedEvents, parseErrors };
+}
+
+module.exports = {
+  compactConsumedEvents,
+};