skill-distill 1.0.0 → 1.0.1

package/dist/index.d.ts

@@ -149,9 +149,8 @@ declare class ClaudeSessionLoader extends SessionLoader {
     getDefaultBasePath(): string;
     listSessions(): Promise<SessionInfo[]>;
     getSession(id: string): Promise<Session>;
-    private readSessionFile;
+    private readTranscriptFile;
     private transformSession;
-    private transformMessage;
     private extractSummary;
 }
 

package/dist/index.js

@@ -95,94 +95,128 @@ var ClaudeSessionLoader = class extends SessionLoader {
     super(options);
   }
   getDefaultBasePath() {
-    return join2(homedir2(), ".claude", "projects");
+    return join2(homedir2(), ".claude", "transcripts");
   }
   async listSessions() {
     const sessions = [];
     try {
-      const projectDirs = await fs2.readdir(this.basePath);
-      for (const projectDir of projectDirs) {
-        const projectPath = join2(this.basePath, projectDir);
-        const stat = await fs2.stat(projectPath);
-        if (!stat.isDirectory()) continue;
-        const sessionsPath = join2(projectPath, "sessions");
-        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)
-              });
-            }
-          }
-        } catch {
-          continue;
-        }
+      const files = await fs2.readdir(this.basePath);
+      for (const file of files) {
+        if (!file.endsWith(".jsonl") || !file.startsWith("ses_")) continue;
+        const filePath = join2(this.basePath, file);
+        const stat = await fs2.stat(filePath);
+        const sessionId = file.replace(".jsonl", "");
+        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: "",
+          startTime: firstEntry.timestamp,
+          endTime: lastEntry.timestamp,
+          messageCount: userMessages.length,
+          summary: this.extractSummary(entries)
+        });
       }
     } catch (error) {
       throw new Error(`Failed to list sessions: ${error}`);
     }
-    return sessions;
+    return sessions.sort(
+      (a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime()
+    );
   }
   async getSession(id) {
-    const sessions = await this.listSessions();
-    const sessionInfo = sessions.find((s) => s.id === id);
-    if (!sessionInfo) {
+    const filePath = join2(this.basePath, `${id}.jsonl`);
+    try {
+      await fs2.access(filePath);
+    } catch {
       throw new Error(`Session not found: ${id}`);
     }
-    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}`);
+    const entries = await this.readTranscriptFile(filePath);
+    if (entries.length === 0) {
+      throw new Error(`Empty session: ${id}`);
     }
-    return this.transformSession(data, sessionInfo.projectPath);
+    return this.transformSession(id, entries);
   }
-  async readSessionFile(path) {
+  async readTranscriptFile(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) {
-    return {
-      id: data.id,
-      projectPath,
-      startTime: data.createdAt,
-      endTime: data.updatedAt,
-      messages: data.messages.map((msg) => this.transformMessage(msg))
-    };
-  }
-  transformMessage(msg) {
+  transformSession(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,
+            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 {
-      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: firstEntry.timestamp,
+      endTime: lastEntry.timestamp,
+      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;
+  extractSummary(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;
   }
 };