@claude-sessions/core 0.3.6 → 0.3.7

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { M as MessagePayload, a as Message, P as Project, T as TodoItem, F as FileChange, b as MoveSessionResult, S as SearchResult, c as SummaryInfo, A as AgentInfo } from './types-C2fzbmg9.js';
-export { i as CleanupPreview, h as ClearSessionsResult, C as ContentItem, D as DeleteSessionResult, k as ProjectTreeData, R as RenameSessionResult, l as ResumeSessionOptions, m as ResumeSessionResult, f as SessionFilesSummary, d as SessionMeta, e as SessionTodos, j as SessionTreeData, g as SplitSessionResult } from './types-C2fzbmg9.js';
+import { M as MessagePayload, a as Message, P as Project, T as TodoItem, F as FileChange, C as CompressSessionOptions, S as SummarizeSessionOptions, b as ConversationLine, c as MoveSessionResult, d as SearchResult, e as SummaryInfo, A as AgentInfo } from './types-Cz8chaYQ.js';
+export { l as CleanupPreview, k as ClearSessionsResult, s as CompressSessionResult, f as ContentItem, D as DeleteSessionResult, t as ProjectKnowledge, n as ProjectTreeData, R as RenameSessionResult, o as ResumeSessionOptions, p as ResumeSessionResult, r as SessionAnalysis, i as SessionFilesSummary, g as SessionMeta, h as SessionTodos, m as SessionTreeData, j as SplitSessionResult, u as SummarizeSessionResult, q as ToolUsageStats } from './types-Cz8chaYQ.js';
 import * as effect_Cause from 'effect/Cause';
 import { Effect } from 'effect';
 
@@ -11,7 +11,9 @@ interface FileSystem {
     readFileSync: (path: string, encoding: 'utf-8') => string;
     readdirSync: (path: string) => string[];
 }
-/** Get Claude sessions directory (~/.claude/projects) */
+/** Get Claude sessions directory (~/.claude/projects)
+ * Can be overridden with CLAUDE_SESSIONS_DIR environment variable for testing
+ */
 declare const getSessionsDir: () => string;
 /** Get Claude todos directory (~/.claude/todos) */
 declare const getTodosDir: () => string;
@@ -94,6 +96,11 @@ declare const findOrphanAgents: (projectName: string) => Effect.Effect<{
 declare const deleteOrphanAgents: (projectName: string) => Effect.Effect<{
     success: boolean;
     deletedAgents: string[];
+    backedUpAgents: string[];
+    cleanedFolders: string[];
+    deletedCount: number;
+    backedUpCount: number;
+    cleanedFolderCount: number;
     count: number;
 }, effect_Cause.UnknownException, never>;
 declare const loadAgentMessages: (projectName: string, _sessionId: string, // Reserved for future validation
@@ -168,6 +175,34 @@ declare const getSessionFiles: (projectName: string, sessionId: string) => Effec
     files: FileChange[];
     totalChanges: number;
 }, effect_Cause.UnknownException, never>;
+declare const analyzeSession: (projectName: string, sessionId: string) => Effect.Effect<{
+    sessionId: string;
+    projectName: string;
+    durationMinutes: number;
+    stats: {
+        totalMessages: number;
+        userMessages: number;
+        assistantMessages: number;
+        summaryCount: number;
+        snapshotCount: number;
+    };
+    toolUsage: {
+        name: string;
+        count: number;
+        errorCount: number;
+    }[];
+    filesChanged: string[];
+    patterns: {
+        type: string;
+        description: string;
+        count: number;
+    }[];
+    milestones: {
+        timestamp?: string;
+        description: string;
+        messageUuid?: string;
+    }[];
+}, effect_Cause.UnknownException, never>;
 declare const moveSession: (sourceProject: string, sessionId: string, targetProject: string) => Effect.Effect<MoveSessionResult, Error>;
 declare const splitSession: (projectName: string, sessionId: string, splitAtMessageUuid: string) => Effect.Effect<{
     success: false;
@@ -277,6 +312,37 @@ declare const loadProjectTreeData: (projectName: string) => Effect.Effect<{
 declare const updateSessionSummary: (projectName: string, sessionId: string, newSummary: string) => Effect.Effect<{
     success: boolean;
 }, effect_Cause.UnknownException, never>;
+declare const compressSession: (projectName: string, sessionId: string, options?: CompressSessionOptions) => Effect.Effect<{
+    success: true;
+    originalSize: number;
+    compressedSize: number;
+    removedSnapshots: number;
+    truncatedOutputs: number;
+}, effect_Cause.UnknownException, never>;
+declare const extractProjectKnowledge: (projectName: string, sessionIds?: string[]) => Effect.Effect<{
+    projectName: string;
+    patterns: never[];
+    hotFiles: {
+        path: string;
+        modifyCount: number;
+        lastModified: string | undefined;
+    }[];
+    workflows: {
+        sequence: string[];
+        count: number;
+    }[];
+    decisions: {
+        context: string;
+        decision: string;
+        sessionId: string;
+    }[];
+}, effect_Cause.UnknownException, never>;
+declare const summarizeSession: (projectName: string, sessionId: string, options?: SummarizeSessionOptions) => Effect.Effect<{
+    sessionId: string;
+    projectName: string;
+    lines: ConversationLine[];
+    formatted: string;
+}, effect_Cause.UnknownException, never>;
 
 /**
  * Simple logger abstraction for Claude Sessions
@@ -312,4 +378,4 @@ declare const getLogger: () => Logger;
  */
 declare const createLogger: (namespace: string) => Logger;
 
-export { AgentInfo, FileChange, type Logger, Message, MessagePayload, MoveSessionResult, Project, SearchResult, SummaryInfo, TodoItem, clearSessions, createLogger, deleteLinkedTodos, deleteMessage, deleteOrphanAgents, deleteOrphanTodos, deleteSession, displayPathToFolderName, extractTextContent, extractTitle, findLinkedAgents, findLinkedTodos, findOrphanAgents, findOrphanTodos, findProjectByWorkspacePath, folderNameToDisplayPath, folderNameToPath, getDisplayTitle, getLogger, getRealPathFromSession, getSessionFiles, getSessionsDir, getTodosDir, isContinuationSummary, isInvalidApiKeyMessage, listProjects, listSessions, loadAgentMessages, loadProjectTreeData, loadSessionTreeData, maskHomePath, moveSession, pathToFolderName, previewCleanup, readSession, renameSession, restoreMessage, searchSessions, sessionHasTodos, setLogger, sortProjects, splitSession, updateSessionSummary };
+export { AgentInfo, CompressSessionOptions, ConversationLine, FileChange, type Logger, Message, MessagePayload, MoveSessionResult, Project, SearchResult, SummarizeSessionOptions, SummaryInfo, TodoItem, analyzeSession, clearSessions, compressSession, createLogger, deleteLinkedTodos, deleteMessage, deleteOrphanAgents, deleteOrphanTodos, deleteSession, displayPathToFolderName, extractProjectKnowledge, extractTextContent, extractTitle, findLinkedAgents, findLinkedTodos, findOrphanAgents, findOrphanTodos, findProjectByWorkspacePath, folderNameToDisplayPath, folderNameToPath, getDisplayTitle, getLogger, getRealPathFromSession, getSessionFiles, getSessionsDir, getTodosDir, isContinuationSummary, isInvalidApiKeyMessage, listProjects, listSessions, loadAgentMessages, loadProjectTreeData, loadSessionTreeData, maskHomePath, moveSession, pathToFolderName, previewCleanup, readSession, renameSession, restoreMessage, searchSessions, sessionHasTodos, setLogger, sortProjects, splitSession, summarizeSession, updateSessionSummary };

package/dist/index.js

@@ -24,7 +24,7 @@ var createLogger = (namespace) => ({
 
 // src/paths.ts
 var log = createLogger("paths");
-var getSessionsDir = () => path.join(os.homedir(), ".claude", "projects");
+var getSessionsDir = () => process.env.CLAUDE_SESSIONS_DIR || path.join(os.homedir(), ".claude", "projects");
 var getTodosDir = () => path.join(os.homedir(), ".claude", "todos");
 var extractCwdFromContent = (content) => {
   const lines = content.split("\n").filter((l) => l.trim());
@@ -80,22 +80,22 @@ var pathToFolderName = (absolutePath) => {
   return convertNonAscii(absolutePath).replace(/^\//g, "-").replace(/\/\./g, "--").replace(/\//g, "-").replace(/\./g, "-");
 };
 var tryGetCwdFromFile = (filePath, fileSystem = fs, logger2 = log) => {
-  const basename2 = path.basename(filePath);
+  const basename3 = path.basename(filePath);
   try {
     const content = fileSystem.readFileSync(filePath, "utf-8");
     const cwd = extractCwdFromContent(content);
     if (cwd === null) {
       const lines = content.split("\n").filter((l) => l.trim());
       if (lines.length === 0) {
-        logger2.debug(`tryGetCwdFromFile: ${basename2} -> empty file`);
+        logger2.debug(`tryGetCwdFromFile: ${basename3} -> empty file`);
       } else {
-        logger2.debug(`tryGetCwdFromFile: ${basename2} -> no cwd found in ${lines.length} lines`);
+        logger2.debug(`tryGetCwdFromFile: ${basename3} -> no cwd found in ${lines.length} lines`);
       }
       return null;
     }
     return cwd;
   } catch (e) {
-    logger2.warn(`tryGetCwdFromFile: ${basename2} -> read error: ${e}`);
+    logger2.warn(`tryGetCwdFromFile: ${basename3} -> read error: ${e}`);
     return null;
   }
 };
@@ -298,46 +298,127 @@ var findLinkedAgents = (projectName, sessionId) => Effect.gen(function* () {
   }
   return linkedAgents;
 });
-var findOrphanAgents = (projectName) => Effect.gen(function* () {
+var findOrphanAgentsWithPaths = (projectName) => Effect.gen(function* () {
   const projectPath = path2.join(getSessionsDir(), projectName);
   const files = yield* Effect.tryPromise(() => fs2.readdir(projectPath));
   const sessionIds = new Set(
     files.filter((f) => !f.startsWith("agent-") && f.endsWith(".jsonl")).map((f) => f.replace(".jsonl", ""))
   );
-  const agentFiles = files.filter((f) => f.startsWith("agent-") && f.endsWith(".jsonl"));
   const orphanAgents = [];
-  for (const agentFile of agentFiles) {
+  const checkAgentFile = async (filePath) => {
+    try {
+      const content = await fs2.readFile(filePath, "utf-8");
+      const lines = content.split("\n").filter((l) => l.trim());
+      const firstLine = lines[0];
+      if (!firstLine) return null;
+      const parsed = JSON.parse(firstLine);
+      if (parsed.sessionId && !sessionIds.has(parsed.sessionId)) {
+        const fileName = path2.basename(filePath);
+        return {
+          agentId: fileName.replace(".jsonl", ""),
+          sessionId: parsed.sessionId,
+          lineCount: lines.length
+        };
+      }
+    } catch {
+    }
+    return null;
+  };
+  const rootAgentFiles = files.filter((f) => f.startsWith("agent-") && f.endsWith(".jsonl"));
+  for (const agentFile of rootAgentFiles) {
     const filePath = path2.join(projectPath, agentFile);
-    const content = yield* Effect.tryPromise(() => fs2.readFile(filePath, "utf-8"));
-    const firstLine = content.split("\n")[0];
-    if (firstLine) {
-      try {
-        const parsed = JSON.parse(firstLine);
-        if (parsed.sessionId && !sessionIds.has(parsed.sessionId)) {
-          orphanAgents.push({
-            agentId: agentFile.replace(".jsonl", ""),
-            sessionId: parsed.sessionId
-          });
+    const orphan = yield* Effect.tryPromise(() => checkAgentFile(filePath));
+    if (orphan) {
+      orphanAgents.push({ ...orphan, filePath });
+    }
+  }
+  for (const entry of files) {
+    const entryPath = path2.join(projectPath, entry);
+    const stat3 = yield* Effect.tryPromise(() => fs2.stat(entryPath).catch(() => null));
+    if (stat3?.isDirectory() && !entry.startsWith(".")) {
+      const subagentsPath = path2.join(entryPath, "subagents");
+      const subagentsExists = yield* Effect.tryPromise(
+        () => fs2.stat(subagentsPath).then(() => true).catch(() => false)
+      );
+      if (subagentsExists) {
+        const subagentFiles = yield* Effect.tryPromise(
+          () => fs2.readdir(subagentsPath).catch(() => [])
+        );
+        for (const subagentFile of subagentFiles) {
+          if (subagentFile.startsWith("agent-") && subagentFile.endsWith(".jsonl")) {
+            const filePath = path2.join(subagentsPath, subagentFile);
+            const orphan = yield* Effect.tryPromise(() => checkAgentFile(filePath));
+            if (orphan) {
+              orphanAgents.push({ ...orphan, filePath });
+            }
+          }
         }
-      } catch {
       }
     }
   }
   return orphanAgents;
 });
+var findOrphanAgents = (projectName) => Effect.gen(function* () {
+  const orphans = yield* findOrphanAgentsWithPaths(projectName);
+  return orphans.map(({ agentId, sessionId }) => ({ agentId, sessionId }));
+});
 var deleteOrphanAgents = (projectName) => Effect.gen(function* () {
   const projectPath = path2.join(getSessionsDir(), projectName);
-  const orphans = yield* findOrphanAgents(projectName);
-  const backupDir = path2.join(projectPath, ".bak");
-  yield* Effect.tryPromise(() => fs2.mkdir(backupDir, { recursive: true }));
+  const orphans = yield* findOrphanAgentsWithPaths(projectName);
   const deletedAgents = [];
+  const backedUpAgents = [];
+  const cleanedFolders = [];
+  let backupDirCreated = false;
+  const foldersToCheck = /* @__PURE__ */ new Set();
   for (const orphan of orphans) {
-    const agentPath = path2.join(projectPath, `${orphan.agentId}.jsonl`);
-    const agentBackupPath = path2.join(backupDir, `${orphan.agentId}.jsonl`);
-    yield* Effect.tryPromise(() => fs2.rename(agentPath, agentBackupPath));
-    deletedAgents.push(orphan.agentId);
+    const parentDir = path2.dirname(orphan.filePath);
+    if (parentDir.endsWith("/subagents") || parentDir.endsWith("\\subagents")) {
+      foldersToCheck.add(parentDir);
+    }
+    if (orphan.lineCount <= 2) {
+      yield* Effect.tryPromise(() => fs2.unlink(orphan.filePath));
+      deletedAgents.push(orphan.agentId);
+    } else {
+      if (!backupDirCreated) {
+        const backupDir2 = path2.join(projectPath, ".bak");
+        yield* Effect.tryPromise(() => fs2.mkdir(backupDir2, { recursive: true }));
+        backupDirCreated = true;
+      }
+      const backupDir = path2.join(projectPath, ".bak");
+      const agentBackupPath = path2.join(backupDir, `${orphan.agentId}.jsonl`);
+      yield* Effect.tryPromise(() => fs2.rename(orphan.filePath, agentBackupPath));
+      backedUpAgents.push(orphan.agentId);
+    }
+  }
+  for (const subagentsDir of foldersToCheck) {
+    const isEmpty = yield* Effect.tryPromise(async () => {
+      const files = await fs2.readdir(subagentsDir);
+      return files.length === 0;
+    });
+    if (isEmpty) {
+      yield* Effect.tryPromise(() => fs2.rmdir(subagentsDir));
+      cleanedFolders.push(subagentsDir);
+      const sessionDir = path2.dirname(subagentsDir);
+      const sessionDirEmpty = yield* Effect.tryPromise(async () => {
+        const files = await fs2.readdir(sessionDir);
+        return files.length === 0;
+      });
+      if (sessionDirEmpty) {
+        yield* Effect.tryPromise(() => fs2.rmdir(sessionDir));
+        cleanedFolders.push(sessionDir);
+      }
+    }
   }
-  return { success: true, deletedAgents, count: deletedAgents.length };
+  return {
+    success: true,
+    deletedAgents,
+    backedUpAgents,
+    cleanedFolders,
+    deletedCount: deletedAgents.length,
+    backedUpCount: backedUpAgents.length,
+    cleanedFolderCount: cleanedFolders.length,
+    count: deletedAgents.length + backedUpAgents.length
+  };
 });
 var loadAgentMessages = (projectName, _sessionId, agentId) => Effect.gen(function* () {
   const projectPath = path2.join(getSessionsDir(), projectName);
@@ -688,8 +769,8 @@ var deleteSession = (projectName, sessionId) => Effect3.gen(function* () {
   const projectPath = path4.join(sessionsDir, projectName);
   const filePath = path4.join(projectPath, `${sessionId}.jsonl`);
   const linkedAgents = yield* findLinkedAgents(projectName, sessionId);
-  const stat2 = yield* Effect3.tryPromise(() => fs4.stat(filePath));
-  if (stat2.size === 0) {
+  const stat3 = yield* Effect3.tryPromise(() => fs4.stat(filePath));
+  if (stat3.size === 0) {
     yield* Effect3.tryPromise(() => fs4.unlink(filePath));
     const agentBackupDir2 = path4.join(projectPath, ".bak");
     yield* Effect3.tryPromise(() => fs4.mkdir(agentBackupDir2, { recursive: true }));
@@ -865,6 +946,137 @@ var getSessionFiles = (projectName, sessionId) => Effect3.gen(function* () {
     totalChanges: fileChanges.length
   };
 });
+var analyzeSession = (projectName, sessionId) => Effect3.gen(function* () {
+  const messages = yield* readSession(projectName, sessionId);
+  let userMessages = 0;
+  let assistantMessages = 0;
+  let summaryCount = 0;
+  let snapshotCount = 0;
+  const toolUsageMap = /* @__PURE__ */ new Map();
+  const filesChanged = /* @__PURE__ */ new Set();
+  const patterns = [];
+  const milestones = [];
+  let firstTimestamp;
+  let lastTimestamp;
+  for (const msg of messages) {
+    if (msg.timestamp) {
+      if (!firstTimestamp) firstTimestamp = msg.timestamp;
+      lastTimestamp = msg.timestamp;
+    }
+    if (msg.type === "user") {
+      userMessages++;
+      const content = typeof msg.content === "string" ? msg.content : "";
+      if (content.toLowerCase().includes("commit") || content.toLowerCase().includes("\uC644\uB8CC")) {
+        milestones.push({
+          timestamp: msg.timestamp,
+          description: `User checkpoint: ${content.slice(0, 50)}...`,
+          messageUuid: msg.uuid
+        });
+      }
+    } else if (msg.type === "assistant") {
+      assistantMessages++;
+      if (msg.message?.content && Array.isArray(msg.message.content)) {
+        for (const item of msg.message.content) {
+          if (item && typeof item === "object" && "type" in item && item.type === "tool_use") {
+            const toolUse = item;
+            const toolName = toolUse.name ?? "unknown";
+            const existing = toolUsageMap.get(toolName) ?? { count: 0, errorCount: 0 };
+            existing.count++;
+            toolUsageMap.set(toolName, existing);
+            if ((toolName === "Write" || toolName === "Edit") && toolUse.input?.file_path) {
+              filesChanged.add(toolUse.input.file_path);
+            }
+          }
+        }
+      }
+    } else if (msg.type === "summary") {
+      summaryCount++;
+      if (msg.summary) {
+        milestones.push({
+          timestamp: msg.timestamp,
+          description: `Summary: ${msg.summary.slice(0, 100)}...`,
+          messageUuid: msg.uuid
+        });
+      }
+    } else if (msg.type === "file-history-snapshot") {
+      snapshotCount++;
+      const snapshot = msg;
+      if (snapshot.snapshot?.trackedFileBackups) {
+        for (const filePath of Object.keys(snapshot.snapshot.trackedFileBackups)) {
+          filesChanged.add(filePath);
+        }
+      }
+    }
+  }
+  for (const msg of messages) {
+    if (msg.type === "user" && msg.content && Array.isArray(msg.content)) {
+      for (const item of msg.content) {
+        if (item && typeof item === "object" && "type" in item && item.type === "tool_result" && "is_error" in item && item.is_error) {
+          const toolResultItem = item;
+          const toolUseId = toolResultItem.tool_use_id;
+          if (toolUseId) {
+            for (const prevMsg of messages) {
+              if (prevMsg.message?.content && Array.isArray(prevMsg.message.content)) {
+                for (const prevItem of prevMsg.message.content) {
+                  if (prevItem && typeof prevItem === "object" && "type" in prevItem && prevItem.type === "tool_use" && "id" in prevItem && prevItem.id === toolUseId) {
+                    const toolName = prevItem.name ?? "unknown";
+                    const existing = toolUsageMap.get(toolName);
+                    if (existing) {
+                      existing.errorCount++;
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  let durationMinutes = 0;
+  if (firstTimestamp && lastTimestamp) {
+    const first = new Date(firstTimestamp).getTime();
+    const last = new Date(lastTimestamp).getTime();
+    durationMinutes = Math.round((last - first) / 1e3 / 60);
+  }
+  const toolUsageArray = Array.from(toolUsageMap.entries()).map(([name, stats]) => ({
+    name,
+    count: stats.count,
+    errorCount: stats.errorCount
+  }));
+  for (const tool of toolUsageArray) {
+    if (tool.count >= 3 && tool.errorCount / tool.count > 0.3) {
+      patterns.push({
+        type: "high_error_rate",
+        description: `${tool.name} had ${tool.errorCount}/${tool.count} errors (${Math.round(tool.errorCount / tool.count * 100)}%)`,
+        count: tool.errorCount
+      });
+    }
+  }
+  if (snapshotCount > 10) {
+    patterns.push({
+      type: "many_snapshots",
+      description: `${snapshotCount} file-history-snapshots could be compressed`,
+      count: snapshotCount
+    });
+  }
+  return {
+    sessionId,
+    projectName,
+    durationMinutes,
+    stats: {
+      totalMessages: messages.length,
+      userMessages,
+      assistantMessages,
+      summaryCount,
+      snapshotCount
+    },
+    toolUsage: toolUsageArray.sort((a, b) => b.count - a.count),
+    filesChanged: Array.from(filesChanged),
+    patterns,
+    milestones
+  };
+});
 var moveSession = (sourceProject, sessionId, targetProject) => Effect3.gen(function* () {
   const sessionsDir = getSessionsDir();
   const sourcePath = path4.join(sessionsDir, sourceProject);
@@ -1072,7 +1284,7 @@ var clearSessions = (options) => Effect3.gen(function* () {
     clearEmpty = true,
     clearInvalid = true,
     skipWithTodos = true,
-    clearOrphanAgents = false,
+    clearOrphanAgents = true,
     clearOrphanTodos = false
   } = options;
   const projects = yield* listProjects;
@@ -1431,8 +1643,194 @@ var updateSessionSummary = (projectName, sessionId, newSummary) => Effect3.gen(f
   yield* Effect3.tryPromise(() => fs4.writeFile(filePath, newContent, "utf-8"));
   return { success: true };
 });
+var compressSession = (projectName, sessionId, options = {}) => Effect3.gen(function* () {
+  const { keepSnapshots = "first_last", maxToolOutputLength = 5e3 } = options;
+  const filePath = path4.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
+  const content = yield* Effect3.tryPromise(() => fs4.readFile(filePath, "utf-8"));
+  const originalSize = Buffer.byteLength(content, "utf-8");
+  const lines = content.trim().split("\n").filter(Boolean);
+  const messages = lines.map((line) => JSON.parse(line));
+  let removedSnapshots = 0;
+  let truncatedOutputs = 0;
+  const snapshotIndices = [];
+  messages.forEach((msg, idx) => {
+    if (msg.type === "file-history-snapshot") {
+      snapshotIndices.push(idx);
+    }
+  });
+  const filteredMessages = messages.filter((msg, idx) => {
+    if (msg.type === "file-history-snapshot") {
+      if (keepSnapshots === "none") {
+        removedSnapshots++;
+        return false;
+      }
+      if (keepSnapshots === "first_last") {
+        const isFirst = idx === snapshotIndices[0];
+        const isLast = idx === snapshotIndices[snapshotIndices.length - 1];
+        if (!isFirst && !isLast) {
+          removedSnapshots++;
+          return false;
+        }
+      }
+    }
+    return true;
+  });
+  for (const msg of filteredMessages) {
+    if (msg.type === "user" && Array.isArray(msg.content)) {
+      for (const item of msg.content) {
+        if (item.type === "tool_result" && typeof item.content === "string") {
+          if (maxToolOutputLength > 0 && item.content.length > maxToolOutputLength) {
+            item.content = item.content.slice(0, maxToolOutputLength) + "\n... [truncated]";
+            truncatedOutputs++;
+          }
+        }
+      }
+    }
+  }
+  const newContent = filteredMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
+  const compressedSize = Buffer.byteLength(newContent, "utf-8");
+  yield* Effect3.tryPromise(() => fs4.writeFile(filePath, newContent, "utf-8"));
+  return {
+    success: true,
+    originalSize,
+    compressedSize,
+    removedSnapshots,
+    truncatedOutputs
+  };
+});
+var extractProjectKnowledge = (projectName, sessionIds) => Effect3.gen(function* () {
+  const sessionsDir = getSessionsDir();
+  const projectDir = path4.join(sessionsDir, projectName);
+  let targetSessionIds = sessionIds;
+  if (!targetSessionIds) {
+    const files = yield* Effect3.tryPromise(() => fs4.readdir(projectDir));
+    targetSessionIds = files.filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-")).map((f) => f.replace(".jsonl", ""));
+  }
+  const fileModifyCount = /* @__PURE__ */ new Map();
+  const toolSequences = [];
+  const decisions = [];
+  for (const sessionId of targetSessionIds) {
+    try {
+      const messages = yield* readSession(projectName, sessionId);
+      for (const msg of messages) {
+        if (msg.type === "file-history-snapshot") {
+          const snapshot = msg;
+          if (snapshot.snapshot?.trackedFileBackups) {
+            for (const filePath of Object.keys(snapshot.snapshot.trackedFileBackups)) {
+              const existing = fileModifyCount.get(filePath) ?? { count: 0 };
+              existing.count++;
+              existing.lastModified = snapshot.snapshot.timestamp;
+              fileModifyCount.set(filePath, existing);
+            }
+          }
+        }
+        if (msg.type === "assistant" && msg.message?.content && Array.isArray(msg.message.content)) {
+          const tools = [];
+          for (const item of msg.message.content) {
+            if (item && typeof item === "object" && "type" in item && item.type === "tool_use") {
+              const toolUse = item;
+              if (toolUse.name) tools.push(toolUse.name);
+            }
+          }
+          if (tools.length > 1) {
+            toolSequences.push(tools);
+          }
+        }
+        if (msg.type === "summary" && msg.summary) {
+          decisions.push({
+            context: "Session summary",
+            decision: msg.summary.slice(0, 200),
+            sessionId
+          });
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  const hotFiles = Array.from(fileModifyCount.entries()).map(([filePath, data]) => ({
+    path: filePath,
+    modifyCount: data.count,
+    lastModified: data.lastModified
+  })).sort((a, b) => b.modifyCount - a.modifyCount).slice(0, 20);
+  const workflowMap = /* @__PURE__ */ new Map();
+  for (const seq of toolSequences) {
+    const key = seq.join(" -> ");
+    workflowMap.set(key, (workflowMap.get(key) ?? 0) + 1);
+  }
+  const workflows = Array.from(workflowMap.entries()).filter(([, count]) => count >= 2).map(([sequence, count]) => ({
+    sequence: sequence.split(" -> "),
+    count
+  })).sort((a, b) => b.count - a.count).slice(0, 10);
+  return {
+    projectName,
+    patterns: [],
+    hotFiles,
+    workflows,
+    decisions: decisions.slice(0, 20)
+  };
+});
+var summarizeSession = (projectName, sessionId, options = {}) => Effect3.gen(function* () {
+  const { limit = 50, maxLength = 100 } = options;
+  const messages = yield* readSession(projectName, sessionId);
+  const lines = [];
+  let count = 0;
+  for (const msg of messages) {
+    if (count >= limit) break;
+    if (msg.type === "user" || msg.type === "human") {
+      let timeStr;
+      if (msg.timestamp) {
+        try {
+          const dt = new Date(msg.timestamp);
+          timeStr = dt.toLocaleString("ko-KR", {
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            hour12: false
+          });
+        } catch {
+        }
+      }
+      const text = extractTextContent(msg.message);
+      if (text) {
+        const truncated = truncateText(text, maxLength);
+        lines.push({ role: "user", content: truncated, timestamp: timeStr });
+        count++;
+      }
+    } else if (msg.type === "assistant") {
+      const text = extractTextContent(msg.message);
+      if (text) {
+        const truncated = truncateText(text, maxLength);
+        lines.push({ role: "assistant", content: truncated });
+        count++;
+      }
+    }
+  }
+  const formatted = lines.map((line) => {
+    if (line.role === "user") {
+      return line.timestamp ? `user [${line.timestamp}]: ${line.content}` : `user: ${line.content}`;
+    }
+    return `assistant: ${line.content}`;
+  }).join("\n");
+  return {
+    sessionId,
+    projectName,
+    lines,
+    formatted
+  };
+});
+function truncateText(text, maxLen) {
+  const cleaned = text.replace(/\n/g, " ");
+  if (cleaned.length > maxLen) {
+    return cleaned.slice(0, maxLen) + "...";
+  }
+  return cleaned;
+}
 export {
+  analyzeSession,
   clearSessions,
+  compressSession,
   createLogger,
   deleteLinkedTodos,
   deleteMessage,
@@ -1440,6 +1838,7 @@ export {
   deleteOrphanTodos,
   deleteSession,
   displayPathToFolderName,
+  extractProjectKnowledge,
   extractTextContent,
   extractTitle,
   findLinkedAgents,
@@ -1474,6 +1873,7 @@ export {
   setLogger,
   sortProjects,
   splitSession,
+  summarizeSession,
   updateSessionSummary
 };
 //# sourceMappingURL=index.js.map