aegiscode 3.1.8 → 3.1.10

package/src/context/storage/MemoryStore.ts

@@ -0,0 +1,205 @@
+/**
+ * 
+ * 
+ * 
+ */
+
+import type { ContextData, ContextMessage, MemoryInfo, ToolCallRecord } from '../types.js';
+
+export class MemoryStore {
+  private contextData: ContextData | null = null;
+  private readonly maxSize: number;
+  private readonly accessLog: Map<string, number> = new Map();
+
+  constructor(maxSize: number = 1000) {
+    this.maxSize = maxSize;
+  }
+
+  /**
+   * 
+   */
+  setContext(data: ContextData): void {
+    this.contextData = data;
+    this.recordAccess('context');
+  }
+
+  /**
+   * 
+   */
+  getContext(): ContextData | null {
+    this.recordAccess('context');
+    return this.contextData;
+  }
+
+  /**
+   * 
+   */
+  hasData(): boolean {
+    return this.contextData !== null;
+  }
+
+  /**
+   * 
+   */
+  addMessage(message: ContextMessage): void {
+    if (!this.contextData) {
+      throw new Error('上下文数据未初始化');
+    }
+
+    this.contextData.layers.conversation.messages.push(message);
+    this.contextData.layers.conversation.lastActivity = Date.now();
+    this.contextData.metadata.lastUpdated = Date.now();
+
+    // 检查是否超过大小限
+    this.enforceMemoryLimit();
+    this.recordAccess('messages');
+  }
+
+  /**
+   * 
+   */
+  getMessages(): ContextMessage[] {
+    if (!this.contextData) {
+      return [];
+    }
+    this.recordAccess('messages');
+    return this.contextData.layers.conversation.messages;
+  }
+
+  /**
+   * 
+   */
+  setMessages(messages: ContextMessage[]): void {
+    if (!this.contextData) {
+      throw new Error('上下文数据未初始化');
+    }
+    this.contextData.layers.conversation.messages = messages;
+    this.contextData.metadata.lastUpdated = Date.now();
+  }
+
+  /**
+   * 
+   */
+  addToolCall(toolCall: ToolCallRecord): void {
+    if (!this.contextData) {
+      throw new Error('上下文数据未初始化');
+    }
+
+    this.contextData.layers.tool.recentCalls.push(toolCall);
+    this.contextData.metadata.lastUpdated = Date.now();
+
+    // 限制工具调用记录数
+    const maxToolCalls = 100;
+    if (this.contextData.layers.tool.recentCalls.length > maxToolCalls) {
+      this.contextData.layers.tool.recentCalls = 
+        this.contextData.layers.tool.recentCalls.slice(-maxToolCalls);
+    }
+
+    this.recordAccess('toolCalls');
+  }
+
+  /**
+   * 
+   */
+  updateToolCallResult(toolCallId: string, output: unknown, error?: string): void {
+    if (!this.contextData) return;
+
+    const toolCall = this.contextData.layers.tool.recentCalls.find(
+      tc => tc.id === toolCallId
+    );
+
+    if (toolCall) {
+      toolCall.output = output;
+      toolCall.status = error ? 'error' : 'success';
+      if (error) {
+        toolCall.error = error;
+      }
+      this.contextData.metadata.lastUpdated = Date.now();
+    }
+  }
+
+  /**
+   * 
+   */
+  getRecentToolCalls(count: number = 10): ToolCallRecord[] {
+    if (!this.contextData) {
+      return [];
+    }
+    return this.contextData.layers.tool.recentCalls.slice(-count);
+  }
+
+  /**
+   * 
+   */
+  updateTokenCount(tokens: number): void {
+    if (!this.contextData) return;
+    this.contextData.metadata.totalTokens = tokens;
+    this.contextData.metadata.lastUpdated = Date.now();
+  }
+
+  /**
+   * 
+   */
+  getTokenCount(): number {
+    return this.contextData?.metadata.totalTokens ?? 0;
+  }
+
+  /**
+   * 
+   */
+  private enforceMemoryLimit(): void {
+    if (!this.contextData) return;
+
+    const messages = this.contextData.layers.conversation.messages;
+    if (messages.length > this.maxSize) {
+      // 保留最近的消息，删除较旧
+      const keepCount = Math.floor(this.maxSize * 0.8); // 保
+      this.contextData.layers.conversation.messages = messages.slice(-keepCount);
+    }
+  }
+
+  /**
+   * 
+   */
+  private recordAccess(key: string): void {
+    this.accessLog.set(key, Date.now());
+  }
+
+  /**
+   * 
+   */
+  getLastAccess(key: string): number | undefined {
+    return this.accessLog.get(key);
+  }
+
+  /**
+   * 
+   */
+  getMemoryInfo(): MemoryInfo {
+    if (!this.contextData) {
+      return { hasData: false, messageCount: 0, toolCallCount: 0, lastUpdated: null };
+    }
+
+    return {
+      hasData: true,
+      messageCount: this.contextData.layers.conversation.messages.length,
+      toolCallCount: this.contextData.layers.tool.recentCalls.length,
+      lastUpdated: this.contextData.metadata.lastUpdated,
+    };
+  }
+
+  /**
+   * 
+   */
+  getSessionId(): string | null {
+    return this.contextData?.layers.session.sessionId ?? null;
+  }
+
+  /**
+   * 
+   */
+  clear(): void {
+    this.contextData = null;
+    this.accessLog.clear();
+  }
+}

package/src/context/storage/PersistentStore.ts

@@ -0,0 +1,327 @@
+/**
+ * 
+ * 
+ * 
+ */
+
+import { nanoid } from 'nanoid';
+import type { JSONLEntry, CompactMetadata, SessionContext, ConversationContext, ContextMessage } from '../types.js';
+import { JSONLStore } from './JSONLStore.js';
+import { getSessionFilePath, detectGitBranch } from './pathUtils.js';
+
+// 获取版本
+let packageVersion = '0.1.0';
+try {
+  const packageJson = await import('../../../package.json', { with: { type: 'json' } });
+  packageVersion = packageJson.default.version || '0.1.0';
+} catch {
+  // 忽略错
+}
+
+export class PersistentStore {
+  private readonly projectPath: string;
+  private readonly maxSessions: number;
+  private readonly version: string;
+
+  constructor(projectPath: string = process.cwd(), maxSessions: number = 100) {
+    this.projectPath = projectPath;
+    this.maxSessions = maxSessions;
+    this.version = packageVersion;
+  }
+
+  /**
+   * 
+   */
+  private getStore(sessionId: string): JSONLStore {
+    const filePath = getSessionFilePath(this.projectPath, sessionId);
+    return new JSONLStore(filePath);
+  }
+
+  /**
+   * 
+   */
+  async saveMessage(
+    sessionId: string,
+    messageRole: 'user' | 'assistant' | 'system',
+    content: string,
+    parentUuid: string | null = null,
+    metadata?: { model?: string; usage?: { input_tokens: number; output_tokens: number } }
+  ): Promise<string> {
+    const store = this.getStore(sessionId);
+
+    const entry: JSONLEntry = {
+      uuid: nanoid(),
+      parentUuid,
+      sessionId,
+      timestamp: new Date().toISOString(),
+      type: messageRole,
+      cwd: this.projectPath,
+      gitBranch: detectGitBranch(this.projectPath),
+      version: this.version,
+      message: {
+        role: messageRole,
+        content,
+        ...(metadata || {}),
+      },
+    };
+
+    await store.append(entry);
+    return entry.uuid;
+  }
+
+  /**
+   * 
+   */
+  async saveToolUse(
+    sessionId: string,
+    toolId: string,
+    toolName: string,
+    input: unknown,
+    parentUuid: string | null = null
+  ): Promise<string> {
+    const store = this.getStore(sessionId);
+
+    const entry: JSONLEntry = {
+      uuid: nanoid(),
+      parentUuid,
+      sessionId,
+      timestamp: new Date().toISOString(),
+      type: 'tool_use',
+      cwd: this.projectPath,
+      gitBranch: detectGitBranch(this.projectPath),
+      version: this.version,
+      message: {
+        role: 'assistant',
+        content: '',
+      },
+      tool: {
+        id: toolId,
+        name: toolName,
+        input,
+      },
+    };
+
+    await store.append(entry);
+    return entry.uuid;
+  }
+
+  /**
+   * 
+   */
+  async saveToolResult(
+    sessionId: string,
+    toolId: string,
+    output: unknown,
+    error?: string,
+    parentUuid: string | null = null
+  ): Promise<string> {
+    const store = this.getStore(sessionId);
+
+    const entry: JSONLEntry = {
+      uuid: nanoid(),
+      parentUuid,
+      sessionId,
+      timestamp: new Date().toISOString(),
+      type: 'tool_result',
+      cwd: this.projectPath,
+      gitBranch: detectGitBranch(this.projectPath),
+      version: this.version,
+      message: {
+        role: 'assistant',
+        content: '',
+      },
+      toolResult: {
+        id: toolId,
+        output,
+        error,
+      },
+    };
+
+    await store.append(entry);
+    return entry.uuid;
+  }
+
+  /**
+   * 
+   */
+  async saveCompaction(
+    sessionId: string,
+    summary: string,
+    metadata: CompactMetadata,
+    parentUuid: string | null = null
+  ): Promise<string> {
+    const store = this.getStore(sessionId);
+
+    // 1. 保存压缩边界标
+    const boundaryEntry: JSONLEntry = {
+      uuid: nanoid(),
+      parentUuid,
+      sessionId,
+      timestamp: new Date().toISOString(),
+      type: 'system',
+      subtype: 'compact_boundary',
+      cwd: this.projectPath,
+      gitBranch: detectGitBranch(this.projectPath),
+      version: this.version,
+      message: {
+        role: 'system',
+        content: '=== 上下文压缩边界 ===',
+      },
+      compactMetadata: metadata,
+    };
+    await store.append(boundaryEntry);
+
+    // 2. 保存压缩总
+    const summaryEntry: JSONLEntry = {
+      uuid: nanoid(),
+      parentUuid: boundaryEntry.uuid,
+      sessionId,
+      timestamp: new Date().toISOString(),
+      type: 'user',
+      isCompactSummary: true,
+      cwd: this.projectPath,
+      version: this.version,
+      message: {
+        role: 'user',
+        content: summary,
+      },
+      compactMetadata: metadata,
+    };
+    await store.append(summaryEntry);
+
+    return summaryEntry.uuid;
+  }
+
+  /**
+   * 
+   */
+  async loadSession(sessionId: string): Promise<SessionContext | null> {
+    const store = this.getStore(sessionId);
+    
+    if (!store.exists()) {
+      return null;
+    }
+
+    const entries = await store.readAll();
+    if (entries.length === 0) {
+      return null;
+    }
+
+    const firstEntry = entries[0];
+    return {
+      sessionId,
+      preferences: {},
+      startTime: new Date(firstEntry.timestamp).getTime(),
+    };
+  }
+
+  /**
+   * 
+   */
+  async loadConversation(sessionId: string): Promise<ConversationContext | null> {
+    const store = this.getStore(sessionId);
+    
+    if (!store.exists()) {
+      return null;
+    }
+
+    // 只加载压缩边界后的消
+    const entries = await store.readAfterCompaction();
+    
+    const messages: ContextMessage[] = [];
+    let lastActivity = 0;
+
+    for (const entry of entries) {
+      const timestamp = new Date(entry.timestamp).getTime();
+      if (timestamp > lastActivity) {
+        lastActivity = timestamp;
+      }
+
+      // 跳过压缩边
+      if (entry.subtype === 'compact_boundary') {
+        continue;
+      }
+
+      // 转换
+      if (entry.type === 'user' || entry.type === 'assistant' || entry.type === 'system') {
+        messages.push({
+          id: entry.uuid,
+          role: entry.message.role as ContextMessage['role'],
+          content: typeof entry.message.content === 'string' 
+            ? entry.message.content 
+            : JSON.stringify(entry.message.content),
+          timestamp,
+          metadata: entry.isCompactSummary ? { isCompactSummary: true } : undefined,
+        });
+      }
+    }
+
+    return {
+      messages,
+      topics: [],
+      lastActivity,
+    };
+  }
+
+  /**
+   * 
+   */
+  async listSessions(): Promise<string[]> {
+    const { readdir } = await import('node:fs/promises');
+    const { getProjectStoragePath } = await import('./pathUtils.js');
+    
+    const storagePath = getProjectStoragePath(this.projectPath);
+    
+    try {
+      const files = await readdir(storagePath);
+      return files
+        .filter(f => f.endsWith('.jsonl'))
+        .map(f => f.replace('.jsonl', ''));
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * 
+   */
+  async deleteSession(sessionId: string): Promise<void> {
+    const store = this.getStore(sessionId);
+    await store.delete();
+  }
+
+  /**
+   * 
+   */
+  async getSessionStats(sessionId: string): Promise<{
+    messageCount: number;
+    fileSize: number;
+    createdAt: Date | null;
+    lastUpdatedAt: Date | null;
+  } | null> {
+    const store = this.getStore(sessionId);
+    
+    if (!store.exists()) {
+      return null;
+    }
+
+    const entries = await store.readAll();
+    const fileSize = await store.getFileSize();
+
+    if (entries.length === 0) {
+      return {
+        messageCount: 0,
+        fileSize,
+        createdAt: null,
+        lastUpdatedAt: null,
+      };
+    }
+
+    return {
+      messageCount: entries.length,
+      fileSize,
+      createdAt: new Date(entries[0].timestamp),
+      lastUpdatedAt: new Date(entries[entries.length - 1].timestamp),
+    };
+  }
+}

package/src/context/storage/index.ts

@@ -0,0 +1,9 @@
+/**
+ * 
+ */
+
+export { MemoryStore } from './MemoryStore.js';
+export { PersistentStore } from './PersistentStore.js';
+export { CacheStore } from './CacheStore.js';
+export { JSONLStore } from './JSONLStore.js';
+export * from './pathUtils.js';

package/src/context/storage/pathUtils.ts

@@ -0,0 +1,114 @@
+/**
+ * 
+ * 
+ * 
+ */
+
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { execSync } from 'node:child_process';
+
+/**
+ * 
+ */
+export function getStorageRoot(): string {
+  return path.join(os.homedir(), '.aegis');
+}
+
+/**
+ * 
+ * /Users/foo/project → -Users-foo-project
+ */
+export function escapeProjectPath(absPath: string): string {
+  const normalized = path.resolve(absPath);
+  // 将路径分隔符替换为 -，移除开头
+  return normalized.replace(/[/\\]/g, '-').replace(/^-/, '');
+}
+
+/**
+ * 
+ * @returns ~/.aegis/projects/{escaped-path}/
+ */
+export function getProjectStoragePath(projectPath: string): string {
+  const escaped = escapeProjectPath(projectPath);
+  return path.join(getStorageRoot(), 'projects', escaped);
+}
+
+/**
+ * 
+ * @returns ~/.aegis/projects/{escaped-path}/{sessionId}.jsonl
+ */
+export function getSessionFilePath(projectPath: string, sessionId: string): string {
+  return path.join(getProjectStoragePath(projectPath), `${sessionId}.jsonl`);
+}
+
+/**
+ * 
+ * @returns ~/.aegis/projects/{escaped-path}/sessions.json
+ */
+export function getSessionIndexPath(projectPath: string): string {
+  return path.join(getProjectStoragePath(projectPath), 'sessions.json');
+}
+
+/**
+ * 
+ */
+export function detectGitBranch(projectPath: string): string | undefined {
+  try {
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+      cwd: projectPath,
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    return branch || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * 
+ */
+export function detectGitRemote(projectPath: string): string | undefined {
+  try {
+    const remote = execSync('git remote get-url origin', {
+      cwd: projectPath,
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    return remote || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * 
+ */
+export async function getLatestSessionFile(projectPath: string): Promise<string | null> {
+  const { readdir, stat } = await import('node:fs/promises');
+  const storagePath = getProjectStoragePath(projectPath);
+  
+  try {
+    const files = await readdir(storagePath);
+    const jsonlFiles = files.filter(f => f.endsWith('.jsonl'));
+    
+    if (jsonlFiles.length === 0) {
+      return null;
+    }
+    
+    // 按修改时间排
+    const fileStats = await Promise.all(
+      jsonlFiles.map(async (file) => {
+        const filePath = path.join(storagePath, file);
+        const stats = await stat(filePath);
+        return { file, mtime: stats.mtime.getTime() };
+      })
+    );
+    
+    fileStats.sort((a, b) => b.mtime - a.mtime);
+    return path.join(storagePath, fileStats[0].file);
+  } catch {
+    return null;
+  }
+}