@0xcraft/powershot 1.0.0

package/dist/ground.js

@@ -0,0 +1,286 @@
+import { Project, SyntaxKind } from 'ts-morph';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { decode } from './text.js';
+import { join, dirname } from 'node:path';
+import { packFor, parse } from './lang/packs.js';
+import { insideRepo, isSymlink, repoPath } from './fspolicy.js';
+const CODE_EXT = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+export function normalizeName(n) {
+    return n.toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+/**
+ * Walks up, but never past `stop`.
+ *
+ * A tsconfig above the repository is somebody else's, and letting one configure the
+ * program that reviews this repository lets a parent directory decide what is
+ * type-checked and where paths resolve to.
+ */
+function findUp(from, name, stop = from) {
+    let dir = from;
+    for (;;) {
+        const p = join(dir, name);
+        if (existsSync(p))
+            return p;
+        if (dir === stop)
+            return undefined;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+function depsIn(pkgPath) {
+    const deps = new Set();
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        for (const field of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
+            for (const name of Object.keys(pkg[field] ?? {}))
+                deps.add(name);
+        }
+    }
+    catch {
+        // an unparseable manifest means we cannot claim a dep is missing
+    }
+    return deps;
+}
+/**
+ * Dependencies visible to one file, which in a workspace is not the same as the
+ * repository's. A monorepo declares react in apps/web/package.json and nowhere else,
+ * so reading only the root manifest would call every real dependency phantom.
+ */
+function makeDepsFor(root) {
+    const cache = new Map();
+    return (absPath) => {
+        let dir = dirname(absPath);
+        const cached = cache.get(dir);
+        if (cached)
+            return cached;
+        const deps = new Set();
+        for (;;) {
+            const pkgPath = join(dir, 'package.json');
+            if (existsSync(pkgPath))
+                for (const d of depsIn(pkgPath))
+                    deps.add(d);
+            if (dir === root || dirname(dir) === dir)
+                break;
+            dir = dirname(dir);
+        }
+        cache.set(dirname(absPath), deps);
+        return deps;
+    };
+}
+/**
+ * Build the oracle once per run: a type-checked project over the working tree,
+ * a syntax-only project holding the base-ref versions, and a symbol index.
+ */
+export async function buildGround(root, changed, signal) {
+    const tsConfigFilePath = findUp(root, 'tsconfig.json');
+    const typed = Boolean(tsConfigFilePath);
+    const project = typed
+        ? new Project({ tsConfigFilePath })
+        : new Project({ compilerOptions: { allowJs: true, checkJs: false } });
+    if (!typed)
+        project.addSourceFilesAtPaths([`${root}/**/*.{ts,tsx,js,jsx,mts,cts}`, `!${root}/**/node_modules/**`]);
+    // What the tsconfig itself owns. A file added past this point is present for
+    // reading, but the checker has no program for it — asking one for diagnostics
+    // throws from inside TypeScript, which took the whole review down with it.
+    const owned = new Set(project.getSourceFiles().map((f) => repoPath(root, String(f.getFilePath()))));
+    // A changed file may be new, or excluded from tsconfig — make sure it is present.
+    // `readable` is the gate for every file that becomes reviewable: the glob above
+    // follows symlinks, so passing this on the way in is not enough on its own.
+    const readable = (path) => {
+        const abs = insideRepo(root, path);
+        return abs && !isSymlink(abs) ? abs : undefined;
+    };
+    for (const c of changed) {
+        if (!CODE_EXT.test(c.path))
+            continue;
+        const abs = readable(c.path);
+        if (!abs)
+            continue;
+        if (!project.getSourceFile(abs) && existsSync(abs))
+            project.addSourceFileAtPath(abs);
+    }
+    const beforeProject = new Project({ useInMemoryFileSystem: true });
+    const files = [];
+    for (const c of changed) {
+        if (!CODE_EXT.test(c.path))
+            continue;
+        const abs = readable(c.path);
+        if (!abs)
+            continue;
+        const sf = project.getSourceFile(abs);
+        if (!sf)
+            continue;
+        const before = c.before === undefined ? undefined : beforeProject.createSourceFile(`/before/${c.path}`, c.before, { overwrite: true });
+        files.push({ sf, changed: c, before, typed: typed && owned.has(repoPath(root, c.path)) });
+    }
+    return {
+        root,
+        project,
+        beforeProject,
+        changed,
+        files,
+        symbolIndex: buildSymbolIndex(project, root),
+        deps: makeDepsFor(root)(join(root, 'x.ts')),
+        depsFor: makeDepsFor(root),
+        typed,
+        internalPrefixes: pathAliasPrefixes(project, root),
+        foreign: await parseForeign(root, changed, signal),
+        envManifest: readEnvManifest(root),
+    };
+}
+/**
+ * Prefixes that `compilerOptions.paths` maps back into the repo — `@/*` and friends.
+ * They look like package names but resolve to local files, so treating them as
+ * dependencies would be wrong.
+ */
+function pathAliasPrefixes(project, root) {
+    const prefixes = new Set();
+    for (const pattern of Object.keys(project.getCompilerOptions().paths ?? {})) {
+        prefixes.add(pattern.replace(/\*$/, ''));
+    }
+    // a workspace declares its aliases in each package's tsconfig, and the root config
+    // often only `extends` a shared base — so the root's paths are not the whole story
+    for (const file of tsconfigsIn(root)) {
+        try {
+            const raw = readFileSync(file, 'utf8').replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|\s)\/\/.*$/gm, '$1');
+            const parsed = JSON.parse(raw.replace(/,(\s*[}\]])/g, '$1'));
+            for (const pattern of Object.keys(parsed?.compilerOptions?.paths ?? {})) {
+                prefixes.add(String(pattern).replace(/\*$/, ''));
+            }
+        }
+        catch {
+            // an unreadable or non-standard tsconfig simply contributes no aliases
+        }
+    }
+    return [...prefixes];
+}
+/** every tsconfig in the repo, capped so a huge monorepo cannot stall the run */
+function tsconfigsIn(root) {
+    const out = [];
+    const walk = (dir, depth) => {
+        if (depth > 4 || out.length > 60)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (e.name === 'node_modules' || e.name.startsWith('.'))
+                continue;
+            const full = join(dir, e.name);
+            if (e.isDirectory())
+                walk(full, depth + 1);
+            else if (e.name === 'tsconfig.json')
+                out.push(full);
+        }
+    };
+    walk(root, 0);
+    return out;
+}
+/**
+ * Changed files the TypeScript project cannot hold. Nine of the checks need only a
+ * parse tree, so a Python or Go file is reviewable the moment its grammar loads —
+ * the four that need types simply do not run on it.
+ */
+const ENV_MANIFESTS = ['.env.example', '.env.sample', '.env.template', '.env.defaults', '.env.dist'];
+/**
+ * Keys declared in whatever env manifest the repo keeps. Read once here rather than
+ * per verifier, so every language's phantom-config compares against the same truth.
+ */
+export function readEnvManifest(root) {
+    for (const name of ENV_MANIFESTS) {
+        const path = join(root, name);
+        if (!existsSync(path))
+            continue;
+        const keys = new Set();
+        for (const line of decode(readFileSync(path)).split(/\r?\n/)) {
+            // A commented entry is how a template documents an optional variable —
+            // `# OPENAI_BASE_URL=` says the name exists and may be left unset, so treating
+            // it as undeclared reports the very file that documents it.
+            const match = /^\s*#?\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line);
+            if (match?.[1])
+                keys.add(match[1]);
+        }
+        return { keys, file: name };
+    }
+    return undefined;
+}
+async function parseForeign(root, changed, signal) {
+    const out = [];
+    for (const c of changed) {
+        // parsing thousands of files is where a large scan spends its time, so a signal
+        // has to be honoured here rather than only once the checks begin
+        if (signal?.aborted)
+            break;
+        const pack = packFor(c.path);
+        if (!pack)
+            continue;
+        const abs = insideRepo(root, c.path);
+        if (!abs || !existsSync(abs))
+            continue;
+        // a generated or minified file is not source anyone reviews, and parsing one
+        // costs seconds to produce findings nobody acts on
+        if ((statSync(abs, { throwIfNoEntry: false })?.size ?? 0) > 512 * 1024)
+            continue;
+        const tree = await parse(pack, decode(readFileSync(abs)));
+        if (!tree)
+            continue;
+        const beforeTree = c.before === undefined ? undefined : await parse(pack, c.before);
+        out.push({ path: c.path, pack, tree, beforeTree, changed: c });
+    }
+    return out;
+}
+function buildSymbolIndex(project, root) {
+    const index = new Map();
+    for (const sf of project.getSourceFiles()) {
+        const path = String(sf.getFilePath());
+        // the project glob follows symlinked directories, so what it loaded is not
+        // proof of where the file is
+        if (path.includes('/node_modules/') || !insideRepo(root, path))
+            continue;
+        for (const [name, decls] of sf.getExportedDeclarations()) {
+            const decl = decls[0];
+            if (!decl)
+                continue;
+            // only index things that could plausibly be reimplemented
+            const kind = decl.getKind();
+            if (kind !== SyntaxKind.FunctionDeclaration &&
+                kind !== SyntaxKind.VariableDeclaration &&
+                kind !== SyntaxKind.ClassDeclaration)
+                continue;
+            // a barrel re-exports another module's symbol, so record where it is actually
+            // declared — otherwise `export * from './x'` makes every symbol look duplicated
+            const declPath = String(decl.getSourceFile().getFilePath());
+            if (declPath.includes('/node_modules/') || !insideRepo(root, declPath))
+                continue;
+            const rel = repoPath(root, declPath);
+            const key = normalizeName(name);
+            const list = index.get(key) ?? [];
+            if (list.some((e) => e.file === rel && e.line === decl.getStartLineNumber()))
+                continue;
+            list.push({ file: rel, name, line: decl.getStartLineNumber() });
+            index.set(key, list);
+        }
+    }
+    return index;
+}
+/**
+ * Resolve an absolute position into the line and column a reader can point at.
+ * Verifiers use this so a finding marks the exact token, not just the line.
+ */
+export function locate(sf, start, length) {
+    const { line, column } = sf.getLineAndColumnAtPos(start);
+    return { line, span: { column, length } };
+}
+export function locateNode(node) {
+    return locate(node.getSourceFile(), node.getStart(), node.getWidth());
+}
+export function relPath(sf, root) {
+    return repoPath(root, sf.getFilePath());
+}
+//# sourceMappingURL=ground.js.map

package/dist/judges/judge.js

@@ -0,0 +1,85 @@
+import { lines as splitLines } from '#app/text.js';
+import { complete, extractJsonArray } from './llm.js';
+import { TOOLS, runTool } from './tools.js';
+import { CONTEXT, reviewables } from '#app/bundle.js';
+import { COMMON } from './prompts.js';
+const SEVERITIES = new Set(['critical', 'high', 'medium', 'low']);
+/**
+ * The changed lines with a little context, marked so the model can tell what the
+ * change introduced from what merely surrounds it.
+ */
+export function renderChanges(files) {
+    const parts = [];
+    for (const f of files) {
+        const all = splitLines(f.text);
+        const added = [...f.added].sort((a, b) => a - b);
+        if (added.length === 0)
+            continue;
+        const show = new Set();
+        for (const n of added)
+            for (let i = n - CONTEXT; i <= n + CONTEXT; i++)
+                if (i >= 1 && i <= all.length)
+                    show.add(i);
+        const body = [...show]
+            .sort((a, b) => a - b)
+            .map((n) => (f.added.has(n) ? '+' : ' ') + String(n).padStart(5) + ' | ' + (all[n - 1] ?? ''))
+            .join('\n');
+        parts.push('=== ' + f.path + ' ===\n' + body);
+    }
+    return parts.join('\n\n');
+}
+/** Parse whatever the model returned into findings, discarding anything malformed. */
+export function parseFindings(raw, check) {
+    const out = [];
+    for (const item of extractJsonArray(raw)) {
+        const f = item;
+        const file = typeof f.file === 'string' ? f.file : undefined;
+        const line = typeof f.line === 'number' ? f.line : undefined;
+        const title = typeof f.title === 'string' ? f.title : undefined;
+        if (!file || !line || !title)
+            continue;
+        out.push({
+            id: '',
+            class: 'judged',
+            check,
+            severity: (SEVERITIES.has(String(f.severity)) ? f.severity : 'medium'),
+            confidence: f.confidence === 'firm' ? 'firm' : 'tentative',
+            file,
+            line,
+            title,
+            evidence: typeof f.why === 'string' ? { oracle: 'agent', detail: f.why } : undefined,
+            fix: typeof f.fix === 'string' ? f.fix : undefined,
+            // a patch, and only ever one line — anything longer is advice wearing a
+            // suggestion's clothes, and it would be applied with a single click
+            suggestion: typeof f.suggestion === 'string' && f.suggestion.trim() !== '' && !f.suggestion.includes('\n')
+                ? f.suggestion
+                : undefined,
+        });
+    }
+    return out;
+}
+export async function runJudge(spec, g, cfg, opts = {}) {
+    const files = opts.bundle?.files ?? reviewables(g);
+    const changes = renderChanges(files);
+    if (!changes.trim())
+        return [];
+    if (spec.needsIntent && !opts.intent)
+        return []; // nothing to compare the diff against
+    const preamble = spec.needsIntent
+        ? 'This change states that it does the following:\n\n' + opts.intent + '\n\n'
+        : '';
+    const tools = opts.useTools
+        ? { defs: TOOLS, run: (name, input) => runTool(g, name, input) }
+        : undefined;
+    const guidance = tools
+        ? '\n\nYou may read files, search the repository, and list references before answering.' +
+            ' Check a suspicion rather than reporting it unverified. When done, answer with the JSON array.'
+        : '';
+    const { text: raw, usage } = await complete(cfg, {
+        system: COMMON + '\n\n' + spec.brief + guidance,
+        user: preamble + 'Review these changed lines (marked with +).\n\n' + changes,
+    }, 2000, tools);
+    opts.budget?.spend({ ...usage, units: 1 });
+    return parseFindings(raw, spec.name);
+}
+//# sourceMappingURL=judge.js.map

package/dist/judges/llm.js

@@ -0,0 +1,234 @@
+export class ProviderError extends Error {
+    kind;
+    provider;
+    retryable;
+    status;
+    constructor(kind, provider, message, retryable = false, status) {
+        super(provider + ' ' + kind + ': ' + redact(message));
+        this.kind = kind;
+        this.provider = provider;
+        this.retryable = retryable;
+        this.status = status;
+        this.name = 'ProviderError';
+    }
+}
+/**
+ * A key must never reach a log, a manifest, or a pull-request comment.
+ *
+ * Provider error bodies echo request context, and a failure reason is one of the few
+ * strings this tool copies verbatim into places other people read.
+ */
+export function redact(text) {
+    return text
+        .replace(/\b(sk-[A-Za-z0-9_-]{8,}|gsk_[A-Za-z0-9]{8,}|AIza[A-Za-z0-9_-]{20,})/g, '<redacted>')
+        .replace(/([Bb]earer\s+)[A-Za-z0-9._-]{8,}/g, '$1<redacted>')
+        .replace(/("?(?:api[_-]?key|x-api-key|authorization)"?\s*[:=]\s*"?)[^",\s]{8,}/gi, '$1<redacted>')
+        .slice(0, 2000);
+}
+function classify(status, body, provider) {
+    if (status === 401 || status === 403) {
+        return new ProviderError('auth', provider, 'rejected the key (' + status + '). ' + body, false, status);
+    }
+    if (status === 429)
+        return new ProviderError('rate_limit', provider, body, true, status);
+    if (status === 529 || status === 503 || status === 502) {
+        return new ProviderError('overload', provider, body, true, status);
+    }
+    if (status === 400 || status === 404 || status === 422) {
+        // a model name that does not exist, or a request this provider will never accept
+        return new ProviderError('configuration', provider, 'rejected the request (' + status + '). ' + body, false, status);
+    }
+    return new ProviderError(status >= 500 ? 'overload' : 'unknown', provider, body, status >= 500, status);
+}
+const NO_USAGE = () => ({ inputTokens: 0, outputTokens: 0, requests: 0, toolCalls: 0 });
+/** How many times a judge may call tools before it must answer. Bounds the bill. */
+const MAX_TURNS = 8;
+/** A hung request must fail, not wait. */
+const REQUEST_TIMEOUT_MS = Number(process.env.POWERSHOT_TIMEOUT_MS) || 120_000;
+async function post(url, init, provider) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
+    }
+    catch (e) {
+        const err = e;
+        if (err.name === 'AbortError' || err.name === 'TimeoutError') {
+            throw new ProviderError('timeout', provider, 'no response within ' + Math.round(REQUEST_TIMEOUT_MS / 1000) + 's', true);
+        }
+        throw new ProviderError('unknown', provider, err.message ?? String(e), true);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * One request, no SDK. Both providers speak JSON over HTTPS and we need exactly
+ * one call shape, so a dependency would buy nothing.
+ */
+export async function complete(cfg, msg, maxTokens = 2000, tools) {
+    if (cfg.provider === 'openai')
+        return openai(cfg, msg, maxTokens);
+    if (cfg.provider === 'gemini')
+        return gemini(cfg, msg, maxTokens);
+    return anthropic(cfg, msg, maxTokens, tools);
+}
+export function apiKey(cfg) {
+    if (cfg.provider === 'openai')
+        return process.env.OPENAI_API_KEY;
+    if (cfg.provider === 'gemini')
+        return process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
+    return process.env.ANTHROPIC_API_KEY;
+}
+/** *_BASE_URL is a base, not a full endpoint — join without doubling the slash. */
+export function endpoint(base, fallback, path) {
+    return (base ?? fallback).replace(/\/+$/, '') + path;
+}
+/**
+ * The agent loop: the judge may read files, search, and walk references before it
+ * answers, so it can check a suspicion against the repository instead of guessing
+ * from the diff alone. Bounded by MAX_TURNS — an agent that will not conclude is a
+ * cost leak, and the last turn's text is taken as its answer either way.
+ */
+async function anthropic(cfg, msg, maxTokens, tools) {
+    const key = process.env.ANTHROPIC_API_KEY;
+    if (!key)
+        throw new ProviderError('configuration', 'Anthropic', 'ANTHROPIC_API_KEY is not set');
+    const url = endpoint(process.env.ANTHROPIC_BASE_URL, 'https://api.anthropic.com', '/v1/messages');
+    const messages = [{ role: 'user', content: msg.user }];
+    const usage = NO_USAGE();
+    let text = '';
+    for (let turn = 0; turn < (tools ? MAX_TURNS : 1); turn++) {
+        // The system prompt and tool definitions are byte-identical across every review
+        // unit and every judge, so they are marked cacheable: a change split into N units
+        // pays to read them once instead of N times. Only the prefix is cached — the diff
+        // itself differs per call and is not marked.
+        const cacheable = cfg.promptCache !== false;
+        const body = {
+            model: cfg.model,
+            max_tokens: maxTokens,
+            // A review that reports nine findings on one run and none on the next is not a
+            // review anyone can act on, and it makes a resumed run disagree with the one it
+            // continues. The Gemini path already pinned this; the default was left floating.
+            temperature: 0,
+            system: cacheable
+                ? [{ type: 'text', text: msg.system, cache_control: { type: 'ephemeral' } }]
+                : msg.system,
+            messages,
+        };
+        if (tools) {
+            body.tools = cacheable
+                ? tools.defs.map((d, i) => i === tools.defs.length - 1 ? { ...d, cache_control: { type: 'ephemeral' } } : d)
+                : tools.defs;
+        }
+        const res = await post(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', 'x-api-key': key, 'anthropic-version': '2023-06-01' },
+            body: JSON.stringify(body),
+        }, 'Anthropic');
+        if (!res.ok)
+            throw classify(res.status, await res.text(), 'Anthropic');
+        const json = await res.json();
+        usage.requests++;
+        usage.inputTokens += Number(json.usage?.input_tokens ?? 0) + Number(json.usage?.cache_read_input_tokens ?? 0);
+        usage.outputTokens += Number(json.usage?.output_tokens ?? 0);
+        const content = json.content ?? [];
+        text = content.map((b) => b.text ?? '').join('');
+        const calls = content.filter((b) => b.type === 'tool_use');
+        if (!tools || calls.length === 0)
+            return { text, usage };
+        usage.toolCalls += calls.length;
+        messages.push({ role: 'assistant', content });
+        messages.push({
+            role: 'user',
+            content: calls.map((c) => ({
+                type: 'tool_result',
+                tool_use_id: c.id,
+                content: tools.run(c.name, (c.input ?? {})),
+            })),
+        });
+    }
+    return { text, usage };
+}
+async function openai(cfg, msg, maxTokens) {
+    const key = process.env.OPENAI_API_KEY;
+    if (!key)
+        throw new ProviderError('configuration', 'OpenAI', 'OPENAI_API_KEY is not set');
+    const res = await post(endpoint(process.env.OPENAI_BASE_URL, 'https://api.openai.com/v1', '/chat/completions'), {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', authorization: 'Bearer ' + key },
+        body: JSON.stringify({
+            model: cfg.model,
+            max_completion_tokens: maxTokens,
+            messages: [
+                { role: 'system', content: msg.system },
+                { role: 'user', content: msg.user },
+            ],
+        }),
+    }, 'OpenAI');
+    if (!res.ok)
+        throw classify(res.status, await res.text(), 'OpenAI');
+    const json = await res.json();
+    return {
+        text: json.choices?.[0]?.message?.content ?? '',
+        usage: {
+            requests: 1,
+            inputTokens: Number(json.usage?.prompt_tokens ?? 0),
+            outputTokens: Number(json.usage?.completion_tokens ?? 0),
+            toolCalls: 0,
+        },
+    };
+}
+/**
+ * Gemini speaks a different shape but the same idea: one system instruction, one user
+ * turn, text back. Single-shot — the tool loop is Anthropic-only for now, and a judge
+ * without tools still does the whole job from the diff.
+ */
+async function gemini(cfg, msg, maxTokens) {
+    const key = process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
+    if (!key)
+        throw new ProviderError('configuration', 'Gemini', 'GEMINI_API_KEY is not set');
+    const base = endpoint(process.env.GEMINI_BASE_URL, 'https://generativelanguage.googleapis.com', '/v1beta/models/');
+    const res = await post(base + encodeURIComponent(cfg.model) + ':generateContent', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', 'x-goog-api-key': key },
+        body: JSON.stringify({
+            systemInstruction: { parts: [{ text: msg.system }] },
+            contents: [{ role: 'user', parts: [{ text: msg.user }] }],
+            generationConfig: { maxOutputTokens: maxTokens, temperature: 0 },
+        }),
+    }, 'Gemini');
+    if (!res.ok)
+        throw classify(res.status, await res.text(), 'Gemini');
+    const json = await res.json();
+    return {
+        text: (json.candidates?.[0]?.content?.parts ?? []).map((p) => p.text ?? '').join(''),
+        usage: {
+            requests: 1,
+            inputTokens: Number(json.usageMetadata?.promptTokenCount ?? 0),
+            outputTokens: Number(json.usageMetadata?.candidatesTokenCount ?? 0),
+            toolCalls: 0,
+        },
+    };
+}
+/** Models like to wrap JSON in prose or fences. Take the first array we can parse. */
+export function extractJsonArray(text) {
+    const fenced = /```(?:json)?\s*([\s\S]*?)```/.exec(text);
+    const candidates = [fenced?.[1], text].filter(Boolean);
+    for (const c of candidates) {
+        const start = c.indexOf('[');
+        const end = c.lastIndexOf(']');
+        if (start === -1 || end <= start)
+            continue;
+        try {
+            const parsed = JSON.parse(c.slice(start, end + 1));
+            if (Array.isArray(parsed))
+                return parsed;
+        }
+        catch {
+            // try the next candidate
+        }
+    }
+    return [];
+}
+//# sourceMappingURL=llm.js.map