@apdesign/cursor-roi-tracker 0.5.2

package/src/cli-install-hooks.js

@@ -0,0 +1,336 @@
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const { loadConfig } = require("./config");
+const { getGitDir, runGit } = require("./git");
+
+const EVENTS_EXCLUDE_ENTRY = ".cursor/animus-ai-events.jsonl";
+const EXTENSION_VSIX_RELATIVE_PATH = path.join("extension", "animus-cursor-roi-tracker.vsix");
+const ANSI_YELLOW = "\x1b[33m";
+const ANSI_RED = "\x1b[31m";
+const ANSI_RESET = "\x1b[0m";
+
+async function runInstallHooks() {
+  const isAutoMode = process.argv.includes("--auto");
+  const hostProjectRoot = resolveHostProjectRoot();
+  const packageRoot = path.resolve(__dirname, "..");
+  try {
+    const repoRoot = resolveTargetRepoRoot(hostProjectRoot);
+    await trySilentInstallEditorExtension({ packageRoot, isAutoMode });
+
+    if (!repoRoot) {
+      if (!isAutoMode) {
+        process.stderr.write("cursor-roi-tracker: no git repo found, skip hook install.\n");
+      }
+      return;
+    }
+
+    const hooksDir = path.join(getGitDir(repoRoot), "hooks");
+    const preCommitPath = path.join(hooksDir, "pre-commit");
+    const postCommitPath = path.join(hooksDir, "post-commit");
+
+    fs.mkdirSync(hooksDir, { recursive: true });
+
+    const preBlock = buildManagedBlock({
+      packageRoot,
+      script: "bin/pre-commit.js",
+      marker: "cursor-roi-tracker pre-commit",
+    });
+    const postBlock = buildManagedBlock({
+      packageRoot,
+      script: "bin/post-commit.js",
+      marker: "cursor-roi-tracker post-commit",
+    });
+
+    writeHook(preCommitPath, preBlock);
+    writeHook(postCommitPath, postBlock);
+    ensureDefaultConfig(repoRoot);
+    ensureEventsFileExcluded(repoRoot);
+    await exchangeSilentToken(repoRoot, isAutoMode);
+
+    if (!isAutoMode) {
+      process.stdout.write("cursor-roi-tracker hooks installed.\n");
+    }
+  } catch (error) {
+    if (!isAutoMode) {
+      process.stderr.write(`cursor-roi-tracker hook install failed: ${error.message}\n`);
+    }
+  }
+}
+
+async function exchangeSilentToken(repoRoot, isAutoMode) {
+  const config = loadConfig(repoRoot);
+  const serverBaseUrl = resolveServerBaseUrl(config);
+  if (!serverBaseUrl) {
+    return;
+  }
+
+  const email = resolveEmailWithFallback(repoRoot);
+  if (!email) {
+    warn(
+      `cursor-roi-tracker: missing email; run git config --global cursor.email "你的邮箱".`,
+      isAutoMode
+    );
+    return;
+  }
+
+  try {
+    const endpoint = new URL(config.silentTokenPath || "/api/cursor-board/auth/silent-token", serverBaseUrl);
+    const payload = await requestJson(endpoint.toString(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email }),
+    }, config.requestTimeoutMs);
+
+    const accessToken = String(payload?.accessToken || "").trim();
+    if (!accessToken) {
+      throw new Error("silent token response missing accessToken");
+    }
+
+    const gitDir = getGitDir(repoRoot);
+    writeLocalToken(gitDir, accessToken);
+  } catch (error) {
+    warn(`cursor-roi-tracker: silent token exchange failed: ${error.message}`, isAutoMode);
+  }
+}
+
+function buildManagedBlock({ packageRoot, script, marker }) {
+  return `
+# >>> cursor-roi-tracker begin
+# ${marker}
+PACKAGE_ROOT="${packageRoot}"
+if [ -f "$PACKAGE_ROOT/${script}" ]; then
+  node "$PACKAGE_ROOT/${script}" || true
+fi
+# <<< cursor-roi-tracker end
+`;
+}
+
+function writeHook(hookPath, managedBlock) {
+  const shebang = "#!/usr/bin/env sh";
+  const current = fs.existsSync(hookPath) ? fs.readFileSync(hookPath, "utf8") : "";
+
+  let body = current.trim() ? current : shebang;
+  if (!body.startsWith("#!")) {
+    body = `${shebang}\n${body}`;
+  }
+
+  body = body.replace(
+    /\n?# >>> cursor-roi-tracker begin[\s\S]*?# <<< cursor-roi-tracker end\n?/g,
+    "\n"
+  );
+  const nextBody = `${body.trimEnd()}\n${managedBlock.trim()}\n`;
+  fs.writeFileSync(hookPath, nextBody, { mode: 0o755 });
+}
+
+function resolveTargetRepoRoot(hostProjectRoot) {
+  const candidateCwds = [hostProjectRoot, process.cwd(), process.env.INIT_CWD].filter(Boolean);
+
+  for (const cwd of candidateCwds) {
+    const repoRoot = findGitRoot(cwd);
+    if (repoRoot) {
+      return repoRoot;
+    }
+  }
+  return null;
+}
+
+function findGitRoot(startDir) {
+  if (!startDir) {
+    return null;
+  }
+  const resolved = path.resolve(startDir);
+  if (fs.existsSync(path.join(resolved, ".git"))) {
+    return resolved;
+  }
+  try {
+    return runGit(resolved, ["rev-parse", "--show-toplevel"]).trim();
+  } catch (_error) {
+    const parent = path.dirname(resolved);
+    if (parent === resolved) {
+      return null;
+    }
+    return findGitRoot(parent);
+  }
+}
+
+function ensureDefaultConfig(repoRoot) {
+  const configPath = path.join(repoRoot, ".cursor-roi-tracker.json");
+  if (fs.existsSync(configPath)) {
+    return;
+  }
+  const payload = {
+    highThreshold: 0.85,
+    sourceExtensions: [".ts", ".tsx", ".js", ".jsx", ".vue", ".css", ".scss", ".html"],
+    excludeRegexes: [
+      "(^|/)dist/",
+      "(^|/)build/",
+      "\\.min\\.",
+      "(^|/)package-lock\\.json$",
+      "(^|/)pnpm-lock\\.yaml$",
+      "(^|/)yarn\\.lock$",
+    ],
+    eventsDirectory: [".cursor/animus-ai-events.jsonl", ".cursor/local-ai-events"],
+    membersFile: ".cursor/enginuity_yunxiao_members.names.json",
+    serverBaseUrl: "",
+    silentTokenPath: "/api/cursor-board/auth/silent-token",
+    commitReportPath: "/api/cursor-board/commit-reports",
+    requestTimeoutMs: 5000,
+  };
+  fs.writeFileSync(configPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+
+function ensureEventsFileExcluded(repoRoot) {
+  const dotGitPath = path.join(repoRoot, ".git");
+  if (!fs.existsSync(dotGitPath)) {
+    return;
+  }
+  try {
+    const gitDir = getGitDir(repoRoot);
+    appendExcludeEntry(gitDir, EVENTS_EXCLUDE_ENTRY);
+  } catch (_error) {
+    // never block install on local exclude setup
+  }
+}
+
+function resolveEmailWithFallback(repoRoot) {
+  const candidates = [
+    ["config", "cursor.email"],
+    ["config", "user.email"],
+  ];
+  for (const args of candidates) {
+    try {
+      const value = runGit(repoRoot, args).trim();
+      if (value) {
+        return value;
+      }
+    } catch (_error) {
+      // ignore and fallback
+    }
+  }
+  return "";
+}
+
+function resolveServerBaseUrl(config) {
+  const fromEnv = String(process.env.CURSOR_ROI_SERVER_URL || "").trim();
+  const fromConfig = String(config?.serverBaseUrl || "").trim();
+  const value = fromEnv || fromConfig;
+  if (!value) {
+    return "";
+  }
+  return value.endsWith("/") ? value : `${value}/`;
+}
+
+function writeLocalToken(gitDir, accessToken) {
+  const tokenPath = path.join(gitDir, ".local-token");
+  fs.writeFileSync(tokenPath, `${accessToken}\n`, "utf8");
+
+  appendExcludeEntry(gitDir, ".local-token");
+}
+
+function appendExcludeEntry(gitDir, line) {
+  const infoDir = path.join(gitDir, "info");
+  fs.mkdirSync(infoDir, { recursive: true });
+  const excludePath = path.join(infoDir, "exclude");
+  const existing = fs.existsSync(excludePath) ? fs.readFileSync(excludePath, "utf8") : "";
+  const lines = new Set(existing.split(/\r?\n/).map((item) => item.trim()).filter(Boolean));
+  if (lines.has(line)) {
+    return;
+  }
+  const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  fs.appendFileSync(excludePath, `${prefix}${line}\n`, "utf8");
+}
+
+function resolveHostProjectRoot() {
+  const initCwd = String(process.env.INIT_CWD || "").trim();
+  if (initCwd) {
+    return path.resolve(initCwd);
+  }
+  return path.resolve(process.cwd());
+}
+
+async function trySilentInstallEditorExtension({ packageRoot, isAutoMode }) {
+  const vsixPath = path.join(packageRoot, EXTENSION_VSIX_RELATIVE_PATH);
+  const availableCli = detectAvailableEditorCli();
+  if (!availableCli.length) {
+    warnInstallFailure(
+      "no cursor/code CLI found in PATH",
+      vsixPath,
+      isAutoMode
+    );
+    return;
+  }
+  if (!fs.existsSync(vsixPath)) {
+    warnInstallFailure("local VSIX not found", vsixPath, isAutoMode);
+    return;
+  }
+
+  for (const cli of availableCli) {
+    const result = spawnSync(cli, ["--install-extension", vsixPath, "--force"], {
+      encoding: "utf8",
+      timeout: 15000,
+    });
+    if (result.status === 0) {
+      return;
+    }
+  }
+
+  warnInstallFailure("CLI install command failed", vsixPath, isAutoMode);
+}
+
+function detectAvailableEditorCli() {
+  const candidates = process.platform === "win32"
+    ? ["cursor.cmd", "cursor", "code.cmd", "code"]
+    : ["cursor", "code"];
+  const available = [];
+  for (const command of candidates) {
+    const probe = spawnSync(command, ["--version"], { encoding: "utf8", timeout: 5000 });
+    if (probe.status === 0) {
+      available.push(command);
+    }
+  }
+  return available;
+}
+
+function warnInstallFailure(reason, vsixPath, isAutoMode) {
+  const header = `${ANSI_YELLOW}cursor-roi-tracker warning:${ANSI_RESET} ${reason}`;
+  const detail = `${ANSI_RED}Manual install required${ANSI_RESET}: install VSIX from ${vsixPath}`;
+  process.stderr.write(`${header}\n`);
+  process.stderr.write(`${detail}\n`);
+  process.stderr.write('Steps: open Extensions panel -> "Install from VSIX..." -> choose the path above.\n');
+  if (!isAutoMode) {
+    process.stderr.write("cursor-roi-tracker: continuing without blocking npm install.\n");
+  }
+}
+
+async function requestJson(url, init, timeoutMs = 5000) {
+  if (typeof fetch !== "function") {
+    throw new Error("fetch is not available on this Node runtime");
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), Math.max(1, Number(timeoutMs) || 5000));
+  try {
+    const response = await fetch(url, { ...init, signal: controller.signal });
+    const text = await response.text();
+    let payload = {};
+    if (text) {
+      payload = JSON.parse(text);
+    }
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    return payload;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function warn(message, isAutoMode) {
+  if (!isAutoMode) {
+    process.stderr.write(`${message}\n`);
+  }
+}
+
+module.exports = {
+  runInstallHooks,
+};

package/src/cli-post-commit.js

@@ -0,0 +1,176 @@
+const fs = require("fs");
+const path = require("path");
+const { loadConfig } = require("./config");
+const { FINAL_REPORT_PATH } = require("./constants");
+const { getRepoRoot, getGitDir, getHeadSha, getHeadCommitTime } = require("./git");
+const { readPendingReport, writeFinalReport, writeErrorStatus } = require("./report");
+const { compactConsumedEvents } = require("./event-store");
+
+async function runPostCommit() {
+  let repoRoot = process.cwd();
+  try {
+    repoRoot = getRepoRoot(process.cwd());
+    const pending = readPendingReport(repoRoot);
+    if (!pending) {
+      return;
+    }
+
+    const sha = getHeadSha(repoRoot);
+    const commitTime = getHeadCommitTime(repoRoot);
+    pending.commitSha = sha;
+    pending.commitTime = commitTime;
+    pending.generatedAt = Date.now();
+
+    if (Array.isArray(pending.aiBlocks)) {
+      pending.aiBlocks = pending.aiBlocks.map((item) => ({
+        ...item,
+        originalCommitSha: sha,
+      }));
+    }
+
+    writeFinalReport(repoRoot, pending);
+    await compactEventsAfterCommit(repoRoot, pending);
+    await uploadFinalReport(repoRoot);
+  } catch (error) {
+    writeErrorStatus(
+      repoRoot,
+      {
+        code: "POST_COMMIT_BIND_ERROR",
+        message: error?.message || "unknown error",
+      },
+      { stage: "post-commit" }
+    );
+  } finally {
+    process.exit(0);
+  }
+}
+
+async function compactEventsAfterCommit(repoRoot, pendingReport) {
+  try {
+    const cleanupPlan = Array.isArray(pendingReport?.cleanupPlan) ? pendingReport.cleanupPlan : [];
+    if (!cleanupPlan.length) {
+      return;
+    }
+    await compactConsumedEvents(repoRoot, cleanupPlan);
+  } catch (error) {
+    writeErrorStatus(
+      repoRoot,
+      {
+        code: "POST_COMMIT_EVENT_COMPACT_ERROR",
+        message: error?.message || "unknown error",
+      },
+      { stage: "post-commit-compact" }
+    );
+  }
+}
+
+async function uploadFinalReport(repoRoot) {
+  const config = loadConfig(repoRoot);
+  const baseUrl = resolveServerBaseUrl(config);
+  if (!baseUrl) {
+    return;
+  }
+
+  const report = readFinalReport(repoRoot);
+  if (!report) {
+    return;
+  }
+  if (!report.commitSha || !report.repoName || !report.cliVersion) {
+    writeErrorStatus(repoRoot, {
+      code: "POST_COMMIT_UPLOAD_INVALID_REPORT",
+      message: "final report missing commitSha/repoName/cliVersion",
+    }, { stage: "post-commit-upload" });
+    return;
+  }
+
+  const token = readLocalToken(repoRoot);
+  if (!token) {
+    writeErrorStatus(repoRoot, {
+      code: "POST_COMMIT_UPLOAD_MISSING_TOKEN",
+      message: "missing local token file",
+    }, { stage: "post-commit-upload" });
+    return;
+  }
+
+  const endpoint = new URL(config.commitReportPath || "/api/cursor-board/commit-reports", baseUrl);
+  try {
+    await requestJson(
+      endpoint.toString(),
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify(report),
+      },
+      config.requestTimeoutMs
+    );
+  } catch (error) {
+    writeErrorStatus(repoRoot, {
+      code: "POST_COMMIT_UPLOAD_ERROR",
+      message: error?.message || "unknown error",
+    }, { stage: "post-commit-upload", endpoint: endpoint.toString() });
+  }
+}
+
+function readFinalReport(repoRoot) {
+  const candidates = [
+    path.join(repoRoot, FINAL_REPORT_PATH),
+    path.join(repoRoot, FINAL_REPORT_PATH.replace(/^\.cursor\//, ".cursor-roi/")),
+  ];
+  const filePath = candidates.find((item) => fs.existsSync(item));
+  if (!filePath) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (_error) {
+    return null;
+  }
+}
+
+function readLocalToken(repoRoot) {
+  try {
+    const gitDir = getGitDir(repoRoot);
+    const tokenPath = path.join(gitDir, ".local-token");
+    if (!fs.existsSync(tokenPath)) {
+      return "";
+    }
+    return fs.readFileSync(tokenPath, "utf8").trim();
+  } catch (_error) {
+    return "";
+  }
+}
+
+function resolveServerBaseUrl(config) {
+  const fromEnv = String(process.env.CURSOR_ROI_SERVER_URL || "").trim();
+  const fromConfig = String(config?.serverBaseUrl || "").trim();
+  const value = fromEnv || fromConfig;
+  if (!value) {
+    return "";
+  }
+  return value.endsWith("/") ? value : `${value}/`;
+}
+
+async function requestJson(url, init, timeoutMs = 5000) {
+  if (typeof fetch !== "function") {
+    throw new Error("fetch is not available on this Node runtime");
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), Math.max(1, Number(timeoutMs) || 5000));
+  try {
+    const response = await fetch(url, { ...init, signal: controller.signal });
+    const text = await response.text();
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    return text ? JSON.parse(text) : {};
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+module.exports = {
+  runPostCommit,
+};