@review-my-code/rmcode 0.1.2 → 0.1.4

package/README.md

@@ -21,7 +21,7 @@ rmcode --staged        # review staged changes
 rmcode --unstaged      # review unstaged changes
 rmcode --all           # review uncommitted tracked changes and safe text files
 rmcode src/auth.ts     # review one file
-git diff main | rmcode --lang typescript
+git diff main | rmcode  # review a custom diff; language is detected from filenames
 rmcode --json --fail-on-findings
 ```
 

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.2";
+const VERSION = "0.1.4";
 const FREE_PLAN_CREDITS_PER_MONTH = 30;
 const REQUEST_TIMEOUT_MS = 290_000;
 const POLL_TIMEOUT_MS = 10 * 60_000;
@@ -199,7 +199,7 @@ function pseudoDiffForNewFile(file, worktreeRoot) {
 }
 function gitRepoName() {
     try {
-        const remote = git(["remote", "get-url", "origin"]);
+        const remote = gitQuiet(["remote", "get-url", "origin"]);
         const m = remote.match(/github\.com[:/]([^/]+\/[^/.]+)/);
         return m ? m[1] : null;
     }
@@ -215,6 +215,36 @@ function currentBranch() {
         return "unknown";
     }
 }
+function headCommitSubject() {
+    try {
+        return gitQuiet(["log", "-1", "--pretty=%s"]) || null;
+    }
+    catch {
+        return null;
+    }
+}
+function firstNonEmpty(...values) {
+    for (const value of values) {
+        const trimmed = value?.trim();
+        if (trimmed)
+            return trimmed;
+    }
+    return undefined;
+}
+function parseOptionalPositiveInt(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return undefined;
+    const parsed = Number.parseInt(trimmed, 10);
+    return Number.isInteger(parsed) && parsed >= 0 ? parsed : undefined;
+}
+function contextOptionsFromCli(options) {
+    return {
+        prTitle: firstNonEmpty(options.title, process.env.RMC_PR_TITLE, headCommitSubject()),
+        prNumber: parseOptionalPositiveInt(firstNonEmpty(options.prNumber, process.env.RMC_PR_NUMBER)),
+        sourceRepo: firstNonEmpty(options.sourceRepo, process.env.RMC_SOURCE_REPO, gitRepoName(), "local/repo"),
+    };
+}
 function filesFromDiff(diff) {
     const files = new Set();
     const re = /^diff --git a\/.+ b\/(.+)$/gm;
@@ -466,7 +496,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) {
+async function extractContextBundle(diff, baseRef, contextOptions = {}) {
     const info = await fetchExtractorInfo();
     if (!info)
         return null;
@@ -490,10 +520,11 @@ async function extractContextBundle(diff, baseRef) {
         (0, fs_1.writeFileSync)(diffPath, diff);
         const result = (0, child_process_1.spawnSync)(process.execPath, [
             extractorPath,
-            "--pr=0",
+            `--pr=${contextOptions.prNumber ?? 0}`,
             `--diff-file=${diffPath}`,
             `--output-bundle=${bundlePath}`,
-            `--source-repo=${process.env.RMC_SOURCE_REPO || gitRepoName() || "local/repo"}`,
+            `--source-repo=${contextOptions.sourceRepo || "local/repo"}`,
+            `--pr-title=${contextOptions.prTitle || ""}`,
             `--tier=${info.tier || "free"}`,
         ], {
             cwd: baseDir,
@@ -544,11 +575,11 @@ async function extractContextBundle(diff, baseRef) {
  * 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) {
+async function maybeExtractContext(diff, spinner, baseRef, contextOptions = {}) {
     if (!API_KEY || !baseRef || !isGitRepo())
         return null;
     try {
-        const bundle = await extractContextBundle(diff, baseRef);
+        const bundle = await extractContextBundle(diff, baseRef, contextOptions);
         if (bundle)
             return bundle;
     }
@@ -775,7 +806,7 @@ function createSpinner(msg) {
     };
 }
 // ── Review runner ─────────────────────────────────────────────────────
-async function runReview(content, files, label, jsonMode, failOnFindings, type = "diff", language, baseRef) {
+async function runReview(content, files, label, jsonMode, failOnFindings, type = "diff", language, baseRef, contextOptions = {}) {
     const startedAt = Date.now();
     const lang = language || detectLanguage(files);
     const uploadMsg = `Uploading review request (${files.length} file${files.length !== 1 ? "s" : ""}, ${lang})`;
@@ -786,7 +817,7 @@ async function runReview(content, files, label, jsonMode, failOnFindings, type =
     const willExtract = type === "diff" && Boolean(API_KEY) && Boolean(baseRef) && isGitRepo();
     const spinner = createSpinner(willExtract ? "Extracting repository context" : uploadMsg);
     const bundle = willExtract
-        ? await maybeExtractContext(content, spinner, baseRef)
+        ? await maybeExtractContext(content, spinner, baseRef, contextOptions)
         : null;
     if (willExtract)
         spinner.update(uploadMsg);
@@ -834,13 +865,17 @@ ${header}
     ${style("rmcode <file>", c.cyan)}             Review a single local file
     ${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
     ${style("rmcode help", c.cyan)}               Show this help
 
   ${style("OPTIONS", c.bold)}
 
     --json               Output the full API response as JSON (for CI/agents)
     --fail-on-findings   Exit 2 when JSON output contains findings
-    --lang <language>    Language hint for stdin input
+    --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
+    --source-repo <repo> Optional owner/repo hint when no origin remote exists
     --help, -h           Show this help
     --version, -v        Show version
 
@@ -862,7 +897,7 @@ ${header}
     rmcode --staged
 
     ${style("# Review a specific range", c.dim)}
-    git diff abc123..def456 | rmcode --lang typescript
+    git diff abc123..def456 | rmcode
 
     ${style("# Review one file", c.dim)}
     rmcode src/auth.ts
@@ -878,6 +913,9 @@ ${header}
     RMC_API_KEY          API key for authenticated reviews (get one: rmcode login)
     RMC_API_URL          API endpoint (default: https://review-my-code.com)
     RMC_APP_URL          App URL for login (default: https://review-my-code.com)
+    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
 
   ${style("PRIVACY", c.bold)}
 
@@ -889,33 +927,181 @@ ${header}
   ${style("https://review-my-code.com", c.dim)}
 `);
 }
-// ── Version check ─────────────────────────────────────────────────────
-async function checkForUpdate() {
+// ── Self-update ───────────────────────────────────────────────────────
+const PACKAGE_NAME = "@review-my-code/rmcode";
+const REGISTRY_LATEST_URL = process.env.RMC_REGISTRY_LATEST_URL ||
+    "https://registry.npmjs.org/@review-my-code%2Frmcode/latest";
+/** Resolved real path of the running entry script, for install detection. */
+function entryScriptPath() {
+    const binPath = process.argv[1] || "";
     try {
-        const resp = await fetch("https://registry.npmjs.org/@review-my-code/rmcode/latest", {
-            signal: AbortSignal.timeout(3000),
-        });
-        if (!resp.ok)
-            return;
-        const data = (await resp.json());
-        if (data.version && data.version !== VERSION) {
-            console.log(style(`\n  Update available: ${VERSION} → ${data.version}`, c.yellow));
-            console.log(style(`  Run: npm install -g @review-my-code/rmcode\n`, c.dim));
+        return (0, fs_1.realpathSync)(binPath);
+    }
+    catch {
+        return binPath;
+    }
+}
+function isNpxInvocation(binPath) {
+    // npm's exec cache lives under .../_npx/<hash>/; older layouts use /npx/.
+    return /[\\/]_?npx[\\/]/.test(binPath);
+}
+function updateCommandFor(binPath) {
+    const ext = process.platform === "win32" ? ".cmd" : "";
+    if (/[\\/]pnpm[\\/]/.test(binPath))
+        return { cmd: `pnpm${ext}`, args: ["add", "-g", `${PACKAGE_NAME}@latest`] };
+    if (/[\\/]bun[\\/]/.test(binPath))
+        return { cmd: "bun", args: ["add", "-g", `${PACKAGE_NAME}@latest`] };
+    return {
+        cmd: `npm${ext}`,
+        args: ["install", "-g", `${PACKAGE_NAME}@latest`],
+    };
+}
+async function runUpdate() {
+    const binPath = entryScriptPath();
+    if (isNpxInvocation(binPath)) {
+        console.log(`\n  ${style("Running via npx — already using the latest published version each run.", c.dim)}\n`);
+        return;
+    }
+    const { cmd, args } = updateCommandFor(binPath);
+    console.log(`\n  ${style(`Updating ${PACKAGE_NAME} via ${cmd}...`, c.bold)}\n`);
+    const result = (0, child_process_1.spawnSync)(cmd, args, { stdio: "inherit" });
+    if (result.status === 0) {
+        const latest = await fetchLatestVersion().catch(() => null);
+        console.log(`\n  ${style("✓", c.green)} ${latest
+            ? `Updated to v${latest}.`
+            : "Updated. Run rmcode --version to confirm."}\n`);
+        return;
+    }
+    console.error(style(`\n  Update failed. Run it manually:`, c.red));
+    console.error(`  ${style([cmd, ...args].join(" "), c.cyan, c.bold)}\n`);
+    process.exit(1);
+}
+// ── Update nudge ──────────────────────────────────────────────────────
+//
+// After a successful human-mode review, print at most one dim line when a
+// newer version is published. The registry is queried at most once per
+// 24h (cached in ~/.config/rmcode/update-check.json) and only after the
+// review output has been printed. Any failure here is silently swallowed
+// — the nudge must never affect review output or exit codes.
+const UPDATE_CHECK_TIMEOUT_MS = 1_500;
+const UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
+function updateCachePath() {
+    return (0, path_1.join)((0, os_1.homedir)(), ".config", "rmcode", "update-check.json");
+}
+async function fetchLatestVersion() {
+    const resp = await fetch(REGISTRY_LATEST_URL, {
+        signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT_MS),
+    });
+    if (!resp.ok)
+        return null;
+    const data = (await resp.json());
+    return typeof data.version === "string" ? data.version : null;
+}
+/** Latest published version, from the daily cache when fresh. */
+async function latestPublishedVersion() {
+    const cachePath = updateCachePath();
+    try {
+        const cached = JSON.parse((0, fs_1.readFileSync)(cachePath, "utf-8"));
+        if (typeof cached.latest === "string" &&
+            typeof cached.checkedAt === "number" &&
+            Date.now() - cached.checkedAt < UPDATE_CHECK_TTL_MS) {
+            return cached.latest;
+        }
+    }
+    catch {
+        // Missing or unreadable cache — fall through to a fresh fetch.
+    }
+    const latest = await fetchLatestVersion();
+    if (!latest)
+        return null;
+    try {
+        (0, fs_1.mkdirSync)((0, path_1.join)((0, os_1.homedir)(), ".config", "rmcode"), { recursive: true });
+        (0, fs_1.writeFileSync)(cachePath, JSON.stringify({ latest, checkedAt: Date.now() }));
+    }
+    catch {
+        // Cache writes are best-effort.
+    }
+    return latest;
+}
+/** Hand-rolled x.y.z compare: 1 if a > b, -1 if a < b, 0 if equal. */
+function compareVersions(a, b) {
+    const pa = a.split(".").map((n) => parseInt(n, 10));
+    const pb = b.split(".").map((n) => parseInt(n, 10));
+    for (let i = 0; i < 3; i++) {
+        const da = pa[i] || 0;
+        const db = pb[i] || 0;
+        if (da !== db)
+            return da > db ? 1 : -1;
+    }
+    return 0;
+}
+async function maybeShowUpdateNudge() {
+    if (noColor || isCI)
+        return;
+    try {
+        const latest = await latestPublishedVersion();
+        if (latest && compareVersions(latest, VERSION) > 0) {
+            console.log(style(`  Update available ${VERSION} → ${latest} · run rmcode update`, c.dim));
         }
     }
     catch {
         /* silent */
     }
 }
+async function enforceLatestCliForReview(jsonMode) {
+    let latest = null;
+    try {
+        latest = await fetchLatestVersion();
+    }
+    catch {
+        return;
+    }
+    if (!latest || compareVersions(latest, VERSION) <= 0)
+        return;
+    const update = updateCommandFor(entryScriptPath());
+    const command = [update.cmd, ...update.args].join(" ");
+    const error = `Update required: rmcode v${latest} is available, but this is v${VERSION}. Run \`${command}\` before reviewing.`;
+    if (jsonMode) {
+        console.log(JSON.stringify({
+            success: false,
+            error,
+            code: "RMC-1006",
+            meta: {
+                currentVersion: VERSION,
+                latestVersion: latest,
+                updateCommand: command,
+            },
+        }));
+    }
+    else {
+        console.error(style(`\n  ${error}\n`, c.yellow));
+    }
+    process.exit(1);
+}
 function parseArgs(args) {
     const flags = new Set();
     const options = {};
     const positional = [];
+    const optionAliases = {
+        "--lang": "lang",
+        "--title": "title",
+        "--pr-title": "title",
+        "--pr-number": "prNumber",
+        "--source-repo": "sourceRepo",
+    };
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
-        if (arg === "--lang") {
-            options.lang = args[i + 1];
-            i++;
+        const eq = arg.indexOf("=");
+        const rawOption = eq > 0 ? arg.slice(0, eq) : arg;
+        const optionName = optionAliases[rawOption];
+        if (optionName) {
+            if (eq > 0) {
+                options[optionName] = arg.slice(eq + 1);
+            }
+            else {
+                options[optionName] = args[i + 1];
+                i++;
+            }
         }
         else if (arg.startsWith("-")) {
             flags.add(arg);
@@ -958,6 +1144,10 @@ async function main() {
         console.error(style(`  Run: rmcode help\n`, c.dim));
         process.exit(1);
     }
+    if (positional[0] === "update") {
+        await runUpdate();
+        return;
+    }
     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`);
@@ -988,11 +1178,13 @@ async function main() {
     }
     const jsonMode = flags.has("--json");
     const failOnFindings = flags.has("--fail-on-findings");
+    const contextOptions = contextOptionsFromCli(options);
     if (positional.length > 1) {
         console.error(style(`\n  Unknown command: ${positional[0]}`, c.red));
         console.error(style(`  Run: rmcode help\n`, c.dim));
         process.exit(1);
     }
+    await enforceLatestCliForReview(jsonMode);
     // Brand header for review runs — stderr so any stdout consumers stay
     // safe; hidden in --json, non-TTY, NO_COLOR, and CI.
     if (!jsonMode && !noColor && !isCI) {
@@ -1000,7 +1192,6 @@ async function main() {
     }
     // Piped stdin
     if (hasPipedStdin()) {
-        const lang = options.lang || "javascript";
         const rl = (0, readline_1.createInterface)({ input: process.stdin });
         const lines = [];
         for await (const line of rl)
@@ -1010,11 +1201,12 @@ async function main() {
             console.error(style("  No input received on stdin.", c.red));
             process.exit(1);
         }
+        const stdinType = looksLikeUnifiedDiff(code) ? "diff" : "snippet";
+        const stdinFiles = stdinType === "diff" ? filesFromDiff(code) : [];
+        const lang = options.lang || detectLanguage(stdinFiles);
         const startedAt = Date.now();
         const spinner = createSpinner(`Uploading review request (stdin, ${lang})`);
         try {
-            const stdinType = looksLikeUnifiedDiff(code) ? "diff" : "snippet";
-            const stdinFiles = stdinType === "diff" ? filesFromDiff(code) : [];
             const result = await callAPI(code, lang, stdinType, stdinFiles, null, spinner);
             spinner.stop("Reviewed stdin");
             if (jsonMode) {
@@ -1054,9 +1246,9 @@ async function main() {
             console.error(style(`  ${file} is empty.`, c.yellow));
             process.exit(0);
         }
-        await runReview(code, [file], file, jsonMode, failOnFindings, "file", detectLanguage([file]));
+        await runReview(code, [file], file, jsonMode, failOnFindings, "file", detectLanguage([file]), undefined, contextOptions);
         if (!jsonMode)
-            await checkForUpdate();
+            await maybeShowUpdateNudge();
         return;
     }
     // Git modes
@@ -1101,14 +1293,14 @@ async function main() {
             process.exit(0);
         }
     }
-    await runReview(diff, files, label, jsonMode, failOnFindings, "diff", undefined, baseRef);
+    await runReview(diff, files, label, jsonMode, failOnFindings, "diff", undefined, baseRef, contextOptions);
     if (!jsonMode && !API_KEY) {
         console.log(style(`  Get ${FREE_PLAN_CREDITS_PER_MONTH} credits/month free: rmcode login`, c.dim));
         console.log(style("  Auto-review every PR: rmcode install", c.dim));
         console.log();
     }
     if (!jsonMode)
-        await checkForUpdate();
+        await maybeShowUpdateNudge();
 }
 main()
     .then(() => {

package/package.json

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