skill-distill 1.0.1 → 1.0.4

package/dist/index.d.ts

@@ -145,13 +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 findProjectSessionFile;
     private readTranscriptFile;
-    private transformSession;
-    private extractSummary;
+    private readProjectFile;
+    private transformTranscriptSession;
+    private transformProjectSession;
+    private extractMessageContent;
+    private decodeProjectPath;
+    private extractTranscriptSummary;
+    private extractProjectSummary;
 }
 
 declare class CodexSessionLoader extends SessionLoader {

package/dist/index.js

@@ -91,54 +91,144 @@ 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", "transcripts");
+    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.basePath);
+      const files = await fs2.readdir(this.transcriptsPath);
       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 filePath = join2(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 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 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 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 = join2(this.basePath, `${id}.jsonl`);
+    const transcriptPath = join2(this.transcriptsPath, `${id}.jsonl`);
     try {
-      await fs2.access(filePath);
+      await fs2.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);
     }
-    return this.transformSession(id, entries);
+    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 {
+    }
+    return null;
   }
   async readTranscriptFile(path) {
     try {
@@ -149,7 +239,16 @@ var ClaudeSessionLoader = class extends SessionLoader {
       return [];
     }
   }
-  transformSession(id, entries) {
+  async readProjectFile(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 [];
+    }
+  }
+  transformTranscriptSession(id, entries) {
     const messages = [];
     let currentAssistantContent = "";
     let currentToolCalls = [];
@@ -160,7 +259,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
@@ -205,19 +304,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
@@ -462,7 +606,41 @@ ${userPrompts.map((p) => `- ${p}`).join("\n")}` : "";
       qualityEnhancement(JSON.stringify(skill, null, 2)),
       SYSTEM_SKILL_WRITER
     );
-    return this.parseJson(response, z2.any());
+    try {
+      const enhanced = this.parseJson(response, z2.any());
+      const mergedSteps = (enhanced.steps ?? skill.steps ?? []).map((step) => {
+        if (typeof step === "object" && step !== null) {
+          const s = step;
+          return {
+            title: String(s.title ?? s.name ?? "Step"),
+            description: String(s.description ?? s.content ?? ""),
+            substeps: Array.isArray(s.substeps) ? s.substeps.map(String) : void 0
+          };
+        }
+        return { title: "Step", description: String(step) };
+      });
+      const mergedExamples = (enhanced.examples ?? skill.examples ?? []).map((ex) => {
+        if (typeof ex === "string") return ex;
+        if (typeof ex === "object" && ex !== null) {
+          const e = ex;
+          return String(e.text ?? e.example ?? e.content ?? JSON.stringify(ex));
+        }
+        return String(ex);
+      });
+      return {
+        metadata: enhanced.metadata ?? skill.metadata ?? { name: "Untitled", description: "", version: "1.0.0" },
+        overview: enhanced.overview ?? skill.overview ?? "",
+        triggers: enhanced.triggers ?? skill.triggers ?? [],
+        prerequisites: enhanced.prerequisites ?? skill.prerequisites ?? [],
+        steps: mergedSteps,
+        parameters: enhanced.parameters ?? skill.parameters ?? [],
+        errorHandling: enhanced.errorHandling ?? skill.errorHandling ?? {},
+        examples: mergedExamples,
+        notes: enhanced.notes ?? skill.notes ?? []
+      };
+    } catch {
+      return skill;
+    }
   }
   async generateDescription(intent) {
     const response = await this.chat(