tabby-ai-assistant 1.0.5 → 1.0.7

package/src/services/chat/ai-sidebar.service.ts

@@ -0,0 +1,258 @@
+import { Injectable, ComponentFactoryResolver, ApplicationRef, Injector, EmbeddedViewRef, ComponentRef } from '@angular/core';
+import { ConfigService } from 'tabby-core';
+import { AiSidebarComponent } from '../../components/chat/ai-sidebar.component';
+
+/**
+ * AI Sidebar 配置接口
+ */
+export interface AiSidebarConfig {
+    enabled?: boolean;
+    position?: 'left' | 'right';
+    showInToolbar?: boolean;
+    sidebarVisible?: boolean;
+    sidebarCollapsed?: boolean;
+}
+
+/**
+ * AI Sidebar 服务 - 管理 AI 聊天侧边栏的生命周期
+ * 
+ * 采用 Flexbox 布局方式，将 sidebar 插入到 app-root 作为第一个子元素，
+ * app-root 变为水平 flex 容器，sidebar 在左侧
+ */
+@Injectable({ providedIn: 'root' })
+export class AiSidebarService {
+    private sidebarComponentRef: ComponentRef<AiSidebarComponent> | null = null;
+    private sidebarElement: HTMLElement | null = null;
+    private styleElement: HTMLStyleElement | null = null;
+    private _isVisible = false;
+    private readonly SIDEBAR_WIDTH = 320;
+
+    /**
+     * 侧边栏是否可见
+     */
+    get sidebarVisible(): boolean {
+        return this._isVisible;
+    }
+
+    constructor(
+        private componentFactoryResolver: ComponentFactoryResolver,
+        private appRef: ApplicationRef,
+        private injector: Injector,
+        private config: ConfigService,
+    ) { }
+
+    /**
+     * 显示 sidebar
+     */
+    show(): void {
+        if (this._isVisible) {
+            return;
+        }
+
+        this.createSidebar();
+
+        const pluginConfig = this.getPluginConfig();
+        pluginConfig.sidebarVisible = true;
+        this.savePluginConfig(pluginConfig);
+
+        this._isVisible = true;
+    }
+
+    /**
+     * 隐藏 sidebar
+     */
+    hide(): void {
+        if (!this._isVisible) {
+            return;
+        }
+
+        this.destroySidebar();
+
+        const pluginConfig = this.getPluginConfig();
+        pluginConfig.sidebarVisible = false;
+        this.savePluginConfig(pluginConfig);
+
+        this._isVisible = false;
+    }
+
+    /**
+     * 切换 sidebar 显示状态
+     */
+    toggle(): void {
+        if (this._isVisible) {
+            this.hide();
+        } else {
+            this.show();
+        }
+    }
+
+    /**
+     * 获取当前显示状态
+     */
+    get visible(): boolean {
+        return this._isVisible;
+    }
+
+    /**
+     * 初始化 - 应用启动时调用
+     */
+    initialize(): void {
+        const pluginConfig = this.getPluginConfig();
+        // 默认显示 sidebar，除非明确设置为隐藏
+        if (pluginConfig.sidebarVisible !== false) {
+            this.show();
+        }
+    }
+
+    /**
+     * 创建 sidebar 组件
+     * 
+     * 使用固定定位方案：
+     * 1. 侧边栏 position: fixed，固定在左侧
+     * 2. 主内容区通过 margin-left 推开
+     * 这样不改变任何现有元素的 flex 布局
+     */
+    private createSidebar(): void {
+        // 创建组件
+        const componentFactory = this.componentFactoryResolver.resolveComponentFactory(AiSidebarComponent);
+        this.sidebarComponentRef = componentFactory.create(this.injector);
+
+        // 附加到应用
+        this.appRef.attachView(this.sidebarComponentRef.hostView);
+
+        // 获取 DOM 元素
+        const domElem = (this.sidebarComponentRef.hostView as EmbeddedViewRef<any>).rootNodes[0] as HTMLElement;
+
+        // 创建 wrapper 元素 - 使用固定定位
+        const wrapper = document.createElement('div');
+        wrapper.className = 'ai-sidebar-wrapper';
+        wrapper.style.cssText = `
+            position: fixed;
+            left: 0;
+            top: 0;
+            width: ${this.SIDEBAR_WIDTH}px;
+            height: 100%;
+            display: flex;
+            flex-direction: column;
+            background: var(--bs-body-bg, #1e1e1e);
+            border-right: 1px solid var(--bs-border-color, #333);
+            box-shadow: 2px 0 10px rgba(0,0,0,0.3);
+            z-index: 1000;
+        `;
+
+        wrapper.appendChild(domElem);
+
+        // 插入到 body
+        document.body.appendChild(wrapper);
+
+        this.sidebarElement = wrapper;
+
+        // 注入布局 CSS - 只添加 margin-left 把主内容推开
+        this.injectLayoutCSS();
+
+        // 注入服务引用到组件
+        if (this.sidebarComponentRef) {
+            const component = this.sidebarComponentRef.instance;
+            component.sidebarService = this;
+        }
+    }
+
+    /**
+     * 销毁 sidebar 组件
+     */
+    private destroySidebar(): void {
+        // 移除注入的 CSS
+        this.removeLayoutCSS();
+
+        if (this.sidebarComponentRef) {
+            this.appRef.detachView(this.sidebarComponentRef.hostView);
+            this.sidebarComponentRef.destroy();
+            this.sidebarComponentRef = null;
+        }
+
+        if (this.sidebarElement) {
+            this.sidebarElement.remove();
+            this.sidebarElement = null;
+        }
+    }
+
+    /**
+     * 调整 .content 元素样式 - 只处理第二个（更深层的）.content
+     */
+    private adjustContentStyles(appRoot: Element, apply: boolean): void {
+        const contentElements = appRoot.querySelectorAll('.content');
+
+        if (contentElements.length > 1) {
+            // 选择第二个（更深层的）.content 元素，这是 Tabby 的主内容区
+            const contentElement = contentElements[1] as HTMLElement;
+            if (apply) {
+                contentElement.style.width = 'auto';
+                contentElement.style.flex = '1 1 auto';
+                contentElement.style.minWidth = '0';
+            } else {
+                contentElement.style.removeProperty('width');
+                contentElement.style.removeProperty('flex');
+                contentElement.style.removeProperty('min-width');
+            }
+        } else if (contentElements.length === 1) {
+            // 如果只有一个 .content，则处理它
+            const contentElement = contentElements[0] as HTMLElement;
+            if (apply) {
+                contentElement.style.width = 'auto';
+                contentElement.style.flex = '1 1 auto';
+                contentElement.style.minWidth = '0';
+            } else {
+                contentElement.style.removeProperty('width');
+                contentElement.style.removeProperty('flex');
+                contentElement.style.removeProperty('min-width');
+            }
+        }
+    }
+
+    /**
+     * 注入布局 CSS - 使用 margin-left 把主内容推开
+     * 
+     * 固定定位方案：侧边栏 fixed，主内容区 margin-left
+     */
+    private injectLayoutCSS(): void {
+        const style = document.createElement('style');
+        style.id = 'ai-sidebar-layout-css';
+        style.textContent = `
+            /* 用 margin-left 把 app-root 推开，为侧边栏腾出空间 */
+            app-root {
+                margin-left: ${this.SIDEBAR_WIDTH}px !important;
+            }
+        `;
+
+        document.head.appendChild(style);
+        this.styleElement = style;
+    }
+
+    /**
+     * 移除布局 CSS
+     */
+    private removeLayoutCSS(): void {
+        if (this.styleElement) {
+            this.styleElement.remove();
+            this.styleElement = null;
+        }
+    }
+
+    /**
+     * 获取插件配置
+     */
+    private getPluginConfig(): AiSidebarConfig {
+        return this.config.store.pluginConfig?.['ai-assistant'] || {};
+    }
+
+    /**
+     * 保存插件配置
+     */
+    private savePluginConfig(pluginConfig: AiSidebarConfig): void {
+        if (!this.config.store.pluginConfig) {
+            this.config.store.pluginConfig = {};
+        }
+        this.config.store.pluginConfig['ai-assistant'] = pluginConfig;
+        this.config.save();
+    }
+}

package/src/services/chat/chat-history.service.ts

@@ -10,6 +10,23 @@ export interface SavedSession {
     createdAt: Date;
     updatedAt: Date;
     messageCount: number;
+    // 上下文工程相关字段
+    contextInfo?: {
+        tokenUsage?: {
+            input: number;
+            output: number;
+            cacheRead: number;
+            cacheWrite: number;
+        };
+        compactionHistory?: Array<{
+            timestamp: Date;
+            type: 'prune' | 'compact' | 'truncate';
+            tokensSaved: number;
+            condenseId?: string;
+        }>;
+        hasCompression?: boolean;
+        lastCompactionAt?: Date;
+    };
 }
 
 const STORAGE_KEY = 'tabby-ai-assistant-chat-history';
@@ -236,4 +253,295 @@ export class ChatHistoryService {
         // 保留最近的messages
         return messages.slice(-MAX_MESSAGES_PER_SESSION);
     }
+
+    /**
+     * 更新会话的上下文信息（压缩标记支持）
+     */
+    updateContextInfo(sessionId: string, contextInfo: SavedSession['contextInfo']): void {
+        const sessions = this.sessionsSubject.value;
+        const existingIndex = sessions.findIndex(s => s.sessionId === sessionId);
+
+        if (existingIndex >= 0) {
+            sessions[existingIndex] = {
+                ...sessions[existingIndex],
+                contextInfo
+            };
+            this.sessionsSubject.next([...sessions]);
+            this.saveToStorage(sessions);
+            this.logger.info('Context info updated', { sessionId });
+        }
+    }
+
+    /**
+     * 导出会话（包含压缩状态）
+     */
+    exportSessionWithContext(sessionId: string): string | undefined {
+        const session = this.loadSession(sessionId);
+        if (!session) {
+            return undefined;
+        }
+
+        const exportData = {
+            exportDate: new Date().toISOString(),
+            version: '2.0',
+            session: {
+                ...session,
+                contextInfo: session.contextInfo || {}
+            }
+        };
+        return JSON.stringify(exportData, null, 2);
+    }
+
+    /**
+     * 导出会话历史（包含所有压缩状态）
+     */
+    exportAllHistoryWithContext(): string {
+        const sessions = this.sessionsSubject.value;
+        const exportData = {
+            exportDate: new Date().toISOString(),
+            version: '2.0',
+            sessions: sessions.map(s => ({
+                ...s,
+                contextInfo: s.contextInfo || {}
+            }))
+        };
+        return JSON.stringify(exportData, null, 2);
+    }
+
+    /**
+     * 导入会话（包含压缩状态）
+     */
+    importSessionWithContext(data: string): void {
+        try {
+            const importData = JSON.parse(data);
+
+            if (!importData.session && !importData.sessions) {
+                throw new Error('Invalid session format');
+            }
+
+            const sessions = this.sessionsSubject.value;
+
+            if (importData.session) {
+                // 导入单个会话
+                const session = importData.session;
+                const existingIndex = sessions.findIndex(s => s.sessionId === session.sessionId);
+
+                const processedSession = {
+                    ...session,
+                    createdAt: new Date(session.createdAt),
+                    updatedAt: new Date(session.updatedAt),
+                    contextInfo: session.contextInfo || undefined
+                };
+
+                if (existingIndex >= 0) {
+                    sessions[existingIndex] = processedSession;
+                } else {
+                    sessions.unshift(processedSession);
+                }
+            } else if (importData.sessions) {
+                // 批量导入会话
+                const importedSessions = importData.sessions.map((s: any) => ({
+                    ...s,
+                    createdAt: new Date(s.createdAt),
+                    updatedAt: new Date(s.updatedAt),
+                    contextInfo: s.contextInfo || undefined
+                }));
+
+                // 合并现有会话，避免重复
+                const mergedSessions = [...sessions];
+                importedSessions.forEach(imported => {
+                    const existingIndex = mergedSessions.findIndex(s => s.sessionId === imported.sessionId);
+                    if (existingIndex >= 0) {
+                        mergedSessions[existingIndex] = imported;
+                    } else {
+                        mergedSessions.unshift(imported);
+                    }
+                });
+
+                // 限制会话数量
+                this.sessionsSubject.next(mergedSessions.slice(0, MAX_SESSIONS));
+                this.saveToStorage(mergedSessions.slice(0, MAX_SESSIONS));
+            }
+
+            this.logger.info('Session(s) with context imported successfully');
+        } catch (error) {
+            this.logger.error('Failed to import session with context', error);
+            throw new Error('Invalid session file format');
+        }
+    }
+
+    /**
+     * 清理压缩数据
+     */
+    cleanupCompressedData(sessionId?: string): void {
+        const sessions = this.sessionsSubject.value;
+
+        if (sessionId) {
+            // 清理指定会话的压缩数据
+            const sessionIndex = sessions.findIndex(s => s.sessionId === sessionId);
+            if (sessionIndex >= 0 && sessions[sessionIndex].contextInfo) {
+                sessions[sessionIndex] = {
+                    ...sessions[sessionIndex],
+                    contextInfo: undefined
+                };
+                this.sessionsSubject.next([...sessions]);
+                this.saveToStorage(sessions);
+                this.logger.info('Compressed data cleaned for session', { sessionId });
+            }
+        } else {
+            // 清理所有会话的压缩数据
+            sessions.forEach(session => {
+                if (session.contextInfo) {
+                    session.contextInfo = undefined;
+                }
+            });
+            this.sessionsSubject.next([...sessions]);
+            this.saveToStorage(sessions);
+            this.logger.info('All compressed data cleaned');
+        }
+    }
+
+    /**
+     * 获取压缩统计信息
+     */
+    getCompressionStatistics(): {
+        totalSessions: number;
+        sessionsWithCompression: number;
+        totalTokensSaved: number;
+        averageTokensSaved: number;
+        lastCompactionAt?: Date;
+        compactionHistory: Array<{
+            sessionId: string;
+            type: 'prune' | 'compact' | 'truncate';
+            timestamp: Date;
+            tokensSaved: number;
+        }>;
+    } {
+        const sessions = this.sessionsSubject.value;
+        const sessionsWithCompression = sessions.filter(s => s.contextInfo?.hasCompression);
+        let totalTokensSaved = 0;
+        const allCompactionEvents: Array<{
+            sessionId: string;
+            type: 'prune' | 'compact' | 'truncate';
+            timestamp: Date;
+            tokensSaved: number;
+        }> = [];
+        let lastCompactionAt: Date | undefined;
+
+        sessionsWithCompression.forEach(session => {
+            if (session.contextInfo?.compactionHistory) {
+                session.contextInfo.compactionHistory.forEach(event => {
+                    totalTokensSaved += event.tokensSaved;
+                    allCompactionEvents.push({
+                        sessionId: session.sessionId,
+                        type: event.type,
+                        timestamp: event.timestamp,
+                        tokensSaved: event.tokensSaved
+                    });
+
+                    if (!lastCompactionAt || event.timestamp > lastCompactionAt) {
+                        lastCompactionAt = event.timestamp;
+                    }
+                });
+            }
+        });
+
+        return {
+            totalSessions: sessions.length,
+            sessionsWithCompression: sessionsWithCompression.length,
+            totalTokensSaved,
+            averageTokensSaved: sessionsWithCompression.length > 0
+                ? Math.round(totalTokensSaved / sessionsWithCompression.length)
+                : 0,
+            lastCompactionAt,
+            compactionHistory: allCompactionEvents
+        };
+    }
+
+    /**
+     * 记录压缩事件
+     */
+    recordCompactionEvent(
+        sessionId: string,
+        type: 'prune' | 'compact' | 'truncate',
+        tokensSaved: number,
+        condenseId?: string
+    ): void {
+        const sessions = this.sessionsSubject.value;
+        const sessionIndex = sessions.findIndex(s => s.sessionId === sessionId);
+
+        if (sessionIndex >= 0) {
+            const session = sessions[sessionIndex];
+            const contextInfo = session.contextInfo || {};
+
+            const compactionHistory = contextInfo.compactionHistory || [];
+            compactionHistory.push({
+                timestamp: new Date(),
+                type,
+                tokensSaved,
+                condenseId
+            });
+
+            sessions[sessionIndex] = {
+                ...session,
+                contextInfo: {
+                    ...contextInfo,
+                    hasCompression: true,
+                    lastCompactionAt: new Date(),
+                    compactionHistory
+                }
+            };
+
+            this.sessionsSubject.next([...sessions]);
+            this.saveToStorage(sessions);
+            this.logger.info('Compaction event recorded', { sessionId, type, tokensSaved });
+        }
+    }
+
+    /**
+     * 检查会话是否有压缩标记
+     */
+    hasCompressionMarkers(sessionId: string): boolean {
+        const session = this.loadSession(sessionId);
+        return session?.contextInfo?.hasCompression || false;
+    }
+
+    /**
+     * 获取会话的压缩历史
+     */
+    getCompactionHistory(sessionId: string): Array<{
+        timestamp: Date;
+        type: 'prune' | 'compact' | 'truncate';
+        tokensSaved: number;
+        condenseId?: string;
+    }> {
+        const session = this.loadSession(sessionId);
+        return session?.contextInfo?.compactionHistory || [];
+    }
+
+    /**
+     * 更新Token使用统计
+     */
+    updateTokenUsage(sessionId: string, tokenUsage?: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    }): void {
+        const sessions = this.sessionsSubject.value;
+        const sessionIndex = sessions.findIndex(s => s.sessionId === sessionId);
+
+        if (sessionIndex >= 0) {
+            const session = sessions[sessionIndex];
+            sessions[sessionIndex] = {
+                ...session,
+                contextInfo: {
+                    ...session.contextInfo,
+                    tokenUsage
+                }
+            };
+            this.sessionsSubject.next([...sessions]);
+            this.saveToStorage(sessions);
+        }
+    }
 }