chrome-devtools-frontend 1.0.1562885 → 1.0.1563377

package/front_end/panels/common/AiCodeGenerationTeaser.ts

@@ -1,11 +1,16 @@
 // Copyright 2025 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
+import '../../ui/components/tooltips/tooltips.js';
 
 import * as Host from '../../core/host/host.js';
 import * as i18n from '../../core/i18n/i18n.js';
+import * as Root from '../../core/root/root.js';
+import * as AiCodeCompletion from '../../models/ai_code_completion/ai_code_completion.js';
+import * as Buttons from '../../ui/components/buttons/buttons.js';
 import * as UI from '../../ui/legacy/legacy.js';
-import {html, nothing, render} from '../../ui/lit/lit.js';
+import {Directives, html, nothing, render} from '../../ui/lit/lit.js';
+import * as VisualLogging from '../../ui/visual_logging/visual_logging.js';
 
 import styles from './aiCodeGenerationTeaser.css.js';
 
@@ -13,19 +18,55 @@ const UIStringsNotTranslate = {
   /**
    * @description Text for teaser to generate code.
    */
-  ctrlItoGenerateCode: 'ctrl-i to generate code',
+  ctrlItoGenerateCode: 'Ctrl+I to generate code',
   /**
    * @description Text for teaser to generate code in Mac.
    */
-  cmdItoGenerateCode: 'cmd-i to generate code',
+  cmdItoGenerateCode: 'Cmd+I to generate code',
   /**
-   * Text for teaser when generating suggestion.
+   * @description Text for teaser when generating suggestion.
    */
   generating: 'Generating... (esc to cancel)',
   /**
-   * Text for teaser for discoverability.
+   * @description Text for teaser for discoverability.
    */
   writeACommentToGenerateCode: 'Write a comment to generate code',
+  /**
+   * @description Text for teaser when suggestion has been generated.
+   */
+  tab: 'tab',
+  /**
+   * @description Text for teaser when suggestion has been generated.
+   */
+  toAccept: 'to accept',
+  /**
+   * @description Text for tooltip shown on hovering over "Relevant Data" in the disclaimer text for AI code generation in Console panel.
+   */
+  tooltipDisclaimerTextForAiCodeGenerationInConsole:
+      'To generate code suggestions, your console input and the history of your current console session are shared with Google. This data may be seen by human reviewers to improve this feature.',
+  /**
+   * @description Text for tooltip shown on hovering over "Relevant Data" in the disclaimer text for AI code generation in Console panel.
+   */
+  tooltipDisclaimerTextForAiCodeGenerationNoLoggingInConsole:
+      'To generate code suggestions, your console input and the history of your current console session are shared with Google. This data will not be used to improve Google’s AI models. Your organization may change these settings at any time.',
+  /**
+   * @description Text for tooltip shown on hovering over "Relevant Data" in the disclaimer text for AI code generation in Sources panel.
+   */
+  tooltipDisclaimerTextForAiCodeGenerationInSources:
+      'To generate code suggestions, the contents of the currently open file are shared with Google. This data may be seen by human reviewers to improve this feature.',
+  /**
+   * @description Text for tooltip shown on hovering over "Relevant Data" in the disclaimer text for AI code generation in Sources panel.
+   */
+  tooltipDisclaimerTextForAiCodeGenerationNoLoggingInSources:
+      'To generate code suggestions, the contents of the currently open file are shared with Google. This data will not be used to improve Google’s AI models. Your organization may change these settings at any time.',
+  /**
+   * @description Text for tooltip button which redirects to AI settings
+   */
+  manageInSettings: 'Manage in settings',
+  /**
+   * @description Title for disclaimer info button in the teaser to generate code.
+   */
+  learnMoreAboutHowYourDataIsBeingUsed: 'Learn more about how your data is being used',
 } as const;
 
 const lockedString = i18n.i18n.lockedString;
@@ -35,17 +76,96 @@ export enum AiCodeGenerationTeaserDisplayState {
   TRIGGER = 'trigger',
   DISCOVERY = 'discovery',
   LOADING = 'loading',
+  GENERATED = 'generated',
+}
+
+function getTooltipDisclaimerText(noLogging: boolean, panel: AiCodeCompletion.AiCodeCompletion.ContextFlavor): string {
+  switch (panel) {
+    case AiCodeCompletion.AiCodeCompletion.ContextFlavor.CONSOLE:
+      return noLogging ?
+          lockedString(UIStringsNotTranslate.tooltipDisclaimerTextForAiCodeGenerationNoLoggingInConsole) :
+          lockedString(UIStringsNotTranslate.tooltipDisclaimerTextForAiCodeGenerationInConsole);
+    case AiCodeCompletion.AiCodeCompletion.ContextFlavor.SOURCES:
+      return noLogging ?
+          lockedString(UIStringsNotTranslate.tooltipDisclaimerTextForAiCodeGenerationNoLoggingInSources) :
+          lockedString(UIStringsNotTranslate.tooltipDisclaimerTextForAiCodeGenerationInSources);
+  }
 }
 
 export interface ViewInput {
   displayState: AiCodeGenerationTeaserDisplayState;
+  disclaimerTooltipId?: string;
+  noLogging: boolean;
+  onManageInSettingsTooltipClick: (event: Event) => void;
+  // TODO(b/472268298): Remove ContextFlavor explicitly and pass required values
+  panel?: AiCodeCompletion.AiCodeCompletion.ContextFlavor;
 }
 
-export type View = (input: ViewInput, output: object, target: HTMLElement) => void;
+export interface ViewOutput {
+  hideTooltip?: () => void;
+  setTimerText?: (text: string) => void;
+}
+
+export type View = (input: ViewInput, output: ViewOutput, target: HTMLElement) => void;
+
+export const DEFAULT_VIEW: View = (input, output, target) => {
+  if (!input.panel) {
+    render(nothing, target);
+    return;
+  }
 
-export const DEFAULT_VIEW: View = (input, _output, target) => {
   let teaserLabel;
   switch (input.displayState) {
+    case AiCodeGenerationTeaserDisplayState.TRIGGER: {
+      if (!input.disclaimerTooltipId) {
+        render(nothing, target);
+        return;
+      }
+      const toGenerateCode = Host.Platform.isMac() ? lockedString(UIStringsNotTranslate.cmdItoGenerateCode) :
+                                                     lockedString(UIStringsNotTranslate.ctrlItoGenerateCode);
+      const tooltipDisclaimerText = getTooltipDisclaimerText(input.noLogging, input.panel);
+      // TODO(b/472291834): Disclaimer icon should match the placeholder's color
+      // clang-format off
+      teaserLabel = html`<div class="ai-code-generation-teaser-trigger">
+        ${toGenerateCode}&nbsp;<devtools-button
+          .data=${{
+              title: lockedString(UIStringsNotTranslate.learnMoreAboutHowYourDataIsBeingUsed),
+              size: Buttons.Button.Size.MICRO,
+              iconName: 'info',
+              variant: Buttons.Button.Variant.ICON,
+              jslogContext: 'ai-code-generation-teaser.info-button',
+            } as Buttons.Button.ButtonData}
+            aria-details=${input.disclaimerTooltipId}
+            aria-describedby=${input.disclaimerTooltipId}
+          ></devtools-button>
+          <devtools-tooltip
+              id=${input.disclaimerTooltipId}
+              variant="rich"
+              jslogContext="ai-code-generation-disclaimer"
+              ${Directives.ref(el => {
+                if (el instanceof HTMLElement) {
+                  output.hideTooltip = () => {
+                    el.hidePopover();
+                  };
+                }
+              })}>
+            <div class="disclaimer-tooltip-container"><div class="tooltip-text">
+                ${tooltipDisclaimerText}
+                </div>
+                <span
+                    tabIndex="0"
+                    class="link"
+                    role="link"
+                    jslog=${VisualLogging.link('open-ai-settings').track({
+                      click: true,
+                    })}
+                    @click=${input.onManageInSettingsTooltipClick}
+                >${lockedString(UIStringsNotTranslate.manageInSettings)}</span></div></devtools-tooltip>
+                  </div>`;
+      // clang-format on
+      break;
+    }
+
     case AiCodeGenerationTeaserDisplayState.DISCOVERY: {
       const newBadge = UI.UIUtils.maybeCreateNewBadge(PROMOTION_ID);
       teaserLabel = newBadge ?
@@ -55,14 +175,27 @@ export const DEFAULT_VIEW: View = (input, _output, target) => {
     }
 
     case AiCodeGenerationTeaserDisplayState.LOADING: {
-      teaserLabel = html`${lockedString(UIStringsNotTranslate.generating)}`;
+      // clang-format off
+      teaserLabel = html`
+        <span class="ai-code-generation-spinner"></span>&nbsp;${lockedString(UIStringsNotTranslate.generating)}&nbsp;
+        <span class="ai-code-generation-timer" ${Directives.ref(el => {
+          if (el) {
+            output.setTimerText = (text: string) => {
+              el.textContent = text;
+            };
+          }
+        })}></span>`;
+      // clang-format on
       break;
     }
 
-    case AiCodeGenerationTeaserDisplayState.TRIGGER: {
-      const toGenerateCode = Host.Platform.isMac() ? lockedString(UIStringsNotTranslate.cmdItoGenerateCode) :
-                                                     lockedString(UIStringsNotTranslate.ctrlItoGenerateCode);
-      teaserLabel = html`${toGenerateCode}`;
+    case AiCodeGenerationTeaserDisplayState.GENERATED: {
+      // clang-format off
+      teaserLabel = html`<div class="ai-code-generation-teaser-generated">
+          <span>${lockedString(UIStringsNotTranslate.tab)}</span>
+          &nbsp;${lockedString(UIStringsNotTranslate.toAccept)}
+        </div>`;
+      // clang-format on
       break;
     }
   }
@@ -73,7 +206,7 @@ export const DEFAULT_VIEW: View = (input, _output, target) => {
           <style>${styles}</style>
           <style>@scope to (devtools-widget > *) { ${UI.inspectorCommonStyles} }</style>
           <div class="ai-code-generation-teaser">
-            &nbsp;${teaserLabel}
+            ${teaserLabel}
           </div>
         `, target
       );
@@ -83,23 +216,39 @@ export const DEFAULT_VIEW: View = (input, _output, target) => {
 // TODO(b/448063927): Add "Dont show again" for discovery teaser.
 export class AiCodeGenerationTeaser extends UI.Widget.Widget {
   readonly #view: View;
+  #viewOutput: ViewOutput = {};
 
   #displayState = AiCodeGenerationTeaserDisplayState.TRIGGER;
+  #disclaimerTooltipId?: string;
+  #noLogging: boolean;  // Whether the enterprise setting is `ALLOW_WITHOUT_LOGGING` or not.
+  #panel?: AiCodeCompletion.AiCodeCompletion.ContextFlavor;
+  #timerIntervalId?: number;
+  #loadStartTime?: number;
 
   constructor(view?: View) {
     super();
     this.markAsExternallyManaged();
+    this.#noLogging = Root.Runtime.hostConfig.aidaAvailability?.enterprisePolicyValue ===
+        Root.Runtime.GenAiEnterprisePolicyValue.ALLOW_WITHOUT_LOGGING;
     this.#view = view ?? DEFAULT_VIEW;
     this.requestUpdate();
   }
 
   override performUpdate(): void {
-    const output = {};
     this.#view(
         {
           displayState: this.#displayState,
+          onManageInSettingsTooltipClick: this.#onManageInSettingsTooltipClick.bind(this),
+          disclaimerTooltipId: this.#disclaimerTooltipId,
+          noLogging: this.#noLogging,
+          panel: this.#panel,
         },
-        output, this.contentElement);
+        this.#viewOutput, this.contentElement);
+  }
+
+  override willHide(): void {
+    super.willHide();
+    this.#stopLoadingAnimation();
   }
 
   get displayState(): AiCodeGenerationTeaserDisplayState {
@@ -112,5 +261,52 @@ export class AiCodeGenerationTeaser extends UI.Widget.Widget {
     }
     this.#displayState = displayState;
     this.requestUpdate();
+    if (this.#displayState === AiCodeGenerationTeaserDisplayState.LOADING) {
+      // wait update to complete so that setTimerText has been set properly
+      void this.updateComplete.then(() => {
+        void this.#startLoadingAnimation();
+      });
+    } else if (this.#loadStartTime) {
+      this.#stopLoadingAnimation();
+    }
+  }
+
+  #startLoadingAnimation(): void {
+    this.#stopLoadingAnimation();
+    this.#loadStartTime = performance.now();
+
+    this.#viewOutput.setTimerText?.('(0s)');
+
+    this.#timerIntervalId = window.setInterval(() => {
+      if (this.#loadStartTime) {
+        const elapsedSeconds = Math.floor((performance.now() - this.#loadStartTime) / 1000);
+        this.#viewOutput.setTimerText?.(`(${elapsedSeconds}s)`);
+      }
+    }, 1000);
+  }
+
+  #stopLoadingAnimation(): void {
+    if (this.#timerIntervalId) {
+      clearInterval(this.#timerIntervalId);
+      this.#timerIntervalId = undefined;
+    }
+    this.#loadStartTime = undefined;
+  }
+
+  set disclaimerTooltipId(disclaimerTooltipId: string) {
+    this.#disclaimerTooltipId = disclaimerTooltipId;
+    this.requestUpdate();
+  }
+
+  set panel(panel: AiCodeCompletion.AiCodeCompletion.ContextFlavor) {
+    this.#panel = panel;
+    this.requestUpdate();
+  }
+
+  #onManageInSettingsTooltipClick(event: Event): void {
+    event.stopPropagation();
+    this.#viewOutput.hideTooltip?.();
+    void UI.ViewManager.ViewManager.instance().showView('chrome-ai');
+    event.consume(true);
   }
 }

package/front_end/panels/common/aiCodeGenerationTeaser.css

@@ -6,9 +6,73 @@
 
 @scope to (devtools-widget > *) {
     .ai-code-generation-teaser {
+        pointer-events: all;
+        font-style: italic;
+        padding-left: var(--sys-size-3);
+        line-height: var(--sys-size-7);
+
+        .ai-code-generation-teaser-trigger {
+            display: inline-flex;
+            align-items: center;
+        }
+
+        .ai-code-generation-teaser-generated {
+            display: inline-flex;
+            gap: var(--sys-size-2);
+            color: var(--sys-color-primary);
+
+            span {
+                border: var(--sys-size-1) solid var(--sys-color-primary);
+                border-radius: var(--sys-shape-corner-extra-small);
+                padding: 0 var(--sys-size-3);
+            }
+        }
+
         .new-badge {
             font-style: normal;
             display: inline-block;
         }
+
+        devtools-tooltip:popover-open {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+
+            .disclaimer-tooltip-container {
+                padding: var(--sys-size-4) 0;
+                max-width: var(--sys-size-30);
+                white-space: normal;
+
+                .tooltip-text {
+                    color: var(--sys-color-on-surface-subtle);
+                    padding: 0 var(--sys-size-5);
+                    align-items: flex-start;
+                    gap: 10px;
+                }
+
+                .link {
+                    margin: var(--sys-size-5) var(--sys-size-8) 0 var(--sys-size-5);
+                    display: inline-block;
+                }
+            }
+        }
+
+        .ai-code-generation-spinner::before {
+            content: "⠋";
+            animation: teaser-spinner-animation 1s linear infinite;
+        }
+    }
+
+    @keyframes teaser-spinner-animation {
+        0% { content: "⠋"; }
+        10% { content: "⠙"; }
+        20% { content: "⠹"; }
+        30% { content: "⠸"; }
+        40% { content: "⠼"; }
+        50% { content: "⠴"; }
+        60% { content: "⠦"; }
+        70% { content: "⠧"; }
+        80% { content: "⠇"; }
+        90% { content: "⠏"; }
     }
 }

package/front_end/panels/console/ConsoleView.ts

@@ -649,7 +649,8 @@ export class ConsoleView extends UI.Widget.VBox implements
     this.aiCodeCompletionSummaryToolbar = new AiCodeCompletionSummaryToolbar({
       citationsTooltipId: CITATIONS_TOOLTIP_ID,
       disclaimerTooltipId: DISCLAIMER_TOOLTIP_ID,
-      spinnerTooltipId: SPINNER_TOOLTIP_ID
+      spinnerTooltipId: SPINNER_TOOLTIP_ID,
+      panel: AiCodeCompletion.AiCodeCompletion.ContextFlavor.CONSOLE,
     });
     this.aiCodeCompletionSummaryToolbarContainer =
         this.element.createChild('div', 'ai-code-completion-summary-toolbar-container');

package/front_end/panels/event_listeners/EventListenersView.ts

@@ -347,7 +347,8 @@ export class ObjectEventListenerBar extends UI.TreeOutline.TreeElement {
     }
 
     const subtitle = title.createChild('span', 'event-listener-tree-subtitle');
-    const linkElement = linkifier.linkifyRawLocation(this.#eventListener.location(), this.#eventListener.sourceURL());
+    const linkElement = linkifier.linkifyRawLocation(
+        this.#eventListener.location(), this.#eventListener.sourceURL(), undefined, {tabStop: true});
     subtitle.appendChild(linkElement);
 
     this.listItemElement.addEventListener('contextmenu', event => {

package/front_end/panels/sources/AiCodeCompletionPlugin.ts

@@ -102,6 +102,7 @@ export class AiCodeCompletionPlugin extends Plugin {
     this.#aiCodeCompletionDisclaimer = new PanelCommon.AiCodeCompletionDisclaimer();
     this.#aiCodeCompletionDisclaimer.disclaimerTooltipId = DISCLAIMER_TOOLTIP_ID;
     this.#aiCodeCompletionDisclaimer.spinnerTooltipId = SPINNER_TOOLTIP_ID;
+    this.#aiCodeCompletionDisclaimer.panel = AiCodeCompletion.AiCodeCompletion.ContextFlavor.SOURCES;
     this.#aiCodeCompletionDisclaimer.show(this.#aiCodeCompletionDisclaimerContainer, undefined, true);
   }
 
@@ -109,8 +110,11 @@ export class AiCodeCompletionPlugin extends Plugin {
     if (this.#aiCodeCompletionCitationsToolbar) {
       return;
     }
-    this.#aiCodeCompletionCitationsToolbar =
-        new PanelCommon.AiCodeCompletionSummaryToolbar({citationsTooltipId: CITATIONS_TOOLTIP_ID, hasTopBorder: true});
+    this.#aiCodeCompletionCitationsToolbar = new PanelCommon.AiCodeCompletionSummaryToolbar({
+      citationsTooltipId: CITATIONS_TOOLTIP_ID,
+      hasTopBorder: true,
+      panel: AiCodeCompletion.AiCodeCompletion.ContextFlavor.SOURCES
+    });
     this.#aiCodeCompletionCitationsToolbar.show(this.#aiCodeCompletionCitationsToolbarContainer, undefined, true);
   }
 

package/front_end/third_party/chromium/README.chromium

@@ -1,7 +1,7 @@
 Name: Dependencies sourced from the upstream `chromium` repository
 URL: https://chromium.googlesource.com/chromium/src
 Version: N/A
-Revision: 142ca60f39457730eafcdd7058a4f812f9aa63dc
+Revision: e3edb4435f06ac3de39688c44cc50378c47e35e8
 Update Mechanism: Manual (https://crbug.com/428069060)
 License: BSD-3-Clause
 License File: LICENSE

package/front_end/ui/components/text_editor/AiCodeCompletionProvider.ts

@@ -122,21 +122,25 @@ export class AiCodeCompletionProvider {
     this.#aiCodeCompletion?.clearCachedRequest();
   }
 
-  // TODO(b/445394511): Update setup and cleanup method so that config callbacks are not
-  // called twice.
   #setupAiCodeCompletion(): void {
     if (!this.#editor || !this.#aiCodeCompletionConfig) {
       return;
     }
-    if (!this.#aiCodeCompletion) {
-      this.#aiCodeCompletion = new AiCodeCompletion.AiCodeCompletion.AiCodeCompletion(
-          {aidaClient: this.#aidaClient}, this.#aiCodeCompletionConfig.panel, undefined,
-          this.#aiCodeCompletionConfig.completionContext.stopSequences);
+    if (this.#aiCodeCompletion) {
+      // early return as this means that code completion was previously setup
+      return;
     }
+    this.#aiCodeCompletion = new AiCodeCompletion.AiCodeCompletion.AiCodeCompletion(
+        {aidaClient: this.#aidaClient}, this.#aiCodeCompletionConfig.panel, undefined,
+        this.#aiCodeCompletionConfig.completionContext.stopSequences);
     this.#aiCodeCompletionConfig.onFeatureEnabled();
   }
 
   #cleanupAiCodeCompletion(): void {
+    if (!this.#aiCodeCompletion) {
+      // early return as this means there is no code completion to clean up
+      return;
+    }
     if (this.#suggestionRenderingTimeout) {
       clearTimeout(this.#suggestionRenderingTimeout);
       this.#suggestionRenderingTimeout = undefined;
@@ -208,6 +212,21 @@ export class AiCodeCompletionProvider {
     this.#editor?.editor.dispatch({effects: this.#teaserCompartment.reconfigure([])});
   }
 
+  /**
+   * This method is responsible for fetching code completion suggestions and
+   * displaying them in the text editor.
+   *
+   * 1. **Debouncing requests:** As the user types, we don't want to send a request
+   *    for every keystroke. Instead, we use debouncing to schedule a request
+   *    only after the user has paused typing for a short period
+   *    (AIDA_REQUEST_THROTTLER_TIMEOUT_MS). This prevents spamming the backend with
+   *    requests for intermediate typing states.
+   *
+   * 2. **Delaying suggestions:** When a suggestion is received from the AIDA
+   *    backend, we don't show it immediately. There is a minimum delay
+   *    (DELAY_BEFORE_SHOWING_RESPONSE_MS) from when the request was sent to when
+   *    the suggestion is displayed.
+   */
   #triggerAiCodeCompletion(update: CodeMirror.ViewUpdate): void {
     if (!update.docChanged || !this.#editor || !this.#aiCodeCompletion) {
       return;
@@ -287,8 +306,7 @@ export class AiCodeCompletionProvider {
         citations,
         rpcGlobalId,
       } = sampleResponse;
-      const remainingDelay = Math.max(
-          AiCodeCompletion.AiCodeCompletion.DELAY_BEFORE_SHOWING_RESPONSE_MS - (performance.now() - startTime), 0);
+      const remainingDelay = Math.max(DELAY_BEFORE_SHOWING_RESPONSE_MS - (performance.now() - startTime), 0);
       this.#suggestionRenderingTimeout = window.setTimeout(() => {
         const currentCursorPosition = this.#editor?.editor.state.selection.main.head;
         if (currentCursorPosition !== cursorPositionAtRequest) {

package/front_end/ui/components/text_editor/AiCodeCompletionTeaserPlaceholder.ts

@@ -71,6 +71,10 @@ export class AiCodeCompletionTeaserPlaceholder extends CM.WidgetType {
     super.destroy(dom);
     this.teaser?.hideWidget();
   }
+
+  override eq(other: AiCodeCompletionTeaserPlaceholder): boolean {
+    return this.teaser === other.teaser;
+  }
 }
 
 export function aiCodeCompletionTeaserPlaceholder(teaser: UI.Widget.Widget): CM.Extension {

package/front_end/ui/components/text_editor/AiCodeGenerationParser.ts

@@ -0,0 +1,77 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as CodeMirror from '../../../third_party/codemirror.next/codemirror.next.js';
+
+const LINE_COMMENT_PATTERN = /^(?:\/\/|#)\s*/;
+const BLOCK_COMMENT_START_PATTERN = /^\/\*+\s*/;
+const BLOCK_COMMENT_END_PATTERN = /\s*\*+\/$/;
+const BLOCK_COMMENT_LINE_PREFIX_PATTERN = /^\s*\*\s?/;
+
+function findLastNonWhitespacePos(state: CodeMirror.EditorState, cursorPosition: number): number {
+  const line = state.doc.lineAt(cursorPosition);
+  const textBefore = line.text.substring(0, cursorPosition - line.from);
+  const effectiveEnd = line.from + textBefore.trimEnd().length;
+  return effectiveEnd;
+}
+
+function resolveCommentNode(state: CodeMirror.EditorState, cursorPosition: number): CodeMirror.SyntaxNode|undefined {
+  const tree = CodeMirror.syntaxTree(state);
+  const lookupPos = findLastNonWhitespacePos(state, cursorPosition);
+  // Find the innermost syntax node at the last non-whitespace character position.
+  // The bias of -1 makes it check the character to the left of the position.
+  const node = tree.resolveInner(lookupPos, -1);
+  const nodeType = node.type.name;
+  // Check if the node type is a comment AND the cursor is within the node's range.
+  if (nodeType.includes('Comment') && cursorPosition >= node.to) {
+    if (!nodeType.includes('BlockComment')) {
+      return node;
+    }
+    // An unclosed block comment can result in the parser inserting an error.
+    let hasInternalError = false;
+    tree.iterate({
+      from: node.from,
+      to: node.to,
+      enter: n => {
+        if (n.type.isError) {
+          hasInternalError = true;
+          return false;
+        }
+        return true;
+      },
+    });
+    return hasInternalError ? undefined : node;
+  }
+  return;
+}
+
+function extractBlockComment(rawText: string): string|undefined {
+  // Remove /* and */, whitespace, and common leading asterisks on new lines
+  let cleaned = rawText.replace(BLOCK_COMMENT_START_PATTERN, '').replace(BLOCK_COMMENT_END_PATTERN, '');
+  // Remove leading " * " from multi-line block comments
+  cleaned = cleaned.split('\n').map(line => line.replace(BLOCK_COMMENT_LINE_PREFIX_PATTERN, '')).join('\n').trim();
+  return cleaned;
+}
+
+function extractLineComment(rawText: string): string {
+  return rawText.replace(LINE_COMMENT_PATTERN, '').trim();
+}
+
+export class AiCodeGenerationParser {
+  static extractCommentText(state: CodeMirror.EditorState, cursorPosition: number): string|undefined {
+    const node = resolveCommentNode(state, cursorPosition);
+    if (!node) {
+      return;
+    }
+    const nodeType = node.type.name;
+    const rawText = state.doc.sliceString(node.from, node.to);
+    if (nodeType.includes('LineComment')) {
+      return extractLineComment(rawText);
+    }
+    if (nodeType.includes('BlockComment')) {
+      return extractBlockComment(rawText);
+    }
+    return rawText;
+  }
+}