AiAssistance: support follow-ups in prompt

This CL adds support for examples that contain follow-up prompts in an
HTML comment in the format of:

```
FollowUp1: "Summarise the main thread activity that slowed down rendering"
FollowUp2: "How can I make the script not render blocking?"
FollowUp3: "Is there anything I can do to optimize how quickly the image loads?"
```

[email protected]

Bug: 409706097
Change-Id: Ib92fc457c775ddda0f280614a86ac197f56662f5
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6450640
Commit-Queue: Jack Franklin <[email protected]>
Reviewed-by: Ergün Erdoğmuş <[email protected]>
Auto-Submit: Jack Franklin <[email protected]>

Author: jackfranklin

scripts/ai_assistance/auto-run-helpers.js

@@ -70,13 +70,41 @@ function parseComment(comment) {
     }
   }
 
+  /** @type {Record<string, string>} */
   const result = {};
   Object.keys(lines).forEach(lineKey => {
     result[lineKey] = lines[lineKey].join('\n');
   });
   return result;
 }
 
+/**
+ * @param {Record<string, string>} comment
+ * @return {string[]}
+ */
+function parseFollowUps(comment) {
+  /** @type {string[]} */
+  const followUpPrompts = [];
+  const FOLLOW_UP_PREFIX = 'followup';
+  Object.entries(comment).forEach(([key, value]) => {
+    if (key.toLowerCase().startsWith(FOLLOW_UP_PREFIX)) {
+      if (value.length === 0) {
+        throw new Error(`Found empty followup value at ${key}`);
+      }
+      const indexStr = key.substring(FOLLOW_UP_PREFIX.length);
+      const index = parseInt(indexStr, 10);
+      if (Number.isNaN(index)) {
+        throw new Error(`Found invalid followup prompt: ${key}, ${value}`);
+      }
+      followUpPrompts[index - 1] = value;
+    }
+  });
+  // In case the input was "followup1" and "followup3", this removes holes
+  // from the array.
+  return followUpPrompts.filter(x => Boolean(x));
+}
+
 module.exports = {
+  parseFollowUps,
   parseComment,
 };

scripts/ai_assistance/auto-run.js

@@ -8,7 +8,7 @@ const puppeteer = require('puppeteer-core');
 const {hideBin} = require('yargs/helpers');
 const yargs = require('yargs/yargs');
 
-const {parseComment} = require('./auto-run-helpers');
+const {parseComment, parseFollowUps} = require('./auto-run-helpers');
 
 const DEFAULT_FOLLOW_UP_QUERY = 'Fix the issue using JavaScript code execution.';
 
@@ -348,8 +348,13 @@ class Example {
     // Only get the first comment for now.
     const comment = comments[0];
     const queries = [comment.prompt];
-    if (userArgs.includeFollowUp) {
+
+    const followUpPromptsFromExample = parseFollowUps(comment);
+
+    if (userArgs.includeFollowUp && followUpPromptsFromExample.length === 0) {
       queries.push(DEFAULT_FOLLOW_UP_QUERY);
+    } else {
+      queries.push(...followUpPromptsFromExample);
     }
 
     return {

scripts/ai_assistance/auto-run.test.js

@@ -10,7 +10,7 @@
 
 const {assert} = require('chai');
 
-const {parseComment} = require('./auto-run-helpers.js');
+const {parseComment, parseFollowUps} = require('./auto-run-helpers.js');
 
 describe('parsing comments', () => {
   it('parses out the prompt and evaluation sections using the "old" syntax', () => {
@@ -86,3 +86,84 @@ describe('parsing comments', () => {
     assert.deepEqual(result, {prompt: 'A', explanation: 'B\nC\nD'});
   });
 });
+
+describe('parseFollowUps', () => {
+  it('should return an empty array when no followup keys exist', () => {
+    const comment = {
+      prompt: 'Test prompt',
+      explanation: 'Test explanation',
+    };
+    assert.deepEqual(parseFollowUps(comment), []);
+  });
+
+  it('should parse a single followup', () => {
+    const comment = {
+      prompt: 'Test prompt',
+      followup1: 'First follow up',
+    };
+    assert.deepEqual(parseFollowUps(comment), ['First follow up']);
+  });
+
+  it('should parse multiple sequential followups in order', () => {
+    const comment = {
+      followup2: 'Second follow up',
+      prompt: 'Test prompt',
+      followup1: 'First follow up',
+      explanation: 'Test explanation',
+      followup3: 'Third follow up',
+    };
+    assert.deepEqual(parseFollowUps(comment), [
+      'First follow up',
+      'Second follow up',
+      'Third follow up',
+    ]);
+  });
+
+  it('should parse non-sequential followups and filter empty slots', () => {
+    const comment = {
+      followup3: 'Third follow up',
+      prompt: 'Test prompt',
+      followup1: 'First follow up',
+    };
+    assert.deepEqual(parseFollowUps(comment), ['First follow up', 'Third follow up']);
+  });
+
+  it('should throw an error for invalid followup keys (non-numeric index)', () => {
+    const comment = {
+      followup1: 'First follow up',
+      followupX: 'Invalid key',
+    };
+    assert.throws(() => parseFollowUps(comment), 'Found invalid followup prompt: followupX, Invalid key');
+  });
+
+  it('should throw an error for invalid followup keys (no index)', () => {
+    const comment = {
+      followup: 'Invalid key',
+      followup1: 'First follow up',
+    };
+    assert.throws(() => parseFollowUps(comment), /^Found invalid followup prompt: followup,/);
+  });
+
+  it('should throw an error when encountering empty string values for followups', () => {
+    const comment = {
+      followup1: '',
+      followup2: 'Second follow up',
+    };
+    assert.throws(() => {
+      parseFollowUps(comment);
+    }, /Found empty followup value at followup1/);
+  });
+
+  it('should correctly parse followup keys with multiple digits', () => {
+    const comment = {
+      followup10: 'Tenth follow up',
+      followup1: 'First follow up',
+      followup2: 'Second follow up',
+    };
+    assert.deepEqual(parseFollowUps(comment), [
+      'First follow up',
+      'Second follow up',
+      'Tenth follow up',
+    ]);
+  });
+});