@xagent-ai/cli 1.0.1

package/src/context-compressor.ts

@@ -0,0 +1,290 @@
+import { ChatMessage, CompressionConfig } from './types.js';
+import { AIClient, Message } from './ai-client.js';
+import { AuthConfig } from './types.js';
+
+export interface CompressionResult {
+  compressedMessages: ChatMessage[];
+  wasCompressed: boolean;
+  originalMessageCount: number;
+  compressedMessageCount: number;
+  originalSize: number;
+  compressedSize: number;
+  compressionMethod: 'summary' | 'truncate' | 'none';
+}
+
+export class ContextCompressor {
+  private aiClient: AIClient | null = null;
+  private defaultConfig: CompressionConfig = {
+    enabled: true,
+    maxMessages: 50,
+    maxContextSize: 150000,
+    preserveRecentMessages: 0,
+    enableSummary: true
+  };
+
+  constructor(authConfig?: AuthConfig) {
+    if (authConfig) {
+      this.aiClient = new AIClient(authConfig);
+    }
+  }
+
+  setAIClient(aiClient: AIClient): void {
+    this.aiClient = aiClient;
+  }
+
+  /**
+   * 检查是否需要进行压缩
+   */
+  needsCompression(
+    messages: ChatMessage[],
+    config?: Partial<CompressionConfig>
+  ): { needsCompression: boolean; reason: string } {
+    const cfg = { ...this.defaultConfig, ...config };
+    const userMessageCount = messages.filter(m => m.role === 'user').length;
+    const contextSize = this.calculateContextSize(messages);
+
+    if (userMessageCount > cfg.maxMessages) {
+      return {
+        needsCompression: true,
+        reason: `User message count (${userMessageCount}) exceeds maximum (${cfg.maxMessages})`
+      };
+    }
+
+    if (contextSize > cfg.maxContextSize) {
+      return {
+        needsCompression: true,
+        reason: `Context size (${contextSize} chars) exceeds maximum (${cfg.maxContextSize} chars)`
+      };
+    }
+
+    return { needsCompression: false, reason: '' };
+  }
+
+  /**
+   * 计算上下文大小（字符数）
+   */
+  calculateContextSize(messages: ChatMessage[]): number {
+    return messages.reduce((total, msg) => {
+      return total + msg.content.length + (msg.role.length + 10);
+    }, 0);
+  }
+
+  /**
+   * 压缩对话历史
+   */
+  async compressContext(
+    messages: ChatMessage[],
+    systemPrompt: string,
+    config?: Partial<CompressionConfig>
+  ): Promise<CompressionResult> {
+    const cfg = { ...this.defaultConfig, ...config };
+    const originalMessageCount = messages.length;
+    const originalSize = this.calculateContextSize(messages);
+
+    // 分离系统消息、用户消息和助手消息
+    const systemMessages = messages.filter(m => m.role === 'system');
+    const nonSystemMessages = messages.filter(m => m.role !== 'system');
+
+    // 如果消息数量和大小都在限制内，不需要压缩
+    const { needsCompression } = this.needsCompression(nonSystemMessages, config);
+    if (!needsCompression) {
+      return {
+        compressedMessages: messages,
+        wasCompressed: false,
+        originalMessageCount,
+        compressedMessageCount: messages.length,
+        originalSize,
+        compressedSize: originalSize,
+        compressionMethod: 'none'
+      };
+    }
+
+    // 使用 AI 生成摘要压缩全部历史对话
+    const compressedMessages = await this.summarizeAllMessages(
+      nonSystemMessages,
+      systemPrompt,
+      cfg
+    );
+
+    // 注意：不再保留原始的 systemMessages，因为 generateResponse 会自动添加系统提示
+    // 压缩后的消息只包含摘要（role: assistant），避免重复的 system 消息导致 API 报错
+    const finalMessages = [...compressedMessages];
+
+    return {
+      compressedMessages: finalMessages,
+      wasCompressed: true,
+      originalMessageCount,
+      compressedMessageCount: finalMessages.length,
+      originalSize,
+      compressedSize: this.calculateContextSize(finalMessages),
+      compressionMethod: 'summary'
+    };
+  }
+
+  /**
+   * 使用 AI 生成摘要来压缩全部对话历史
+   */
+  private async summarizeAllMessages(
+    messages: ChatMessage[],
+    systemPrompt: string,
+    config: CompressionConfig
+  ): Promise<ChatMessage[]> {
+    // 生成完整对话的摘要
+    const summary = await this.generateSummary(messages, systemPrompt);
+
+    // 构建压缩后的对话：只有摘要作为 system 消息
+    const compressed: ChatMessage[] = [];
+
+    // 添加摘要作为 assistant 消息，避免与系统提示重复导致 API 报错
+    compressed.push({
+      role: 'assistant',
+      content: `[Conversation Summary - ${messages.length} messages compressed]\n\n${summary}`,
+      timestamp: Date.now()
+    });
+
+    return compressed;
+  }
+
+  /**
+   * Generate conversation summary
+   */
+  private async generateSummary(
+    messages: ChatMessage[],
+    systemPrompt: string
+  ): Promise<string> {
+    if (!this.aiClient) {
+      throw new Error('AI client not initialized for summarization');
+    }
+
+    // Extract all conversation content
+    const conversationText = messages
+      .map((m, idx) => {
+        const role = m.role === 'user' ? 'User' : 
+                     m.role === 'assistant' ? 'Assistant' : 
+                     m.role === 'tool' ? 'Tool' : m.role;
+        return `[${idx + 1}] ${role}:\n${m.content}`;
+      })
+      .join('\n\n' + '='.repeat(50) + '\n\n');
+
+    const summaryPrompt = `You are an expert at summarizing conversations. Please create a comprehensive summary of the following conversation.
+
+## Instructions
+1. Analyze ALL messages in the conversation
+2. Create a detailed summary that captures:
+   - Complete context and background
+   - All topics discussed
+   - All decisions made
+   - All files created, modified, or analyzed
+   - All code changes and implementations
+   - All problems solved
+   - Current state and progress
+   - Any pending or ongoing tasks
+3. Be extremely thorough - this summary will replace the entire conversation history
+4. Include specific details like file paths, code snippets, command outputs, etc.
+
+## Conversation to summarize
+${conversationText}
+
+## Output Format
+Provide a detailed, comprehensive summary in the following format:
+
+### Conversation Summary
+
+#### Overview
+[Brief description of what this conversation was about]
+
+#### Background & Context
+[Complete background information]
+
+#### Topics Discussed
+- [Topic 1: detailed description]
+- [Topic 2: detailed description]
+- [All topics with full details]
+
+#### Key Decisions
+- [Decision 1: details and rationale]
+- [All decisions made during the conversation]
+
+#### File Operations
+- Created: [file paths]
+- Modified: [file paths]
+- Analyzed: [file paths]
+- Deleted: [file paths]
+
+#### Code Changes
+- [Specific code changes with details]
+- [All implementations]
+
+#### Problems & Solutions
+- Problem: [description]
+  Solution: [how it was solved]
+- [All problems and solutions]
+
+#### Current State
+[What is the current status of the project/work]
+
+#### Pending Tasks
+- [Any ongoing or pending work]
+
+#### Important Details
+[Any other crucial information]
+
+Please provide the comprehensive summary possible. Do not omit any important information.`;
+
+    try {
+      const summaryMessage: Message = {
+        role: 'user',
+        content: summaryPrompt
+      };
+
+      const response = await this.aiClient.chatCompletion([summaryMessage], {
+        maxTokens: 8192,
+        temperature: 0.3
+      });
+
+      const summary = response.choices[0]?.message?.content || '';
+      return typeof summary === 'string' ? summary : JSON.stringify(summary);
+    } catch (error) {
+      console.error('Failed to generate summary:', error);
+      const userCount = messages.filter(m => m.role === 'user').length;
+      const toolCount = messages.filter(m => m.role === 'tool').length;
+      return `[Summary of ${messages.length} messages: ${userCount} user exchanges, ${toolCount} tool calls. Key topics discussed but details unavailable due to summarization error.]`;
+    }
+  }
+
+  /**
+   * 创建压缩后的消息副本（用于保存）
+   */
+  createCompressedSnapshot(
+    messages: ChatMessage[],
+    compressionResult: CompressionResult
+  ): object {
+    return {
+      timestamp: Date.now(),
+      originalMessageCount: compressionResult.originalMessageCount,
+      compressedMessageCount: compressionResult.compressedMessageCount,
+      originalSize: compressionResult.originalSize,
+      compressedSize: compressionResult.compressedSize,
+      compressionMethod: compressionResult.compressionMethod,
+      messages: compressionResult.compressedMessages
+    };
+  }
+
+  /**
+   * Estimate token count (rough estimate)
+   */
+  estimateTokens(text: string): number {
+    const chineseChars = (text.match(/[\u4e00-\u9fa5]/g) || []).length;
+    const otherChars = text.length - chineseChars;
+    return Math.ceil(chineseChars / 2 + otherChars / 4);
+  }
+}
+
+let compressorInstance: ContextCompressor | null = null;
+
+export function getContextCompressor(authConfig?: AuthConfig): ContextCompressor {
+  if (!compressorInstance) {
+    compressorInstance = new ContextCompressor(authConfig);
+  }
+  return compressorInstance;
+}

package/src/conversation.ts

@@ -0,0 +1,288 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { ChatMessage, Conversation } from './types.js';
+
+export class ConversationManager {
+  private conversationsDir: string;
+  private conversations: Map<string, Conversation> = new Map();
+  private currentConversationId: string | null = null;
+
+  constructor() {
+    this.conversationsDir = path.join(os.homedir(), '.xagent', 'conversations');
+  }
+
+  async initialize(): Promise<void> {
+    try {
+      await fs.mkdir(this.conversationsDir, { recursive: true });
+      await this.loadConversations();
+    } catch (error) {
+      console.error('Failed to initialize conversation manager:', error);
+    }
+  }
+
+  private async loadConversations(): Promise<void> {
+    try {
+      const files = await fs.readdir(this.conversationsDir);
+      
+      for (const file of files) {
+        if (file.endsWith('.json')) {
+          const filePath = path.join(this.conversationsDir, file);
+          const content = await fs.readFile(filePath, 'utf-8');
+          const conversation: Conversation = JSON.parse(content);
+          this.conversations.set(conversation.id, conversation);
+        }
+      }
+    } catch (error) {
+      console.error('Failed to load conversations:', error);
+    }
+  }
+
+  async createConversation(title?: string): Promise<Conversation> {
+    const conversationId = `conv_${Date.now()}`;
+    const now = Date.now();
+
+    const conversation: Conversation = {
+      id: conversationId,
+      messages: [],
+      createdAt: now,
+      updatedAt: now
+    };
+
+    this.conversations.set(conversationId, conversation);
+    await this.saveConversation(conversation);
+
+    this.currentConversationId = conversationId;
+
+    return conversation;
+  }
+
+  async saveConversation(conversation: Conversation): Promise<void> {
+    const filePath = path.join(this.conversationsDir, `${conversation.id}.json`);
+    await fs.writeFile(filePath, JSON.stringify(conversation, null, 2), 'utf-8');
+  }
+
+  async addMessage(message: ChatMessage, conversationId?: string): Promise<void> {
+    const convId = conversationId || this.currentConversationId;
+
+    if (!convId) {
+      await this.createConversation();
+      return this.addMessage(message, this.currentConversationId || undefined);
+    }
+
+    const conversation = this.conversations.get(convId);
+    
+    if (!conversation) {
+      throw new Error(`Conversation not found: ${convId}`);
+    }
+
+    conversation.messages.push(message);
+    conversation.updatedAt = Date.now();
+
+    await this.saveConversation(conversation);
+  }
+
+  async updateLastMessage(content: string, conversationId?: string): Promise<void> {
+    const convId = conversationId || this.currentConversationId;
+
+    if (!convId) {
+      throw new Error('No active conversation');
+    }
+
+    const conversation = this.conversations.get(convId);
+    
+    if (!conversation || conversation.messages.length === 0) {
+      throw new Error('Conversation has no messages');
+    }
+
+    const lastMessage = conversation.messages[conversation.messages.length - 1];
+    lastMessage.content = content;
+
+    conversation.updatedAt = Date.now();
+
+    await this.saveConversation(conversation);
+  }
+
+  getConversation(conversationId: string): Conversation | undefined {
+    return this.conversations.get(conversationId);
+  }
+
+  getCurrentConversation(): Conversation | undefined {
+    if (!this.currentConversationId) {
+      return undefined;
+    }
+    return this.conversations.get(this.currentConversationId);
+  }
+
+  async setCurrentConversation(conversationId: string): Promise<void> {
+    const conversation = this.conversations.get(conversationId);
+    
+    if (!conversation) {
+      throw new Error(`Conversation not found: ${conversationId}`);
+    }
+
+    this.currentConversationId = conversationId;
+    console.log(`✅ Switched to conversation: ${conversationId}`);
+  }
+
+  listConversations(): Conversation[] {
+    return Array.from(this.conversations.values())
+      .sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+
+  async deleteConversation(conversationId: string): Promise<void> {
+    const conversation = this.conversations.get(conversationId);
+    
+    if (!conversation) {
+      throw new Error(`Conversation not found: ${conversationId}`);
+    }
+
+    const filePath = path.join(this.conversationsDir, `${conversationId}.json`);
+    await fs.unlink(filePath);
+
+    this.conversations.delete(conversationId);
+
+    if (this.currentConversationId === conversationId) {
+      this.currentConversationId = null;
+    }
+
+    console.log(`✅ Deleted conversation: ${conversationId}`);
+  }
+
+  async clearCurrentConversation(): Promise<void> {
+    if (!this.currentConversationId) {
+      await this.createConversation();
+      return;
+    }
+
+    const conversation = this.conversations.get(this.currentConversationId);
+    
+    if (!conversation) {
+      throw new Error(`Conversation not found: ${this.currentConversationId}`);
+    }
+
+    conversation.messages = [];
+    conversation.updatedAt = Date.now();
+
+    await this.saveConversation(conversation);
+  }
+
+  async exportConversation(conversationId: string, outputPath: string): Promise<void> {
+    const conversation = this.conversations.get(conversationId);
+    
+    if (!conversation) {
+      throw new Error(`Conversation not found: ${conversationId}`);
+    }
+
+    const markdown = this.conversationToMarkdown(conversation);
+    await fs.writeFile(outputPath, markdown, 'utf-8');
+
+    console.log(`✅ Exported conversation to: ${outputPath}`);
+  }
+
+  private conversationToMarkdown(conversation: Conversation): string {
+    let markdown = `# Conversation Export\n\n`;
+    markdown += `**ID:** ${conversation.id}\n`;
+    markdown += `**Created:** ${new Date(conversation.createdAt).toLocaleString()}\n`;
+    markdown += `**Updated:** ${new Date(conversation.updatedAt).toLocaleString()}\n`;
+    markdown += `**Messages:** ${conversation.messages.length}\n\n`;
+    markdown += `---\n\n`;
+
+    for (const message of conversation.messages) {
+      const role = message.role === 'user' ? '👤 User' : 
+                     message.role === 'assistant' ? '🤖 Assistant' : 
+                     message.role === 'system' ? '⚙️ System' : '🔧 Tool';
+      
+      markdown += `### ${role}\n\n`;
+      markdown += `**Time:** ${new Date(message.timestamp).toLocaleString()}\n\n`;
+
+      if (message.images && message.images.length > 0) {
+        markdown += `**Images:** ${message.images.length}\n\n`;
+      }
+
+      markdown += `${message.content}\n\n`;
+      markdown += `---\n\n`;
+    }
+
+    return markdown;
+  }
+
+  async importConversation(filePath: string): Promise<Conversation> {
+    const content = await fs.readFile(filePath, 'utf-8');
+    const data = JSON.parse(content);
+
+    const conversation: Conversation = {
+      id: data.id || `imported_${Date.now()}`,
+      messages: data.messages || [],
+      createdAt: data.createdAt || Date.now(),
+      updatedAt: data.updatedAt || Date.now()
+    };
+
+    this.conversations.set(conversation.id, conversation);
+    await this.saveConversation(conversation);
+
+    console.log(`✅ Imported conversation: ${conversation.id}`);
+
+    return conversation;
+  }
+
+  async searchConversations(query: string): Promise<Conversation[]> {
+    const lowerQuery = query.toLowerCase();
+
+    return this.listConversations().filter(conv => {
+      const text = conv.messages.map(msg => msg.content).join(' ').toLowerCase();
+      return text.includes(lowerQuery);
+    });
+  }
+
+  getConversationStats(): { total: number; totalMessages: number; oldest: Date; newest: Date } {
+    const conversations = this.listConversations();
+    const totalMessages = conversations.reduce((sum, conv) => sum + conv.messages.length, 0);
+
+    const timestamps = conversations.map(conv => conv.createdAt);
+    const oldest = timestamps.length > 0 ? new Date(Math.min(...timestamps)) : new Date();
+    const newest = timestamps.length > 0 ? new Date(Math.max(...timestamps)) : new Date();
+
+    return {
+      total: conversations.length,
+      totalMessages,
+      oldest,
+      newest
+    };
+  }
+
+  async cleanupOldConversations(days: number = 30): Promise<number> {
+    const cutoffDate = Date.now() - (days * 24 * 60 * 60 * 1000);
+    const toDelete: string[] = [];
+
+    for (const [id, conv] of this.conversations) {
+      if (conv.updatedAt < cutoffDate) {
+        toDelete.push(id);
+      }
+    }
+
+    for (const id of toDelete) {
+      await this.deleteConversation(id);
+    }
+
+    return toDelete.length;
+  }
+
+  getCurrentConversationId(): string | null {
+    return this.currentConversationId;
+  }
+
+  async setCurrentConversationId(id: string): Promise<void> {
+    this.currentConversationId = id;
+  }
+}
+
+let conversationManagerInstance: ConversationManager | null = null;
+
+export function getConversationManager(): ConversationManager {
+  if (!conversationManagerInstance) {
+    conversationManagerInstance = new ConversationManager();
+    conversationManagerInstance.initialize();
+  }
+  return conversationManagerInstance;
+}