@review-my-code/rmcode 0.1.6 → 0.1.8

package/dist/cli.js

@@ -9,7 +9,7 @@ const path_1 = require("path");
 const readline_1 = require("readline");
 const API_URL = process.env.RMC_API_URL || "https://review-my-code.com";
 const APP_URL = process.env.RMC_APP_URL || "https://review-my-code.com";
-const VERSION = "0.1.6";
+const VERSION = "0.1.8";
 const FREE_PLAN_CREDITS_PER_MONTH = 30;
 const REQUEST_TIMEOUT_MS = 290_000;
 const POLL_TIMEOUT_MS = 10 * 60_000;
@@ -97,6 +97,62 @@ function gitQuietIn(cwd, args) {
         stdio: ["ignore", "pipe", "ignore"],
     }).trim();
 }
+function runQuietAsync(cmd, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let stdout = "";
+        let stderr = "";
+        const child = (0, child_process_1.spawn)(cmd, args, {
+            cwd: options.cwd,
+            env: options.env ? { ...process.env, ...options.env } : process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const timer = options.timeoutMs && options.timeoutMs > 0
+            ? setTimeout(() => {
+                child.kill("SIGTERM");
+                finish(new Error(`${cmd} ${args.join(" ")} timed out after ${formatElapsed(options.timeoutMs)}.`));
+            }, options.timeoutMs)
+            : null;
+        function finish(err, output = "") {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            if (err)
+                reject(err);
+            else
+                resolve(output.trim());
+        }
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", (err) => finish(err));
+        child.on("close", (code, signal) => {
+            if (code === 0) {
+                finish(undefined, stdout);
+                return;
+            }
+            finish(new Error(`${cmd} ${args.join(" ")} failed${signal ? ` with signal ${signal}` : ` with exit code ${code}`}. ${stderr.slice(0, 240).trim()}`.trim()));
+        });
+    });
+}
+function gitQuietInAsync(cwd, args) {
+    return runQuietAsync("git", ["-C", cwd, ...args], {
+        timeoutMs: REQUEST_TIMEOUT_MS,
+    });
+}
+function gitQuietInAsyncWithEnv(cwd, args, env) {
+    return runQuietAsync("git", ["-C", cwd, ...args], {
+        env,
+        timeoutMs: REQUEST_TIMEOUT_MS,
+    });
+}
 function isGitRepo() {
     try {
         git(["rev-parse", "--is-inside-work-tree"]);
@@ -239,21 +295,42 @@ function parsePrReference(value) {
         number: Number.parseInt(match[2], 10),
     };
 }
+let cachedGithubToken;
 function githubToken() {
+    if (cachedGithubToken !== undefined)
+        return cachedGithubToken || undefined;
     const envToken = process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
-    if (envToken?.trim())
-        return envToken.trim();
+    if (envToken?.trim()) {
+        cachedGithubToken = envToken.trim();
+        return cachedGithubToken;
+    }
     try {
-        return (0, child_process_1.execFileSync)("gh", ["auth", "token"], {
+        const token = (0, child_process_1.execFileSync)("gh", ["auth", "token"], {
             encoding: "utf-8",
             stdio: ["ignore", "pipe", "ignore"],
             timeout: 5_000,
         }).trim();
+        cachedGithubToken = token || null;
+        return cachedGithubToken || undefined;
     }
     catch {
+        cachedGithubToken = null;
         return undefined;
     }
 }
+function githubGitAuthEnv(cloneUrl) {
+    if (!/^https:\/\/github\.com\//i.test(cloneUrl))
+        return undefined;
+    const token = githubToken();
+    if (!token)
+        return undefined;
+    const basicToken = Buffer.from(`x-access-token:${token}`).toString("base64");
+    return {
+        GIT_CONFIG_COUNT: "1",
+        GIT_CONFIG_KEY_0: "http.https://github.com/.extraheader",
+        GIT_CONFIG_VALUE_0: `AUTHORIZATION: basic ${basicToken}`,
+    };
+}
 function githubHeaders(accept) {
     const headers = {
         Accept: accept,
@@ -312,7 +389,7 @@ async function fetchPrDiff(ref) {
     return fetchGithubText(`/repos/${ref.ownerRepo}/pulls/${ref.number}`, "application/vnd.github.v3.diff");
 }
 function rmcodeCacheRoot() {
-    return process.env.RMC_CACHE_DIR || (0, path_1.join)((0, os_1.homedir)(), ".cache", "rmcode");
+    return process.env.RMC_CACHE_DIR || (0, path_1.join)((0, os_1.homedir)(), ".rmcode");
 }
 function prCacheRoot() {
     return process.env.RMC_PR_CACHE_DIR || (0, path_1.join)(rmcodeCacheRoot(), "pr-repos");
@@ -320,39 +397,82 @@ function prCacheRoot() {
 function safeCacheName(ownerRepo) {
     return ownerRepo.toLowerCase().replace(/[^a-z0-9._-]+/g, "__");
 }
-function ensurePrCacheDir(metadata) {
+async function ensurePrCacheDir(metadata) {
     const root = prCacheRoot();
     (0, fs_1.mkdirSync)(root, { recursive: true });
     const cacheDir = (0, path_1.join)(root, safeCacheName(metadata.baseRepo));
+    const gitAuthEnv = githubGitAuthEnv(metadata.cloneUrl);
+    // We only need the PR base commit's tree so the extractor can check it out
+    // in a detached worktree. A full `git clone` pulls the repo's entire history
+    // and every branch — gigabytes for large monorepos, which reliably blew past
+    // the timeout and left an unusable cache. Instead, init a local repo once and
+    // shallow-fetch just the single base commit (one snapshot, no history).
     if (!(0, fs_1.existsSync)((0, path_1.join)(cacheDir, ".git"))) {
-        const clone = (0, child_process_1.spawnSync)("git", ["clone", "--no-checkout", metadata.cloneUrl, cacheDir], { stdio: "ignore", timeout: REQUEST_TIMEOUT_MS });
-        if (clone.status !== 0) {
-            throw new Error(`Could not clone ${metadata.baseRepo} into rmcode cache.`);
+        if ((0, fs_1.existsSync)(cacheDir))
+            (0, fs_1.rmSync)(cacheDir, { recursive: true, force: true });
+        (0, fs_1.mkdirSync)(cacheDir, { recursive: true });
+        try {
+            await gitQuietInAsync(cacheDir, ["init", "--quiet"]);
+            await gitQuietInAsync(cacheDir, [
+                "remote",
+                "add",
+                "origin",
+                metadata.cloneUrl,
+            ]);
+        }
+        catch (err) {
+            (0, fs_1.rmSync)(cacheDir, { recursive: true, force: true });
+            throw new Error(`Could not initialize the rmcode PR cache for ${metadata.baseRepo}. ${err.message}`);
         }
     }
     else {
         try {
-            gitQuietIn(cacheDir, ["remote", "set-url", "origin", metadata.cloneUrl]);
+            await gitQuietInAsync(cacheDir, [
+                "remote",
+                "set-url",
+                "origin",
+                metadata.cloneUrl,
+            ]);
         }
         catch {
             // Keep the existing remote; the next fetch will report any real issue.
         }
     }
+    // Shallow-fetch only the base commit. Fetching by SHA works on GitHub for
+    // commits reachable from a ref; fall back to the base branch ref if the
+    // server rejects an explicit SHA in the want (the rev-parse below then
+    // confirms the SHA actually arrived).
     try {
-        gitQuietIn(cacheDir, ["fetch", "--no-tags", "origin", metadata.baseSha]);
+        await gitQuietInAsyncWithEnv(cacheDir, [
+            "fetch",
+            "--no-tags",
+            "--depth=1",
+            "origin",
+            metadata.baseSha,
+        ], gitAuthEnv);
     }
     catch {
-        gitQuietIn(cacheDir, ["fetch", "--no-tags", "origin", metadata.baseRef]);
+        await gitQuietInAsyncWithEnv(cacheDir, [
+            "fetch",
+            "--no-tags",
+            "--depth=1",
+            "origin",
+            metadata.baseRef,
+        ], gitAuthEnv);
     }
     try {
-        gitQuietIn(cacheDir, ["rev-parse", "--verify", metadata.baseSha]);
+        await gitQuietInAsync(cacheDir, [
+            "rev-parse",
+            "--verify",
+            metadata.baseSha,
+        ]);
     }
     catch {
         throw new Error(`Could not fetch PR base commit ${metadata.baseSha} into the rmcode cache.`);
     }
     return cacheDir;
 }
-async function diffFromPullRequest(value) {
+async function diffFromPullRequest(value, progress) {
     const ref = typeof value === "string" ? parsePrReference(value) : value;
     const [metadata, diff] = await Promise.all([
         fetchPrMetadata(ref),
@@ -361,7 +481,8 @@ async function diffFromPullRequest(value) {
     if (!diff.trim()) {
         throw new Error(`GitHub returned an empty diff for ${metadata.htmlUrl}.`);
     }
-    const cacheDir = ensurePrCacheDir(metadata);
+    progress?.update(`Preparing PR cache for ${metadata.baseRepo}`);
+    const cacheDir = await ensurePrCacheDir(metadata);
     return {
         diff,
         files: filesFromDiff(diff),
@@ -1047,7 +1168,7 @@ async function runPullRequestReview(prValue, jsonMode, failOnFindings, options)
     }
     const spinner = createSpinner(`Fetching GitHub PR ${prValue}`);
     try {
-        const source = await diffFromPullRequest(ref);
+        const source = await diffFromPullRequest(ref, spinner);
         spinner.stop(`Fetched ${source.metadata.baseRepo}#${source.metadata.number}`);
         const contextOptions = {
             prTitle: firstNonEmpty(options.title, process.env.RMC_PR_TITLE, source.metadata.title),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@review-my-code/rmcode",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "AI code review from your terminal. Catches logic errors, null risks, security holes, and broken error handling.",
   "keywords": [
     "code-review",