@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/promptTimeline/promptBucketing.d.ts

@@ -0,0 +1,38 @@
+/** A user prompt that can be represented on the prompt timeline. */
+export interface PromptItem {
+    /** Stable id of the user request (chat request view model id). */
+    readonly requestId: string;
+    /** Preview text of the prompt (already single-line/plain is fine). */
+    readonly text: string;
+    /** Creation time in ms since epoch. */
+    readonly timestamp: number;
+}
+/** A timeline tick representing one or more chronological prompts. */
+export interface PromptBucket {
+    /** Representative prompt (the FIRST prompt in the bucket) — the jump target. */
+    readonly prompt: PromptItem;
+    /** All prompts grouped into this bucket, in chronological order. */
+    readonly prompts: readonly PromptItem[];
+    /** How many prompts this tick represents (== prompts.length). */
+    readonly count: number;
+}
+/** Hard cap on the number of ticks produced. */
+export declare const MAX_TICKS = 24;
+declare function bucketKey(date: Date, now: Date): string;
+declare function bucketPrompts(prompts: readonly PromptItem[], now: Date): PromptBucket[];
+declare function uniformSample(buckets: PromptBucket[], maxTicks: number): PromptBucket[];
+declare function expandRecentBuckets(buckets: PromptBucket[], maxTicks: number): PromptBucket[];
+/**
+ * Compresses chronological prompts into a bounded set of recency-aware timeline ticks.
+ * Pass `now` in tests to make time-based grouping deterministic. `maxTicks` caps the
+ * result (defaults to {@link MAX_TICKS}); callers lower it to fit the available height.
+ */
+export declare function budgetBucketPrompts(prompts: readonly PromptItem[], now?: number, maxTicks?: number): PromptBucket[];
+/** Internal helpers exposed only for focused unit tests. */
+export declare const _testing: {
+    readonly bucketKey: typeof bucketKey;
+    readonly bucketPrompts: typeof bucketPrompts;
+    readonly uniformSample: typeof uniformSample;
+    readonly expandRecentBuckets: typeof expandRecentBuckets;
+};
+export {};

package/vscode/src/vs/workbench/contrib/chat/browser/promptTimeline/promptBucketing.js

@@ -0,0 +1,100 @@
+
+
+const MAX_TICKS = 24;
+const oneDayMs = 86400000;
+function bucketKey(date, now) {
+    const startOfToday = ( new Date(now.getFullYear(), now.getMonth(), now.getDate()));
+    if (date >= startOfToday) {
+        return `today-${date.getTime()}`;
+    }
+    const daysAgo = (startOfToday.getTime() - date.getTime()) / oneDayMs;
+    if (daysAgo < 1) {
+        return `yesterday-h${date.getHours()}`;
+    }
+    if (daysAgo < 30) {
+        return `day-${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`;
+    }
+    return `month-${date.getFullYear()}-${date.getMonth()}`;
+}
+function toBucket(prompt, prompts = [prompt]) {
+    return {
+        prompt,
+        prompts,
+        count: prompts.length
+    };
+}
+function bucketPrompts(prompts, now) {
+    const buckets = [];
+    let currentKey;
+    for (const prompt of prompts) {
+        const key = bucketKey(( new Date(prompt.timestamp)), now);
+        const current = buckets[buckets.length - 1];
+        if (!current || key !== currentKey) {
+            buckets.push(toBucket(prompt));
+            currentKey = key;
+        } else {
+            const groupedPrompts = [...current.prompts, prompt];
+            buckets[buckets.length - 1] = toBucket(current.prompt, groupedPrompts);
+        }
+    }
+    return buckets;
+}
+function uniformSample(buckets, maxTicks) {
+    if (buckets.length <= maxTicks) {
+        return buckets;
+    }
+    const first = buckets[0];
+    const last = buckets[buckets.length - 1];
+    if (maxTicks <= 2) {
+        return [first, last];
+    }
+    const sampled = [first];
+    const step = (buckets.length - 1) / (maxTicks - 1);
+    for (let i = 1; i <= maxTicks - 2; i++) {
+        const index = Math.round(i * step);
+        if (index > 0 && index < buckets.length - 1) {
+            sampled.push(buckets[index]);
+        }
+    }
+    sampled.push(last);
+    return sampled;
+}
+function expandBucket(bucket, budget) {
+    if (bucket.count <= budget + 1) {
+        return ( bucket.prompts.map(prompt => toBucket(prompt)));
+    }
+    const expandedCount = budget;
+    const remainder = bucket.prompts.slice(0, bucket.count - expandedCount);
+    const expandedPrompts = bucket.prompts.slice(bucket.count - expandedCount);
+    return [toBucket(remainder[0], remainder), ...( expandedPrompts.map(prompt => toBucket(prompt)))];
+}
+function expandRecentBuckets(buckets, maxTicks) {
+    if (buckets.length >= maxTicks) {
+        return buckets;
+    }
+    let expanded = buckets;
+    let total = buckets.length;
+    for (let i = expanded.length - 1; i >= 0 && total < maxTicks; i--) {
+        const bucket = expanded[i];
+        if (bucket.count <= 1) {
+            continue;
+        }
+        const replacement = expandBucket(bucket, maxTicks - total);
+        total += replacement.length - 1;
+        expanded = [...expanded.slice(0, i), ...replacement, ...expanded.slice(i + 1)];
+    }
+    return expanded;
+}
+function budgetBucketPrompts(prompts, now = Date.now(), maxTicks = MAX_TICKS) {
+    const cap = Math.min(MAX_TICKS, Math.max(1, maxTicks));
+    const buckets = bucketPrompts(prompts, ( new Date(now)));
+    if (buckets.length > cap) {
+        return uniformSample(buckets, cap);
+    }
+    if (buckets.length < cap) {
+        return expandRecentBuckets(buckets, cap);
+    }
+    return buckets;
+}
+
+export { MAX_TICKS, budgetBucketPrompts };

package/vscode/src/vs/workbench/contrib/chat/browser/promptTimeline/promptTimeline.contribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/workbench/contrib/chat/browser/promptTimeline/promptTimeline.contribution.js

@@ -0,0 +1,51 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { ChatWidget } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatWidget';
+import { PROMPT_TIMELINE_STICKY_SCROLL_SETTING, PROMPT_TIMELINE_DISPLAY_SETTING, PROMPT_TIMELINE_RAIL_STYLES } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/promptTimeline';
+import { PromptTimelineWidgetContrib } from './promptTimelineWidgetContrib.js';
+
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+configurationRegistry.registerConfiguration({
+    id: "chat",
+    properties: {
+        [PROMPT_TIMELINE_STICKY_SCROLL_SETTING]: {
+            type: "boolean",
+            default: true,
+            description: ( localize(
+                9007,
+                "Controls whether the current prompt is pinned to the top of the chat transcript while scrolling."
+            )),
+            experiment: {
+                mode: "startup"
+            }
+        }
+    }
+});
+configurationRegistry.registerConfiguration({
+    id: "sessions",
+    properties: {
+        [PROMPT_TIMELINE_DISPLAY_SETTING]: {
+            type: "string",
+            enum: [...PROMPT_TIMELINE_RAIL_STYLES],
+            enumDescriptions: [( localize(9008, "Do not show the prompt timeline.")), ( localize(
+                9009,
+                "Show an overview ruler beside the transcript scrollbar that fans into prompt pills on engagement."
+            )), ( localize(
+                9010,
+                "Show a minimal handle in the transcript's left gutter that opens a list of prompts on hover."
+            ))],
+            default: "gutter",
+            description: ( localize(
+                9011,
+                "Controls how the prompt timeline is displayed next to the chat transcript in the Agents window."
+            )),
+            tags: ["experimental"],
+            experiment: {
+                mode: "startup"
+            }
+        }
+    }
+});
+ChatWidget.CONTRIBS.push(PromptTimelineWidgetContrib);

package/vscode/src/vs/workbench/contrib/chat/browser/promptTimeline/promptTimelineCard.d.ts

@@ -0,0 +1,30 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IPromptReviewFileEvent } from "./promptTimelineRail.js";
+import { PromptFileDiff, PromptTick } from "./promptTimelineModel.js";
+/**
+ * The interactive preview shown when a prompt mark is hovered or focused, shared
+ * by every rail style. Renders the prompt text, its diff summary (a shortcut to
+ * review the whole prompt) and per-file rows, and stays open while hovered.
+ */
+export declare class PromptTimelineCard extends Disposable {
+    private readonly _container;
+    private readonly _element;
+    private readonly _contentDisposables;
+    private _hovered;
+    private _hideTimer;
+    private _filesProvider;
+    private readonly _onDidReview;
+    readonly onDidReview: Event<PromptTick>;
+    private readonly _onDidReviewFile;
+    readonly onDidReviewFile: Event<IPromptReviewFileEvent>;
+    constructor(_container: HTMLElement);
+    setFilesProvider(provider: (tick: PromptTick) => readonly PromptFileDiff[]): void;
+    /** Builds the card for a tick and positions it centered on `anchorCenterY` (relative to the container). */
+    show(tick: PromptTick, anchorCenterY: number): void;
+    private _renderStat;
+    /** Hides the card shortly, unless it (or a mark) is re-hovered first. */
+    scheduleHide(): void;
+    hide(): void;
+    dispose(): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/promptTimeline/promptTimelineCard.js

@@ -0,0 +1,113 @@
+
+import { append, $, addDisposableListener, EventType, clearNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+
+class PromptTimelineCard extends Disposable {
+    constructor(_container) {
+        super();
+        this._container = _container;
+        this._contentDisposables = this._register(( new DisposableStore()));
+        this._hovered = false;
+        this._filesProvider = () => [];
+        this._onDidReview = this._register(( new Emitter()));
+        this.onDidReview = this._onDidReview.event;
+        this._onDidReviewFile = this._register(( new Emitter()));
+        this.onDidReviewFile = this._onDidReviewFile.event;
+        this._element = append(this._container, $(".prompt-timeline-card"));
+        this._element.classList.add("hidden");
+        this._register(addDisposableListener(this._element, EventType.MOUSE_ENTER, () => {
+            this._hovered = true;
+        }));
+        this._register(addDisposableListener(this._element, EventType.MOUSE_LEAVE, () => {
+            this._hovered = false;
+            this.scheduleHide();
+        }));
+    }
+    setFilesProvider(provider) {
+        this._filesProvider = provider;
+    }
+    show(tick, anchorCenterY) {
+        if (this._hideTimer !== undefined) {
+            clearTimeout(this._hideTimer);
+            this._hideTimer = undefined;
+        }
+        this._contentDisposables.clear();
+        clearNode(this._element);
+        const head = append(this._element, $(".prompt-timeline-card-head"));
+        append(head, $(".prompt-timeline-card-text")).textContent = tick.text;
+        if (tick.count > 1) {
+            append(head, $(".prompt-timeline-card-meta")).textContent = ( localize(9012, "{0} prompts", tick.count));
+        }
+        const files = tick.stat ? this._filesProvider(tick) : [];
+        if (tick.stat) {
+            const diffAction = append(head, $("button.prompt-timeline-card-diff-action"));
+            diffAction.setAttribute("aria-label", ( localize(9013, "Review Changes for Prompt: {0}", tick.text)));
+            this._renderStat(
+                append(diffAction, $("span.prompt-timeline-card-stat")),
+                tick.stat.added,
+                tick.stat.removed
+            );
+            append(diffAction, $("span")).textContent = tick.stat.fileCount === 1 ? ( localize(9014, "1 file")) : ( localize(9015, "{0} files", tick.stat.fileCount));
+            append(diffAction, $("span.prompt-timeline-card-diff-action-chevron")).textContent = "›";
+            this._contentDisposables.add(addDisposableListener(diffAction, EventType.CLICK, () => {
+                this._onDidReview.fire(tick);
+                this.hide();
+            }));
+        } else {
+            append(head, $("div.prompt-timeline-card-no-edits")).textContent = ( localize(9016, "no edits"));
+        }
+        if (files.length > 0) {
+            const list = append(this._element, $(".prompt-timeline-card-files"));
+            for (const file of files) {
+                const row = append(list, $("button.prompt-timeline-card-file"));
+                row.title = file.name;
+                append(row, $(".prompt-timeline-card-fname")).textContent = file.name;
+                this._renderStat(append(row, $(".prompt-timeline-card-fstat")), file.added, file.removed);
+                this._contentDisposables.add(addDisposableListener(row, EventType.CLICK, () => {
+                    this._onDidReviewFile.fire({
+                        tick,
+                        file: file.modifiedURI
+                    });
+                    this.hide();
+                }));
+            }
+        }
+        this._element.classList.remove("hidden");
+        const top = anchorCenterY - this._element.offsetHeight / 2;
+        const clampedTop = Math.max(
+            4,
+            Math.min(top, this._container.clientHeight - this._element.offsetHeight - 4)
+        );
+        this._element.style.top = `${clampedTop}px`;
+    }
+    _renderStat(container, added, removed) {
+        append(container, $("span.added")).textContent = `+${added}`;
+        append(container, $("span.removed")).textContent = `\u2212${removed}`;
+    }
+    scheduleHide() {
+        if (this._hideTimer !== undefined) {
+            clearTimeout(this._hideTimer);
+        }
+        this._hideTimer = setTimeout(() => {
+            this._hideTimer = undefined;
+            if (!this._hovered) {
+                this.hide();
+            }
+        }, 200);
+    }
+    hide() {
+        this._hovered = false;
+        this._contentDisposables.clear();
+        this._element.classList.add("hidden");
+    }
+    dispose() {
+        if (this._hideTimer !== undefined) {
+            clearTimeout(this._hideTimer);
+        }
+        super.dispose();
+    }
+}
+
+export { PromptTimelineCard };

package/vscode/src/vs/workbench/contrib/chat/browser/promptTimeline/promptTimelineGutterRail.d.ts

@@ -0,0 +1,146 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { PromptFileDiff, PromptTick, IPromptScrollLayout } from "./promptTimelineModel.js";
+import { IPromptReviewFileEvent, IPromptTimelineRail } from "./promptTimelineRail.js";
+/** How many resting dots fit for `promptCount` prompts in a rail `railHeight` px tall (0 when unmeasured). */
+export declare function restDotCount(promptCount: number, railHeight: number): number;
+/**
+ * A minimal, left-edge prompt timeline. At rest it is only a small handle in the transcript's left
+ * gutter (one dot per prompt, the current prompt's dot accented) — no per-prompt marks, no diff
+ * colour — so the transcript stays calm. Hovering, tapping, or focusing the handle expands a flyout
+ * listing every prompt (its text and a diff badge) to the *right* of the dots, so the dots stay
+ * visible and keep working as a scrubber: hovering an individual dot previews its prompt in the
+ * flyout. Because the list is evenly spaced and never derived from response heights, it stays stable
+ * under virtualization.
+ *
+ * Each row is split into two buttons so the prompt's changes are reachable without leaving the rail:
+ * the label on the left reveals the prompt in the transcript, and the diff badge on the right opens
+ * just that turn's changes (the ruler rail offers the same drill-down from its hover card). The badge
+ * is absent for prompts that edited nothing. Both close the flyout.
+ *
+ * The handle is an accessible disclosure button (`aria-expanded`/`aria-controls`) wired for mouse,
+ * touch (via {@link Gesture}) and keyboard; the flyout is a single-tab-stop toolbar where Up/Down
+ * (and Home/End) move between rows, Left/Right move between a row's two buttons, and Escape dismisses.
+ *
+ * It implements the same {@link IPromptTimelineRail} contract as the overview-ruler rail so the two
+ * are interchangeable behind the `sessions.chatTimeline.display` setting; the scroll-driven and
+ * fisheye affordances the ruler needs (hard-wheel bloom, proportional scroll layout) are no-ops here.
+ */
+export declare class PromptTimelineGutterRail extends Disposable implements IPromptTimelineRail {
+    private readonly _domNode;
+    private readonly _rest;
+    private readonly _list;
+    private readonly _rowDisposables;
+    /** Held separately from {@link _rowDisposables}: the dots are re-rendered on resize, without the rows. */
+    private readonly _dotDisposables;
+    private readonly _rows;
+    /** The resting dots, in order; `_dotTicks[i]` is the tick index dot `i` stands for. */
+    private readonly _dots;
+    private readonly _dotTicks;
+    private _activeRequestId;
+    private _hostWidth;
+    /** Cached rail height; only changes on resize (observed), so rendering never forces a reflow to read it. */
+    private _railHeight;
+    private _resizeObserverReady;
+    /** Prompt count of the last {@link setTicks}, so a resize can re-sample the dots without new ticks. */
+    private _tickCount;
+    /** Disclosure held open by explicit activation (handle click/tap/keyboard, or a row focused via keyboard). */
+    private _open;
+    /** Pointer is over the rail; reveals the flyout transiently (independent of {@link _open}). */
+    private _hovering;
+    /** Tick index previewed by the dot currently under the pointer, or `-1` when no dot is hovered. */
+    private _previewIndex;
+    /** Row currently showing the full-width preview band, or `-1`; only dot-driven previews band. */
+    private _previewBand;
+    /** Tick index of the prompt the transcript is scrolled to, or `-1`; re-applied when the dots re-render. */
+    private _activeIndex;
+    /** Row holding the flyout's single tab stop. */
+    private _focusRow;
+    /** Which of that row's two buttons holds it. */
+    private _focusColumn;
+    private readonly _onDidSelect;
+    readonly onDidSelect: Event<string>;
+    /** Fired by a row's diff button to review that prompt's whole changeset. */
+    private readonly _onDidReview;
+    readonly onDidReview: Event<PromptTick>;
+    private readonly _onDidReviewFile;
+    readonly onDidReviewFile: Event<IPromptReviewFileEvent>;
+    get domNode(): HTMLElement;
+    constructor();
+    /** Reveal whenever the disclosure is open OR the pointer is hovering; keep `aria-expanded` in sync. */
+    private _updateRevealed;
+    /** Toggle the disclosure via explicit activation: opening focuses a row, closing returns to the handle. */
+    private _toggleOpen;
+    /**
+     * Collapse the disclosure (shared close path for activation, Escape, and row actions).
+     *
+     * `restoreFocus` returns focus to the handle so keyboard users are not stranded; the diff action
+     * opts out, because the multi-diff editor it opens takes focus itself and pulling focus back to
+     * the rail first would fight it.
+     */
+    private _close;
+    private _focusActiveRow;
+    setFilesProvider(_provider: (tick: PromptTick) => readonly PromptFileDiff[]): void;
+    /**
+     * Rebuilds the resting handle's dots. There is one dot per prompt as long as they fit — capped by
+     * {@link MAX_REST_DOTS} and by the room the rail actually has (see {@link restDotCount}); beyond
+     * that the dots are evenly sampled across the session so every dot still stands for a real prompt
+     * (and the active prompt always maps to one), with a trailing marker signalling the sampling.
+     */
+    private _renderDots;
+    /**
+     * Observes the rail so the dot column keeps fitting when the transcript's height changes — the
+     * window resizing, the chat input growing, a split view. The rail is only mounted once, so the
+     * observer is created on the first render and lives for the rail's lifetime.
+     */
+    private _ensureResizeObserver;
+    /** Previews the prompt a hovered dot stands for by highlighting its row and scrolling it into view. */
+    /**
+     * Previews the prompt a row stands for: highlights it and scrolls it into view.
+     *
+     * `source` decides whether the row gets the full-width band. A preview from a hovered *dot* points
+     * at a row the pointer is nowhere near, so the whole row lights up to say "this one". A preview
+     * from the pointer resting on the row itself must NOT band it: the row's two halves light up
+     * individually under the pointer, and a band covering both would paint over that — making a row
+     * with two buttons read as one.
+     */
+    private _setPreview;
+    /**
+     * Accents the dots standing for the active ("you are here") and previewed prompts. Once the dots
+     * are sampled the nearest dot stands in, so both accents survive a re-sampling on resize.
+     */
+    private _updateDotHighlights;
+    private _findNearestDotIndex;
+    /**
+     * Scrolls a row into view inside the flyout. Done by hand rather than with `scrollIntoView` so a
+     * hover can never scroll the transcript (or any other ancestor) behind the rail.
+     */
+    private _revealRow;
+    setTicks(ticks: readonly PromptTick[]): void;
+    private _renderRow;
+    private _renderStat;
+    /** The button a row column maps to, or undefined when that row has no changes to review. */
+    private _cell;
+    /** True when `element` is a row button that is still a live focus target — a dropped badge is not. */
+    private _isLiveCell;
+    /**
+     * Roving tabindex: exactly one button across the whole flyout is tabbable, so it stays a single Tab
+     * stop even though every row now holds two. A requested diff column falls back to the label when
+     * that row has no changes, so the tab stop can never land on a hidden (unfocusable) button.
+     */
+    private _updateTabStops;
+    /** Moves the roving tab stop and the focus together, clamping the row and resolving the column. */
+    private _focusCell;
+    /**
+     * The flyout's toolbar keyboard model: Up/Down (and Home/End) walk the rows keeping the current
+     * column where the target row has one, Left/Right cross between a row's label and diff buttons,
+     * and Escape dismisses.
+     */
+    private _onListKeyDown;
+    setActive(requestId: string | undefined): void;
+    private _updateActiveClasses;
+    focusTick(requestId: string): void;
+    setHostWidth(width: number): void;
+    notifyHardWheel(): void;
+    setScrollLayout(_layout: IPromptScrollLayout | undefined): void;
+}