@theia/ai-ide 1.74.0-next.8 → 1.74.0

package/src/browser/chat-sessions-welcome-message-provider.tsx

@@ -17,109 +17,22 @@
 import { ChatWelcomeMessageProvider } from '@theia/ai-chat-ui/lib/browser/chat-tree-view';
 import { formatTimeAgo } from '@theia/ai-chat-ui/lib/browser/chat-date-utils';
 import {
-    ChatAgentService, ChatService, ChatSession, ChatSessionMetadata
+    ChatAgentService, ChatService, ChatSessionMetadata
 } from '@theia/ai-chat';
-import { BYPASS_MODEL_REQUIREMENT_PREF, PERSISTED_SESSION_LIMIT_PREF, SESSION_STORAGE_PREF, WELCOME_SCREEN_SESSIONS_PREF } from '@theia/ai-chat/lib/common/ai-chat-preferences';
+import { BYPASS_MODEL_REQUIREMENT_PREF, WELCOME_SCREEN_SESSIONS_PREF } from '@theia/ai-chat/lib/common/ai-chat-preferences';
 import { AI_CHAT_SHOW_CHATS_COMMAND } from '@theia/ai-chat-ui/lib/browser/chat-view-commands';
-import { ChatViewWidget } from '@theia/ai-chat-ui/lib/browser/chat-view-widget';
 import { ChatSessionItemAction, ChatSessionItemActionContribution } from './chat-session-item-action-contribution';
+import { ChatSessionListService } from './chat-session-list-service';
+import { SectionedSessions, SessionRow, SessionsList } from './chat-session-list-components';
 import { ChatSessionItem } from './chat-session-item';
 import { FrontendLanguageModelRegistry } from '@theia/ai-core/lib/common';
-import { CommandRegistry, ContributionProvider, DisposableCollection, Emitter, Event, PreferenceService } from '@theia/core';
-import { ApplicationShell, buttonKeyboardProps, HoverService, isActivationKey } from '@theia/core/lib/browser';
+import { CommandRegistry, ContributionProvider, Emitter, Event, PreferenceService } from '@theia/core';
+import { ApplicationShell, HoverService } from '@theia/core/lib/browser';
+import { AISessionsWidget } from './ai-sessions-widget';
 import { MarkdownRenderer, MarkdownRendererFactory } from '@theia/core/lib/browser/markdown-rendering/markdown-renderer';
-import { nls } from '@theia/core/lib/common/nls';
 import { inject, injectable, named, postConstruct } from '@theia/core/shared/inversify';
 import * as React from '@theia/core/shared/react';
 
-/** When both Active and Restored sections are non-empty, keep at least this many Restored slots. */
-const RESTORED_MIN_RESERVATION = 5;
-
-export interface SectionedSessions {
-    active: ChatSessionMetadata[];
-    restored: ChatSessionMetadata[];
-}
-
-export interface VisibleSessionSlots {
-    activeCount: number;
-    restoredCount: number;
-}
-
-/**
- * Allocates the capped number of visible items between the Active and Restored sections of the
- * overview. When both sections are non-empty, up to {@link RESTORED_MIN_RESERVATION} slots are
- * reserved for Restored so active sessions cannot crowd it out entirely. A cap of 0 hides the
- * inline list (every session stays reachable via the "Browse all chats..." link).
- */
-export function computeVisibleSessionSlots(activeTotal: number, restoredTotal: number, maxSessions: number): VisibleSessionSlots {
-    const cap = Math.max(0, maxSessions);
-    if (cap === 0) {
-        return { activeCount: 0, restoredCount: 0 };
-    }
-    if (restoredTotal === 0) {
-        return { activeCount: Math.min(activeTotal, cap), restoredCount: 0 };
-    }
-    if (activeTotal === 0) {
-        return { activeCount: 0, restoredCount: Math.min(restoredTotal, cap) };
-    }
-    const reserved = Math.min(restoredTotal, Math.min(RESTORED_MIN_RESERVATION, Math.max(1, cap - 1)));
-    const activeCount = Math.min(activeTotal, cap - reserved);
-    const restoredCount = Math.min(restoredTotal, cap - activeCount);
-    return { activeCount, restoredCount };
-}
-
-interface SessionsListProps {
-    sections: SectionedSessions;
-    /** Total cap on items shown on the home view; overflow surfaces via the Browse all link. */
-    maxSessions: number;
-    renderItem: (session: ChatSessionMetadata, isRestored: boolean) => React.ReactNode;
-    onBrowseAll: () => void;
-}
-
-function SessionsList({ sections, maxSessions, renderItem, onBrowseAll }: SessionsListProps): React.ReactElement {
-    const total = sections.active.length + sections.restored.length;
-    const { activeCount, restoredCount } = computeVisibleSessionSlots(sections.active.length, sections.restored.length, maxSessions);
-    const activeVisible = sections.active.slice(0, activeCount);
-    const restoredVisible = sections.restored.slice(0, restoredCount);
-    const hiddenCount = total - activeVisible.length - restoredVisible.length;
-
-    return (
-        <div className="theia-WelcomeMessage-SessionsList">
-            {activeVisible.length > 0 && (
-                <div className="theia-WelcomeMessage-SessionsGroup">
-                    <div className="theia-WelcomeMessage-SessionsHeader">
-                        {nls.localizeByDefault('Active')}
-                    </div>
-                    {activeVisible.map(s => renderItem(s, false))}
-                </div>
-            )}
-            {restoredVisible.length > 0 && (
-                <div className="theia-WelcomeMessage-SessionsGroup">
-                    <div className="theia-WelcomeMessage-SessionsHeader">
-                        {nls.localize('theia/ai/ide/sectionRestored', 'Restored')}
-                    </div>
-                    {restoredVisible.map(s => renderItem(s, true))}
-                </div>
-            )}
-            {hiddenCount > 0 && (
-                <div className="theia-WelcomeMessage-SessionsFooter">
-                    <a className="theia-WelcomeMessage-FooterLink"
-                        {...buttonKeyboardProps(nls.localize('theia/ai/ide/browseAllChats', 'Browse all chats...'))}
-                        onClick={onBrowseAll}
-                        onKeyDown={e => {
-                            if (isActivationKey(e)) {
-                                e.preventDefault();
-                                onBrowseAll();
-                            }
-                        }}>
-                        {nls.localize('theia/ai/ide/browseAllChats', 'Browse all chats...')}
-                    </a>
-                </div>
-            )}
-        </div>
-    );
-}
-
 @injectable()
 export class ChatSessionsWelcomeMessageProvider implements ChatWelcomeMessageProvider {
 
@@ -152,11 +65,12 @@ export class ChatSessionsWelcomeMessageProvider implements ChatWelcomeMessagePro
     @inject(ApplicationShell)
     protected readonly shell: ApplicationShell;
 
+    @inject(ChatSessionListService)
+    protected readonly sessionListService: ChatSessionListService;
+
     protected _inputEnabled = false;
 
-    private readonly unreadSessions = new Map<string, { unread: boolean; seenRequests: number; seenCompleted: number; listener: DisposableCollection }>();
-    private readonly onUnreadChangedEmitter = new Emitter<string>();
-    readonly onUnreadChanged: Event<string> = this.onUnreadChangedEmitter.event;
+    protected _sessionsWidgetAttached = false;
 
     protected _markdownRenderer: MarkdownRenderer | undefined;
     protected get markdownRenderer(): MarkdownRenderer {
@@ -166,48 +80,47 @@ export class ChatSessionsWelcomeMessageProvider implements ChatWelcomeMessagePro
         return this._markdownRenderer;
     }
 
-    /** Persisted sessions index sorted newest first. May include duplicates of active sessions. */
-    protected _persistedSessions: ChatSessionMetadata[] = [];
-
     protected readonly onStateChangedEmitter = new Emitter<void>();
     readonly onStateChanged: Event<void> = this.onStateChangedEmitter.event;
 
     @postConstruct()
     protected init(): void {
-        for (const session of this.chatService.getSessions()) {
-            this.watchSession(session);
-        }
-
-        this.chatService.onSessionEvent(event => {
-            if (event.type === 'created') {
-                const s = this.chatService.getSession(event.sessionId);
-                if (s) {
-                    this.watchSession(s);
-                }
-            } else if (event.type === 'activeChange' && event.sessionId) {
-                this.markSessionRead(event.sessionId);
-            } else if (event.type === 'deleted') {
-                this.unwatchSession(event.sessionId);
-            }
-            // `loadSessions` fires `onStateChangedEmitter` once the (re)load settles, so we don't
-            // fire it again here: a single session event should trigger a single re-render.
-            this.loadSessions();
+        this.sessionListService.onStateChanged(() => {
+            this.onStateChangedEmitter.fire();
         });
 
-        this.loadSessions();
         this.updateInputEnabled();
         this.languageModelRegistry.onChange(() => {
             this.updateInputEnabled();
         });
         this.preferenceService.onPreferenceChanged(e => {
-            if (e.preferenceName === PERSISTED_SESSION_LIMIT_PREF || e.preferenceName === SESSION_STORAGE_PREF) {
-                this.loadSessions();
-            } else if (e.preferenceName === BYPASS_MODEL_REQUIREMENT_PREF) {
+            if (e.preferenceName === BYPASS_MODEL_REQUIREMENT_PREF) {
                 this.updateInputEnabled();
             } else if (e.preferenceName === WELCOME_SCREEN_SESSIONS_PREF) {
                 this.onStateChangedEmitter.fire();
             }
         });
+
+        this._sessionsWidgetAttached = this.isSessionsWidgetAttached();
+        this.shell.onDidAddWidget(widget => {
+            if (widget.id === AISessionsWidget.ID) {
+                this._sessionsWidgetAttached = true;
+                this.onStateChangedEmitter.fire();
+            }
+        });
+        this.shell.onDidRemoveWidget(widget => {
+            if (widget.id === AISessionsWidget.ID) {
+                this._sessionsWidgetAttached = false;
+                this.onStateChangedEmitter.fire();
+            }
+        });
+    }
+
+    protected isSessionsWidgetAttached(): boolean {
+        const areas: ApplicationShell.Area[] = ['left', 'right', 'main', 'bottom'];
+        return areas.some(area =>
+            this.shell.getWidgets(area).some(w => w.id === AISessionsWidget.ID && !w.isDisposed)
+        );
     }
 
     protected async updateInputEnabled(): Promise<void> {
@@ -221,138 +134,16 @@ export class ChatSessionsWelcomeMessageProvider implements ChatWelcomeMessagePro
         }
     }
 
-    protected async loadSessions(): Promise<void> {
-        if (!this.isPersistenceEnabled()) {
-            this._persistedSessions = [];
-            this.onStateChangedEmitter.fire();
-            return;
-        }
-
-        const hasSessions = await this.chatService.hasPersistedSessions();
-        if (!hasSessions) {
-            this._persistedSessions = [];
-            this.onStateChangedEmitter.fire();
-            return;
-        }
-
-        try {
-            const index = await this.chatService.getPersistedSessions();
-            this._persistedSessions = Object.values(index)
-                .toSorted((a, b) => b.saveDate - a.saveDate);
-        } catch (error) {
-            console.error('Failed to load persisted sessions:', error);
-            this._persistedSessions = [];
-        } finally {
-            // Fire once after the load settles; the data was stale until now anyway.
-            this.onStateChangedEmitter.fire();
-        }
-    }
-
-    protected isPersistenceEnabled(): boolean {
-        const limit = this.preferenceService.get<number>(PERSISTED_SESSION_LIMIT_PREF, 25);
-        return limit !== 0;
-    }
-
-    isUnread(sessionId: string): boolean {
-        return this.unreadSessions.get(sessionId)?.unread === true;
-    }
-
-    protected watchSession(session: ChatSession): void {
-        if (this.unreadSessions.has(session.id)) {
-            return;
-        }
-        const reqs = session.model.getRequests();
-        const state = {
-            unread: false,
-            seenRequests: reqs.length,
-            seenCompleted: this.countCompleted(reqs),
-            listener: new DisposableCollection()
-        };
-        this.unreadSessions.set(session.id, state);
-
-        session.model.onDidChange(() => {
-            const current = session.model.getRequests();
-            if (current.length > state.seenRequests || this.countCompleted(current) > state.seenCompleted) {
-                // Only silently update the seen counts (instead of flashing the unread badge)
-                // when the user is actually looking at this session: it must be the active
-                // session AND the chat view must currently be the focused widget. Otherwise,
-                // the user may have switched away (e.g. to the editor) while the chat agent
-                // is still running, and we want the badge to appear so they notice the new
-                // response when they return.
-                const activeSession = this.chatService.getActiveSession();
-                const chatViewFocused = ChatViewWidget.findActive(this.shell) !== undefined;
-                if (chatViewFocused && activeSession && activeSession.id === session.id) {
-                    state.seenRequests = current.length;
-                    state.seenCompleted = this.countCompleted(current);
-                } else if (!state.unread) {
-                    state.unread = true;
-                    this.onUnreadChangedEmitter.fire(session.id);
-                }
-            }
-        }, undefined, state.listener);
-    }
-
-    protected markSessionRead(sessionId: string): void {
-        const state = this.unreadSessions.get(sessionId);
-        if (!state) {
-            return;
-        }
-        const session = this.chatService.getSession(sessionId);
-        const reqs = session?.model.getRequests() ?? [];
-        state.seenRequests = reqs.length;
-        state.seenCompleted = this.countCompleted(reqs);
-        if (state.unread) {
-            state.unread = false;
-            this.onUnreadChangedEmitter.fire(sessionId);
-        }
-    }
-
-    protected unwatchSession(sessionId: string): void {
-        const state = this.unreadSessions.get(sessionId);
-        if (state) {
-            state.listener.dispose();
-            this.unreadSessions.delete(sessionId);
-        }
-    }
-
-    private countCompleted(reqs: ReturnType<ChatSession['model']['getRequests']>): number {
-        return reqs.filter(r => r.response.isComplete).length;
-    }
-
-    /**
-     * Splits sessions into active vs. restored. Active sessions are sourced from
-     * `chatService.getSessions()` (in-memory). Restored sessions are the persisted index entries
-     * that aren't already loaded as an active session.
-     */
-    protected getSections(): SectionedSessions {
-        const activeRaw = this.chatService.getSessions().filter(s => !!s.title);
-        const activeIds = new Set(activeRaw.map(s => s.id));
-        const active: ChatSessionMetadata[] = activeRaw
-            .toSorted((a, b) => (b.lastInteraction?.getTime() ?? 0) - (a.lastInteraction?.getTime() ?? 0))
-            .map(session => {
-                const lastReq = session.model.getRequests().at(-1);
-                const hasError = lastReq?.response.isComplete === true && lastReq?.response.isError === true;
-                return {
-                    sessionId: session.id,
-                    title: session.title!,
-                    saveDate: session.lastInteraction?.getTime() ?? Date.now(),
-                    location: session.model.location,
-                    pinnedAgentId: session.pinnedAgent?.id,
-                    hasError
-                };
-            });
-        const restored = this._persistedSessions.filter(metadata => !activeIds.has(metadata.sessionId));
-        return { active, restored };
-    }
-
     renderWelcomeMessage(): React.ReactNode {
+        if (this._sessionsWidgetAttached) {
+            return undefined;
+        }
         if (!this._inputEnabled) {
             return undefined;
         }
-        const sections = this.getSections();
+        const sections = this.sessionListService.getSections();
         const sessionCount = sections.active.length + sections.restored.length;
-        if (!this.isPersistenceEnabled() || sessionCount === 0) {
-            // Empty state: let other providers (IDE welcome) show their onboarding content.
+        if (!this.sessionListService.isPersistenceEnabled() || sessionCount === 0) {
             return undefined;
         }
         return this.renderSessionsSection(sections);
@@ -360,13 +151,15 @@ export class ChatSessionsWelcomeMessageProvider implements ChatWelcomeMessagePro
 
     protected renderSessionsSection(sections: SectionedSessions): React.ReactNode {
         const maxSessions = this.preferenceService.get<number>(WELCOME_SCREEN_SESSIONS_PREF, 20);
+        const rows = this.sessionListService.buildRows(sections);
+
         return (
             <div className="theia-WelcomeMessage" key="sessions-section">
                 <div className="theia-WelcomeMessage-SessionsSection">
                     <SessionsList
-                        sections={sections}
+                        rows={rows}
                         maxSessions={maxSessions}
-                        renderItem={this.renderSessionItem}
+                        renderRow={this.renderSessionRow}
                         onBrowseAll={this.handleBrowseAllChats}
                     />
                 </div>
@@ -374,29 +167,46 @@ export class ChatSessionsWelcomeMessageProvider implements ChatWelcomeMessagePro
         );
     }
 
-    protected renderSessionItem = (session: ChatSessionMetadata, isRestored: boolean): React.ReactNode => {
-        const actions = this.chatSessionItemActionContributions
+    protected getSessionActions(session: ChatSessionMetadata): ChatSessionItemAction[] {
+        return this.chatSessionItemActionContributions
             .getContributions()
             .flatMap(c => c.getActions(session))
             .filter(action => this.commandRegistry.isEnabled(action.commandId, session))
             .sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+    }
+
+    protected renderSessionRow = (row: SessionRow): React.ReactNode => this.renderSessionRowAtDepth(row, 0);
+
+    protected renderSessionRowAtDepth(row: SessionRow, depth: number): React.ReactNode {
+        const hasChildSessions = row.childSessions.length > 0;
+        const isExpanded = hasChildSessions && this.sessionListService.isExpanded(row.session.sessionId);
+        const descendantNeedsAttention = this.sessionListService.descendantRequiresAction(row);
+
         return (
-            <ChatSessionItem
-                key={session.sessionId}
-                session={session}
-                isRestored={isRestored}
-                chatService={this.chatService}
-                chatAgentService={this.chatAgentService}
-                hoverService={this.hoverService}
-                markdownRenderer={this.markdownRenderer}
-                unreadState={this}
-                onClick={() => this.handleSessionItemClick(session.sessionId)}
-                actions={actions}
-                onAction={this.handleSessionItemAction}
-                formatTimeAgo={date => formatTimeAgo(date)}
-            />
+            <React.Fragment key={row.session.sessionId}>
+                <ChatSessionItem
+                    session={row.session}
+                    isRestored={row.isRestored}
+                    chatService={this.chatService}
+                    chatAgentService={this.chatAgentService}
+                    hoverService={this.hoverService}
+                    markdownRenderer={this.markdownRenderer}
+                    unreadState={this.sessionListService}
+                    onClick={() => this.handleSessionItemClick(row.session.sessionId)}
+                    actions={this.getSessionActions(row.session)}
+                    onAction={this.handleSessionItemAction}
+                    formatTimeAgo={date => formatTimeAgo(date)}
+                    hasChildSessions={hasChildSessions}
+                    isChildSession={depth > 0}
+                    depth={depth}
+                    isExpanded={isExpanded}
+                    descendantNeedsAttention={descendantNeedsAttention}
+                    onToggleExpand={hasChildSessions ? () => this.sessionListService.toggleExpand(row.session.sessionId) : undefined}
+                />
+                {isExpanded && row.childSessions.map(child => this.renderSessionRowAtDepth(child, depth + 1))}
+            </React.Fragment>
         );
-    };
+    }
 
     protected handleSessionItemAction = (action: ChatSessionItemAction, session: ChatSessionMetadata): void => {
         this.commandRegistry.executeCommand(action.commandId, session);

package/src/browser/context-file-validation-service-impl.spec.ts

@@ -28,7 +28,7 @@ import { FileStat } from '@theia/filesystem/lib/common/files';
 import { ContextFileValidationService, FileValidationState } from '@theia/ai-chat/lib/browser/context-file-validation-service';
 import { ContextFileValidationServiceImpl } from './context-file-validation-service-impl';
 import { WorkspaceFunctionScope } from './workspace-functions';
-import { TrustAwarePreferenceReader } from '@theia/ai-core/lib/browser/trust-aware-preference-reader';
+import { AiConfigurationService } from '@theia/ai-core';
 import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 
 disableJSDOM();
@@ -113,11 +113,11 @@ describe('ContextFileValidationService', () => {
         container.bind(FileService).toConstantValue(mockFileService);
         container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
         container.bind(PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(TrustAwarePreferenceReader).toConstantValue({
+        container.bind(AiConfigurationService).toConstantValue({
             get: <T>(_name: string, fallback?: T) => fallback,
             ready: Promise.resolve(),
             onDidChangeTrust: () => ({ dispose: () => { /* noop */ } })
-        } as unknown as TrustAwarePreferenceReader);
+        } as unknown as AiConfigurationService);
         container.bind(EnvVariablesServer).toConstantValue({
             getHomeDirUri: async () => 'file:///home/user',
             getExecPath: async () => '',

package/src/browser/frontend-module.ts

@@ -80,6 +80,8 @@ import { ChatWelcomeMessageProvider } from '@theia/ai-chat-ui/lib/browser/chat-t
 import { IdeChatWelcomeMessageProvider } from './ide-chat-welcome-message-provider';
 import { ChatSessionsWelcomeMessageProvider } from './chat-sessions-welcome-message-provider';
 import { ChatSessionItemActionContribution, DefaultChatSessionItemActionContribution } from './chat-session-item-action-contribution';
+import { AiAllowAllModeChatBanner } from './ai-allow-all-mode-chat-banner';
+import { ChatBannerProvider } from '@theia/ai-chat-ui/lib/browser/chat-banner-provider';
 import { DefaultChatAgentRecommendationService } from './default-chat-agent-recommendation-service';
 import { AITokenUsageConfigurationWidget } from './ai-configuration/token-usage-configuration-widget';
 import { AISkillsConfigurationWidget } from './ai-configuration/skills-configuration-widget';
@@ -125,6 +127,11 @@ import { CodeReviewerAgent } from './code-reviewer-agent';
 import { CodeReviewCapabilityContribution } from './code-review-capability-contribution';
 import { PRReviewAgent } from './review/pr-review-agent';
 import { PRReviewCapabilityContribution } from './review/pr-review-capability-contribution';
+import { PerspectiveContribution } from '@theia/core/lib/browser/perspective-service';
+import { AIFirstPerspectiveContribution } from './ai-first-perspective-contribution';
+import { ChatSessionListService } from './chat-session-list-service';
+import { AISessionsWidget } from './ai-sessions-widget';
+import { AISessionsViewContribution } from './ai-sessions-view-contribution';
 
 export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
     bind(PreferenceContribution).toConstantValue({ schema: aiIdePreferenceSchema });
@@ -192,8 +199,11 @@ export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
     bind(Agent).toService(PRReviewAgent);
     bind(ChatAgent).toService(PRReviewAgent);
 
+    bind(ChatSessionListService).toSelf().inSingletonScope();
+
     bind(ChatWelcomeMessageProvider).to(IdeChatWelcomeMessageProvider).inSingletonScope();
     bind(ChatWelcomeMessageProvider).to(ChatSessionsWelcomeMessageProvider).inSingletonScope();
+    bind(ChatBannerProvider).to(AiAllowAllModeChatBanner).inSingletonScope();
     bindRootContributionProvider(bind, ChatSessionItemActionContribution);
     bind(DefaultChatSessionItemActionContribution).toSelf().inSingletonScope();
     bind(ChatSessionItemActionContribution).toService(DefaultChatSessionItemActionContribution);
@@ -350,4 +360,17 @@ export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
 
     bind(FrontendApplicationContribution).to(CodeReviewCapabilityContribution);
     bind(FrontendApplicationContribution).to(PRReviewCapabilityContribution);
+
+    bind(AIFirstPerspectiveContribution).toSelf().inSingletonScope();
+    bind(PerspectiveContribution).toService(AIFirstPerspectiveContribution);
+
+    bind(AISessionsWidget).toSelf();
+    bind(WidgetFactory)
+        .toDynamicValue(ctx => ({
+            id: AISessionsWidget.ID,
+            createWidget: () => ctx.container.get(AISessionsWidget)
+        }))
+        .inSingletonScope();
+    bindViewContribution(bind, AISessionsViewContribution);
+    bind(TabBarToolbarContribution).toService(AISessionsViewContribution);
 });