claude-sessions-mcp 0.2.1 → 0.3.0

package/dist/web/server/chunks/{session-BAE596_s.js → session-DmOGNZUD.js}

@@ -3,7 +3,264 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import * as os from 'node:os';
 
-const getSessionsDir = () => path.join(os.homedir(), ".claude", "projects");
+const getSessionsDir$1 = () => path.join(os.homedir(), ".claude", "projects");
+const getTodosDir = () => path.join(os.homedir(), ".claude", "todos");
+const findLinkedAgents$1 = (projectName, sessionId) => Effect.gen(function* () {
+  const projectPath = path.join(getSessionsDir$1(), projectName);
+  const files = yield* Effect.tryPromise(() => fs.readdir(projectPath));
+  const agentFiles = files.filter((f) => f.startsWith("agent-") && f.endsWith(".jsonl"));
+  const linkedAgents = [];
+  for (const agentFile of agentFiles) {
+    const filePath = path.join(projectPath, agentFile);
+    const content = yield* Effect.tryPromise(() => fs.readFile(filePath, "utf-8"));
+    const firstLine = content.split("\n")[0];
+    if (firstLine) {
+      try {
+        const parsed = JSON.parse(firstLine);
+        if (parsed.sessionId === sessionId) {
+          linkedAgents.push(agentFile.replace(".jsonl", ""));
+        }
+      } catch {
+      }
+    }
+  }
+  return linkedAgents;
+});
+const findOrphanAgents$1 = (projectName) => Effect.gen(function* () {
+  const projectPath = path.join(getSessionsDir$1(), projectName);
+  const files = yield* Effect.tryPromise(() => fs.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 filePath = path.join(projectPath, agentFile);
+    const content = yield* Effect.tryPromise(() => fs.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
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return orphanAgents;
+});
+const deleteOrphanAgents$1 = (projectName) => Effect.gen(function* () {
+  const projectPath = path.join(getSessionsDir$1(), projectName);
+  const orphans = yield* findOrphanAgents$1(projectName);
+  const backupDir = path.join(projectPath, ".bak");
+  yield* Effect.tryPromise(() => fs.mkdir(backupDir, { recursive: true }));
+  const deletedAgents = [];
+  for (const orphan of orphans) {
+    const agentPath = path.join(projectPath, `${orphan.agentId}.jsonl`);
+    const agentBackupPath = path.join(backupDir, `${orphan.agentId}.jsonl`);
+    yield* Effect.tryPromise(() => fs.rename(agentPath, agentBackupPath));
+    deletedAgents.push(orphan.agentId);
+  }
+  return { success: true, deletedAgents, count: deletedAgents.length };
+});
+const findLinkedTodos = (sessionId, agentIds) => Effect.gen(function* () {
+  const todosDir = getTodosDir();
+  const exists = yield* Effect.tryPromise(
+    () => fs.access(todosDir).then(() => true).catch(() => false)
+  );
+  if (!exists) {
+    return {
+      sessionId,
+      sessionTodos: [],
+      agentTodos: [],
+      hasTodos: false
+    };
+  }
+  const sessionTodoPath = path.join(todosDir, `${sessionId}.json`);
+  let sessionTodos = [];
+  const sessionTodoExists = yield* Effect.tryPromise(
+    () => fs.access(sessionTodoPath).then(() => true).catch(() => false)
+  );
+  if (sessionTodoExists) {
+    const content = yield* Effect.tryPromise(() => fs.readFile(sessionTodoPath, "utf-8"));
+    try {
+      sessionTodos = JSON.parse(content);
+    } catch {
+    }
+  }
+  const agentTodos = [];
+  for (const agentId of agentIds) {
+    const shortAgentId = agentId.replace("agent-", "");
+    const agentTodoPath = path.join(todosDir, `${sessionId}-agent-${shortAgentId}.json`);
+    const agentTodoExists = yield* Effect.tryPromise(
+      () => fs.access(agentTodoPath).then(() => true).catch(() => false)
+    );
+    if (agentTodoExists) {
+      const content = yield* Effect.tryPromise(() => fs.readFile(agentTodoPath, "utf-8"));
+      try {
+        const todos = JSON.parse(content);
+        agentTodos.push({ agentId, todos });
+      } catch {
+      }
+    }
+  }
+  const hasTodos = sessionTodos.length > 0 || agentTodos.some((at) => at.todos.length > 0);
+  return {
+    sessionId,
+    sessionTodos,
+    agentTodos,
+    hasTodos
+  };
+});
+const sessionHasTodos$1 = (sessionId, agentIds) => Effect.gen(function* () {
+  const todosDir = getTodosDir();
+  const exists = yield* Effect.tryPromise(
+    () => fs.access(todosDir).then(() => true).catch(() => false)
+  );
+  if (!exists) return false;
+  const sessionTodoPath = path.join(todosDir, `${sessionId}.json`);
+  const sessionTodoExists = yield* Effect.tryPromise(
+    () => fs.access(sessionTodoPath).then(() => true).catch(() => false)
+  );
+  if (sessionTodoExists) {
+    const content = yield* Effect.tryPromise(() => fs.readFile(sessionTodoPath, "utf-8"));
+    try {
+      const todos = JSON.parse(content);
+      if (todos.length > 0) return true;
+    } catch {
+    }
+  }
+  for (const agentId of agentIds) {
+    const shortAgentId = agentId.replace("agent-", "");
+    const agentTodoPath = path.join(todosDir, `${sessionId}-agent-${shortAgentId}.json`);
+    const agentTodoExists = yield* Effect.tryPromise(
+      () => fs.access(agentTodoPath).then(() => true).catch(() => false)
+    );
+    if (agentTodoExists) {
+      const content = yield* Effect.tryPromise(() => fs.readFile(agentTodoPath, "utf-8"));
+      try {
+        const todos = JSON.parse(content);
+        if (todos.length > 0) return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+});
+const deleteLinkedTodos$1 = (sessionId, agentIds) => Effect.gen(function* () {
+  const todosDir = getTodosDir();
+  const exists = yield* Effect.tryPromise(
+    () => fs.access(todosDir).then(() => true).catch(() => false)
+  );
+  if (!exists) return { deletedCount: 0 };
+  const backupDir = path.join(todosDir, ".bak");
+  yield* Effect.tryPromise(() => fs.mkdir(backupDir, { recursive: true }));
+  let deletedCount = 0;
+  const sessionTodoPath = path.join(todosDir, `${sessionId}.json`);
+  const sessionTodoExists = yield* Effect.tryPromise(
+    () => fs.access(sessionTodoPath).then(() => true).catch(() => false)
+  );
+  if (sessionTodoExists) {
+    const backupPath = path.join(backupDir, `${sessionId}.json`);
+    yield* Effect.tryPromise(() => fs.rename(sessionTodoPath, backupPath));
+    deletedCount++;
+  }
+  for (const agentId of agentIds) {
+    const shortAgentId = agentId.replace("agent-", "");
+    const agentTodoPath = path.join(todosDir, `${sessionId}-agent-${shortAgentId}.json`);
+    const agentTodoExists = yield* Effect.tryPromise(
+      () => fs.access(agentTodoPath).then(() => true).catch(() => false)
+    );
+    if (agentTodoExists) {
+      const backupPath = path.join(backupDir, `${sessionId}-agent-${shortAgentId}.json`);
+      yield* Effect.tryPromise(() => fs.rename(agentTodoPath, backupPath));
+      deletedCount++;
+    }
+  }
+  return { deletedCount };
+});
+const findOrphanTodos$1 = () => Effect.gen(function* () {
+  const todosDir = getTodosDir();
+  const sessionsDir = getSessionsDir$1();
+  const [todosExists, sessionsExists] = yield* Effect.all([
+    Effect.tryPromise(
+      () => fs.access(todosDir).then(() => true).catch(() => false)
+    ),
+    Effect.tryPromise(
+      () => fs.access(sessionsDir).then(() => true).catch(() => false)
+    )
+  ]);
+  if (!todosExists || !sessionsExists) return [];
+  const todoFiles = yield* Effect.tryPromise(() => fs.readdir(todosDir));
+  const jsonFiles = todoFiles.filter((f) => f.endsWith(".json"));
+  const validSessionIds = /* @__PURE__ */ new Set();
+  const projectEntries = yield* Effect.tryPromise(
+    () => fs.readdir(sessionsDir, { withFileTypes: true })
+  );
+  for (const entry of projectEntries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const projectPath = path.join(sessionsDir, entry.name);
+    const files = yield* Effect.tryPromise(() => fs.readdir(projectPath));
+    for (const f of files) {
+      if (f.endsWith(".jsonl") && !f.startsWith("agent-")) {
+        validSessionIds.add(f.replace(".jsonl", ""));
+      }
+    }
+  }
+  const orphans = [];
+  for (const todoFile of jsonFiles) {
+    const match = todoFile.match(/^([a-f0-9-]+)(?:-agent-[a-f0-9]+)?\.json$/);
+    if (match) {
+      const sessionId = match[1];
+      if (!validSessionIds.has(sessionId)) {
+        orphans.push(todoFile);
+      }
+    }
+  }
+  return orphans;
+});
+const deleteOrphanTodos$1 = () => Effect.gen(function* () {
+  const todosDir = getTodosDir();
+  const orphans = yield* findOrphanTodos$1();
+  if (orphans.length === 0) return { success: true, deletedCount: 0 };
+  const backupDir = path.join(todosDir, ".bak");
+  yield* Effect.tryPromise(() => fs.mkdir(backupDir, { recursive: true }));
+  let deletedCount = 0;
+  for (const orphan of orphans) {
+    const filePath = path.join(todosDir, orphan);
+    const backupPath = path.join(backupDir, orphan);
+    yield* Effect.tryPromise(() => fs.rename(filePath, backupPath));
+    deletedCount++;
+  }
+  return { success: true, deletedCount };
+});
+const shared = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  deleteLinkedTodos: deleteLinkedTodos$1,
+  deleteOrphanAgents: deleteOrphanAgents$1,
+  deleteOrphanTodos: deleteOrphanTodos$1,
+  findLinkedAgents: findLinkedAgents$1,
+  findLinkedTodos,
+  findOrphanAgents: findOrphanAgents$1,
+  findOrphanTodos: findOrphanTodos$1,
+  getSessionsDir: getSessionsDir$1,
+  getTodosDir,
+  sessionHasTodos: sessionHasTodos$1
+}, Symbol.toStringTag, { value: "Module" }));
+const {
+  getSessionsDir,
+  findLinkedAgents,
+  findOrphanAgents,
+  deleteOrphanAgents,
+  sessionHasTodos,
+  deleteLinkedTodos,
+  findOrphanTodos,
+  deleteOrphanTodos
+} = shared;
 const extractTextContent = (message) => {
   if (!message) return "";
   const content = message.content;
@@ -71,6 +328,7 @@ const listSessions = (projectName) => Effect.gen(function* () {
         const userAssistantMessages = messages.filter(
           (m) => m.type === "user" || m.type === "assistant"
         );
+        const hasSummary = messages.some((m) => m.type === "summary");
         const firstMessage = userAssistantMessages[0];
         const lastMessage = userAssistantMessages[userAssistantMessages.length - 1];
         const title = pipe(
@@ -80,13 +338,14 @@ const listSessions = (projectName) => Effect.gen(function* () {
             const text = extractTextContent(m.message);
             return extractTitle(text);
           }),
-          Option.getOrElse(() => `Session ${sessionId.slice(0, 8)}`)
+          Option.getOrElse(() => hasSummary ? "[Summary Only]" : `Session ${sessionId.slice(0, 8)}`)
         );
         return {
           id: sessionId,
           projectName,
           title,
-          messageCount: userAssistantMessages.length,
+          // If session has summary but no user/assistant messages, count as 1
+          messageCount: userAssistantMessages.length > 0 ? userAssistantMessages.length : hasSummary ? 1 : 0,
           createdAt: firstMessage?.timestamp,
           updatedAt: lastMessage?.timestamp
         };
@@ -108,17 +367,42 @@ const readSession = (projectName, sessionId) => Effect.gen(function* () {
 });
 const deleteSession = (projectName, sessionId) => Effect.gen(function* () {
   const sessionsDir = getSessionsDir();
-  const filePath = path.join(sessionsDir, projectName, `${sessionId}.jsonl`);
+  const projectPath = path.join(sessionsDir, projectName);
+  const filePath = path.join(projectPath, `${sessionId}.jsonl`);
+  const linkedAgents = yield* findLinkedAgents(projectName, sessionId);
   const stat = yield* Effect.tryPromise(() => fs.stat(filePath));
   if (stat.size === 0) {
     yield* Effect.tryPromise(() => fs.unlink(filePath));
-    return { success: true };
+    const agentBackupDir2 = path.join(projectPath, ".bak");
+    yield* Effect.tryPromise(() => fs.mkdir(agentBackupDir2, { recursive: true }));
+    for (const agentId of linkedAgents) {
+      const agentPath = path.join(projectPath, `${agentId}.jsonl`);
+      const agentBackupPath = path.join(agentBackupDir2, `${agentId}.jsonl`);
+      yield* Effect.tryPromise(() => fs.rename(agentPath, agentBackupPath).catch(() => {
+      }));
+    }
+    yield* deleteLinkedTodos(sessionId, linkedAgents);
+    return { success: true, deletedAgents: linkedAgents.length };
   }
   const backupDir = path.join(sessionsDir, ".bak");
   yield* Effect.tryPromise(() => fs.mkdir(backupDir, { recursive: true }));
+  const agentBackupDir = path.join(projectPath, ".bak");
+  yield* Effect.tryPromise(() => fs.mkdir(agentBackupDir, { recursive: true }));
+  for (const agentId of linkedAgents) {
+    const agentPath = path.join(projectPath, `${agentId}.jsonl`);
+    const agentBackupPath = path.join(agentBackupDir, `${agentId}.jsonl`);
+    yield* Effect.tryPromise(() => fs.rename(agentPath, agentBackupPath).catch(() => {
+    }));
+  }
+  const todosResult = yield* deleteLinkedTodos(sessionId, linkedAgents);
   const backupPath = path.join(backupDir, `${projectName}_${sessionId}.jsonl`);
   yield* Effect.tryPromise(() => fs.rename(filePath, backupPath));
-  return { success: true, backupPath };
+  return {
+    success: true,
+    backupPath,
+    deletedAgents: linkedAgents.length,
+    deletedTodos: todosResult.deletedCount
+  };
 });
 const renameSession = (projectName, sessionId, newTitle) => Effect.gen(function* () {
   const filePath = path.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
@@ -193,6 +477,8 @@ const deleteMessage = (projectName, sessionId, messageUuid) => Effect.gen(functi
 const previewCleanup = (projectName) => Effect.gen(function* () {
   const projects = yield* listProjects;
   const targetProjects = projectName ? projects.filter((p) => p.name === projectName) : projects;
+  const orphanTodos = yield* findOrphanTodos();
+  const orphanTodoCount = orphanTodos.length;
   const results = yield* Effect.all(
     targetProjects.map(
       (project) => Effect.gen(function* () {
@@ -201,15 +487,34 @@ const previewCleanup = (projectName) => Effect.gen(function* () {
         const invalidSessions = sessions.filter(
           (s) => s.title?.includes("Invalid API key") || s.title?.includes("API key")
         );
+        let emptyWithTodosCount = 0;
+        for (const session of emptySessions) {
+          const linkedAgents = yield* findLinkedAgents(project.name, session.id);
+          const hasTodos = yield* sessionHasTodos(session.id, linkedAgents);
+          if (hasTodos) {
+            emptyWithTodosCount++;
+          }
+        }
+        const orphanAgents = yield* findOrphanAgents(project.name);
         return {
           project: project.name,
           emptySessions,
-          invalidSessions
+          invalidSessions,
+          emptyWithTodosCount,
+          orphanAgentCount: orphanAgents.length,
+          orphanTodoCount
+          // Include global orphan todo count in first project only
         };
       })
     ),
     { concurrency: 5 }
   );
+  if (results.length > 0) {
+    results[0] = { ...results[0], orphanTodoCount };
+    for (let i = 1; i < results.length; i++) {
+      results[i] = { ...results[i], orphanTodoCount: 0 };
+    }
+  }
   return results;
 });
 const isInvalidApiKeyMessage = (msg) => {
@@ -232,7 +537,9 @@ const cleanInvalidMessages = (projectName, sessionId) => Effect.gen(function* ()
     const userAssistantCount = messages.filter(
       (m) => m.type === "user" || m.type === "assistant"
     ).length;
-    return { removedCount: 0, remainingCount: userAssistantCount };
+    const hasSummary2 = messages.some((m) => m.type === "summary");
+    const remainingCount2 = userAssistantCount > 0 ? userAssistantCount : hasSummary2 ? 1 : 0;
+    return { removedCount: 0, remainingCount: remainingCount2 };
   }
   const filtered = [];
   let lastValidUuid = null;
@@ -252,7 +559,9 @@ const cleanInvalidMessages = (projectName, sessionId) => Effect.gen(function* ()
   const remainingUserAssistant = filtered.filter(
     (m) => m.type === "user" || m.type === "assistant"
   ).length;
-  return { removedCount: invalidIndices.length, remainingCount: remainingUserAssistant };
+  const hasSummary = filtered.some((m) => m.type === "summary");
+  const remainingCount = remainingUserAssistant > 0 ? remainingUserAssistant : hasSummary ? 1 : 0;
+  return { removedCount: invalidIndices.length, remainingCount };
 });
 const getSessionFiles = (projectName, sessionId) => Effect.gen(function* () {
   const messages = yield* readSession(projectName, sessionId);
@@ -306,6 +615,39 @@ const getSessionFiles = (projectName, sessionId) => Effect.gen(function* () {
     totalChanges: fileChanges.length
   };
 });
+const moveSession = (sourceProject, sessionId, targetProject) => Effect.gen(function* () {
+  const sessionsDir = getSessionsDir();
+  const sourcePath = path.join(sessionsDir, sourceProject);
+  const targetPath = path.join(sessionsDir, targetProject);
+  const sourceFile = path.join(sourcePath, `${sessionId}.jsonl`);
+  const targetFile = path.join(targetPath, `${sessionId}.jsonl`);
+  const sourceExists = yield* Effect.tryPromise(
+    () => fs.access(sourceFile).then(() => true).catch(() => false)
+  );
+  if (!sourceExists) {
+    return { success: false, error: "Source session not found" };
+  }
+  const targetExists = yield* Effect.tryPromise(
+    () => fs.access(targetFile).then(() => true).catch(() => false)
+  );
+  if (targetExists) {
+    return { success: false, error: "Session already exists in target project" };
+  }
+  yield* Effect.tryPromise(() => fs.mkdir(targetPath, { recursive: true }));
+  const linkedAgents = yield* findLinkedAgents(sourceProject, sessionId);
+  yield* Effect.tryPromise(() => fs.rename(sourceFile, targetFile));
+  for (const agentId of linkedAgents) {
+    const sourceAgentFile = path.join(sourcePath, `${agentId}.jsonl`);
+    const targetAgentFile = path.join(targetPath, `${agentId}.jsonl`);
+    const agentExists = yield* Effect.tryPromise(
+      () => fs.access(sourceAgentFile).then(() => true).catch(() => false)
+    );
+    if (agentExists) {
+      yield* Effect.tryPromise(() => fs.rename(sourceAgentFile, targetAgentFile));
+    }
+  }
+  return { success: true };
+});
 const splitSession = (projectName, sessionId, splitAtMessageUuid) => Effect.gen(function* () {
   const projectPath = path.join(getSessionsDir(), projectName);
   const filePath = path.join(projectPath, `${sessionId}.jsonl`);
@@ -365,11 +707,19 @@ const splitSession = (projectName, sessionId, splitAtMessageUuid) => Effect.gen(
   };
 });
 const clearSessions = (options) => Effect.gen(function* () {
-  const { projectName, clearEmpty = true } = options;
+  const {
+    projectName,
+    clearEmpty = true,
+    skipWithTodos = true,
+    clearOrphanAgents = false,
+    clearOrphanTodos = false
+  } = options;
   const projects = yield* listProjects;
   const targetProjects = projectName ? projects.filter((p) => p.name === projectName) : projects;
   let deletedSessionCount = 0;
   let removedMessageCount = 0;
+  let deletedOrphanAgentCount = 0;
+  let deletedOrphanTodoCount = 0;
   const sessionsToDelete = [];
   for (const project of targetProjects) {
     const projectPath = path.join(getSessionsDir(), project.name);
@@ -393,6 +743,11 @@ const clearSessions = (options) => Effect.gen(function* () {
             (s) => s.project === project.name && s.sessionId === session.id
           );
           if (!alreadyMarked) {
+            if (skipWithTodos) {
+              const linkedAgents = yield* findLinkedAgents(project.name, session.id);
+              const hasTodos = yield* sessionHasTodos(session.id, linkedAgents);
+              if (hasTodos) continue;
+            }
             sessionsToDelete.push({ project: project.name, sessionId: session.id });
           }
         }
@@ -403,12 +758,24 @@ const clearSessions = (options) => Effect.gen(function* () {
     yield* deleteSession(project, sessionId);
     deletedSessionCount++;
   }
+  if (clearOrphanAgents) {
+    for (const project of targetProjects) {
+      const result = yield* deleteOrphanAgents(project.name);
+      deletedOrphanAgentCount += result.count;
+    }
+  }
+  if (clearOrphanTodos) {
+    const result = yield* deleteOrphanTodos();
+    deletedOrphanTodoCount = result.deletedCount;
+  }
   return {
     success: true,
     deletedCount: deletedSessionCount,
-    removedMessageCount
+    removedMessageCount,
+    deletedOrphanAgentCount,
+    deletedOrphanTodoCount
   };
 });
 
-export { listSessions as a, deleteSession as b, clearSessions as c, deleteMessage as d, renameSession as e, getSessionFiles as g, listProjects as l, previewCleanup as p, readSession as r, splitSession as s, updateCustomTitle as u };
-//# sourceMappingURL=session-BAE596_s.js.map
+export { listSessions as a, deleteSession as b, clearSessions as c, deleteMessage as d, renameSession as e, getSessionFiles as g, listProjects as l, moveSession as m, previewCleanup as p, readSession as r, splitSession as s, updateCustomTitle as u };
+//# sourceMappingURL=session-DmOGNZUD.js.map