skill-distill 1.0.1 → 1.0.3

package/dist/cli.js

@@ -42,54 +42,144 @@ var SessionLoader = class {
 
 // src/loaders/claude.ts
 var ClaudeSessionLoader = class extends SessionLoader {
+  transcriptsPath;
+  projectsPath;
   constructor(options = {}) {
     super(options);
+    const claudeDir = join(homedir(), ".claude");
+    this.transcriptsPath = join(claudeDir, "transcripts");
+    this.projectsPath = join(claudeDir, "projects");
   }
   getDefaultBasePath() {
-    return join(homedir(), ".claude", "transcripts");
+    return join(homedir(), ".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 fs.readdir(this.basePath);
+      const files = await fs.readdir(this.transcriptsPath);
       for (const file of files) {
         if (!file.endsWith(".jsonl") || !file.startsWith("ses_")) continue;
-        const filePath = join(this.basePath, file);
-        const stat = await fs.stat(filePath);
+        const filePath = join(this.transcriptsPath, file);
         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)
-        });
+        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 (error) {
-      throw new Error(`Failed to list sessions: ${error}`);
+    } catch {
     }
-    return sessions.sort(
-      (a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime()
-    );
+    return sessions;
+  }
+  async listProjectSessions() {
+    const sessions = [];
+    const sessionMap = /* @__PURE__ */ new Map();
+    try {
+      const projectDirs = await fs.readdir(this.projectsPath);
+      for (const projectDir of projectDirs) {
+        if (projectDir.startsWith(".")) continue;
+        const projectPath = join(this.projectsPath, projectDir);
+        const stat = await fs.stat(projectPath);
+        if (!stat.isDirectory()) continue;
+        const files = await fs.readdir(projectPath);
+        for (const file of files) {
+          if (!file.endsWith(".jsonl")) continue;
+          if (file.startsWith("agent-")) continue;
+          const filePath = join(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 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 {
+    }
+    return sessions;
   }
   async getSession(id) {
-    const filePath = join(this.basePath, `${id}.jsonl`);
+    const transcriptPath = join(this.transcriptsPath, `${id}.jsonl`);
     try {
-      await fs.access(filePath);
+      await fs.access(transcriptPath);
+      const entries = await this.readTranscriptFile(transcriptPath);
+      if (entries.length > 0) {
+        return this.transformTranscriptSession(id, entries);
+      }
     } catch {
-      throw new Error(`Session not found: ${id}`);
     }
-    const entries = await this.readTranscriptFile(filePath);
-    if (entries.length === 0) {
-      throw new Error(`Empty session: ${id}`);
+    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 fs.readdir(this.projectsPath);
+      for (const projectDir of projectDirs) {
+        if (projectDir.startsWith(".")) continue;
+        const projectPath = join(this.projectsPath, projectDir);
+        const stat = await fs.stat(projectPath);
+        if (!stat.isDirectory()) continue;
+        const sessionFile = join(projectPath, `${sessionId}.jsonl`);
+        try {
+          await fs.access(sessionFile);
+          return {
+            filePath: sessionFile,
+            projectPath: this.decodeProjectPath(projectDir)
+          };
+        } catch {
+          continue;
+        }
+      }
+    } catch {
     }
-    return this.transformSession(id, entries);
+    return null;
   }
   async readTranscriptFile(path) {
     try {
@@ -100,7 +190,16 @@ var ClaudeSessionLoader = class extends SessionLoader {
       return [];
     }
   }
-  transformSession(id, entries) {
+  async readProjectFile(path) {
+    try {
+      const content = await fs.readFile(path, "utf-8");
+      const lines = content.trim().split("\n").filter(Boolean);
+      return lines.map((line) => JSON.parse(line));
+    } catch {
+      return [];
+    }
+  }
+  transformTranscriptSession(id, entries) {
     const messages = [];
     let currentAssistantContent = "";
     let currentToolCalls = [];
@@ -111,7 +210,7 @@ var ClaudeSessionLoader = class extends SessionLoader {
         if (currentAssistantContent || currentToolCalls?.length) {
           messages.push({
             role: "assistant",
-            content: currentAssistantContent,
+            content: currentAssistantContent.trim(),
             timestamp: lastTimestamp,
             toolCalls: currentToolCalls.length > 0 ? currentToolCalls : void 0,
             toolResults: currentToolResults.length > 0 ? currentToolResults : void 0
@@ -156,19 +255,64 @@ var ClaudeSessionLoader = class extends SessionLoader {
     const lastEntry = entries[entries.length - 1];
     return {
       id,
-      projectPath: "",
+      projectPath: "[transcripts]",
       startTime: firstEntry.timestamp,
       endTime: lastEntry.timestamp,
       messages
     };
   }
-  extractSummary(entries) {
+  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 {
+      id,
+      projectPath,
+      startTime: timestamps[0] ?? "",
+      endTime: timestamps[timestamps.length - 1] ?? "",
+      messages
+    };
+  }
+  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;
+  }
 };
 
 // src/loaders/codex.ts