@apdesign/cursor-roi-tracker 0.5.2

package/src/git.js

@@ -0,0 +1,170 @@
+const path = require("path");
+const { execFileSync } = require("child_process");
+
+function runGit(repoRoot, args) {
+  return execFileSync("git", args, {
+    cwd: repoRoot,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  }).trimEnd();
+}
+
+function getRepoRoot(cwd = process.cwd()) {
+  return runGit(cwd, ["rev-parse", "--show-toplevel"]).trim();
+}
+
+function getGitDir(repoRoot) {
+  const gitDir = runGit(repoRoot, ["rev-parse", "--git-dir"]).trim();
+  if (!gitDir) {
+    throw new Error("Unable to resolve git dir");
+  }
+  return path.isAbsolute(gitDir)
+    ? path.resolve(gitDir)
+    : path.resolve(repoRoot, gitDir);
+}
+
+function getBranch(repoRoot) {
+  try {
+    return runGit(repoRoot, ["rev-parse", "--abbrev-ref", "HEAD"]).trim();
+  } catch (_error) {
+    return runGit(repoRoot, ["symbolic-ref", "--short", "HEAD"]).trim();
+  }
+}
+
+function getAuthor(repoRoot) {
+  return runGit(repoRoot, ["config", "user.name"]).trim();
+}
+
+function getAuthorEmail(repoRoot) {
+  return runGit(repoRoot, ["config", "user.email"]).trim();
+}
+
+function getHeadSha(repoRoot) {
+  return runGit(repoRoot, ["rev-parse", "HEAD"]).trim();
+}
+
+function getHeadCommitTime(repoRoot) {
+  const seconds = Number(runGit(repoRoot, ["show", "-s", "--format=%ct", "HEAD"]).trim());
+  if (!Number.isFinite(seconds)) {
+    return null;
+  }
+  return seconds * 1000;
+}
+
+function getRemoteUrl(repoRoot) {
+  try {
+    const originUrl = runGit(repoRoot, ["remote", "get-url", "origin"]).trim();
+    if (originUrl) {
+      return originUrl;
+    }
+  } catch (_error) {
+    // Fall through to generic remote parsing.
+  }
+
+  try {
+    const remoteList = runGit(repoRoot, ["remote", "-v"]);
+    const lines = remoteList
+      .split("\n")
+      .map((item) => item.trim())
+      .filter(Boolean);
+    const parsed = lines
+      .map((line) => {
+        const match = line.match(/^(\S+)\s+(\S+)\s+\((fetch|push)\)$/i);
+        if (!match) {
+          return null;
+        }
+        return {
+          name: match[1],
+          url: match[2],
+          direction: match[3].toLowerCase(),
+        };
+      })
+      .filter(Boolean);
+
+    const firstFetch = parsed.find((item) => item.direction === "fetch");
+    if (firstFetch?.url) {
+      return firstFetch.url;
+    }
+    return parsed[0]?.url || null;
+  } catch (_error) {
+    return null;
+  }
+}
+
+function maskRemoteUrl(raw) {
+  if (typeof raw !== "string") {
+    return null;
+  }
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  const match = trimmed.match(/(?:[a-z]+:\/\/|[^@]+@)?[^:/]+(?::\d+)?[:/](.+)$/i);
+  if (!match?.[1]) {
+    return null;
+  }
+
+  const slug = match[1]
+    .toLowerCase()
+    .replace(/\.git$/i, "")
+    .replace(/\/+/g, "/")
+    .replace(/^\/+/, "")
+    .trim();
+
+  return slug || null;
+}
+
+function isMergeCommitInProgress(repoRoot) {
+  try {
+    runGit(repoRoot, ["rev-parse", "-q", "--verify", "MERGE_HEAD"]);
+    return true;
+  } catch (_error) {
+    return false;
+  }
+}
+
+function listStagedFiles(repoRoot) {
+  const raw = runGit(repoRoot, ["diff", "--cached", "--name-only", "--diff-filter=ACMR"]);
+  if (!raw.trim()) {
+    return [];
+  }
+  return raw
+    .split("\n")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function getStagedUnifiedDiff(repoRoot, files) {
+  if (!files.length) {
+    return "";
+  }
+
+  const outputParts = [];
+  const batchSize = 200;
+  for (let i = 0; i < files.length; i += batchSize) {
+    const batch = files.slice(i, i + batchSize);
+    const args = ["diff", "--cached", "--unified=0", "--no-color", "--", ...batch];
+    const part = runGit(repoRoot, args);
+    if (part) {
+      outputParts.push(part);
+    }
+  }
+  return outputParts.join("\n");
+}
+
+module.exports = {
+  runGit,
+  getRepoRoot,
+  getGitDir,
+  getBranch,
+  getAuthor,
+  getAuthorEmail,
+  getHeadSha,
+  getHeadCommitTime,
+  getRemoteUrl,
+  maskRemoteUrl,
+  isMergeCommitInProgress,
+  listStagedFiles,
+  getStagedUnifiedDiff,
+};

package/src/index.js

@@ -0,0 +1,9 @@
+const { runPreCommit } = require("./cli-pre-commit");
+const { runPostCommit } = require("./cli-post-commit");
+const { runInstallHooks } = require("./cli-install-hooks");
+
+module.exports = {
+  runPreCommit,
+  runPostCommit,
+  runInstallHooks,
+};

package/src/metrics.js

@@ -0,0 +1,63 @@
+const fs = require("fs");
+const path = require("path");
+
+function extractTaskSerials(branch) {
+  if (!branch || typeof branch !== "string") {
+    return [];
+  }
+  const patterns = [
+    /(?:feature|fix|hotfix|bugfix|task|story|issue)[/\-_]?(\d{4,})/gi,
+    /[A-Z]{2,10}-\d+/g,
+  ];
+  const results = new Set();
+  for (const pattern of patterns) {
+    const matches = branch.match(pattern);
+    if (matches) {
+      for (const m of matches) {
+        results.add(m);
+      }
+    }
+  }
+  return [...results];
+}
+
+function resolveMemberMatch(repoRoot, config, author) {
+  const result = { memberMatched: false, matchedMemberName: null };
+  if (!config.membersFile) {
+    return result;
+  }
+  const membersPath = path.join(repoRoot, config.membersFile);
+  if (!fs.existsSync(membersPath)) {
+    return result;
+  }
+  try {
+    const names = JSON.parse(fs.readFileSync(membersPath, "utf8"));
+    if (!Array.isArray(names)) {
+      return result;
+    }
+    const normalizedAuthor = String(author || "").trim().toLowerCase();
+    const matched = names.find(
+      (name) => String(name || "").trim().toLowerCase() === normalizedAuthor
+    );
+    if (matched) {
+      result.memberMatched = true;
+      result.matchedMemberName = String(matched).trim();
+    }
+  } catch (_error) {
+    // ignore
+  }
+  return result;
+}
+
+function ratio(numerator, denominator) {
+  if (!Number.isFinite(numerator) || !Number.isFinite(denominator) || denominator === 0) {
+    return null;
+  }
+  return Math.round((numerator / denominator) * 1000000) / 1000000;
+}
+
+module.exports = {
+  extractTaskSerials,
+  resolveMemberMatch,
+  ratio,
+};

package/src/mutex-lock.js

@@ -0,0 +1,112 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const crypto = require("crypto");
+
+const DEFAULT_TIMEOUT_MS = 5000;
+const DEFAULT_STALE_LOCK_MS = 5000;
+const DEFAULT_RETRY_BASE_MS = 50;
+const DEFAULT_RETRY_MAX_MS = 500;
+const LOCK_OWNER_FILE = "owner.json";
+
+async function acquireMutexLock(lockDirPath, options = {}) {
+  const timeoutMs = positiveNumber(options.timeoutMs, DEFAULT_TIMEOUT_MS);
+  const staleLockMs = positiveNumber(options.staleLockMs, DEFAULT_STALE_LOCK_MS);
+  const retryBaseMs = positiveNumber(options.retryBaseMs, DEFAULT_RETRY_BASE_MS);
+  const retryMaxMs = Math.max(retryBaseMs, positiveNumber(options.retryMaxMs, DEFAULT_RETRY_MAX_MS));
+  const ownerInfo = {
+    id: crypto.randomUUID(),
+    pid: process.pid,
+    hostname: os.hostname(),
+    startMs: Date.now(),
+  };
+  const ownerPath = path.join(lockDirPath, LOCK_OWNER_FILE);
+  const startedAt = Date.now();
+  let attempt = 0;
+
+  while (Date.now() - startedAt < timeoutMs) {
+    try {
+      await fs.promises.mkdir(lockDirPath, { recursive: false });
+      await fs.promises.writeFile(ownerPath, `${JSON.stringify(ownerInfo)}\n`, "utf8");
+      return { lockDirPath, ownerPath, ownerInfo };
+    } catch (error) {
+      if (error?.code !== "EEXIST") {
+        throw error;
+      }
+    }
+
+    await recoverStaleLock(lockDirPath, ownerPath, staleLockMs);
+
+    const delayMs = Math.min(retryMaxMs, retryBaseMs * Math.pow(2, Math.min(4, attempt)));
+    await sleep(delayMs);
+    attempt += 1;
+  }
+
+  throw new Error(`LOCK_ACQUIRE_TIMEOUT:${lockDirPath}`);
+}
+
+async function releaseMutexLock(lockHandle) {
+  if (!lockHandle?.lockDirPath || !lockHandle?.ownerPath || !lockHandle?.ownerInfo?.id) {
+    return;
+  }
+  const currentOwner = await readOwner(lockHandle.ownerPath);
+  if (!currentOwner || currentOwner.id !== lockHandle.ownerInfo.id) {
+    return;
+  }
+  await fs.promises.rm(lockHandle.lockDirPath, { recursive: true, force: true });
+}
+
+function resolveEventLockPath(repoRoot) {
+  return path.join(repoRoot, ".cursor", "ai-events.lock");
+}
+
+async function recoverStaleLock(lockDirPath, ownerPath, staleLockMs) {
+  const owner = await readOwner(ownerPath);
+  const startedAtMs = Number(owner?.startMs);
+  const now = Date.now();
+  if (Number.isFinite(startedAtMs) && now - startedAtMs <= staleLockMs) {
+    return false;
+  }
+
+  if (!Number.isFinite(startedAtMs)) {
+    const lockStat = await safeStat(lockDirPath);
+    if (lockStat && now - lockStat.mtimeMs <= staleLockMs) {
+      return false;
+    }
+  }
+
+  await fs.promises.rm(lockDirPath, { recursive: true, force: true });
+  return true;
+}
+
+async function readOwner(ownerPath) {
+  try {
+    const text = await fs.promises.readFile(ownerPath, "utf8");
+    return JSON.parse(String(text || "").trim() || "{}");
+  } catch (_error) {
+    return null;
+  }
+}
+
+async function safeStat(filePath) {
+  try {
+    return await fs.promises.stat(filePath);
+  } catch (_error) {
+    return null;
+  }
+}
+
+function positiveNumber(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : fallback;
+}
+
+async function sleep(ms) {
+  await new Promise((resolve) => setTimeout(resolve, Math.max(1, Number(ms) || 1)));
+}
+
+module.exports = {
+  acquireMutexLock,
+  releaseMutexLock,
+  resolveEventLockPath,
+};

package/src/report.js

@@ -0,0 +1,68 @@
+const fs = require("fs");
+const path = require("path");
+const {
+  ERROR_HISTORY_PATH,
+  FINAL_REPORT_PATH,
+  HISTORY_PATH,
+  PENDING_REPORT_PATH,
+} = require("./constants");
+
+function writePendingReport(repoRoot, report) {
+  writeJson(repoRoot, PENDING_REPORT_PATH, report);
+}
+
+function readPendingReport(repoRoot) {
+  const preferredPath = path.join(repoRoot, PENDING_REPORT_PATH);
+  const fallbackPath = path.join(
+    repoRoot,
+    PENDING_REPORT_PATH.replace(/^\.cursor\//, ".cursor-roi/")
+  );
+  const filePath = fs.existsSync(preferredPath) ? preferredPath : fallbackPath;
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function writeFinalReport(repoRoot, report) {
+  writeJson(repoRoot, FINAL_REPORT_PATH, report);
+  appendJsonLine(repoRoot, HISTORY_PATH, report);
+}
+
+function writeErrorStatus(repoRoot, errorStatus, context = {}) {
+  appendJsonLine(repoRoot, ERROR_HISTORY_PATH, {
+    ...context,
+    errorStatus,
+    ts: Date.now(),
+  });
+}
+
+function writeJson(repoRoot, relativePath, payload) {
+  const targetPath = resolveWritablePath(repoRoot, relativePath);
+  fs.writeFileSync(targetPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+
+function appendJsonLine(repoRoot, relativePath, payload) {
+  const targetPath = resolveWritablePath(repoRoot, relativePath);
+  fs.appendFileSync(targetPath, `${JSON.stringify(payload)}\n`, "utf8");
+}
+
+function resolveWritablePath(repoRoot, relativePath) {
+  const preferredPath = path.join(repoRoot, relativePath);
+  try {
+    fs.mkdirSync(path.dirname(preferredPath), { recursive: true });
+    return preferredPath;
+  } catch (_error) {
+    const fallbackRelative = relativePath.replace(/^\.cursor\//, ".cursor-roi/");
+    const fallbackPath = path.join(repoRoot, fallbackRelative);
+    fs.mkdirSync(path.dirname(fallbackPath), { recursive: true });
+    return fallbackPath;
+  }
+}
+
+module.exports = {
+  writePendingReport,
+  readPendingReport,
+  writeFinalReport,
+  writeErrorStatus,
+};