ccjk 4.0.0-beta.1 → 4.0.0-beta.3

package/dist/chunks/context.mjs

@@ -1,248 +1,771 @@
-import chalk from 'chalk';
-import ora from 'ora';
+import * as nodeFs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import ansis from 'ansis';
+import * as crypto from 'node:crypto';
+import process__default from 'node:process';
 
-const { green, yellow, cyan, gray, red, blue } = chalk;
-async function contextCommand(action, id, options) {
-  switch (action) {
-    case "status":
-    case "s":
-      await showStatus(options);
-      break;
-    case "compress":
-    case "c":
-      await triggerCompress(id, options);
-      break;
-    case "history":
-    case "h":
-      await showHistory(options);
-      break;
-    case "restore":
-    case "r":
-      await restoreContext(id, options);
-      break;
-    case "config":
-    case "cfg":
-      await configureContext(options);
-      break;
-    case "clear":
-      await clearContext(options);
-      break;
-    case "hook":
-      await handleHookCommand(id, options);
-      break;
-    case "help":
-    default:
-      showHelp();
+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);
   }
 }
-async function handleHookCommand(subAction, options) {
-  const { contextCommand: hookContextCommand } = await import('./claude-wrapper.mjs');
-  await hookContextCommand(subAction || "status", [], {
-    lang: options.lang,
-    verbose: options.verbose
-  });
-}
-async function showStatus(options) {
-  const spinner = ora("Loading context status...").start();
-  try {
-    const { getContextManager } = await import('./context-manager.mjs');
-    const manager = getContextManager();
-    const status = await manager.getStatus();
-    spinner.stop();
-    console.log(`
-${cyan("\u{1F9E0} Context Compression Status")}
-`);
-    console.log(`${yellow("Current Session:")}`);
-    console.log(`  ${gray("ID:")} ${status.sessionId || "None"}`);
-    console.log(`  ${gray("Started:")} ${status.startTime ? new Date(status.startTime).toLocaleString() : "N/A"}`);
-    console.log(`  ${gray("Duration:")} ${status.duration || "N/A"}`);
-    console.log(`
-${yellow("Context Statistics:")}`);
-    console.log(`  ${gray("Total Tokens:")} ${status.totalTokens?.toLocaleString() || 0}`);
-    console.log(`  ${gray("Compressed Tokens:")} ${status.compressedTokens?.toLocaleString() || 0}`);
-    console.log(`  ${gray("Compression Ratio:")} ${status.compressionRatio ? `${(status.compressionRatio * 100).toFixed(1)}%` : "N/A"}`);
-    console.log(`  ${gray("Savings:")} ${status.tokensSaved?.toLocaleString() || 0} tokens`);
-    console.log(`
-${yellow("Compression Status:")}`);
-    console.log(`  ${gray("Auto-compress:")} ${status.autoCompress ? green("Enabled") : gray("Disabled")}`);
-    console.log(`  ${gray("Threshold:")} ${status.threshold?.toLocaleString() || "N/A"} tokens`);
-    console.log(`  ${gray("Last Compressed:")} ${status.lastCompressed ? new Date(status.lastCompressed).toLocaleString() : "Never"}`);
-    console.log(`  ${gray("Compressions Today:")} ${status.compressionsToday || 0}`);
-    if (options.verbose) {
-      console.log(`
-${yellow("Detailed Info:")}`);
-      console.log(`  ${gray("Storage Path:")} ${status.storagePath || "N/A"}`);
-      console.log(`  ${gray("Cache Size:")} ${status.cacheSize || "N/A"}`);
-      console.log(`  ${gray("Model:")} ${status.model || "haiku"}`);
+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 (!nodeFs.existsSync(dir)) {
+        nodeFs.mkdirSync(dir, { recursive: true });
+      }
     }
-    console.log();
-  } catch (error) {
-    spinner.fail(red("Failed to get context status"));
-    if (options.verbose) {
-      console.error(error);
-    } else {
-      console.log(gray("Run with --verbose for details"));
+  }
+  /**
+   * 获取当前项目的会话文件
+   */
+  getProjectSessions(projectPath) {
+    const projectKey = projectPath ? projectPath.replace(/\//g, "-").replace(/^-/, "") : this.detectCurrentProject();
+    const projectDir = path.join(this.projectsDir, projectKey);
+    if (!nodeFs.existsSync(projectDir)) {
+      return [];
     }
+    return nodeFs.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 (!nodeFs.existsSync(sessionFile)) {
+      return [];
+    }
+    const content = nodeFs.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`);
+    nodeFs.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");
+    nodeFs.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");
+    nodeFs.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 (!nodeFs.existsSync(this.summaryDir)) {
+      return [];
+    }
+    return nodeFs.readdirSync(this.summaryDir).filter((f) => f.endsWith(".json")).map((f) => {
+      try {
+        const content = nodeFs.readFileSync(path.join(this.summaryDir, f), "utf-8");
+        return JSON.parse(content);
+      } catch {
+        return null;
+      }
+    }).filter((s) => s !== null);
+  }
+  /**
+   * 恢复归档的会话
+   */
+  restoreArchive(archiveFile, targetSession) {
+    if (!nodeFs.existsSync(archiveFile)) {
+      return false;
+    }
+    const archiveContent = nodeFs.readFileSync(archiveFile, "utf-8");
+    const currentContent = nodeFs.existsSync(targetSession) ? nodeFs.readFileSync(targetSession, "utf-8") : "";
+    const merged = `${archiveContent}
+${currentContent}`;
+    nodeFs.writeFileSync(targetSession, merged.trim());
+    return true;
+  }
+}
+const contextManager = new ContextManager();
+
+const chalk = ansis;
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(2)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+function formatNumber(num) {
+  return num.toLocaleString();
 }
-async function triggerCompress(sessionId, options) {
-  const spinner = ora("Compressing context...").start();
+function formatDate(dateStr) {
   try {
-    const { getContextManager } = await import('./context-manager.mjs');
-    const manager = getContextManager();
-    const targetSession = sessionId || options.session;
-    const result = await manager.compress(targetSession);
-    spinner.succeed(green("Context compressed successfully"));
-    console.log(`
-${cyan("Compression Result:")}`);
-    console.log(`  ${gray("Original Tokens:")} ${result.originalTokens.toLocaleString()}`);
-    console.log(`  ${gray("Compressed Tokens:")} ${result.compressedTokens.toLocaleString()}`);
-    console.log(`  ${gray("Reduction:")} ${((1 - result.compressedTokens / result.originalTokens) * 100).toFixed(1)}%`);
-    console.log(`  ${gray("Time:")} ${result.duration}ms`);
+    const date = new Date(dateStr);
+    return date.toLocaleString("zh-CN", {
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit"
+    });
+  } catch {
+    return dateStr;
+  }
+}
+function printHeader(title) {
+  console.log();
+  console.log(chalk.cyan.bold(`\u{1F4E6} ${title}`));
+  console.log(chalk.gray("\u2500".repeat(50)));
+}
+function printSuccess(message) {
+  console.log(chalk.green(`\u2714 ${message}`));
+}
+function printWarning(message) {
+  console.log(chalk.yellow(`\u26A0 ${message}`));
+}
+function printError(message) {
+  console.log(chalk.red(`\u2716 ${message}`));
+}
+function printInfo(label, value) {
+  console.log(`  ${chalk.gray(label.padEnd(20))} ${chalk.white(value)}`);
+}
+async function contextStatus(_options = {}) {
+  printHeader("Context Status");
+  const sessions = contextManager.getProjectSessions();
+  if (sessions.length === 0) {
+    printWarning("No sessions found for current project");
+    return;
+  }
+  let totalMessages = 0;
+  let totalTokens = 0;
+  for (const sessionFile of sessions) {
+    const status = contextManager.getSessionStatus(sessionFile);
+    const sessionId = path.basename(sessionFile, ".jsonl");
     console.log();
-  } catch (error) {
-    spinner.fail(red("Compression failed"));
-    if (options.verbose) {
-      console.error(error);
+    console.log(chalk.white.bold(`Session: ${sessionId.slice(0, 8)}...`));
+    printInfo("Messages", formatNumber(status.messageCount));
+    printInfo("Est. Tokens", formatNumber(status.tokenEstimate));
+    printInfo("Oldest", formatDate(status.oldestMessage));
+    printInfo("Newest", formatDate(status.newestMessage));
+    if (status.needsCompact) {
+      console.log(chalk.yellow(`  \u26A0 Needs compact (${status.messageCount > 50 ? "too many messages" : "high token count"})`));
+    } else {
+      console.log(chalk.green(`  \u2714 Healthy`));
     }
+    totalMessages += status.messageCount;
+    totalTokens += status.tokenEstimate;
+  }
+  console.log();
+  console.log(chalk.gray("\u2500".repeat(50)));
+  console.log(chalk.cyan.bold("Total:"));
+  printInfo("Sessions", sessions.length.toString());
+  printInfo("Messages", formatNumber(totalMessages));
+  printInfo("Est. Tokens", formatNumber(totalTokens));
+  if (totalTokens > 1e5) {
+    console.log();
+    printWarning(`High token usage detected. Run ${chalk.cyan("ccjk context compact")} to optimize.`);
   }
 }
-async function showHistory(options) {
-  const spinner = ora("Loading compression history...").start();
-  try {
-    const { getContextManager } = await import('./context-manager.mjs');
-    const manager = getContextManager();
-    const history = await manager.getHistory();
-    spinner.stop();
-    if (history.length === 0) {
-      console.log(yellow("\nNo compression history found.\n"));
-      return;
-    }
-    console.log(`
-${cyan("\u{1F4DC} Compression History")}
-`);
-    if (options.format === "json") {
-      console.log(JSON.stringify(history, null, 2));
-      return;
+async function contextCompact(options = {}) {
+  printHeader("Context Compact");
+  const sessions = contextManager.getProjectSessions();
+  if (sessions.length === 0) {
+    printWarning("No sessions found for current project");
+    return;
+  }
+  const compactOptions = {
+    keepLastN: Number.parseInt(options.keep || "20", 10),
+    summarizeThreshold: Number.parseInt(options.threshold || "50", 10),
+    preserveDecisions: options.decisions !== false,
+    preserveCodeChanges: options.codeChanges !== false
+  };
+  console.log(chalk.gray("Compact options:"));
+  printInfo("Keep last N", compactOptions.keepLastN.toString());
+  printInfo("Threshold", compactOptions.summarizeThreshold.toString());
+  printInfo("Preserve decisions", compactOptions.preserveDecisions ? "Yes" : "No");
+  printInfo("Preserve code changes", compactOptions.preserveCodeChanges ? "Yes" : "No");
+  console.log();
+  let totalSaved = 0;
+  let compactedCount = 0;
+  for (const sessionFile of sessions) {
+    const sessionId = path.basename(sessionFile, ".jsonl").slice(0, 8);
+    const status = contextManager.getSessionStatus(sessionFile);
+    if (!options.force && !status.needsCompact) {
+      console.log(chalk.gray(`  \u23ED ${sessionId}... (no compact needed)`));
+      continue;
     }
-    console.log(`${gray("ID".padEnd(12))} ${gray("Date".padEnd(20))} ${gray("Original".padEnd(12))} ${gray("Compressed".padEnd(12))} ${gray("Ratio")}`);
-    console.log(gray("\u2500".repeat(70)));
-    for (const entry of history.slice(0, 20)) {
-      const date = new Date(entry.timestamp).toLocaleString();
-      const ratio = ((1 - entry.compressedTokens / entry.originalTokens) * 100).toFixed(1);
-      console.log(
-        `${entry.id.slice(0, 10).padEnd(12)} ${date.padEnd(20)} ${entry.originalTokens.toString().padEnd(12)} ${entry.compressedTokens.toString().padEnd(12)} ${green(`-${ratio}%`)}`
-      );
+    if (options.dryRun) {
+      console.log(chalk.yellow(`  \u{1F50D} ${sessionId}... (dry run)`));
+      console.log(chalk.gray(`     Would compact ${status.messageCount} messages`));
+      continue;
     }
-    if (history.length > 20) {
-      console.log(gray(`
-... and ${history.length - 20} more entries`));
+    try {
+      console.log(chalk.cyan(`  \u23F3 Compacting ${sessionId}...`));
+      const result = await contextManager.compact(sessionFile, compactOptions);
+      if (result.summaryGenerated) {
+        printSuccess(`${sessionId}: ${result.originalMessages} \u2192 ${result.compactedMessages} messages`);
+        console.log(chalk.gray(`     Tokens saved: ~${formatNumber(result.tokensSaved)}`));
+        if (result.archived) {
+          console.log(chalk.gray(`     Archived to cold storage`));
+        }
+        if (result.summary) {
+          console.log(chalk.gray(`     Topics: ${result.summary.topics.join(", ") || "N/A"}`));
+        }
+        totalSaved += result.tokensSaved;
+        compactedCount++;
+      } else {
+        console.log(chalk.gray(`  \u23ED ${sessionId}... (already compact)`));
+      }
+    } catch (error) {
+      printError(`Failed to compact ${sessionId}: ${error}`);
     }
+  }
+  console.log();
+  console.log(chalk.gray("\u2500".repeat(50)));
+  if (compactedCount > 0) {
+    printSuccess(`Compacted ${compactedCount} session(s)`);
+    console.log(chalk.green(`  Total tokens saved: ~${formatNumber(totalSaved)}`));
+  } else if (options.dryRun) {
+    printInfo("Dry run", "No changes made");
+  } else {
+    printInfo("Result", "All sessions already optimized");
+  }
+}
+async function contextSummaries(options = {}) {
+  printHeader("Session Summaries");
+  const summaries = contextManager.listSummaries();
+  if (summaries.length === 0) {
+    printWarning("No summaries found. Run `ccjk context compact` to generate summaries.");
+    return;
+  }
+  const sorted = summaries.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()).slice(0, Number.parseInt(options.limit || "10", 10));
+  for (const summary of sorted) {
     console.log();
-  } catch (error) {
-    spinner.fail(red("Failed to load history"));
-    if (options.verbose) {
-      console.error(error);
+    console.log(chalk.white.bold(`Summary: ${summary.id.slice(0, 8)}...`));
+    printInfo("Created", formatDate(summary.createdAt));
+    printInfo("Messages", formatNumber(summary.messageCount));
+    printInfo("Est. Tokens", formatNumber(summary.tokenEstimate));
+    if (summary.topics.length > 0) {
+      printInfo("Topics", summary.topics.join(", "));
+    }
+    if (summary.keyDecisions.length > 0) {
+      console.log(chalk.gray("  Key Decisions:"));
+      for (const decision of summary.keyDecisions.slice(0, 3)) {
+        console.log(chalk.gray(`    \u2022 ${decision.slice(0, 80)}${decision.length > 80 ? "..." : ""}`));
+      }
+    }
+    if (summary.codeChanges.length > 0) {
+      console.log(chalk.gray("  Code Changes:"));
+      for (const change of summary.codeChanges.slice(0, 5)) {
+        const fileName = path.basename(change.file);
+        console.log(chalk.gray(`    \u2022 ${change.action}: ${fileName}`));
+      }
     }
   }
+  console.log();
+  console.log(chalk.gray(`Showing ${sorted.length} of ${summaries.length} summaries`));
 }
-async function restoreContext(id, options) {
-  if (!id) {
-    console.log(red("\nError: Please provide a context ID to restore."));
-    console.log(gray("Usage: ccjk context restore <id>\n"));
+async function contextArchives() {
+  printHeader("Archived Sessions");
+  const archiveDir = path.join(os.homedir(), ".claude", "archive");
+  if (!nodeFs.existsSync(archiveDir)) {
+    printWarning("No archives found.");
     return;
   }
-  const spinner = ora(`Restoring context ${id}...`).start();
-  try {
-    const { getContextManager } = await import('./context-manager.mjs');
-    const manager = getContextManager();
-    await manager.restore(id);
-    spinner.succeed(green(`Context ${id} restored successfully`));
+  const archives = nodeFs.readdirSync(archiveDir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+    const filePath = path.join(archiveDir, f);
+    const stats = nodeFs.statSync(filePath);
+    return {
+      name: f,
+      path: filePath,
+      size: stats.size,
+      mtime: stats.mtime
+    };
+  }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+  if (archives.length === 0) {
+    printWarning("No archives found.");
+    return;
+  }
+  for (const archive of archives) {
     console.log();
-  } catch (error) {
-    spinner.fail(red("Failed to restore context"));
-    if (options.verbose) {
-      console.error(error);
+    console.log(chalk.white.bold(archive.name));
+    printInfo("Size", formatBytes(archive.size));
+    printInfo("Archived", formatDate(archive.mtime.toISOString()));
+  }
+  console.log();
+  console.log(chalk.gray(`Total: ${archives.length} archive(s)`));
+  console.log();
+  console.log(chalk.gray(`To restore: ${chalk.cyan("ccjk context restore <archive-file>")}`));
+}
+async function contextRestore(archive, options = {}) {
+  printHeader("Restore Archive");
+  const archiveDir = path.join(os.homedir(), ".claude", "archive");
+  let archivePath = archive;
+  if (!path.isAbsolute(archive)) {
+    archivePath = path.join(archiveDir, archive);
+  }
+  if (!nodeFs.existsSync(archivePath)) {
+    printError(`Archive not found: ${archivePath}`);
+    return;
+  }
+  let targetSession = options.target;
+  if (!targetSession) {
+    const sessions = contextManager.getProjectSessions();
+    if (sessions.length === 0) {
+      printError("No active sessions found. Please specify target with --target");
+      return;
     }
+    targetSession = sessions[sessions.length - 1];
+  }
+  console.log(chalk.gray(`Archive: ${archivePath}`));
+  console.log(chalk.gray(`Target: ${targetSession}`));
+  console.log();
+  const success = contextManager.restoreArchive(archivePath, targetSession);
+  if (success) {
+    printSuccess("Archive restored successfully!");
+    console.log(chalk.gray("The archived messages have been prepended to the target session."));
+  } else {
+    printError("Failed to restore archive");
   }
 }
-async function configureContext(options) {
-  try {
-    const { getContextManager } = await import('./context-manager.mjs');
-    const manager = getContextManager();
-    const config = await manager.getConfig();
-    console.log(`
-${cyan("\u2699\uFE0F  Context Compression Configuration")}
-`);
-    console.log(`${yellow("Current Settings:")}`);
-    console.log(`  ${gray("Auto-compress:")} ${config.autoCompress ? green("Enabled") : gray("Disabled")}`);
-    console.log(`  ${gray("Threshold:")} ${config.threshold.toLocaleString()} tokens`);
-    console.log(`  ${gray("Model:")} ${config.model}`);
-    console.log(`  ${gray("Max History:")} ${config.maxHistory} entries`);
-    console.log(`  ${gray("Retention Days:")} ${config.retentionDays} days`);
-    console.log(`
-${yellow("To modify settings:")}`);
-    console.log(`  ${gray("Edit:")} ~/.ccjk/context-compression/config.json`);
-    console.log(`  ${gray("Or use:")} ccjk config context.<setting> <value>`);
+async function contextAnalyze() {
+  printHeader("Context Analysis");
+  const sessions = contextManager.getProjectSessions();
+  if (sessions.length === 0) {
+    printWarning("No sessions found for current project");
+    return;
+  }
+  const latestSession = sessions[sessions.length - 1];
+  const messages = contextManager.readSessionMessages(latestSession);
+  if (messages.length === 0) {
+    printWarning("No messages in current session");
+    return;
+  }
+  console.log(chalk.gray(`Analyzing ${messages.length} messages...`));
+  console.log();
+  const topics = ContextAnalyzer.extractTopics(messages);
+  const decisions = ContextAnalyzer.extractDecisions(messages);
+  const codeChanges = ContextAnalyzer.extractCodeChanges(messages);
+  const tokenEstimate = ContextAnalyzer.estimateTokens(messages);
+  const importanceScores = messages.map((m) => ContextAnalyzer.analyzeImportance(m));
+  const avgImportance = importanceScores.reduce((a, b) => a + b, 0) / importanceScores.length;
+  const highImportance = importanceScores.filter((s) => s >= 50).length;
+  console.log(chalk.white.bold("\u{1F4CA} Statistics"));
+  printInfo("Total Messages", formatNumber(messages.length));
+  printInfo("Est. Tokens", formatNumber(tokenEstimate));
+  printInfo("Avg Importance", avgImportance.toFixed(1));
+  printInfo("High Importance", `${highImportance} (${(highImportance / messages.length * 100).toFixed(1)}%)`);
+  if (topics.length > 0) {
     console.log();
-  } catch (error) {
-    console.error(red("Failed to load configuration"));
-    if (options.verbose) {
-      console.error(error);
+    console.log(chalk.white.bold("\u{1F3F7}\uFE0F Topics"));
+    for (const topic of topics) {
+      console.log(chalk.gray(`  \u2022 ${topic}`));
     }
   }
-}
-async function clearContext(options) {
-  const spinner = ora("Clearing context cache...").start();
-  try {
-    const { getContextManager } = await import('./context-manager.mjs');
-    const manager = getContextManager();
-    await manager.clear();
-    spinner.succeed(green("Context cache cleared"));
+  if (decisions.length > 0) {
+    console.log();
+    console.log(chalk.white.bold("\u{1F3AF} Key Decisions"));
+    for (const decision of decisions.slice(0, 5)) {
+      console.log(chalk.gray(`  \u2022 ${decision.slice(0, 100)}${decision.length > 100 ? "..." : ""}`));
+    }
+  }
+  if (codeChanges.length > 0) {
     console.log();
-  } catch (error) {
-    spinner.fail(red("Failed to clear cache"));
-    if (options.verbose) {
-      console.error(error);
+    console.log(chalk.white.bold("\u{1F4DD} Code Changes"));
+    for (const change of codeChanges.slice(0, 10)) {
+      const fileName = path.basename(change.file);
+      const icon = change.action === "create" ? "\u2795" : change.action === "modify" ? "\u270F\uFE0F" : "\u{1F5D1}\uFE0F";
+      console.log(chalk.gray(`  ${icon} ${fileName}`));
     }
   }
+  console.log();
+  console.log(chalk.white.bold("\u{1F4A1} Recommendations"));
+  if (tokenEstimate > 5e4) {
+    console.log(chalk.yellow(`  \u2022 High token usage. Consider running ${chalk.cyan("ccjk context compact")}`));
+  }
+  if (messages.length > 100) {
+    console.log(chalk.yellow(`  \u2022 Many messages. Consider archiving old conversations.`));
+  }
+  if (highImportance < messages.length * 0.1) {
+    console.log(chalk.gray(`  \u2022 Most messages are low importance. Safe to compact.`));
+  }
+  if (tokenEstimate < 2e4 && messages.length < 50) {
+    console.log(chalk.green(`  \u2022 Session is healthy. No action needed.`));
+  }
 }
-function showHelp() {
-  console.log(`
-${cyan("\u{1F9E0} Context Compression Commands")}
-
-${yellow("Usage:")} ccjk context <action> [id] [options]
-
-${yellow("Actions:")}
-  ${green("status")}    ${gray("s")}     Show current context status
-  ${green("compress")}  ${gray("c")}     Manually trigger compression
-  ${green("history")}   ${gray("h")}     View compression history
-  ${green("restore")}   ${gray("r")}     Restore a previous context
-  ${green("config")}    ${gray("cfg")}   View/edit configuration
-  ${green("clear")}             Clear context cache
-  ${green("hook")}              Shell hook management
-  ${green("help")}              Show this help
-
-${yellow("Hook Subcommands:")}
-  ${green("hook install")}      Install shell hook for transparent wrapping
-  ${green("hook uninstall")}    Remove shell hook
-  ${green("hook status")}       Show hook installation status
-
-${yellow("Options:")}
-  ${blue("--session, -s")} <id>    Session ID to operate on
-  ${blue("--format, -f")} <fmt>    Output format (json, text)
-  ${blue("--verbose, -v")}         Show detailed output
-
-${yellow("Examples:")}
-  ${gray("ccjk context status")}           Show current status
-  ${gray("ccjk ctx s -v")}                 Status with details
-  ${gray("ccjk context compress")}         Compress current session
-  ${gray("ccjk context history -f json")}  History in JSON format
-  ${gray("ccjk context restore abc123")}   Restore specific context
-  ${gray("ccjk context hook install")}     Install shell hook
-
-${yellow("Aliases:")} ctx
-`);
+async function context(action, args = [], options = {}) {
+  switch (action) {
+    case "status":
+      await contextStatus({ all: options.all });
+      break;
+    case "compact":
+      await contextCompact({
+        keep: options.keep,
+        threshold: options.threshold,
+        decisions: options.decisions,
+        codeChanges: options.codeChanges,
+        force: options.force,
+        dryRun: options.dryRun
+      });
+      break;
+    case "summaries":
+    case "sum":
+      await contextSummaries({ limit: options.limit });
+      break;
+    case "archives":
+    case "arch":
+      await contextArchives();
+      break;
+    case "restore":
+      if (args.length === 0) {
+        printError("Please specify an archive file to restore");
+        console.log(chalk.gray(`Usage: ccjk context restore <archive-file>`));
+        return;
+      }
+      await contextRestore(args[0], { target: options.target });
+      break;
+    case "analyze":
+      await contextAnalyze();
+      break;
+    default:
+      console.log();
+      console.log(chalk.cyan.bold("\u{1F4E6} Context Management Commands"));
+      console.log();
+      console.log(chalk.white("Usage: ccjk context <action> [options]"));
+      console.log();
+      console.log(chalk.white("Actions:"));
+      console.log(`${chalk.gray("  status     ")}View current session status`);
+      console.log(`${chalk.gray("  compact    ")}Smart compress sessions (preserve key info)`);
+      console.log(`${chalk.gray("  summaries  ")}View all session summaries`);
+      console.log(`${chalk.gray("  archives   ")}View archived sessions`);
+      console.log(`${chalk.gray("  restore    ")}Restore an archived session`);
+      console.log(`${chalk.gray("  analyze    ")}Analyze current session content`);
+      console.log();
+      console.log(chalk.white("Examples:"));
+      console.log(chalk.gray("  ccjk context status"));
+      console.log(chalk.gray("  ccjk context compact --keep 20"));
+      console.log(chalk.gray("  ccjk context restore session-123.jsonl"));
+      break;
+  }
 }
 
-export { contextCommand };
+export { context, contextAnalyze, contextArchives, contextCompact, contextRestore, contextStatus, contextSummaries };