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

package/vscode/src/vs/workbench/contrib/chat/browser/aiCustomization/automationsListWidget.js

@@ -0,0 +1,772 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as aiCustomizationManagement from './media/aiCustomizationManagement.css';
+import { $ as $$1, append, addDisposableListener, isAncestor, clearNode, addStandardDisposableListener, scheduleAtNextAnimationFrame, getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { getDefaultHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore, Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { fromNow, getDurationString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/date';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { WorkbenchList } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { defaultButtonStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { status } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { IAutomationRunner } from '../../common/automations/automationRunner.service.js';
+import { IAutomationService } from '../../common/automations/automationService.service.js';
+import { IAutomationDialogService } from '../../common/automations/automationDialogService.service.js';
+import { CHAT_AUTOMATIONS_ENABLED_SETTING } from '../../common/automations/automationsEnabled.js';
+import { DAYS_OF_WEEK } from '../../common/automations/schedule.js';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { openSession } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsOpener';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+registerCss(aiCustomizationManagement);
+const $ = $$1;
+const AUTOMATION_ROW_HEIGHT = 72;
+const HISTORY_ROW_HEIGHT = 28;
+const HISTORY_HEADER_HEIGHT = 32;
+const HISTORY_EMPTY_HEIGHT = 28;
+const HISTORY_MORE_HEIGHT = 22;
+const MAX_VISIBLE_RUNS = 20;
+class AutomationItemDelegate {
+    getHeight(element) {
+        if (!element.expanded) {
+            return AUTOMATION_ROW_HEIGHT;
+        }
+        const runs = element.runs;
+        const visibleRuns = Math.min(runs.length, MAX_VISIBLE_RUNS);
+        if (visibleRuns === 0) {
+            return AUTOMATION_ROW_HEIGHT + HISTORY_EMPTY_HEIGHT;
+        }
+        let historyHeight = HISTORY_HEADER_HEIGHT + visibleRuns * HISTORY_ROW_HEIGHT;
+        if (runs.length > MAX_VISIBLE_RUNS) {
+            historyHeight += HISTORY_MORE_HEIGHT;
+        }
+        return AUTOMATION_ROW_HEIGHT + historyHeight;
+    }
+    hasDynamicHeight(_element) {
+        return true;
+    }
+    getTemplateId(_element) {
+        return "automationItem";
+    }
+}
+class AutomationItemRenderer {
+    constructor(
+        widget,
+        hoverService,
+        notificationService,
+        editorService,
+        editorGroupsService,
+        logService,
+        agentSessionsService,
+        instantiationService
+    ) {
+        this.widget = widget;
+        this.hoverService = hoverService;
+        this.notificationService = notificationService;
+        this.editorService = editorService;
+        this.editorGroupsService = editorGroupsService;
+        this.logService = logService;
+        this.agentSessionsService = agentSessionsService;
+        this.instantiationService = instantiationService;
+        this.templateId = "automationItem";
+    }
+    renderTemplate(container) {
+        const disposables = ( new DisposableStore());
+        container.classList.add("automations-row-wrapper");
+        const row = append(container, $(".automations-row"));
+        const main = append(row, $(".automations-row-main"));
+        const nameEl = append(main, $(".automations-row-name"));
+        const nameTextEl = append(nameEl, $("span.automations-row-name-text"));
+        const disabledBadge = append(nameEl, $("span.automations-row-disabled-badge"));
+        const metaEl = append(main, $(".automations-row-meta"));
+        const scheduleEl = append(metaEl, $("span.automations-row-schedule"));
+        const sep1 = append(metaEl, $("span.automations-row-meta-sep"));
+        const nextEl = append(metaEl, $("span.automations-row-next"));
+        const sepFolder = append(metaEl, $("span.automations-row-meta-sep"));
+        const folderEl = append(metaEl, $("span.automations-row-folder"));
+        const sep2 = append(metaEl, $("span.automations-row-meta-sep"));
+        const lastEl = append(metaEl, $("span.automations-row-last"));
+        const promptEl = append(main, $(".automations-row-prompt"));
+        const actions = append(row, $(".automations-row-actions"));
+        const historyPanel = append(container, $(".automations-row-history"));
+        return {
+            container,
+            row,
+            nameEl,
+            nameTextEl,
+            disabledBadge,
+            scheduleEl,
+            sep1,
+            nextEl,
+            sepFolder,
+            folderEl,
+            sep2,
+            lastEl,
+            promptEl,
+            actions,
+            historyPanel,
+            disposables
+        };
+    }
+    renderElement(element, _index, templateData) {
+        templateData.disposables.clear();
+        const {
+            automation,
+            runs,
+            expanded,
+            inFlight
+        } = element;
+        templateData.nameTextEl.textContent = automation.name;
+        templateData.row.classList.toggle("automations-row-disabled", !automation.enabled);
+        templateData.disabledBadge.textContent = !automation.enabled ? ( localize(5950, "Disabled")) : "";
+        templateData.disabledBadge.style.display = !automation.enabled ? "" : "none";
+        templateData.scheduleEl.textContent = formatSchedule(automation);
+        templateData.sep1.textContent = "·";
+        templateData.nextEl.textContent = formatNextRun(automation);
+        templateData.sepFolder.textContent = "·";
+        const folderLabel = this.widget.formatFolderLabel(automation.folderUri);
+        templateData.folderEl.textContent = ( localize(5951, "in {0}", folderLabel));
+        templateData.folderEl.title = ( automation.folderUri.toString());
+        if (automation.lastRunAt) {
+            templateData.sep2.textContent = "·";
+            templateData.sep2.style.display = "";
+            templateData.lastEl.textContent = ( localize(5952, "Last run {0}", formatRelativeTimeOrIso(automation.lastRunAt)));
+            templateData.lastEl.style.display = "";
+        } else {
+            templateData.sep2.style.display = "none";
+            templateData.lastEl.style.display = "none";
+        }
+        templateData.promptEl.textContent = truncate(automation.prompt, 160);
+        templateData.promptEl.title = automation.prompt;
+        templateData.disposables.add(addDisposableListener(templateData.row, "click", e => {
+            if (isAncestor(e.target, templateData.actions)) {
+                return;
+            }
+            this.widget.toggleExpanded(automation.id);
+        }));
+        clearNode(templateData.actions);
+        templateData.disposables.add(addDisposableListener(templateData.actions, "click", e => {
+            e.stopPropagation();
+        }));
+        this.renderActions(templateData, automation, expanded, inFlight);
+        clearNode(templateData.historyPanel);
+        templateData.historyPanel.id = `automation-history-${automation.id}`;
+        if (expanded) {
+            this.renderHistoryPanel(templateData, automation, runs);
+        }
+        templateData.historyPanel.style.display = expanded ? "" : "none";
+    }
+    renderActions(templateData, automation, expanded, inFlight) {
+        const {
+            actions,
+            disposables
+        } = templateData;
+        const runBtn = this.createIconButton(actions, Codicon.play, ( localize(5953, "Run now")), inFlight, disposables);
+        disposables.add(addStandardDisposableListener(runBtn, "click", () => {
+            void this.widget.runNow(automation);
+        }));
+        const toggleIcon = automation.enabled ? Codicon.eye : Codicon.eyeClosed;
+        const toggleTooltip = automation.enabled ? ( localize(5954, "Disable")) : ( localize(5955, "Enable"));
+        const toggleBtn = this.createIconButton(actions, toggleIcon, toggleTooltip, false, disposables);
+        disposables.add(addStandardDisposableListener(toggleBtn, "click", () => {
+            void this.widget.toggleEnabled(automation);
+        }));
+        const editBtn = this.createIconButton(actions, Codicon.edit, ( localize(5956, "Edit")), false, disposables);
+        disposables.add(addStandardDisposableListener(editBtn, "click", () => {
+            void this.widget.openEditDialog(automation);
+        }));
+        const deleteBtn = this.createIconButton(actions, Codicon.trash, ( localize(5957, "Delete")), false, disposables);
+        disposables.add(addStandardDisposableListener(deleteBtn, "click", () => {
+            void this.widget.deleteAutomation(automation);
+        }));
+        const histIcon = expanded ? Codicon.chevronDown : Codicon.chevronRight;
+        const histTooltip = expanded ? ( localize(5958, "Hide history")) : ( localize(5959, "Show history"));
+        const histBtn = this.createIconButton(actions, histIcon, histTooltip, false, disposables);
+        histBtn.setAttribute("aria-expanded", expanded ? "true" : "false");
+        histBtn.setAttribute("aria-controls", `automation-history-${automation.id}`);
+        disposables.add(addStandardDisposableListener(histBtn, "click", () => {
+            this.widget.toggleExpanded(automation.id);
+        }));
+    }
+    renderHistoryPanel(templateData, automation, runs) {
+        const panel = templateData.historyPanel;
+        panel.setAttribute("role", "region");
+        panel.setAttribute("aria-label", ( localize(5960, "Run history for {0}", automation.name)));
+        if (runs.length === 0) {
+            const empty = append(panel, $(".automations-history-empty"));
+            empty.textContent = ( localize(5961, "No runs yet."));
+            return;
+        }
+        const heading = append(panel, $("h4.automations-history-heading"));
+        heading.textContent = ( localize(5962, "Run history"));
+        const runsList = append(panel, $("ul.automations-history-list"));
+        const visibleRuns = runs.slice(0, MAX_VISIBLE_RUNS);
+        for (const run of visibleRuns) {
+            this.renderRunRow(runsList, run, templateData.disposables);
+        }
+        if (runs.length > MAX_VISIBLE_RUNS) {
+            const more = append(panel, $(".automations-history-more"));
+            more.textContent = ( localize(5963, "{0} more run(s) not shown.", runs.length - visibleRuns.length));
+        }
+    }
+    renderRunRow(container, run, disposables) {
+        const li = append(container, $("li.automations-history-row", {
+            "data-run-id": run.id,
+            "data-run-status": run.status
+        }));
+        const statusIcon = append(li, $("span.automations-history-status.codicon"));
+        const {
+            iconId,
+            spin
+        } = runStatusIcon(run.status);
+        statusIcon.classList.add(`codicon-${iconId}`);
+        if (spin) {
+            statusIcon.classList.add("codicon-modifier-spin");
+        }
+        statusIcon.setAttribute("aria-hidden", "true");
+        const text = append(li, $(".automations-history-row-text"));
+        const first = append(text, $(".automations-history-row-first"));
+        const statusLabel = append(first, $("span.automations-history-row-status"));
+        statusLabel.textContent = runStatusLabel(run.status);
+        const sep = append(first, $("span.automations-history-row-sep"));
+        sep.textContent = "·";
+        const trig = append(first, $("span.automations-history-row-trigger"));
+        trig.textContent = runTriggerLabel(run.trigger);
+        const sep2 = append(first, $("span.automations-history-row-sep"));
+        sep2.textContent = "·";
+        const started = append(first, $("span.automations-history-row-started"));
+        started.textContent = ( localize(5964, "Started {0}", formatRelativeTimeOrIso(run.startedAt)));
+        const dur = formatRunDuration(run);
+        if (dur) {
+            const sep3 = append(first, $("span.automations-history-row-sep"));
+            sep3.textContent = "·";
+            const durEl = append(first, $("span.automations-history-row-duration"));
+            durEl.textContent = dur;
+        }
+        if (run.errorMessage) {
+            const err = append(text, $(".automations-history-row-error"));
+            err.textContent = run.errorMessage;
+            err.setAttribute("role", "status");
+            err.setAttribute("aria-live", "polite");
+        }
+        if (run.sessionResource) {
+            const openButton = append(li, $("span.automations-history-row-open.codicon.codicon-link-external"));
+            openButton.setAttribute("role", "button");
+            openButton.setAttribute("tabindex", "0");
+            openButton.setAttribute("aria-label", ( localize(5965, "Open session")));
+            disposables.add(
+                this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), openButton, ( localize(5965, "Open session")))
+            );
+            const openSession$1 = e => {
+                e.stopPropagation();
+                const sessionResource = ( URI.parse(run.sessionResource));
+                this.logService.debug(`[AutomationsListWidget] Opening session: ${( sessionResource.toString())}`);
+                const activeEditor = this.editorService.activeEditor;
+                const activeGroupId = this.editorGroupsService.activeGroup.id;
+                const agentSession = this.agentSessionsService.getSession(sessionResource);
+                if (!agentSession) {
+                    this.logService.warn(`[AutomationsListWidget] Session not found for ${( sessionResource.toString())}`);
+                    this.notificationService.error(( localize(5966, "Failed to open automation session")));
+                    return;
+                }
+                this.instantiationService.invokeFunction(openSession, agentSession).then(() => {
+                    if (activeEditor) {
+                        this.editorService.closeEditor({
+                            editor: activeEditor,
+                            groupId: activeGroupId
+                        });
+                    }
+                }).catch(err => {
+                    this.logService.error(`[AutomationsListWidget] openSession failed for ${( sessionResource.toString())}`, err);
+                    this.notificationService.error(( localize(5966, "Failed to open automation session")));
+                });
+            };
+            disposables.add(addDisposableListener(openButton, "click", openSession$1));
+            disposables.add(addDisposableListener(openButton, "keydown", e => {
+                if (e.key === "Enter" || e.key === " ") {
+                    e.preventDefault();
+                    openSession$1(e);
+                }
+            }));
+        }
+    }
+    createIconButton(container, icon, tooltip, disabled, disposables) {
+        const button = append(container, $("button.automations-row-action-button", {
+            type: "button",
+            "aria-label": tooltip,
+            tabindex: "0"
+        }));
+        button.classList.add(...ThemeIcon.asClassNameArray(icon));
+        button.disabled = disabled;
+        disposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), button, tooltip)
+        );
+        return button;
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+}
+let AutomationsListWidget = class AutomationsListWidget extends Disposable {
+    constructor(
+        automationService,
+        automationRunner,
+        dialogService,
+        automationDialogService,
+        hoverService,
+        workspaceContextService,
+        logService,
+        configurationService,
+        instantiationService,
+        notificationService,
+        editorService,
+        editorGroupsService,
+        agentSessionsService
+    ) {
+        super();
+        this.automationService = automationService;
+        this.automationRunner = automationRunner;
+        this.dialogService = dialogService;
+        this.automationDialogService = automationDialogService;
+        this.hoverService = hoverService;
+        this.workspaceContextService = workspaceContextService;
+        this.logService = logService;
+        this.configurationService = configurationService;
+        this.instantiationService = instantiationService;
+        this.notificationService = notificationService;
+        this.editorService = editorService;
+        this.editorGroupsService = editorGroupsService;
+        this.agentSessionsService = agentSessionsService;
+        this._onDidChangeItemCount = this._register(( new Emitter()));
+        this.onDidChangeItemCount = this._onDidChangeItemCount.event;
+        this.newButtonHover = this._register(( new MutableDisposable()));
+        this.newEmptyStateButtonHover = this._register(( new MutableDisposable()));
+        this._emptyStateStore = this._register(( new DisposableStore()));
+        this.runInFlight = ( new Set());
+        this.expandedRows = ( new Set());
+        this.displayEntries = [];
+        this.lastHeight = 0;
+        this.lastWidth = 0;
+        this._layoutDeferred = false;
+        this._layoutRAF = this._register(( new MutableDisposable()));
+        this.element = $(".automations-list-widget");
+        this.headerEl = append(this.element, $(".automations-header"));
+        this.emptyContainer = append(this.element, $(".automations-empty-state"));
+        this.emptyContainer.style.display = "none";
+        this.listContainer = append(this.element, $(".automations-list"));
+        this.renderHeader();
+        this.createList();
+        this._register(autorun(reader => {
+            const items = this.automationService.automations.read(reader);
+            this.automationService.runs.read(reader);
+            this.updateList(items);
+            this._onDidChangeItemCount.fire(items.length);
+        }));
+    }
+    renderHeader() {
+        const titleRow = append(this.headerEl, $(".automations-header-row"));
+        const titleEl = append(titleRow, $("h2.automations-header-title"));
+        titleEl.textContent = ( localize(5967, "Automations"));
+        const subtitleEl = append(this.headerEl, $("p.automations-header-subtitle"));
+        subtitleEl.textContent = ( localize(5968, "Schedule agent sessions to run on a cadence you choose."));
+        const newButton = this._register(( new Button(titleRow, {
+            ...defaultButtonStyles,
+            title: ( localize(5969, "New automation"))
+        })));
+        newButton.label = ( localize(5969, "New automation"));
+        newButton.element.classList.add("automations-new-button");
+        this._register(newButton.onDidClick(() => this.openCreateDialog()));
+        this.newButtonHover.value = this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), newButton.element, ( localize(5970, "Create a new automation")));
+    }
+    createList() {
+        const delegate = ( new AutomationItemDelegate());
+        const renderer = ( new AutomationItemRenderer(
+            this,
+            this.hoverService,
+            this.notificationService,
+            this.editorService,
+            this.editorGroupsService,
+            this.logService,
+            this.agentSessionsService,
+            this.instantiationService
+        ));
+        this.list = this._register(this.instantiationService.createInstance(
+            WorkbenchList,
+            "AutomationsManagementList",
+            this.listContainer,
+            delegate,
+            [renderer],
+            {
+                multipleSelectionSupport: false,
+                setRowLineHeight: false,
+                supportDynamicHeights: true,
+                horizontalScrolling: false,
+                accessibilityProvider: {
+                    getAriaLabel: element => {
+                        const a = element.automation;
+                        return a.enabled ? ( localize(5971, "{0}, {1}", a.name, formatSchedule(a))) : ( localize(5972, "{0}, disabled", a.name));
+                    },
+                    getWidgetAriaLabel() {
+                        return localize(5973, "Automations");
+                    }
+                },
+                identityProvider: {
+                    getId(element) {
+                        return element.automation.id;
+                    }
+                }
+            }
+        ));
+        this._register(this.list.onDidChangeSelection(() => {
+            if (this.list.getSelection().length > 0) {
+                this.list.setSelection([]);
+            }
+        }));
+    }
+    updateList(items) {
+        if (items.length === 0) {
+            this.element.classList.add("automations-empty");
+            this.emptyContainer.style.display = "";
+            this.listContainer.style.display = "none";
+            this.renderEmptyState();
+            this.displayEntries = [];
+            this.list.splice(0, this.list.length, []);
+            return;
+        }
+        this.element.classList.remove("automations-empty");
+        this.emptyContainer.style.display = "none";
+        this.listContainer.style.display = "";
+        this.newEmptyStateButtonHover.clear();
+        this.displayEntries = ( items.map(automation => ({
+            type: "automation-item",
+            automation,
+            runs: this.automationService.runsFor(automation.id).get(),
+            expanded: ( this.expandedRows.has(automation.id)),
+            inFlight: ( this.runInFlight.has(automation.id))
+        })));
+        this.list.splice(0, this.list.length, this.displayEntries);
+    }
+    renderEmptyState() {
+        this._emptyStateStore.clear();
+        clearNode(this.emptyContainer);
+        this.emptyContainer.setAttribute("role", "status");
+        const title = append(this.emptyContainer, $("h3.automations-empty-title"));
+        title.textContent = ( localize(5974, "No automations yet"));
+        const message = append(this.emptyContainer, $("p.automations-empty-message"));
+        message.textContent = ( localize(
+            5975,
+            "Create an automation to schedule an agent session to run on a cadence you choose."
+        ));
+        const ctaButton = this._emptyStateStore.add(( new Button(this.emptyContainer, {
+            ...defaultButtonStyles
+        })));
+        ctaButton.label = ( localize(5976, "Create automation"));
+        ctaButton.element.classList.add("automations-empty-cta");
+        this._emptyStateStore.add(ctaButton.onDidClick(() => this.openCreateDialog()));
+        this.newEmptyStateButtonHover.value = this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), ctaButton.element, ( localize(5970, "Create a new automation")));
+    }
+    toggleExpanded(automationId) {
+        if (( this.expandedRows.has(automationId))) {
+            this.expandedRows.delete(automationId);
+        } else {
+            this.expandedRows.add(automationId);
+        }
+        this.updateList(this.automationService.automations.get());
+    }
+    async runNow(automation) {
+        if (!this._isEnabled()) {
+            await this._notifyDisabled();
+            return;
+        }
+        if (( this.runInFlight.has(automation.id))) {
+            return;
+        }
+        this.runInFlight.add(automation.id);
+        this.updateList(this.automationService.automations.get());
+        const previousRunId = this.automationService.runsFor(automation.id).get()[0]?.id;
+        try {
+            await this.automationRunner.runOnce(automation, "manual", 0, CancellationToken.None);
+            const latestRun = this.automationService.runsFor(automation.id).get()[0];
+            if (latestRun && latestRun.id !== previousRunId && latestRun.status !== "failed") {
+                status(( localize(5977, "Started automation {0}", automation.name)));
+            }
+        } catch (err) {
+            this.logService.error("[Automations] runNow failed unexpectedly", err);
+        } finally {
+            this.runInFlight.delete(automation.id);
+            this.updateList(this.automationService.automations.get());
+        }
+    }
+    async toggleEnabled(automation) {
+        if (!this._isEnabled()) {
+            await this._notifyDisabled();
+            return;
+        }
+        try {
+            await this.automationService.updateAutomation(automation.id, {
+                enabled: !automation.enabled
+            });
+            status(automation.enabled ? ( localize(5978, "Disabled automation {0}", automation.name)) : ( localize(5979, "Enabled automation {0}", automation.name)));
+        } catch (err) {
+            this.logService.error("[Automations] Failed to toggle automation", err);
+        }
+    }
+    async deleteAutomation(automation) {
+        if (!this._isEnabled()) {
+            await this._notifyDisabled();
+            return;
+        }
+        const result = await this.dialogService.confirm({
+            type: "warning",
+            message: ( localize(5980, "Delete automation “{0}”?", automation.name)),
+            detail: ( localize(5981, "Runs already in flight will continue. This cannot be undone.")),
+            primaryButton: ( localize(5982, "Delete"))
+        });
+        if (!result.confirmed) {
+            return;
+        }
+        if (!this._isEnabled()) {
+            await this._notifyDisabled();
+            return;
+        }
+        try {
+            await this.automationService.deleteAutomation(automation.id);
+            status(( localize(5983, "Deleted automation {0}", automation.name)));
+        } catch (err) {
+            this.logService.error("[Automations] Failed to delete automation", err);
+        }
+    }
+    async openEditDialog(automation) {
+        if (!this._isEnabled()) {
+            await this._notifyDisabled();
+            return;
+        }
+        const result = await this.automationDialogService.showAutomationDialog({
+            existing: automation
+        });
+        if (!result || result.kind !== "update") {
+            return;
+        }
+        if (!this._isEnabled()) {
+            await this._notifyDisabled();
+            return;
+        }
+        try {
+            await this.automationService.updateAutomation(result.id, result.value);
+            status(( localize(5984, "Updated automation {0}", automation.name)));
+        } catch (err) {
+            this.logService.error("[Automations] Failed to update automation", err);
+            await this.dialogService.error(( localize(5985, "Failed to update automation.")), err instanceof Error ? err.message : String(err));
+        }
+    }
+    formatFolderLabel(folderUri) {
+        const folders = this.workspaceContextService.getWorkspace().folders;
+        const match = folders.find(f => isEqual(f.uri, folderUri));
+        if (match) {
+            return match.name || ( match.uri.toString());
+        }
+        const segments = folderUri.path.split("/").filter(s => s.length > 0);
+        return segments[segments.length - 1] ?? ( folderUri.toString());
+    }
+    _isEnabled() {
+        return this.configurationService.getValue(CHAT_AUTOMATIONS_ENABLED_SETTING) === true;
+    }
+    async _notifyDisabled() {
+        await this.dialogService.info(( localize(5986, "Automations are disabled.")), ( localize(5987, "Enable “{0}” to make changes.", CHAT_AUTOMATIONS_ENABLED_SETTING)));
+    }
+    async openCreateDialog() {
+        if (!this._isEnabled()) {
+            await this._notifyDisabled();
+            return;
+        }
+        const result = await this.automationDialogService.showAutomationDialog({});
+        if (!result || result.kind !== "create") {
+            return;
+        }
+        if (!this._isEnabled()) {
+            await this._notifyDisabled();
+            return;
+        }
+        try {
+            const created = await this.automationService.createAutomation(result.value);
+            status(( localize(5988, "Created automation {0}", created.name)));
+        } catch (err) {
+            this.logService.error("[Automations] Failed to create automation", err);
+            await this.dialogService.error(( localize(5989, "Failed to create automation.")), err instanceof Error ? err.message : String(err));
+        }
+    }
+    layout(height, width) {
+        this.lastHeight = height;
+        this.lastWidth = width;
+        this.element.style.height = `${height}px`;
+        const headerHeight = this.headerEl.offsetHeight;
+        if (headerHeight === 0 && !this._layoutDeferred) {
+            this._layoutDeferred = true;
+            this._layoutRAF.value = scheduleAtNextAnimationFrame(getWindow(this.element), () => {
+                this._layoutDeferred = false;
+                this.layout(this.lastHeight, this.lastWidth);
+            });
+            return;
+        }
+        const listHeight = Math.max(0, height - headerHeight);
+        this.listContainer.style.height = `${listHeight}px`;
+        this.list.layout(listHeight, width);
+    }
+    fireItemCount() {
+        this._onDidChangeItemCount.fire(this.automationService.automations.get().length);
+    }
+    get itemCount() {
+        return this.list.length;
+    }
+    getDisplayEntriesForTest() {
+        return this.displayEntries;
+    }
+    focus() {
+        if (this.list.length > 0) {
+            this.list.domFocus();
+        }
+    }
+};
+AutomationsListWidget = ( __decorate([( __param(0, IAutomationService)), ( __param(1, IAutomationRunner)), ( __param(2, IDialogService)), ( __param(3, IAutomationDialogService)), ( __param(4, IHoverService)), ( __param(5, IWorkspaceContextService)), ( __param(6, ILogService)), ( __param(7, IConfigurationService)), ( __param(8, IInstantiationService)), ( __param(9, INotificationService)), ( __param(10, IEditorService)), ( __param(11, IEditorGroupsService)), ( __param(12, IAgentSessionsService))], AutomationsListWidget));
+function formatSchedule(a) {
+    switch (a.schedule.interval) {
+    case "manual":
+        return localize(5990, "Manual");
+    case "hourly":
+        return localize(5991, "Hourly");
+    case "daily":
+        return localize(
+            5992,
+            "Daily at {0}",
+            formatHourMinute(a.schedule.scheduleHour, a.schedule.scheduleMinute)
+        );
+    case "weekly":
+        {
+            const day = dayName(a.schedule.scheduleDay);
+            return localize(
+                5993,
+                "Weekly on {0} at {1}",
+                day,
+                formatHourMinute(a.schedule.scheduleHour, a.schedule.scheduleMinute)
+            );
+        }
+    }
+}
+function formatHourMinute(hour, minute) {
+    const date = ( new Date());
+    date.setHours(
+        Math.max(0, Math.min(23, hour | 0)),
+        Math.max(0, Math.min(59, minute | 0)),
+        0,
+        0
+    );
+    return date.toLocaleTimeString(undefined, {
+        hour: "numeric",
+        minute: "2-digit"
+    });
+}
+function dayName(day) {
+    const idx = ((day % 7) + 7) % 7;
+    return DAYS_OF_WEEK[idx];
+}
+function formatNextRun(a) {
+    if (a.schedule.interval === "manual" || !a.nextRunAt) {
+        return localize(5994, "No scheduled run");
+    }
+    return localize(5995, "Next run {0}", formatRelativeTimeOrIso(a.nextRunAt));
+}
+function formatRelativeTimeOrIso(iso) {
+    const t = Date.parse(iso);
+    if (Number.isNaN(t)) {
+        return iso;
+    }
+    const date = ( new Date(t));
+    const rel = fromNow(date, true);
+    const absolute = date.toLocaleString();
+    return `${rel} (${absolute})`;
+}
+function truncate(s, max) {
+    const single = s.replace(/\s+/g, " ").trim();
+    if (single.length <= max) {
+        return single;
+    }
+    return single.slice(0, Math.max(0, max - 1)) + "…";
+}
+function runStatusIcon(status) {
+    switch (status) {
+    case "pending":
+        return {
+            iconId: "circle-outline",
+            spin: false
+        };
+    case "running":
+        return {
+            iconId: "sync",
+            spin: true
+        };
+    case "completed":
+        return {
+            iconId: "check",
+            spin: false
+        };
+    case "failed":
+        return {
+            iconId: "error",
+            spin: false
+        };
+    }
+}
+function runStatusLabel(status) {
+    switch (status) {
+    case "pending":
+        return localize(5996, "Pending");
+    case "running":
+        return localize(5997, "Running");
+    case "completed":
+        return localize(5998, "Completed");
+    case "failed":
+        return localize(5999, "Failed");
+    }
+}
+function runTriggerLabel(trigger) {
+    switch (trigger) {
+    case "schedule":
+        return localize(6000, "Scheduled");
+    case "manual":
+        return localize(6001, "Manual");
+    case "catch_up":
+        return localize(6002, "Catch-up");
+    }
+}
+function formatRunDuration(run) {
+    if (!run.completedAt) {
+        return undefined;
+    }
+    const startMs = Date.parse(run.startedAt);
+    const endMs = Date.parse(run.completedAt);
+    if (Number.isNaN(startMs) || Number.isNaN(endMs)) {
+        return undefined;
+    }
+    const durationMs = Math.max(0, endMs - startMs);
+    return getDurationString(durationMs);
+}
+
+export { AutomationsListWidget };