@claude-sessions/core 0.3.5 → 0.3.7

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;
   }
 };
@@ -196,6 +196,17 @@ var isInvalidApiKeyMessage = (msg) => {
   const text = extractTextContent(msg.message);
   return text.includes("Invalid API key");
 };
+var ERROR_SESSION_PATTERNS = [
+  "API Error",
+  "authentication_error",
+  "Invalid API key",
+  "OAuth token has expired",
+  "Please run /login"
+];
+var isErrorSessionTitle = (title) => {
+  if (!title) return false;
+  return ERROR_SESSION_PATTERNS.some((pattern) => title.includes(pattern));
+};
 var isContinuationSummary = (msg) => {
   if (msg.isCompactSummary === true) return true;
   if (msg.type !== "user") return false;
@@ -287,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);
@@ -677,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 }));
@@ -854,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);
@@ -1061,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;
@@ -1385,12 +1608,18 @@ var loadProjectTreeData = (projectName) => Effect3.gen(function* () {
     const dateB = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;
     return dateB - dateA;
   });
+  const filteredSessions = sortedSessions.filter((s) => {
+    if (isErrorSessionTitle(s.title)) return false;
+    if (isErrorSessionTitle(s.customTitle)) return false;
+    if (isErrorSessionTitle(s.currentSummary)) return false;
+    return true;
+  });
   return {
     name: project.name,
     displayName: project.displayName,
     path: project.path,
-    sessionCount: sessions.length,
-    sessions: sortedSessions
+    sessionCount: filteredSessions.length,
+    sessions: filteredSessions
   };
 });
 var updateSessionSummary = (projectName, sessionId, newSummary) => Effect3.gen(function* () {
@@ -1414,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,
@@ -1423,6 +1838,7 @@ export {
   deleteOrphanTodos,
   deleteSession,
   displayPathToFolderName,
+  extractProjectKnowledge,
   extractTextContent,
   extractTitle,
   findLinkedAgents,
@@ -1457,6 +1873,7 @@ export {
   setLogger,
   sortProjects,
   splitSession,
+  summarizeSession,
   updateSessionSummary
 };
 //# sourceMappingURL=index.js.map