@expo/code-review-cli 0.1.0

package/build/core/diff.js

@@ -0,0 +1,86 @@
+/**
+ * Parse a unified `git diff` into one DiffEntry per file. Splits on `diff --git`
+ * headers and derives the new-tree path from the `+++ b/...` line (falling back
+ * to the header) so renames and additions land on the right path.
+ */
+export function parseUnifiedDiff(diffText) {
+    if (!diffText.trim()) {
+        return [];
+    }
+    const entries = [];
+    const lines = diffText.split('\n');
+    let current = null;
+    const flush = () => {
+        if (!current || current.length === 0) {
+            return;
+        }
+        const entry = patchToEntry(current.join('\n'));
+        if (entry) {
+            entries.push(entry);
+        }
+        current = null;
+    };
+    for (const line of lines) {
+        if (line.startsWith('diff --git ')) {
+            flush();
+            current = [line];
+        }
+        else if (current) {
+            current.push(line);
+        }
+    }
+    flush();
+    return entries;
+}
+function patchToEntry(patch) {
+    const lines = patch.split('\n');
+    const header = lines[0] ?? '';
+    let newPath = null;
+    let oldPath = null;
+    let status;
+    let binary = false;
+    for (const line of lines) {
+        if (line.startsWith('+++ ')) {
+            newPath = stripDiffPathPrefix(line.slice(4));
+        }
+        else if (line.startsWith('--- ')) {
+            oldPath = stripDiffPathPrefix(line.slice(4));
+        }
+        else if (line.startsWith('new file mode')) {
+            status = 'A';
+        }
+        else if (line.startsWith('deleted file mode')) {
+            status = 'D';
+        }
+        else if (line.startsWith('rename ')) {
+            status = 'R';
+        }
+        else if (line.startsWith('Binary files ') || line === 'GIT binary patch') {
+            // git emits one of these instead of +++/---/@@ hunks for a binary file.
+            // There is no textual diff to review; flag it so noise filtering drops it.
+            binary = true;
+        }
+    }
+    let path = newPath && newPath !== '/dev/null' ? newPath : oldPath;
+    if (!path || path === '/dev/null') {
+        path = pathFromHeader(header);
+    }
+    if (!path) {
+        return null;
+    }
+    return { path, patch, status: status ?? 'M', binary };
+}
+function stripDiffPathPrefix(raw) {
+    const value = raw.trim();
+    if (value === '/dev/null') {
+        return value;
+    }
+    return value.replace(/^[ab]\//, '');
+}
+function pathFromHeader(header) {
+    const match = header.match(/^diff --git a\/(.+?) b\/(.+)$/);
+    if (match) {
+        return match[2] ?? match[1] ?? null;
+    }
+    return null;
+}

package/build/core/exec.js

@@ -0,0 +1,61 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+/**
+ * Run a command capturing stdout/stderr. Never interpolates a shell, so
+ * arguments are passed verbatim and are not subject to shell injection.
+ */
+export async function run(command, args, options = {}) {
+    const check = options.check ?? true;
+    try {
+        const { stdout, stderr } = await execFileAsync(command, args, {
+            cwd: options.cwd,
+            maxBuffer: options.maxBuffer ?? 64 * 1024 * 1024,
+            encoding: 'utf8',
+        });
+        return { stdout, stderr, code: 0 };
+    }
+    catch (error) {
+        const err = error;
+        if (!check) {
+            return { stdout: err.stdout ?? '', stderr: err.stderr ?? '', code: err.code ?? 1 };
+        }
+        throw new Error(`Command failed: ${command} ${args.join(' ')}\n${err.stderr ?? err.message ?? ''}`.trim());
+    }
+}
+export async function git(args, cwd) {
+    const { stdout } = await run('git', args, { cwd });
+    return stdout;
+}
+/** Resolve owner/repo from the current checkout via gh (for PR-targeting commands). */
+export async function resolveRepo(cwd) {
+    try {
+        const { stdout } = await run('gh', ['repo', 'view', '--json', 'nameWithOwner', '--jq', '.nameWithOwner'], {
+            cwd,
+        });
+        const repo = stdout.trim();
+        if (repo) {
+            return repo;
+        }
+    }
+    catch {
+        // fall through to a clear error
+    }
+    throw new Error('Could not determine the repository; pass --repo owner/repo.');
+}
+/** Absolute path of the git working-tree root, or null if not in a repo. */
+export async function repoRoot(cwd) {
+    try {
+        return (await git(['rev-parse', '--show-toplevel'], cwd)).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Whether an executable is resolvable on PATH. */
+export async function onPath(command) {
+    const { code } = await run(process.platform === 'win32' ? 'where' : 'which', [command], {
+        check: false,
+    });
+    return code === 0;
+}

package/build/core/log.js

@@ -0,0 +1,10 @@
+import { appendFile, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Append one JSON line per review run. Keeps inputs, findings, decision, and
+ * cost together so runs are auditable and cost/latency can be measured later.
+ */
+export async function writeRunLog(logPath, record) {
+    await mkdir(path.dirname(logPath), { recursive: true });
+    await appendFile(logPath, `${JSON.stringify(record)}\n`, 'utf8');
+}

package/build/core/noise.js

@@ -0,0 +1,186 @@
+import { mkdir, open, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+const LOCKFILES = new Set(['yarn.lock', 'package-lock.json', 'pnpm-lock.yaml', 'bun.lock']);
+const NOISE_EXTENSIONS = ['.min.js', '.min.css', '.bundle.js', '.map'];
+const DEFAULT_MARKERS = [
+    '@generated',
+    '@codegen',
+    'code generated by',
+    'this file was generated',
+    'this file is generated',
+    'auto-generated',
+    'autogenerated',
+    'do not edit',
+];
+/**
+ * Strip files that add no signal (lockfiles, generated bundles/maps, snapshots,
+ * generated-file markers, plus any repo-specified extras) before any agent sees
+ * them. Reads each file's on-disk head for a generation marker — the diff hunk
+ * alone misses markers that live at the top of a file when the change is mid-file.
+ */
+export async function filterNoise(entries, options = {}, cwd = process.cwd()) {
+    const kept = [];
+    const filtered = [];
+    for (const entry of entries) {
+        const reason = await noiseReason(entry, options, cwd);
+        if (reason) {
+            filtered.push({ path: entry.path, reason });
+        }
+        else {
+            kept.push(entry);
+        }
+    }
+    return { kept, filtered };
+}
+async function noiseReason(entry, options, cwd) {
+    if (entry.binary) {
+        return 'binary file (no textual diff)';
+    }
+    const base = path.basename(entry.path);
+    if (LOCKFILES.has(base)) {
+        return 'lockfile';
+    }
+    for (const ext of NOISE_EXTENSIONS) {
+        if (entry.path.endsWith(ext)) {
+            return `generated asset (${ext})`;
+        }
+    }
+    if (entry.path.includes('__snapshots__/') && entry.path.endsWith('.snap')) {
+        return 'jest snapshot';
+    }
+    for (const pattern of options.additionalIgnores ?? []) {
+        if (matchesIgnore(entry.path, pattern)) {
+            return `repo-ignored (${pattern})`;
+        }
+    }
+    const markers = [...DEFAULT_MARKERS, ...(options.additionalMarkers ?? [])].map(marker => marker.toLowerCase());
+    // A generation marker only counts as a HEADER — real generated files carry it
+    // in their first few lines (e.g. `// @generated`, `# ... DO NOT EDIT.`). Only
+    // checking the top avoids false positives on hand-written files that merely
+    // mention these strings (e.g. this module lists them as DEFAULT_MARKERS, and a
+    // config comment references "@generated"), which were being wrongly filtered.
+    if (hasMarkerHeaderInPatch(entry.patch, markers)) {
+        return 'generated file header';
+    }
+    const head = await readFileHead(path.resolve(cwd, entry.path));
+    if (head && hasMarkerInHead(head, markers)) {
+        return 'generated file header';
+    }
+    return null;
+}
+/** How many leading lines of a file count as its (generation) header. */
+const HEADER_LINES = 5;
+/** Minimal glob: supports `**` (crosses `/`) and `*` (within a segment). */
+export function matchesIgnore(filePath, pattern) {
+    // Translate the glob to a regex in a single pass, escaping metacharacters
+    // inline. We deliberately use NO placeholder character: an earlier version
+    // stashed a literal NUL byte as a sentinel, which made git classify this
+    // source file as binary (so its diff was invisible to reviewers).
+    let out = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (ch === '*') {
+            if (pattern[i + 1] === '*') {
+                out += '.*';
+                i++;
+            }
+            else {
+                out += '[^/]*';
+            }
+        }
+        else if (/[.+^${}()|[\]\\?]/.test(ch)) {
+            out += '\\' + ch;
+        }
+        else {
+            out += ch;
+        }
+    }
+    return new RegExp(`^${out}$`).test(filePath);
+}
+/** A generation marker in the first few ADDED lines (i.e. the top of a new file). */
+function hasMarkerHeaderInPatch(patch, markers) {
+    const topAddedLines = patch
+        .split('\n')
+        .filter(line => line.startsWith('+') && !line.startsWith('+++'))
+        .slice(0, HEADER_LINES)
+        .map(line => line.toLowerCase());
+    return topAddedLines.some(line => markers.some(marker => line.includes(marker)));
+}
+/** A generation marker in the first few lines of the on-disk file. */
+function hasMarkerInHead(head, markers) {
+    const topLines = head.split('\n').slice(0, HEADER_LINES).join('\n').toLowerCase();
+    return markers.some(marker => topLines.includes(marker));
+}
+/** Read the first `bytes` of a file (default 4 KB) without loading the whole thing. */
+async function readFileHead(absPath, bytes = 4096) {
+    try {
+        const handle = await open(absPath, 'r');
+        try {
+            const buffer = Buffer.alloc(bytes);
+            const { bytesRead } = await handle.read(buffer, 0, bytes, 0);
+            return buffer.subarray(0, bytesRead).toString('utf8');
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/** Count added + removed lines in a unified-diff patch (ignores +++/--- headers). */
+export function countChangedLines(patch) {
+    let count = 0;
+    for (const line of patch.split('\n')) {
+        if (line.startsWith('+') && !line.startsWith('+++')) {
+            count++;
+        }
+        else if (line.startsWith('-') && !line.startsWith('---')) {
+            count++;
+        }
+    }
+    return count;
+}
+/**
+ * Write one patch file per changed file plus a shared manifest, all inside the
+ * repo (so the OpenCode read tool can reach them). Agents are pointed at these
+ * paths instead of having the full diff inlined into every prompt.
+ */
+export async function writePatchWorkspace(kept, metadata, rootDir) {
+    const patchDir = path.join(rootDir, 'patches');
+    await mkdir(patchDir, { recursive: true });
+    const files = [];
+    for (let index = 0; index < kept.length; index++) {
+        const entry = kept[index];
+        const safeName = `${String(index).padStart(4, '0')}-${entry.path.replace(/[^a-zA-Z0-9._-]/g, '__')}.patch`;
+        const patchPath = path.join(patchDir, safeName);
+        await writeFile(patchPath, entry.patch, 'utf8');
+        files.push({
+            path: entry.path,
+            patchPath,
+            status: entry.status,
+            patch: entry.patch,
+            changedLines: countChangedLines(entry.patch),
+        });
+    }
+    const manifestPath = path.join(rootDir, 'context.md');
+    await writeFile(manifestPath, renderManifest(files, metadata), 'utf8');
+    return { root: rootDir, manifestPath, files };
+}
+function renderManifest(files, metadata) {
+    const lines = [
+        '# Changed files',
+        '',
+        `Base: ${metadata.baseRef || '(unknown)'}  Head: ${metadata.headRef || '(unknown)'}`,
+        '',
+        'Each entry lists the changed file (path relative to repo root) and a patch',
+        'file containing its unified diff. Read the patch to see what changed, then',
+        'read the surrounding source in the repo to confirm findings in context.',
+        '',
+    ];
+    for (const file of files) {
+        lines.push(`- \`${file.path}\` (${file.status ?? 'M'}) — patch: \`${file.patchPath}\``);
+    }
+    lines.push('');
+    return lines.join('\n');
+}