@review-my-code/rmcode 0.1.5 → 0.1.7

package/README.md

@@ -16,14 +16,22 @@ Set `RMC_API_KEY` before running a review; anonymous CLI reviews are disabled.
 
 ```bash
 rmcode                 # review branch diff from merge base
+rmcode --pr 123        # review GitHub PR #123 for this repo
+rmcode --pr https://github.com/owner/repo/pull/123
 rmcode --staged        # review staged changes
 rmcode --unstaged      # review unstaged changes
 rmcode --all           # review all uncommitted changes, including safe text files
 rmcode src/auth.ts     # review one file
 git diff main | rmcode  # review a custom diff; language is detected from filenames
 rmcode --json --fail-on-findings
+rmcode cache clear     # clear reusable PR checkout cache
 rmcode update          # update to the latest CLI
 ```
 
 Review commands check for the latest published CLI before uploading code. If a
 newer version is available, run `rmcode update` and retry.
+
+`rmcode --pr` fetches PR metadata and diff from GitHub, caches a reusable base
+checkout under `~/.cache/rmcode/pr-repos`, and runs the same pinned context
+extractor used for local diff reviews. Use `GH_TOKEN`, `GITHUB_TOKEN`, or
+`gh auth login` for private repositories.

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.5";
+const VERSION = "0.1.7";
 const FREE_PLAN_CREDITS_PER_MONTH = 30;
 const REQUEST_TIMEOUT_MS = 290_000;
 const POLL_TIMEOUT_MS = 10 * 60_000;
@@ -22,6 +22,7 @@ const MAX_UNTRACKED_FILE_BYTES = 512 * 1024;
 const EXTRACTOR_TIMEOUT_MS = 120_000;
 const EXTRACTOR_DOWNLOAD_TIMEOUT_MS = 60_000;
 const EXTRACTOR_INFO_TIMEOUT_MS = 15_000;
+const GITHUB_API_URL = "https://api.github.com";
 // Mirrors the GitHub App workflow template's "Install extractor runtime
 // dependencies" step and REPOMAP_MAX_CHARS env.
 const EXTRACTOR_RUNTIME_DEPS = [
@@ -89,6 +90,69 @@ function gitQuiet(args) {
         stdio: ["ignore", "pipe", "ignore"],
     }).trim();
 }
+function gitQuietIn(cwd, args) {
+    return (0, child_process_1.execFileSync)("git", ["-C", cwd, ...args], {
+        encoding: "utf-8",
+        maxBuffer: 10 * 1024 * 1024,
+        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"]);
@@ -200,13 +264,217 @@ function pseudoDiffForNewFile(file, worktreeRoot) {
 function gitRepoName() {
     try {
         const remote = gitQuiet(["remote", "get-url", "origin"]);
-        const m = remote.match(/github\.com[:/]([^/]+\/[^/.]+)/);
-        return m ? m[1] : null;
+        return ownerRepoFromRemoteUrl(remote);
     }
     catch {
         return null;
     }
 }
+function ownerRepoFromRemoteUrl(remote) {
+    const m = remote.match(/github\.com[:/]([^/]+\/[^/]+?)(?:\.git)?$/i);
+    return m ? m[1].replace(/\.git$/i, "") : null;
+}
+function parsePrReference(value) {
+    const trimmed = value.trim();
+    const numeric = /^\d+$/.test(trimmed)
+        ? Number.parseInt(trimmed, 10)
+        : undefined;
+    if (numeric != null && numeric > 0) {
+        const ownerRepo = gitRepoName();
+        if (!ownerRepo) {
+            throw new Error("Could not infer owner/repo from origin. Use: rmcode --pr https://github.com/owner/repo/pull/123");
+        }
+        return { ownerRepo, number: numeric };
+    }
+    const match = trimmed.match(/^https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/(\d+)(?:[/?#].*)?$/i);
+    if (!match) {
+        throw new Error("Invalid PR reference. Use `rmcode --pr 123` or `rmcode --pr https://github.com/owner/repo/pull/123`.");
+    }
+    return {
+        ownerRepo: match[1].replace(/\.git$/i, ""),
+        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()) {
+        cachedGithubToken = envToken.trim();
+        return cachedGithubToken;
+    }
+    try {
+        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,
+        "User-Agent": `rmcode/${VERSION}`,
+    };
+    const token = githubToken();
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    return headers;
+}
+async function fetchGithubJson(path) {
+    const resp = await fetch(`${GITHUB_API_URL}${path}`, {
+        headers: githubHeaders("application/vnd.github+json"),
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+    if (!resp.ok) {
+        const body = await resp.text().catch(() => "");
+        throw new Error(`GitHub API request failed (${resp.status}). ${body.includes("Not Found")
+            ? "Check the PR URL and GitHub authentication."
+            : body.slice(0, 180)}`.trim());
+    }
+    return (await resp.json());
+}
+async function fetchGithubText(path, accept) {
+    const resp = await fetch(`${GITHUB_API_URL}${path}`, {
+        headers: githubHeaders(accept),
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+    if (!resp.ok) {
+        throw new Error(`GitHub diff request failed (${resp.status}).`);
+    }
+    return resp.text();
+}
+async function fetchPrMetadata(ref) {
+    const pr = await fetchGithubJson(`/repos/${ref.ownerRepo}/pulls/${ref.number}`);
+    const baseRepo = pr.base?.repo?.full_name;
+    const cloneUrl = pr.base?.repo?.clone_url;
+    const baseSha = pr.base?.sha;
+    const baseRef = pr.base?.ref;
+    const headSha = pr.head?.sha;
+    if (!baseRepo || !cloneUrl || !baseSha || !baseRef || !headSha) {
+        throw new Error("GitHub PR metadata is missing base/head information.");
+    }
+    return {
+        number: pr.number,
+        title: pr.title || `PR #${pr.number}`,
+        htmlUrl: pr.html_url || `https://github.com/${ref.ownerRepo}/pull/${ref.number}`,
+        baseRef,
+        baseSha,
+        baseRepo,
+        cloneUrl,
+        headSha,
+    };
+}
+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");
+}
+function prCacheRoot() {
+    return process.env.RMC_PR_CACHE_DIR || (0, path_1.join)(rmcodeCacheRoot(), "pr-repos");
+}
+function safeCacheName(ownerRepo) {
+    return ownerRepo.toLowerCase().replace(/[^a-z0-9._-]+/g, "__");
+}
+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);
+    if (!(0, fs_1.existsSync)((0, path_1.join)(cacheDir, ".git"))) {
+        if ((0, fs_1.existsSync)(cacheDir))
+            (0, fs_1.rmSync)(cacheDir, { recursive: true, force: true });
+        try {
+            await runQuietAsync("git", ["clone", "--no-checkout", metadata.cloneUrl, cacheDir], { env: gitAuthEnv, timeoutMs: REQUEST_TIMEOUT_MS });
+        }
+        catch (err) {
+            throw new Error(`Could not clone ${metadata.baseRepo} into rmcode cache. Make sure GitHub CLI is authenticated with access to the repository. ${err.message}`);
+        }
+    }
+    else {
+        try {
+            await gitQuietInAsync(cacheDir, [
+                "remote",
+                "set-url",
+                "origin",
+                metadata.cloneUrl,
+            ]);
+        }
+        catch {
+            // Keep the existing remote; the next fetch will report any real issue.
+        }
+    }
+    try {
+        await gitQuietInAsyncWithEnv(cacheDir, [
+            "fetch",
+            "--no-tags",
+            "origin",
+            metadata.baseSha,
+        ], gitAuthEnv);
+    }
+    catch {
+        await gitQuietInAsyncWithEnv(cacheDir, [
+            "fetch",
+            "--no-tags",
+            "origin",
+            metadata.baseRef,
+        ], gitAuthEnv);
+    }
+    try {
+        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, progress) {
+    const ref = typeof value === "string" ? parsePrReference(value) : value;
+    const [metadata, diff] = await Promise.all([
+        fetchPrMetadata(ref),
+        fetchPrDiff(ref),
+    ]);
+    if (!diff.trim()) {
+        throw new Error(`GitHub returned an empty diff for ${metadata.htmlUrl}.`);
+    }
+    progress?.update(`Preparing PR cache for ${metadata.baseRepo}`);
+    const cacheDir = await ensurePrCacheDir(metadata);
+    return {
+        diff,
+        files: filesFromDiff(diff),
+        baseRef: metadata.baseSha,
+        metadata,
+        cacheDir,
+    };
+}
+function clearPrCache() {
+    (0, fs_1.rmSync)(prCacheRoot(), { recursive: true, force: true });
+}
 function currentBranch() {
     try {
         return git(["branch", "--show-current"]);
@@ -310,8 +578,8 @@ async function fetchReviewJson(url, init) {
         clearTimeout(timeout);
     }
 }
-async function callAuthenticatedAPI(code, language, type, files, bundle, progress) {
-    const repo = gitRepoName();
+async function callAuthenticatedAPI(code, language, type, files, bundle, progress, repoOverride) {
+    const repo = repoOverride || gitRepoName();
     const payload = {
         type,
         value: code,
@@ -353,8 +621,8 @@ async function callAuthenticatedAPI(code, language, type, files, bundle, progres
     }
     return body;
 }
-async function callAnonymousAPI(code, language, type, files, progress) {
-    const repo = gitRepoName();
+async function callAnonymousAPI(code, language, type, files, progress, repoOverride) {
+    const repo = repoOverride || gitRepoName();
     const { status, body } = await fetchReviewJson(`${API_URL}/api/reviews/anonymous`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
@@ -398,9 +666,9 @@ async function pollForResults(url, initialMeta, headers, progress) {
     }
     return { success: false, error: "Review timed out after 10 minutes." };
 }
-function callAPI(code, language, type = "snippet", files = [], bundle, progress) {
+function callAPI(code, language, type = "snippet", files = [], bundle, progress, repoOverride) {
     if (API_KEY)
-        return callAuthenticatedAPI(code, language, type, files, bundle, progress);
+        return callAuthenticatedAPI(code, language, type, files, bundle, progress, repoOverride);
     return Promise.resolve({
         success: false,
         error: "API key required. Run `rmcode login`, then set RMC_API_KEY before sending code for review.",
@@ -496,7 +764,7 @@ async function ensureExtractor(info) {
  * diff's base state and return the ContextBundle, or null when extraction
  * is unavailable. Throws ExtractorIntegrityError on checksum mismatch.
  */
-async function extractContextBundle(diff, baseRef, contextOptions = {}) {
+async function extractContextBundle(diff, baseRef, contextOptions = {}, repoRoot) {
     const info = await fetchExtractorInfo();
     if (!info)
         return null;
@@ -508,7 +776,12 @@ async function extractContextBundle(diff, baseRef, contextOptions = {}) {
     let worktreeAdded = false;
     try {
         try {
-            gitQuiet(["worktree", "add", "--detach", baseDir, baseRef]);
+            if (repoRoot) {
+                gitQuietIn(repoRoot, ["worktree", "add", "--detach", baseDir, baseRef]);
+            }
+            else {
+                gitQuiet(["worktree", "add", "--detach", baseDir, baseRef]);
+            }
             worktreeAdded = true;
         }
         catch {
@@ -554,12 +827,22 @@ async function extractContextBundle(diff, baseRef, contextOptions = {}) {
     finally {
         if (worktreeAdded) {
             try {
-                gitQuiet(["worktree", "remove", "--force", baseDir]);
+                if (repoRoot) {
+                    gitQuietIn(repoRoot, ["worktree", "remove", "--force", baseDir]);
+                }
+                else {
+                    gitQuiet(["worktree", "remove", "--force", baseDir]);
+                }
             }
             catch {
                 (0, fs_1.rmSync)(baseDir, { recursive: true, force: true });
                 try {
-                    gitQuiet(["worktree", "prune"]);
+                    if (repoRoot) {
+                        gitQuietIn(repoRoot, ["worktree", "prune"]);
+                    }
+                    else {
+                        gitQuiet(["worktree", "prune"]);
+                    }
                 }
                 catch {
                     // Stale worktree metadata only; git prunes it on its own later.
@@ -575,11 +858,11 @@ async function extractContextBundle(diff, baseRef, contextOptions = {}) {
  * Reports progress on the shared review spinner so the run renders as one
  * phase-aware line. Exits the process on extractor checksum mismatch.
  */
-async function maybeExtractContext(diff, spinner, baseRef, contextOptions = {}) {
-    if (!API_KEY || !baseRef || !isGitRepo())
+async function maybeExtractContext(diff, spinner, baseRef, contextOptions = {}, repoRoot) {
+    if (!API_KEY || !baseRef || (!repoRoot && !isGitRepo()))
         return null;
     try {
-        const bundle = await extractContextBundle(diff, baseRef, contextOptions);
+        const bundle = await extractContextBundle(diff, baseRef, contextOptions, repoRoot);
         if (bundle)
             return bundle;
     }
@@ -806,7 +1089,7 @@ function createSpinner(msg) {
     };
 }
 // ── Review runner ─────────────────────────────────────────────────────
-async function runReview(content, files, label, jsonMode, failOnFindings, type = "diff", language, baseRef, contextOptions = {}) {
+async function runReview(content, files, label, jsonMode, failOnFindings, type = "diff", language, baseRef, contextOptions = {}, contextRepoRoot, repoOverride) {
     const startedAt = Date.now();
     const lang = language || detectLanguage(files);
     const uploadMsg = `Uploading review request (${files.length} file${files.length !== 1 ? "s" : ""}, ${lang})`;
@@ -814,15 +1097,18 @@ async function runReview(content, files, label, jsonMode, failOnFindings, type =
     // the diff's base state so the review sees the same repository context.
     // One spinner carries the whole run through its phases. The guard here
     // mirrors maybeExtractContext's own early return.
-    const willExtract = type === "diff" && Boolean(API_KEY) && Boolean(baseRef) && isGitRepo();
+    const willExtract = type === "diff" &&
+        Boolean(API_KEY) &&
+        Boolean(baseRef) &&
+        (Boolean(contextRepoRoot) || isGitRepo());
     const spinner = createSpinner(willExtract ? "Extracting repository context" : uploadMsg);
     const bundle = willExtract
-        ? await maybeExtractContext(content, spinner, baseRef, contextOptions)
+        ? await maybeExtractContext(content, spinner, baseRef, contextOptions, contextRepoRoot)
         : null;
     if (willExtract)
         spinner.update(uploadMsg);
     try {
-        const result = await callAPI(content, lang, type, files, bundle, spinner);
+        const result = await callAPI(content, lang, type, files, bundle, spinner, repoOverride);
         spinner.stop(`Reviewed ${label}`);
         if (jsonMode) {
             printJsonResponse(result);
@@ -848,6 +1134,38 @@ async function runReview(content, files, label, jsonMode, failOnFindings, type =
         process.exit(1);
     }
 }
+async function runPullRequestReview(prValue, jsonMode, failOnFindings, options) {
+    if (!API_KEY) {
+        console.error(style("  API key required. Run `rmcode login`, then set RMC_API_KEY before reviewing a PR.", c.red));
+        process.exit(1);
+    }
+    let ref;
+    try {
+        ref = parsePrReference(prValue);
+    }
+    catch (err) {
+        console.error(style(`  ${err.message}`, c.red));
+        process.exit(1);
+    }
+    const spinner = createSpinner(`Fetching GitHub PR ${prValue}`);
+    try {
+        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),
+            prNumber: source.metadata.number,
+            sourceRepo: firstNonEmpty(options.sourceRepo, process.env.RMC_SOURCE_REPO, source.metadata.baseRepo),
+        };
+        await runReview(source.diff, source.files, `${source.metadata.baseRepo}#${source.metadata.number}`, jsonMode, failOnFindings, "diff", undefined, source.baseRef, contextOptions, source.cacheDir, source.metadata.baseRepo);
+        if (!jsonMode)
+            await maybeShowUpdateNudge();
+    }
+    catch (err) {
+        spinner.stop("PR fetch failed");
+        console.error(style(`  ${err.message}`, c.red));
+        process.exit(1);
+    }
+}
 // ── Help ──────────────────────────────────────────────────────────────
 function printHelp() {
     const header = !noColor && !isCI
@@ -859,10 +1177,13 @@ ${header}
   ${style("COMMANDS", c.bold)}
 
     ${style("rmcode", c.cyan)}                   Review changes from merge base (default)
+    ${style("rmcode --pr 123", c.cyan)}          Review GitHub PR #123 for this repo
+    ${style("rmcode --pr <url>", c.cyan)}        Review a specific GitHub PR URL
     ${style("rmcode --staged", c.cyan)}           Review staged changes only
     ${style("rmcode --unstaged", c.cyan)}         Review unstaged changes only
     ${style("rmcode --all", c.cyan)}              Review all uncommitted changes (staged + unstaged)
     ${style("rmcode <file>", c.cyan)}             Review a single local file
+    ${style("rmcode cache clear", c.cyan)}        Clear cached PR checkouts
     ${style("rmcode login", c.cyan)}              Set up your API key
     ${style("rmcode install", c.cyan)}            Install the GitHub App for automatic PR reviews
     ${style("rmcode update", c.cyan)}             Update rmcode to the latest version
@@ -872,6 +1193,7 @@ ${header}
 
     --json               Output the full API response as JSON (for CI/agents)
     --fail-on-findings   Exit 2 when JSON output contains findings
+    --pr <number|url>    Review a GitHub PR by number or URL
     --lang <language>    Optional language hint for raw stdin snippets
     --title <text>       Optional PR title hint for repository-context reviews
     --pr-number <n>      Optional PR number hint for CI/benchmark parity
@@ -882,6 +1204,7 @@ ${header}
   ${style("MODES", c.bold)}
 
     ${style("Default", c.white)}    Diff from merge base to HEAD — what your PR would contain
+    ${style("--pr", c.white)}       Fetch a GitHub PR diff and cached base checkout for context extraction
     ${style("--staged", c.white)}   Only changes in the staging area (git add)
     ${style("--unstaged", c.white)} Only working directory changes not yet staged
     ${style("--all", c.white)}      Everything not yet committed, including untracked text files
@@ -899,6 +1222,10 @@ ${header}
     ${style("# Review a specific range", c.dim)}
     git diff abc123..def456 | rmcode
 
+    ${style("# Review a GitHub PR without checking it out locally", c.dim)}
+    rmcode --pr 123
+    rmcode --pr https://github.com/owner/repo/pull/123
+
     ${style("# Review one file", c.dim)}
     rmcode src/auth.ts
 
@@ -911,6 +1238,7 @@ ${header}
   ${style("ENVIRONMENT", c.bold)}
 
     RMC_API_KEY          API key for authenticated reviews (get one: rmcode login)
+    RMC_PR_CACHE_DIR     Optional directory for reusable GitHub PR cache clones
     RMC_PR_TITLE         Optional PR title hint for repository-context reviews
     RMC_PR_NUMBER        Optional PR number hint for CI/benchmark parity
     RMC_SOURCE_REPO      Optional owner/repo hint when no origin remote exists
@@ -1082,6 +1410,7 @@ function parseArgs(args) {
     const positional = [];
     const optionAliases = {
         "--lang": "lang",
+        "--pr": "pr",
         "--title": "title",
         "--pr-title": "title",
         "--pr-number": "prNumber",
@@ -1096,10 +1425,13 @@ function parseArgs(args) {
             if (eq > 0) {
                 options[optionName] = arg.slice(eq + 1);
             }
-            else {
+            else if (args[i + 1] && !args[i + 1].startsWith("-")) {
                 options[optionName] = args[i + 1];
                 i++;
             }
+            else {
+                options[optionName] = undefined;
+            }
         }
         else if (arg.startsWith("-")) {
             flags.add(arg);
@@ -1146,6 +1478,15 @@ async function main() {
         await runUpdate();
         return;
     }
+    if (positional[0] === "cache") {
+        if (positional[1] === "clear" && positional.length === 2) {
+            clearPrCache();
+            console.log(`\n  ${style("✓", c.green)} Cleared rmcode PR cache.\n`);
+            return;
+        }
+        console.error(style(`\n  Unknown cache command. Run: rmcode cache clear\n`, c.red));
+        process.exit(1);
+    }
     if (positional[0] === "install") {
         console.log(`\n  ${style("Install the GitHub App for automatic PR reviews:", c.bold)}\n`);
         console.log(`  ${style("https://github.com/apps/rmcode-ai", c.cyan, c.bold)}\n`);
@@ -1177,6 +1518,7 @@ async function main() {
     const jsonMode = flags.has("--json");
     const failOnFindings = flags.has("--fail-on-findings");
     const contextOptions = contextOptionsFromCli(options);
+    const hasPrOption = Object.prototype.hasOwnProperty.call(options, "pr");
     if (positional.length > 1) {
         console.error(style(`\n  Unknown command: ${positional[0]}`, c.red));
         console.error(style(`  Run: rmcode help\n`, c.dim));
@@ -1188,6 +1530,23 @@ async function main() {
     if (!jsonMode && !noColor && !isCI) {
         process.stderr.write(`\n${owlHeader()}\n\n`);
     }
+    if (hasPrOption) {
+        const prValue = options.pr?.trim();
+        if (!prValue) {
+            console.error(style("\n  Missing value for --pr.\n", c.red));
+            process.exit(1);
+        }
+        if (positional.length > 0) {
+            console.error(style("\n  --pr cannot be combined with a file path or command.\n", c.red));
+            process.exit(1);
+        }
+        if (flags.has("--staged") || flags.has("--unstaged") || flags.has("--all")) {
+            console.error(style("\n  --pr cannot be combined with --staged, --unstaged, or --all.\n", c.red));
+            process.exit(1);
+        }
+        await runPullRequestReview(prValue, jsonMode, failOnFindings, options);
+        return;
+    }
     // Piped stdin
     if (hasPipedStdin()) {
         const rl = (0, readline_1.createInterface)({ input: process.stdin });

package/package.json

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