limn-review 0.1.123

package/dist/coding/merge.js

@@ -0,0 +1,262 @@
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { isAbsolute, join } from 'node:path';
+import { promisify } from 'node:util';
+import { config } from '../config.js';
+import { getAccessToken, getAccountById } from '../auth/account.js';
+import { cleanupCloneCache, prepWorktree, removeWorktreeLocked, } from '../review/clone-manager.js';
+import { fetchPrHeadInfo } from '../github/mutations.js';
+import { codedError, pushForceWithLease, pushRef } from './git.js';
+import { protectedRefsFor } from './git-ops.js';
+const execFileAsync = promisify(execFile);
+// CORE (free tier): "Update branch from trunk" — rebase or merge the trunk into a PR's own
+// head branch and push — plus `hasConflictMarkers`, which the in-app conflict resolver
+// (src/conflict/) imports. Same discipline as git.ts / clone-manager.ts: args are ALWAYS arrays
+// (no shell), a tokenized URL is passed per-op and never persisted, and there is no agent here
+// at all. ANY conflict aborts the rebase/merge and throws CONFLICTS_UNRESOLVED — nothing is
+// ever resolved on this path, so a tree with conflicts is never pushed.
+//
+// (This file used to also hold AI Fix's trunk reconciliation — merge preview, rebase-resolve,
+// merge-resolve-and-push, push-resolved, and the agentic conflict resolver they called. All of
+// it was removed: an AI Fix now pushes as-is through git-ops.ts `applyAndPush`.)
+// Non-interactive git env: no credential prompt, no editor, no merge-message editor.
+const GIT_ENV = {
+    ...process.env,
+    GIT_TERMINAL_PROMPT: '0',
+    GIT_EDITOR: 'true',
+    GIT_SEQUENCE_EDITOR: 'true',
+    GIT_MERGE_AUTOEDIT: 'no',
+};
+/** Run git, throwing on a non-zero exit (for ops that MUST succeed). */
+async function git(args, cwd) {
+    const { stdout, stderr } = await execFileAsync('git', args, {
+        cwd,
+        env: GIT_ENV,
+        timeout: 120_000,
+        maxBuffer: 128 * 1024 * 1024,
+    });
+    return { ok: true, code: 0, stdout, stderr };
+}
+/** Run git WITHOUT throwing; returns the exit code + output (for merge/rebase). */
+async function gitTry(args, cwd) {
+    try {
+        const { stdout, stderr } = await execFileAsync('git', args, {
+            cwd,
+            env: GIT_ENV,
+            timeout: 120_000,
+            maxBuffer: 128 * 1024 * 1024,
+        });
+        return { ok: true, code: 0, stdout, stderr };
+    }
+    catch (err) {
+        const e = err;
+        return {
+            ok: false,
+            code: typeof e.code === 'number' ? e.code : 1,
+            stdout: e.stdout ?? '',
+            stderr: e.stderr ?? (err instanceof Error ? err.message : String(err)),
+        };
+    }
+}
+function tokenizedUrl(owner, name, token) {
+    return `https://x-access-token:${token}@github.com/${owner}/${name}.git`;
+}
+function lines(s) {
+    return s
+        .split('\n')
+        .map((l) => l.trim())
+        .filter(Boolean);
+}
+async function identFor(accountId) {
+    const account = await getAccountById(accountId);
+    const name = account?.displayName || account?.githubLogin || 'pierre-review';
+    const email = account?.githubLogin
+        ? `${account.githubLogin}@users.noreply.github.com`
+        : 'pierre-review@users.noreply.github.com';
+    return { name, email };
+}
+function identArgs(ident) {
+    return ['-c', `user.name=${ident.name}`, '-c', `user.email=${ident.email}`];
+}
+async function scheduleCleanup(repoCloneDir) {
+    if (!repoCloneDir)
+        return;
+    setImmediate(() => {
+        try {
+            cleanupCloneCache();
+        }
+        catch {
+            /* advisory */
+        }
+    });
+}
+async function teardown(owner, name, repoCloneDir, worktreePath) {
+    if (repoCloneDir && worktreePath) {
+        await removeWorktreeLocked(owner, name, repoCloneDir, worktreePath).catch(() => { });
+    }
+    void scheduleCleanup(repoCloneDir);
+}
+/** Fetch a branch into the worktree's object store and return its tip sha. */
+async function fetchTrunk(worktree, owner, name, token, trunk) {
+    const res = await gitTry(['fetch', '--no-tags', '--force', tokenizedUrl(owner, name, token), trunk], worktree);
+    if (!res.ok) {
+        throw codedError('TRUNK_FETCH_FAILED', `couldn't fetch trunk '${trunk}': ${res.stderr || res.stdout}`);
+    }
+    const { stdout } = await git(['rev-parse', 'FETCH_HEAD'], worktree);
+    return stdout.trim();
+}
+/** True if `ancestor` is an ancestor of `descendant` (i.e. already contained). */
+async function isAncestor(worktree, ancestor, descendant) {
+    const res = await gitTry(['merge-base', '--is-ancestor', ancestor, descendant], worktree);
+    return res.ok;
+}
+/** The currently-unmerged (conflicted) paths. */
+async function conflictedFiles(worktree) {
+    const { stdout } = await git(['diff', '--name-only', '--diff-filter=U'], worktree);
+    return lines(stdout);
+}
+// A leftover conflict marker: `<<<<<<< `, `>>>>>>> ` or diff3's `||||||| ` (the
+// `=======` divider alone is ambiguous — real files contain it — so we rely on the
+// unambiguous open/close markers plus git's own unmerged-index check).
+const MARKER_RE = /^(<{7}|>{7}|\|{7})[ \t]/m;
+/** True if `text` still contains an (unambiguous) unresolved conflict marker. */
+export function hasConflictMarkers(text) {
+    return MARKER_RE.test(text);
+}
+/** True if a rebase or merge is currently in progress in this worktree. */
+async function opInProgress(worktree, kind) {
+    const probes = kind === 'rebase' ? ['rebase-merge', 'rebase-apply'] : ['MERGE_HEAD'];
+    for (const p of probes) {
+        try {
+            const { stdout } = await git(['rev-parse', '--git-path', p], worktree);
+            const rel = stdout.trim();
+            const abs = isAbsolute(rel) ? rel : join(worktree, rel);
+            if (existsSync(abs))
+                return true;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return false;
+}
+// ---- rebase the checked-out branch onto the trunk (aborts on the first conflict) ----
+async function runRebase(worktree, trunkSha, ident) {
+    const gc = identArgs(ident);
+    let res = await gitTry([...gc, 'rebase', trunkSha], worktree);
+    let step = 0;
+    while (!res.ok) {
+        if (!(await opInProgress(worktree, 'rebase'))) {
+            // The rebase never started / hard-failed (not a conflict stop).
+            throw codedError('REBASE_FAILED', res.stderr || res.stdout || 'rebase failed');
+        }
+        const files = await conflictedFiles(worktree);
+        if (files.length > 0) {
+            await gitTry(['rebase', '--abort'], worktree);
+            throw codedError('CONFLICTS_UNRESOLVED', `rebase conflicts in ${files.join(', ')}`);
+        }
+        // A stop with no conflicted file (e.g. a commit that became empty): continue or skip it,
+        // capped so a pathological history can't spin.
+        if (++step > config.aiFixRebaseMaxSteps) {
+            await gitTry(['rebase', '--abort'], worktree);
+            throw codedError('REBASE_FAILED', `rebase exceeded ${config.aiFixRebaseMaxSteps} conflict steps`);
+        }
+        res = await continueOrSkip(worktree, gc);
+    }
+}
+// `git rebase --continue`, falling back to `--skip` when a commit became empty (its
+// changes are already on the trunk).
+async function continueOrSkip(worktree, gc) {
+    const cont = await gitTry([...gc, 'rebase', '--continue'], worktree);
+    if (cont.ok)
+        return cont;
+    const blob = `${cont.stderr}\n${cont.stdout}`.toLowerCase();
+    if (blob.includes('no changes') ||
+        blob.includes('nothing to commit') ||
+        blob.includes('did you forget') ||
+        blob.includes('patch is empty')) {
+        return gitTry([...gc, 'rebase', '--skip'], worktree);
+    }
+    return cont;
+}
+// ---- merge the trunk into the checked-out branch (aborts on any conflict) ----
+async function runMerge(worktree, trunkSha, trunk, branchLabel, ident) {
+    const gc = identArgs(ident);
+    if (await isAncestor(worktree, trunkSha, 'HEAD')) {
+        return; // already contains the trunk
+    }
+    const res = await gitTry([...gc, 'merge', '--no-ff', '--no-edit', '-m', `Merge ${trunk} into ${branchLabel}`, trunkSha], worktree);
+    if (res.ok)
+        return;
+    const files = await conflictedFiles(worktree);
+    if (files.length === 0) {
+        await gitTry(['merge', '--abort'], worktree);
+        throw codedError('MERGE_FAILED', res.stderr || res.stdout || 'merge failed');
+    }
+    await gitTry(['merge', '--abort'], worktree);
+    throw codedError('CONFLICTS_UNRESOLVED', `merge conflicts in ${files.join(', ')}`);
+}
+// ---- CORE (free tier): update a PR's OWN branch from its base/trunk ----
+// Rebase (default) or merge the trunk into the PR's head branch and push. This is the local,
+// clone-based path for the free-tier "Update branch from trunk": on ANY conflict runRebase /
+// runMerge abort the op and throw CONFLICTS_UNRESOLVED (nothing here resolves a conflict — the
+// in-app resolver in src/conflict/ is a separate, reader-driven flow). No stored patch is
+// involved: we check the PR head out as-is and reconcile it.
+export async function updatePrBranchFromTrunk(args) {
+    const { accountId, owner, name, prNumber, headRef, headSha, trunk, strategy } = args;
+    const token = await getAccessToken(accountId);
+    const ident = await identFor(accountId);
+    // The head must not have moved out from under us, and a fork head must be pushable.
+    const info = await fetchPrHeadInfo(token, owner, name, prNumber);
+    if (info.headSha !== headSha) {
+        throw codedError('HEAD_MOVED', `the PR head advanced (now ${info.headSha.slice(0, 7)}, expected ${headSha.slice(0, 7)})`);
+    }
+    if (info.isFork && !info.maintainerCanModify) {
+        throw codedError('PUSH_DENIED', 'the PR head is a fork this account cannot push to — update it on GitHub instead');
+    }
+    // The PR head branch lives in the HEAD repo, which for a fork PR is NOT the base (watched)
+    // repo — push there, or a merge would create a stray branch on the base and a rebase's lease
+    // would target the wrong ref. The clone/fetch still uses the base repo below (pull/N/head
+    // resolves there); only the PUSH target is the head repo. full_name is always `owner/name`.
+    const slash = info.headRepoFullName.indexOf('/');
+    const headOwner = slash > 0 ? info.headRepoFullName.slice(0, slash) : owner;
+    const headName = slash > 0 ? info.headRepoFullName.slice(slash + 1) : name;
+    // The push lands in the HEAD repo, which for a fork PR is not the watched one — then there
+    // is nothing of ours to protect there (see protectedRefsFor).
+    const push = {
+        worktree: '',
+        owner: headOwner,
+        name: headName,
+        token,
+        committish: 'HEAD',
+        remoteBranch: headRef,
+        protect: await protectedRefsFor(accountId, owner, name, prNumber, headOwner, headName),
+    };
+    let repoCloneDir = null;
+    let worktreePath = null;
+    try {
+        // Check out the PR head branch (prepWorktree checks out at the given sha).
+        ({ repoCloneDir, worktreePath } = await prepWorktree(owner, name, prNumber, headSha, token));
+        const trunkSha = await fetchTrunk(worktreePath, owner, name, token, trunk);
+        if (strategy === 'rebase') {
+            await runRebase(worktreePath, trunkSha, ident); // throws CONFLICTS_UNRESOLVED on conflict
+            const newSha = (await git(['rev-parse', 'HEAD'], worktreePath)).stdout.trim();
+            // Rewriting history requires a force push; the lease pins to the sha we cloned so a
+            // concurrent push aborts it (never blows away someone else's work).
+            await pushForceWithLease({ ...push, worktree: worktreePath, leaseSha: headSha });
+            return { headSha: newSha, strategy };
+        }
+        await runMerge(worktreePath, trunkSha, trunk, headRef, ident); // throws on conflict
+        const newSha = (await git(['rev-parse', 'HEAD'], worktreePath)).stdout.trim();
+        // A merge only adds a commit (the old head is its ancestor) → a plain push. Already
+        // up-to-date (runMerge no-op) leaves HEAD unchanged → nothing to push.
+        if (newSha !== headSha) {
+            await pushRef({ ...push, worktree: worktreePath });
+        }
+        return { headSha: newSha, strategy };
+    }
+    finally {
+        await teardown(owner, name, repoCloneDir, worktreePath);
+    }
+}
+//# sourceMappingURL=merge.js.map

package/dist/coding/safe-path.js

@@ -0,0 +1,75 @@
+import { lstatSync, realpathSync } from 'node:fs';
+import { join, sep } from 'node:path';
+import { codedError } from './git.js';
+// Where a write is allowed to land inside a checked-out worktree.
+//
+// File paths reach the coding seams from adapter plans whose locations can be influenced by
+// REPO CONTENT (a T3 manifest proposes a configPath), i.e. attacker-suppliable in cloud. Two
+// guards, and NEITHER is sufficient alone:
+//   - assertSafeTargetPath is LEXICAL and runs before any side effect;
+//   - resolveContainedTargetPath is FILESYSTEM and runs after checkout, immediately before
+//     the write, because a committed symlink is a real directory entry and no amount of
+//     string inspection can see it.
+/**
+ * Lexical: repo-relative, no traversal, no drive letter, no `.git` segment at ANY depth,
+ * case-folded. Throws a coded 'APPLY_FAILED'.
+ * ⚠ `.git` is checked per SEGMENT and case-INSENSITIVELY: the predecessor anchored it at the
+ * root (`norm === '.git' || norm.startsWith('.git/')`), so `a/.git/hooks/pre-commit` — a hook
+ * git runs on the next commit — sailed through, and `.GIT/config` did too on macOS.
+ */
+export function assertSafeTargetPath(path) {
+    const norm = path.replace(/\\/g, '/');
+    const segments = norm.split('/');
+    if (!norm ||
+        norm.startsWith('/') ||
+        /^[A-Za-z]:/.test(norm) ||
+        segments.some((s) => s === '' || s === '.' || s === '..' || s.toLowerCase() === '.git')) {
+        throw codedError('APPLY_FAILED', `invalid target path: ${path}`);
+    }
+}
+/**
+ * Containment: resolve every EXISTING component of `<root>/<path>` and assert the result
+ * stays inside `<root>`. Returns the absolute path to write to.
+ *
+ * ⚠ A COMMITTED SYMLINK IS A REAL DIRECTORY ENTRY, so `link/evil.txt` is traversal-free text
+ * that writes wherever `link` points — outside the worktree, with no `..` anywhere in it. An
+ * in-tree symlink is REFUSED outright rather than followed: git records the LINK, not the
+ * target, so a repo can ship one and nothing about writing through it is ever intended.
+ * ⚠ realpath the ROOT too — /tmp is a symlink to /private/tmp on macOS, and comparing an
+ * unresolved root against a resolved child refuses every legitimate write.
+ *
+ * Call AFTER checkout, IMMEDIATELY before the mkdir/write.
+ */
+export function resolveContainedTargetPath(root, path) {
+    assertSafeTargetPath(path);
+    let realRoot;
+    try {
+        realRoot = realpathSync(root);
+    }
+    catch {
+        throw codedError('APPLY_FAILED', `worktree root is not readable: ${root}`);
+    }
+    let current = realRoot;
+    for (const segment of path.replace(/\\/g, '/').split('/')) {
+        const next = join(current, segment);
+        let entry;
+        try {
+            entry = lstatSync(next);
+        }
+        catch {
+            // Nothing there yet — this segment and everything after it is ours to create, and a
+            // path that does not exist cannot redirect us anywhere.
+            current = next;
+            continue;
+        }
+        if (entry.isSymbolicLink()) {
+            throw codedError('APPLY_FAILED', `refusing to write through the symlink ${segment} in ${path}`);
+        }
+        current = next;
+    }
+    if (current !== realRoot && !current.startsWith(realRoot + sep)) {
+        throw codedError('APPLY_FAILED', `target path escapes the worktree: ${path}`);
+    }
+    return current;
+}
+//# sourceMappingURL=safe-path.js.map

package/dist/coding/schema.js

@@ -0,0 +1,43 @@
+import { loadZod } from "../ai/runtime.js";
+// The structured-output contract for the in-process `submit_fix` MCP tool. The agent
+// EDITS files in the worktree and calls this ONCE at the end to report what it did.
+// We deliberately capture ONLY a prose summary + a commit message here — the actual
+// changeset (patch + file list) is derived from `git` after the run, never from the
+// agent's self-report (which miscounts / omits files). Exported as a raw zod shape
+// (what `tool()` wants) plus an assembled object schema for validation.
+export function buildSubmitFixShape(z) {
+    return {
+        // A concise, user-facing description of the fix that was applied.
+        summary: z.string(),
+        // A conventional-commit-style message for the commit the host will create.
+        commitMessage: z.string(),
+        // The per-change report: ONE entry per file the agent changed — what changed and why, and the
+        // refs of the task items (F3, T1, S1-AC2, C1, P2 …) that change addresses. Optional at the
+        // schema level so a run that changed nothing is not made to invent one; the prompt asks for it.
+        // As with `summary`, this is a SELF-REPORT stored as commentary: the authoritative changeset
+        // still comes from git, and the manager drops any ref the run was not shown.
+        changes: z
+            .array(z.object({
+            path: z.string(),
+            // 1–3 sentences: what changed and why.
+            summary: z.string(),
+            refs: z.array(z.string()).optional(),
+        }))
+            .optional(),
+        // Items the agent deliberately did NOT fix, each with the reason (wrong, out of scope, needs
+        // a person, already done …).
+        unaddressed: z
+            .array(z.object({ ref: z.string(), reason: z.string() }))
+            .optional(),
+    };
+}
+/** The raw shape `tool()` wants, built from the runtime's zod. */
+export async function submitFixShape() {
+    return buildSubmitFixShape(await loadZod());
+}
+/** The assembled object schema, for validation. */
+export async function submitFixSchema() {
+    const z = await loadZod();
+    return z.object(buildSubmitFixShape(z));
+}
+//# sourceMappingURL=schema.js.map