59 lines
3.6 KiB
TypeScript
59 lines
3.6 KiB
TypeScript
import { z } from "zod/v4";
|
|
import { digestForModel, type Digest } from "./digest.ts";
|
|
import type { AnalystConfig } from "./settings.ts";
|
|
|
|
export class AnalystError extends Error {}
|
|
|
|
const Action = z.object({ title: z.string().min(3), detail: z.string().min(3),
|
|
effort: z.enum(["low", "medium", "high"]), requires_change_control: z.boolean() });
|
|
const RawCandidate = z.object({ key: z.string().min(2), title: z.string().min(3), diagnosis: z.string().min(15),
|
|
actions: z.array(Action).min(1), rewrite_sql: z.string().nullable(), expected: z.string().min(5) });
|
|
const Proposal = z.object({ candidates: z.array(RawCandidate).min(2).max(4) });
|
|
export type Action = z.infer<typeof Action>;
|
|
export type Candidate = z.infer<typeof RawCandidate>;
|
|
|
|
export const CANDIDATE_SYSTEM_PROMPT = `You are a SQL Server performance engineer. You receive a JSON digest of one
|
|
execution plan. Judge only what the digest contains — never invent operators, waits, or row counts you were not given.
|
|
|
|
Return 2 to 4 genuinely different remediation options, not one option restated. Real differences: an index change, a
|
|
rewritten query, a statistics or parallelism fix, a batching or schema change. At least one option must be the
|
|
lowest-risk one. Each option needs a snake_case key, a diagnosis naming WHY the plan is slow, 1-4 ordered actions, an
|
|
optional rewritten query, and an expected effect stated as a concrete claim about the plan (logical reads, seek vs
|
|
scan, tempdb spill, degree of parallelism).
|
|
|
|
A rewrite must return the same rows as the original. If you cannot rewrite safely, set rewrite_sql to null.
|
|
Output ONE JSON object and nothing else:
|
|
{"candidates":[{"key":"idx_covering_orders","title":"...","diagnosis":"...","actions":[{"title":"...","detail":"...",
|
|
"effort":"low|medium|high","requires_change_control":false}],"rewrite_sql":null,"expected":"..."}]}`;
|
|
|
|
export function extractJson(text: string): unknown {
|
|
const fenced = /```(?:json)?\s*([\s\S]*?)```/.exec(text);
|
|
const s = (fenced ? fenced[1] : text).trim();
|
|
const start = s.indexOf("{"); const end = s.lastIndexOf("}");
|
|
if (start === -1 || end <= start) throw new AnalystError("The analyst model returned prose instead of JSON.");
|
|
try { return JSON.parse(s.slice(start, end + 1)); }
|
|
catch { throw new AnalystError("The analyst model returned malformed JSON."); }
|
|
}
|
|
|
|
export async function proposeCandidates(cfg: AnalystConfig, digest: Digest, note: string,
|
|
fetchImpl: typeof fetch = fetch): Promise<Candidate[]> {
|
|
const res = await fetchImpl(`${cfg.baseUrl}/chat/completions`, {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json", authorization: `Bearer ${cfg.apiKey}` },
|
|
body: JSON.stringify({ model: cfg.model, temperature: 0.6, ...cfg.extra, stream: false,
|
|
messages: [{ role: "system", content: CANDIDATE_SYSTEM_PROMPT },
|
|
{ role: "user", content: JSON.stringify({ digest: digestForModel(digest), user_note: note || null }) }] }),
|
|
}).catch((e) => { throw new AnalystError(`Could not reach ${cfg.baseUrl}: ${(e as Error).message}`); });
|
|
|
|
if (!res.ok) throw new AnalystError(`Analyst model returned HTTP ${res.status}. ${(await res.text()).slice(0, 300)}`);
|
|
const content: string = ((await res.json() as any)?.choices?.[0]?.message?.content) ?? "";
|
|
const parsed = Proposal.safeParse(extractJson(content));
|
|
if (!parsed.success) {
|
|
const n = (extractJson(content) as any)?.candidates?.length ?? 0;
|
|
throw new AnalystError(n < 2
|
|
? `The analyst model proposed ${n} option(s); at least 2 are needed before Jev can rank anything.`
|
|
: `Analyst output did not match the schema at ${parsed.error.issues[0].path.join(".")}: ${parsed.error.issues[0].message}`);
|
|
}
|
|
return parsed.data.candidates;
|
|
}
|