pierre-review 0.1.37 → 0.1.39

package/dist/api/routes/claude-review.js

@@ -7,6 +7,7 @@ import { hasUserAnthropicKey, setUserAnthropicKey, } from '../../review/local-se
 import { buildAnchorIndex, buildReview, fallbackAnchor, fetchCurrentHeadSha, fetchPrDiff, findingCommentBody, prLevelFindingBody, stripNoiseFromDiff, submitGithubComment, submitGithubIssueComment, submitGithubReview, } from '../../review/post-review.js';
 import { isNoiseFile } from '../../review/prompt.js';
 import { accountIdOf } from '../plugins/auth.js';
+import { reviewEvents } from '../../review/events.js';
 const MODELS = ['claude-opus-4-8', 'claude-sonnet-4-6', 'claude-haiku-4-5'];
 const VERDICTS = ['COMMENT', 'REQUEST_CHANGES', 'APPROVE'];
 const REVIEW_MODES = ['auto', 'diff_only', 'worktree'];
@@ -158,6 +159,13 @@ export async function claudeReviewRoutes(app) {
                     : 'The review queue is full; try again once some finish.',
             };
         }
+        reviewEvents.emit({
+            type: 'review.requested',
+            accountId: accountIdOf(req),
+            prId: id,
+            model,
+            requestedMode: mode ?? 'auto',
+        });
         reply.status(202);
         return { reviewId: result.reviewId, status: 'queued' };
     });
@@ -218,6 +226,12 @@ export async function claudeReviewRoutes(app) {
             reply.status(404);
             return { error: 'NotFound', message: `Review ${reviewId} not found` };
         }
+        reviewEvents.emit({
+            type: 'review.draftUpdated',
+            accountId: accountIdOf(req),
+            reviewId,
+            change: { userBody: body.userBody, userVerdict: body.userVerdict },
+        });
         return { status: 'ok' };
     });
     // Tick a finding for inline posting and/or save the user's reworded body.
@@ -231,6 +245,12 @@ export async function claudeReviewRoutes(app) {
             reply.status(404);
             return { error: 'NotFound', message: `Finding ${findingId} not found` };
         }
+        reviewEvents.emit({
+            type: 'finding.updated',
+            accountId: accountIdOf(req),
+            findingId,
+            change: { included: body.included, editedBody: body.editedBody },
+        });
         return { status: 'ok' };
     });
     // Post a single finding as a standalone comment (no review submitted). The
@@ -243,7 +263,8 @@ export async function claudeReviewRoutes(app) {
         if (!config.claudeReviewEnabled)
             return featureOff(reply);
         const { findingId } = req.params;
-        const ctx = await getFindingPostContext(findingId, accountIdOf(req));
+        const accountId = accountIdOf(req);
+        const ctx = await getFindingPostContext(findingId, accountId);
         if (!ctx) {
             reply.status(404);
             return { error: 'NotFound', message: `Finding ${findingId} not found` };
@@ -276,6 +297,12 @@ export async function claudeReviewRoutes(app) {
                     }),
                 });
                 await markFindingPosted(findingId, commentId, 'inline');
+                reviewEvents.emit({
+                    type: 'finding.posted',
+                    accountId,
+                    findingId,
+                    postedCommentKind: 'inline',
+                });
                 const result = { githubCommentId: commentId, postedAt };
                 return result;
             }
@@ -295,6 +322,12 @@ export async function claudeReviewRoutes(app) {
                     body: findingCommentBody({ body: f.body, editedBody: f.editedBody, suggestion: f.suggestion }, { fallbackNote: true }),
                 });
                 await markFindingPosted(findingId, commentId, 'inline');
+                reviewEvents.emit({
+                    type: 'finding.posted',
+                    accountId,
+                    findingId,
+                    postedCommentKind: 'inline',
+                });
                 const result = { githubCommentId: commentId, postedAt };
                 return result;
             }
@@ -312,6 +345,12 @@ export async function claudeReviewRoutes(app) {
                 }),
             });
             await markFindingPosted(findingId, commentId, 'pr_comment');
+            reviewEvents.emit({
+                type: 'finding.posted',
+                accountId,
+                findingId,
+                postedCommentKind: 'pr_comment',
+            });
             const result = { githubCommentId: commentId, postedAt };
             return result;
         }
@@ -398,6 +437,14 @@ export async function claudeReviewRoutes(app) {
                 }
             }
             await markReviewPosted(reviewId, ghReviewId, built.inlineFindingIds, prCommentResults);
+            reviewEvents.emit({
+                type: 'review.posted',
+                accountId,
+                reviewId,
+                userVerdict,
+                inlineFindingIds: built.inlineFindingIds,
+                prCommentFindingIds: prCommentResults.map((r) => r.findingId),
+            });
             const result = {
                 postedReviewId: ghReviewId,
                 postedAt: new Date().toISOString(),

package/dist/api/routes/inbox.js

@@ -0,0 +1,28 @@
+import { getInbox, listClaudeReviewsByRepo } from '../../db/queries.js';
+import { accountIdOf } from '../plugins/auth.js';
+function parseIntList(raw) {
+    if (!raw)
+        return null;
+    const ids = raw
+        .split(',')
+        .map((s) => Number.parseInt(s.trim(), 10))
+        .filter((n) => Number.isFinite(n));
+    return ids.length > 0 ? ids : null;
+}
+export async function inboxRoutes(app) {
+    // The Inbox aggregate: per watched repo, current-state stats + thread totals +
+    // attention/unread flags + open PRs. Scoped to the account; `repoIds` narrows to
+    // the active watched-repo selection. Pure DB read — no GitHub sync, no AI.
+    app.get('/api/inbox', async (req) => {
+        const q = req.query;
+        return getInbox(accountIdOf(req), parseIntList(q.repoIds));
+    });
+    // Repo-scoped Claude-review history for the Inbox single-repo console. Ownership +
+    // feature-gating are handled inside the query (an unowned repo / disabled feature
+    // both return an empty list), so the caller never leaks another account's data.
+    app.get('/api/repos/:id/claude-reviews', async (req) => {
+        const { id } = req.params;
+        return listClaudeReviewsByRepo(Number.parseInt(id, 10), accountIdOf(req));
+    });
+}
+//# sourceMappingURL=inbox.js.map

package/dist/api/routes/me.js

@@ -1,6 +1,7 @@
 import { config } from '../../config.js';
 import { accountToLocalUser } from '../../auth/account.js';
 import { accountIdOf } from '../plugins/auth.js';
+import { getProCapabilities } from '../../pro/contract.js';
 import { dismissMyTurn, getCompletedDismissals, getMyTurn, undismissMyTurn, } from '../../db/queries.js';
 const dismissSchema = {
     body: {
@@ -32,6 +33,7 @@ export async function meRoutes(app) {
             },
             claudeReviewEnabled: config.claudeReviewEnabled,
             deploymentMode: config.deploymentMode,
+            pro: getProCapabilities(),
         };
     });
     app.get('/api/my-turn', async (req) => getMyTurn(accountIdOf(req)));

package/dist/app.js

@@ -18,6 +18,7 @@ import { openPrsRoutes } from './api/routes/open-prs.js';
 import { feedRoutes } from './api/routes/feed.js';
 import { mergersRoutes } from './api/routes/mergers.js';
 import { insightsRoutes } from './api/routes/insights.js';
+import { inboxRoutes } from './api/routes/inbox.js';
 import { claudeReviewRoutes } from './api/routes/claude-review.js';
 export async function buildApp() {
     const app = Fastify({
@@ -130,6 +131,7 @@ export async function buildApp() {
     await app.register(feedRoutes);
     await app.register(mergersRoutes);
     await app.register(insightsRoutes);
+    await app.register(inboxRoutes);
     // Claude Review is local-only + opt-in. Only register its routes when enabled,
     // so the clone-manager / gh-CLI dependency is unreachable in cloud mode.
     if (config.claudeReviewEnabled)

package/dist/config.js

@@ -118,6 +118,19 @@ export const config = {
     // HSTS_MAX_AGE=0 as a kill switch. `preload` is intentionally NOT sent — it is
     // hard to undo; opt in manually once the domain is proven.
     hstsMaxAge: intFromEnv('HSTS_MAX_AGE', 31536000),
+    // Pro plugin master gate. Pro is local-only for now; bind.ts skips the dynamic
+    // import entirely when false.
+    proEnabled: !isCloud,
+    // Per-repo digest (Pro, Workstream 2) config — consumed by @pierre/pro, kept in
+    // core so the model id / budgets live in one place and aren't hardcoded at call
+    // sites. Inert until the plugin is present AND digestEnabled.
+    pro: {
+        digestModel: process.env.PRO_DIGEST_MODEL ?? 'claude-haiku-4-5',
+        digestEnabled: process.env.PRO_DIGEST_ENABLED === 'true',
+        digestMaxUsdPerRefresh: floatFromEnv('PRO_DIGEST_MAX_USD', 0.5),
+        digestMaxReposPerRefresh: intFromEnv('PRO_DIGEST_MAX_REPOS', 30),
+        digestMinIntervalSec: intFromEnv('PRO_DIGEST_MIN_INTERVAL_SEC', 60),
+    },
     // ---- Claude Review (agentic PR review; opt-in, LOCAL-ONLY) ----
     // OFF by default: the feature spends real money / Agent-SDK credits per run.
     // Enable with ENABLE_CLAUDE_REVIEW=true. FORCE-DISABLED in cloud mode (it

package/dist/db/queries.js

@@ -1015,6 +1015,86 @@ export async function getMergers(accountId) {
     }
     return [...byRepo.entries()].map(([repoId, userIds]) => ({ repoId, userIds }));
 }
+// ---- inbox (CORE, always-on, no AI) ----
+// Reason tags that, on an open PR, count as "needs attention" for the Inbox rail
+// badge (a my-turn-shaped triage reason). Stalled + untouched threads are folded
+// in separately via the per-PR flags. Keep in sync with REASON_PRIORITY values.
+const INBOX_ATTENTION_REASONS = new Set([
+    'awaiting_your_review',
+    'your_pr_new_comments',
+    'ci_failing',
+    'merge_conflicts',
+    'untouched_threads',
+]);
+// The Inbox aggregate: per watched repo, current-state stats + a per-repo thread
+// total + maintainer ids + attention/unread flags + the open PRs (caller groups by
+// author). Composes EXISTING accountId-scoped readers — getInsights / getOpenPrs /
+// getMergers / listRepos — so isolation + triage logic stay single-sourced. The
+// one genuinely new aggregation is `threadTotals` (sum each open PR's threadCounts
+// per repo). Every watched repo is included (a quiet repo → empty prs, zeroed stats).
+export async function getInbox(accountId, repoIds) {
+    const reposAll = await listRepos(accountId);
+    const reposScoped = repoIds ? reposAll.filter((r) => repoIds.includes(r.id)) : reposAll;
+    const [insights, openPrs, mergers] = await Promise.all([
+        getInsights({ accountId, repoIds }),
+        getOpenPrs({ accountId, repoIds, userIds: null }),
+        getMergers(accountId),
+    ]);
+    const insightsByRepo = new Map(insights.repos.map((r) => [r.repoId, r]));
+    const mergersByRepo = new Map(mergers.map((m) => [m.repoId, m.userIds]));
+    const prsByRepo = new Map();
+    for (const pr of openPrs) {
+        const arr = prsByRepo.get(pr.repoId);
+        if (arr)
+            arr.push(pr);
+        else
+            prsByRepo.set(pr.repoId, [pr]);
+    }
+    // Preserve listRepos order (stable, not jumpy across loads).
+    const inboxRepos = reposScoped.map((repo) => {
+        const repoPrs = prsByRepo.get(repo.id) ?? [];
+        const ins = insightsByRepo.get(repo.id);
+        const stats = ins
+            ? {
+                openPrs: ins.openPrs,
+                draftPrs: ins.draftPrs,
+                mergedLast7d: ins.mergedLast7d,
+                stalledPrs: ins.stalledPrs,
+                medianHoursToFirstReview: ins.medianHoursToFirstReview,
+                oldestUnreviewed: ins.oldestUnreviewed,
+            }
+            : {
+                openPrs: 0,
+                draftPrs: 0,
+                mergedLast7d: 0,
+                stalledPrs: 0,
+                medianHoursToFirstReview: null,
+                oldestUnreviewed: null,
+            };
+        const threadTotals = emptyCounts();
+        for (const pr of repoPrs) {
+            threadTotals.untouched += pr.threadCounts.untouched;
+            threadTotals.replied_unresolved += pr.threadCounts.replied_unresolved;
+            threadTotals.likely_addressed += pr.threadCounts.likely_addressed;
+            threadTotals.resolved += pr.threadCounts.resolved;
+        }
+        const attentionCount = repoPrs.filter((pr) => pr.isStalled ||
+            pr.threadCounts.untouched > 0 ||
+            INBOX_ATTENTION_REASONS.has(pr.reasonTag)).length;
+        const hasUnread = repoPrs.some((pr) => pr.newSinceLastViewed != null);
+        return {
+            repoId: repo.id,
+            repoFullName: repo.fullName,
+            stats,
+            threadTotals,
+            maintainerIds: mergersByRepo.get(repo.id) ?? [],
+            attentionCount,
+            hasUnread,
+            prs: repoPrs,
+        };
+    });
+    return { repos: inboxRepos, generatedAt: new Date().toISOString() };
+}
 // ---- incremental review: pr_views ----
 export async function markPrViewed(prId, accountId, sha) {
     const prRows = await db
@@ -2213,6 +2293,65 @@ export async function listClaudeReviewHistory(prId, accountId) {
         finishedAt: iso(r.finishedAt),
     }));
 }
+// Repo-oriented Claude-review retrieval for the Inbox single-repo console: ALL runs
+// for a repo's PRs, grouped by PR (newest run first within each), PRs ordered by
+// most-recent run desc. Richer than listAllClaudeReviews (which keeps only one
+// latest-succeeded run per PR). IDOR-sensitive id getter: scoped by accountId, and
+// gated on config.claudeReviewEnabled. An unowned repo (cross-account) → empty list.
+export async function listClaudeReviewsByRepo(repoId, accountId) {
+    if (!config.claudeReviewEnabled)
+        return { enabled: false, prs: [] };
+    // Ownership: a repo not owned by this account leaks nothing (404-equivalent).
+    const owned = await getRepo(repoId, accountId);
+    if (!owned)
+        return { enabled: config.claudeReviewEnabled, prs: [] };
+    const rows = await db
+        .select({
+        review: claudeReviews,
+        prNumber: pullRequests.number,
+        prTitle: pullRequests.title,
+        prState: pullRequests.state,
+        authorId: pullRequests.authorId,
+    })
+        .from(claudeReviews)
+        .innerJoin(pullRequests, eq(pullRequests.id, claudeReviews.prId))
+        .where(and(eq(claudeReviews.accountId, accountId), eq(pullRequests.repoId, repoId)))
+        .orderBy(desc(claudeReviews.id))
+        .execute();
+    // Rows are globally id-desc (newest-first). The first row seen for each PR is its
+    // newest run, so map-insertion order = PRs by most-recent run desc, and each PR's
+    // runs[] accumulate newest-first — no extra sort needed.
+    const byPr = new Map();
+    for (const { review: r, prNumber, prTitle, prState, authorId } of rows) {
+        const summary = {
+            id: r.id,
+            headSha: r.headSha,
+            status: r.status,
+            model: r.model,
+            scope: r.scope,
+            reviewMode: r.reviewMode,
+            verdict: r.verdict,
+            userVerdict: r.userVerdict,
+            costUsd: r.costUsd,
+            postedAt: iso(r.postedAt),
+            createdAt: r.createdAt.toISOString(),
+            finishedAt: iso(r.finishedAt),
+        };
+        const existing = byPr.get(r.prId);
+        if (existing)
+            existing.runs.push(summary);
+        else
+            byPr.set(r.prId, {
+                prId: r.prId,
+                prNumber,
+                prTitle,
+                prState,
+                authorId,
+                runs: [summary],
+            });
+    }
+    return { enabled: true, prs: [...byPr.values()] };
+}
 // Cross-PR list of prior Claude reviews: ONE entry per PR = that PR's most-recent
 // SUCCEEDED run, accountId-scoped, restricted to PRs still within the timeline
 // window (open, or last touched within `backfillDays`), newest-first by finish

package/dist/index.js

@@ -34,6 +34,12 @@ export async function start() {
         const { reconcileReviewsOnStartup } = await import('./review/review-manager.js');
         await reconcileReviewsOnStartup(app.log);
     }
+    // Bind the optional Pro plugin (dynamic import; no-ops in OSS mode). Same
+    // "optional subsystem, degrade gracefully" posture as the scheduler below.
+    {
+        const { bindProPlugin } = await import('./pro/bind.js');
+        await bindProPlugin(app);
+    }
     // Scheduler is wired in Phase 3; guarded so the skeleton runs without it.
     if (!config.disableScheduler) {
         try {

package/dist/pro/bind.js

@@ -0,0 +1,77 @@
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { config } from '../config.js';
+import { accountIdOf } from '../api/plugins/auth.js';
+import { db, schema, runTransaction, isPg } from '../db/client.js';
+import * as hostQueries from '../db/queries.js';
+import { reviewEvents, registerLearningsProvider } from '../review/events.js';
+import { cheapComplete } from '../review/llm.js';
+import { runPluginMigrations } from './migrate.js';
+import { setProCapabilities } from './contract.js';
+// Boot binding for the optional @pierre/pro plugin. The plugin lives in a PRIVATE
+// git submodule at packages/pro (often absent — a pure-OSS checkout never has it).
+// It is deliberately NOT a declared dependency, so `pnpm install` succeeds without
+// it; we resolve it by FILESYSTEM PATH rather than a bare specifier (no package.json
+// coupling). Submodule absent → no entry file on disk → clean OSS no-op.
+export async function bindProPlugin(app) {
+    if (!config.proEnabled)
+        return; // master gate (Pro is local-only for now)
+    // here = apps/backend/{src|dist}/pro/bind.{ts|js} → repo root is four levels up.
+    const here = fileURLToPath(import.meta.url);
+    const repoRoot = resolve(dirname(here), '../../../..');
+    const entry = [
+        join(repoRoot, 'packages/pro/dist/index.js'), // built plugin (node)
+        join(repoRoot, 'packages/pro/src/index.ts'), // source (tsx dev)
+    ].find(existsSync);
+    if (!entry) {
+        app.log.debug('pro plugin submodule absent — OSS mode');
+        return;
+    }
+    const mod = await import(pathToFileURL(entry).href).catch((err) => {
+        app.log.warn({ err }, 'pro plugin present but failed to load — OSS mode');
+        return null;
+    });
+    if (!mod)
+        return;
+    const plugin = (mod.default ?? mod);
+    if (plugin?.apiVersion !== 1 || typeof plugin.register !== 'function') {
+        app.log.warn({ apiVersion: plugin?.apiVersion }, 'pro contract mismatch — skipped');
+        return;
+    }
+    const ctx = {
+        log: app.log,
+        host: {
+            version: process.env.npm_package_version ?? '0.0.0',
+            deploymentMode: config.deploymentMode,
+            isCloud: config.isCloud,
+        },
+        accountIdOf,
+        db,
+        schema,
+        runTransaction,
+        isPg,
+        registerMigrations: (sqliteFolder, pgFolder) => runPluginMigrations(sqliteFolder, pgFolder),
+        llm: { complete: cheapComplete },
+        queries: {
+            getInsights: (accountId, repoIds) => hostQueries.getInsights({ accountId, repoIds: repoIds ?? null }),
+            getRepoAnalytics: (accountId, repoId) => hostQueries.getRepoAnalytics(accountId, repoId),
+            getOpenPrs: (args) => hostQueries.getOpenPrs({
+                accountId: args.accountId,
+                repoIds: args.repoIds ?? null,
+                userIds: null,
+            }),
+            getInbox: (accountId, repoIds) => hostQueries.getInbox(accountId, repoIds ?? null),
+        },
+        reviewEvents,
+        registerLearningsProvider,
+    };
+    try {
+        setProCapabilities(await plugin.register(app, ctx));
+        app.log.info('pro plugin active');
+    }
+    catch (err) {
+        app.log.warn({ err }, 'pro register() failed — OSS mode');
+    }
+}
+//# sourceMappingURL=bind.js.map

package/dist/pro/contract.js

@@ -0,0 +1,12 @@
+// The live capability singleton, mirrored to the frontend via /api/me exactly
+// like claudeReviewEnabled. All-false in OSS mode (no plugin ever calls the
+// setter).
+const EMPTY = { inboxDigest: false, reviewMemory: false };
+let active = EMPTY;
+export function setProCapabilities(c) {
+    active = c;
+}
+export function getProCapabilities() {
+    return active;
+}
+//# sourceMappingURL=contract.js.map

package/dist/pro/migrate.js

@@ -0,0 +1,64 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { db, isPg } from '../db/client.js';
+// Plugin migration runner (core-owned). The optional @pierre/pro plugin ships its
+// OWN dual-dialect *.sql migrations and calls ctx.registerMigrations(sqliteFolder,
+// pgFolder); core executes them here against the live connection.
+//
+// ⚠ THIS IS THE ONLY PLACE the raw DB driver / non-portable terminals are used,
+// and it is strictly DDL + bookkeeping (CREATE TABLE / INSERT into pro_migrations)
+// — never a data query. Everything else in the codebase MUST go through the
+// portable async drizzle surface (.execute()/.returning().execute()).
+export async function runPluginMigrations(sqliteFolder, pgFolder) {
+    const folder = isPg ? pgFolder : sqliteFolder;
+    // The raw driver behind drizzle: a node-postgres Pool (pg) or a better-sqlite3
+    // Database (sqlite). drizzle exposes it as `$client`.
+    const client = db.$client;
+    // Run a raw SQL string (possibly several statements). pg's Pool.query and
+    // better-sqlite3's Database.exec both accept multiple semicolon-separated
+    // statements in a single call.
+    const execRaw = async (sqlText) => {
+        if (isPg)
+            await client.query(sqlText);
+        else
+            client.exec(sqlText);
+    };
+    // Bookkeeping table — which plugin migrations have been applied.
+    await execRaw('CREATE TABLE IF NOT EXISTS pro_migrations (name text PRIMARY KEY, applied_at ' +
+        (isPg ? 'timestamptz' : 'integer') +
+        ' NOT NULL)');
+    const files = readdirSync(folder)
+        .filter((f) => f.endsWith('.sql'))
+        .sort();
+    for (const name of files) {
+        try {
+            let applied;
+            if (isPg) {
+                const r = await client.query('SELECT 1 FROM pro_migrations WHERE name=$1', [name]);
+                applied = r.rowCount > 0;
+            }
+            else {
+                const row = client
+                    .prepare('SELECT 1 FROM pro_migrations WHERE name=?')
+                    .get(name);
+                applied = !!row;
+            }
+            if (applied)
+                continue;
+            const text = readFileSync(join(folder, name), 'utf8');
+            await execRaw(text);
+            if (isPg) {
+                await client.query('INSERT INTO pro_migrations(name,applied_at) VALUES($1,$2)', [name, new Date()]);
+            }
+            else {
+                client
+                    .prepare('INSERT INTO pro_migrations(name,applied_at) VALUES(?,?)')
+                    .run(name, Date.now());
+            }
+        }
+        catch (err) {
+            throw new Error(`pro migration '${name}' failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+//# sourceMappingURL=migrate.js.map

package/dist/review/agent.js

@@ -197,6 +197,7 @@ export async function runReview(args) {
                 diff: promptDiff,
                 mode,
                 omittedFiles,
+                priorReviewContext: args.priorReviewContext,
             }),
             options: {
                 model: args.model,

package/dist/review/events.js

@@ -0,0 +1,31 @@
+const listeners = new Set();
+export const reviewEvents = {
+    on(listener) {
+        listeners.add(listener);
+        return () => {
+            listeners.delete(listener);
+        };
+    },
+    emit(e) {
+        // A subscriber error must NEVER break the review route that emitted, so each
+        // call is isolated; we deliberately swallow (log nothing) rather than throw.
+        for (const listener of listeners) {
+            try {
+                listener(e);
+            }
+            catch {
+                /* a subscriber failure must not surface to the emitter */
+            }
+        }
+    },
+};
+// Single nullable provider registry. Null in OSS mode ⇒ the review prompt is
+// byte-identical to today (review-manager passes priorReviewContext: undefined).
+let _provider = null;
+export function registerLearningsProvider(p) {
+    _provider = p;
+}
+export function getLearningsProvider() {
+    return _provider;
+}
+//# sourceMappingURL=events.js.map

package/dist/review/llm.js

@@ -0,0 +1,92 @@
+import { getUserAnthropicKey } from './local-settings.js';
+const DEFAULT_MODEL = 'claude-haiku-4-5';
+export async function cheapComplete(opts) {
+    const model = opts.model ?? DEFAULT_MODEL;
+    // A real API key (user-supplied local key wins, then ANTHROPIC_API_KEY) takes the
+    // cheap, metered, exact-cost raw path.
+    const apiKey = getUserAnthropicKey() ?? process.env.ANTHROPIC_API_KEY;
+    if (apiKey)
+        return rawComplete(apiKey, model, opts);
+    // No explicit key → use the Agent SDK, which resolves a CLAUDE_CODE_OAUTH_TOKEN
+    // or an ambient logged-in Claude session exactly as Claude Review does.
+    return agentComplete(model, opts);
+}
+// ---- raw @anthropic-ai/sdk path (explicit API key) ----------------------------
+async function rawComplete(apiKey, model, opts) {
+    const { default: Anthropic } = await import('@anthropic-ai/sdk');
+    const client = new Anthropic({ apiKey });
+    const resp = await client.messages.create({
+        model,
+        max_tokens: opts.maxTokens ?? 700,
+        system: opts.system,
+        messages: [{ role: 'user', content: opts.prompt }],
+    });
+    const blocks = resp.content;
+    const text = (Array.isArray(blocks) ? blocks : [])
+        .map((b) => {
+        const block = b;
+        return block?.type === 'text' && typeof block.text === 'string'
+            ? block.text
+            : '';
+    })
+        .join('');
+    return {
+        text: text.trim(),
+        usage: {
+            inputTokens: resp.usage.input_tokens,
+            outputTokens: resp.usage.output_tokens,
+        },
+    };
+}
+// ---- Claude Agent SDK path (OAuth token / ambient session) --------------------
+async function agentComplete(model, opts) {
+    const { query } = await import('@anthropic-ai/claude-agent-sdk');
+    // A single-turn, tool-less completion: the system prompt is folded into the user
+    // prompt (the SDK's systemPrompt is also passed for models that honour it). No
+    // tools, no settings, one turn — just text out.
+    const prompt = opts.system
+        ? `${opts.system}\n\n---\n\n${opts.prompt}`
+        : opts.prompt;
+    const q = query({
+        prompt,
+        options: {
+            model,
+            systemPrompt: opts.system,
+            allowedTools: [],
+            maxTurns: 1,
+            permissionMode: 'bypassPermissions',
+            // Don't load the user's ~/.claude settings / MCP servers for a plain
+            // completion (mirrors review/agent.ts).
+            settingSources: [],
+        },
+    });
+    let text = '';
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let errored = null;
+    for await (const message of q) {
+        const type = message.type;
+        if (type === 'assistant') {
+            const inner = (message.message ?? {});
+            for (const b of inner.content ?? []) {
+                if (b?.type === 'text' && typeof b.text === 'string')
+                    text += b.text;
+            }
+        }
+        else if (type === 'result') {
+            const usage = (message.usage ?? {});
+            inputTokens = usage.input_tokens ?? inputTokens;
+            outputTokens = usage.output_tokens ?? outputTokens;
+            const subtype = String(message.subtype ?? '');
+            if (subtype && subtype !== 'success' && !text) {
+                errored = subtype;
+            }
+        }
+    }
+    const trimmed = text.trim();
+    if (!trimmed) {
+        throw new Error(`Agent SDK completion returned no text${errored ? ` (${errored})` : ''} — check Claude auth (ANTHROPIC_API_KEY, or run \`claude\` to sign in).`);
+    }
+    return { text: trimmed, usage: { inputTokens, outputTokens } };
+}
+//# sourceMappingURL=llm.js.map