skill-distill 1.0.0

package/dist/index.js

@@ -0,0 +1,2020 @@
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger = {
+  info: (msg) => console.log(chalk.blue("\u2139"), msg),
+  success: (msg) => console.log(chalk.green("\u2713"), msg),
+  warn: (msg) => console.log(chalk.yellow("\u26A0"), msg),
+  error: (msg) => console.log(chalk.red("\u2717"), msg),
+  step: (msg) => console.log(chalk.cyan("\u2192"), msg)
+};
+
+// src/utils/fs.ts
+import { promises as fs } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function expandHome(path) {
+  if (path.startsWith("~")) {
+    return join(homedir(), path.slice(1));
+  }
+  return path;
+}
+async function ensureDir(path) {
+  await fs.mkdir(path, { recursive: true });
+}
+async function fileExists(path) {
+  try {
+    await fs.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJson(path) {
+  const content = await fs.readFile(path, "utf-8");
+  return JSON.parse(content);
+}
+async function writeJson(path, data) {
+  await fs.writeFile(path, JSON.stringify(data, null, 2));
+}
+
+// src/utils/validation.ts
+import { z } from "zod";
+var SessionIdSchema = z.string().min(1, "Session ID is required");
+var PlatformSchema = z.enum(["claude", "codex", "cursor"]);
+var DistillOptionsSchema = z.object({
+  sessionId: z.string().optional(),
+  last: z.boolean().optional(),
+  prompts: z.array(z.string()).optional(),
+  format: z.enum(["claude", "codex", "cursor", "all"]).optional(),
+  outputDir: z.string().optional(),
+  install: z.boolean().optional(),
+  interactive: z.boolean().optional()
+});
+function validateSessionId(id) {
+  return SessionIdSchema.parse(id);
+}
+function validatePlatform(platform) {
+  return PlatformSchema.parse(platform);
+}
+
+// src/loaders/claude.ts
+import { promises as fs2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } 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 join2(homedir2(), ".claude", "projects");
+  }
+  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;
+        }
+      }
+    } 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 = join2(this.basePath, sessionInfo.projectPath, "sessions", `${id}.json`);
+    const data = await this.readSessionFile(sessionPath);
+    if (!data) {
+      throw new Error(`Failed to read session: ${id}`);
+    }
+    return this.transformSession(data, sessionInfo.projectPath);
+  }
+  async readSessionFile(path) {
+    try {
+      const content = await fs2.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 join3 } from "path";
+import { homedir as homedir3 } from "os";
+var CodexSessionLoader = class extends SessionLoader {
+  getDefaultBasePath() {
+    return join3(homedir3(), ".codex", "history");
+  }
+  async listSessions() {
+    return [];
+  }
+  async getSession(_id) {
+    throw new Error("Codex session loading not yet implemented");
+  }
+};
+
+// src/loaders/cursor.ts
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+var CursorSessionLoader = class extends SessionLoader {
+  getDefaultBasePath() {
+    return join4(homedir4(), ".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 as z2 } 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 = z2.object({
+  goal: z2.string().describe("The user core objective"),
+  problem: z2.string().describe("The problem to solve"),
+  outcome: z2.string().describe("The final result"),
+  triggers: z2.array(z2.string()).describe("Trigger phrases list"),
+  category: z2.string().describe("Task category")
+});
+var StepSchema = z2.object({
+  title: z2.string(),
+  description: z2.string(),
+  substeps: z2.array(z2.string()).optional(),
+  isKeyStep: z2.boolean(),
+  toolsUsed: z2.array(z2.string()).optional()
+});
+var StepsResultSchema = z2.object({
+  steps: z2.array(StepSchema),
+  parameters: z2.array(
+    z2.object({
+      name: z2.string(),
+      type: z2.enum(["string", "boolean", "number"]),
+      description: z2.string(),
+      defaultValue: z2.unknown().optional()
+    })
+  ),
+  prerequisites: z2.array(z2.string()),
+  errorHandling: z2.record(z2.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, z2.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/prompt-handler/classifier.ts
+var PromptClassifier = class {
+  constructor(language = "zh") {
+    this.language = language;
+    this.patterns = {
+      zh: [
+        // Order matters: more specific patterns (exclude with negation) must come before generic ones
+        { keywords: ["\u4E0D\u8981", "\u6392\u9664", "\u8DF3\u8FC7", "\u5FFD\u7565", "\u4E0D\u5305\u542B", "\u53BB\u6389"], type: "exclude" },
+        { keywords: ["\u91CD\u70B9", "\u5173\u6CE8", "\u5F3A\u8C03", "\u7740\u91CD", "\u7279\u522B\u6CE8\u610F"], type: "focus" },
+        { keywords: ["\u9700\u8981", "\u5FC5\u987B", "\u517C\u5BB9", "\u8981\u6C42", "\u786E\u4FDD", "\u652F\u6301"], type: "constraint" },
+        { keywords: ["\u6DFB\u52A0", "\u8865\u5145", "\u5305\u542B", "\u52A0\u5165", "\u589E\u52A0"], type: "supplement" },
+        { keywords: ["\u8BE6\u7EC6", "\u7B80\u6D01", "\u9002\u5408", "\u98CE\u683C", "\u5F62\u5F0F"], type: "style" }
+      ],
+      en: [
+        // Order matters: "don't include" must be checked before "include"
+        { keywords: ["don't include", "exclude", "skip", "ignore", "without", "do not include"], type: "exclude" },
+        { keywords: ["focus", "emphasize", "highlight", "prioritize"], type: "focus" },
+        { keywords: ["must", "require", "compatible", "ensure", "support"], type: "constraint" },
+        { keywords: ["add", "include", "supplement", "incorporate"], type: "supplement" },
+        { keywords: ["detailed", "concise", "style", "format", "suitable"], type: "style" }
+      ]
+    };
+  }
+  patterns;
+  classify(prompt) {
+    const lower = prompt.toLowerCase();
+    const patterns = this.patterns[this.language];
+    let matchedType = "supplement";
+    let matchedKeywords = [];
+    for (const pattern of patterns) {
+      const foundKeywords = pattern.keywords.filter((k) => lower.includes(k.toLowerCase()));
+      if (foundKeywords.length > 0) {
+        matchedType = pattern.type;
+        matchedKeywords = foundKeywords;
+        break;
+      }
+    }
+    const target = this.extractTarget(prompt, matchedKeywords);
+    return {
+      original: prompt,
+      type: matchedType,
+      keywords: matchedKeywords,
+      target
+    };
+  }
+  extractTarget(prompt, keywords) {
+    if (!keywords.length) return void 0;
+    for (const keyword of keywords) {
+      const index = prompt.toLowerCase().indexOf(keyword.toLowerCase());
+      if (index !== -1) {
+        const after = prompt.slice(index + keyword.length).trim();
+        const match = after.match(/^[^，。,.!！?？]+/);
+        if (match) {
+          return match[0].trim();
+        }
+      }
+    }
+    return void 0;
+  }
+};
+
+// src/prompt-handler/fuser.ts
+var PromptFuser = class {
+  fuse(prompts) {
+    const effect = {};
+    for (const prompt of prompts) {
+      switch (prompt.type) {
+        case "focus":
+          this.applyFocus(prompt, effect);
+          break;
+        case "constraint":
+          this.applyConstraint(prompt, effect);
+          break;
+        case "supplement":
+          this.applySupplement(prompt, effect);
+          break;
+        case "style":
+          this.applyStyle(prompt, effect);
+          break;
+        case "exclude":
+          this.applyExclude(prompt, effect);
+          break;
+      }
+    }
+    return effect;
+  }
+  applyFocus(prompt, effect) {
+    if (!effect.stepWeights) {
+      effect.stepWeights = /* @__PURE__ */ new Map();
+    }
+    if (prompt.target) {
+      effect.stepWeights.set(prompt.target.toLowerCase(), 2);
+    }
+  }
+  applyConstraint(prompt, effect) {
+    if (!effect.additionalPrerequisites) {
+      effect.additionalPrerequisites = [];
+    }
+    effect.additionalPrerequisites.push(prompt.original);
+  }
+  applySupplement(prompt, effect) {
+    if (!effect.stepEnrichments) {
+      effect.stepEnrichments = /* @__PURE__ */ new Map();
+    }
+    const existing = effect.stepEnrichments.get("additional") ?? [];
+    existing.push(prompt.original);
+    effect.stepEnrichments.set("additional", existing);
+  }
+  applyStyle(prompt, effect) {
+    const lower = prompt.original.toLowerCase();
+    if (lower.includes("\u8BE6\u7EC6") || lower.includes("detailed")) {
+      effect.verbosityLevel = "detailed";
+    } else if (lower.includes("\u7B80\u6D01") || lower.includes("concise")) {
+      effect.verbosityLevel = "minimal";
+    } else {
+      effect.verbosityLevel = "standard";
+    }
+  }
+  applyExclude(prompt, effect) {
+    if (!effect.excludePatterns) {
+      effect.excludePatterns = [];
+    }
+    if (prompt.target) {
+      effect.excludePatterns.push(prompt.target.toLowerCase());
+    }
+  }
+};
+
+// src/prompt-handler/prompt-handler.ts
+var PromptHandler = class {
+  classifier;
+  fuser;
+  constructor(options = {}) {
+    this.classifier = new PromptClassifier(options.language ?? "zh");
+    this.fuser = new PromptFuser();
+  }
+  process(prompts) {
+    const classified = prompts.map((p) => this.classifier.classify(p));
+    return this.fuser.fuse(classified);
+  }
+  classify(prompt) {
+    return this.classifier.classify(prompt);
+  }
+  toPromptText(prompts) {
+    if (!prompts.length) return "";
+    const classified = prompts.map((p) => this.classifier.classify(p));
+    const sections = {
+      focus: classified.filter((c) => c.type === "focus"),
+      constraint: classified.filter((c) => c.type === "constraint"),
+      supplement: classified.filter((c) => c.type === "supplement"),
+      style: classified.filter((c) => c.type === "style"),
+      exclude: classified.filter((c) => c.type === "exclude")
+    };
+    const parts = ["## User Instructions"];
+    if (sections.focus.length) {
+      parts.push("\n### Focus Areas");
+      sections.focus.forEach((p) => parts.push(`- ${p.original}`));
+    }
+    if (sections.constraint.length) {
+      parts.push("\n### Constraints");
+      sections.constraint.forEach((p) => parts.push(`- ${p.original}`));
+    }
+    if (sections.supplement.length) {
+      parts.push("\n### Additional Content");
+      sections.supplement.forEach((p) => parts.push(`- ${p.original}`));
+    }
+    if (sections.style.length) {
+      parts.push("\n### Output Style");
+      sections.style.forEach((p) => parts.push(`- ${p.original}`));
+    }
+    if (sections.exclude.length) {
+      parts.push("\n### Exclusions");
+      sections.exclude.forEach((p) => parts.push(`- ${p.original}`));
+    }
+    return parts.join("\n");
+  }
+};
+
+// src/prompt-handler/interactive.ts
+import inquirer from "inquirer";
+import chalk2 from "chalk";
+async function collectPromptsInteractively() {
+  const prompts = [];
+  console.log(chalk2.cyan("\n\u{1F4DD} \u6DFB\u52A0\u9644\u52A0\u6307\u4EE4 (\u53EF\u9009)"));
+  console.log(chalk2.gray("  \u8F93\u5165\u7A7A\u884C\u5B8C\u6210\u6536\u96C6\n"));
+  for (; ; ) {
+    const { prompt } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "prompt",
+        message: "\u6307\u4EE4:",
+        prefix: chalk2.yellow("\u2192")
+      }
+    ]);
+    if (!prompt.trim()) {
+      break;
+    }
+    prompts.push(prompt.trim());
+  }
+  if (prompts.length === 0) {
+    return { prompts: [], confirmed: true };
+  }
+  console.log(chalk2.cyan("\n\u{1F4CB} \u5DF2\u6536\u96C6\u7684\u6307\u4EE4:"));
+  prompts.forEach((p, i) => {
+    console.log(chalk2.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 };
+}
+async function selectPromptsFromSuggestions(suggestions) {
+  const { selected } = await inquirer.prompt([
+    {
+      type: "checkbox",
+      name: "selected",
+      message: "\u9009\u62E9\u8981\u5E94\u7528\u7684\u6307\u4EE4:",
+      choices: suggestions.map((s) => ({ name: s, value: s }))
+    }
+  ]);
+  return selected;
+}
+
+// src/generators/skill-generator.ts
+import { promises as fs4 } from "fs";
+import { join as join6 } 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 fs3 } from "fs";
+import { join as join5 } from "path";
+var DirectoryBuilder = class {
+  async create(basePath, options = {}) {
+    const { includeReferences = true, includeExamples = false, includeScripts = false } = options;
+    await fs3.mkdir(basePath, { recursive: true });
+    if (includeReferences) {
+      await fs3.mkdir(join5(basePath, "references"), { recursive: true });
+    }
+    if (includeExamples) {
+      await fs3.mkdir(join5(basePath, "examples"), { recursive: true });
+    }
+    if (includeScripts) {
+      await fs3.mkdir(join5(basePath, "scripts"), { recursive: true });
+    }
+  }
+  async listStructure(basePath) {
+    const files = [];
+    async function walk(dir, prefix = "") {
+      const entries = await fs3.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(join5(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/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 = join6(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 = join6(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 = join6(skillDir, "references");
+    await ensureDir(refDir);
+    const patternsPath = join6(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/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/formatters/validator.ts
+var FormatValidator = class {
+  validateClaude(content) {
+    const errors = [];
+    const warnings = [];
+    if (!content.startsWith("---")) {
+      errors.push("Missing YAML frontmatter");
+    }
+    if (!content.includes("name:")) {
+      errors.push("Missing name in frontmatter");
+    }
+    if (!content.includes("description:")) {
+      errors.push("Missing description in frontmatter");
+    }
+    if (!content.includes("## Overview")) {
+      errors.push("Missing Overview section");
+    }
+    if (!content.includes("## Core Workflow") && !content.includes("## Steps")) {
+      errors.push("Missing Core Workflow section");
+    }
+    if (/\bYou should\b/i.test(content)) {
+      warnings.push('Avoid "You should" - use imperative form');
+    }
+    return {
+      valid: errors.length === 0,
+      format: "claude",
+      errors,
+      warnings
+    };
+  }
+  validateCodex(content) {
+    const errors = [];
+    const warnings = [];
+    if (!content.startsWith("---")) {
+      errors.push("Missing YAML frontmatter");
+    }
+    if (!content.includes("model:")) {
+      warnings.push("Missing model specification");
+    }
+    return {
+      valid: errors.length === 0,
+      format: "codex",
+      errors,
+      warnings
+    };
+  }
+  validateCursor(content) {
+    const errors = [];
+    const warnings = [];
+    if (content.trim().length < 100) {
+      warnings.push("Content seems too short");
+    }
+    return {
+      valid: errors.length === 0,
+      format: "cursor",
+      errors,
+      warnings
+    };
+  }
+};
+
+// src/installers/claude.ts
+import { promises as fs5 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir5 } 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 join7(homedir5(), ".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 = join7(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 = join7(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 = join7(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: join7(this.basePath, entry.name),
+            version: metadata.version ?? "0.0.0",
+            installedAt: stat.mtime.toISOString()
+          });
+        }
+      }
+    } catch {
+    }
+    return skills;
+  }
+  async verifyInstallation(skillPath) {
+    const skillMd = join7(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 join8 } from "path";
+import { homedir as homedir6 } from "os";
+var CodexInstaller = class extends AgentInstaller {
+  converter;
+  constructor(basePath) {
+    super(basePath);
+    this.converter = new FormatConverter();
+  }
+  getDefaultBasePath() {
+    return join8(homedir6(), ".codex", "agents");
+  }
+  getPlatformName() {
+    return "Codex CLI";
+  }
+  async install(skill, options = {}) {
+    const { overwrite = false } = options;
+    const agentName = this.toKebabCase(skill.metadata.name);
+    const agentPath = join8(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 = join8(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 = join8(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 join9 } 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 = join9(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 = join9(this.basePath, ".cursorrules");
+    if (!await fileExists(rulesPath)) {
+      throw new Error(".cursorrules not found");
+    }
+    await fs7.unlink(rulesPath);
+  }
+  async list() {
+    const rulesPath = join9(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/index.ts
+var VERSION = "0.1.0";
+export {
+  AgentInstaller,
+  ClaudeCodeInstaller,
+  ClaudeFormatter,
+  ClaudeSessionLoader,
+  CodexFormatter,
+  CodexInstaller,
+  CodexSessionLoader,
+  ConversationPreprocessor,
+  CursorFormatter,
+  CursorInstaller,
+  CursorSessionLoader,
+  DirectoryBuilder,
+  DistillOptionsSchema,
+  Distiller,
+  FailedAttemptFilter,
+  FormatConverter,
+  FormatValidator,
+  FrontmatterBuilder,
+  LLMEngine,
+  MarkdownRenderer,
+  ParameterExtractor,
+  PlatformSchema,
+  PromptClassifier,
+  PromptFuser,
+  PromptHandler,
+  SessionIdSchema,
+  SessionLoader,
+  SkillGenerator,
+  TemplateValidator,
+  VERSION,
+  collectPromptsInteractively,
+  createInstaller,
+  createSessionLoader,
+  ensureDir,
+  expandHome,
+  fileExists,
+  logger,
+  readJson,
+  selectPromptsFromSuggestions,
+  validatePlatform,
+  validateSessionId,
+  writeJson
+};
+//# sourceMappingURL=index.js.map