aegiscode 3.1.7 → 3.1.10

package/src/context/ContextManager.ts

@@ -0,0 +1,450 @@
+/**
+ * 
+ * 
+ * 
+ */
+
+import { nanoid } from 'nanoid';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import type {
+  ContextData,
+  ContextMessage,
+  ContextManagerOptions,
+  SystemContext,
+  WorkspaceContext,
+  CompactionResult,
+} from './types.js';
+import { MemoryStore, PersistentStore, CacheStore, getStorageRoot, detectGitBranch, detectGitRemote } from './storage/index.js';
+import { TokenCounter } from './TokenCounter.js';
+import { CompactionService } from './CompactionService.js';
+
+export class ContextManager {
+  private readonly memory: MemoryStore;
+  private readonly persistent: PersistentStore;
+  private readonly cache: CacheStore;
+  private readonly options: ContextManagerOptions;
+
+  private currentSessionId: string | null = null;
+  private readonly pendingSaves: Array<Promise<void>> = [];
+
+  constructor(options: Partial<ContextManagerOptions> = {}) {
+    // 默认配
+    this.options = {
+      storage: {
+        maxMemorySize: 1000,
+        persistentPath: getStorageRoot(),
+        cacheSize: 100,
+        compressionEnabled: true,
+        ...options.storage,
+      },
+      defaultFilter: {
+        maxTokens: 32000,
+        maxMessages: 50,
+        timeWindow: 24 * 60 * 60 * 1000, // 24小
+        ...options.defaultFilter,
+      },
+      compressionThreshold: options.compressionThreshold || 100000, // 100k tokens
+    };
+
+    // 初始化存储
+    this.memory = new MemoryStore(this.options.storage.maxMemorySize);
+    this.persistent = new PersistentStore(process.cwd(), 100);
+    this.cache = new CacheStore(this.options.storage.cacheSize, 5 * 60 * 1000);
+  }
+
+  /**
+   * 
+   */
+  async createSession(
+    userId?: string,
+    preferences: Record<string, unknown> = {},
+    configuration: Record<string, unknown> = {}
+  ): Promise<string> {
+    // 使用 nanoid 生成会话 ID，或使用提供
+    const sessionId = (configuration.sessionId as string) || nanoid();
+    const now = Date.now();
+
+    // 创建初始上下
+    const contextData: ContextData = {
+      layers: {
+        system: await this.createSystemContext(),
+        session: {
+          sessionId,
+          userId,
+          preferences,
+          configuration,
+          startTime: now,
+        },
+        conversation: {
+          messages: [],
+          topics: [],
+          lastActivity: now,
+        },
+        tool: {
+          recentCalls: [],
+          toolStates: {},
+          dependencies: {},
+        },
+        workspace: await this.createWorkspaceContext(),
+      },
+      metadata: {
+        totalTokens: 0,
+        priority: 1,
+        lastUpdated: now,
+      },
+    };
+
+    // 存储到内
+    this.memory.setContext(contextData);
+
+    this.currentSessionId = sessionId;
+    return sessionId;
+  }
+
+  /**
+   * 
+   */
+  private async createSystemContext(): Promise<SystemContext> {
+    return {
+      osType: os.type(),
+      osVersion: os.release(),
+      shell: process.env.SHELL || 'unknown',
+      nodeVersion: process.version,
+      cwd: process.cwd(),
+    };
+  }
+
+  /**
+   * 
+   */
+  private async createWorkspaceContext(): Promise<WorkspaceContext> {
+    const projectPath = process.cwd();
+
+    // 尝试读
+    let packageJson: WorkspaceContext['packageJson'];
+    try {
+      const { readFile } = await import('node:fs/promises');
+      const { join } = await import('node:path');
+      const content = await readFile(join(projectPath, 'package.json'), 'utf-8');
+      const pkg = JSON.parse(content);
+      packageJson = {
+        name: pkg.name,
+        version: pkg.version,
+        dependencies: pkg.dependencies,
+      };
+    } catch {
+      // 忽略错
+    }
+
+    return {
+      projectPath,
+      gitBranch: detectGitBranch(projectPath),
+      gitRemote: detectGitRemote(projectPath),
+      packageJson,
+    };
+  }
+
+  /**
+   * 
+   */
+  async addMessage(
+    role: ContextMessage['role'],
+    content: string,
+    metadata?: Record<string, unknown>
+  ): Promise<void> {
+    if (!this.currentSessionId) {
+      throw new Error('没有活动会话');
+    }
+
+    const message: ContextMessage = {
+      id: nanoid(),
+      role,
+      content,
+      timestamp: Date.now(),
+      metadata,
+    };
+
+    // 添加到内
+    this.memory.addMessage(message);
+
+    // 检查是否需要压
+    const contextData = this.memory.getContext();
+    if (contextData && this.shouldCompress(contextData)) {
+      await this.compressCurrentContext();
+    }
+
+    // 持久化保存到 JSONL 文件
+    await this.saveMessagePersist(message);
+  }
+
+  /**
+   * 
+   */
+  private shouldCompress(contextData: ContextData): boolean {
+    return contextData.metadata.totalTokens > this.options.compressionThreshold;
+  }
+
+  /**
+   * Persist message to JSONL synchronously (awaited by the caller).
+   * The promise is tracked so cleanup() can flush before exit.
+   */
+  private async saveMessagePersist(message: ContextMessage): Promise<void> {
+    if (!this.currentSessionId) return;
+    const promise = this.persistent.saveMessage(
+      this.currentSessionId!,
+      message.role as 'user' | 'assistant' | 'system',
+      message.content,
+      null,
+      message.metadata as any
+    ).catch(error => {
+      console.error('[ContextManager] 保存消息失败:', error);
+    });
+    this.pendingSaves.push(promise as Promise<void>);
+    await promise;
+  }
+
+  /**
+   * Flush all pending saves — call before exit to ensure no data loss.
+   */
+  async flush(): Promise<void> {
+    const pending = [...this.pendingSaves];
+    this.pendingSaves.length = 0;
+    await Promise.all(pending);
+  }
+
+  /**
+   * 
+   */
+  async compressCurrentContext(): Promise<CompactionResult | null> {
+    const contextData = this.memory.getContext();
+    if (!contextData) {
+      return null;
+    }
+
+    const messages = contextData.layers.conversation.messages.map(m => ({
+      role: m.role as 'user' | 'assistant' | 'system' | 'tool',
+      content: m.content,
+    }));
+
+    const result = await CompactionService.compact(messages, {
+      trigger: 'auto',
+      modelName: (() => {
+        try {
+          const cfg = JSON.parse(fs.readFileSync(path.join(os.homedir(), '.aegiscode', 'config.json'), 'utf8'));
+          return cfg?.default?.model || 'claude-sonnet-4-6';
+        } catch { return 'claude-sonnet-4-6'; }
+      })(),
+      maxContextTokens: this.options.compressionThreshold,
+    });
+
+    if (result.success) {
+      // 更新内存中的消
+      const newMessages: ContextMessage[] = result.compactedMessages.map(m => ({
+        id: nanoid(),
+        role: m.role as ContextMessage['role'],
+        content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
+        timestamp: Date.now(),
+      }));
+
+      this.memory.setMessages(newMessages);
+      this.memory.updateTokenCount(result.postTokens);
+
+      // 保存压缩记
+      if (this.currentSessionId) {
+        await this.persistent.saveCompaction(
+          this.currentSessionId,
+          result.summary,
+          {
+            trigger: 'auto',
+            preTokens: result.preTokens,
+            postTokens: result.postTokens,
+            filesIncluded: result.filesIncluded,
+          }
+        );
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * 
+   */
+  async manualCompact(): Promise<CompactionResult | null> {
+    const contextData = this.memory.getContext();
+    if (!contextData) {
+      return null;
+    }
+
+    const messages = contextData.layers.conversation.messages.map(m => ({
+      role: m.role as 'user' | 'assistant' | 'system' | 'tool',
+      content: m.content,
+    }));
+
+    const result = await CompactionService.compact(messages, {
+      trigger: 'manual',
+      modelName: 'claude-sonnet-4-6',
+      maxContextTokens: this.options.compressionThreshold,
+    });
+
+    if (result.success) {
+      const newMessages: ContextMessage[] = result.compactedMessages.map(m => ({
+        id: nanoid(),
+        role: m.role as ContextMessage['role'],
+        content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
+        timestamp: Date.now(),
+      }));
+
+      this.memory.setMessages(newMessages);
+      this.memory.updateTokenCount(result.postTokens);
+
+      if (this.currentSessionId) {
+        await this.persistent.saveCompaction(
+          this.currentSessionId,
+          result.summary,
+          {
+            trigger: 'manual',
+            preTokens: result.preTokens,
+            postTokens: result.postTokens,
+            filesIncluded: result.filesIncluded,
+          }
+        );
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * 
+   */
+  async loadSession(sessionId: string): Promise<boolean> {
+    try {
+      // 先尝试从内存加
+      let contextData = this.memory.getContext();
+
+      if (!contextData || contextData.layers.session.sessionId !== sessionId) {
+        // 从持久化存储加
+        const [session, conversation] = await Promise.all([
+          this.persistent.loadSession(sessionId),
+          this.persistent.loadConversation(sessionId),
+        ]);
+
+        if (!session || !conversation) {
+          return false;
+        }
+
+        // 重建完整的上下文数
+        contextData = {
+          layers: {
+            system: await this.createSystemContext(),
+            session,
+            conversation,
+            tool: { recentCalls: [], toolStates: {}, dependencies: {} },
+            workspace: await this.createWorkspaceContext(),
+          },
+          metadata: {
+            totalTokens: 0,
+            priority: 1,
+            lastUpdated: Date.now(),
+          },
+        };
+
+        this.memory.setContext(contextData);
+      }
+
+      this.currentSessionId = sessionId;
+      return true;
+    } catch (error) {
+      console.error('[ContextManager] 加载会话失败:', error);
+      return false;
+    }
+  }
+
+  /**
+   * 
+   */
+  getCurrentSessionId(): string | null {
+    return this.currentSessionId;
+  }
+
+  /**
+   * 
+   */
+  getContext(): ContextData | null {
+    return this.memory.getContext();
+  }
+
+  /**
+   * 
+   */
+  getMessages(): ContextMessage[] {
+    return this.memory.getMessages();
+  }
+
+  /**
+   * 
+   */
+  getTokenCount(): number {
+    return this.memory.getTokenCount();
+  }
+
+  /**
+   * 
+   */
+  updateTokenCount(tokens: number): void {
+    this.memory.updateTokenCount(tokens);
+  }
+
+  /**
+   * 
+   */
+  replaceMessages(messages: ContextMessage[]): void {
+    this.memory.setMessages(messages);
+  }
+
+  /**
+   * 
+   */
+  getCache<T>(key: string): T | undefined {
+    return this.cache.get<T>(key);
+  }
+
+  /**
+   * 
+   */
+  setCache<T>(key: string, value: T, ttl?: number): void {
+    this.cache.set(key, value, ttl);
+  }
+
+  /**
+   * 
+   */
+  async listSessions(): Promise<string[]> {
+    return this.persistent.listSessions();
+  }
+
+  /**
+   * 
+   */
+  async deleteSession(sessionId: string): Promise<void> {
+    await this.persistent.deleteSession(sessionId);
+    
+    if (this.currentSessionId === sessionId) {
+      this.memory.clear();
+      this.currentSessionId = null;
+    }
+  }
+
+  /**
+   * 
+   */
+  async cleanup(): Promise<void> {
+    await this.flush();
+    this.memory.clear();
+    this.cache.clear();
+    TokenCounter.clearCache();
+  }
+}

package/src/context/FileAnalyzer.ts

@@ -0,0 +1,267 @@
+/**
+ * 
+ * 
+ * 
+ */
+
+import * as fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import * as path from 'node:path';
+import type { Message } from '../agent/types.js';
+import type { FileReference, FileContent } from './types.js';
+
+export class FileAnalyzer {
+  /** 最多包含的文件数量 */
+  private static readonly MAX_FILES = 5;
+  /** 单个文件最大行数 */
+  private static readonly MAX_LINES_PER_FILE = 1000;
+  /** 单个文件最大字符数 */
+  private static readonly MAX_CHARS_PER_FILE = 50000;
+
+  /**
+   * 
+   */
+  static analyzeFiles(messages: Message[]): FileReference[] {
+    const fileMap = new Map<string, FileReference>();
+
+    messages.forEach((msg, index) => {
+      // 从消息内容中提取文件路
+      if (msg.content) {
+        const content = typeof msg.content === 'string' 
+          ? msg.content 
+          : JSON.stringify(msg.content);
+        const contentFiles = this.extractFilePathsFromContent(content);
+        contentFiles.forEach(filePath => {
+          this.updateFileReference(fileMap, filePath, index, false);
+        });
+      }
+
+      // 从工具调用中提取文件路
+      if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
+        for (const call of msg.tool_calls) {
+          const toolFiles = this.extractFilePathsFromToolCall(call);
+          const wasModified = ['Write', 'Edit'].includes(call.function?.name || '');
+          toolFiles.forEach(filePath => {
+            this.updateFileReference(fileMap, filePath, index, wasModified);
+          });
+        }
+      }
+    });
+
+    // 按重要性排序：1. 是否被修改 2. 提及次数 3. 最近
+    return Array.from(fileMap.values())
+      .filter(ref => this.isValidFilePath(ref.path))
+      .sort((a, b) => {
+        if (a.wasModified !== b.wasModified) return a.wasModified ? -1 : 1;
+        if (a.mentions !== b.mentions) return b.mentions - a.mentions;
+        return b.lastMentioned - a.lastMentioned;
+      })
+      .slice(0, this.MAX_FILES);
+  }
+
+  /**
+   * 
+   */
+  private static extractFilePathsFromContent(content: string): string[] {
+    const paths: string[] = [];
+
+    // 匹配常见的文件路径模
+    const patterns = [
+      // 绝对路
+      /(?:^|\s|["'`])(\/?(?:[\w.-]+\/)+[\w.-]+\.[a-zA-Z]{1,10})(?:\s|$|["'`]|:)/gm,
+      // 相对路
+      /(?:^|\s|["'`])(\.\/(?:[\w.-]+\/)*[\w.-]+\.[a-zA-Z]{1,10})(?:\s|$|["'`]|:)/gm,
+      // 代码块中的文件路
+      /```\d+:\d+:([\w./-]+)/gm,
+    ];
+
+    for (const pattern of patterns) {
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const filePath = match[1];
+        if (filePath && !paths.includes(filePath)) {
+          paths.push(filePath);
+        }
+      }
+    }
+
+    return paths;
+  }
+
+  /**
+   * 
+   */
+  private static extractFilePathsFromToolCall(
+    toolCall: { function?: { name?: string; arguments?: string } }
+  ): string[] {
+    const paths: string[] = [];
+
+    const functionName = toolCall.function?.name;
+    let args: Record<string, unknown> = {};
+
+    try {
+      if (typeof toolCall.function?.arguments === 'string') {
+        args = JSON.parse(toolCall.function.arguments);
+      } else if (toolCall.function?.arguments) {
+        args = toolCall.function.arguments as Record<string, unknown>;
+      }
+    } catch {
+      return paths;
+    }
+
+    // 文件操作工
+    const fileTools = ['Read', 'Write', 'Edit', 'Glob', 'Grep', 'NotebookEdit'];
+
+    if (fileTools.includes(functionName || '')) {
+      const pathKeys = ['file_path', 'path', 'notebook_path', 'filePath'];
+      for (const key of pathKeys) {
+        if (args[key] && typeof args[key] === 'string') {
+          paths.push(args[key] as string);
+        }
+      }
+    }
+
+    return paths;
+  }
+
+  /**
+   * 
+   */
+  private static updateFileReference(
+    fileMap: Map<string, FileReference>,
+    filePath: string,
+    messageIndex: number,
+    wasModified: boolean
+  ): void {
+    const existing = fileMap.get(filePath);
+
+    if (existing) {
+      existing.mentions++;
+      existing.lastMentioned = Math.max(existing.lastMentioned, messageIndex);
+      existing.wasModified = existing.wasModified || wasModified;
+    } else {
+      fileMap.set(filePath, {
+        path: filePath,
+        mentions: 1,
+        lastMentioned: messageIndex,
+        wasModified,
+      });
+    }
+  }
+
+  /**
+   * 
+   */
+  private static isValidFilePath(filePath: string): boolean {
+    // 排除常见的非文件路
+    const excludePatterns = [
+      /^https?:\/\//,  // URL
+      /^node_modules\//,  // node_modules
+      /^\.git\//,  // git 目
+      /\.(png|jpg|jpeg|gif|svg|ico|webp|mp4|mp3|wav|pdf|zip|tar|gz)$/i,  // 二进制文
+    ];
+
+    for (const pattern of excludePatterns) {
+      if (pattern.test(filePath)) {
+        return false;
+      }
+    }
+
+    // 检查文件是否存
+    try {
+      const absolutePath = path.isAbsolute(filePath) 
+        ? filePath 
+        : path.join(process.cwd(), filePath);
+      return existsSync(absolutePath);
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * 
+   */
+  static async readFilesContent(filePaths: string[]): Promise<FileContent[]> {
+    const results: FileContent[] = [];
+
+    for (const filePath of filePaths) {
+      try {
+        const absolutePath = path.isAbsolute(filePath) 
+          ? filePath 
+          : path.join(process.cwd(), filePath);
+
+        if (!existsSync(absolutePath)) {
+          continue;
+        }
+
+        const content = await fs.readFile(absolutePath, 'utf-8');
+        const lines = content.split('\n');
+        
+        let truncated = false;
+        let finalContent = content;
+
+        // 检查行数限
+        if (lines.length > this.MAX_LINES_PER_FILE) {
+          finalContent = lines.slice(0, this.MAX_LINES_PER_FILE).join('\n');
+          truncated = true;
+        }
+
+        // 检查字符数限
+        if (finalContent.length > this.MAX_CHARS_PER_FILE) {
+          finalContent = finalContent.substring(0, this.MAX_CHARS_PER_FILE);
+          truncated = true;
+        }
+
+        if (truncated) {
+          finalContent += '\n\n[... 内容已截断 ...]';
+        }
+
+        results.push({
+          path: filePath,
+          content: finalContent,
+          lines: lines.length,
+          truncated,
+        });
+      } catch (error) {
+        console.warn(`[FileAnalyzer] 读取文件失败: ${filePath}`, error);
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * 
+   */
+  static async getFileSummary(filePath: string): Promise<string | null> {
+    try {
+      const absolutePath = path.isAbsolute(filePath) 
+        ? filePath 
+        : path.join(process.cwd(), filePath);
+
+      if (!existsSync(absolutePath)) {
+        return null;
+      }
+
+      const stats = await fs.stat(absolutePath);
+      const content = await fs.readFile(absolutePath, 'utf-8');
+      const lines = content.split('\n');
+
+      return `文件: ${filePath}
+大小: ${this.formatFileSize(stats.size)}
+行数: ${lines.length}
+最后修改: ${stats.mtime.toISOString()}`;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * 
+   */
+  private static formatFileSize(bytes: number): string {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  }
+}