tabby-ai-assistant 1.0.5 → 1.0.6

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

@@ -0,0 +1,239 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ChatMessage } from '../../types/ai.types';
+import { LoggerService } from '../core/logger.service';
+
+export interface SavedSession {
+    sessionId: string;
+    title: string;
+    messages: ChatMessage[];
+    createdAt: Date;
+    updatedAt: Date;
+    messageCount: number;
+}
+
+const STORAGE_KEY = 'tabby-ai-assistant-chat-history';
+const MAX_SESSIONS = 50;
+const MAX_MESSAGES_PER_SESSION = 1000;
+
+/**
+ * 聊天历史服务
+ * 持久化存储和管理聊天会话历史
+ */
+@Injectable({
+    providedIn: 'root'
+})
+export class ChatHistoryService {
+    private sessionsSubject = new BehaviorSubject<SavedSession[]>([]);
+    public sessions$ = this.sessionsSubject.asObservable();
+
+    constructor(private logger: LoggerService) {
+        this.loadSessions();
+    }
+
+    /**
+     * 保存会话
+     */
+    saveSession(sessionId: string, messages: ChatMessage[], title?: string): void {
+        try {
+            const sessions = this.sessionsSubject.value;
+            const existingIndex = sessions.findIndex(s => s.sessionId === sessionId);
+
+            const sessionTitle = title || this.generateSessionTitle(messages);
+            const now = new Date();
+
+            const session: SavedSession = {
+                sessionId,
+                title: sessionTitle,
+                messages: this.trimMessages(messages),
+                createdAt: existingIndex >= 0 ? sessions[existingIndex].createdAt : now,
+                updatedAt: now,
+                messageCount: messages.length
+            };
+
+            if (existingIndex >= 0) {
+                sessions[existingIndex] = session;
+            } else {
+                sessions.unshift(session);
+            }
+
+            // 限制会话数量
+            const trimmedSessions = sessions.slice(0, MAX_SESSIONS);
+            this.sessionsSubject.next(trimmedSessions);
+            this.saveToStorage(trimmedSessions);
+
+            this.logger.info('Session saved', { sessionId, title: sessionTitle });
+
+        } catch (error) {
+            this.logger.error('Failed to save session', { error, sessionId });
+            throw error;
+        }
+    }
+
+    /**
+     * 加载会话
+     */
+    loadSession(sessionId: string): SavedSession | undefined {
+        const sessions = this.sessionsSubject.value;
+        return sessions.find(s => s.sessionId === sessionId);
+    }
+
+    /**
+     * 删除会话
+     */
+    deleteSession(sessionId: string): void {
+        const sessions = this.sessionsSubject.value;
+        const filteredSessions = sessions.filter(s => s.sessionId !== sessionId);
+        this.sessionsSubject.next(filteredSessions);
+        this.saveToStorage(filteredSessions);
+        this.logger.info('Session deleted', { sessionId });
+    }
+
+    /**
+     * 清空所有历史
+     */
+    clearAllHistory(): void {
+        this.sessionsSubject.next([]);
+        this.saveToStorage([]);
+        this.logger.info('All chat history cleared');
+    }
+
+    /**
+     * 搜索会话
+     */
+    searchSessions(query: string): SavedSession[] {
+        const sessions = this.sessionsSubject.value;
+        const lowercaseQuery = query.toLowerCase();
+
+        return sessions.filter(session =>
+            session.title.toLowerCase().includes(lowercaseQuery) ||
+            session.messages.some(msg =>
+                msg.content.toLowerCase().includes(lowercaseQuery)
+            )
+        );
+    }
+
+    /**
+     * 获取最近的会话
+     */
+    getRecentSessions(count: number = 10): SavedSession[] {
+        const sessions = this.sessionsSubject.value;
+        return sessions.slice(0, count);
+    }
+
+    /**
+     * 获取会话统计
+     */
+    getStatistics(): {
+        totalSessions: number;
+        totalMessages: number;
+        averageMessagesPerSession: number;
+        oldestSession?: Date;
+        newestSession?: Date;
+    } {
+        const sessions = this.sessionsSubject.value;
+        const totalSessions = sessions.length;
+        const totalMessages = sessions.reduce((sum, s) => sum + s.messageCount, 0);
+        const averageMessagesPerSession = totalSessions > 0 ? totalMessages / totalSessions : 0;
+
+        const dates = sessions.map(s => s.createdAt.getTime());
+        const oldestSession = dates.length > 0 ? new Date(Math.min(...dates)) : undefined;
+        const newestSession = dates.length > 0 ? new Date(Math.max(...dates)) : undefined;
+
+        return {
+            totalSessions,
+            totalMessages,
+            averageMessagesPerSession: Math.round(averageMessagesPerSession * 100) / 100,
+            oldestSession,
+            newestSession
+        };
+    }
+
+    /**
+     * 导出所有历史
+     */
+    exportAllHistory(): string {
+        const sessions = this.sessionsSubject.value;
+        const exportData = {
+            exportDate: new Date().toISOString(),
+            version: '1.0',
+            sessions
+        };
+        return JSON.stringify(exportData, null, 2);
+    }
+
+    /**
+     * 导入历史
+     */
+    importHistory(data: string): void {
+        try {
+            const importData = JSON.parse(data);
+
+            if (!importData.sessions || !Array.isArray(importData.sessions)) {
+                throw new Error('Invalid history format');
+            }
+
+            const sessions = importData.sessions.map((s: any) => ({
+                ...s,
+                createdAt: new Date(s.createdAt),
+                updatedAt: new Date(s.updatedAt)
+            }));
+
+            this.sessionsSubject.next(sessions);
+            this.saveToStorage(sessions);
+
+            this.logger.info('History imported', {
+                sessionCount: sessions.length
+            });
+
+        } catch (error) {
+            this.logger.error('Failed to import history', error);
+            throw new Error('Invalid history file format');
+        }
+    }
+
+    private loadSessions(): void {
+        try {
+            const stored = localStorage.getItem(STORAGE_KEY);
+            if (stored) {
+                const sessions = JSON.parse(stored).map((s: any) => ({
+                    ...s,
+                    createdAt: new Date(s.createdAt),
+                    updatedAt: new Date(s.updatedAt)
+                }));
+                this.sessionsSubject.next(sessions);
+                this.logger.info('Loaded sessions from storage', { count: sessions.length });
+            }
+        } catch (error) {
+            this.logger.error('Failed to load sessions from storage', error);
+            this.sessionsSubject.next([]);
+        }
+    }
+
+    private saveToStorage(sessions: SavedSession[]): void {
+        try {
+            localStorage.setItem(STORAGE_KEY, JSON.stringify(sessions));
+        } catch (error) {
+            this.logger.error('Failed to save sessions to storage', error);
+        }
+    }
+
+    private generateSessionTitle(messages: ChatMessage[]): string {
+        const firstUserMessage = messages.find(m => m.role === 'user');
+        if (!firstUserMessage) {
+            return `会话 ${new Date().toLocaleString()}`;
+        }
+
+        const content = firstUserMessage.content;
+        return content.length > 50 ? content.substring(0, 50) + '...' : content;
+    }
+
+    private trimMessages(messages: ChatMessage[]): ChatMessage[] {
+        if (messages.length <= MAX_MESSAGES_PER_SESSION) {
+            return messages;
+        }
+
+        // 保留最近的messages
+        return messages.slice(-MAX_MESSAGES_PER_SESSION);
+    }
+}

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

@@ -1,8 +1,9 @@
 import { Injectable } from '@angular/core';
 import { BehaviorSubject, Observable, Subject } from 'rxjs';
-import { ChatMessage, ChatRequest, ChatResponse, MessageRole } from '../../types/ai.types';
+import { ChatMessage, ChatRequest, ChatResponse, MessageRole, Checkpoint, ApiMessage } from '../../types/ai.types';
 import { AiAssistantService } from '../core/ai-assistant.service';
 import { LoggerService } from '../core/logger.service';
+import { ChatHistoryService } from './chat-history.service';
 
 /**
  * 聊天会话服务
@@ -16,15 +17,18 @@ export class ChatSessionService {
     private messagesSubject = new BehaviorSubject<ChatMessage[]>([]);
     private isTypingSubject = new BehaviorSubject<boolean>(false);
     private errorSubject = new Subject<string>();
+    private checkpointsSubject = new BehaviorSubject<Checkpoint[]>([]);
 
     public messages$ = this.messagesSubject.asObservable();
     public isTyping$ = this.isTypingSubject.asObservable();
     public error$ = this.errorSubject.asObservable();
+    public checkpoints$ = this.checkpointsSubject.asObservable();
 
     constructor(
         private aiService: AiAssistantService,
-        private logger: LoggerService
-    ) {}
+        private logger: LoggerService,
+        private chatHistoryService: ChatHistoryService
+    ) { }
 
     /**
      * 创建新会话
@@ -177,4 +181,273 @@ export class ChatSessionService {
     private generateMessageId(): string {
         return `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
     }
+
+    // ==================== 检查点管理功能 ====================
+
+    /**
+     * 创建检查点
+     */
+    createCheckpoint(label?: string): Checkpoint {
+        if (!this.currentSessionId) {
+            throw new Error('No active session');
+        }
+
+        const checkpointId = this.generateCheckpointId();
+        const currentMessages = this.messagesSubject.value;
+        const apiMessages: ApiMessage[] = currentMessages.map(msg => ({
+            role: msg.role,
+            content: msg.content,
+            ts: msg.timestamp.getTime()
+        }));
+
+        // 计算Token使用量
+        const tokenUsage = {
+            input: this.calculateInputTokens(apiMessages),
+            output: this.calculateOutputTokens(apiMessages),
+            cacheRead: 0,
+            cacheWrite: 0
+        };
+
+        // 生成摘要
+        const summary = label || this.generateCheckpointSummary(currentMessages);
+
+        const checkpoint: Checkpoint = {
+            id: checkpointId,
+            sessionId: this.currentSessionId,
+            messages: apiMessages,
+            summary,
+            createdAt: Date.now(),
+            tokenUsage
+        };
+
+        // 保存到会话历史（保留现有contextInfo）
+        const existingContextInfo = this.chatHistoryService.loadSession(this.currentSessionId)?.contextInfo;
+        this.chatHistoryService.updateContextInfo(this.currentSessionId, {
+            ...existingContextInfo
+        });
+
+        // 更新本地检查点列表
+        const currentCheckpoints = this.checkpointsSubject.value;
+        this.checkpointsSubject.next([...currentCheckpoints, checkpoint]);
+
+        this.logger.info('Checkpoint created', {
+            checkpointId,
+            sessionId: this.currentSessionId,
+            messageCount: currentMessages.length
+        });
+
+        return checkpoint;
+    }
+
+    /**
+     * 恢复检查点
+     */
+    restoreCheckpoint(checkpointId: string): void {
+        const checkpoint = this.getCheckpoint(checkpointId);
+        if (!checkpoint) {
+            throw new Error(`Checkpoint not found: ${checkpointId}`);
+        }
+
+        if (checkpoint.sessionId !== this.currentSessionId) {
+            throw new Error('Checkpoint belongs to different session');
+        }
+
+        // 恢复消息
+        const restoredMessages: ChatMessage[] = checkpoint.messages.map(msg => ({
+            id: this.generateMessageId(),
+            role: msg.role as any,
+            content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+            timestamp: new Date(msg.ts)
+        }));
+
+        this.messagesSubject.next(restoredMessages);
+
+        this.logger.info('Checkpoint restored', {
+            checkpointId,
+            sessionId: this.currentSessionId,
+            messageCount: restoredMessages.length
+        });
+    }
+
+    /**
+     * 删除检查点
+     */
+    deleteCheckpoint(checkpointId: string): void {
+        const currentCheckpoints = this.checkpointsSubject.value;
+        const filteredCheckpoints = currentCheckpoints.filter(cp => cp.id !== checkpointId);
+
+        this.checkpointsSubject.next(filteredCheckpoints);
+
+        this.logger.info('Checkpoint deleted', { checkpointId, sessionId: this.currentSessionId });
+    }
+
+    /**
+     * 获取指定检查点
+     */
+    getCheckpoint(checkpointId: string): Checkpoint | undefined {
+        return this.checkpointsSubject.value.find(cp => cp.id === checkpointId);
+    }
+
+    /**
+     * 列出所有检查点
+     */
+    listCheckpoints(sessionId?: string): Checkpoint[] {
+        const allCheckpoints = this.checkpointsSubject.value;
+        if (sessionId) {
+            return allCheckpoints.filter(cp => cp.sessionId === sessionId);
+        }
+        return [...allCheckpoints];
+    }
+
+    /**
+     * 清空检查点
+     */
+    clearCheckpoints(sessionId?: string): void {
+        if (sessionId) {
+            // 清空指定会话的检查点
+            const currentCheckpoints = this.checkpointsSubject.value;
+            const filteredCheckpoints = currentCheckpoints.filter(cp => cp.sessionId !== sessionId);
+            this.checkpointsSubject.next(filteredCheckpoints);
+        } else {
+            // 清空所有检查点
+            this.checkpointsSubject.next([]);
+        }
+
+        this.logger.info('Checkpoints cleared', { sessionId: sessionId || 'all' });
+    }
+
+    /**
+     * 压缩存储检查点
+     */
+    compressCheckpoint(checkpointId: string): Checkpoint {
+        const checkpoint = this.getCheckpoint(checkpointId);
+        if (!checkpoint) {
+            throw new Error(`Checkpoint not found: ${checkpointId}`);
+        }
+
+        // TODO: 实现检查点压缩逻辑
+        // 这里先返回原检查点，实际实现中可以使用 ContextManager 进行压缩
+        this.logger.info('Checkpoint compressed', { checkpointId });
+
+        return checkpoint;
+    }
+
+    /**
+     * 导出会话（包含检查点）
+     */
+    exportSessionWithCheckpoints(): string {
+        const sessionData = {
+            sessionId: this.currentSessionId,
+            messages: this.messagesSubject.value,
+            checkpoints: this.checkpointsSubject.value,
+            timestamp: new Date().toISOString(),
+            version: '2.0'
+        };
+        return JSON.stringify(sessionData, null, 2);
+    }
+
+    /**
+     * 导入会话（包含检查点）
+     */
+    importSessionWithCheckpoints(sessionData: string): void {
+        try {
+            const data = JSON.parse(sessionData);
+            this.currentSessionId = data.sessionId;
+            this.messagesSubject.next(data.messages || []);
+
+            // 恢复检查点
+            if (data.checkpoints) {
+                const restoredCheckpoints: Checkpoint[] = data.checkpoints.map((cp: any) => ({
+                    ...cp,
+                    createdAt: typeof cp.createdAt === 'number' ? cp.createdAt : new Date(cp.createdAt).getTime(),
+                    messages: cp.messages.map((msg: any) => ({
+                        ...msg,
+                        ts: typeof msg.ts === 'number' ? msg.ts : new Date(msg.ts).getTime()
+                    }))
+                }));
+                this.checkpointsSubject.next(restoredCheckpoints);
+            }
+
+            this.logger.info('Session with checkpoints imported', {
+                sessionId: this.currentSessionId,
+                checkpointCount: data.checkpoints?.length || 0
+            });
+        } catch (error) {
+            this.logger.error('Failed to import session with checkpoints', error);
+            throw new Error('Invalid session data format');
+        }
+    }
+
+    /**
+     * 获取检查点统计信息
+     */
+    getCheckpointStatistics(): {
+        totalCheckpoints: number;
+        averageMessagesPerCheckpoint: number;
+        totalTokenUsage: number;
+        oldestCheckpoint?: Date;
+        newestCheckpoint?: Date;
+    } {
+        const checkpoints = this.checkpointsSubject.value;
+        const totalCheckpoints = checkpoints.length;
+
+        const totalMessages = checkpoints.reduce((sum, cp) => sum + cp.messages.length, 0);
+        const averageMessagesPerCheckpoint = totalCheckpoints > 0 ? totalMessages / totalCheckpoints : 0;
+
+        const totalTokenUsage = checkpoints.reduce((sum, cp) => {
+            return sum + cp.tokenUsage.input + cp.tokenUsage.output;
+        }, 0);
+
+        const timestamps = checkpoints.map(cp => cp.createdAt);
+        const oldestCheckpoint = timestamps.length > 0 ? new Date(Math.min(...timestamps)) : undefined;
+        const newestCheckpoint = timestamps.length > 0 ? new Date(Math.max(...timestamps)) : undefined;
+
+        return {
+            totalCheckpoints,
+            averageMessagesPerCheckpoint: Math.round(averageMessagesPerCheckpoint * 100) / 100,
+            totalTokenUsage,
+            oldestCheckpoint,
+            newestCheckpoint
+        };
+    }
+
+    // ==================== 私有辅助方法 ====================
+
+    private generateCheckpointId(): string {
+        return `checkpoint_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    private generateCheckpointSummary(messages: ChatMessage[]): string {
+        if (messages.length === 0) {
+            return '空检查点';
+        }
+
+        const firstMessage = messages[0];
+        const lastMessage = messages[messages.length - 1];
+        const messageCount = messages.length;
+
+        return `检查点：${messageCount}条消息 | 从 "${this.truncateText(firstMessage.content, 30)}" 到 "${this.truncateText(lastMessage.content, 30)}"`;
+    }
+
+    private truncateText(text: string, maxLength: number): string {
+        return text.length > maxLength ? text.substring(0, maxLength) + '...' : text;
+    }
+
+    private calculateInputTokens(messages: ApiMessage[]): number {
+        return messages
+            .filter(msg => msg.role === 'user' || msg.role === 'system')
+            .reduce((sum, msg) => {
+                const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+                return sum + Math.ceil(content.length / 4);
+            }, 0);
+    }
+
+    private calculateOutputTokens(messages: ApiMessage[]): number {
+        return messages
+            .filter(msg => msg.role === 'assistant')
+            .reduce((sum, msg) => {
+                const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+                return sum + Math.ceil(content.length / 4);
+            }, 0);
+    }
 }