skillli 0.1.0

package/dist/index.js

@@ -0,0 +1,961 @@
+// src/core/parser.ts
+import { readFile } from "fs/promises";
+import matter from "gray-matter";
+
+// src/core/schema.ts
+import { z } from "zod";
+var SkillCategorySchema = z.enum([
+  "development",
+  "creative",
+  "enterprise",
+  "data",
+  "devops",
+  "other"
+]);
+var TrustLevelSchema = z.enum(["community", "verified", "official"]);
+var SkillMetadataSchema = z.object({
+  name: z.string().min(1).max(100).regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/, "Must be lowercase alphanumeric with hyphens, not starting/ending with hyphen"),
+  version: z.string().regex(/^\d+\.\d+\.\d+$/, "Must be valid semver (e.g. 1.0.0)"),
+  description: z.string().min(10).max(500),
+  author: z.string().min(1),
+  license: z.string().min(1),
+  tags: z.array(z.string().min(1).max(50)).min(1).max(20),
+  category: SkillCategorySchema,
+  repository: z.string().url().optional(),
+  homepage: z.string().url().optional(),
+  "min-skillli-version": z.string().optional(),
+  "trust-level": TrustLevelSchema.default("community"),
+  checksum: z.string().optional(),
+  "disable-model-invocation": z.boolean().default(false),
+  "user-invocable": z.boolean().default(true)
+});
+
+// src/core/errors.ts
+var SkillliError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SkillliError";
+  }
+};
+var SkillValidationError = class extends SkillliError {
+  details;
+  constructor(message, details = []) {
+    super(message);
+    this.name = "SkillValidationError";
+    this.details = details;
+  }
+};
+var SkillNotFoundError = class extends SkillliError {
+  constructor(skillName) {
+    super(`Skill not found: ${skillName}`);
+    this.name = "SkillNotFoundError";
+  }
+};
+var RegistryError = class extends SkillliError {
+  constructor(message) {
+    super(message);
+    this.name = "RegistryError";
+  }
+};
+var InstallError = class extends SkillliError {
+  constructor(message) {
+    super(message);
+    this.name = "InstallError";
+  }
+};
+
+// src/core/parser.ts
+function normalizeMetadata(raw) {
+  return {
+    name: raw.name,
+    version: raw.version,
+    description: raw.description,
+    author: raw.author,
+    license: raw.license,
+    tags: raw.tags,
+    category: raw.category,
+    repository: raw.repository,
+    homepage: raw.homepage,
+    minSkillliVersion: raw["min-skillli-version"],
+    trustLevel: raw["trust-level"],
+    checksum: raw.checksum,
+    disableModelInvocation: raw["disable-model-invocation"],
+    userInvocable: raw["user-invocable"]
+  };
+}
+function validateMetadata(data) {
+  const result = SkillMetadataSchema.safeParse(data);
+  if (!result.success) {
+    const details = result.error.issues.map(
+      (issue) => `${issue.path.join(".")}: ${issue.message}`
+    );
+    throw new SkillValidationError("Invalid skill metadata", details);
+  }
+  return normalizeMetadata(result.data);
+}
+function parseSkillContent(content, filePath = "<inline>") {
+  const { data, content: body, matter: rawFrontmatter } = matter(content);
+  const metadata = validateMetadata(data);
+  return {
+    metadata,
+    content: body.trim(),
+    rawFrontmatter: rawFrontmatter || "",
+    filePath
+  };
+}
+async function parseSkillFile(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  return parseSkillContent(content, filePath);
+}
+function extractManifest(skill) {
+  const { metadata } = skill;
+  return {
+    name: metadata.name,
+    version: metadata.version,
+    description: metadata.description,
+    author: metadata.author,
+    license: metadata.license,
+    tags: metadata.tags,
+    category: metadata.category,
+    repository: metadata.repository,
+    trust_level: metadata.trustLevel,
+    checksum: metadata.checksum,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/core/search.ts
+function tokenize(text) {
+  return text.toLowerCase().split(/[\s\-_,./]+/).filter((t) => t.length > 1);
+}
+function textScore(tokens, text) {
+  const lower = text.toLowerCase();
+  let score = 0;
+  for (const token of tokens) {
+    if (lower.includes(token)) score += 1;
+  }
+  return score;
+}
+function scoreSkill(entry, queryTokens, options) {
+  let score = 0;
+  const matchedOn = [];
+  const nameScore = textScore(queryTokens, entry.name);
+  if (nameScore > 0) {
+    score += nameScore * 5;
+    matchedOn.push("name");
+  }
+  if (entry.name === options.query.toLowerCase()) {
+    score += 10;
+  }
+  const descScore = textScore(queryTokens, entry.description);
+  if (descScore > 0) {
+    score += descScore * 2;
+    matchedOn.push("description");
+  }
+  for (const token of queryTokens) {
+    if (entry.tags.some((t) => t.toLowerCase() === token)) {
+      score += 4;
+      if (!matchedOn.includes("tags")) matchedOn.push("tags");
+    }
+  }
+  if (options.tags) {
+    for (const tag of options.tags) {
+      if (entry.tags.includes(tag)) {
+        score += 3;
+        if (!matchedOn.includes("tags")) matchedOn.push("tags");
+      }
+    }
+  }
+  if (options.category && entry.category === options.category) {
+    score += 2;
+    matchedOn.push("category");
+  }
+  if (matchedOn.length > 0) {
+    if (entry.trustLevel === "official") score += 3;
+    if (entry.trustLevel === "verified") score += 1.5;
+    score += entry.rating.average * 0.5;
+    if (entry.downloads > 0) {
+      score += Math.log10(entry.downloads) * 0.5;
+    }
+  }
+  return { score, matchedOn };
+}
+function search(index, options) {
+  const queryTokens = tokenize(options.query);
+  const results = [];
+  for (const entry of Object.values(index.skills)) {
+    if (options.category && entry.category !== options.category) continue;
+    if (options.trustLevel && entry.trustLevel !== options.trustLevel) continue;
+    if (options.minRating && entry.rating.average < options.minRating) continue;
+    const { score, matchedOn } = scoreSkill(entry, queryTokens, options);
+    if (score > 0) {
+      results.push({ skill: entry, relevanceScore: score, matchedOn });
+    }
+  }
+  results.sort((a, b) => b.relevanceScore - a.relevanceScore);
+  const offset = options.offset ?? 0;
+  const limit = options.limit ?? 20;
+  return results.slice(offset, offset + limit);
+}
+function searchByTags(index, tags) {
+  return search(index, { query: tags.join(" "), tags });
+}
+function searchByCategory(index, category) {
+  return search(index, { query: "", category });
+}
+
+// src/core/installer.ts
+import { mkdir as mkdir2, rm, symlink } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { execSync } from "child_process";
+
+// src/core/constants.ts
+import { homedir } from "os";
+import { join } from "path";
+var SKILLLI_DIR = join(homedir(), ".skillli");
+var LOCAL_INDEX_PATH = join(SKILLLI_DIR, "index.json");
+var CONFIG_PATH = join(SKILLLI_DIR, "config.json");
+var SKILLS_DIR = join(SKILLLI_DIR, "skills");
+var CACHE_DIR = join(SKILLLI_DIR, "cache");
+var DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/skillli/registry/main/index.json";
+var SKILL_FILENAME = "SKILL.md";
+var MAX_SKILL_SIZE_BYTES = 5 * 1024 * 1024;
+var MAX_SKILL_MD_LINES = 500;
+var VERSION = "0.1.0";
+
+// src/core/local-store.ts
+import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+async function ensureDir() {
+  for (const dir of [SKILLLI_DIR, SKILLS_DIR, CACHE_DIR]) {
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+  }
+}
+function defaultConfig() {
+  return {
+    installedSkills: {},
+    registryUrl: DEFAULT_REGISTRY_URL,
+    lastSync: ""
+  };
+}
+function defaultIndex() {
+  return {
+    version: "1.0.0",
+    lastUpdated: "",
+    skills: {}
+  };
+}
+async function getConfig() {
+  await ensureDir();
+  if (!existsSync(CONFIG_PATH)) {
+    const config = defaultConfig();
+    await saveConfig(config);
+    return config;
+  }
+  const raw = await readFile2(CONFIG_PATH, "utf-8");
+  return JSON.parse(raw);
+}
+async function saveConfig(config) {
+  await ensureDir();
+  await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+async function getLocalIndex() {
+  await ensureDir();
+  if (!existsSync(LOCAL_INDEX_PATH)) {
+    const index = defaultIndex();
+    await saveLocalIndex(index);
+    return index;
+  }
+  const raw = await readFile2(LOCAL_INDEX_PATH, "utf-8");
+  return JSON.parse(raw);
+}
+async function saveLocalIndex(index) {
+  await ensureDir();
+  await writeFile(LOCAL_INDEX_PATH, JSON.stringify(index, null, 2));
+}
+async function getInstalledSkills() {
+  const config = await getConfig();
+  return Object.values(config.installedSkills);
+}
+async function markInstalled(skill) {
+  const config = await getConfig();
+  config.installedSkills[skill.name] = skill;
+  await saveConfig(config);
+}
+async function markUninstalled(name) {
+  const config = await getConfig();
+  delete config.installedSkills[name];
+  await saveConfig(config);
+}
+
+// src/core/registry.ts
+async function fetchIndex(registryUrl) {
+  const config = await getConfig();
+  const url = registryUrl ?? config.registryUrl ?? DEFAULT_REGISTRY_URL;
+  try {
+    const res = await fetch(url);
+    if (!res.ok) {
+      throw new RegistryError(`Failed to fetch registry: ${res.status} ${res.statusText}`);
+    }
+    const index = await res.json();
+    index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    await saveLocalIndex(index);
+    return index;
+  } catch (error) {
+    if (error instanceof RegistryError) throw error;
+    const localIndex = await getLocalIndex();
+    if (Object.keys(localIndex.skills).length > 0) {
+      return localIndex;
+    }
+    throw new RegistryError(`Cannot reach registry at ${url}: ${error}`);
+  }
+}
+async function getSkillEntry(name) {
+  const index = await getLocalIndex();
+  const entry = index.skills[name];
+  if (!entry) {
+    throw new SkillNotFoundError(name);
+  }
+  return entry;
+}
+async function syncIndex() {
+  return fetchIndex();
+}
+
+// src/core/safeguards.ts
+import { stat } from "fs/promises";
+import { join as join2 } from "path";
+import { existsSync as existsSync2, readdirSync } from "fs";
+var PROHIBITED_PATTERNS = [
+  { pattern: /\beval\s*\(/, label: "eval()" },
+  { pattern: /\bexec\s*\(/, label: "exec()" },
+  { pattern: /\bexecSync\s*\(/, label: "execSync()" },
+  { pattern: /rm\s+-rf\s+\//, label: "rm -rf /" },
+  { pattern: /\bchild_process\b/, label: "child_process" },
+  { pattern: /\bProcess\.kill\b/i, label: "Process.kill" },
+  { pattern: /password\s*[:=]\s*['"][^'"]+['"]/, label: "hardcoded password" },
+  { pattern: /api[_-]?key\s*[:=]\s*['"][^'"]+['"]/, label: "hardcoded API key" },
+  { pattern: /[A-Za-z0-9+/]{100,}={0,2}/, label: "large base64 blob" }
+];
+var ALLOWED_SCRIPT_EXTENSIONS = [".sh", ".py", ".js", ".ts"];
+function checkSchema(skill) {
+  return {
+    name: "schema-validation",
+    passed: true,
+    severity: "info",
+    message: "SKILL.md metadata is valid"
+  };
+}
+function checkLineCount(content) {
+  const lines = content.split("\n").length;
+  const passed = lines <= MAX_SKILL_MD_LINES;
+  return {
+    name: "line-count",
+    passed,
+    severity: passed ? "info" : "warning",
+    message: passed ? `SKILL.md has ${lines} lines (max ${MAX_SKILL_MD_LINES})` : `SKILL.md has ${lines} lines, exceeds max of ${MAX_SKILL_MD_LINES}`
+  };
+}
+function checkProhibitedPatterns(content) {
+  const found = [];
+  for (const { pattern, label } of PROHIBITED_PATTERNS) {
+    if (pattern.test(content)) {
+      found.push(label);
+    }
+  }
+  const passed = found.length === 0;
+  return {
+    name: "prohibited-patterns",
+    passed,
+    severity: passed ? "info" : "error",
+    message: passed ? "No prohibited patterns detected" : `Prohibited patterns found: ${found.join(", ")}`
+  };
+}
+function checkScriptSafety(skillDir) {
+  const scriptsDir = join2(skillDir, "scripts");
+  if (!existsSync2(scriptsDir)) {
+    return {
+      name: "script-safety",
+      passed: true,
+      severity: "info",
+      message: "No scripts directory found"
+    };
+  }
+  const badFiles = [];
+  const files = readdirSync(scriptsDir, { recursive: true });
+  for (const file of files) {
+    const ext = "." + file.split(".").pop();
+    if (!ALLOWED_SCRIPT_EXTENSIONS.includes(ext)) {
+      badFiles.push(file);
+    }
+  }
+  const passed = badFiles.length === 0;
+  return {
+    name: "script-safety",
+    passed,
+    severity: passed ? "info" : "error",
+    message: passed ? "All scripts use allowed extensions" : `Disallowed script types: ${badFiles.join(", ")}`
+  };
+}
+async function checkFileSize(skillDir) {
+  let totalSize = 0;
+  const entries = readdirSync(skillDir, { recursive: true, withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      const fullPath = join2(entry.parentPath ?? skillDir, entry.name);
+      const s = await stat(fullPath);
+      totalSize += s.size;
+    }
+  }
+  const passed = totalSize <= MAX_SKILL_SIZE_BYTES;
+  return {
+    name: "file-size",
+    passed,
+    severity: passed ? "info" : "warning",
+    message: passed ? `Total size: ${(totalSize / 1024).toFixed(1)}KB (max ${MAX_SKILL_SIZE_BYTES / 1024 / 1024}MB)` : `Total size ${(totalSize / 1024 / 1024).toFixed(1)}MB exceeds max of ${MAX_SKILL_SIZE_BYTES / 1024 / 1024}MB`
+  };
+}
+async function runSafeguards(skill, skillDir) {
+  const checks = [];
+  checks.push(checkSchema(skill));
+  checks.push(checkLineCount(skill.content));
+  checks.push(checkProhibitedPatterns(skill.content + skill.rawFrontmatter));
+  if (skillDir) {
+    checks.push(checkScriptSafety(skillDir));
+    checks.push(await checkFileSize(skillDir));
+  }
+  const passed = checks.every((c) => c.passed || c.severity !== "error");
+  const score = computeTrustScore(skill);
+  return { passed, score, checks };
+}
+function computeTrustScore(skill, registryEntry) {
+  let score = 0;
+  if (skill.metadata.repository) score += 10;
+  if (skill.metadata.license) score += 10;
+  if (skill.metadata.trustLevel === "verified") score += 15;
+  if (skill.metadata.trustLevel === "official") score += 20;
+  if (registryEntry && registryEntry.rating.average >= 3.5) score += 15;
+  if (registryEntry && registryEntry.downloads > 100) score += 5;
+  if (registryEntry && registryEntry.downloads > 1e3) score += 5;
+  const patternCheck = checkProhibitedPatterns(skill.content);
+  const lineCheck = checkLineCount(skill.content);
+  if (patternCheck.passed) score += 20;
+  if (lineCheck.passed) score += 15;
+  return Math.min(score, 100);
+}
+
+// src/core/installer.ts
+async function installFromRegistry(name, version) {
+  const entry = await getSkillEntry(name);
+  if (!entry.repository) {
+    throw new InstallError(`Skill "${name}" has no repository URL`);
+  }
+  return installFromGithub(entry.repository, name);
+}
+async function installFromGithub(repoUrl, nameOverride) {
+  const name = nameOverride ?? repoUrl.split("/").pop()?.replace(/\.git$/, "") ?? "unknown";
+  const installPath = join3(SKILLS_DIR, name);
+  if (existsSync3(installPath)) {
+    await rm(installPath, { recursive: true });
+  }
+  await mkdir2(installPath, { recursive: true });
+  try {
+    execSync(`git clone --depth 1 "${repoUrl}" "${installPath}"`, {
+      stdio: "pipe",
+      timeout: 3e4
+    });
+  } catch {
+    throw new InstallError(`Failed to clone ${repoUrl}`);
+  }
+  const skillFile = join3(installPath, SKILL_FILENAME);
+  if (!existsSync3(skillFile)) {
+    await rm(installPath, { recursive: true });
+    throw new InstallError(`No ${SKILL_FILENAME} found in ${repoUrl}`);
+  }
+  const skill = await parseSkillFile(skillFile);
+  const safeguards = await runSafeguards(skill, installPath);
+  if (!safeguards.passed) {
+    await rm(installPath, { recursive: true });
+    const errors = safeguards.checks.filter((c) => !c.passed).map((c) => c.message);
+    throw new InstallError(`Skill failed safety checks: ${errors.join("; ")}`);
+  }
+  const installed = {
+    name: skill.metadata.name,
+    version: skill.metadata.version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    path: installPath,
+    source: "github"
+  };
+  await markInstalled(installed);
+  return installed;
+}
+async function installFromLocal(dirPath) {
+  const skillFile = join3(dirPath, SKILL_FILENAME);
+  if (!existsSync3(skillFile)) {
+    throw new InstallError(`No ${SKILL_FILENAME} found in ${dirPath}`);
+  }
+  const skill = await parseSkillFile(skillFile);
+  const safeguards = await runSafeguards(skill, dirPath);
+  if (!safeguards.passed) {
+    const errors = safeguards.checks.filter((c) => !c.passed).map((c) => c.message);
+    throw new InstallError(`Skill failed safety checks: ${errors.join("; ")}`);
+  }
+  const installPath = join3(SKILLS_DIR, skill.metadata.name);
+  if (existsSync3(installPath)) {
+    await rm(installPath, { recursive: true });
+  }
+  execSync(`cp -r "${dirPath}" "${installPath}"`, { stdio: "pipe" });
+  const installed = {
+    name: skill.metadata.name,
+    version: skill.metadata.version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    path: installPath,
+    source: "local"
+  };
+  await markInstalled(installed);
+  return installed;
+}
+async function uninstall(name) {
+  const installPath = join3(SKILLS_DIR, name);
+  if (existsSync3(installPath)) {
+    await rm(installPath, { recursive: true });
+  }
+  await markUninstalled(name);
+}
+async function linkToClaudeSkills(skill, projectDir = process.cwd()) {
+  const claudeSkillsDir = join3(projectDir, ".claude", "skills");
+  await mkdir2(claudeSkillsDir, { recursive: true });
+  const linkPath = join3(claudeSkillsDir, skill.name);
+  if (existsSync3(linkPath)) {
+    await rm(linkPath, { recursive: true });
+  }
+  await symlink(skill.path, linkPath, "dir");
+  return linkPath;
+}
+
+// src/core/ratings.ts
+async function getRatings(name) {
+  const index = await getLocalIndex();
+  const entry = index.skills[name];
+  if (!entry) {
+    throw new SkillNotFoundError(name);
+  }
+  return entry.rating;
+}
+async function submitRating(name, rating, userId, comment) {
+  const index = await getLocalIndex();
+  const entry = index.skills[name];
+  if (!entry) {
+    throw new SkillNotFoundError(name);
+  }
+  const current = entry.rating;
+  const newCount = current.count + 1;
+  const newAverage = (current.average * current.count + rating) / newCount;
+  const dist = [...current.distribution];
+  dist[rating - 1] += 1;
+  entry.rating = {
+    average: Math.round(newAverage * 10) / 10,
+    count: newCount,
+    distribution: dist
+  };
+  await saveLocalIndex(index);
+  return entry.rating;
+}
+function formatRating(rating) {
+  const filled = Math.round(rating.average);
+  const empty = 5 - filled;
+  const stars = "\u2605".repeat(filled) + "\u2606".repeat(empty);
+  return `${stars} ${rating.average.toFixed(1)} (${rating.count} ratings)`;
+}
+
+// src/core/publisher.ts
+import { readFile as readFile5 } from "fs/promises";
+import { join as join4 } from "path";
+import { createHash } from "crypto";
+import { existsSync as existsSync4, readdirSync as readdirSync2, statSync } from "fs";
+async function packageSkill(skillDir) {
+  const skillFile = join4(skillDir, SKILL_FILENAME);
+  if (!existsSync4(skillFile)) {
+    throw new SkillValidationError(`No ${SKILL_FILENAME} found in ${skillDir}`);
+  }
+  const skill = await parseSkillFile(skillFile);
+  const safeguards = await runSafeguards(skill, skillDir);
+  if (!safeguards.passed) {
+    const errors = safeguards.checks.filter((c) => !c.passed).map((c) => `[${c.severity}] ${c.message}`);
+    throw new SkillValidationError("Skill failed safety checks", errors);
+  }
+  const checksum = await computeDirectoryChecksum(skillDir);
+  const manifest = extractManifest(skill);
+  manifest.checksum = `sha256:${checksum}`;
+  manifest.files = listFiles(skillDir);
+  manifest.size_bytes = computeDirectorySize(skillDir);
+  return { skill, manifest, checksum };
+}
+async function computeDirectoryChecksum(dir) {
+  const hash = createHash("sha256");
+  const files = listFiles(dir).sort();
+  for (const file of files) {
+    const content = await readFile5(join4(dir, file));
+    hash.update(file);
+    hash.update(content);
+  }
+  return hash.digest("hex");
+}
+function listFiles(dir, prefix = "") {
+  const files = [];
+  const entries = readdirSync2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === ".git" || entry.name === "node_modules") continue;
+    const relative = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      files.push(...listFiles(join4(dir, entry.name), relative));
+    } else {
+      files.push(relative);
+    }
+  }
+  return files;
+}
+function computeDirectorySize(dir) {
+  let size = 0;
+  const entries = readdirSync2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === ".git" || entry.name === "node_modules") continue;
+    const fullPath = join4(dir, entry.name);
+    if (entry.isDirectory()) {
+      size += computeDirectorySize(fullPath);
+    } else {
+      size += statSync(fullPath).size;
+    }
+  }
+  return size;
+}
+
+// src/trawler/strategies.ts
+async function searchRegistry(query) {
+  const index = await getLocalIndex();
+  const tokens = query.toLowerCase().split(/\s+/);
+  const results = [];
+  for (const entry of Object.values(index.skills)) {
+    const text = `${entry.name} ${entry.description} ${entry.tags.join(" ")}`.toLowerCase();
+    const matchCount = tokens.filter((t) => text.includes(t)).length;
+    if (matchCount === 0) continue;
+    results.push({
+      source: "registry",
+      skill: entry,
+      confidence: Math.min(matchCount / tokens.length, 1),
+      url: entry.repository || `skillli://registry/${entry.name}`
+    });
+  }
+  return results;
+}
+async function searchGithub(query) {
+  const results = [];
+  const searchQuery = encodeURIComponent(`${query} SKILL.md in:path`);
+  const url = `https://api.github.com/search/repositories?q=${searchQuery}&per_page=10`;
+  try {
+    const res = await fetch(url, {
+      headers: { Accept: "application/vnd.github.v3+json" }
+    });
+    if (!res.ok) return results;
+    const data = await res.json();
+    for (const repo of data.items ?? []) {
+      const confidence = Math.min(
+        0.3 + (repo.stargazers_count > 10 ? 0.2 : 0) + (repo.stargazers_count > 100 ? 0.2 : 0),
+        0.9
+      );
+      results.push({
+        source: "github",
+        skill: {
+          name: repo.full_name.split("/").pop() ?? repo.full_name,
+          description: repo.description ?? "",
+          author: repo.full_name.split("/")[0],
+          repository: repo.html_url,
+          tags: repo.topics ?? []
+        },
+        confidence,
+        url: repo.html_url
+      });
+    }
+  } catch {
+  }
+  return results;
+}
+async function searchNpm(query) {
+  const results = [];
+  const searchQuery = encodeURIComponent(`${query} skill agent claude`);
+  const url = `https://registry.npmjs.org/-/v1/search?text=${searchQuery}&size=10`;
+  try {
+    const res = await fetch(url);
+    if (!res.ok) return results;
+    const data = await res.json();
+    for (const obj of data.objects ?? []) {
+      const pkg = obj.package;
+      results.push({
+        source: "npm",
+        skill: {
+          name: pkg.name,
+          description: pkg.description ?? "",
+          version: pkg.version,
+          repository: pkg.links.repository ?? "",
+          tags: pkg.keywords ?? []
+        },
+        confidence: Math.min(obj.score.final * 0.7, 0.85),
+        url: pkg.links.npm
+      });
+    }
+  } catch {
+  }
+  return results;
+}
+
+// src/trawler/ranker.ts
+function deduplicateResults(results) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const key = result.skill.name?.toLowerCase() ?? result.url;
+    const existing = seen.get(key);
+    if (!existing || result.confidence > existing.confidence) {
+      seen.set(key, result);
+    }
+  }
+  return Array.from(seen.values());
+}
+function rankResults(results, query) {
+  const tokens = query.toLowerCase().split(/\s+/);
+  return results.map((result) => {
+    let bonus = 0;
+    if (result.source === "registry") bonus += 0.2;
+    else if (result.source === "github") bonus += 0.05;
+    const name = (result.skill.name ?? "").toLowerCase();
+    for (const token of tokens) {
+      if (name.includes(token)) bonus += 0.15;
+    }
+    const tags = (result.skill.tags ?? []).map((t) => t.toLowerCase());
+    for (const token of tokens) {
+      if (tags.includes(token)) bonus += 0.1;
+    }
+    return {
+      ...result,
+      confidence: Math.min(result.confidence + bonus, 1)
+    };
+  }).sort((a, b) => b.confidence - a.confidence);
+}
+
+// src/trawler/index.ts
+async function trawl(query, options = {}) {
+  const sources = options.sources ?? ["registry", "github"];
+  const maxResults = options.maxResults ?? 10;
+  const searches = [];
+  if (sources.includes("registry")) {
+    searches.push(searchRegistry(query));
+  }
+  if (sources.includes("github")) {
+    searches.push(searchGithub(query));
+  }
+  if (sources.includes("npm")) {
+    searches.push(searchNpm(query));
+  }
+  const allResults = (await Promise.all(searches)).flat();
+  const deduplicated = deduplicateResults(allResults);
+  const ranked = rankResults(deduplicated, query);
+  return ranked.slice(0, maxResults);
+}
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as z2 } from "zod";
+function createSkillliMcpServer() {
+  const server = new McpServer({
+    name: "skillli",
+    version: "0.1.0"
+  });
+  server.tool(
+    "search_skills",
+    "Search the skillli registry for agentic AI skills",
+    {
+      query: z2.string().describe("Search query"),
+      tags: z2.array(z2.string()).optional().describe("Filter by tags"),
+      category: z2.string().optional().describe("Filter by category"),
+      limit: z2.number().optional().default(10).describe("Max results")
+    },
+    async ({ query, tags, category, limit }) => {
+      const index = await getLocalIndex();
+      const results = search(index, {
+        query,
+        tags,
+        category,
+        limit
+      });
+      const text = results.length === 0 ? "No skills found matching your query." : results.map((r) => {
+        const s = r.skill;
+        return `**${s.name}** v${s.version} [${s.trustLevel.toUpperCase()}]
+  ${s.description}
+  Rating: ${s.rating.average}/5 (${s.rating.count}) | Downloads: ${s.downloads}
+  Tags: ${s.tags.join(", ")}`;
+      }).join("\n\n");
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  server.tool(
+    "install_skill",
+    "Install an agentic skill from the skillli registry",
+    {
+      name: z2.string().describe("Skill name to install"),
+      link: z2.boolean().optional().default(true).describe("Link to .claude/skills/")
+    },
+    async ({ name, link }) => {
+      try {
+        const installed = await installFromRegistry(name);
+        let text = `Installed ${installed.name} v${installed.version} at ${installed.path}`;
+        if (link) {
+          const linkPath = await linkToClaudeSkills(installed);
+          text += `
+Linked to ${linkPath}`;
+        }
+        return { content: [{ type: "text", text }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Install failed: ${error}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "get_skill_info",
+    "Get detailed information about a skill including trust score",
+    {
+      name: z2.string().describe("Skill name")
+    },
+    async ({ name }) => {
+      try {
+        const entry = await getSkillEntry(name);
+        const text = [
+          `**${entry.name}** v${entry.version} [${entry.trustLevel.toUpperCase()}]`,
+          `${entry.description}`,
+          `Author: ${entry.author}`,
+          `Category: ${entry.category}`,
+          `Tags: ${entry.tags.join(", ")}`,
+          `Rating: ${entry.rating.average}/5 (${entry.rating.count} ratings)`,
+          `Downloads: ${entry.downloads}`,
+          entry.repository ? `Repository: ${entry.repository}` : null,
+          `Published: ${entry.publishedAt}`,
+          `Updated: ${entry.updatedAt}`
+        ].filter(Boolean).join("\n");
+        return { content: [{ type: "text", text }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "trawl_skills",
+    "Agentic search across multiple sources (registry, GitHub, npm) for skills matching a need",
+    {
+      query: z2.string().describe("What kind of skill you need"),
+      sources: z2.array(z2.enum(["registry", "github", "npm"])).optional().default(["registry", "github"]),
+      maxResults: z2.number().optional().default(5)
+    },
+    async ({ query, sources, maxResults }) => {
+      const results = await trawl(query, { sources, maxResults });
+      if (results.length === 0) {
+        return { content: [{ type: "text", text: "No skills found across any source." }] };
+      }
+      const text = results.map((r) => {
+        const conf = Math.round(r.confidence * 100);
+        return `**${r.skill.name ?? "unknown"}** [${r.source}] (${conf}% match)
+  ${r.skill.description ?? ""}
+  ${r.url}`;
+      }).join("\n\n");
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  server.tool(
+    "rate_skill",
+    "Rate an installed skill (1-5 stars)",
+    {
+      name: z2.string().describe("Skill name to rate"),
+      rating: z2.number().min(1).max(5).describe("Rating 1-5"),
+      comment: z2.string().optional().describe("Optional review comment")
+    },
+    async ({ name, rating, comment }) => {
+      try {
+        const updated = await submitRating(name, rating, "mcp-user", comment);
+        return {
+          content: [
+            { type: "text", text: `Rated ${name}: ${formatRating(updated)}` }
+          ]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Rating failed: ${error}` }], isError: true };
+      }
+    }
+  );
+  server.resource(
+    "installed-skills",
+    "skillli://installed",
+    { description: "List of all currently installed skillli skills" },
+    async () => {
+      const skills = await getInstalledSkills();
+      return {
+        contents: [
+          {
+            uri: "skillli://installed",
+            mimeType: "application/json",
+            text: JSON.stringify(skills, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.resource(
+    "skill-index",
+    "skillli://index",
+    { description: "The full skillli registry index" },
+    async () => {
+      const index = await getLocalIndex();
+      return {
+        contents: [
+          {
+            uri: "skillli://index",
+            mimeType: "application/json",
+            text: JSON.stringify(index, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  return server;
+}
+export {
+  SkillMetadataSchema,
+  VERSION,
+  computeTrustScore,
+  createSkillliMcpServer,
+  extractManifest,
+  fetchIndex,
+  formatRating,
+  getConfig,
+  getInstalledSkills,
+  getLocalIndex,
+  getRatings,
+  getSkillEntry,
+  installFromGithub,
+  installFromLocal,
+  installFromRegistry,
+  linkToClaudeSkills,
+  packageSkill,
+  parseSkillContent,
+  parseSkillFile,
+  runSafeguards,
+  search,
+  searchByCategory,
+  searchByTags,
+  submitRating,
+  syncIndex,
+  trawl,
+  uninstall,
+  validateMetadata
+};
+//# sourceMappingURL=index.js.map