skill-distill 1.0.0 → 1.0.3

package/dist/index.d.ts

@@ -145,14 +145,23 @@ declare abstract class SessionLoader {
 }
 
 declare class ClaudeSessionLoader extends SessionLoader {
+    private transcriptsPath;
+    private projectsPath;
     constructor(options?: SessionLoaderOptions);
     getDefaultBasePath(): string;
     listSessions(): Promise<SessionInfo[]>;
+    private listTranscriptSessions;
+    private listProjectSessions;
     getSession(id: string): Promise<Session>;
-    private readSessionFile;
-    private transformSession;
-    private transformMessage;
-    private extractSummary;
+    private findProjectSessionFile;
+    private readTranscriptFile;
+    private readProjectFile;
+    private transformTranscriptSession;
+    private transformProjectSession;
+    private extractMessageContent;
+    private decodeProjectPath;
+    private extractTranscriptSummary;
+    private extractProjectSummary;
 }
 
 declare class CodexSessionLoader extends SessionLoader {

package/dist/index.js

@@ -91,98 +91,276 @@ var SessionLoader = class {
 
 // src/loaders/claude.ts
 var ClaudeSessionLoader = class extends SessionLoader {
+  transcriptsPath;
+  projectsPath;
   constructor(options = {}) {
     super(options);
+    const claudeDir = join2(homedir2(), ".claude");
+    this.transcriptsPath = join2(claudeDir, "transcripts");
+    this.projectsPath = join2(claudeDir, "projects");
   }
   getDefaultBasePath() {
-    return join2(homedir2(), ".claude", "projects");
+    return join2(homedir2(), ".claude");
   }
   async listSessions() {
     const sessions = [];
+    const transcriptSessions = await this.listTranscriptSessions();
+    const projectSessions = await this.listProjectSessions();
+    sessions.push(...transcriptSessions, ...projectSessions);
+    return sessions.sort(
+      (a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime()
+    );
+  }
+  async listTranscriptSessions() {
+    const sessions = [];
+    try {
+      const files = await fs2.readdir(this.transcriptsPath);
+      for (const file of files) {
+        if (!file.endsWith(".jsonl") || !file.startsWith("ses_")) continue;
+        const filePath = join2(this.transcriptsPath, file);
+        const sessionId = file.replace(".jsonl", "");
+        try {
+          const entries = await this.readTranscriptFile(filePath);
+          if (entries.length === 0) continue;
+          const userMessages = entries.filter((e) => e.type === "user");
+          const firstEntry = entries[0];
+          const lastEntry = entries[entries.length - 1];
+          sessions.push({
+            id: sessionId,
+            projectPath: "[transcripts]",
+            startTime: firstEntry.timestamp,
+            endTime: lastEntry.timestamp,
+            messageCount: userMessages.length,
+            summary: this.extractTranscriptSummary(entries)
+          });
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+    }
+    return sessions;
+  }
+  async listProjectSessions() {
+    const sessions = [];
+    const sessionMap = /* @__PURE__ */ new Map();
     try {
-      const projectDirs = await fs2.readdir(this.basePath);
+      const projectDirs = await fs2.readdir(this.projectsPath);
       for (const projectDir of projectDirs) {
-        const projectPath = join2(this.basePath, projectDir);
+        if (projectDir.startsWith(".")) continue;
+        const projectPath = join2(this.projectsPath, projectDir);
         const stat = await fs2.stat(projectPath);
         if (!stat.isDirectory()) continue;
-        const sessionsPath = join2(projectPath, "sessions");
+        const files = await fs2.readdir(projectPath);
+        for (const file of files) {
+          if (!file.endsWith(".jsonl")) continue;
+          if (file.startsWith("agent-")) continue;
+          const filePath = join2(projectPath, file);
+          const sessionId = file.replace(".jsonl", "");
+          sessionMap.set(sessionId, {
+            id: sessionId,
+            filePath,
+            projectPath: this.decodeProjectPath(projectDir),
+            source: "projects"
+          });
+        }
+      }
+      for (const [sessionId, source] of sessionMap) {
         try {
-          const sessionFiles = await fs2.readdir(sessionsPath);
-          for (const file of sessionFiles) {
-            if (!file.endsWith(".json")) continue;
-            const sessionPath = join2(sessionsPath, file);
-            const sessionData = await this.readSessionFile(sessionPath);
-            if (sessionData) {
-              sessions.push({
-                id: sessionData.id,
-                projectPath: projectDir,
-                startTime: sessionData.createdAt,
-                endTime: sessionData.updatedAt,
-                messageCount: sessionData.messages.length,
-                summary: this.extractSummary(sessionData.messages)
-              });
-            }
-          }
+          const entries = await this.readProjectFile(source.filePath);
+          if (entries.length === 0) continue;
+          const userMessages = entries.filter(
+            (e) => e.type === "user" && e.message?.role === "user"
+          );
+          const timestamps = entries.filter((e) => e.timestamp).map((e) => e.timestamp);
+          if (timestamps.length === 0) continue;
+          sessions.push({
+            id: sessionId,
+            projectPath: source.projectPath,
+            startTime: timestamps[0],
+            endTime: timestamps[timestamps.length - 1],
+            messageCount: userMessages.length,
+            summary: this.extractProjectSummary(entries)
+          });
         } catch {
           continue;
         }
       }
-    } catch (error) {
-      throw new Error(`Failed to list sessions: ${error}`);
+    } catch {
     }
     return sessions;
   }
   async getSession(id) {
-    const sessions = await this.listSessions();
-    const sessionInfo = sessions.find((s) => s.id === id);
-    if (!sessionInfo) {
-      throw new Error(`Session not found: ${id}`);
+    const transcriptPath = join2(this.transcriptsPath, `${id}.jsonl`);
+    try {
+      await fs2.access(transcriptPath);
+      const entries = await this.readTranscriptFile(transcriptPath);
+      if (entries.length > 0) {
+        return this.transformTranscriptSession(id, entries);
+      }
+    } catch {
+    }
+    const projectFile = await this.findProjectSessionFile(id);
+    if (projectFile) {
+      const entries = await this.readProjectFile(projectFile.filePath);
+      return this.transformProjectSession(id, entries, projectFile.projectPath);
+    }
+    throw new Error(`Session not found: ${id}`);
+  }
+  async findProjectSessionFile(sessionId) {
+    try {
+      const projectDirs = await fs2.readdir(this.projectsPath);
+      for (const projectDir of projectDirs) {
+        if (projectDir.startsWith(".")) continue;
+        const projectPath = join2(this.projectsPath, projectDir);
+        const stat = await fs2.stat(projectPath);
+        if (!stat.isDirectory()) continue;
+        const sessionFile = join2(projectPath, `${sessionId}.jsonl`);
+        try {
+          await fs2.access(sessionFile);
+          return {
+            filePath: sessionFile,
+            projectPath: this.decodeProjectPath(projectDir)
+          };
+        } catch {
+          continue;
+        }
+      }
+    } catch {
     }
-    const sessionPath = join2(this.basePath, sessionInfo.projectPath, "sessions", `${id}.json`);
-    const data = await this.readSessionFile(sessionPath);
-    if (!data) {
-      throw new Error(`Failed to read session: ${id}`);
+    return null;
+  }
+  async readTranscriptFile(path) {
+    try {
+      const content = await fs2.readFile(path, "utf-8");
+      const lines = content.trim().split("\n").filter(Boolean);
+      return lines.map((line) => JSON.parse(line));
+    } catch {
+      return [];
     }
-    return this.transformSession(data, sessionInfo.projectPath);
   }
-  async readSessionFile(path) {
+  async readProjectFile(path) {
     try {
       const content = await fs2.readFile(path, "utf-8");
-      return JSON.parse(content);
+      const lines = content.trim().split("\n").filter(Boolean);
+      return lines.map((line) => JSON.parse(line));
     } catch {
-      return null;
+      return [];
     }
   }
-  transformSession(data, projectPath) {
+  transformTranscriptSession(id, entries) {
+    const messages = [];
+    let currentAssistantContent = "";
+    let currentToolCalls = [];
+    let currentToolResults = [];
+    let lastTimestamp = "";
+    for (const entry of entries) {
+      if (entry.type === "user") {
+        if (currentAssistantContent || currentToolCalls?.length) {
+          messages.push({
+            role: "assistant",
+            content: currentAssistantContent.trim(),
+            timestamp: lastTimestamp,
+            toolCalls: currentToolCalls.length > 0 ? currentToolCalls : void 0,
+            toolResults: currentToolResults.length > 0 ? currentToolResults : void 0
+          });
+          currentAssistantContent = "";
+          currentToolCalls = [];
+          currentToolResults = [];
+        }
+        messages.push({
+          role: "user",
+          content: entry.content ?? "",
+          timestamp: entry.timestamp
+        });
+      } else if (entry.type === "assistant") {
+        currentAssistantContent += (entry.content ?? "") + "\n";
+        lastTimestamp = entry.timestamp;
+      } else if (entry.type === "tool_use") {
+        currentToolCalls.push({
+          name: entry.tool_name ?? "unknown",
+          input: entry.tool_input ?? {}
+        });
+        lastTimestamp = entry.timestamp;
+      } else if (entry.type === "tool_result") {
+        currentToolResults.push({
+          name: entry.tool_name ?? "unknown",
+          output: entry.tool_output?.preview ?? "",
+          success: true
+        });
+        lastTimestamp = entry.timestamp;
+      }
+    }
+    if (currentAssistantContent || currentToolCalls?.length) {
+      messages.push({
+        role: "assistant",
+        content: currentAssistantContent.trim(),
+        timestamp: lastTimestamp,
+        toolCalls: currentToolCalls.length > 0 ? currentToolCalls : void 0,
+        toolResults: currentToolResults.length > 0 ? currentToolResults : void 0
+      });
+    }
+    const firstEntry = entries[0];
+    const lastEntry = entries[entries.length - 1];
     return {
-      id: data.id,
-      projectPath,
-      startTime: data.createdAt,
-      endTime: data.updatedAt,
-      messages: data.messages.map((msg) => this.transformMessage(msg))
+      id,
+      projectPath: "[transcripts]",
+      startTime: firstEntry.timestamp,
+      endTime: lastEntry.timestamp,
+      messages
     };
   }
-  transformMessage(msg) {
+  transformProjectSession(id, entries, projectPath) {
+    const messages = [];
+    for (const entry of entries) {
+      if (entry.type === "file-history-snapshot") continue;
+      if (entry.message) {
+        const content = this.extractMessageContent(entry.message.content);
+        if (content) {
+          messages.push({
+            role: entry.message.role === "user" ? "user" : "assistant",
+            content,
+            timestamp: entry.timestamp
+          });
+        }
+      }
+    }
+    const timestamps = entries.filter((e) => e.timestamp).map((e) => e.timestamp);
     return {
-      role: msg.role === "human" ? "user" : "assistant",
-      content: msg.content,
-      timestamp: msg.createdAt,
-      toolCalls: msg.toolUseBlocks?.map((t) => ({
-        name: t.name,
-        input: t.input
-      })),
-      toolResults: msg.toolResultBlocks?.map((t) => ({
-        name: t.toolUseId,
-        output: t.content,
-        success: !t.isError
-      }))
+      id,
+      projectPath,
+      startTime: timestamps[0] ?? "",
+      endTime: timestamps[timestamps.length - 1] ?? "",
+      messages
     };
   }
-  extractSummary(messages) {
-    const firstUserMessage = messages.find((m) => m.role === "human");
-    if (!firstUserMessage) return "";
-    const content = firstUserMessage.content;
-    return content.length > 100 ? content.slice(0, 100) + "..." : content;
+  extractMessageContent(content) {
+    if (typeof content === "string") {
+      return content;
+    }
+    if (Array.isArray(content)) {
+      return content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join("\n");
+    }
+    return "";
+  }
+  decodeProjectPath(encoded) {
+    return encoded.replace(/-/g, "/").replace(/^\//, "");
+  }
+  extractTranscriptSummary(entries) {
+    const firstUserEntry = entries.find((e) => e.type === "user");
+    if (!firstUserEntry?.content) return "";
+    const content = firstUserEntry.content;
+    const firstLine = content.split("\n")[0];
+    return firstLine.length > 80 ? firstLine.slice(0, 80) + "..." : firstLine;
+  }
+  extractProjectSummary(entries) {
+    const firstUserEntry = entries.find(
+      (e) => e.type === "user" && e.message?.role === "user"
+    );
+    if (!firstUserEntry?.message) return "";
+    const content = this.extractMessageContent(firstUserEntry.message.content);
+    const firstLine = content.split("\n")[0];
+    return firstLine.length > 80 ? firstLine.slice(0, 80) + "..." : firstLine;
   }
 };