skillmesh-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,2090 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import * as path from 'path';
+import * as os2 from 'os';
+import fs from 'fs-extra';
+import * as yaml from 'js-yaml';
+
+var { existsSync } = fs;
+var AGENT_PATHS = {
+  "claude-code": {
+    projectPath: ".claude/skills",
+    globalPath: "~/.claude/skills"
+  },
+  "antigravity": {
+    projectPath: ".agent/skills",
+    globalPath: "~/.gemini/antigravity/global_skills"
+  },
+  "cursor": {
+    projectPath: ".cursor/skills",
+    globalPath: "~/.cursor/skills"
+  },
+  "windsurf": {
+    projectPath: ".windsurf/skills",
+    globalPath: "~/.codeium/windsurf/skills"
+  },
+  "gemini-cli": {
+    projectPath: ".gemini/skills",
+    globalPath: "~/.gemini/skills"
+  },
+  "codex-cli": {
+    projectPath: ".codex/skills",
+    globalPath: "~/.codex/skills"
+  },
+  "kilocode": {
+    projectPath: ".kilocode/skills",
+    globalPath: "~/.kilocode/skills"
+  },
+  "trae": {
+    projectPath: ".trae/skills",
+    globalPath: "~/.trae/skills"
+  },
+  "void": {
+    projectPath: ".void/skills",
+    globalPath: "~/.void/skills"
+  },
+  "continue": {
+    projectPath: ".continue/skills",
+    globalPath: "~/.continue/skills"
+  },
+  "cline": {
+    projectPath: ".cline/skills",
+    globalPath: "~/.cline/skills"
+  }
+};
+function getSkillPath(agentId, projectPath, skillName, global = false) {
+  const agentConfig = AGENT_PATHS[agentId];
+  if (!agentConfig) {
+    const fallbackPath = global ? `~/.${agentId}/skills` : `.${agentId}/skills`;
+    const basePath2 = global ? expandTilde(fallbackPath) : path.join(projectPath, fallbackPath);
+    return path.join(basePath2, skillName, "SKILL.md");
+  }
+  const basePath = global ? expandTilde(agentConfig.globalPath) : path.join(projectPath, agentConfig.projectPath);
+  return path.join(basePath, skillName, "SKILL.md");
+}
+async function detectInstalledAgents(projectPath) {
+  const detected = [];
+  for (const [agentId, config] of Object.entries(AGENT_PATHS)) {
+    const baseDir = config.projectPath.split("/")[0];
+    const agentDirPath = path.join(projectPath, baseDir);
+    if (existsSync(agentDirPath)) {
+      detected.push(agentId);
+    }
+  }
+  return detected;
+}
+function expandTilde(filepath) {
+  if (filepath.startsWith("~/") || filepath === "~") {
+    return path.join(os2.homedir(), filepath.slice(1));
+  }
+  return filepath;
+}
+var { existsSync: existsSync2 } = fs;
+var DetectAgentsInputSchema = z.object({
+  projectPath: z.string().describe("Absolute path to project root directory"),
+  includeGlobal: z.boolean().optional().default(false).describe("Also scan home directory for globally installed agents")
+});
+async function detectAgents(input) {
+  try {
+    const { projectPath, includeGlobal } = input;
+    const projectAgents = await detectInstalledAgents(projectPath);
+    const agentMap = /* @__PURE__ */ new Map();
+    for (const agentId of projectAgents) {
+      const config = AGENT_PATHS[agentId];
+      if (!config) continue;
+      const projectSkillPath = path.join(projectPath, config.projectPath);
+      const globalSkillPath = config.globalPath.replace(/^~/, os2.homedir());
+      agentMap.set(agentId, {
+        id: agentId,
+        name: agentId,
+        projectSkillPath,
+        globalSkillPath,
+        foundInProject: true,
+        foundGlobally: false
+      });
+    }
+    if (includeGlobal) {
+      const homeDir = os2.homedir();
+      for (const [agentId, config] of Object.entries(AGENT_PATHS)) {
+        const globalSkillPath = config.globalPath.replace(/^~/, homeDir);
+        const globalConfigDir = path.dirname(globalSkillPath);
+        const foundGlobally = existsSync2(globalConfigDir);
+        if (agentMap.has(agentId)) {
+          agentMap.get(agentId).foundGlobally = foundGlobally;
+        } else if (foundGlobally) {
+          const projectSkillPath = path.join(projectPath, config.projectPath);
+          agentMap.set(agentId, {
+            id: agentId,
+            name: agentId,
+            projectSkillPath,
+            globalSkillPath,
+            foundInProject: false,
+            foundGlobally: true
+          });
+        }
+      }
+    }
+    const agents = Array.from(agentMap.values());
+    return {
+      success: true,
+      agents,
+      projectRoot: projectPath
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      agents: [],
+      projectRoot: input.projectPath,
+      error: message
+    };
+  }
+}
+var { ensureDirSync, readJsonSync, writeJsonSync, existsSync: existsSync3 } = fs;
+var DEFAULT_CONFIG = {
+  version: "1.0.0",
+  installedSkills: []
+};
+function getConfigPath(projectRoot) {
+  return path.join(projectRoot, ".skillmesh", "skillmesh.config.json");
+}
+async function readConfig(projectRoot) {
+  const configPath = getConfigPath(projectRoot);
+  try {
+    if (!existsSync3(configPath)) {
+      return { ...DEFAULT_CONFIG };
+    }
+    const config = readJsonSync(configPath);
+    return {
+      version: config.version || DEFAULT_CONFIG.version,
+      installedSkills: config.installedSkills || []
+    };
+  } catch (error) {
+    console.error("Failed to read config, returning default:", error);
+    return { ...DEFAULT_CONFIG };
+  }
+}
+async function writeConfig(projectRoot, config) {
+  const configPath = getConfigPath(projectRoot);
+  try {
+    ensureDirSync(path.dirname(configPath));
+    writeJsonSync(configPath, config, { spaces: 2 });
+  } catch (error) {
+    console.error("Failed to write config:", error);
+    throw error;
+  }
+}
+async function trackInstalledSkill(projectRoot, skillName, agents, source) {
+  try {
+    const config = await readConfig(projectRoot);
+    const existingIndex = config.installedSkills.findIndex(
+      (skill) => skill.name === skillName
+    );
+    if (existingIndex !== -1) {
+      const existing = config.installedSkills[existingIndex];
+      const mergedAgents = Array.from(/* @__PURE__ */ new Set([...existing.agents, ...agents]));
+      config.installedSkills[existingIndex] = {
+        name: skillName,
+        source: source || existing.source,
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        agents: mergedAgents
+      };
+    } else {
+      config.installedSkills.push({
+        name: skillName,
+        source,
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        agents
+      });
+    }
+    await writeConfig(projectRoot, config);
+  } catch (error) {
+    console.error("Failed to track installed skill:", error);
+  }
+}
+async function untrackSkill(projectRoot, skillName, agentName) {
+  try {
+    const config = await readConfig(projectRoot);
+    const skillIndex = config.installedSkills.findIndex(
+      (skill2) => skill2.name === skillName
+    );
+    if (skillIndex === -1) {
+      return;
+    }
+    const skill = config.installedSkills[skillIndex];
+    skill.agents = skill.agents.filter((agent) => agent !== agentName);
+    if (skill.agents.length === 0) {
+      config.installedSkills.splice(skillIndex, 1);
+    } else {
+      config.installedSkills[skillIndex] = skill;
+    }
+    await writeConfig(projectRoot, config);
+  } catch (error) {
+    console.error("Failed to untrack skill:", error);
+  }
+}
+var { ensureDirSync: ensureDirSync2, existsSync: existsSync4 } = fs;
+var CreateFolderInputSchema = z.object({
+  projectPath: z.string().describe("Absolute path to project root directory"),
+  agents: z.array(z.string()).describe("List of agent names to create folders for"),
+  global: z.boolean().optional().default(false).describe("Create in global scope instead of project scope")
+});
+async function createFolder(input) {
+  try {
+    const { projectPath, agents, global } = input;
+    const results = [];
+    for (const agentId of agents) {
+      const config = AGENT_PATHS[agentId];
+      if (!config) {
+        results.push({
+          agent: agentId,
+          path: "",
+          created: false,
+          alreadyExists: false
+        });
+        continue;
+      }
+      let skillDirPath;
+      if (global) {
+        skillDirPath = config.globalPath.replace(/^~/, os2.homedir());
+      } else {
+        skillDirPath = path.join(projectPath, config.projectPath);
+      }
+      const alreadyExists = existsSync4(skillDirPath);
+      try {
+        ensureDirSync2(skillDirPath);
+        results.push({
+          agent: agentId,
+          path: skillDirPath,
+          created: !alreadyExists,
+          alreadyExists
+        });
+      } catch (err) {
+        results.push({
+          agent: agentId,
+          path: skillDirPath,
+          created: false,
+          alreadyExists: false
+        });
+      }
+    }
+    let configCreated = false;
+    let configPath;
+    if (!global) {
+      try {
+        const skillmeshDir = path.join(projectPath, ".skillmesh");
+        const configFilePath = path.join(skillmeshDir, "skillmesh.config.json");
+        const configExists = existsSync4(configFilePath);
+        ensureDirSync2(skillmeshDir);
+        if (!configExists) {
+          await writeConfig(projectPath, {
+            version: "1.0.0",
+            installedSkills: []
+          });
+          configCreated = true;
+        }
+        configPath = configFilePath;
+      } catch (err) {
+        configCreated = false;
+      }
+    }
+    return {
+      success: true,
+      results,
+      configCreated,
+      configPath
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      results: [],
+      configCreated: false,
+      error: message
+    };
+  }
+}
+
+// src/lib/tavily.ts
+async function searchTavily(query, maxResults = 10) {
+  const tavilyKey = process.env.TAVILY_API_KEY;
+  if (!tavilyKey) {
+    console.error("TAVILY_API_KEY not found in environment, trying Firecrawl fallback");
+    return searchFirecrawl(query, maxResults);
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 15e3);
+    const response = await fetch("https://api.tavily.com/search", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        api_key: tavilyKey,
+        query,
+        max_results: maxResults,
+        search_depth: "basic",
+        include_answer: false,
+        include_images: false
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      console.error("Tavily API error:", response.status, response.statusText);
+      return [];
+    }
+    const data = await response.json();
+    if (!data.results || !Array.isArray(data.results)) {
+      return [];
+    }
+    return data.results.map((result) => ({
+      title: result.title || "",
+      url: result.url || "",
+      snippet: result.content || "",
+      score: result.score
+    }));
+  } catch (error) {
+    console.error("Tavily search failed:", error);
+    return [];
+  }
+}
+async function searchFirecrawl(query, maxResults = 10) {
+  const firecrawlKey = process.env.FIRECRAWL_API_KEY;
+  if (!firecrawlKey) {
+    console.error("Neither TAVILY_API_KEY nor FIRECRAWL_API_KEY found in environment");
+    return [];
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 15e3);
+    const response = await fetch("https://api.firecrawl.dev/v1/search", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${firecrawlKey}`
+      },
+      body: JSON.stringify({
+        query,
+        limit: maxResults
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      console.error("Firecrawl API error:", response.status, response.statusText);
+      return [];
+    }
+    const data = await response.json();
+    if (!data.data || !Array.isArray(data.data)) {
+      return [];
+    }
+    return data.data.map((result) => ({
+      title: result.title || "",
+      url: result.url || "",
+      snippet: result.description || result.content || "",
+      score: result.score
+    }));
+  } catch (error) {
+    console.error("Firecrawl search failed:", error);
+    return [];
+  }
+}
+
+// src/lib/github.ts
+async function fetchSkillFromGitHub(owner, repo, skillName, githubToken) {
+  const baseUrl = `https://raw.githubusercontent.com/${owner}/${repo}/main`;
+  const paths = [
+    `${baseUrl}/.claude/skills/${skillName}/SKILL.md`,
+    `${baseUrl}/SKILL.md`,
+    `${baseUrl}/skills/${skillName}/SKILL.md`
+  ];
+  for (const url of paths) {
+    const result = await fetchWithTimeout(url, githubToken);
+    if (result.found) {
+      return result;
+    }
+  }
+  const searchResult = await searchGitHubForSkill(owner, repo, skillName, githubToken);
+  if (searchResult.found) {
+    return searchResult;
+  }
+  return {
+    content: "",
+    url: "",
+    found: false
+  };
+}
+async function getGitHubStars(owner, repo, githubToken) {
+  const url = `https://api.github.com/repos/${owner}/${repo}`;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 15e3);
+    const headers = {
+      "Accept": "application/vnd.github.v3+json",
+      "User-Agent": "skillmesh-mcp"
+    };
+    if (githubToken) {
+      headers["Authorization"] = `Bearer ${githubToken}`;
+    }
+    const response = await fetch(url, {
+      headers,
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      return 0;
+    }
+    const data = await response.json();
+    return data.stargazers_count || 0;
+  } catch (error) {
+    console.error(`Failed to fetch star count for ${owner}/${repo}:`, error);
+    return 0;
+  }
+}
+async function getLastUpdated(owner, repo, githubToken) {
+  const url = `https://api.github.com/repos/${owner}/${repo}`;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 15e3);
+    const headers = {
+      "Accept": "application/vnd.github.v3+json",
+      "User-Agent": "skillmesh-mcp"
+    };
+    if (githubToken) {
+      headers["Authorization"] = `Bearer ${githubToken}`;
+    }
+    const response = await fetch(url, {
+      headers,
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    const updatedAt = data.updated_at || data.pushed_at;
+    return updatedAt ? new Date(updatedAt) : null;
+  } catch (error) {
+    console.error(`Failed to fetch last updated for ${owner}/${repo}:`, error);
+    return null;
+  }
+}
+async function fetchWithTimeout(url, githubToken) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 15e3);
+    const headers = {
+      "User-Agent": "skillmesh-mcp"
+    };
+    if (githubToken && url.includes("api.github.com")) {
+      headers["Authorization"] = `Bearer ${githubToken}`;
+    }
+    const response = await fetch(url, {
+      headers,
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      return {
+        content: "",
+        url: "",
+        found: false
+      };
+    }
+    const content = await response.text();
+    return {
+      content,
+      url,
+      found: true
+    };
+  } catch (error) {
+    return {
+      content: "",
+      url: "",
+      found: false
+    };
+  }
+}
+async function searchGitHubForSkill(owner, repo, skillName, githubToken) {
+  if (!githubToken) {
+    return {
+      content: "",
+      url: "",
+      found: false
+    };
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 15e3);
+    const query = encodeURIComponent(
+      `filename:SKILL.md repo:${owner}/${repo}`
+    );
+    const searchUrl = `https://api.github.com/search/code?q=${query}`;
+    const response = await fetch(searchUrl, {
+      headers: {
+        "Accept": "application/vnd.github.v3+json",
+        "Authorization": `Bearer ${githubToken}`,
+        "User-Agent": "skillmesh-mcp"
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      return {
+        content: "",
+        url: "",
+        found: false
+      };
+    }
+    const data = await response.json();
+    if (!data.items || data.items.length === 0) {
+      return {
+        content: "",
+        url: "",
+        found: false
+      };
+    }
+    let bestMatch = data.items[0];
+    for (const item of data.items) {
+      if (item.path.includes(skillName)) {
+        bestMatch = item;
+        break;
+      }
+    }
+    const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/main/${bestMatch.path}`;
+    return await fetchWithTimeout(rawUrl, githubToken);
+  } catch (error) {
+    console.error("GitHub search failed:", error);
+    return {
+      content: "",
+      url: "",
+      found: false
+    };
+  }
+}
+
+// src/tools/search-skills.ts
+var SearchSkillsInputSchema = z.object({
+  keyword: z.string().describe('Search keyword or skill domain (e.g., "nextjs-app-router", "prisma")'),
+  minStars: z.number().optional().default(50).describe("Minimum GitHub stars filter"),
+  maxAgeMonths: z.number().optional().default(12).describe("Maximum age in months (updated within)"),
+  limit: z.number().optional().default(10).describe("Maximum number of results")
+});
+async function searchSkills(input) {
+  try {
+    const { keyword, minStars, maxAgeMonths, limit } = input;
+    const searchQuery = `site:skills.sh ${keyword}`;
+    const searchResults = await searchTavily(searchQuery, limit * 3);
+    const qualityResults = [];
+    const githubToken = process.env.GITHUB_TOKEN;
+    for (const result of searchResults) {
+      const githubMatch = result.url.match(/github\.com\/([^\/]+)\/([^\/\?#]+)/);
+      if (!githubMatch) {
+        const pathMatch = result.url.match(/skills\.sh\/([^\/]+)\/([^\/\?#]+)/);
+        if (pathMatch) {
+          const [, owner2, repo2] = pathMatch;
+          try {
+            const stars = await getGitHubStars(owner2, repo2, githubToken);
+            const lastUpdated = await getLastUpdated(owner2, repo2, githubToken);
+            if (stars < minStars) continue;
+            if (lastUpdated) {
+              const ageMonths = (Date.now() - lastUpdated.getTime()) / (1e3 * 60 * 60 * 24 * 30);
+              if (ageMonths > maxAgeMonths) continue;
+            }
+            const recencyBonus = lastUpdated ? Math.max(0, 100 - (Date.now() - lastUpdated.getTime()) / (1e3 * 60 * 60 * 24 * 30)) : 0;
+            const score = stars + recencyBonus + (result.score || 0) * 10;
+            qualityResults.push({
+              name: repo2,
+              repo: repo2,
+              owner: owner2,
+              description: result.snippet,
+              stars,
+              lastUpdated: lastUpdated ? lastUpdated.toISOString() : "unknown",
+              url: result.url,
+              score
+            });
+          } catch (err) {
+            continue;
+          }
+        }
+        continue;
+      }
+      const [, owner, repo] = githubMatch;
+      try {
+        const stars = await getGitHubStars(owner, repo, githubToken);
+        const lastUpdated = await getLastUpdated(owner, repo, githubToken);
+        if (stars < minStars) continue;
+        if (lastUpdated) {
+          const ageMonths = (Date.now() - lastUpdated.getTime()) / (1e3 * 60 * 60 * 24 * 30);
+          if (ageMonths > maxAgeMonths) continue;
+        }
+        const recencyBonus = lastUpdated ? Math.max(0, 100 - (Date.now() - lastUpdated.getTime()) / (1e3 * 60 * 60 * 24 * 30)) : 0;
+        const score = stars + recencyBonus + (result.score || 0) * 10;
+        qualityResults.push({
+          name: repo,
+          repo,
+          owner,
+          description: result.snippet,
+          stars,
+          lastUpdated: lastUpdated ? lastUpdated.toISOString() : "unknown",
+          url: result.url,
+          score
+        });
+      } catch (err) {
+        continue;
+      }
+    }
+    qualityResults.sort((a, b) => b.score - a.score);
+    const limitedResults = qualityResults.slice(0, limit);
+    return {
+      success: true,
+      results: limitedResults,
+      query: keyword,
+      totalFound: qualityResults.length
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      results: [],
+      query: input.keyword,
+      totalFound: 0,
+      error: message
+    };
+  }
+}
+var SkillMetadataSchema = z.object({
+  name: z.string().min(1, "Skill name is required"),
+  description: z.string().min(1, "Description is required"),
+  tags: z.array(z.string()).optional().default([]),
+  sources: z.array(z.string().url()).optional().default([]),
+  created_by: z.string().optional(),
+  created_at: z.string().optional()
+});
+function parseSkillMd(content) {
+  try {
+    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) {
+      return null;
+    }
+    const [, frontmatterStr, bodyContent] = match;
+    const parsedYaml = yaml.load(frontmatterStr);
+    if (!parsedYaml || typeof parsedYaml !== "object") {
+      return null;
+    }
+    const validationResult = SkillMetadataSchema.safeParse(parsedYaml);
+    if (!validationResult.success) {
+      console.error("Skill metadata validation failed:", validationResult.error.flatten());
+      return null;
+    }
+    return {
+      metadata: validationResult.data,
+      content: bodyContent.trim(),
+      raw: content
+    };
+  } catch (error) {
+    console.error("Failed to parse SKILL.md:", error);
+    return null;
+  }
+}
+function validateSkillMd(content) {
+  const errors = [];
+  const parsed = parseSkillMd(content);
+  if (!parsed) {
+    errors.push("Invalid or missing YAML frontmatter");
+    return { valid: false, errors };
+  }
+  const requiredSections = [
+    { name: "Overview", pattern: /##\s+Overview/i },
+    { name: "Core Rules", pattern: /##\s+Core\s+Rules/i },
+    { name: "Patterns", pattern: /##\s+Patterns/i },
+    { name: "Anti-Patterns", pattern: /##\s+Anti-?Patterns/i }
+  ];
+  for (const section of requiredSections) {
+    if (!section.pattern.test(parsed.content)) {
+      errors.push(`Missing required section: ${section.name}`);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function checkSkillQuality(parsed) {
+  const feedback = [];
+  let score = 100;
+  const rulesMatch = parsed.content.match(/##\s+Core\s+Rules([\s\S]*?)(?=##|$)/i);
+  if (rulesMatch) {
+    const rulesSection = rulesMatch[1];
+    const ruleCount = (rulesSection.match(/^\d+\./gm) || []).length;
+    if (ruleCount < 6) {
+      feedback.push(`Core Rules should have 6-10 rules (found ${ruleCount})`);
+      score -= 15;
+    }
+  } else {
+    feedback.push("Core Rules section is missing or improperly formatted");
+    score -= 20;
+  }
+  const patternsMatch = parsed.content.match(/##\s+Patterns(?:\s+and\s+Examples)?([\s\S]*?)(?=##|$)/i);
+  if (patternsMatch) {
+    const patternsSection = patternsMatch[1];
+    const patternCount = (patternsSection.match(/###\s+Pattern\s+\d+/gi) || []).length;
+    if (patternCount < 3) {
+      feedback.push(`Patterns section should have 3-5 patterns (found ${patternCount})`);
+      score -= 15;
+    }
+    const codeBlockCount = (patternsSection.match(/```/g) || []).length / 2;
+    if (codeBlockCount < patternCount) {
+      feedback.push("Each pattern should include a complete runnable code example");
+      score -= 10;
+    }
+  } else {
+    feedback.push("Patterns section is missing or improperly formatted");
+    score -= 20;
+  }
+  const antiPatternsMatch = parsed.content.match(/##\s+Anti-?Patterns([\s\S]*?)(?=##|$)/i);
+  if (antiPatternsMatch) {
+    const antiPatternsSection = antiPatternsMatch[1];
+    const antiPatternCount = (antiPatternsSection.match(/^-\s+/gm) || []).length;
+    if (antiPatternCount < 4) {
+      feedback.push(`Anti-Patterns section should have 4-6 items (found ${antiPatternCount})`);
+      score -= 10;
+    }
+  } else {
+    feedback.push("Anti-Patterns section is missing");
+    score -= 15;
+  }
+  if (!/##\s+File\s+and\s+Folder\s+Conventions/i.test(parsed.content)) {
+    feedback.push("Consider adding File and Folder Conventions section");
+    score -= 5;
+  }
+  if (!/##\s+Useful\s+References/i.test(parsed.content)) {
+    feedback.push("Consider adding Useful References section");
+    score -= 5;
+  }
+  score = Math.max(0, score);
+  if (score === 100) {
+    feedback.push("Excellent! This skill meets gold-standard quality criteria.");
+  } else if (score >= 80) {
+    feedback.push("Good quality skill with minor improvements suggested.");
+  } else if (score >= 60) {
+    feedback.push("Acceptable skill but significant improvements recommended.");
+  } else {
+    feedback.push("This skill needs substantial improvements to meet quality standards.");
+  }
+  return { score, feedback };
+}
+
+// src/tools/fetch-skill.ts
+var FetchSkillInputSchema = z.object({
+  owner: z.string().describe("GitHub repository owner"),
+  repo: z.string().describe("GitHub repository name"),
+  skillName: z.string().describe("Skill name to fetch"),
+  githubToken: z.string().optional().describe("Optional GitHub token for higher rate limits")
+});
+async function fetchSkillContent(input) {
+  try {
+    const { owner, repo, skillName, githubToken } = input;
+    const token = githubToken || process.env.GITHUB_TOKEN;
+    const fetchResult = await fetchSkillFromGitHub(owner, repo, skillName, token);
+    if (!fetchResult.found || !fetchResult.content) {
+      return {
+        success: false,
+        content: "",
+        sourceUrl: fetchResult.url,
+        found: false,
+        error: "SKILL.md not found in repository"
+      };
+    }
+    try {
+      const parsed = parseSkillMd(fetchResult.content);
+      const validation = validateSkillMd(fetchResult.content);
+      if (!parsed) {
+        return {
+          success: true,
+          content: fetchResult.content,
+          sourceUrl: fetchResult.url,
+          found: true,
+          quality: {
+            valid: false,
+            issues: ["Failed to parse SKILL.md frontmatter"]
+          }
+        };
+      }
+      return {
+        success: true,
+        content: fetchResult.content,
+        sourceUrl: fetchResult.url,
+        found: true,
+        metadata: {
+          name: parsed.metadata.name,
+          description: parsed.metadata.description,
+          tags: parsed.metadata.tags,
+          sources: parsed.metadata.sources
+        },
+        quality: {
+          valid: validation.valid,
+          issues: validation.errors
+        }
+      };
+    } catch (parseErr) {
+      const parseMessage = parseErr instanceof Error ? parseErr.message : String(parseErr);
+      return {
+        success: true,
+        content: fetchResult.content,
+        sourceUrl: fetchResult.url,
+        found: true,
+        quality: {
+          valid: false,
+          issues: [`Failed to parse SKILL.md: ${parseMessage}`]
+        }
+      };
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      content: "",
+      sourceUrl: "",
+      found: false,
+      error: message
+    };
+  }
+}
+
+// src/lib/skill-sanitizer.ts
+function sanitizeSkillName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+
+// src/lib/llm.ts
+var PROVIDER_MODELS = {
+  anthropic: "claude-sonnet-4-5-20250929",
+  google: "gemini-3.0-pro",
+  openai: "gpt-4o"
+};
+function detectLLMProvider() {
+  if (process.env.ANTHROPIC_API_KEY) {
+    return {
+      provider: "anthropic",
+      model: PROVIDER_MODELS.anthropic,
+      apiKey: process.env.ANTHROPIC_API_KEY
+    };
+  }
+  if (process.env.GOOGLE_API_KEY) {
+    return {
+      provider: "google",
+      model: PROVIDER_MODELS.google,
+      apiKey: process.env.GOOGLE_API_KEY
+    };
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return {
+      provider: "openai",
+      model: PROVIDER_MODELS.openai,
+      apiKey: process.env.OPENAI_API_KEY
+    };
+  }
+  return null;
+}
+async function generateWithLLM(systemPrompt, userPrompt, config) {
+  const llmConfig = config || detectLLMProvider();
+  if (!llmConfig) {
+    return 'ERROR: No LLM API key found. Please add one of the following environment variables to your MCP config:\n  - ANTHROPIC_API_KEY (recommended)\n  - GOOGLE_API_KEY\n  - OPENAI_API_KEY\n\nAdd the key to your MCP server configuration under the "env" section.';
+  }
+  try {
+    switch (llmConfig.provider) {
+      case "anthropic":
+        return await callAnthropic(systemPrompt, userPrompt, llmConfig.apiKey);
+      case "google":
+        return await callGoogle(systemPrompt, userPrompt, llmConfig.apiKey);
+      case "openai":
+        return await callOpenAI(systemPrompt, userPrompt, llmConfig.apiKey);
+      default:
+        return `ERROR: Unknown LLM provider: ${llmConfig.provider}`;
+    }
+  } catch (error) {
+    console.error("LLM generation failed:", error);
+    return `ERROR: LLM generation failed: ${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+async function callAnthropic(systemPrompt, userPrompt, apiKey) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 6e4);
+  try {
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model: PROVIDER_MODELS.anthropic,
+        max_tokens: 4096,
+        system: systemPrompt,
+        messages: [
+          {
+            role: "user",
+            content: userPrompt
+          }
+        ]
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Anthropic API error ${response.status}: ${errorText}`);
+    }
+    const data = await response.json();
+    if (!data.content || !data.content[0] || !data.content[0].text) {
+      throw new Error("Invalid response format from Anthropic API");
+    }
+    return data.content[0].text;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    throw error;
+  }
+}
+async function callGoogle(systemPrompt, userPrompt, apiKey) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 6e4);
+  try {
+    const combinedPrompt = `${systemPrompt}
+
+${userPrompt}`;
+    const response = await fetch(
+      `https://generativelanguage.googleapis.com/v1beta/models/${PROVIDER_MODELS.google}:generateContent?key=${apiKey}`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          contents: [
+            {
+              parts: [
+                {
+                  text: combinedPrompt
+                }
+              ]
+            }
+          ],
+          generationConfig: {
+            maxOutputTokens: 4096,
+            temperature: 0.7
+          }
+        }),
+        signal: controller.signal
+      }
+    );
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Google API error ${response.status}: ${errorText}`);
+    }
+    const data = await response.json();
+    if (!data.candidates || !data.candidates[0] || !data.candidates[0].content || !data.candidates[0].content.parts || !data.candidates[0].content.parts[0]) {
+      throw new Error("Invalid response format from Google API");
+    }
+    return data.candidates[0].content.parts[0].text;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    throw error;
+  }
+}
+async function callOpenAI(systemPrompt, userPrompt, apiKey) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 6e4);
+  try {
+    const response = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model: PROVIDER_MODELS.openai,
+        max_tokens: 4096,
+        messages: [
+          {
+            role: "system",
+            content: systemPrompt
+          },
+          {
+            role: "user",
+            content: userPrompt
+          }
+        ]
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`OpenAI API error ${response.status}: ${errorText}`);
+    }
+    const data = await response.json();
+    if (!data.choices || !data.choices[0] || !data.choices[0].message || !data.choices[0].message.content) {
+      throw new Error("Invalid response format from OpenAI API");
+    }
+    return data.choices[0].message.content;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    throw error;
+  }
+}
+
+// src/tools/generate-skill.ts
+var GenerateSkillInputSchema = z.object({
+  skillName: z.string().describe("Skill name/domain to generate"),
+  projectContext: z.string().describe("Rich project context: frameworks, versions, patterns, structure"),
+  researchQuery: z.string().optional().describe("Optional custom web research query"),
+  maxResearchResults: z.number().optional().default(10).describe("Maximum web research results")
+});
+async function generateSkill(input) {
+  try {
+    const { skillName, projectContext, researchQuery, maxResearchResults } = input;
+    const sanitizedName = sanitizeSkillName(skillName);
+    const llmConfig = detectLLMProvider();
+    if (!llmConfig) {
+      return {
+        success: false,
+        content: "",
+        skillName: sanitizedName,
+        researchSources: [],
+        error: 'No LLM API key found. Please add one of the following to your MCP server config:\n  - ANTHROPIC_API_KEY (for Claude Sonnet 4.5)\n  - GOOGLE_API_KEY (for Gemini 3.0 Pro)\n  - OPENAI_API_KEY (for GPT-4o)\n\nAdd the key to the "env" section of your MCP config file.'
+      };
+    }
+    const query = researchQuery || `${skillName} best practices patterns conventions documentation`;
+    let researchResults = [];
+    let researchSources = [];
+    try {
+      researchResults = await searchTavily(query, maxResearchResults || 10);
+      researchSources = researchResults.map((r) => r.url);
+    } catch (searchErr) {
+      researchResults = [];
+    }
+    const researchContext = researchResults.map((result, idx) => {
+      return `[${idx + 1}] ${result.title}
+${result.snippet}
+Source: ${result.url}`;
+    }).join("\n\n");
+    const systemPrompt = `You are an expert technical writer creating Agent Skills (SKILL.md files) that teach AI coding agents about specific technologies, frameworks, and best practices.
+
+CRITICAL REQUIREMENTS:
+1. Follow the EXACT structure from the gold-standard example below
+2. Include 6-10 Core Rules (numbered list, specific and actionable)
+3. Include 3-5 Patterns with complete runnable code examples
+4. Include 4-6 Anti-Patterns (bulleted list with explanations)
+5. Include File and Folder Conventions section
+6. Include Useful References section
+7. Use proper YAML frontmatter with name, description, tags, sources
+8. All code examples must be complete and runnable
+
+GOLD-STANDARD EXAMPLE STRUCTURE:
+---
+name: ${sanitizedName}
+description: One-line description of what this skill covers
+tags: [tag1, tag2, tag3]
+sources: [https://example.com/docs]
+created_by: skillmesh
+created_at: ${(/* @__PURE__ */ new Date()).toISOString()}
+---
+
+## Overview
+2-3 sentence explanation of what this skill covers and why it matters.
+
+## Core Rules
+1. Rule one \u2014 specific and actionable with rationale
+2. Rule two \u2014 specific and actionable with rationale
+... (6-10 total)
+
+## Patterns and Examples
+
+### Pattern 1 \u2014 Descriptive Name
+Explain what this pattern does and when to use it.
+\`\`\`language
+// Complete runnable code example
+\`\`\`
+
+### Pattern 2 \u2014 Descriptive Name
+... (3-5 total patterns)
+
+## Anti-Patterns (What NOT To Do)
+- NEVER do X because Y (specific reason)
+- NEVER do A because B (specific reason)
+... (4-6 total)
+
+## File and Folder Conventions
+Project-specific folder structure and naming rules.
+
+## Useful References
+- https://official-docs-link
+- https://github.com/source-repo`;
+    const userPrompt = `Generate a gold-standard SKILL.md for: ${skillName}
+
+PROJECT CONTEXT:
+${projectContext}
+
+WEB RESEARCH RESULTS:
+${researchContext || "No research results available. Use your knowledge of best practices."}
+
+INSTRUCTIONS:
+1. Create a comprehensive skill that follows the exact structure shown in the system prompt
+2. Use the project context to make rules and patterns specific to this project
+3. Reference the research sources in the "sources" frontmatter field
+4. Ensure all code examples are complete, runnable, and production-ready
+5. Make the skill immediately actionable for an AI agent working in this codebase
+
+Generate the complete SKILL.md now:`;
+    const generatedContent = await generateWithLLM(systemPrompt, userPrompt, llmConfig);
+    const parsed = parseSkillMd(generatedContent);
+    let quality;
+    if (parsed) {
+      quality = checkSkillQuality(parsed);
+    } else {
+      quality = {
+        score: 0,
+        feedback: ["Generated content does not have valid YAML frontmatter"]
+      };
+    }
+    return {
+      success: true,
+      content: generatedContent,
+      skillName: sanitizedName,
+      researchSources,
+      provider: llmConfig.provider,
+      model: llmConfig.model,
+      quality
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      content: "",
+      skillName: sanitizeSkillName(input.skillName),
+      researchSources: [],
+      error: message
+    };
+  }
+}
+
+// src/tools/install-skill.ts
+var { ensureDirSync: ensureDirSync3, writeFileSync, existsSync: existsSync5 } = fs;
+var InstallSkillInputSchema = z.object({
+  projectPath: z.string().describe("Absolute path to project root directory"),
+  skillName: z.string().describe("Skill name to install"),
+  agents: z.array(z.string()).describe("List of target agent names"),
+  source: z.object({
+    type: z.enum(["github", "content"]).describe("Source type"),
+    owner: z.string().optional().describe("GitHub owner (for type: github)"),
+    repo: z.string().optional().describe("GitHub repo (for type: github)"),
+    content: z.string().optional().describe("Direct SKILL.md content (for type: content)"),
+    stars: z.number().optional().describe("GitHub star count (for quality check)")
+  }).describe("Skill source"),
+  overwrite: z.boolean().optional().default(false).describe("Overwrite existing skill if present"),
+  global: z.boolean().optional().default(false).describe("Install to global scope")
+});
+async function installSkill(input) {
+  try {
+    const { projectPath, skillName, agents, source, overwrite, global } = input;
+    const sanitizedSkillName = sanitizeSkillName(skillName);
+    if (!sanitizedSkillName || sanitizedSkillName.length === 0) {
+      return {
+        method: "skipped",
+        results: [],
+        skillName,
+        error: `Invalid skill name: "${skillName}". Skill names must contain alphanumeric characters.`
+      };
+    }
+    if (!overwrite) {
+      const existingPaths = [];
+      for (const agent of agents) {
+        const skillPath = getSkillPath(agent, projectPath, sanitizedSkillName, global);
+        if (existsSync5(skillPath)) {
+          existingPaths.push(skillPath);
+        }
+      }
+      if (existingPaths.length > 0) {
+        return {
+          method: "skipped",
+          results: agents.map((agent) => ({
+            agent,
+            path: getSkillPath(agent, projectPath, sanitizedSkillName, global),
+            method: "skipped",
+            success: true,
+            error: "Skill already exists. Use overwrite flag to replace."
+          })),
+          skillName: sanitizedSkillName
+        };
+      }
+    }
+    if (source.type === "github" && source.owner && source.repo) {
+      const stars = source.stars ?? 0;
+      if (stars >= 50) {
+        return executePathA(source.owner, source.repo, sanitizedSkillName, agents, projectPath, global);
+      }
+    }
+    let skillContent = null;
+    if (source.type === "content" && source.content) {
+      skillContent = source.content;
+    } else if (source.type === "github" && source.owner && source.repo) {
+      const githubToken = process.env.GITHUB_TOKEN;
+      const fetchResult = await fetchSkillFromGitHub(
+        source.owner,
+        source.repo,
+        sanitizedSkillName,
+        githubToken
+      );
+      if (fetchResult.found) {
+        skillContent = fetchResult.content;
+      }
+    }
+    if (skillContent) {
+      return await executePathB(
+        skillContent,
+        sanitizedSkillName,
+        agents,
+        projectPath,
+        global,
+        overwrite,
+        source.type === "github" ? `${source.owner}/${source.repo}` : "direct-content"
+      );
+    }
+    return await executePathC(skillName, sanitizedSkillName, agents, projectPath, global, overwrite);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      method: "skipped",
+      results: [],
+      skillName: input.skillName,
+      error: `Installation failed: ${message}`
+    };
+  }
+}
+function executePathA(owner, repo, skillName, agents, projectPath, global) {
+  const agentFlags = agents.map((agent) => `--agent ${agent}`).join(" ");
+  const globalFlag = global ? "-g" : "";
+  const repoPath = `${owner}/${repo}`;
+  const command = `npx skills add ${repoPath} --skill ${skillName} ${agentFlags} ${globalFlag} -y`.trim().replace(/\s+/g, " ");
+  const envNote = process.env.GITHUB_TOKEN ? "GITHUB_TOKEN is available in environment (higher rate limits)." : "Note: Set GITHUB_TOKEN environment variable for higher GitHub API rate limits.";
+  const instruction = `Execute this command in your terminal now. The command will install the skill to all specified agents without any interactive prompts.
+
+${envNote}`;
+  const results = agents.map((agent) => ({
+    agent,
+    path: getSkillPath(agent, projectPath, skillName, global),
+    method: "npx_command",
+    success: true
+    // Command generation succeeded; actual execution is agent's responsibility
+  }));
+  return {
+    method: "npx_command",
+    command,
+    instruction,
+    results,
+    skillName
+  };
+}
+async function executePathB(content, skillName, agents, projectPath, global, overwrite, source) {
+  const results = [];
+  const parsed = parseSkillMd(content);
+  if (!parsed) {
+    return {
+      method: "direct_write",
+      results: [],
+      skillName,
+      error: "Invalid SKILL.md content: missing or invalid YAML frontmatter"
+    };
+  }
+  for (const agent of agents) {
+    try {
+      const skillPath = getSkillPath(agent, projectPath, skillName, global);
+      const skillDir = path.dirname(skillPath);
+      if (existsSync5(skillPath) && !overwrite) {
+        results.push({
+          agent,
+          path: skillPath,
+          method: "skipped",
+          success: true,
+          error: "Skill already exists. Use overwrite flag to replace."
+        });
+        continue;
+      }
+      ensureDirSync3(skillDir);
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 15e3);
+      try {
+        writeFileSync(skillPath, content, "utf-8");
+        clearTimeout(timeoutId);
+        results.push({
+          agent,
+          path: skillPath,
+          method: "direct_write",
+          success: true
+        });
+      } catch (writeErr) {
+        clearTimeout(timeoutId);
+        throw writeErr;
+      }
+    } catch (agentErr) {
+      const message = agentErr instanceof Error ? agentErr.message : String(agentErr);
+      results.push({
+        agent,
+        path: getSkillPath(agent, projectPath, skillName, global),
+        method: "direct_write",
+        success: false,
+        error: `Write failed: ${message}`
+      });
+    }
+  }
+  const successfulAgents = results.filter((r) => r.success).map((r) => r.agent);
+  if (successfulAgents.length > 0) {
+    await trackInstalledSkill(projectPath, skillName, successfulAgents, source);
+  }
+  const allSucceeded = results.every((r) => r.success);
+  return {
+    method: "direct_write",
+    results,
+    skillName,
+    error: allSucceeded ? void 0 : "Some installations failed. Check individual agent results."
+  };
+}
+async function executePathC(originalSkillName, sanitizedSkillName, agents, projectPath, global, overwrite) {
+  try {
+    const projectContext = `Generating skill for: ${originalSkillName}
+Project path: ${projectPath}
+Target agents: ${agents.join(", ")}`;
+    const generateResult = await generateSkill({
+      skillName: originalSkillName,
+      projectContext,
+      maxResearchResults: 10
+    });
+    if (!generateResult.success || !generateResult.content) {
+      return {
+        method: "generated",
+        results: [],
+        skillName: sanitizedSkillName,
+        error: generateResult.error || "Skill generation failed"
+      };
+    }
+    const pathBResult = await executePathB(
+      generateResult.content,
+      sanitizedSkillName,
+      agents,
+      projectPath,
+      global,
+      overwrite,
+      "generated"
+    );
+    return {
+      ...pathBResult,
+      method: "generated"
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      method: "generated",
+      results: [],
+      skillName: sanitizedSkillName,
+      error: `Generation failed: ${message}`
+    };
+  }
+}
+var { readdirSync, statSync, readFileSync, existsSync: existsSync6 } = fs;
+var ListSkillsInputSchema = z.object({
+  projectPath: z.string().describe("Absolute path to project root directory"),
+  agent: z.string().optional().describe("Filter by specific agent name"),
+  global: z.boolean().optional().default(false).describe("List global skills instead of project skills")
+});
+async function listSkills(input) {
+  try {
+    const { projectPath, agent, global } = input;
+    const skills = [];
+    const byAgent = {};
+    let agentsToScan;
+    if (agent) {
+      agentsToScan = [agent];
+    } else {
+      if (global) {
+        agentsToScan = Object.keys(AGENT_PATHS);
+      } else {
+        agentsToScan = await detectInstalledAgents(projectPath);
+      }
+    }
+    for (const agentId of agentsToScan) {
+      const agentConfig = AGENT_PATHS[agentId];
+      if (!agentConfig) continue;
+      let skillsDir;
+      if (global) {
+        skillsDir = agentConfig.globalPath.replace(/^~/, os2.homedir());
+      } else {
+        skillsDir = path.join(projectPath, agentConfig.projectPath);
+      }
+      if (!existsSync6(skillsDir)) {
+        continue;
+      }
+      try {
+        const entries = readdirSync(skillsDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory()) continue;
+          const skillName = entry.name;
+          const skillPath = path.join(skillsDir, skillName, "SKILL.md");
+          if (!existsSync6(skillPath)) {
+            continue;
+          }
+          try {
+            const content = readFileSync(skillPath, "utf-8");
+            const stats = statSync(skillPath);
+            const parsed = parseSkillMd(content);
+            const skillInfo = {
+              name: skillName,
+              agent: agentId,
+              path: skillPath,
+              description: parsed?.metadata.description || "No description",
+              tags: parsed?.metadata.tags || [],
+              source: parsed?.metadata.sources?.[0],
+              lastModified: stats.mtime.toISOString()
+            };
+            skills.push(skillInfo);
+            byAgent[agentId] = (byAgent[agentId] || 0) + 1;
+          } catch (readErr) {
+            continue;
+          }
+        }
+      } catch (dirErr) {
+        continue;
+      }
+    }
+    skills.sort((a, b) => {
+      if (a.agent !== b.agent) {
+        return a.agent.localeCompare(b.agent);
+      }
+      return a.name.localeCompare(b.name);
+    });
+    return {
+      success: true,
+      skills,
+      totalCount: skills.length,
+      byAgent
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      skills: [],
+      totalCount: 0,
+      byAgent: {},
+      error: message
+    };
+  }
+}
+var { removeSync, existsSync: existsSync7 } = fs;
+var DeleteSkillInputSchema = z.object({
+  projectPath: z.string().describe("Absolute path to project root directory"),
+  skillName: z.string().describe("Skill name to delete"),
+  agents: z.array(z.string()).optional().describe("Target agents (if omitted, deletes from all agents)"),
+  global: z.boolean().optional().default(false).describe("Delete from global scope")
+});
+async function deleteSkill(input) {
+  try {
+    const { projectPath, skillName, agents, global } = input;
+    const sanitizedName = sanitizeSkillName(skillName);
+    let targetAgents;
+    if (agents && agents.length > 0) {
+      targetAgents = agents;
+    } else {
+      if (global) {
+        targetAgents = Object.keys(AGENT_PATHS);
+      } else {
+        targetAgents = await detectInstalledAgents(projectPath);
+      }
+    }
+    const results = [];
+    let totalDeleted = 0;
+    for (const agentId of targetAgents) {
+      const agentConfig = AGENT_PATHS[agentId];
+      if (!agentConfig) {
+        results.push({
+          agent: agentId,
+          path: "",
+          deleted: false,
+          notFound: true,
+          error: "Unknown agent"
+        });
+        continue;
+      }
+      let skillDir;
+      if (global) {
+        const skillsDir = agentConfig.globalPath.replace(/^~/, os2.homedir());
+        skillDir = path.join(skillsDir, sanitizedName);
+      } else {
+        const skillsDir = path.join(projectPath, agentConfig.projectPath);
+        skillDir = path.join(skillsDir, sanitizedName);
+      }
+      if (!existsSync7(skillDir)) {
+        results.push({
+          agent: agentId,
+          path: skillDir,
+          deleted: false,
+          notFound: true
+        });
+        continue;
+      }
+      try {
+        removeSync(skillDir);
+        if (!global) {
+          try {
+            await untrackSkill(projectPath, sanitizedName, agentId);
+          } catch (configErr) {
+          }
+        }
+        results.push({
+          agent: agentId,
+          path: skillDir,
+          deleted: true,
+          notFound: false
+        });
+        totalDeleted++;
+      } catch (deleteErr) {
+        const message = deleteErr instanceof Error ? deleteErr.message : String(deleteErr);
+        results.push({
+          agent: agentId,
+          path: skillDir,
+          deleted: false,
+          notFound: false,
+          error: message
+        });
+      }
+    }
+    return {
+      success: true,
+      results,
+      skillName: sanitizedName,
+      totalDeleted
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      results: [],
+      skillName: input.skillName,
+      totalDeleted: 0,
+      error: message
+    };
+  }
+}
+
+// src/prompts/system-prompt.ts
+var SYSTEM_PROMPT = `You are connected to SkillMesh, an intelligent Agent Skills manager.
+You have 8 tools to discover, fetch, generate, and install SKILL.md files that permanently teach you and other agents about this project.
+
+## WHAT IS AN AGENT SKILL
+
+A SKILL.md file that lives in your agent's skill directory. You read all SKILL.md files at the start of every session \u2014 skills are always present when the user prompts. Installing a skill permanently teaches you project-specific rules, patterns, conventions, and best practices.
+
+## THE 8 SKILLMESH TOOLS
+
+1. detect_installed_agents \u2014 Scans project root and home directory for installed AI coding agents. Returns list with their skill directory paths.
+
+2. create_skills_folder \u2014 Initializes skill directory structure for selected agents. Creates .claude/skills/, .cursor/skills/, etc. Also creates .skillmesh/skillmesh.config.json for tracking.
+
+3. search_skills \u2014 Searches skills.sh via Tavily for skills matching a keyword. Fetches GitHub star count and recency. Returns ranked list filtered by quality (stars >= 50, updated within 12 months).
+
+4. fetch_skill_content \u2014 Fetches full SKILL.md content from a GitHub repository using raw URL fallbacks. Validates YAML frontmatter. Returns content, source URL, and parsed metadata.
+
+5. install_skill \u2014 Core installation tool. PATH A: returns npx skills add command string for you to execute via your bash tool. PATH B: writes SKILL.md directly to disk if npx fails. PATH C: calls generate_skill if both fail. Handles all selected agents simultaneously.
+
+6. generate_skill \u2014 LLM-powered skill generation. Searches web via Tavily for best practices, sends research + project context to LLM, generates a gold-standard SKILL.md. Only called when PATH A and B fail.
+
+7. list_installed_skills \u2014 Reads all agent skill directories in the project. Returns table of installed skills grouped by agent with name, description, source, and last modified date.
+
+8. delete_skill \u2014 Removes a specific SKILL.md from one or all agent directories. Returns success/failure per agent.
+
+## WHEN TO RUN THE FULL SKILL SETUP WORKFLOW
+
+Automatically trigger when the user says anything resembling:
+- 'set up skills'
+- 'add skills'
+- 'install skills'
+- 'analyze my project and add skills'
+- 'make my agent smarter'
+- 'skillmesh'
+- 'initialize skills'
+
+Run immediately without asking for confirmation.
+
+## FULL SKILL SETUP WORKFLOW (execute in this exact order)
+
+STEP 1: Detect agents
+- Call detect_installed_agents with current project path
+- If no agents detected, inform user and stop
+
+STEP 2: Initialize directories
+- Call create_skills_folder for all detected agents
+- This ensures skill directories exist before installation
+
+STEP 3: Analyze codebase thoroughly
+Scan the project and identify:
+- Primary language and framework (e.g., TypeScript, React, Next.js)
+- Key dependencies and their versions (read package.json, requirements.txt, etc.)
+- Architectural patterns (e.g., App Router, REST API, GraphQL)
+- Folder structure and conventions (e.g., /src, /app, /components)
+- Test setup (Jest, Vitest, Playwright, etc.)
+- Database and ORM (Prisma, Drizzle, MongoDB, etc.)
+- Auth system (NextAuth, Clerk, Auth0, etc.)
+- API patterns (REST, tRPC, GraphQL)
+- Deployment config (Vercel, Docker, AWS, etc.)
+
+STEP 4: Derive skill domains
+From your analysis, identify 4-8 specific skill domains using kebab-case names.
+
+GOOD examples:
+- nextjs-app-router-patterns
+- prisma-multi-tenant-schema
+- react-hook-form-validation
+- tailwind-component-architecture
+- playwright-e2e-testing
+- trpc-api-patterns
+
+BAD examples (too generic):
+- javascript
+- frontend
+- react
+- coding
+- testing
+
+STEP 5: Install skills for each domain
+For each domain you identified:
+
+a. Call search_skills(domain)
+   - This searches skills.sh via Tavily
+   - Returns quality-filtered results (stars >= 50, updated within 12 months)
+
+b. If quality results found (stars >= 50):
+   - Call fetch_skill_content for the top result
+   - Review the content to ensure it matches your needs
+   - Call install_skill with source type 'github' and the owner/repo/stars data
+   - install_skill returns a PATH A response: an npx command string
+   - YOU MUST EXECUTE THIS COMMAND using your bash tool immediately
+   - Example command: npx skills add vercel-labs/next-skills --skill nextjs-patterns --agent claude-code --agent cursor -y
+   - The command is fully non-interactive (no prompts) thanks to --agent flags and -y flag
+
+c. If no quality results OR PATH A fails:
+   - Call install_skill with source type 'github' (if you have owner/repo) or 'content' (if you have raw content)
+   - This triggers PATH B: direct write to disk
+   - If PATH B also fails OR no GitHub source exists:
+     - Call generate_skill with rich projectContext
+     - Then call install_skill with source type 'content' using the generated content
+
+STEP 6: Report results
+- Call list_installed_skills to see all installed skills
+- Present a summary table to the user grouped by agent
+- Highlight which skills were installed (PATH A, PATH B, or generated)
+
+## CRITICAL REQUIREMENTS
+
+PROJECTCONTEXT QUALITY:
+When calling generate_skill, always provide detailed projectContext. Include:
+- Exact framework versions from package.json/requirements.txt
+- Key architectural patterns observed in the code
+- Specific folder structure and file naming conventions
+- Main dependencies and how they interact
+- Any coding conventions found in existing files
+The richer the context, the more useful the generated skill.
+
+EXECUTION RULES:
+- NEVER ask the user to confirm before running the workflow
+- NEVER install the same skill twice \u2014 call list_installed_skills first and check for duplicates
+- ALWAYS install to all detected agents simultaneously
+- ALWAYS execute npx commands returned by install_skill (PATH A) using your bash tool
+- NEVER manually write SKILL.md files \u2014 always use install_skill tool
+
+ERROR HANDLING:
+- If search_skills returns no results, immediately fall back to generate_skill
+- If install_skill PATH A fails (npx error), the tool automatically falls back to PATH B
+- If PATH B fails (fetch error), the tool automatically falls back to PATH C (generate)
+- Always report errors clearly to the user and show which skills succeeded vs failed
+
+## SKILL INSTALLATION PATHS EXPLAINED
+
+PATH A (npx command \u2014 preferred):
+- Used for high-quality GitHub repos (stars >= 50)
+- install_skill returns an npx command string
+- YOU execute it using your bash tool
+- Command format: npx skills add <owner/repo> --skill <name> --agent <agent1> --agent <agent2> -y
+- The npx CLI handles cloning, writing, and directory creation
+- Fully automated with zero interactive prompts
+
+PATH B (direct write \u2014 fallback):
+- Used when PATH A not applicable or GitHub fetch available but stars < 50
+- install_skill fetches raw SKILL.md from GitHub
+- Writes directly to all agent directories using fs-extra
+- Updates .skillmesh/skillmesh.config.json for tracking
+
+PATH C (LLM generation \u2014 last resort):
+- Used when no existing skill found on GitHub
+- Requires ANTHROPIC_API_KEY, GOOGLE_API_KEY, or OPENAI_API_KEY in env
+- Searches web via Tavily for best practices
+- Generates gold-standard SKILL.md from research + project context
+- Writes to all agent directories
+
+## TYPICAL USER INTERACTION EXAMPLE
+
+User: "Set up skills for my Next.js project"
+
+You:
+1. [Call detect_installed_agents] \u2192 Found: claude-code, cursor
+2. [Call create_skills_folder] \u2192 Created .claude/skills/ and .cursor/skills/
+3. [Analyze project] \u2192 Next.js 15, App Router, TypeScript, Prisma, TailwindCSS
+4. [Derive domains] \u2192 nextjs-app-router-patterns, prisma-schema-design, tailwindcss-components
+5. For nextjs-app-router-patterns:
+   - [Call search_skills] \u2192 Found vercel-labs/next-skills (2,341 stars)
+   - [Call fetch_skill_content] \u2192 Retrieved SKILL.md
+   - [Call install_skill] \u2192 Returns npx command
+   - [Execute via bash] \u2192 npx skills add vercel-labs/next-skills --skill nextjs-app-router-patterns --agent claude-code --agent cursor -y
+6. [Repeat for other domains]
+7. [Call list_installed_skills] \u2192 Report summary table
+
+User sees: "Installed 3 skills across 2 agents (claude-code, cursor). You now have permanent knowledge of Next.js App Router patterns, Prisma schema design, and TailwindCSS component architecture."
+
+## NOTES
+
+- Skill names on disk are sanitized to kebab-case: toLowerCase().replace(/[^a-z0-9-]/g, '-')
+- GITHUB_TOKEN is optional but recommended for higher API rate limits (5000/hr vs 60/hr)
+- LLM API keys are only needed for generate_skill (PATH C)
+- Always use absolute paths, never relative paths
+- Target directories: .claude/skills/, .cursor/skills/, .agent/skills/, .windsurf/skills/, etc.
+`;
+
+// src/index.ts
+var server = new Server(
+  {
+    name: "skillmesh-mcp",
+    version: "1.0.0"
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "detect_installed_agents",
+        description: "Scans project root and home directory for installed AI coding agents. Returns list of detected agents with their skill directory paths.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectPath: {
+              type: "string",
+              description: "Absolute path to project root directory"
+            },
+            includeGlobal: {
+              type: "boolean",
+              description: "Also scan home directory for globally installed agents",
+              default: false
+            }
+          },
+          required: ["projectPath"]
+        }
+      },
+      {
+        name: "create_skills_folder",
+        description: "Initializes skill directory structure for selected agents. Creates .claude/skills/, .cursor/skills/, etc. Also creates .skillmesh/skillmesh.config.json for tracking.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectPath: {
+              type: "string",
+              description: "Absolute path to project root directory"
+            },
+            agents: {
+              type: "array",
+              items: { type: "string" },
+              description: "List of agent names to create folders for"
+            },
+            global: {
+              type: "boolean",
+              description: "Create in global scope instead of project scope",
+              default: false
+            }
+          },
+          required: ["projectPath", "agents"]
+        }
+      },
+      {
+        name: "search_skills",
+        description: "Searches skills.sh via Tavily for skills matching a keyword. Fetches GitHub star count and recency. Returns ranked list filtered by quality (stars >= 50, updated within 12 months).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            keyword: {
+              type: "string",
+              description: 'Search keyword or skill domain (e.g., "nextjs-app-router", "prisma")'
+            },
+            minStars: {
+              type: "number",
+              description: "Minimum GitHub stars filter",
+              default: 50
+            },
+            maxAgeMonths: {
+              type: "number",
+              description: "Maximum age in months (updated within)",
+              default: 12
+            },
+            limit: {
+              type: "number",
+              description: "Maximum number of results",
+              default: 10
+            }
+          },
+          required: ["keyword"]
+        }
+      },
+      {
+        name: "fetch_skill_content",
+        description: "Fetches full SKILL.md content from a GitHub repository using raw URL fallbacks. Validates YAML frontmatter. Returns content, source URL, and parsed metadata.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            owner: {
+              type: "string",
+              description: "GitHub repository owner"
+            },
+            repo: {
+              type: "string",
+              description: "GitHub repository name"
+            },
+            skillName: {
+              type: "string",
+              description: "Skill name to fetch"
+            },
+            githubToken: {
+              type: "string",
+              description: "Optional GitHub token for higher rate limits"
+            }
+          },
+          required: ["owner", "repo", "skillName"]
+        }
+      },
+      {
+        name: "install_skill",
+        description: "Core installation tool. PATH A: returns npx skills add command string for agent to execute. PATH B: writes SKILL.md directly to disk if npx fails. Handles all selected agents simultaneously.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectPath: {
+              type: "string",
+              description: "Absolute path to project root directory"
+            },
+            skillName: {
+              type: "string",
+              description: "Skill name to install"
+            },
+            agents: {
+              type: "array",
+              items: { type: "string" },
+              description: "List of target agent names"
+            },
+            source: {
+              type: "object",
+              properties: {
+                type: {
+                  type: "string",
+                  enum: ["github", "content"],
+                  description: "Source type"
+                },
+                owner: {
+                  type: "string",
+                  description: "GitHub owner (for type: github)"
+                },
+                repo: {
+                  type: "string",
+                  description: "GitHub repo (for type: github)"
+                },
+                content: {
+                  type: "string",
+                  description: "Direct SKILL.md content (for type: content)"
+                }
+              },
+              required: ["type"],
+              description: "Skill source"
+            },
+            overwrite: {
+              type: "boolean",
+              description: "Overwrite existing skill if present",
+              default: false
+            },
+            global: {
+              type: "boolean",
+              description: "Install to global scope",
+              default: false
+            }
+          },
+          required: ["projectPath", "skillName", "agents", "source"]
+        }
+      },
+      {
+        name: "generate_skill",
+        description: "LLM-powered skill generation. Searches web via Tavily for best practices, sends research + project context to LLM, generates a gold-standard SKILL.md. Only called when search and fetch fail.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            skillName: {
+              type: "string",
+              description: "Skill name/domain to generate"
+            },
+            projectContext: {
+              type: "string",
+              description: "Rich project context: frameworks, versions, patterns, structure"
+            },
+            researchQuery: {
+              type: "string",
+              description: "Optional custom web research query"
+            },
+            maxResearchResults: {
+              type: "number",
+              description: "Maximum web research results",
+              default: 10
+            }
+          },
+          required: ["skillName", "projectContext"]
+        }
+      },
+      {
+        name: "list_installed_skills",
+        description: "Reads all agent skill directories in the project. Returns table of installed skills grouped by agent with name, description, source, and last modified date.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectPath: {
+              type: "string",
+              description: "Absolute path to project root directory"
+            },
+            agent: {
+              type: "string",
+              description: "Filter by specific agent name"
+            },
+            global: {
+              type: "boolean",
+              description: "List global skills instead of project skills",
+              default: false
+            }
+          },
+          required: ["projectPath"]
+        }
+      },
+      {
+        name: "delete_skill",
+        description: "Removes a specific SKILL.md from one or all agent directories. Returns success/failure per agent.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectPath: {
+              type: "string",
+              description: "Absolute path to project root directory"
+            },
+            skillName: {
+              type: "string",
+              description: "Skill name to delete"
+            },
+            agents: {
+              type: "array",
+              items: { type: "string" },
+              description: "Target agents (if omitted, deletes from all agents)"
+            },
+            global: {
+              type: "boolean",
+              description: "Delete from global scope",
+              default: false
+            }
+          },
+          required: ["projectPath", "skillName"]
+        }
+      }
+    ]
+  };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    switch (name) {
+      case "detect_installed_agents": {
+        const validated = DetectAgentsInputSchema.parse(args);
+        const result = await detectAgents(validated);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "create_skills_folder": {
+        const validated = CreateFolderInputSchema.parse(args);
+        const result = await createFolder(validated);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "search_skills": {
+        const validated = SearchSkillsInputSchema.parse(args);
+        const result = await searchSkills(validated);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "fetch_skill_content": {
+        const validated = FetchSkillInputSchema.parse(args);
+        const result = await fetchSkillContent(validated);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "install_skill": {
+        const validated = InstallSkillInputSchema.parse(args);
+        const result = await installSkill(validated);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "generate_skill": {
+        const validated = GenerateSkillInputSchema.parse(args);
+        const result = await generateSkill(validated);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "list_installed_skills": {
+        const validated = ListSkillsInputSchema.parse(args);
+        const result = await listSkills(validated);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "delete_skill": {
+        const validated = DeleteSkillInputSchema.parse(args);
+        const result = await deleteSkill(validated);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: errorMessage }, null, 2)
+        }
+      ],
+      isError: true
+    };
+  }
+});
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("SkillMesh MCP Server running on stdio");
+  console.error("System prompt loaded:", SYSTEM_PROMPT.substring(0, 100) + "...");
+}
+main().catch((error) => {
+  console.error("Fatal error in main():", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map