skill-distill 1.0.0

package/dist/cli.js

@@ -0,0 +1,1940 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command as Command4 } from "commander";
+
+// src/cli/commands/distill.ts
+import { Command } from "commander";
+import chalk3 from "chalk";
+import ora from "ora";
+
+// src/loaders/claude.ts
+import { promises as fs } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/loaders/base.ts
+var SessionLoader = class {
+  basePath;
+  projectPath;
+  constructor(options = {}) {
+    this.basePath = options.basePath ?? this.getDefaultBasePath();
+    this.projectPath = options.projectPath;
+  }
+  async getLatestSession() {
+    const sessions = await this.listSessions();
+    if (sessions.length === 0) {
+      throw new Error("No sessions found");
+    }
+    const sorted = sessions.sort(
+      (a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime()
+    );
+    return this.getSession(sorted[0].id);
+  }
+  async searchSessions(query) {
+    const sessions = await this.listSessions();
+    const lowerQuery = query.toLowerCase();
+    return sessions.filter(
+      (s) => s.summary?.toLowerCase().includes(lowerQuery) || s.projectPath.toLowerCase().includes(lowerQuery)
+    );
+  }
+};
+
+// src/loaders/claude.ts
+var ClaudeSessionLoader = class extends SessionLoader {
+  constructor(options = {}) {
+    super(options);
+  }
+  getDefaultBasePath() {
+    return join(homedir(), ".claude", "projects");
+  }
+  async listSessions() {
+    const sessions = [];
+    try {
+      const projectDirs = await fs.readdir(this.basePath);
+      for (const projectDir of projectDirs) {
+        const projectPath = join(this.basePath, projectDir);
+        const stat = await fs.stat(projectPath);
+        if (!stat.isDirectory()) continue;
+        const sessionsPath = join(projectPath, "sessions");
+        try {
+          const sessionFiles = await fs.readdir(sessionsPath);
+          for (const file of sessionFiles) {
+            if (!file.endsWith(".json")) continue;
+            const sessionPath = join(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;
+        }
+      }
+    } catch (error) {
+      throw new Error(`Failed to list sessions: ${error}`);
+    }
+    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 sessionPath = join(this.basePath, sessionInfo.projectPath, "sessions", `${id}.json`);
+    const data = await this.readSessionFile(sessionPath);
+    if (!data) {
+      throw new Error(`Failed to read session: ${id}`);
+    }
+    return this.transformSession(data, sessionInfo.projectPath);
+  }
+  async readSessionFile(path) {
+    try {
+      const content = await fs.readFile(path, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  transformSession(data, projectPath) {
+    return {
+      id: data.id,
+      projectPath,
+      startTime: data.createdAt,
+      endTime: data.updatedAt,
+      messages: data.messages.map((msg) => this.transformMessage(msg))
+    };
+  }
+  transformMessage(msg) {
+    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
+      }))
+    };
+  }
+  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;
+  }
+};
+
+// src/loaders/codex.ts
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var CodexSessionLoader = class extends SessionLoader {
+  getDefaultBasePath() {
+    return join2(homedir2(), ".codex", "history");
+  }
+  async listSessions() {
+    return [];
+  }
+  async getSession(_id) {
+    throw new Error("Codex session loading not yet implemented");
+  }
+};
+
+// src/loaders/cursor.ts
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+var CursorSessionLoader = class extends SessionLoader {
+  getDefaultBasePath() {
+    return join3(homedir3(), ".cursor", "workspaceStorage");
+  }
+  async listSessions() {
+    return [];
+  }
+  async getSession(_id) {
+    throw new Error("Cursor session loading not yet implemented");
+  }
+};
+
+// src/loaders/index.ts
+function createSessionLoader(platform, options) {
+  switch (platform) {
+    case "claude":
+      return new ClaudeSessionLoader(options);
+    case "codex":
+      return new CodexSessionLoader(options);
+    case "cursor":
+      return new CursorSessionLoader(options);
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+}
+
+// src/core/llm-engine.ts
+import Anthropic from "@anthropic-ai/sdk";
+import { z } from "zod";
+
+// src/prompts/index.ts
+var SYSTEM_DEFAULT = `You are Skill Distill, an expert at analyzing AI agent conversations and extracting reusable patterns.`;
+var SYSTEM_ANALYST = `You are an expert conversation analyst. Your task is to:
+1. Understand the user's original intent
+2. Identify key steps and patterns
+3. Filter out failed attempts and trial-and-error
+4. Extract reusable knowledge
+
+Always respond in valid JSON format.`;
+var SYSTEM_SKILL_WRITER = `You are an expert at writing Claude Code Skills. You follow these rules:
+1. Use third-person in descriptions ("This skill should be used when...")
+2. Use imperative/infinitive form in steps ("Parse the file...", not "You should parse...")
+3. Include specific trigger phrases
+4. Keep content focused and lean
+5. Follow Claude Code Skill format exactly`;
+function intentExtraction(conversation) {
+  return `Analyze the following conversation between a user and an AI assistant.
+
+<conversation>
+${conversation}
+</conversation>
+
+Extract the user's intent and provide a structured analysis.
+
+Respond with a JSON object containing:
+- goal: The user's core objective (what they wanted to achieve)
+- problem: The problem they were trying to solve
+- outcome: What was ultimately accomplished
+- triggers: An array of 3-5 specific phrases that would trigger this type of task (e.g., "migrate to RSC", "add server components")
+- category: The category of this task (e.g., "refactoring", "feature-development", "debugging", "configuration")
+
+\`\`\`json
+{
+  "goal": "...",
+  "problem": "...",
+  "outcome": "...",
+  "triggers": ["...", "..."],
+  "category": "..."
+}
+\`\`\``;
+}
+function stepDistillation(conversation, intent, userPromptAdditions) {
+  return `Based on the following conversation, extract the key steps that were taken to achieve the goal.
+
+<goal>
+${intent.goal}
+</goal>
+
+<problem>
+${intent.problem}
+</problem>
+
+<conversation>
+${conversation}
+</conversation>
+${userPromptAdditions}
+
+Instructions:
+1. Identify the SUCCESSFUL steps that led to the outcome (filter out failed attempts)
+2. Generalize specific values into parameters where appropriate
+3. Identify prerequisites needed before starting
+4. Note any error handling patterns discovered
+
+Respond with a JSON object:
+
+\`\`\`json
+{
+  "steps": [
+    {
+      "title": "Step title",
+      "description": "What to do in this step (use imperative form)",
+      "substeps": ["optional substep 1", "optional substep 2"],
+      "isKeyStep": true,
+      "toolsUsed": ["tool1", "tool2"]
+    }
+  ],
+  "parameters": [
+    {
+      "name": "parameter_name",
+      "type": "string",
+      "description": "What this parameter controls",
+      "defaultValue": "optional default"
+    }
+  ],
+  "prerequisites": [
+    "Prerequisite 1",
+    "Prerequisite 2"
+  ],
+  "errorHandling": {
+    "Error scenario 1": "How to handle it",
+    "Error scenario 2": "How to handle it"
+  }
+}
+\`\`\``;
+}
+function qualityEnhancement(skillJson) {
+  return `Review and enhance the following Skill definition for quality and completeness.
+
+<skill>
+${skillJson}
+</skill>
+
+Improvements to make:
+1. Ensure all steps use imperative form ("Do X" not "You should do X")
+2. Add any missing error handling scenarios
+3. Improve trigger phrases to be more specific
+4. Add example usage phrases
+5. Ensure prerequisites are complete
+6. Add any missing notes or warnings
+
+Return the enhanced Skill as a complete JSON object with the same structure but improved content.`;
+}
+function descriptionGeneration(intent) {
+  return `Generate a Claude Code Skill description based on the following:
+
+Goal: ${intent.goal}
+Trigger phrases: ${intent.triggers.join(", ")}
+
+Requirements:
+1. Use third-person format: "This skill should be used when..."
+2. Include the specific trigger phrases in quotes
+3. Be concise but descriptive (1-2 sentences)
+
+Example format:
+"This skill should be used when the user asks to \\"migrate to RSC\\", \\"convert to Server Components\\", or mentions React Server Components migration. Provides step-by-step guidance for the migration process."
+
+Generate only the description text, no additional formatting.`;
+}
+
+// src/core/llm-engine.ts
+var IntentSchema = z.object({
+  goal: z.string().describe("The user core objective"),
+  problem: z.string().describe("The problem to solve"),
+  outcome: z.string().describe("The final result"),
+  triggers: z.array(z.string()).describe("Trigger phrases list"),
+  category: z.string().describe("Task category")
+});
+var StepSchema = z.object({
+  title: z.string(),
+  description: z.string(),
+  substeps: z.array(z.string()).optional(),
+  isKeyStep: z.boolean(),
+  toolsUsed: z.array(z.string()).optional()
+});
+var StepsResultSchema = z.object({
+  steps: z.array(StepSchema),
+  parameters: z.array(
+    z.object({
+      name: z.string(),
+      type: z.enum(["string", "boolean", "number"]),
+      description: z.string(),
+      defaultValue: z.unknown().optional()
+    })
+  ),
+  prerequisites: z.array(z.string()),
+  errorHandling: z.record(z.string())
+});
+var LLMEngine = class {
+  client;
+  model;
+  maxTokens;
+  totalUsage = { inputTokens: 0, outputTokens: 0 };
+  constructor(options = {}) {
+    this.client = new Anthropic({
+      apiKey: options.apiKey ?? process.env.ANTHROPIC_API_KEY
+    });
+    this.model = options.model ?? "claude-sonnet-4-20250514";
+    this.maxTokens = options.maxTokens ?? 4096;
+  }
+  async extractIntent(session) {
+    const conversationText = this.formatConversation(session.messages);
+    const response = await this.chat(
+      intentExtraction(conversationText),
+      SYSTEM_ANALYST
+    );
+    return this.parseJson(response, IntentSchema);
+  }
+  async distillSteps(session, intent, userPrompts) {
+    const conversationText = this.formatConversation(session.messages);
+    const promptAdditions = userPrompts?.length ? `
+
+User additional instructions:
+${userPrompts.map((p) => `- ${p}`).join("\n")}` : "";
+    const response = await this.chat(
+      stepDistillation(conversationText, intent, promptAdditions),
+      SYSTEM_ANALYST
+    );
+    return this.parseJson(response, StepsResultSchema);
+  }
+  async enhanceQuality(skill) {
+    const response = await this.chat(
+      qualityEnhancement(JSON.stringify(skill, null, 2)),
+      SYSTEM_SKILL_WRITER
+    );
+    return this.parseJson(response, z.any());
+  }
+  async generateDescription(intent) {
+    const response = await this.chat(
+      descriptionGeneration(intent),
+      SYSTEM_SKILL_WRITER
+    );
+    return response.trim();
+  }
+  async chat(prompt, system) {
+    const response = await this.withRetry(async () => {
+      return this.client.messages.create({
+        model: this.model,
+        max_tokens: this.maxTokens,
+        system: system ?? SYSTEM_DEFAULT,
+        messages: [{ role: "user", content: prompt }]
+      });
+    });
+    this.totalUsage.inputTokens += response.usage.input_tokens;
+    this.totalUsage.outputTokens += response.usage.output_tokens;
+    const textBlock = response.content.find((b) => b.type === "text");
+    if (!textBlock || textBlock.type !== "text") {
+      throw new Error("No text response from LLM");
+    }
+    return textBlock.text;
+  }
+  getTokenUsage() {
+    return { ...this.totalUsage };
+  }
+  formatConversation(messages) {
+    return messages.map((m) => {
+      const role = m.role === "user" ? "User" : "Assistant";
+      let content = `[${role}]: ${m.content}`;
+      if (m.toolCalls?.length) {
+        content += `
+  [Tools Used]: ${m.toolCalls.map((t) => t.name).join(", ")}`;
+      }
+      return content;
+    }).join("\n\n");
+  }
+  parseJson(text, schema) {
+    const jsonMatch = text.match(/```json\n?([\s\S]*?)\n?```/) || text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      throw new Error("No JSON found in response");
+    }
+    const jsonStr = jsonMatch[1] || jsonMatch[0];
+    const parsed = JSON.parse(jsonStr);
+    return schema.parse(parsed);
+  }
+  async withRetry(fn, maxRetries = 3, delay = 1e3) {
+    let lastError;
+    for (let i = 0; i < maxRetries; i++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error;
+        if (error instanceof Anthropic.RateLimitError) {
+          await this.sleep(delay * (i + 1) * 2);
+        } else if (error instanceof Anthropic.APIError) {
+          await this.sleep(delay * (i + 1));
+        } else {
+          throw error;
+        }
+      }
+    }
+    throw lastError;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/core/preprocessor.ts
+var ConversationPreprocessor = class {
+  positiveSignals = [
+    "perfect",
+    "great",
+    "thanks",
+    "good",
+    "works",
+    "done",
+    "\u597D\u7684",
+    "\u53EF\u4EE5",
+    "\u5B8C\u6210",
+    "\u6210\u529F",
+    "\u5BF9\u7684"
+  ];
+  negativeSignals = [
+    "wrong",
+    "error",
+    "fail",
+    "doesn't work",
+    "not working",
+    "not right",
+    "undo",
+    "\u4E0D\u5BF9",
+    "\u9519\u8BEF",
+    "\u5931\u8D25",
+    "\u64A4\u9500",
+    "\u56DE\u6EDA"
+  ];
+  process(messages) {
+    let turnIndex = 0;
+    let toolCallCount = 0;
+    const processed = messages.map((msg) => {
+      if (msg.role === "user") {
+        turnIndex++;
+      }
+      const hasToolCalls = (msg.toolCalls?.length ?? 0) > 0;
+      if (hasToolCalls) {
+        toolCallCount += msg.toolCalls.length;
+      }
+      const codeBlocks = this.extractCodeBlocks(msg.content);
+      return {
+        ...msg,
+        turnIndex,
+        hasToolCalls,
+        hasCodeBlocks: codeBlocks.length > 0,
+        codeBlocks,
+        sentiment: this.analyzeSentiment(msg.content)
+      };
+    });
+    return {
+      messages: processed,
+      totalTurns: turnIndex,
+      toolCallCount
+    };
+  }
+  extractCodeBlocks(content) {
+    const regex = /```[\w]*\n([\s\S]*?)```/g;
+    const blocks = [];
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      blocks.push(match[1].trim());
+    }
+    return blocks;
+  }
+  analyzeSentiment(content) {
+    const lower = content.toLowerCase();
+    const hasPositive = this.positiveSignals.some((s) => lower.includes(s));
+    const hasNegative = this.negativeSignals.some((s) => lower.includes(s));
+    if (hasPositive && !hasNegative) return "positive";
+    if (hasNegative) return "negative";
+    return "neutral";
+  }
+};
+
+// src/core/failed-filter.ts
+var FailedAttemptFilter = class {
+  failureIndicators = {
+    userSignals: [
+      "not working",
+      "doesn't work",
+      "wrong",
+      "undo",
+      "revert",
+      "go back",
+      "try again",
+      "that's not right",
+      "actually",
+      "\u4E0D\u5BF9",
+      "\u64A4\u9500",
+      "\u56DE\u6EDA",
+      "\u91CD\u8BD5",
+      "\u6362\u4E2A\u65B9\u6CD5"
+    ],
+    assistantSignals: [
+      "sorry",
+      "apologize",
+      "my mistake",
+      "let me try again",
+      "I made an error",
+      "that was incorrect",
+      "\u62B1\u6B49",
+      "\u5BF9\u4E0D\u8D77",
+      "\u6211\u7684\u9519\u8BEF",
+      "\u8BA9\u6211\u91CD\u8BD5"
+    ],
+    toolFailures: ["error", "failed", "exception", "not found", "permission denied"]
+  };
+  filter(messages) {
+    const failedTurns = this.identifyFailedTurns(messages);
+    const filtered = messages.filter((msg) => !failedTurns.has(msg.turnIndex));
+    return {
+      messages: filtered,
+      removedCount: messages.length - filtered.length,
+      removedTurns: Array.from(failedTurns)
+    };
+  }
+  identifyFailedTurns(messages) {
+    const failedTurns = /* @__PURE__ */ new Set();
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+      const nextMsg = messages[i + 1];
+      if (msg.role === "user" && this.hasFailureSignal(msg.content, "userSignals")) {
+        if (msg.turnIndex > 1) {
+          failedTurns.add(msg.turnIndex - 1);
+        }
+      }
+      if (msg.role === "assistant" && this.hasFailureSignal(msg.content, "assistantSignals")) {
+        failedTurns.add(msg.turnIndex);
+      }
+      if (msg.toolResults?.some((r) => !r.success)) {
+        failedTurns.add(msg.turnIndex);
+      }
+      if (msg.toolResults?.some((r) => this.hasFailureSignal(r.output, "toolFailures"))) {
+        failedTurns.add(msg.turnIndex);
+      }
+      if (msg.role === "user" && nextMsg?.role === "user") {
+        failedTurns.add(msg.turnIndex);
+      }
+    }
+    return failedTurns;
+  }
+  hasFailureSignal(content, signalType) {
+    const lower = content.toLowerCase();
+    return this.failureIndicators[signalType].some((signal) => lower.includes(signal.toLowerCase()));
+  }
+};
+
+// src/core/parameter-extractor.ts
+var ParameterExtractor = class {
+  patterns = [
+    { regex: /(?:src|lib|app|components|pages)\/[\w\-/]+\.\w+/g, type: "path" },
+    { regex: /(?:src|lib|app|components|pages)\/[\w\-/]+/g, type: "directory" },
+    {
+      regex: /\b[a-z][a-zA-Z0-9]*(?:Component|Hook|Service|Controller|Module)\b/g,
+      type: "name"
+    },
+    { regex: /:\d{4,5}\b/g, type: "port" },
+    { regex: /https?:\/\/[^\s]+/g, type: "url" }
+  ];
+  extract(steps, existingParams) {
+    const extractedParams = /* @__PURE__ */ new Map();
+    existingParams.forEach((p) => {
+      extractedParams.set(p.name, {
+        ...p,
+        required: p.default === void 0
+      });
+    });
+    const processedSteps = steps.filter((s) => s.isKeyStep).map((step) => {
+      let description = step.description;
+      for (const pattern of this.patterns) {
+        const matches = description.match(pattern.regex);
+        if (matches) {
+          for (const match of matches) {
+            const paramName = this.generateParamName(match, pattern.type);
+            if (!extractedParams.has(paramName)) {
+              extractedParams.set(paramName, {
+                name: paramName,
+                type: "string",
+                description: `${pattern.type} parameter extracted from step`,
+                default: match,
+                required: false
+              });
+            }
+            description = description.replace(match, `{${paramName}}`);
+          }
+        }
+      }
+      return {
+        title: step.title,
+        description,
+        substeps: step.substeps
+      };
+    });
+    return {
+      steps: processedSteps,
+      parameters: Array.from(extractedParams.values())
+    };
+  }
+  generateParamName(value, type) {
+    switch (type) {
+      case "path": {
+        const fileName = value.split("/").pop() ?? "file";
+        return `${fileName.replace(/\.\w+$/, "")}_path`;
+      }
+      case "directory": {
+        const dirName = value.split("/").pop() ?? "dir";
+        return `${dirName}_dir`;
+      }
+      case "name":
+        return value.toLowerCase().replace(/component|hook|service/gi, "") + "_name";
+      case "port":
+        return "port";
+      case "url":
+        return "api_url";
+      default:
+        return `param_${type}`;
+    }
+  }
+};
+
+// src/core/distiller.ts
+var Distiller = class {
+  llmEngine;
+  preprocessor;
+  failedFilter;
+  parameterExtractor;
+  constructor(llmEngine) {
+    this.llmEngine = llmEngine ?? new LLMEngine();
+    this.preprocessor = new ConversationPreprocessor();
+    this.failedFilter = new FailedAttemptFilter();
+    this.parameterExtractor = new ParameterExtractor();
+  }
+  async distill(session, options = {}) {
+    const { userPrompts, skipFailedFilter, verbose } = options;
+    if (verbose) console.log("Preprocessing conversation...");
+    const preprocessed = this.preprocessor.process(session.messages);
+    let filteredMessages = preprocessed.messages;
+    let stepsFiltered = 0;
+    if (!skipFailedFilter) {
+      if (verbose) console.log("Filtering failed attempts...");
+      const filterResult = this.failedFilter.filter(preprocessed.messages);
+      filteredMessages = filterResult.messages;
+      stepsFiltered = filterResult.removedCount;
+    }
+    const filteredSession = {
+      ...session,
+      messages: filteredMessages
+    };
+    if (verbose) console.log("Extracting intent...");
+    const intent = await this.llmEngine.extractIntent(filteredSession);
+    if (verbose) console.log("Distilling steps...");
+    const stepsResult = await this.llmEngine.distillSteps(filteredSession, intent, userPrompts);
+    if (verbose) console.log("Extracting parameters...");
+    const { steps: parameterizedSteps, parameters } = this.parameterExtractor.extract(
+      stepsResult.steps,
+      this.convertParameters(stepsResult.parameters)
+    );
+    if (verbose) console.log("Generating description...");
+    const description = await this.llmEngine.generateDescription(intent);
+    const skill = this.assembleSkill(
+      intent,
+      description,
+      parameterizedSteps,
+      parameters,
+      stepsResult
+    );
+    if (verbose) console.log("Enhancing quality...");
+    const enhancedSkill = await this.llmEngine.enhanceQuality(skill);
+    const tokenUsage = this.llmEngine.getTokenUsage();
+    return {
+      skill: enhancedSkill,
+      metadata: {
+        sessionId: session.id,
+        distilledAt: (/* @__PURE__ */ new Date()).toISOString(),
+        tokenUsage: {
+          input: tokenUsage.inputTokens,
+          output: tokenUsage.outputTokens
+        },
+        stepsFiltered
+      }
+    };
+  }
+  convertParameters(params) {
+    return params.map((p) => ({
+      name: p.name,
+      type: p.type,
+      description: p.description,
+      default: p.defaultValue,
+      required: p.defaultValue === void 0
+    }));
+  }
+  assembleSkill(intent, description, steps, parameters, stepsResult) {
+    return {
+      metadata: {
+        name: this.generateName(intent),
+        description,
+        version: "1.0.0"
+      },
+      overview: intent.goal,
+      triggers: intent.triggers,
+      prerequisites: stepsResult.prerequisites,
+      steps,
+      parameters,
+      errorHandling: stepsResult.errorHandling,
+      examples: this.generateExamples(intent.triggers),
+      notes: []
+    };
+  }
+  generateName(intent) {
+    const words = intent.goal.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 2).slice(0, 4);
+    return words.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+  }
+  generateExamples(triggers) {
+    return triggers.slice(0, 3).map((trigger) => `Help me ${trigger.toLowerCase()}`);
+  }
+};
+
+// src/generators/skill-generator.ts
+import { promises as fs4 } from "fs";
+import { join as join5 } from "path";
+
+// src/generators/frontmatter-builder.ts
+import { stringify } from "yaml";
+var FrontmatterBuilder = class {
+  build(metadata) {
+    const frontmatter = {
+      name: metadata.name,
+      description: metadata.description,
+      version: metadata.version
+    };
+    if (metadata.license) {
+      frontmatter.license = metadata.license;
+    }
+    const yaml = stringify(frontmatter, {
+      lineWidth: 0,
+      defaultStringType: "PLAIN"
+    });
+    return `---
+${yaml}---`;
+  }
+  validateDescription(description) {
+    const thirdPersonStart = description.toLowerCase().startsWith("this skill");
+    const hasTriggerPhrases = description.includes('"') || description.includes("'");
+    return thirdPersonStart && hasTriggerPhrases;
+  }
+};
+
+// src/generators/markdown-renderer.ts
+var MarkdownRenderer = class {
+  renderTitle(name) {
+    return `# ${name}`;
+  }
+  renderOverview(overview) {
+    return `## Overview
+
+${overview}`;
+  }
+  renderTriggers(triggers) {
+    const lines = ["## When This Skill Applies", "", "This skill activates when the user's request involves:"];
+    triggers.forEach((trigger) => {
+      lines.push(`- ${trigger}`);
+    });
+    return lines.join("\n");
+  }
+  renderPrerequisites(prerequisites) {
+    const lines = ["## Prerequisites", ""];
+    prerequisites.forEach((prereq) => {
+      lines.push(`- ${prereq}`);
+    });
+    return lines.join("\n");
+  }
+  renderSteps(steps) {
+    const lines = ["## Core Workflow", ""];
+    steps.forEach((step, index) => {
+      lines.push(`### Step ${index + 1}: ${step.title}`);
+      lines.push("");
+      lines.push(step.description);
+      if (step.substeps?.length) {
+        lines.push("");
+        step.substeps.forEach((substep, i) => {
+          lines.push(`${i + 1}. ${substep}`);
+        });
+      }
+      lines.push("");
+    });
+    return lines.join("\n").trim();
+  }
+  renderParameters(parameters) {
+    const lines = [
+      "## Parameters",
+      "",
+      "| Parameter | Type | Default | Description |",
+      "|-----------|------|---------|-------------|"
+    ];
+    parameters.forEach((param) => {
+      const defaultVal = param.default !== void 0 ? `\`${param.default}\`` : "-";
+      const required = param.required ? " (required)" : "";
+      lines.push(`| \`${param.name}\` | ${param.type} | ${defaultVal} | ${param.description}${required} |`);
+    });
+    return lines.join("\n");
+  }
+  renderErrorHandling(errorHandling) {
+    const lines = ["## Error Handling", ""];
+    Object.entries(errorHandling).forEach(([error, solution]) => {
+      lines.push(`- **${error}**: ${solution}`);
+    });
+    return lines.join("\n");
+  }
+  renderExamples(examples) {
+    const lines = ["## Example Usage", ""];
+    examples.forEach((example) => {
+      lines.push("```");
+      lines.push(example);
+      lines.push("```");
+      lines.push("");
+    });
+    return lines.join("\n").trim();
+  }
+  renderReferences(references) {
+    const lines = ["## Additional Resources", "", "### Reference Files", ""];
+    references.forEach((ref) => {
+      lines.push(`- **\`${ref}\`**`);
+    });
+    return lines.join("\n");
+  }
+  renderNotes(notes) {
+    const lines = ["## Notes", ""];
+    notes.forEach((note) => {
+      lines.push(`- ${note}`);
+    });
+    return lines.join("\n");
+  }
+};
+
+// src/generators/directory-builder.ts
+import { promises as fs2 } from "fs";
+import { join as join4 } from "path";
+var DirectoryBuilder = class {
+  async create(basePath, options = {}) {
+    const { includeReferences = true, includeExamples = false, includeScripts = false } = options;
+    await fs2.mkdir(basePath, { recursive: true });
+    if (includeReferences) {
+      await fs2.mkdir(join4(basePath, "references"), { recursive: true });
+    }
+    if (includeExamples) {
+      await fs2.mkdir(join4(basePath, "examples"), { recursive: true });
+    }
+    if (includeScripts) {
+      await fs2.mkdir(join4(basePath, "scripts"), { recursive: true });
+    }
+  }
+  async listStructure(basePath) {
+    const files = [];
+    async function walk(dir, prefix = "") {
+      const entries = await fs2.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+          files.push(`${relativePath}/`);
+          await walk(join4(dir, entry.name), relativePath);
+        } else {
+          files.push(relativePath);
+        }
+      }
+    }
+    await walk(basePath);
+    return files;
+  }
+};
+
+// src/generators/template-validator.ts
+var TemplateValidator = class {
+  validate(content, skill) {
+    const errors = [];
+    const warnings = [];
+    this.validateFrontmatter(content, skill, errors, warnings);
+    this.validateRequiredSections(content, errors);
+    this.validateWritingStyle(content, warnings);
+    this.validateLength(content, warnings);
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  validateFrontmatter(content, skill, errors, warnings) {
+    if (!content.startsWith("---")) {
+      errors.push({
+        field: "frontmatter",
+        message: "Missing YAML frontmatter",
+        severity: "error"
+      });
+      return;
+    }
+    if (!skill.metadata.description.toLowerCase().includes("this skill")) {
+      warnings.push({
+        field: "description",
+        message: 'Description should start with "This skill should be used when..."',
+        severity: "warning"
+      });
+    }
+    if (!skill.metadata.description.includes('"')) {
+      warnings.push({
+        field: "description",
+        message: "Description should include specific trigger phrases in quotes",
+        severity: "warning"
+      });
+    }
+  }
+  validateRequiredSections(content, errors) {
+    const requiredSections = [
+      { pattern: /^## Overview/m, name: "Overview" },
+      { pattern: /^## (When This Skill Applies|Triggers)/m, name: "Triggers" },
+      { pattern: /^## (Core Workflow|Steps)/m, name: "Steps" }
+    ];
+    for (const section of requiredSections) {
+      if (!section.pattern.test(content)) {
+        errors.push({
+          field: section.name,
+          message: `Missing required section: ${section.name}`,
+          severity: "error"
+        });
+      }
+    }
+  }
+  validateWritingStyle(content, warnings) {
+    const secondPersonPatterns = [/\bYou should\b/gi, /\bYou need to\b/gi, /\bYou can\b/gi, /\bYou must\b/gi];
+    for (const pattern of secondPersonPatterns) {
+      if (pattern.test(content)) {
+        warnings.push({
+          field: "style",
+          message: `Avoid second person ("${pattern.source}"). Use imperative form instead.`,
+          severity: "warning"
+        });
+      }
+    }
+  }
+  validateLength(content, warnings) {
+    const wordCount = content.split(/\s+/).length;
+    if (wordCount > 5e3) {
+      warnings.push({
+        field: "length",
+        message: `SKILL.md is too long (${wordCount} words). Consider moving content to references/`,
+        severity: "warning"
+      });
+    }
+    if (wordCount < 200) {
+      warnings.push({
+        field: "length",
+        message: `SKILL.md is very short (${wordCount} words). Consider adding more detail.`,
+        severity: "warning"
+      });
+    }
+  }
+};
+
+// src/utils/fs.ts
+import { promises as fs3 } from "fs";
+async function ensureDir(path) {
+  await fs3.mkdir(path, { recursive: true });
+}
+async function fileExists(path) {
+  try {
+    await fs3.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/generators/skill-generator.ts
+var SkillGenerator = class {
+  frontmatterBuilder;
+  markdownRenderer;
+  directoryBuilder;
+  validator;
+  constructor() {
+    this.frontmatterBuilder = new FrontmatterBuilder();
+    this.markdownRenderer = new MarkdownRenderer();
+    this.directoryBuilder = new DirectoryBuilder();
+    this.validator = new TemplateValidator();
+  }
+  async generate(skill, options) {
+    const { outputDir, overwrite = false, includeReferences = true } = options;
+    const skillDirName = this.toKebabCase(skill.metadata.name);
+    const skillDir = join5(outputDir, skillDirName);
+    if (!overwrite && await this.exists(skillDir)) {
+      throw new Error(`Skill directory already exists: ${skillDir}`);
+    }
+    await this.directoryBuilder.create(skillDir, {
+      includeReferences,
+      includeExamples: options.includeExamples ?? false
+    });
+    const content = this.renderSkill(skill);
+    const validation = this.validator.validate(content, skill);
+    const skillPath = join5(skillDir, "SKILL.md");
+    await fs4.writeFile(skillPath, content, "utf-8");
+    const files = [skillPath];
+    if (includeReferences && skill.references?.length) {
+      const refPath = await this.generateReferences(skillDir, skill);
+      files.push(refPath);
+    }
+    return {
+      skillPath,
+      files,
+      validation
+    };
+  }
+  renderSkill(skill) {
+    const parts = [];
+    parts.push(this.frontmatterBuilder.build(skill.metadata));
+    parts.push(this.markdownRenderer.renderTitle(skill.metadata.name));
+    parts.push(this.markdownRenderer.renderOverview(skill.overview));
+    parts.push(this.markdownRenderer.renderTriggers(skill.triggers));
+    if (skill.prerequisites.length) {
+      parts.push(this.markdownRenderer.renderPrerequisites(skill.prerequisites));
+    }
+    parts.push(this.markdownRenderer.renderSteps(skill.steps));
+    if (skill.parameters.length) {
+      parts.push(this.markdownRenderer.renderParameters(skill.parameters));
+    }
+    if (Object.keys(skill.errorHandling).length) {
+      parts.push(this.markdownRenderer.renderErrorHandling(skill.errorHandling));
+    }
+    if (skill.examples.length) {
+      parts.push(this.markdownRenderer.renderExamples(skill.examples));
+    }
+    if (skill.references?.length) {
+      parts.push(this.markdownRenderer.renderReferences(skill.references));
+    }
+    if (skill.notes?.length) {
+      parts.push(this.markdownRenderer.renderNotes(skill.notes));
+    }
+    return parts.join("\n\n");
+  }
+  async generateReferences(skillDir, skill) {
+    const refDir = join5(skillDir, "references");
+    await ensureDir(refDir);
+    const patternsPath = join5(refDir, "patterns.md");
+    const patternsContent = `# Patterns and Best Practices
+
+This file contains detailed patterns extracted from the original conversation.
+
+## Common Patterns
+
+${skill.notes?.map((n) => `- ${n}`).join("\n") || "No additional patterns documented."}
+`;
+    await fs4.writeFile(patternsPath, patternsContent, "utf-8");
+    return patternsPath;
+  }
+  toKebabCase(str) {
+    return str.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+  }
+  async exists(path) {
+    try {
+      await fs4.access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/prompt-handler/interactive.ts
+import inquirer from "inquirer";
+import chalk from "chalk";
+async function collectPromptsInteractively() {
+  const prompts = [];
+  console.log(chalk.cyan("\n\u{1F4DD} \u6DFB\u52A0\u9644\u52A0\u6307\u4EE4 (\u53EF\u9009)"));
+  console.log(chalk.gray("  \u8F93\u5165\u7A7A\u884C\u5B8C\u6210\u6536\u96C6\n"));
+  for (; ; ) {
+    const { prompt } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "prompt",
+        message: "\u6307\u4EE4:",
+        prefix: chalk.yellow("\u2192")
+      }
+    ]);
+    if (!prompt.trim()) {
+      break;
+    }
+    prompts.push(prompt.trim());
+  }
+  if (prompts.length === 0) {
+    return { prompts: [], confirmed: true };
+  }
+  console.log(chalk.cyan("\n\u{1F4CB} \u5DF2\u6536\u96C6\u7684\u6307\u4EE4:"));
+  prompts.forEach((p, i) => {
+    console.log(chalk.gray(`  ${i + 1}. ${p}`));
+  });
+  const { confirm } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: "\u4F7F\u7528\u8FD9\u4E9B\u6307\u4EE4?",
+      default: true
+    }
+  ]);
+  return { prompts, confirmed: confirm };
+}
+
+// src/installers/claude.ts
+import { promises as fs5 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir4 } from "os";
+
+// src/installers/base.ts
+var AgentInstaller = class {
+  basePath;
+  constructor(basePath) {
+    this.basePath = basePath ?? this.getDefaultBasePath();
+  }
+  async verify(skillName) {
+    const installed = await this.list();
+    return installed.some((s) => s.name === skillName);
+  }
+};
+
+// src/installers/claude.ts
+var ClaudeCodeInstaller = class extends AgentInstaller {
+  generator;
+  constructor(basePath) {
+    super(basePath);
+    this.generator = new SkillGenerator();
+  }
+  getDefaultBasePath() {
+    return join6(homedir4(), ".claude", "plugins", "local", "skills");
+  }
+  getPlatformName() {
+    return "Claude Code";
+  }
+  async install(skill, options = {}) {
+    const { overwrite = false, backup = true, verify = true } = options;
+    const skillDirName = this.toKebabCase(skill.metadata.name);
+    const skillPath = join6(this.basePath, skillDirName);
+    if (await fileExists(skillPath)) {
+      if (!overwrite) {
+        return {
+          success: false,
+          path: skillPath,
+          message: `Skill already exists: ${skillPath}. Use --overwrite to replace.`
+        };
+      }
+      if (backup) {
+        const backupPath = `${skillPath}.backup.${Date.now()}`;
+        await fs5.rename(skillPath, backupPath);
+      }
+    }
+    await ensureDir(this.basePath);
+    const result = await this.generator.generate(skill, {
+      outputDir: this.basePath,
+      overwrite: true
+    });
+    if (verify) {
+      const verified = await this.verifyInstallation(skillPath);
+      if (!verified) {
+        return {
+          success: false,
+          path: skillPath,
+          message: "Installation verification failed"
+        };
+      }
+    }
+    return {
+      success: true,
+      path: result.skillPath,
+      message: `Successfully installed to ${this.getPlatformName()}`
+    };
+  }
+  async uninstall(skillName) {
+    const skillPath = join6(this.basePath, this.toKebabCase(skillName));
+    if (!await fileExists(skillPath)) {
+      throw new Error(`Skill not found: ${skillName}`);
+    }
+    await fs5.rm(skillPath, { recursive: true });
+  }
+  async list() {
+    const skills = [];
+    try {
+      const entries = await fs5.readdir(this.basePath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const skillMdPath = join6(this.basePath, entry.name, "SKILL.md");
+        if (await fileExists(skillMdPath)) {
+          const content = await fs5.readFile(skillMdPath, "utf-8");
+          const metadata = this.parseMetadata(content);
+          const stat = await fs5.stat(skillMdPath);
+          skills.push({
+            name: metadata.name ?? entry.name,
+            path: join6(this.basePath, entry.name),
+            version: metadata.version ?? "0.0.0",
+            installedAt: stat.mtime.toISOString()
+          });
+        }
+      }
+    } catch {
+    }
+    return skills;
+  }
+  async verifyInstallation(skillPath) {
+    const skillMd = join6(skillPath, "SKILL.md");
+    if (!await fileExists(skillMd)) {
+      return false;
+    }
+    const content = await fs5.readFile(skillMd, "utf-8");
+    if (!content.startsWith("---")) {
+      return false;
+    }
+    const metadata = this.parseMetadata(content);
+    return !!(metadata.name && metadata.description);
+  }
+  parseMetadata(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) return {};
+    const yaml = match[1];
+    const metadata = {};
+    yaml.split("\n").forEach((line) => {
+      const colonIndex = line.indexOf(":");
+      if (colonIndex > 0) {
+        const key = line.slice(0, colonIndex).trim();
+        const value = line.slice(colonIndex + 1).trim();
+        metadata[key] = value;
+      }
+    });
+    return metadata;
+  }
+  toKebabCase(str) {
+    return str.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+  }
+};
+
+// src/installers/codex.ts
+import { promises as fs6 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir5 } from "os";
+
+// src/formatters/claude-formatter.ts
+import { stringify as stringify2 } from "yaml";
+var ClaudeFormatter = class {
+  format(skill, options = {}) {
+    const parts = [];
+    parts.push(this.formatFrontmatter(skill));
+    parts.push(`# ${skill.metadata.name}`);
+    parts.push(`## Overview
+
+${skill.overview}`);
+    parts.push(this.formatTriggers(skill.triggers));
+    if (skill.prerequisites.length > 0) {
+      parts.push(this.formatPrerequisites(skill.prerequisites));
+    }
+    parts.push(this.formatSteps(skill.steps));
+    if (skill.parameters.length > 0) {
+      parts.push(this.formatParameters(skill.parameters));
+    }
+    if (Object.keys(skill.errorHandling).length > 0) {
+      parts.push(this.formatErrorHandling(skill.errorHandling));
+    }
+    if (options.includeExamples !== false && skill.examples.length > 0) {
+      parts.push(this.formatExamples(skill.examples));
+    }
+    if (skill.notes && skill.notes.length > 0) {
+      parts.push(this.formatNotes(skill.notes));
+    }
+    return parts.join("\n\n");
+  }
+  formatFrontmatter(skill) {
+    const data = {
+      name: skill.metadata.name,
+      description: skill.metadata.description,
+      version: skill.metadata.version
+    };
+    if (skill.metadata.license) {
+      data.license = skill.metadata.license;
+    }
+    return `---
+${stringify2(data)}---`;
+  }
+  formatTriggers(triggers) {
+    const lines = ["## When This Skill Applies", "", "This skill activates when:"];
+    triggers.forEach((t) => lines.push(`- ${t}`));
+    return lines.join("\n");
+  }
+  formatPrerequisites(prerequisites) {
+    const lines = ["## Prerequisites", ""];
+    prerequisites.forEach((p) => lines.push(`- ${p}`));
+    return lines.join("\n");
+  }
+  formatSteps(steps) {
+    const lines = ["## Core Workflow", ""];
+    steps.forEach((step, i) => {
+      lines.push(`### Step ${i + 1}: ${step.title}`);
+      lines.push("");
+      lines.push(step.description);
+      if (step.substeps?.length) {
+        lines.push("");
+        step.substeps.forEach((sub, j) => {
+          lines.push(`${j + 1}. ${sub}`);
+        });
+      }
+      lines.push("");
+    });
+    return lines.join("\n").trim();
+  }
+  formatParameters(parameters) {
+    const lines = [
+      "## Parameters",
+      "",
+      "| Parameter | Type | Default | Description |",
+      "|-----------|------|---------|-------------|"
+    ];
+    parameters.forEach((p) => {
+      const def = p.default !== void 0 ? `\`${p.default}\`` : "-";
+      lines.push(`| \`${p.name}\` | ${p.type} | ${def} | ${p.description} |`);
+    });
+    return lines.join("\n");
+  }
+  formatErrorHandling(errorHandling) {
+    const lines = ["## Error Handling", ""];
+    Object.entries(errorHandling).forEach(([error, solution]) => {
+      lines.push(`- **${error}**: ${solution}`);
+    });
+    return lines.join("\n");
+  }
+  formatExamples(examples) {
+    const lines = ["## Example Usage", ""];
+    examples.forEach((ex) => {
+      lines.push("```");
+      lines.push(ex);
+      lines.push("```");
+      lines.push("");
+    });
+    return lines.join("\n").trim();
+  }
+  formatNotes(notes) {
+    const lines = ["## Notes", ""];
+    notes.forEach((n) => lines.push(`- ${n}`));
+    return lines.join("\n");
+  }
+};
+
+// src/formatters/codex-formatter.ts
+import { stringify as stringify3 } from "yaml";
+var CodexFormatter = class {
+  format(skill, _options = {}) {
+    const parts = [];
+    parts.push(this.formatFrontmatter(skill));
+    parts.push("# Agent Instructions");
+    parts.push("");
+    parts.push(skill.overview);
+    parts.push("");
+    parts.push("## Capabilities");
+    parts.push("");
+    skill.triggers.forEach((t) => parts.push(`- ${t}`));
+    parts.push("");
+    parts.push("## Workflow");
+    parts.push("");
+    skill.steps.forEach((step, i) => {
+      parts.push(`${i + 1}. **${step.title}**: ${step.description}`);
+      if (step.substeps?.length) {
+        step.substeps.forEach((sub) => {
+          parts.push(`   - ${sub}`);
+        });
+      }
+    });
+    if (skill.prerequisites.length > 0) {
+      parts.push("");
+      parts.push("## Prerequisites");
+      parts.push("");
+      skill.prerequisites.forEach((p) => parts.push(`- ${p}`));
+    }
+    if (Object.keys(skill.errorHandling).length > 0) {
+      parts.push("");
+      parts.push("## Error Handling");
+      parts.push("");
+      Object.entries(skill.errorHandling).forEach(([error, solution]) => {
+        parts.push(`- ${error}: ${solution}`);
+      });
+    }
+    return parts.join("\n");
+  }
+  formatFrontmatter(skill) {
+    const data = {
+      name: this.toKebabCase(skill.metadata.name),
+      description: skill.metadata.description,
+      model: "o4-mini"
+    };
+    return `---
+${stringify3(data)}---`;
+  }
+  toKebabCase(str) {
+    return str.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+  }
+};
+
+// src/formatters/cursor-formatter.ts
+var CursorFormatter = class {
+  format(skill, _options = {}) {
+    const parts = [];
+    parts.push(`# ${skill.metadata.name}`);
+    parts.push(`# Generated by Skill Distill`);
+    parts.push("");
+    parts.push("## Overview");
+    parts.push("");
+    parts.push(skill.overview);
+    parts.push("");
+    parts.push("## Workflow Rules");
+    parts.push("");
+    skill.steps.forEach((step) => {
+      parts.push(`### ${step.title}`);
+      parts.push("");
+      parts.push(step.description);
+      if (step.substeps?.length) {
+        parts.push("");
+        step.substeps.forEach((sub) => {
+          parts.push(`- ${sub}`);
+        });
+      }
+      parts.push("");
+    });
+    if (skill.prerequisites.length > 0) {
+      parts.push("## Constraints");
+      parts.push("");
+      skill.prerequisites.forEach((p) => {
+        parts.push(`- ${p}`);
+      });
+      parts.push("");
+    }
+    if (Object.keys(skill.errorHandling).length > 0) {
+      parts.push("## Error Handling");
+      parts.push("");
+      Object.entries(skill.errorHandling).forEach(([error, solution]) => {
+        parts.push(`- When encountering "${error}": ${solution}`);
+      });
+      parts.push("");
+    }
+    if (skill.parameters.length > 0) {
+      parts.push("## Parameters");
+      parts.push("");
+      parts.push("The following parameters can be customized:");
+      parts.push("");
+      skill.parameters.forEach((p) => {
+        const def = p.default ? ` (default: ${p.default})` : "";
+        parts.push(`- \`${p.name}\`: ${p.description}${def}`);
+      });
+    }
+    return parts.join("\n");
+  }
+};
+
+// src/formatters/converter.ts
+var FormatConverter = class {
+  claudeFormatter;
+  codexFormatter;
+  cursorFormatter;
+  constructor() {
+    this.claudeFormatter = new ClaudeFormatter();
+    this.codexFormatter = new CodexFormatter();
+    this.cursorFormatter = new CursorFormatter();
+  }
+  convert(skill, format, options) {
+    switch (format) {
+      case "claude":
+        return this.toClaudeFormat(skill, options);
+      case "codex":
+        return this.toCodexFormat(skill, options);
+      case "cursor":
+        return this.toCursorFormat(skill, options);
+      default:
+        throw new Error(`Unsupported format: ${format}`);
+    }
+  }
+  convertAll(skill, options) {
+    const results = /* @__PURE__ */ new Map();
+    results.set("claude", this.toClaudeFormat(skill, options));
+    results.set("codex", this.toCodexFormat(skill, options));
+    results.set("cursor", this.toCursorFormat(skill, options));
+    return results;
+  }
+  toClaudeFormat(skill, options) {
+    return this.claudeFormatter.format(skill, options);
+  }
+  toCodexFormat(skill, options) {
+    return this.codexFormatter.format(skill, options);
+  }
+  toCursorFormat(skill, options) {
+    return this.cursorFormatter.format(skill, options);
+  }
+};
+
+// src/installers/codex.ts
+var CodexInstaller = class extends AgentInstaller {
+  converter;
+  constructor(basePath) {
+    super(basePath);
+    this.converter = new FormatConverter();
+  }
+  getDefaultBasePath() {
+    return join7(homedir5(), ".codex", "agents");
+  }
+  getPlatformName() {
+    return "Codex CLI";
+  }
+  async install(skill, options = {}) {
+    const { overwrite = false } = options;
+    const agentName = this.toKebabCase(skill.metadata.name);
+    const agentPath = join7(this.basePath, `${agentName}.md`);
+    if (await fileExists(agentPath) && !overwrite) {
+      return {
+        success: false,
+        path: agentPath,
+        message: `Agent already exists: ${agentPath}`
+      };
+    }
+    await ensureDir(this.basePath);
+    const content = this.converter.toCodexFormat(skill);
+    await fs6.writeFile(agentPath, content, "utf-8");
+    return {
+      success: true,
+      path: agentPath,
+      message: `Successfully installed to ${this.getPlatformName()}`
+    };
+  }
+  async uninstall(skillName) {
+    const agentPath = join7(this.basePath, `${this.toKebabCase(skillName)}.md`);
+    if (!await fileExists(agentPath)) {
+      throw new Error(`Agent not found: ${skillName}`);
+    }
+    await fs6.unlink(agentPath);
+  }
+  async list() {
+    const skills = [];
+    try {
+      const files = await fs6.readdir(this.basePath);
+      for (const file of files) {
+        if (!file.endsWith(".md")) continue;
+        const agentPath = join7(this.basePath, file);
+        const stat = await fs6.stat(agentPath);
+        skills.push({
+          name: file.replace(".md", ""),
+          path: agentPath,
+          version: "0.0.0",
+          installedAt: stat.mtime.toISOString()
+        });
+      }
+    } catch {
+    }
+    return skills;
+  }
+  toKebabCase(str) {
+    return str.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+  }
+};
+
+// src/installers/cursor.ts
+import { promises as fs7 } from "fs";
+import { join as join8 } from "path";
+var CursorInstaller = class extends AgentInstaller {
+  converter;
+  projectPath;
+  constructor(projectPath) {
+    super(projectPath);
+    this.projectPath = projectPath;
+    this.converter = new FormatConverter();
+  }
+  getDefaultBasePath() {
+    return this.projectPath;
+  }
+  getPlatformName() {
+    return "Cursor";
+  }
+  async install(skill, options = {}) {
+    const { overwrite = false, backup = true } = options;
+    const rulesPath = join8(this.basePath, ".cursorrules");
+    if (await fileExists(rulesPath)) {
+      if (!overwrite) {
+        return {
+          success: false,
+          path: rulesPath,
+          message: ".cursorrules already exists. Use --overwrite to replace."
+        };
+      }
+      if (backup) {
+        const backupPath = `${rulesPath}.backup.${Date.now()}`;
+        await fs7.copyFile(rulesPath, backupPath);
+      }
+    }
+    const content = this.converter.toCursorFormat(skill);
+    await fs7.writeFile(rulesPath, content, "utf-8");
+    return {
+      success: true,
+      path: rulesPath,
+      message: `Successfully installed to ${this.getPlatformName()}`
+    };
+  }
+  async uninstall(_skillName) {
+    const rulesPath = join8(this.basePath, ".cursorrules");
+    if (!await fileExists(rulesPath)) {
+      throw new Error(".cursorrules not found");
+    }
+    await fs7.unlink(rulesPath);
+  }
+  async list() {
+    const rulesPath = join8(this.basePath, ".cursorrules");
+    if (!await fileExists(rulesPath)) {
+      return [];
+    }
+    const stat = await fs7.stat(rulesPath);
+    return [
+      {
+        name: "cursorrules",
+        path: rulesPath,
+        version: "0.0.0",
+        installedAt: stat.mtime.toISOString()
+      }
+    ];
+  }
+};
+
+// src/installers/index.ts
+function createInstaller(platform, options = {}) {
+  switch (platform) {
+    case "claude":
+      return new ClaudeCodeInstaller(options.basePath);
+    case "codex":
+      return new CodexInstaller(options.basePath);
+    case "cursor":
+      if (!options.projectPath) {
+        throw new Error("Cursor installer requires projectPath");
+      }
+      return new CursorInstaller(options.projectPath);
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+}
+
+// src/cli/config.ts
+import { promises as fs8 } from "fs";
+import { join as join9 } from "path";
+import { homedir as homedir6 } from "os";
+var CONFIG_DIR = join9(homedir6(), ".skill-distill");
+var CONFIG_FILE = join9(CONFIG_DIR, "config.json");
+var DEFAULT_CONFIG = {
+  defaultPlatform: "claude",
+  outputDir: join9(homedir6(), ".skills"),
+  autoInstall: false,
+  sessionSources: {
+    claude: join9(homedir6(), ".claude", "projects")
+  }
+};
+async function loadConfig() {
+  try {
+    const content = await fs8.readFile(CONFIG_FILE, "utf-8");
+    const saved = JSON.parse(content);
+    return { ...DEFAULT_CONFIG, ...saved };
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+
+// src/utils/logger.ts
+import chalk2 from "chalk";
+var logger = {
+  info: (msg) => console.log(chalk2.blue("\u2139"), msg),
+  success: (msg) => console.log(chalk2.green("\u2713"), msg),
+  warn: (msg) => console.log(chalk2.yellow("\u26A0"), msg),
+  error: (msg) => console.log(chalk2.red("\u2717"), msg),
+  step: (msg) => console.log(chalk2.cyan("\u2192"), msg)
+};
+
+// src/cli/commands/distill.ts
+var distillCommand = new Command("distill").description("Distill a session into a Skill").argument("[session]", "Session ID to distill").option("-l, --last", "Use the most recent session").option("-s, --session <id>", "Specify session ID").option("-p, --prompt <text>", "Add user instruction", collect, []).option("-f, --format <type>", "Output format: claude, codex, cursor, all", "claude").option("-o, --output <dir>", "Output directory").option("--install", "Install to local agent").option("-i, --interactive", "Interactive mode").option("-v, --verbose", "Verbose output").action(async (sessionArg, options) => {
+  try {
+    await runDistill(sessionArg, options);
+  } catch (error) {
+    logger.error(`Distill failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+function collect(value, previous) {
+  return previous.concat([value]);
+}
+async function runDistill(sessionArg, options) {
+  const config = await loadConfig();
+  const spinner = ora();
+  let sessionId = sessionArg ?? options.session;
+  if (options.last) {
+    spinner.start("Loading latest session...");
+    const loader2 = createSessionLoader(config.defaultPlatform);
+    const session2 = await loader2.getLatestSession();
+    sessionId = session2.id;
+    spinner.succeed(`Found session: ${chalk3.cyan(sessionId)}`);
+  } else if (options.interactive && !sessionId) {
+    sessionId = await selectSessionInteractive(config.defaultPlatform);
+  }
+  if (!sessionId) {
+    logger.error("No session specified. Use --last or provide a session ID.");
+    process.exit(1);
+  }
+  spinner.start("Loading session...");
+  const loader = createSessionLoader(config.defaultPlatform);
+  const session = await loader.getSession(sessionId);
+  spinner.succeed(`Loaded session with ${chalk3.cyan(session.messages.length)} messages`);
+  let prompts = options.prompt ?? [];
+  if (options.interactive) {
+    const collected = await collectPromptsInteractively();
+    if (collected.confirmed) {
+      prompts = [...prompts, ...collected.prompts];
+    }
+  }
+  if (prompts.length > 0) {
+    console.log(chalk3.cyan("\n\u{1F4DD} User Instructions:"));
+    prompts.forEach((p) => console.log(chalk3.gray(`  \u2022 ${p}`)));
+    console.log();
+  }
+  spinner.start("Distilling session...");
+  const distiller = new Distiller();
+  const result = await distiller.distill(session, {
+    userPrompts: prompts,
+    verbose: options.verbose
+  });
+  spinner.succeed("Distillation complete");
+  console.log(chalk3.cyan("\n\u{1F4CB} Distilled Skill:"));
+  console.log(chalk3.gray(`  Name: ${chalk3.white(result.skill.metadata.name)}`));
+  console.log(chalk3.gray(`  Steps: ${chalk3.white(result.skill.steps.length)}`));
+  console.log(chalk3.gray(`  Parameters: ${chalk3.white(result.skill.parameters.length)}`));
+  console.log(
+    chalk3.gray(
+      `  Token usage: ${chalk3.white(result.metadata.tokenUsage.input + result.metadata.tokenUsage.output)}`
+    )
+  );
+  const outputDir = options.output ?? config.outputDir ?? "./skills";
+  spinner.start("Generating Skill files...");
+  const generator = new SkillGenerator();
+  const genResult = await generator.generate(result.skill, {
+    outputDir,
+    includeReferences: true
+  });
+  spinner.succeed("Skill generated");
+  if (genResult.validation.warnings.length > 0) {
+    console.log(chalk3.yellow("\n\u26A0\uFE0F  Warnings:"));
+    genResult.validation.warnings.forEach((w) => {
+      console.log(chalk3.yellow(`  \u2022 ${w.message}`));
+    });
+  }
+  if (options.install) {
+    spinner.start("Installing to local agent...");
+    const installer = createInstaller(config.defaultPlatform);
+    const installResult = await installer.install(result.skill, { overwrite: true });
+    if (installResult.success) {
+      spinner.succeed(`Installed to ${installer.getPlatformName()}`);
+    } else {
+      spinner.fail(installResult.message);
+    }
+  }
+  console.log(chalk3.green("\n\u2705 Success!"));
+  console.log(chalk3.gray(`  Skill saved to: ${chalk3.white(genResult.skillPath)}`));
+  console.log(chalk3.cyan("\n\u{1F4CC} Next steps:"));
+  console.log(chalk3.gray("  1. Review and edit the generated Skill"));
+  console.log(chalk3.gray("  2. Test the Skill in Claude Code"));
+  console.log(chalk3.gray("  3. Publish to Skill Registry (optional)"));
+}
+async function selectSessionInteractive(platform) {
+  const inquirer3 = await import("inquirer");
+  const loader = createSessionLoader(platform);
+  const sessions = await loader.listSessions();
+  if (sessions.length === 0) {
+    throw new Error("No sessions found");
+  }
+  const choices = sessions.slice(0, 20).map((s) => ({
+    name: `${s.id.slice(0, 8)}... | ${s.messageCount} msgs | ${s.summary?.slice(0, 50) ?? "No summary"}`,
+    value: s.id
+  }));
+  const { sessionId } = await inquirer3.default.prompt([
+    {
+      type: "list",
+      name: "sessionId",
+      message: "Select a session:",
+      choices
+    }
+  ]);
+  return sessionId;
+}
+
+// src/cli/commands/list.ts
+import { Command as Command2 } from "commander";
+import chalk4 from "chalk";
+var listCommand = new Command2("list").description("List available sessions").option("-n, --limit <number>", "Number of sessions to show", "20").option("--platform <type>", "Platform: claude, codex, cursor").action(async (options) => {
+  const config = await loadConfig();
+  const platform = options.platform ?? config.defaultPlatform ?? "claude";
+  const limit = parseInt(options.limit, 10);
+  console.log(chalk4.cyan(`
+\u{1F4DA} Sessions (${platform}):
+`));
+  const loader = createSessionLoader(platform);
+  const sessions = await loader.listSessions();
+  if (sessions.length === 0) {
+    console.log(chalk4.gray("  No sessions found."));
+    return;
+  }
+  const sorted = sessions.sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime()).slice(0, limit);
+  console.log(chalk4.gray("  ID              Messages  Date        Summary"));
+  console.log(chalk4.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500   \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  sorted.forEach((s) => {
+    const id = s.id.slice(0, 12).padEnd(14);
+    const msgs = String(s.messageCount).padEnd(8);
+    const date = new Date(s.startTime).toISOString().slice(0, 10);
+    const summary = (s.summary ?? "").slice(0, 30);
+    console.log(`  ${chalk4.white(id)}  ${chalk4.cyan(msgs)}  ${chalk4.gray(date)}  ${chalk4.gray(summary)}`);
+  });
+  console.log(chalk4.gray(`
+  Showing ${sorted.length} of ${sessions.length} sessions`));
+});
+
+// src/cli/commands/init.ts
+import { Command as Command3 } from "commander";
+import inquirer2 from "inquirer";
+import chalk5 from "chalk";
+import { promises as fs9 } from "fs";
+var initCommand = new Command3("init").description("Initialize configuration").action(async () => {
+  console.log(chalk5.cyan("\n\u{1F527} Skill Distill Configuration\n"));
+  const answers = await inquirer2.prompt([
+    {
+      type: "list",
+      name: "defaultPlatform",
+      message: "Default AI Agent platform:",
+      choices: [
+        { name: "Claude Code", value: "claude" },
+        { name: "Codex CLI", value: "codex" },
+        { name: "Cursor", value: "cursor" }
+      ],
+      default: "claude"
+    },
+    {
+      type: "password",
+      name: "apiKey",
+      message: "Claude API Key (optional, for LLM analysis):",
+      mask: "*"
+    },
+    {
+      type: "input",
+      name: "outputDir",
+      message: "Default output directory:",
+      default: "~/.skills"
+    },
+    {
+      type: "confirm",
+      name: "autoInstall",
+      message: "Auto-install generated Skills to local agent?",
+      default: true
+    }
+  ]);
+  await ensureDir(CONFIG_DIR);
+  await fs9.writeFile(CONFIG_FILE, JSON.stringify(answers, null, 2));
+  console.log(chalk5.green("\n\u2705 Configuration saved!"));
+  console.log(chalk5.gray(`  Location: ${CONFIG_FILE}`));
+});
+
+// src/utils/validation.ts
+import { z as z2 } from "zod";
+var SessionIdSchema = z2.string().min(1, "Session ID is required");
+var PlatformSchema = z2.enum(["claude", "codex", "cursor"]);
+var DistillOptionsSchema = z2.object({
+  sessionId: z2.string().optional(),
+  last: z2.boolean().optional(),
+  prompts: z2.array(z2.string()).optional(),
+  format: z2.enum(["claude", "codex", "cursor", "all"]).optional(),
+  outputDir: z2.string().optional(),
+  install: z2.boolean().optional(),
+  interactive: z2.boolean().optional()
+});
+
+// src/index.ts
+var VERSION = "0.1.0";
+
+// src/cli/index.ts
+var program = new Command4();
+program.name("skill-distill").description("Distill AI agent conversations into reusable Skills").version(VERSION);
+program.addCommand(distillCommand);
+program.addCommand(listCommand);
+program.addCommand(initCommand);
+program.action(() => {
+  program.help();
+});
+program.parse();
+//# sourceMappingURL=cli.js.map