@review-my-code/rmcode 0.1.0-alpha.1

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,487 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const readline_1 = require("readline");
+const API_URL = process.env.RMC_API_URL || "https://review-my-code.com";
+const VERSION = "0.1.0";
+// ── Colors (no dependencies) ──────────────────────────────────────────
+const c = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    gray: "\x1b[90m",
+    white: "\x1b[97m",
+    bgRed: "\x1b[41m",
+    bgYellow: "\x1b[43m",
+    bgGreen: "\x1b[42m",
+    bgBlue: "\x1b[44m",
+};
+const isCI = process.env.CI === "true";
+const noColor = process.env.NO_COLOR === "1" || !process.stdout.isTTY;
+function style(text, ...codes) {
+    if (noColor)
+        return text;
+    return codes.join("") + text + c.reset;
+}
+// ── Severity styling ──────────────────────────────────────────────────
+function severityBadge(severity) {
+    const s = severity.toLowerCase();
+    if (s === "critical" || s === "security")
+        return style(` ${severity.toUpperCase()} `, c.bold, c.bgRed, c.white);
+    if (s === "bug" || s === "high")
+        return style(` ${severity.toUpperCase()} `, c.bold, c.red);
+    if (s === "perf" || s === "medium")
+        return style(` ${severity.toUpperCase()} `, c.bold, c.yellow);
+    return style(` ${severity.toUpperCase()} `, c.dim);
+}
+// ── Git helpers ───────────────────────────────────────────────────────
+function gitDiff(staged) {
+    try {
+        const flag = staged ? "--cached" : "";
+        const diff = (0, child_process_1.execSync)(`git diff ${flag}`, { encoding: "utf-8", maxBuffer: 5 * 1024 * 1024 });
+        return diff.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+function gitStagedFiles() {
+    try {
+        return (0, child_process_1.execSync)("git diff --cached --name-only", { encoding: "utf-8" }).trim().split("\n").filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function gitUnstagedFiles() {
+    try {
+        return (0, child_process_1.execSync)("git diff --name-only", { encoding: "utf-8" }).trim().split("\n").filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function isGitRepo() {
+    try {
+        (0, child_process_1.execSync)("git rev-parse --is-inside-work-tree", { encoding: "utf-8", stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function gitRepoName() {
+    try {
+        const remote = (0, child_process_1.execSync)("git remote get-url origin", {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        const httpsMatch = remote.match(/github\.com\/([^/]+\/[^/.]+)/);
+        if (httpsMatch)
+            return httpsMatch[1];
+        const sshMatch = remote.match(/github\.com:([^/]+\/[^/.]+)/);
+        if (sshMatch)
+            return sshMatch[1];
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+const API_KEY = process.env.RMC_API_KEY || null;
+async function callAuthenticatedAPI(code, language, type, files) {
+    const repo = gitRepoName();
+    const resp = await fetch(`${API_URL}/api/reviews/cli`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "X-API-Key": API_KEY,
+        },
+        body: JSON.stringify({ type, value: code, language, files, repo }),
+    });
+    return resp.json();
+}
+async function callAnonymousAPI(code, language) {
+    const repo = gitRepoName();
+    const resp = await fetch(`${API_URL}/api/reviews/anonymous`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ type: "snippet", value: code, language, repo }),
+    });
+    const result = (await resp.json());
+    // Handle 202 polling
+    if (resp.status === 202 && result.data?.accessToken) {
+        return pollForResults(result.data.accessToken, result.meta);
+    }
+    return result;
+}
+async function pollForResults(accessToken, initialMeta) {
+    const deadline = Date.now() + 60_000;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 2000));
+        const resp = await fetch(`${API_URL}/api/reviews/anonymous/${accessToken}`);
+        const result = (await resp.json());
+        if (result.data?.status === "completed" || result.data?.status === "failed") {
+            if (initialMeta && !result.meta)
+                result.meta = initialMeta;
+            return result;
+        }
+    }
+    return { success: false, error: "Review timed out after 60 seconds." };
+}
+function callAPI(code, language, type = "snippet", files = []) {
+    if (API_KEY) {
+        return callAuthenticatedAPI(code, language, type, files);
+    }
+    return callAnonymousAPI(code, language);
+}
+// ── Language detection ────────────────────────────────────────────────
+const EXT_TO_LANG = {
+    ".ts": "typescript", ".tsx": "typescript", ".js": "javascript", ".jsx": "javascript",
+    ".py": "python", ".java": "java", ".go": "go", ".rs": "rust",
+    ".c": "c", ".cpp": "cpp", ".h": "c", ".cs": "csharp",
+    ".rb": "ruby", ".php": "php", ".swift": "swift", ".kt": "kotlin",
+    ".scala": "scala", ".lua": "lua", ".dart": "dart",
+    ".v": "verilog", ".sv": "verilog", ".vhd": "vhdl",
+    ".glsl": "glsl", ".hlsl": "hlsl", ".wgsl": "wgsl",
+    ".jl": "julia", ".r": "r", ".ex": "elixir", ".erl": "erlang",
+    ".hs": "haskell", ".ml": "ocaml", ".fs": "fsharp",
+    ".sh": "bash", ".zig": "zig", ".sol": "solidity",
+};
+function detectLanguage(files) {
+    for (const f of files) {
+        const ext = (0, path_1.extname)(f).toLowerCase();
+        if (EXT_TO_LANG[ext])
+            return EXT_TO_LANG[ext];
+    }
+    return "javascript";
+}
+// ── Output formatting ─────────────────────────────────────────────────
+function printFindings(findings, jsonMode) {
+    if (jsonMode) {
+        console.log(JSON.stringify(findings, null, 2));
+        return;
+    }
+    if (findings.length === 0) {
+        console.log(`\n  ${style("No issues found.", c.green, c.bold)} Your code looks good.\n`);
+        return;
+    }
+    const counts = {};
+    for (const f of findings) {
+        counts[f.severity] = (counts[f.severity] || 0) + 1;
+    }
+    const summary = Object.entries(counts).map(([k, v]) => `${v} ${k}`).join(" · ");
+    console.log(`\n  ${style(`${findings.length} finding${findings.length !== 1 ? "s" : ""}`, c.bold, c.white)} · ${summary}\n`);
+    for (const f of findings) {
+        const location = f.filePath ? `${style(f.filePath, c.cyan)}${f.line ? `:${f.line}` : ""}` : "";
+        console.log(`  ${severityBadge(f.severity)} ${style(f.title, c.bold, c.white)}`);
+        if (location)
+            console.log(`  ${style("at", c.dim)} ${location}`);
+        console.log(`  ${style(f.explanation, c.gray)}`);
+        if (f.codeContext) {
+            console.log(`  ${style(f.codeContext, c.dim)}`);
+        }
+        if (f.suggestedCode) {
+            console.log(`  ${style("fix:", c.green)} ${style(f.suggestedCode, c.green)}`);
+        }
+        console.log();
+    }
+}
+function printMeta(meta) {
+    if (!meta)
+        return;
+    const parts = [];
+    if (meta.reviewer)
+        parts.push(meta.reviewer.charAt(0).toUpperCase() + meta.reviewer.slice(1));
+    if (meta.plan) {
+        const planLabel = meta.plan.charAt(0).toUpperCase() + meta.plan.slice(1);
+        if (meta.creditsRemaining != null) {
+            parts.push(`${planLabel} (${meta.creditsRemaining} credits remaining)`);
+        }
+        else {
+            parts.push(planLabel);
+        }
+    }
+    if (meta.quotaUsed) {
+        parts.push(`Free review (${meta.quotaUsed} today)`);
+    }
+    if (parts.length > 0) {
+        console.log(`  ${style(parts.join(" · "), c.dim)}`);
+    }
+    if (meta.message) {
+        console.log(`  ${style(meta.message, c.yellow)}`);
+    }
+}
+// ── Spinner ───────────────────────────────────────────────────────────
+function createSpinner(msg) {
+    if (noColor || isCI) {
+        process.stderr.write(`  ${msg}...\n`);
+        return { stop: (final) => { if (final)
+                process.stderr.write(`  ${final}\n`); } };
+    }
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    let i = 0;
+    const interval = setInterval(() => {
+        process.stderr.write(`\r  ${style(frames[i++ % frames.length], c.green)} ${msg}`);
+    }, 80);
+    return {
+        stop(finalMsg) {
+            clearInterval(interval);
+            process.stderr.write(`\r  ${style("✓", c.green)} ${finalMsg || msg}${"".padEnd(20)}\n`);
+        },
+    };
+}
+// ── Commands ──────────────────────────────────────────────────────────
+async function reviewDiff(staged, jsonMode) {
+    if (!isGitRepo()) {
+        console.error(style("  Not a git repository.", c.red));
+        process.exit(1);
+    }
+    const files = staged ? gitStagedFiles() : gitUnstagedFiles();
+    const diff = gitDiff(staged);
+    if (!diff) {
+        const which = staged ? "staged" : "unstaged";
+        console.error(style(`  No ${which} changes found.`, c.yellow));
+        if (!staged && gitStagedFiles().length > 0) {
+            console.error(style("  Try: rmcode --staged", c.dim));
+        }
+        process.exit(0);
+    }
+    const lang = detectLanguage(files);
+    const spinner = createSpinner(`Reviewing ${files.length} file${files.length !== 1 ? "s" : ""} (${lang})`);
+    try {
+        const result = await callAPI(diff, lang, "diff", files);
+        spinner.stop(`Reviewed ${files.length} file${files.length !== 1 ? "s" : ""}`);
+        if (!result.success) {
+            console.error(style(`  ${result.error || "Review failed."}`, c.red));
+            if (result.meta?.message) {
+                console.log(`  ${style(result.meta.message, c.yellow)}`);
+            }
+            process.exit(1);
+        }
+        if (!jsonMode)
+            printMeta(result.meta);
+        if (result.data?.findings?.findings) {
+            printFindings(result.data.findings.findings, jsonMode);
+        }
+    }
+    catch (err) {
+        spinner.stop("Review failed");
+        console.error(style(`  ${err.message}`, c.red));
+        process.exit(1);
+    }
+}
+async function reviewFile(filePath, jsonMode) {
+    const resolved = (0, path_1.resolve)(filePath);
+    if (!(0, fs_1.existsSync)(resolved)) {
+        console.error(style(`  File not found: ${filePath}`, c.red));
+        process.exit(1);
+    }
+    const content = (0, fs_1.readFileSync)(resolved, "utf-8");
+    const ext = (0, path_1.extname)(filePath).toLowerCase();
+    const lang = EXT_TO_LANG[ext] || "javascript";
+    const spinner = createSpinner(`Reviewing ${(0, path_1.basename)(filePath)} (${lang})`);
+    try {
+        const result = await callAPI(content, lang, "file", [filePath]);
+        spinner.stop(`Reviewed ${(0, path_1.basename)(filePath)}`);
+        if (!result.success) {
+            console.error(style(`  ${result.error || "Review failed."}`, c.red));
+            if (result.meta?.message) {
+                console.log(`  ${style(result.meta.message, c.yellow)}`);
+            }
+            process.exit(1);
+        }
+        if (!jsonMode)
+            printMeta(result.meta);
+        if (result.data?.findings?.findings) {
+            printFindings(result.data.findings.findings, jsonMode);
+        }
+    }
+    catch (err) {
+        spinner.stop("Review failed");
+        console.error(style(`  ${err.message}`, c.red));
+        process.exit(1);
+    }
+}
+async function reviewStdin(lang, jsonMode) {
+    const rl = (0, readline_1.createInterface)({ input: process.stdin });
+    const lines = [];
+    for await (const line of rl)
+        lines.push(line);
+    const code = lines.join("\n");
+    if (!code.trim()) {
+        console.error(style("  No input received on stdin.", c.red));
+        process.exit(1);
+    }
+    const spinner = createSpinner(`Reviewing stdin (${lang})`);
+    try {
+        const result = await callAPI(code, lang, "snippet", []);
+        spinner.stop("Reviewed stdin");
+        if (!result.success) {
+            console.error(style(`  ${result.error || "Review failed."}`, c.red));
+            if (result.meta?.message) {
+                console.log(`  ${style(result.meta.message, c.yellow)}`);
+            }
+            process.exit(1);
+        }
+        if (!jsonMode)
+            printMeta(result.meta);
+        if (result.data?.findings?.findings) {
+            printFindings(result.data.findings.findings, jsonMode);
+        }
+    }
+    catch (err) {
+        spinner.stop("Review failed");
+        console.error(style(`  ${err.message}`, c.red));
+        process.exit(1);
+    }
+}
+// ── Help & Version ────────────────────────────────────────────────────
+function printHelp() {
+    console.log(`
+  ${style("rmcode", c.bold, c.green)} — AI code review from your terminal
+
+  ${style("USAGE", c.bold)}
+
+    ${style("rmcode", c.cyan)}                   Review unstaged changes
+    ${style("rmcode --staged", c.cyan)}           Review staged changes
+    ${style("rmcode file.ts", c.cyan)}            Review a specific file
+    ${style("cat file.ts | rmcode", c.cyan)}      Review from stdin
+    ${style("rmcode login", c.cyan)}              Set up your API key
+    ${style("rmcode install", c.cyan)}            Install the GitHub App for PR reviews
+
+  ${style("OPTIONS", c.bold)}
+
+    --staged             Review staged (git add) changes only
+    --deep               Deep multi-pass review (coming soon)
+    --json               Output findings as JSON (for agents/CI)
+    --lang <language>     Language hint for stdin input
+    --help, -h           Show this help
+    --version, -v        Show version
+
+  ${style("EXAMPLES", c.bold)}
+
+    ${style("# Review your work before committing", c.dim)}
+    rmcode --staged
+
+    ${style("# Let an AI agent review its own code", c.dim)}
+    rmcode --staged --json
+
+    ${style("# Review a file directly", c.dim)}
+    rmcode src/auth/login.ts
+
+    ${style("# Pipe from another command", c.dim)}
+    git diff main | rmcode --lang typescript
+
+    ${style("# Set up authenticated reviews (30/month free)", c.dim)}
+    rmcode login
+
+    ${style("# Auto-review every PR on GitHub", c.dim)}
+    rmcode install
+
+  ${style("https://review-my-code.com", c.dim)}
+`);
+}
+// ── Version check ─────────────────────────────────────────────────────
+async function checkForUpdate() {
+    try {
+        const resp = await fetch("https://registry.npmjs.org/rmcode/latest", {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (!resp.ok)
+            return;
+        const data = await resp.json();
+        const latest = data.version;
+        if (latest && latest !== VERSION) {
+            console.log(style(`\n  Update available: ${VERSION} → ${latest}`, c.yellow));
+            console.log(style(`  Run: npm install -g rmcode\n`, c.dim));
+        }
+    }
+    catch {
+        // Silent fail — don't block the review
+    }
+}
+// ── Main ──────────────────────────────────────────────────────────────
+async function main() {
+    const args = process.argv.slice(2);
+    const flags = new Set(args.filter((a) => a.startsWith("-")));
+    const positional = args.filter((a) => !a.startsWith("-"));
+    if (flags.has("--help") || flags.has("-h")) {
+        printHelp();
+        return;
+    }
+    if (flags.has("--version") || flags.has("-v")) {
+        console.log(`rmcode v${VERSION}`);
+        return;
+    }
+    const jsonMode = flags.has("--json");
+    const staged = flags.has("--staged");
+    // rmc install
+    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`);
+        console.log(`  ${style("Once installed, RMCode AI reviews every PR automatically.", c.dim)}\n`);
+        return;
+    }
+    // rmc login
+    if (positional[0] === "login") {
+        const url = `${API_URL}/api-keys`;
+        console.log(`\n  ${style("Opening your browser to create an API key...", c.bold)}\n`);
+        try {
+            const openCmd = process.platform === "darwin"
+                ? "open"
+                : process.platform === "win32"
+                    ? "start"
+                    : "xdg-open";
+            (0, child_process_1.execSync)(`${openCmd} ${url}`, { stdio: "ignore" });
+        }
+        catch {
+            console.log(`  ${style("Could not open browser. Visit this URL:", c.yellow)}`);
+        }
+        console.log(`  ${style(url, c.cyan, c.bold)}\n`);
+        console.log(`  ${style("Then set your API key:", c.dim)}`);
+        console.log(`  ${style("export RMC_API_KEY=rmc_k_...", c.green)}\n`);
+        return;
+    }
+    // --deep stub
+    if (flags.has("--deep")) {
+        console.log(`\n  ${style("Deep review is coming soon.", c.yellow)}`);
+        console.log(`  ${style("Scout review is available now — just run: rmcode --staged", c.dim)}\n`);
+        return;
+    }
+    console.log(`\n  ${style("rmcode", c.green, c.bold)} ${style(`v${VERSION}`, c.dim)}`);
+    // rmc file.ts
+    if (positional.length > 0 && (0, fs_1.existsSync)((0, path_1.resolve)(positional[0]))) {
+        await reviewFile(positional[0], jsonMode);
+        return;
+    }
+    // Piped stdin
+    if (!process.stdin.isTTY) {
+        const langIdx = args.indexOf("--lang");
+        const lang = langIdx >= 0 && args[langIdx + 1] ? args[langIdx + 1] : "javascript";
+        await reviewStdin(lang, jsonMode);
+        return;
+    }
+    // Default: review git diff
+    await reviewDiff(staged, jsonMode);
+    if (!jsonMode && !API_KEY) {
+        console.log(style("  Get 30 reviews/month free: rmcode login", c.dim));
+        console.log(style("  Auto-review every PR: rmcode install", c.dim));
+        console.log();
+    }
+    // Non-blocking update check after review completes
+    await checkForUpdate();
+}
+main().catch((err) => {
+    console.error(style(`  Fatal: ${err.message}`, c.red));
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@review-my-code/rmcode",
+  "version": "0.1.0-alpha.1",
+  "description": "AI code review from your terminal. Catches logic errors, null risks, security holes, and broken error handling.",
+  "keywords": [
+    "code-review",
+    "ai",
+    "linter",
+    "security",
+    "static-analysis",
+    "github",
+    "cli",
+    "developer-tools"
+  ],
+  "bin": {
+    "rmcode": "dist/cli.js",
+    "rmc": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/review-my-code/review-my-code"
+  },
+  "homepage": "https://review-my-code.com",
+  "author": "Alex Yang"
+}