limn-review 0.1.123

package/dist/coding/ai-fix/manager.js

@@ -0,0 +1,370 @@
+import { and, desc, eq } from 'drizzle-orm';
+import { getFixPrContext } from './pr-context.js';
+import { getClaudeReviewById } from '../../review/claude-review/persist.js';
+import { pickReviewNonce } from '../../review/claude-review/prompts.js';
+import { buildReviewSeed } from './review-seed.js';
+import { buildFixSystemPrompt, buildFixUserPrompt } from './prompts.js';
+import { insertQueuedFix, markFixCancelled, markFixFailed, markFixRunning, reconcileOrphanedFixes, saveFixSuccess, } from './persist.js';
+// In-memory job manager for AI Fix's agentic fixer (CORE, free, local-only — it left the plugin
+// with Claude Review; the PR summary and the CI-failure analysis stayed Pro). A SINGLE global slot (concurrency 1) carries every
+// fix-generate run in the process, so no two ever run concurrently (a write run is costly,
+// and running one at a time means the agent never needs to mutate process.env for auth, so
+// it can't race a Claude Review). One job per PR (the `claimed` guard). Pushing a finished
+// fix is NOT a job: POST …/push is synchronous and never takes the slot.
+const MAX_CONCURRENT = 1;
+const MAX_QUEUED = 20;
+// ---- the single-slot scheduler ----
+const running = new Set(); // prIds with a fix run in flight
+const claimed = new Set(); // prIds claimed (queued OR running)
+const pending = [];
+function enqueue(prId, run) {
+    if (running.size < MAX_CONCURRENT) {
+        void execRun(prId, run);
+        return true; // started immediately
+    }
+    pending.push({ prId, run });
+    return false; // queued
+}
+async function execRun(prId, run) {
+    running.add(prId);
+    try {
+        await run();
+    }
+    catch {
+        /* every job body handles its own errors; this is only a backstop */
+    }
+    finally {
+        running.delete(prId);
+        pump();
+    }
+}
+function pump() {
+    while (running.size < MAX_CONCURRENT && pending.length > 0) {
+        const next = pending.shift();
+        if (!next)
+            break;
+        void execRun(next.prId, next.run);
+    }
+}
+// ---- fix-generate state ----
+const fixIdByPr = new Map();
+const progressByFix = new Map();
+const controllers = new Map(); // fixId → controller
+const fixStreamSubs = new Map();
+export function subscribeFixStream(prId, cb) {
+    let set = fixStreamSubs.get(prId);
+    if (!set) {
+        set = new Set();
+        fixStreamSubs.set(prId, set);
+    }
+    set.add(cb);
+    return () => {
+        const s = fixStreamSubs.get(prId);
+        if (!s)
+            return;
+        s.delete(cb);
+        if (s.size === 0)
+            fixStreamSubs.delete(prId);
+    };
+}
+function emitFixStream(prId, e) {
+    const set = fixStreamSubs.get(prId);
+    if (!set)
+        return;
+    for (const cb of set) {
+        try {
+            cb(e);
+        }
+        catch {
+            /* a broken subscriber must not break the run */
+        }
+    }
+}
+/**
+ * Load the review a 'review' seed names and render its items. null when the review is missing,
+ * not this account's, not THIS PR's, or did not succeed. Never throws.
+ */
+export async function loadReviewSeed(ctx, input) {
+    if (input.reviewId == null)
+        return null;
+    try {
+        const review = await getClaudeReviewById(ctx, input.reviewId, input.accountId);
+        if (!review || review.prId !== input.prId || review.status !== 'succeeded')
+            return null;
+        return { review, seed: buildReviewSeed(review, { nonce: pickReviewNonce }) };
+    }
+    catch (err) {
+        ctx.log.warn({ err }, 'ai-fix: loading the review seed failed');
+        return null;
+    }
+}
+/**
+ * Start a fix seeded from a Claude review — the ONE entry the auto-review agent calls (it passes
+ * `trigger: 'auto'`); the manual "Fix from review" route goes through the same path. Same queue,
+ * slot, worktree and guards as every fix; nothing is pushed until a person presses Push.
+ */
+export function startReviewFix(ctx, input) {
+    return startFix(ctx, {
+        accountId: input.accountId,
+        prId: input.prId,
+        model: input.model,
+        seed: 'review',
+        sourceReviewId: input.reviewId,
+        trigger: input.trigger,
+    });
+}
+export async function startFix(ctx, input) {
+    const { accountId, prId } = input;
+    const auth = ctx.llm.detectAuth();
+    if (auth.status !== 'ok')
+        return { status: 'no_auth', message: auth.message };
+    // Hard agentic cap: refuse a run once the account's monthly agent credit allowance is spent
+    // (metered per calendar month; local accounts are unmetered → never blocked).
+    if ((await ctx.aiCredits.check(accountId)).agentBlocked)
+        return { status: 'credits_exhausted' };
+    const instruction = (input.instruction ?? '').trim();
+    if (input.seed === 'plain' && instruction === '')
+        return { status: 'no_instruction' };
+    if (claimed.has(prId))
+        return { status: 'already_running' };
+    if (pending.length >= MAX_QUEUED)
+        return { status: 'busy' };
+    // Reserve the PR SYNCHRONOUSLY, in the same tick as the check above and BEFORE any await, so
+    // two concurrent starts (a manual click and `maybeStartAutoFix`) can't both pass the guard.
+    // ⚠ EVERY bail path below this line releases the claim, or this PR's fixer wedges for the
+    // process's lifetime.
+    claimed.add(prId);
+    try {
+        const pr = await getFixPrContext(ctx, accountId, prId);
+        if (!pr) {
+            claimed.delete(prId);
+            return { status: 'not_found' };
+        }
+        // The review seed is resolved BEFORE GitHub is asked anything: a review with nothing to fix
+        // must not spend two GitHub calls on its way to a refusal.
+        //
+        // ⚠ The rendered prompt is FROZEN HERE, at launch, and the run may start later (one global
+        // slot). That is intended: the stored items must describe what the agent was actually given.
+        let reviewItems = null;
+        let sentRefs = [];
+        let seed;
+        if (input.seed === 'review') {
+            const loaded = await loadReviewSeed(ctx, {
+                accountId,
+                prId,
+                reviewId: input.sourceReviewId,
+            });
+            if (!loaded) {
+                claimed.delete(prId);
+                return { status: 'review_unavailable' };
+            }
+            if (loaded.seed.sentRefs.length === 0) {
+                claimed.delete(prId);
+                return { status: 'nothing_to_fix' };
+            }
+            reviewItems = loaded.seed.items;
+            sentRefs = loaded.seed.sentRefs;
+            seed = { kind: 'review', text: loaded.seed.text };
+        }
+        else {
+            seed = { kind: 'plain', text: instruction };
+        }
+        const headInfo = await ctx.github.fetchPrHeadInfo(accountId, pr.owner, pr.name, pr.number);
+        const baseSha = headInfo.headSha;
+        if (!baseSha) {
+            claimed.delete(prId);
+            return { status: 'no_head' };
+        }
+        const diff = await ctx.github
+            .fetchPrDiff(accountId, pr.owner, pr.name, pr.number)
+            .catch(() => '');
+        const systemPrompt = buildFixSystemPrompt();
+        const prompt = buildFixUserPrompt({ pr, diff, seed });
+        const trigger = input.trigger ?? 'manual';
+        const fixId = await insertQueuedFix(ctx, {
+            accountId,
+            repoId: pr.repoId,
+            prId,
+            baseSha,
+            model: input.model,
+            seed: input.seed,
+            sourceReviewId: input.seed === 'review' ? (input.sourceReviewId ?? null) : null,
+            prompt,
+            trigger,
+            reviewItems,
+        });
+        fixIdByPr.set(prId, fixId);
+        const job = {
+            fixId,
+            accountId,
+            prId,
+            owner: pr.owner,
+            name: pr.name,
+            prNumber: pr.number,
+            baseSha,
+            model: input.model,
+            systemPrompt,
+            prompt,
+            sentRefs,
+        };
+        const immediate = enqueue(prId, () => launchFix(ctx, job));
+        if (!immediate) {
+            emitFixStream(prId, {
+                type: 'progress',
+                status: 'queued',
+                fixId,
+                progress: { phase: 'fetching_diff' },
+            });
+        }
+        return { status: 'queued', fixId };
+    }
+    catch (err) {
+        claimed.delete(prId);
+        fixIdByPr.delete(prId);
+        ctx.log.warn({ err }, 'ai-fix startFix failed');
+        return { status: 'not_found' };
+    }
+}
+async function launchFix(ctx, job) {
+    const controller = new AbortController();
+    controllers.set(job.fixId, controller);
+    const seed = { phase: 'cloning' };
+    progressByFix.set(job.fixId, seed);
+    emitFixStream(job.prId, {
+        type: 'progress',
+        status: 'running',
+        fixId: job.fixId,
+        progress: seed,
+    });
+    const onProgress = (p) => {
+        const prog = p;
+        progressByFix.set(job.fixId, prog);
+        emitFixStream(job.prId, {
+            type: 'progress',
+            status: 'running',
+            fixId: job.fixId,
+            progress: prog,
+        });
+    };
+    let finalStatus = 'failed';
+    try {
+        await markFixRunning(ctx, job.fixId);
+        const result = await ctx.coding.generateFix({
+            accountId: job.accountId,
+            owner: job.owner,
+            name: job.name,
+            prNumber: job.prNumber,
+            baseSha: job.baseSha,
+            model: job.model,
+            systemPrompt: job.systemPrompt,
+            prompt: job.prompt,
+            abortController: controller,
+            onProgress,
+        });
+        if (result.aborted || controller.signal.aborted) {
+            await markFixCancelled(ctx, job.fixId);
+            finalStatus = 'cancelled';
+        }
+        else {
+            emitFixStream(job.prId, {
+                type: 'progress',
+                status: 'running',
+                fixId: job.fixId,
+                progress: { phase: 'persisting' },
+            });
+            await saveFixSuccess(ctx, job.fixId, result, job.sentRefs);
+            finalStatus = 'succeeded';
+        }
+    }
+    catch (err) {
+        if (controller.signal.aborted) {
+            await markFixCancelled(ctx, job.fixId).catch(() => { });
+            finalStatus = 'cancelled';
+        }
+        else {
+            const m = err instanceof Error ? err.message : String(err);
+            await markFixFailed(ctx, job.fixId, m).catch(() => { });
+            finalStatus = 'failed';
+            ctx.log.warn({ err }, 'ai-fix run failed');
+        }
+    }
+    finally {
+        claimed.delete(job.prId);
+        controllers.delete(job.fixId);
+        progressByFix.delete(job.fixId);
+        fixIdByPr.delete(job.prId);
+        emitFixStream(job.prId, {
+            type: 'done',
+            status: finalStatus,
+            fixId: job.fixId,
+        });
+    }
+}
+export function requestFixCancel(ctx, prId) {
+    const fixId = fixIdByPr.get(prId);
+    if (fixId != null && running.has(prId)) {
+        controllers.get(fixId)?.abort();
+        return true;
+    }
+    const idx = pending.findIndex((j) => j.prId === prId);
+    if (idx >= 0 && fixId != null) {
+        pending.splice(idx, 1);
+        claimed.delete(prId);
+        fixIdByPr.delete(prId);
+        void markFixCancelled(ctx, fixId).catch(() => { });
+        emitFixStream(prId, { type: 'done', status: 'cancelled', fixId });
+        return true;
+    }
+    return false;
+}
+export function isFixRunning(prId) {
+    return claimed.has(prId);
+}
+export async function getFixStatus(ctx, accountId, prId) {
+    // The DB lookup goes FIRST, and it is what establishes ownership.
+    //
+    // `running` / `claimed` / `fixIdByPr` are process-global Sets and Maps keyed by prId alone,
+    // with no notion of who owns the job. Reading them before this query meant a foreign PR with
+    // a job in flight returned that job's fixId and live `progress` to whoever asked — another
+    // tenant's phase and activity, from a repository the caller cannot see. Every started fix
+    // inserts its row (with accountId) BEFORE it runs, so "no row for this account" is a reliable
+    // "not yours", and the in-memory maps are consulted only to upgrade a row we already know
+    // belongs to the caller into a live status.
+    const t = ctx.schema.aiFixes;
+    const rows = (await ctx.db
+        .select({ id: t.id, status: t.status })
+        .from(t)
+        .where(and(eq(t.accountId, accountId), eq(t.prId, prId)))
+        .orderBy(desc(t.id))
+        .limit(1)
+        .execute());
+    const row = rows[0];
+    if (!row)
+        return { status: 'idle', fixId: null, progress: null };
+    // Live in-memory state, but only for a fix id this account actually owns.
+    const liveFixId = fixIdByPr.get(prId) ?? null;
+    if (liveFixId === row.id) {
+        if (running.has(prId)) {
+            return {
+                status: 'running',
+                fixId: row.id,
+                progress: progressByFix.get(row.id) ?? { phase: 'cloning' },
+            };
+        }
+        if (claimed.has(prId)) {
+            return { status: 'queued', fixId: row.id, progress: { phase: 'fetching_diff' } };
+        }
+    }
+    return { status: row.status, fixId: row.id, progress: null };
+}
+export async function reconcileFixesOnStartup(ctx) {
+    try {
+        const n = await reconcileOrphanedFixes(ctx);
+        if (n > 0)
+            ctx.log.info({ n }, 'ai-fix: reconciled orphaned runs on startup');
+    }
+    catch (err) {
+        ctx.log.warn({ err }, 'ai-fix: startup reconcile failed');
+    }
+}
+//# sourceMappingURL=manager.js.map

package/dist/coding/ai-fix/persist.js

@@ -0,0 +1,213 @@
+import { and, desc, eq } from 'drizzle-orm';
+import { normalizeChangeReport } from './review-seed.js';
+export async function insertQueuedFix(ctx, input) {
+    const t = ctx.schema.aiFixes;
+    const items = input.reviewItems;
+    const rows = (await ctx.db
+        .insert(t)
+        .values({
+        accountId: input.accountId,
+        repoId: input.repoId,
+        prId: input.prId,
+        baseSha: input.baseSha,
+        status: 'queued',
+        model: input.model,
+        seed: input.seed,
+        sourceReviewId: input.sourceReviewId,
+        prompt: input.prompt,
+        trigger: input.trigger ?? 'manual',
+        // Omitted (→ NULL) on a plain run: null means "this run had no review items".
+        ...(items != null ? { reviewItems: JSON.stringify(items) } : {}),
+    })
+        .returning({ id: t.id })
+        .execute());
+    const id = rows[0]?.id;
+    if (id == null)
+        throw new Error('insertQueuedFix: no id returned');
+    return id;
+}
+export async function markFixRunning(ctx, id) {
+    const t = ctx.schema.aiFixes;
+    await ctx.db.update(t).set({ status: 'running' }).where(eq(t.id, id)).execute();
+}
+export async function saveFixSuccess(ctx, id, data, 
+// The refs the run was SHOWN ([] for a plain run) — the set the agent's report is validated
+// against.
+sentRefs) {
+    const t = ctx.schema.aiFixes;
+    const report = normalizeChangeReport(data.report, sentRefs, data.filesChanged);
+    await ctx.db
+        .update(t)
+        .set({
+        status: 'succeeded',
+        summary: data.summary,
+        commitMessage: data.commitMessage,
+        patch: data.patch,
+        filesChanged: JSON.stringify(data.filesChanged),
+        costUsd: data.costUsd,
+        inputTokens: data.usage.inputTokens,
+        outputTokens: data.usage.outputTokens,
+        numTurns: data.numTurns,
+        finishedAt: new Date(),
+        changeReport: JSON.stringify(report),
+    })
+        .where(eq(t.id, id))
+        .execute();
+    // Record the agentic-fixer spend on the shared AI-usage ledger (agent seam). Reads
+    // accountId/prId/model back off the row. Best-effort — the whole block (incl. the
+    // read-back SELECT) is guarded so a ledger error never flips an already-succeeded fix.
+    if (data.costUsd != null && Number.isFinite(data.costUsd) && data.costUsd > 0) {
+        try {
+            const row = (await ctx.db
+                .select({ accountId: t.accountId, prId: t.prId, model: t.model })
+                .from(t)
+                .where(eq(t.id, id))
+                .limit(1)
+                .execute())[0];
+            if (row)
+                await ctx.recordAiUsage({
+                    accountId: row.accountId,
+                    seam: 'agent',
+                    feature: 'ai_fix',
+                    model: row.model,
+                    costUsd: data.costUsd,
+                    inputTokens: data.usage.inputTokens,
+                    outputTokens: data.usage.outputTokens,
+                    prId: row.prId,
+                });
+        }
+        catch {
+            /* ledger write is best-effort — never break the fix save */
+        }
+    }
+}
+export async function markFixFailed(ctx, id, error) {
+    const t = ctx.schema.aiFixes;
+    await ctx.db
+        .update(t)
+        .set({ status: 'failed', error: error.slice(0, 4000), finishedAt: new Date() })
+        .where(eq(t.id, id))
+        .execute();
+}
+export async function markFixCancelled(ctx, id) {
+    const t = ctx.schema.aiFixes;
+    await ctx.db
+        .update(t)
+        .set({ status: 'cancelled', finishedAt: new Date() })
+        .where(eq(t.id, id))
+        .execute();
+}
+export async function markFixPushed(ctx, id, input) {
+    const t = ctx.schema.aiFixes;
+    await ctx.db
+        .update(t)
+        .set({
+        pushedBranch: input.pushedBranch,
+        pushedPrNumber: input.pushedPrNumber ?? null,
+        pushedPrUrl: input.pushedPrUrl ?? null,
+        pushedAt: new Date(),
+    })
+        .where(eq(t.id, id))
+        .execute();
+}
+export async function getFixById(ctx, accountId, id) {
+    const t = ctx.schema.aiFixes;
+    const rows = (await ctx.db
+        .select()
+        .from(t)
+        .where(and(eq(t.id, id), eq(t.accountId, accountId)))
+        .limit(1)
+        .execute());
+    return rows[0] ?? null;
+}
+export async function getLatestFix(ctx, accountId, prId) {
+    const t = ctx.schema.aiFixes;
+    const rows = (await ctx.db
+        .select()
+        .from(t)
+        .where(and(eq(t.accountId, accountId), eq(t.prId, prId)))
+        .orderBy(desc(t.id))
+        .limit(1)
+        .execute());
+    return rows[0] ?? null;
+}
+export async function listFixHistory(ctx, accountId, prId, limit = 20) {
+    const t = ctx.schema.aiFixes;
+    return (await ctx.db
+        .select()
+        .from(t)
+        .where(and(eq(t.accountId, accountId), eq(t.prId, prId)))
+        .orderBy(desc(t.id))
+        .limit(limit)
+        .execute());
+}
+// Heal rows left `queued`/`running` by a crash/restart (no live job can resume them).
+export async function reconcileOrphanedFixes(ctx) {
+    const t = ctx.schema.aiFixes;
+    const rows = (await ctx.db
+        .update(t)
+        .set({
+        status: 'failed',
+        error: 'interrupted by a server restart',
+        finishedAt: new Date(),
+    })
+        .where(eq(t.status, 'queued'))
+        .returning({ id: t.id })
+        .execute());
+    const rows2 = (await ctx.db
+        .update(t)
+        .set({
+        status: 'failed',
+        error: 'interrupted by a server restart',
+        finishedAt: new Date(),
+    })
+        .where(eq(t.status, 'running'))
+        .returning({ id: t.id })
+        .execute());
+    return rows.length + rows2.length;
+}
+export function parseFilesChanged(json) {
+    if (!json)
+        return [];
+    try {
+        const v = JSON.parse(json);
+        return Array.isArray(v) ? v : [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * The report JSON columns, parsed DEFENSIVELY: null for NULL and for anything unparseable. These
+ * are read by `GET /api/pro/prs/:id/ai-fix`, which loads the whole AI Fix tab, so a throw here
+ * would take the tab down over a malformed blob rather than degrading to "no report".
+ */
+export function parseReviewItems(json) {
+    const v = parseJson(json);
+    return Array.isArray(v) ? v : null;
+}
+export function parseChangeReport(json) {
+    const v = parseJson(json);
+    if (v == null || typeof v !== 'object' || Array.isArray(v))
+        return null;
+    const o = v;
+    return {
+        changes: Array.isArray(o.changes) ? o.changes : [],
+        unaddressed: Array.isArray(o.unaddressed) ? o.unaddressed : [],
+        notReported: Array.isArray(o.notReported) ? o.notReported : [],
+    };
+}
+export function parseTrigger(v) {
+    return v === 'auto' ? 'auto' : 'manual';
+}
+function parseJson(json) {
+    if (json == null || json === '')
+        return null;
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=persist.js.map

package/dist/coding/ai-fix/pr-context.js

@@ -0,0 +1,58 @@
+import { and, eq } from 'drizzle-orm';
+export async function getFixPrContext(ctx, accountId, prId) {
+    const pr = ctx.schema.pullRequests;
+    const repos = ctx.schema.repos;
+    const rows = (await ctx.db
+        .select({
+        prId: pr.id,
+        repoId: pr.repoId,
+        owner: repos.owner,
+        name: repos.name,
+        number: pr.number,
+        title: pr.title,
+        body: pr.body,
+        headSha: pr.headSha,
+        baseRefName: pr.baseRefName,
+        defaultBranch: repos.defaultBranch,
+        authorId: pr.authorId,
+        state: pr.state,
+    })
+        .from(pr)
+        .innerJoin(repos, eq(pr.repoId, repos.id))
+        .where(and(eq(pr.id, prId), eq(pr.accountId, accountId)))
+        .limit(1)
+        .execute());
+    const row = rows[0];
+    if (!row)
+        return null;
+    return {
+        prId: row.prId,
+        repoId: row.repoId,
+        owner: row.owner,
+        name: row.name,
+        repoFullName: `${row.owner}/${row.name}`,
+        number: row.number,
+        title: row.title,
+        body: row.body,
+        headSha: row.headSha,
+        baseRefName: row.baseRefName,
+        defaultBranch: row.defaultBranch,
+        authorId: row.authorId,
+        state: row.state,
+    };
+}
+// The viewer's WRITE permission on the PR's repo (for the push gate + branch picker).
+// Read from the synced repos.viewerPermission; the actual push still fails loud if the
+// token can't push, but this hides the controls / server-guards early.
+export async function getViewerCanPush(ctx, accountId, repoId) {
+    const repos = ctx.schema.repos;
+    const rows = (await ctx.db
+        .select({ perm: repos.viewerPermission })
+        .from(repos)
+        .where(and(eq(repos.id, repoId), eq(repos.accountId, accountId)))
+        .limit(1)
+        .execute());
+    const perm = rows[0]?.perm ?? '';
+    return ['WRITE', 'MAINTAIN', 'ADMIN'].includes(perm);
+}
+//# sourceMappingURL=pr-context.js.map