tabby-ai-assistant 1.0.0

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

@@ -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.spec.ts

@@ -0,0 +1,249 @@
+import { TestBed } from '@angular/core/testing';
+import { ChatSessionService } from './chat-session.service';
+import { AiAssistantService } from '../core/ai-assistant.service';
+import { LoggerService } from '../core/logger.service';
+import { MessageRole } from '../../types/ai.types';
+
+// Mock AiAssistantService
+class MockAiAssistantService {
+    async chat(request: any): Promise<any> {
+        return {
+            message: {
+                role: MessageRole.ASSISTANT,
+                content: 'AI response',
+                timestamp: new Date()
+            }
+        };
+    }
+}
+
+// Mock LoggerService
+class MockLoggerService {
+    info = jest.fn();
+    error = jest.fn();
+    warn = jest.fn();
+}
+
+describe('ChatSessionService', () => {
+    let service: ChatSessionService;
+    let mockAiService: MockAiAssistantService;
+    let mockLogger: MockLoggerService;
+
+    beforeEach(() => {
+        TestBed.configureTestingModule({
+            providers: [
+                ChatSessionService,
+                { provide: AiAssistantService, useClass: MockAiAssistantService },
+                { provide: LoggerService, useClass: MockLoggerService }
+            ]
+        });
+
+        service = TestBed.inject(ChatSessionService);
+        mockAiService = TestBed.inject(AiAssistantService) as any;
+        mockLogger = TestBed.inject(LoggerService) as any;
+    });
+
+    it('should be created', () => {
+        expect(service).toBeTruthy();
+    });
+
+    describe('createSession', () => {
+        it('should create a new session', () => {
+            const sessionId = service.createSession();
+            expect(sessionId).toBeDefined();
+            expect(sessionId).toMatch(/^session_/);
+            expect(mockLogger.info).toHaveBeenCalledWith(
+                'Created new chat session',
+                expect.objectContaining({ sessionId })
+            );
+        });
+
+        it('should initialize with empty messages', () => {
+            service.createSession();
+            service.messages$.subscribe(messages => {
+                expect(messages).toEqual([]);
+            });
+        });
+    });
+
+    describe('sendMessage', () => {
+        it('should send a message and receive response', async () => {
+            service.createSession();
+
+            await service.sendMessage('Test message');
+
+            service.messages$.subscribe(messages => {
+                expect(messages.length).toBe(2); // User message + AI response
+                expect(messages[0].content).toBe('Test message');
+                expect(messages[0].role).toBe(MessageRole.USER);
+                expect(messages[1].content).toBe('AI response');
+                expect(messages[1].role).toBe(MessageRole.ASSISTANT);
+            });
+        });
+
+        it('should create session if none exists', async () => {
+            await service.sendMessage('Test message');
+
+            const sessionId = service.getCurrentSessionId();
+            expect(sessionId).toBeDefined();
+        });
+
+        it('should handle errors gracefully', async () => {
+            mockAiService.chat = jest.fn().mockRejectedValue(new Error('API error'));
+
+            try {
+                await service.sendMessage('Test message');
+            } catch (error) {
+                expect(error).toBeDefined();
+            }
+        });
+
+        it('should set and clear typing indicator', async () => {
+            service.createSession();
+
+            let typingStates: boolean[] = [];
+            service.isTyping$.subscribe(state => typingStates.push(state));
+
+            await service.sendMessage('Test message');
+
+            // Should be false initially, true during request, false after
+            expect(typingStates[typingStates.length - 1]).toBe(false);
+        });
+    });
+
+    describe('clearSession', () => {
+        it('should clear session messages', async () => {
+            service.createSession();
+            await service.sendMessage('Test message');
+
+            service.clearSession();
+
+            service.messages$.subscribe(messages => {
+                expect(messages).toEqual([]);
+            });
+        });
+    });
+
+    describe('deleteMessage', () => {
+        it('should delete a specific message', async () => {
+            service.createSession();
+            await service.sendMessage('Message 1');
+            await service.sendMessage('Message 2');
+
+            service.messages$.subscribe(messages => {
+                expect(messages.length).toBe(4);
+            });
+
+            const messages = service.getCurrentMessages();
+            const messageId = messages[0].id;
+            service.deleteMessage(messageId);
+
+            service.messages$.subscribe(messages => {
+                expect(messages.length).toBe(3);
+                expect(messages.find(m => m.id === messageId)).toBeUndefined();
+            });
+        });
+    });
+
+    describe('exportSession', () => {
+        it('should export session data', async () => {
+            service.createSession();
+            await service.sendMessage('Test message');
+
+            const exported = service.exportSession();
+            const data = JSON.parse(exported);
+
+            expect(data.sessionId).toBeDefined();
+            expect(data.messages).toBeDefined();
+            expect(data.timestamp).toBeDefined();
+            expect(Array.isArray(data.messages)).toBe(true);
+        });
+    });
+
+    describe('importSession', () => {
+        it('should import session data', () => {
+            const sessionData = {
+                sessionId: 'test-session',
+                messages: [
+                    {
+                        id: 'msg-1',
+                        role: MessageRole.USER,
+                        content: 'Test',
+                        timestamp: new Date()
+                    }
+                ],
+                timestamp: new Date().toISOString()
+            };
+
+            service.importSession(JSON.stringify(sessionData));
+
+            expect(service.getCurrentSessionId()).toBe('test-session');
+            service.messages$.subscribe(messages => {
+                expect(messages.length).toBe(1);
+            });
+        });
+
+        it('should throw error for invalid data', () => {
+            expect(() => service.importSession('invalid json')).toThrow();
+        });
+    });
+
+    describe('switchToSession', () => {
+        it('should switch to specified session', () => {
+            service.createSession();
+            const sessionId = service.getCurrentSessionId();
+
+            service.switchToSession('new-session-id');
+
+            expect(service.getCurrentSessionId()).toBe('new-session-id');
+            expect(mockLogger.info).toHaveBeenCalledWith(
+                'Switched to session',
+                expect.objectContaining({ sessionId: 'new-session-id' })
+            );
+        });
+    });
+
+    describe('getCurrentMessages', () => {
+        it('should return current messages', async () => {
+            service.createSession();
+            await service.sendMessage('Test message');
+
+            const messages = service.getCurrentMessages();
+            expect(messages.length).toBe(2);
+        });
+    });
+
+    describe('Observable streams', () => {
+        it('should emit messages when changed', async () => {
+            service.createSession();
+
+            let emittedMessages: any[][] = [];
+            service.messages$.subscribe(messages => {
+                emittedMessages.push(messages);
+            });
+
+            await service.sendMessage('Message 1');
+
+            expect(emittedMessages.length).toBeGreaterThan(1);
+            expect(emittedMessages[emittedMessages.length - 1].length).toBe(2);
+        });
+
+        it('should emit errors', async () => {
+            service.createSession();
+            mockAiService.chat = jest.fn().mockRejectedValue(new Error('Test error'));
+
+            let errorMessage: string | undefined;
+            service.error$.subscribe(error => {
+                errorMessage = error;
+            });
+
+            try {
+                await service.sendMessage('Test');
+            } catch {
+                // Ignore
+            }
+
+            expect(errorMessage).toBe('Test error');
+        });
+    });
+});

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

@@ -0,0 +1,180 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { ChatMessage, ChatRequest, ChatResponse, MessageRole } from '../../types/ai.types';
+import { AiAssistantService } from '../core/ai-assistant.service';
+import { LoggerService } from '../core/logger.service';
+
+/**
+ * 聊天会话服务
+ * 管理聊天会话的生命周期、消息历史和状态
+ */
+@Injectable({
+    providedIn: 'root'
+})
+export class ChatSessionService {
+    private currentSessionId: string | null = null;
+    private messagesSubject = new BehaviorSubject<ChatMessage[]>([]);
+    private isTypingSubject = new BehaviorSubject<boolean>(false);
+    private errorSubject = new Subject<string>();
+
+    public messages$ = this.messagesSubject.asObservable();
+    public isTyping$ = this.isTypingSubject.asObservable();
+    public error$ = this.errorSubject.asObservable();
+
+    constructor(
+        private aiService: AiAssistantService,
+        private logger: LoggerService
+    ) {}
+
+    /**
+     * 创建新会话
+     */
+    createSession(): string {
+        this.currentSessionId = this.generateSessionId();
+        this.messagesSubject.next([]);
+        this.logger.info('Created new chat session', { sessionId: this.currentSessionId });
+        return this.currentSessionId;
+    }
+
+    /**
+     * 切换到指定会话
+     */
+    switchToSession(sessionId: string): void {
+        this.currentSessionId = sessionId;
+        // TODO: 从存储中加载会话历史
+        this.logger.info('Switched to session', { sessionId });
+    }
+
+    /**
+     * 发送消息
+     */
+    async sendMessage(content: string, systemPrompt?: string): Promise<void> {
+        if (!this.currentSessionId) {
+            this.createSession();
+        }
+
+        try {
+            // 添加用户消息
+            const userMessage: ChatMessage = {
+                id: this.generateMessageId(),
+                role: MessageRole.USER,
+                content,
+                timestamp: new Date()
+            };
+
+            const currentMessages = this.messagesSubject.value;
+            this.messagesSubject.next([...currentMessages, userMessage]);
+
+            // 显示打字状态
+            this.isTypingSubject.next(true);
+
+            // 构建请求
+            const request: ChatRequest = {
+                messages: [...currentMessages, userMessage],
+                systemPrompt,
+                maxTokens: 2000,
+                temperature: 0.7
+            };
+
+            // 发送请求
+            const response = await this.aiService.chat(request);
+
+            // 添加AI响应
+            const assistantMessage: ChatMessage = {
+                ...response.message,
+                id: this.generateMessageId()
+            };
+
+            this.messagesSubject.next([
+                ...this.messagesSubject.value,
+                assistantMessage
+            ]);
+
+            this.logger.info('Message sent successfully', {
+                sessionId: this.currentSessionId,
+                messageId: assistantMessage.id
+            });
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.errorSubject.next(errorMessage);
+            this.logger.error('Failed to send message', {
+                error,
+                sessionId: this.currentSessionId,
+                content
+            });
+            throw error;
+        } finally {
+            this.isTypingSubject.next(false);
+        }
+    }
+
+    /**
+     * 清空会话历史
+     */
+    clearSession(): void {
+        this.messagesSubject.next([]);
+        this.logger.info('Cleared chat session', {
+            sessionId: this.currentSessionId
+        });
+    }
+
+    /**
+     * 删除消息
+     */
+    deleteMessage(messageId: string): void {
+        const currentMessages = this.messagesSubject.value;
+        const filteredMessages = currentMessages.filter(msg => msg.id !== messageId);
+        this.messagesSubject.next(filteredMessages);
+        this.logger.info('Deleted message', { messageId, sessionId: this.currentSessionId });
+    }
+
+    /**
+     * 获取当前会话ID
+     */
+    getCurrentSessionId(): string | null {
+        return this.currentSessionId;
+    }
+
+    /**
+     * 获取当前消息列表
+     */
+    getCurrentMessages(): ChatMessage[] {
+        return this.messagesSubject.value;
+    }
+
+    /**
+     * 导出会话
+     */
+    exportSession(): string {
+        const sessionData = {
+            sessionId: this.currentSessionId,
+            messages: this.messagesSubject.value,
+            timestamp: new Date().toISOString()
+        };
+        return JSON.stringify(sessionData, null, 2);
+    }
+
+    /**
+     * 导入会话
+     */
+    importSession(sessionData: string): void {
+        try {
+            const data = JSON.parse(sessionData);
+            this.currentSessionId = data.sessionId;
+            this.messagesSubject.next(data.messages || []);
+            this.logger.info('Imported session', { sessionId: this.currentSessionId });
+        } catch (error) {
+            this.logger.error('Failed to import session', error);
+            throw new Error('Invalid session data format');
+        }
+    }
+
+    private generateSessionId(): string {
+        return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    private generateMessageId(): string {
+        return `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+}