@demon-utils/playwright 0.1.5 → 0.1.6

package/src/review.ts

@@ -1,5 +1,3 @@
-import type { ReviewMetadata } from "./review-types.ts";
-
 export type SpawnFn = (
   cmd: string[],
 ) => { exitCode: Promise<number>; stdout: ReadableStream<Uint8Array> };
@@ -9,33 +7,84 @@ export interface InvokeClaudeOptions {
   spawn?: SpawnFn;
 }
 
-export function buildReviewPrompt(filenames: string[]): string {
-  const fileList = filenames.map((f) => `- ${f}`).join("\n");
+const GIT_DIFF_MAX_CHARS = 50_000;
+
+export interface BuildReviewPromptOptions {
+  filenames: string[];
+  stepsMap: Record<string, Array<{ text: string; timestampSeconds: number }>>;
+  gitDiff?: string;
+  guidelines?: string[];
+}
+
+export function buildReviewPrompt(options: BuildReviewPromptOptions): string {
+  const { filenames, stepsMap, gitDiff, guidelines } = options;
+
+  const demoEntries = filenames.map((f) => {
+    const steps = stepsMap[f] ?? [];
+    const stepLines = steps
+      .map((s) => `- [${s.timestampSeconds}s] ${s.text}`)
+      .join("\n");
+    return `Video: ${f}\nRecorded steps:\n${stepLines || "(no steps recorded)"}`;
+  });
+
+  const sections: string[] = [];
+
+  if (guidelines && guidelines.length > 0) {
+    sections.push(`## Coding Guidelines\n\n${guidelines.join("\n\n")}`);
+  }
+
+  if (gitDiff) {
+    let diff = gitDiff;
+    if (diff.length > GIT_DIFF_MAX_CHARS) {
+      diff = diff.slice(0, GIT_DIFF_MAX_CHARS) + "\n\n... (diff truncated at 50k characters)";
+    }
+    sections.push(`## Git Diff\n\n\`\`\`diff\n${diff}\n\`\`\``);
+  }
+
+  sections.push(`## Demo Recordings\n\n${demoEntries.join("\n\n")}`);
 
-  return `You are given the following .webm demo video filenames:
+  return `You are a code reviewer. You are given a git diff, coding guidelines, and demo recordings that show the feature in action.
 
-${fileList}
+${sections.join("\n\n")}
 
-Based on the filenames, generate a JSON object matching this exact schema:
+## Task
+
+Review the code changes and demo recordings. Generate a JSON object matching this exact schema:
 
 {
   "demos": [
     {
       "file": "<filename>",
-      "summary": "<a short sentence describing what the demo likely shows>",
-      "annotations": [
-        { "timestampSeconds": <number>, "text": "<annotation text>" }
-      ]
+      "summary": "<a meaningful sentence describing what this demo showcases based on the steps>"
     }
-  ]
+  ],
+  "review": {
+    "summary": "<2-3 sentence overview of the changes>",
+    "highlights": ["<positive aspect 1>", "<positive aspect 2>"],
+    "verdict": "approve" | "request_changes",
+    "verdictReason": "<one sentence justifying the verdict>",
+    "issues": [
+      {
+        "severity": "major" | "minor" | "nit",
+        "description": "<what the issue is and how to fix it>"
+      }
+    ]
+  }
 }
 
 Rules:
 - Return ONLY the JSON object, no markdown fences or extra text.
 - Include one entry in "demos" for each filename, in the same order.
-- Infer the summary and annotations from the filename.
-- Each demo should have at least one annotation starting at timestampSeconds 0.
-- "file" must exactly match the provided filename.`;
+- "file" must exactly match the provided filename.
+- "verdict" must be exactly "approve" or "request_changes".
+- Use "request_changes" if there are any "major" issues.
+- "severity" must be exactly "major", "minor", or "nit".
+- "major": bugs, security issues, broken functionality, guideline violations.
+- "minor": code quality, readability, missing edge cases.
+- "nit": style, naming, trivial improvements.
+- "highlights" must have at least one entry.
+- "issues" can be an empty array if there are no issues.
+- Verify that demo steps demonstrate the acceptance criteria being met.`;
 }
 
 export async function invokeClaude(
@@ -68,10 +117,46 @@ export async function invokeClaude(
   return output.trim();
 }
 
-export function parseReviewMetadata(raw: string): ReviewMetadata {
+import type { IssueSeverity, ReviewVerdict } from "./review-types.ts";
+
+export interface LlmReviewResponse {
+  demos: Array<{ file: string; summary: string }>;
+  review: {
+    summary: string;
+    highlights: string[];
+    verdict: ReviewVerdict;
+    verdictReason: string;
+    issues: Array<{ severity: IssueSeverity; description: string }>;
+  };
+}
+
+const VALID_VERDICTS: ReadonlySet<string> = new Set(["approve", "request_changes"]);
+const VALID_SEVERITIES: ReadonlySet<string> = new Set(["major", "minor", "nit"]);
+
+export function extractJson(raw: string): string {
+  // Try raw string first
+  try {
+    JSON.parse(raw);
+    return raw;
+  } catch {
+    // look for first { and last }
+  }
+
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start === -1 || end === -1 || end <= start) {
+    throw new Error(`No JSON object found in LLM response: ${raw.slice(0, 200)}`);
+  }
+
+  return raw.slice(start, end + 1);
+}
+
+export function parseLlmResponse(raw: string): LlmReviewResponse {
+  const jsonStr = extractJson(raw);
+
   let parsed: unknown;
   try {
-    parsed = JSON.parse(raw);
+    parsed = JSON.parse(jsonStr);
   } catch {
     throw new Error(`Invalid JSON from LLM: ${raw.slice(0, 200)}`);
   }
@@ -97,25 +182,56 @@ export function parseReviewMetadata(raw: string): ReviewMetadata {
     if (typeof d["summary"] !== "string") {
       throw new Error("Each demo must have a 'summary' string");
     }
-    if (!Array.isArray(d["annotations"])) {
-      throw new Error("Each demo must have an 'annotations' array");
+  }
+
+  if (typeof obj["review"] !== "object" || obj["review"] === null) {
+    throw new Error("Missing 'review' object in response");
+  }
+
+  const review = obj["review"] as Record<string, unknown>;
+
+  if (typeof review["summary"] !== "string") {
+    throw new Error("review.summary must be a string");
+  }
+
+  if (!Array.isArray(review["highlights"])) {
+    throw new Error("review.highlights must be an array");
+  }
+  if (review["highlights"].length === 0) {
+    throw new Error("review.highlights must not be empty");
+  }
+  for (const h of review["highlights"]) {
+    if (typeof h !== "string") {
+      throw new Error("Each highlight must be a string");
     }
+  }
 
-    for (const ann of d["annotations"] as unknown[]) {
-      if (typeof ann !== "object" || ann === null) {
-        throw new Error("Each annotation must be an object");
-      }
-      const a = ann as Record<string, unknown>;
-      if (typeof a["timestampSeconds"] !== "number") {
-        throw new Error("Each annotation must have a 'timestampSeconds' number");
-      }
-      if (typeof a["text"] !== "string") {
-        throw new Error("Each annotation must have a 'text' string");
-      }
+  if (typeof review["verdict"] !== "string" || !VALID_VERDICTS.has(review["verdict"])) {
+    throw new Error("review.verdict must be 'approve' or 'request_changes'");
+  }
+
+  if (typeof review["verdictReason"] !== "string") {
+    throw new Error("review.verdictReason must be a string");
+  }
+
+  if (!Array.isArray(review["issues"])) {
+    throw new Error("review.issues must be an array");
+  }
+
+  for (const issue of review["issues"] as unknown[]) {
+    if (typeof issue !== "object" || issue === null) {
+      throw new Error("Each issue must be an object");
+    }
+    const i = issue as Record<string, unknown>;
+    if (typeof i["severity"] !== "string" || !VALID_SEVERITIES.has(i["severity"])) {
+      throw new Error("Each issue severity must be 'major', 'minor', or 'nit'");
+    }
+    if (typeof i["description"] !== "string") {
+      throw new Error("Each issue must have a 'description' string");
     }
   }
 
-  return parsed as ReviewMetadata;
+  return parsed as LlmReviewResponse;
 }
 
 function defaultSpawn(