@codingame/monaco-vscode-chat-service-override 34.1.3 → 35.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatDebug/chatDebugCacheExplorerView.d.ts

@@ -1,5 +1,7 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IChatDebugModelTurnEvent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService";
 import { IChatDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service";
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
 /**
@@ -22,21 +24,62 @@ export declare enum CacheExplorerNavigation {
 export declare class ChatDebugCacheExplorerView extends Disposable {
     private readonly chatService;
     private readonly chatDebugService;
+    private readonly contextMenuService;
     private readonly _onNavigate;
     readonly onNavigate: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<CacheExplorerNavigation>;
     readonly container: HTMLElement;
     private readonly breadcrumbWidget;
     private readonly rail;
+    private readonly railToolbar;
     private readonly railList;
     private readonly content;
     private readonly sash;
     private railWidth;
-    private readonly loadDisposables;
+    /** Disposables for the left rail (toolbar + turn rows). Cleared on every full render. */
+    private readonly railDisposables;
+    /** Disposables for the right content panel. Cleared whenever the content is re-rendered. */
+    private readonly contentDisposables;
     private readonly refreshScheduler;
     private currentSessionResource;
+    /** All model turns for the session, before the agent filter is applied. */
+    private allModelTurns;
+    /** Model turns after the agent filter — the list the rail and diff operate on. */
     private modelTurns;
     /** Selected turn (B side). A is computed as `selectedIndex - 1`. -1 = no explicit selection yet. */
     private selectedIndex;
+    /**
+     * Selected agent names (keyed by {@link agentKey}). `undefined` until the
+     * first render applies the default selection. An empty set is never stored —
+     * clearing the last agent falls back to "all".
+     */
+    private selectedAgents;
+    /**
+     * Turn to re-select after the next render, used to keep the user's place
+     * when the agent filter changes. Stored as the event object rather than its
+     * id because {@link IChatDebugModelTurnEvent.id} is optional; matching falls
+     * back to object reference and a composite identity for turns without an id.
+     */
+    private pendingSelectTurn;
+    /** Whether the per-chunk signature breakdown table is expanded. */
+    private sigBreakdownOpen;
+    /** Rail turn-row elements by turn index, for in-place selection updates without rebuilding the rail. */
+    private readonly railRowsByIndex;
+    /**
+     * Component accordion entries by component name (`system`, `tools`,
+     * `messages[i]`), so findings and signature segments can reveal the
+     * matching entry. We track both the outer item (for the open/flash
+     * classes and scroll target) and the inner header (the focus target).
+     * Rebuilt on every content render.
+     */
+    private readonly componentElements;
+    /** Selection index the breaking component was last auto-expanded for. */
+    private autoOpenedForIndex;
+    /**
+     * Memoized cross-turn session report. Keyed on the session + filtered
+     * turn list so background refreshes with new events recompute it while
+     * plain selection changes reuse it.
+     */
+    private sessionReportCache;
     /**
      * Monotonically-increasing render token. Each call to {@link render}
      * captures the current value, then re-checks it after each await; if a
@@ -51,17 +94,93 @@ export declare class ChatDebugCacheExplorerView extends Disposable {
     private readonly openComponents;
     /** Rail groups currently collapsed (by group key — the parent event id). */
     private readonly collapsedGroups;
-    constructor(parent: HTMLElement, chatService: IChatService, chatDebugService: IChatDebugService);
+    constructor(parent: HTMLElement, chatService: IChatService, chatDebugService: IChatDebugService, contextMenuService: IContextMenuService);
     setSession(sessionResource: URI): void;
     show(): void;
     hide(): void;
     refresh(): void;
     updateBreadcrumb(): void;
     private render;
+    /**
+     * Render the right-hand content panel (summary, signature, options,
+     * components) for the current selection. Split out of {@link render} so a
+     * selection change can refresh just the content without rebuilding the
+     * rail \u2014 which is what keeps keyboard focus and scroll position stable
+     * while navigating turns.
+     *
+     * @param preserveScroll keep the content scroll position (used for zoom
+     * and breakdown toggles where the selection is unchanged).
+     */
+    private renderContentInner;
+    /**
+     * Build the findings list for an A→B pair. Shared between the per-turn
+     * content panel and the cross-turn session report.
+     */
+    private buildInsights;
+    /**
+     * Memoization key for the session report. The report is scoped to the
+     * turns up to (and including) the selected one, so it is stable while
+     * later requests stream in. Undefined when there is nothing to report
+     * (no session, or fewer than two turns in scope).
+     *
+     * Every in-scope turn contributes its identity AND token counts to the
+     * key — endpoints alone would miss a middle turn replaced in place, and
+     * token counts live on the event (not the id-cached resolved content),
+     * so a usage update arriving after the first render must invalidate the
+     * memoized report or the overall hit rate stays stale.
+     */
+    private sessionReportKey;
+    /**
+     * Run the insights engine over every consecutive turn pair up to the
+     * selected turn and aggregate the outcome. Memoized per (session,
+     * selection prefix, agent filter) — per-turn resolution is cached in
+     * {@link resolvedCache}, so even a cold run is one pass over in-memory
+     * events.
+     */
+    private ensureSessionReport;
+    /** Render the session-level cache health card from the cross-turn report. */
+    private renderSessionHealth;
+    /**
+     * Select a turn (the B side of the diff) and refresh only the content
+     * panel. The rail is updated in place \u2014 just the selected classes move \u2014
+     * so clicking or arrowing through turns never rebuilds the list, keeping
+     * focus and scroll position stable.
+     */
+    private selectTurn;
+    /** Move the selection to the previous/next visible turn row (arrow keys). */
+    private moveSelection;
+    /**
+     * Render the agent filter dropdown at the top of the rail. Hidden when a
+     * session only used a single agent (nothing to filter).
+     */
+    private renderRailToolbar;
+    private showAgentFilterMenu;
+    /** Toggle a single agent on/off. Never leaves the selection empty. */
+    private toggleAgent;
+    private setAgentSelection;
+    /**
+     * Render a collapsible per-chunk breakdown table. Lists every signature
+     * chunk (including identical ones the bar may hide) with its exact char
+     * count on each side and its share of the current request \u2014 i.e. where the
+     * bytes are allocated.
+     */
+    private renderChunkBreakdown;
     private resolveSide;
     private renderRail;
     private renderTitleRow;
     private renderSummary;
+    /**
+     * Render one finding row: severity icon, title, evidence, and hint.
+     * Findings that point at a Components entry render as a button that
+     * reveals (scrolls to, expands, and flashes) that component.
+     */
+    private renderFinding;
+    /**
+     * Scroll the named Components entry into view, expand it, and flash it so
+     * the eye lands on the right place. No-op when the component isn't part
+     * of the current drift list (e.g. an identical message).
+     */
+    private revealComponent;
     private renderSideCard;
     /**
      * Render the summary cards alone when there is no prior turn to diff
@@ -82,3 +201,65 @@ export declare class ChatDebugCacheExplorerView extends Disposable {
     private renderComponents;
     private renderComponentDiff;
 }
+/** A prompt-signature segment: a synthetic prefix (system/tools) or an input message. */
+export interface ISignatureSegment {
+    readonly role: string;
+    readonly chars: number;
+    readonly drift: boolean;
+    readonly label: string;
+    /** True for the synthetic system/tools prefix segments, false for input messages. */
+    readonly synthetic: boolean;
+}
+/** One aligned row of the chunk breakdown — a chunk present on either or both sides. */
+export interface IChunkBreakdownRow {
+    readonly role: string;
+    readonly label: string;
+    readonly aChars: number | undefined;
+    readonly bChars: number | undefined;
+    readonly drift: boolean;
+}
+/**
+ * Align the previous (A) and current (B) signature segments into comparable
+ * rows for the chunk breakdown table.
+ *
+ * Synthetic prefix segments (system, tools) are matched by identity so that a
+ * tool catalog or system prompt present on only one side does not shift every
+ * later message row. Input messages are matched positionally, consistent with
+ * the positional prompt-signature diff used elsewhere in this view.
+ */
+export declare function alignSignatureChunks(aSegs: readonly ISignatureSegment[], bSegs: readonly ISignatureSegment[]): IChunkBreakdownRow[];
+/**
+ * The agent a model turn belongs to. `requestName` carries the debug/agent
+ * name the producer tagged the request with (e.g. `panel/editAgent`,
+ * `backgroundTodoAgent`, or a utility name such as `title`).
+ */
+export declare function agentKey(turn: IChatDebugModelTurnEvent): string;
+/** Count model turns per agent, preserving first-seen order. */
+export declare function computeAgentCounts(turns: readonly IChatDebugModelTurnEvent[]): Map<string, number>;
+/**
+ * Default agent selection: focus on the main panel edit agent when present so
+ * background and utility calls don't clutter the rail. Falls back to all agents
+ * when the edit agent isn't part of the session.
+ */
+export declare function defaultAgentSelection(agentCounts: Map<string, number>): Set<string>;
+/**
+ * Whether two model-turn events refer to the *exact same* turn. This is the
+ * precise identity test: the same object reference, or the same stable span
+ * `id` when both events carry one. It never reports two distinct turns as equal,
+ * so it is safe to scan a list with it even when several turns look alike.
+ */
+export declare function isSameModelTurn(a: IChatDebugModelTurnEvent, b: IChatDebugModelTurnEvent): boolean;
+/**
+ * Resolve which turn index to select after the agent filter changes. Prefers
+ * the previously-selected turn; when that turn no longer survives the filter —
+ * or there was no prior selection — falls back to the most recent turn so the
+ * selection never lands on an unrelated turn that happens to occupy the old
+ * ordinal position. Returns -1 when there are no turns to select.
+ *
+ * Matching runs in two passes so the exact turn always wins: first the precise
+ * id/reference identity ({@link isSameModelTurn}), then a best-effort composite
+ * match for id-less turns ({@link isSimilarNoIdModelTurn}). Without the split,
+ * an earlier look-alike turn could be picked by `findIndex` before the real
+ * object is reached.
+ */
+export declare function resolveFilteredSelectionIndex(turns: readonly IChatDebugModelTurnEvent[], previous: IChatDebugModelTurnEvent | undefined): number;