ccjk 2.3.2 → 2.4.2

package/dist/chunks/context-manager.mjs

@@ -0,0 +1,641 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import process__default from 'node:process';
+
+class ContextAnalyzer {
+  /**
+   * 分析消息重要性
+   */
+  static analyzeImportance(message) {
+    let score = 0;
+    const content = this.extractTextContent(message);
+    if (this.containsDecision(content))
+      score += 30;
+    if (this.containsCodeChange(message))
+      score += 25;
+    if (this.containsErrorResolution(content))
+      score += 20;
+    if (message.type === "user" && content.length > 50)
+      score += 15;
+    if (message.toolUseResult)
+      score += 10;
+    const age = Date.now() - new Date(message.timestamp).getTime();
+    const hourAge = age / (1e3 * 60 * 60);
+    score += Math.max(0, 20 - hourAge * 2);
+    return Math.min(100, score);
+  }
+  /**
+   * 提取文本内容
+   */
+  static extractTextContent(message) {
+    const content = message.message.content;
+    if (typeof content === "string")
+      return content;
+    return content.filter(
+      (block) => block.type === "text" && typeof block.text === "string"
+    ).map((block) => block.text).join("\n");
+  }
+  /**
+   * 检测是否包含决策
+   */
+  static containsDecision(content) {
+    const decisionPatterns = [
+      /决定|决策|选择|采用|使用|方案/,
+      /decide|decision|choose|adopt|use|approach/i,
+      /我们应该|建议|推荐/,
+      /should|recommend|suggest/i,
+      /✅|✔|确定|confirmed/i
+    ];
+    return decisionPatterns.some((p) => p.test(content));
+  }
+  /**
+   * 检测是否包含代码变更
+   */
+  static containsCodeChange(message) {
+    const content = message.message.content;
+    if (typeof content === "string")
+      return false;
+    return content.some(
+      (block) => block.type === "tool_use" && ["Write", "Edit", "Bash"].includes(block.name || "")
+    );
+  }
+  /**
+   * 检测是否包含错误解决
+   */
+  static containsErrorResolution(content) {
+    const patterns = [
+      /修复|解决|fix|resolve|solved/i,
+      /错误|error|bug|issue/i,
+      /成功|success|works|working/i
+    ];
+    return patterns.filter((p) => p.test(content)).length >= 2;
+  }
+  /**
+   * 提取关键决策
+   */
+  static extractDecisions(messages) {
+    const decisions = [];
+    for (const msg of messages) {
+      const content = this.extractTextContent(msg);
+      if (this.containsDecision(content)) {
+        const sentences = content.split(/[。.!！?\n]/).filter((s) => s.trim());
+        for (const sentence of sentences) {
+          if (this.containsDecision(sentence) && sentence.length < 200) {
+            decisions.push(sentence.trim());
+          }
+        }
+      }
+    }
+    return [...new Set(decisions)].slice(0, 10);
+  }
+  /**
+   * 提取代码变更
+   */
+  static extractCodeChanges(messages) {
+    const changes = [];
+    for (const msg of messages) {
+      const content = msg.message.content;
+      if (typeof content === "string")
+        continue;
+      for (const block of content) {
+        if (block.type === "tool_use") {
+          const input = block.input;
+          if (block.name === "Write" && input?.file_path) {
+            changes.push({
+              file: String(input.file_path),
+              action: "create",
+              description: `Created file`
+            });
+          } else if (block.name === "Edit" && input?.file_path) {
+            changes.push({
+              file: String(input.file_path),
+              action: "modify",
+              description: `Modified file`
+            });
+          }
+        }
+      }
+    }
+    const merged = /* @__PURE__ */ new Map();
+    for (const change of changes) {
+      const existing = merged.get(change.file);
+      if (existing) {
+        existing.action = "modify";
+      } else {
+        merged.set(change.file, change);
+      }
+    }
+    return Array.from(merged.values());
+  }
+  /**
+   * 提取主题
+   */
+  static extractTopics(messages) {
+    const topicKeywords = /* @__PURE__ */ new Map();
+    for (const msg of messages) {
+      const content = this.extractTextContent(msg).toLowerCase();
+      const techPatterns = [
+        /\b(mcp|api|cli|sdk|npm|git|docker)\b/gi,
+        /\b(typescript|javascript|python|rust|go)\b/gi,
+        /\b(react|vue|angular|node|express)\b/gi,
+        /\b(database|cache|redis|mongodb|postgres)\b/gi,
+        /\b(performance|optimization|refactor|debug)\b/gi
+      ];
+      for (const pattern of techPatterns) {
+        const matches = content.match(pattern) || [];
+        for (const match of matches) {
+          const key = match.toLowerCase();
+          topicKeywords.set(key, (topicKeywords.get(key) || 0) + 1);
+        }
+      }
+    }
+    return Array.from(topicKeywords.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([topic]) => topic);
+  }
+  /**
+   * 估算 token 数量
+   */
+  static estimateTokens(messages) {
+    let totalChars = 0;
+    for (const msg of messages) {
+      const content = this.extractTextContent(msg);
+      totalChars += content.length;
+      if (msg.toolUseResult?.stdout) {
+        totalChars += msg.toolUseResult.stdout.length;
+      }
+    }
+    return Math.ceil(totalChars / 4);
+  }
+}
+class ContextManager {
+  claudeDir;
+  projectsDir;
+  archiveDir;
+  summaryDir;
+  constructor() {
+    this.claudeDir = path.join(os.homedir(), ".claude");
+    this.projectsDir = path.join(this.claudeDir, "projects");
+    this.archiveDir = path.join(this.claudeDir, "archive");
+    this.summaryDir = path.join(this.claudeDir, "summaries");
+    this.ensureDirectories();
+  }
+  ensureDirectories() {
+    for (const dir of [this.archiveDir, this.summaryDir]) {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    }
+  }
+  /**
+   * 获取当前项目的会话文件
+   */
+  getProjectSessions(projectPath) {
+    const projectKey = projectPath ? projectPath.replace(/\//g, "-").replace(/^-/, "") : this.detectCurrentProject();
+    const projectDir = path.join(this.projectsDir, projectKey);
+    if (!fs.existsSync(projectDir)) {
+      return [];
+    }
+    return fs.readdirSync(projectDir).filter((f) => f.endsWith(".jsonl")).map((f) => path.join(projectDir, f));
+  }
+  /**
+   * 检测当前项目
+   */
+  detectCurrentProject() {
+    const cwd = process__default.cwd();
+    return cwd.replace(/\//g, "-").replace(/^-/, "");
+  }
+  /**
+   * 读取会话消息
+   */
+  readSessionMessages(sessionFile) {
+    if (!fs.existsSync(sessionFile)) {
+      return [];
+    }
+    const content = fs.readFileSync(sessionFile, "utf-8");
+    const lines = content.trim().split("\n").filter((l) => l.trim());
+    return lines.map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((msg) => msg !== null);
+  }
+  /**
+   * 压缩会话 - 核心功能
+   */
+  async compact(sessionFile, options = {}) {
+    const {
+      keepLastN = 20,
+      archiveThreshold = 200,
+      preserveDecisions = true,
+      preserveCodeChanges = true
+    } = options;
+    const messages = this.readSessionMessages(sessionFile);
+    const originalCount = messages.length;
+    const originalTokens = ContextAnalyzer.estimateTokens(messages);
+    if (messages.length <= keepLastN) {
+      return {
+        originalMessages: originalCount,
+        compactedMessages: originalCount,
+        summaryGenerated: false,
+        archived: false,
+        tokensSaved: 0
+      };
+    }
+    const scoredMessages = messages.map((msg) => ({
+      message: msg,
+      score: ContextAnalyzer.analyzeImportance(msg)
+    }));
+    const recentMessages = messages.slice(-keepLastN);
+    const olderMessages = messages.slice(0, -keepLastN);
+    const importantOlder = scoredMessages.slice(0, -keepLastN).filter((m) => m.score >= 50).map((m) => m.message);
+    const summary = this.generateSummary(olderMessages);
+    this.saveSummary(sessionFile, summary);
+    let archived = false;
+    if (originalCount >= archiveThreshold) {
+      this.archiveSession(sessionFile, olderMessages);
+      archived = true;
+    }
+    const compactedMessages = [];
+    compactedMessages.push(this.createSummaryMessage(summary));
+    if (preserveDecisions || preserveCodeChanges) {
+      compactedMessages.push(...importantOlder.slice(0, 10));
+    }
+    compactedMessages.push(...recentMessages);
+    this.writeSession(sessionFile, compactedMessages);
+    const compactedTokens = ContextAnalyzer.estimateTokens(compactedMessages);
+    return {
+      originalMessages: originalCount,
+      compactedMessages: compactedMessages.length,
+      summaryGenerated: true,
+      archived,
+      tokensSaved: originalTokens - compactedTokens,
+      summary
+    };
+  }
+  /**
+   * 生成会话摘要
+   */
+  generateSummary(messages) {
+    const id = crypto.randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const keyDecisions = ContextAnalyzer.extractDecisions(messages);
+    const codeChanges = ContextAnalyzer.extractCodeChanges(messages);
+    const topics = ContextAnalyzer.extractTopics(messages);
+    const tokenEstimate = ContextAnalyzer.estimateTokens(messages);
+    const summaryParts = [];
+    if (topics.length > 0) {
+      summaryParts.push(`\u4E3B\u8981\u8BDD\u9898: ${topics.join(", ")}`);
+    }
+    if (keyDecisions.length > 0) {
+      summaryParts.push(`\u5173\u952E\u51B3\u7B56:
+${keyDecisions.map((d) => `  - ${d}`).join("\n")}`);
+    }
+    if (codeChanges.length > 0) {
+      summaryParts.push(`\u4EE3\u7801\u53D8\u66F4:
+${codeChanges.map((c) => `  - ${c.action}: ${c.file}`).join("\n")}`);
+    }
+    return {
+      id,
+      createdAt: now,
+      updatedAt: now,
+      messageCount: messages.length,
+      tokenEstimate,
+      keyDecisions,
+      codeChanges,
+      topics,
+      summary: summaryParts.join("\n\n")
+    };
+  }
+  /**
+   * 保存摘要
+   */
+  saveSummary(sessionFile, summary) {
+    const sessionId = path.basename(sessionFile, ".jsonl");
+    const summaryFile = path.join(this.summaryDir, `${sessionId}-${summary.id}.json`);
+    fs.writeFileSync(summaryFile, JSON.stringify(summary, null, 2));
+    return summaryFile;
+  }
+  /**
+   * 归档会话
+   */
+  archiveSession(sessionFile, messages) {
+    const sessionId = path.basename(sessionFile, ".jsonl");
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const archiveFile = path.join(this.archiveDir, `${sessionId}-${timestamp}.jsonl`);
+    const content = messages.map((m) => JSON.stringify(m)).join("\n");
+    fs.writeFileSync(archiveFile, content);
+    return archiveFile;
+  }
+  /**
+   * 创建摘要消息
+   */
+  createSummaryMessage(summary) {
+    return {
+      uuid: crypto.randomUUID(),
+      type: "assistant",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      message: {
+        role: "assistant",
+        content: `[\u4F1A\u8BDD\u6458\u8981 - ${summary.messageCount} \u6761\u6D88\u606F\u5DF2\u538B\u7F29]
+
+${summary.summary}`
+      },
+      metadata: {
+        isSummary: true,
+        summaryId: summary.id,
+        originalMessageCount: summary.messageCount,
+        originalTokenEstimate: summary.tokenEstimate
+      }
+    };
+  }
+  /**
+   * 写入会话
+   */
+  writeSession(sessionFile, messages) {
+    const content = messages.map((m) => JSON.stringify(m)).join("\n");
+    fs.writeFileSync(sessionFile, content);
+  }
+  /**
+   * 获取会话状态
+   */
+  getSessionStatus(sessionFile) {
+    const messages = this.readSessionMessages(sessionFile);
+    const tokenEstimate = ContextAnalyzer.estimateTokens(messages);
+    return {
+      messageCount: messages.length,
+      tokenEstimate,
+      oldestMessage: messages[0]?.timestamp || "N/A",
+      newestMessage: messages[messages.length - 1]?.timestamp || "N/A",
+      needsCompact: messages.length > 50 || tokenEstimate > 5e4
+    };
+  }
+  /**
+   * 列出所有摘要
+   */
+  listSummaries() {
+    if (!fs.existsSync(this.summaryDir)) {
+      return [];
+    }
+    return fs.readdirSync(this.summaryDir).filter((f) => f.endsWith(".json")).map((f) => {
+      try {
+        const content = fs.readFileSync(path.join(this.summaryDir, f), "utf-8");
+        return JSON.parse(content);
+      } catch {
+        return null;
+      }
+    }).filter((s) => s !== null);
+  }
+  /**
+   * 恢复归档的会话
+   */
+  restoreArchive(archiveFile, targetSession) {
+    if (!fs.existsSync(archiveFile)) {
+      return false;
+    }
+    const archiveContent = fs.readFileSync(archiveFile, "utf-8");
+    const currentContent = fs.existsSync(targetSession) ? fs.readFileSync(targetSession, "utf-8") : "";
+    const merged = `${archiveContent}
+${currentContent}`;
+    fs.writeFileSync(targetSession, merged.trim());
+    return true;
+  }
+}
+new ContextManager();
+
+class ContextManagerAdapter {
+  baseManager;
+  configPath;
+  historyPath;
+  config;
+  constructor() {
+    this.baseManager = new ContextManager();
+    const ccjkDir = path.join(os.homedir(), ".ccjk");
+    const contextDir = path.join(ccjkDir, "context-compression");
+    if (!fs.existsSync(contextDir)) {
+      fs.mkdirSync(contextDir, { recursive: true });
+    }
+    this.configPath = path.join(contextDir, "config.json");
+    this.historyPath = path.join(contextDir, "history.json");
+    this.config = this.loadConfig();
+  }
+  /**
+   * 加载配置
+   */
+  loadConfig() {
+    const defaultConfig = {
+      autoCompress: true,
+      threshold: 5e4,
+      model: "haiku",
+      maxHistory: 100,
+      retentionDays: 30
+    };
+    if (fs.existsSync(this.configPath)) {
+      try {
+        const content = fs.readFileSync(this.configPath, "utf-8");
+        return { ...defaultConfig, ...JSON.parse(content) };
+      } catch {
+        return defaultConfig;
+      }
+    }
+    fs.writeFileSync(this.configPath, JSON.stringify(defaultConfig, null, 2));
+    return defaultConfig;
+  }
+  /**
+   * 获取当前状态
+   */
+  async getStatus() {
+    const sessions = this.baseManager.getProjectSessions();
+    const currentSession = sessions[sessions.length - 1];
+    let totalTokens = 0;
+    const compressedTokens = 0;
+    let sessionId = null;
+    let startTime = null;
+    if (currentSession) {
+      sessionId = path.basename(currentSession, ".jsonl");
+      const status = this.baseManager.getSessionStatus(currentSession);
+      totalTokens = status.tokenEstimate;
+      try {
+        const stats = fs.statSync(currentSession);
+        startTime = stats.birthtimeMs;
+      } catch {
+      }
+    }
+    const history = await this.getHistory();
+    const todayStart = /* @__PURE__ */ new Date();
+    todayStart.setHours(0, 0, 0, 0);
+    const compressionsToday = history.filter((h) => h.timestamp >= todayStart.getTime()).length;
+    const lastEntry = history[history.length - 1];
+    const lastCompressed = lastEntry?.timestamp || null;
+    const totalSaved = history.reduce((sum, h) => sum + (h.originalTokens - h.compressedTokens), 0);
+    return {
+      sessionId,
+      startTime,
+      duration: startTime ? this.formatDuration(Date.now() - startTime) : null,
+      totalTokens,
+      compressedTokens,
+      compressionRatio: totalTokens > 0 ? compressedTokens / totalTokens : null,
+      tokensSaved: totalSaved,
+      autoCompress: this.config.autoCompress,
+      threshold: this.config.threshold,
+      lastCompressed,
+      compressionsToday,
+      storagePath: path.dirname(this.configPath),
+      cacheSize: this.getCacheSize(),
+      model: this.config.model
+    };
+  }
+  /**
+   * 压缩上下文
+   */
+  async compress(sessionId) {
+    const startTime = Date.now();
+    const sessions = this.baseManager.getProjectSessions();
+    let targetSession;
+    if (sessionId) {
+      targetSession = sessions.find((s) => path.basename(s, ".jsonl").includes(sessionId));
+    } else {
+      targetSession = sessions[sessions.length - 1];
+    }
+    if (!targetSession) {
+      throw new Error("No session found to compress");
+    }
+    const beforeStatus = this.baseManager.getSessionStatus(targetSession);
+    await this.baseManager.compact(targetSession, {
+      keepLastN: 20,
+      preserveDecisions: true,
+      preserveCodeChanges: true
+    });
+    const afterStatus = this.baseManager.getSessionStatus(targetSession);
+    const duration = Date.now() - startTime;
+    await this.addHistoryEntry({
+      id: `compress-${Date.now()}`,
+      timestamp: Date.now(),
+      originalTokens: beforeStatus.tokenEstimate,
+      compressedTokens: afterStatus.tokenEstimate,
+      sessionId: path.basename(targetSession, ".jsonl")
+    });
+    return {
+      originalTokens: beforeStatus.tokenEstimate,
+      compressedTokens: afterStatus.tokenEstimate,
+      duration
+    };
+  }
+  /**
+   * 获取压缩历史
+   */
+  async getHistory() {
+    if (!fs.existsSync(this.historyPath)) {
+      return [];
+    }
+    try {
+      const content = fs.readFileSync(this.historyPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * 添加历史记录
+   */
+  async addHistoryEntry(entry) {
+    const history = await this.getHistory();
+    history.push(entry);
+    const trimmed = history.slice(-this.config.maxHistory);
+    fs.writeFileSync(this.historyPath, JSON.stringify(trimmed, null, 2));
+  }
+  /**
+   * 恢复上下文
+   */
+  async restore(id) {
+    const archiveDir = path.join(os.homedir(), ".claude", "archive");
+    if (!fs.existsSync(archiveDir)) {
+      throw new Error("No archives found");
+    }
+    const archives = fs.readdirSync(archiveDir).filter((f) => f.includes(id));
+    if (archives.length === 0) {
+      throw new Error(`Archive not found: ${id}`);
+    }
+    const archiveFile = path.join(archiveDir, archives[0]);
+    const sessions = this.baseManager.getProjectSessions();
+    const currentSession = sessions[sessions.length - 1];
+    if (!currentSession) {
+      throw new Error("No current session to restore to");
+    }
+    const success = this.baseManager.restoreArchive(archiveFile, currentSession);
+    if (!success) {
+      throw new Error("Failed to restore archive");
+    }
+  }
+  /**
+   * 获取配置
+   */
+  async getConfig() {
+    return this.config;
+  }
+  /**
+   * 清除缓存
+   */
+  async clear() {
+    const contextDir = path.dirname(this.configPath);
+    const cacheFiles = ["history.json"];
+    for (const file of cacheFiles) {
+      const filePath = path.join(contextDir, file);
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    }
+  }
+  /**
+   * 格式化持续时间
+   */
+  formatDuration(ms) {
+    const seconds = Math.floor(ms / 1e3);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+      return `${hours}h ${minutes % 60}m`;
+    }
+    if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    }
+    return `${seconds}s`;
+  }
+  /**
+   * 获取缓存大小
+   */
+  getCacheSize() {
+    const contextDir = path.dirname(this.configPath);
+    let totalSize = 0;
+    try {
+      const files = fs.readdirSync(contextDir);
+      for (const file of files) {
+        const filePath = path.join(contextDir, file);
+        const stats = fs.statSync(filePath);
+        if (stats.isFile()) {
+          totalSize += stats.size;
+        }
+      }
+    } catch {
+      return "N/A";
+    }
+    if (totalSize < 1024) {
+      return `${totalSize} B`;
+    }
+    if (totalSize < 1024 * 1024) {
+      return `${(totalSize / 1024).toFixed(1)} KB`;
+    }
+    return `${(totalSize / (1024 * 1024)).toFixed(1)} MB`;
+  }
+}
+let instance = null;
+function getContextManager() {
+  if (!instance) {
+    instance = new ContextManagerAdapter();
+  }
+  return instance;
+}
+
+export { ContextAnalyzer, getContextManager };