trusttools 1.0.0

package/dist/index.js

@@ -0,0 +1,1635 @@
+#!/usr/bin/env node
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+// src/index.ts
+import { Command } from "commander";
+import chalk9 from "chalk";
+import { render as render3 } from "ink";
+import React5 from "react";
+
+// src/commands/add.ts
+import fs5 from "fs";
+import path6 from "path";
+import simpleGit from "simple-git";
+import chalk2 from "chalk";
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var Logger = class {
+  currentTask = null;
+  start(message) {
+    this.currentTask = message;
+    process.stdout.write(chalk.cyan(`\u23F3 ${message}
+`));
+  }
+  succeed(message) {
+    const msg = message || this.currentTask || "Done";
+    process.stdout.write(chalk.green(`\u2714 ${msg}
+`));
+    this.currentTask = null;
+  }
+  fail(message) {
+    const msg = message || this.currentTask || "Failed";
+    process.stdout.write(chalk.red(`\u2716 ${msg}
+`));
+    this.currentTask = null;
+  }
+  info(message) {
+    console.log(chalk.blue(`\u2139 ${message}`));
+  }
+  warn(message) {
+    console.log(chalk.yellow(`\u26A0 ${message}`));
+  }
+  error(message) {
+    console.log(chalk.red(`\u2716 ${message}`));
+  }
+};
+function createLogger() {
+  return new Logger();
+}
+
+// src/utils/source.ts
+function parseSource(source) {
+  source = source.trim().replace(/\/+$/, "");
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    const url = new URL(source);
+    if (url.hostname === "github.com") {
+      const parts2 = url.pathname.split("/").filter(Boolean);
+      if (parts2.length >= 2) {
+        return {
+          type: "github",
+          value: source,
+          owner: parts2[0],
+          repo: parts2[1].replace(".git", ""),
+          path: parts2.length > 2 ? parts2.slice(2).join("/") : void 0
+        };
+      }
+    }
+    return {
+      type: "url",
+      value: source
+    };
+  }
+  if (source.startsWith(".") || source.startsWith("/")) {
+    return {
+      type: "local",
+      value: source
+    };
+  }
+  const parts = source.split("/");
+  if (parts.length >= 2) {
+    return {
+      type: "github",
+      value: source,
+      owner: parts[0],
+      repo: parts[1],
+      path: parts.length > 2 ? parts.slice(2).join("/") : void 0
+    };
+  }
+  return {
+    type: "search",
+    value: source
+  };
+}
+function getGitHubCloneUrl(source) {
+  if (source.type !== "github" || !source.owner || !source.repo) {
+    return null;
+  }
+  return `https://github.com/${source.owner}/${source.repo}.git`;
+}
+
+// src/utils/parser.ts
+import fs from "fs";
+import path2 from "path";
+import matter from "gray-matter";
+function parseSkillFile(filePath, source) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const { data, content: markdownContent } = matter(content);
+    if (!data.name || !data.description) {
+      console.warn(`Skipping ${filePath}: missing required fields (name, description)`);
+      return null;
+    }
+    return {
+      metadata: data,
+      content: markdownContent,
+      path: filePath,
+      source
+    };
+  } catch (error) {
+    console.error(`Error parsing ${filePath}:`, error);
+    return null;
+  }
+}
+function discoverSkills(dir, source) {
+  const skills = [];
+  const rootSkillPath = path2.join(dir, "SKILL.md");
+  if (fs.existsSync(rootSkillPath)) {
+    const skill = parseSkillFile(rootSkillPath, source);
+    if (skill) skills.push(skill);
+  }
+  const skillsDir = path2.join(dir, "skills");
+  if (fs.existsSync(skillsDir) && fs.statSync(skillsDir).isDirectory()) {
+    const entries = fs.readdirSync(skillsDir);
+    for (const entry of entries) {
+      const entryPath = path2.join(skillsDir, entry);
+      const stat = fs.statSync(entryPath);
+      if (stat.isDirectory()) {
+        const skillPath = path2.join(entryPath, "SKILL.md");
+        if (fs.existsSync(skillPath)) {
+          const skill = parseSkillFile(skillPath, source);
+          if (skill) skills.push(skill);
+        }
+      } else if (entry === "SKILL.md") {
+        const skill = parseSkillFile(entryPath, source);
+        if (skill) skills.push(skill);
+      }
+    }
+  }
+  const recursiveSearch = (currentDir, depth = 0, maxDepth = 2) => {
+    if (depth > maxDepth) return;
+    try {
+      const entries = fs.readdirSync(currentDir);
+      for (const entry of entries) {
+        if (entry.startsWith(".") || entry === "node_modules") continue;
+        const entryPath = path2.join(currentDir, entry);
+        const stat = fs.statSync(entryPath);
+        if (stat.isDirectory() && entryPath !== skillsDir) {
+          const skillPath = path2.join(entryPath, "SKILL.md");
+          if (fs.existsSync(skillPath)) {
+            const skill = parseSkillFile(skillPath, source);
+            if (skill) skills.push(skill);
+          }
+          recursiveSearch(entryPath, depth + 1, maxDepth);
+        }
+      }
+    } catch (error) {
+    }
+  };
+  recursiveSearch(dir);
+  return skills;
+}
+
+// src/utils/agents.ts
+import * as path3 from "path";
+import * as fs2 from "fs";
+import * as os from "os";
+function getAllAgents(cwd = process.cwd()) {
+  const homeDir = os.homedir();
+  const agents = [
+    {
+      type: "adal",
+      name: "AdaL",
+      detected: false,
+      skillsPath: path3.join(cwd, ".adal", "skills"),
+      globalPath: path3.join(homeDir, ".adal", "skills")
+    },
+    {
+      type: "amp",
+      name: "Amp",
+      detected: false,
+      skillsPath: path3.join(cwd, ".agents", "skills"),
+      globalPath: path3.join(homeDir, ".agents", "skills"),
+      isUniversal: true
+    },
+    {
+      type: "antigravity",
+      name: "Antigravity",
+      detected: false,
+      skillsPath: path3.join(cwd, ".agent", "skills"),
+      globalPath: path3.join(homeDir, ".gemini", "antigravity", "skills")
+    },
+    {
+      type: "augment",
+      name: "Augment",
+      detected: false,
+      skillsPath: path3.join(cwd, ".augment", "rules"),
+      globalPath: path3.join(homeDir, ".augment", "rules")
+    },
+    {
+      type: "claude-code",
+      name: "Claude Code",
+      detected: false,
+      skillsPath: path3.join(cwd, ".claude", "skills"),
+      globalPath: path3.join(homeDir, ".claude", "skills")
+    },
+    {
+      type: "cline",
+      name: "Cline",
+      detected: false,
+      skillsPath: path3.join(cwd, ".cline", "skills"),
+      globalPath: path3.join(homeDir, ".cline", "skills")
+    },
+    {
+      type: "codebuddy",
+      name: "CodeBuddy",
+      detected: false,
+      skillsPath: path3.join(cwd, ".codebuddy", "skills"),
+      globalPath: path3.join(homeDir, ".codebuddy", "skills")
+    },
+    {
+      type: "codex",
+      name: "Codex",
+      detected: false,
+      skillsPath: path3.join(cwd, ".agents", "skills"),
+      globalPath: path3.join(homeDir, ".agents", "skills"),
+      isUniversal: true
+    },
+    {
+      type: "command-code",
+      name: "Command Code",
+      detected: false,
+      skillsPath: path3.join(cwd, ".commandcode", "skills"),
+      globalPath: path3.join(homeDir, ".commandcode", "skills")
+    },
+    {
+      type: "continue",
+      name: "Continue",
+      detected: false,
+      skillsPath: path3.join(cwd, ".continue", "skills"),
+      globalPath: path3.join(homeDir, ".continue", "skills")
+    },
+    {
+      type: "cortex",
+      name: "Cortex Code",
+      detected: false,
+      skillsPath: path3.join(cwd, ".cortex", "skills"),
+      globalPath: path3.join(homeDir, ".snowflake", "cortex", "skills")
+    },
+    {
+      type: "crush",
+      name: "Crush",
+      detected: false,
+      skillsPath: path3.join(cwd, ".crush", "skills"),
+      globalPath: path3.join(homeDir, ".config", "crush", "skills")
+    },
+    {
+      type: "cursor",
+      name: "Cursor",
+      detected: false,
+      skillsPath: path3.join(cwd, ".agents", "skills"),
+      globalPath: path3.join(homeDir, ".cursor", "skills"),
+      isUniversal: true
+    },
+    {
+      type: "droid",
+      name: "Droid",
+      detected: false,
+      skillsPath: path3.join(cwd, ".agents", "skills"),
+      globalPath: path3.join(homeDir, ".agents", "skills"),
+      isUniversal: true
+    },
+    {
+      type: "gemini-cli",
+      name: "Gemini CLI",
+      detected: false,
+      skillsPath: path3.join(cwd, ".agents", "skills"),
+      globalPath: path3.join(homeDir, ".agents", "skills"),
+      isUniversal: true
+    },
+    {
+      type: "github-copilot",
+      name: "GitHub Copilot",
+      detected: false,
+      skillsPath: path3.join(cwd, ".agents", "skills"),
+      globalPath: path3.join(homeDir, ".agents", "skills"),
+      isUniversal: true
+    },
+    {
+      type: "goose",
+      name: "Goose",
+      detected: false,
+      skillsPath: path3.join(cwd, ".goose", "skills"),
+      globalPath: path3.join(homeDir, ".config", "goose", "skills")
+    },
+    {
+      type: "iflow-cli",
+      name: "iFlow CLI",
+      detected: false,
+      skillsPath: path3.join(cwd, ".iflow", "skills"),
+      globalPath: path3.join(homeDir, ".iflow", "skills")
+    },
+    {
+      type: "junie",
+      name: "Junie",
+      detected: false,
+      skillsPath: path3.join(cwd, ".junie", "skills"),
+      globalPath: path3.join(homeDir, ".junie", "skills")
+    },
+    {
+      type: "kilo",
+      name: "Kilo Code",
+      detected: false,
+      skillsPath: path3.join(cwd, ".kilocode", "skills"),
+      globalPath: path3.join(homeDir, ".kilocode", "skills")
+    },
+    {
+      type: "kimi-cli",
+      name: "Kimi Code CLI",
+      detected: false,
+      skillsPath: path3.join(cwd, ".agents", "skills"),
+      globalPath: path3.join(homeDir, ".agents", "skills"),
+      isUniversal: true
+    },
+    {
+      type: "kiro-cli",
+      name: "Kiro CLI",
+      detected: false,
+      skillsPath: path3.join(cwd, ".kiro", "skills"),
+      globalPath: path3.join(homeDir, ".kiro", "skills")
+    },
+    {
+      type: "kode",
+      name: "Kode",
+      detected: false,
+      skillsPath: path3.join(cwd, ".kode", "skills"),
+      globalPath: path3.join(homeDir, ".kode", "skills")
+    },
+    {
+      type: "mcpjam",
+      name: "MCPJam",
+      detected: false,
+      skillsPath: path3.join(cwd, ".mcpjam", "skills"),
+      globalPath: path3.join(homeDir, ".mcpjam", "skills")
+    },
+    {
+      type: "mistral-vibe",
+      name: "Mistral Vibe",
+      detected: false,
+      skillsPath: path3.join(cwd, ".vibe", "skills"),
+      globalPath: path3.join(homeDir, ".vibe", "skills")
+    },
+    {
+      type: "mux",
+      name: "Mux",
+      detected: false,
+      skillsPath: path3.join(cwd, ".mux", "skills"),
+      globalPath: path3.join(homeDir, ".mux", "skills")
+    },
+    {
+      type: "neovate",
+      name: "Neovate",
+      detected: false,
+      skillsPath: path3.join(cwd, ".neovate", "skills"),
+      globalPath: path3.join(homeDir, ".neovate", "skills")
+    },
+    {
+      type: "openclaw",
+      name: "OpenClaw",
+      detected: false,
+      skillsPath: path3.join(cwd, "skills"),
+      globalPath: path3.join(homeDir, ".openclaw", "skills")
+    },
+    {
+      type: "opencode",
+      name: "OpenCode",
+      detected: false,
+      skillsPath: path3.join(cwd, ".agents", "skills"),
+      globalPath: path3.join(homeDir, ".agents", "skills"),
+      isUniversal: true
+    },
+    {
+      type: "openhands",
+      name: "OpenHands",
+      detected: false,
+      skillsPath: path3.join(cwd, ".openhands", "skills"),
+      globalPath: path3.join(homeDir, ".openhands", "skills")
+    },
+    {
+      type: "pi",
+      name: "Pi",
+      detected: false,
+      skillsPath: path3.join(cwd, ".pi", "skills"),
+      globalPath: path3.join(homeDir, ".pi", "agent", "skills")
+    },
+    {
+      type: "pochi",
+      name: "Pochi",
+      detected: false,
+      skillsPath: path3.join(cwd, ".pochi", "skills"),
+      globalPath: path3.join(homeDir, ".pochi", "skills")
+    },
+    {
+      type: "qoder",
+      name: "Qoder",
+      detected: false,
+      skillsPath: path3.join(cwd, ".qoder", "skills"),
+      globalPath: path3.join(homeDir, ".qoder", "skills")
+    },
+    {
+      type: "qwen-code",
+      name: "Qwen Code",
+      detected: false,
+      skillsPath: path3.join(cwd, ".qwen", "skills"),
+      globalPath: path3.join(homeDir, ".qwen", "skills")
+    },
+    {
+      type: "replit",
+      name: "Replit",
+      detected: false,
+      skillsPath: path3.join(cwd, ".agents", "skills"),
+      isUniversal: true
+    },
+    {
+      type: "roo",
+      name: "Roo Code",
+      detected: false,
+      skillsPath: path3.join(cwd, ".roo", "skills"),
+      globalPath: path3.join(homeDir, ".roo", "skills")
+    },
+    {
+      type: "trae",
+      name: "Trae",
+      detected: false,
+      skillsPath: path3.join(cwd, ".trae", "skills"),
+      globalPath: path3.join(homeDir, ".trae", "skills")
+    },
+    {
+      type: "trae-cn",
+      name: "Trae CN",
+      detected: false,
+      skillsPath: path3.join(cwd, ".trae", "skills"),
+      globalPath: path3.join(homeDir, ".trae-cn", "skills")
+    },
+    {
+      type: "windsurf",
+      name: "Windsurf",
+      detected: false,
+      skillsPath: path3.join(cwd, ".windsurf", "skills"),
+      globalPath: path3.join(homeDir, ".codeium", "windsurf", "skills")
+    },
+    {
+      type: "zencoder",
+      name: "Zencoder",
+      detected: false,
+      skillsPath: path3.join(cwd, ".zencoder", "skills"),
+      globalPath: path3.join(homeDir, ".zencoder", "skills")
+    },
+    {
+      type: "universal",
+      name: "Universal",
+      detected: false,
+      skillsPath: path3.join(cwd, ".agents", "skills"),
+      globalPath: path3.join(homeDir, ".agents", "skills"),
+      isUniversal: true
+    }
+  ];
+  return agents;
+}
+function detectAgents(cwd = process.cwd()) {
+  const agents = getAllAgents(cwd);
+  for (const agent of agents) {
+    const agentDir = path3.dirname(agent.skillsPath);
+    agent.detected = fs2.existsSync(agentDir);
+  }
+  return agents;
+}
+function getUniversalSkillsPath(cwd = process.cwd()) {
+  return path3.join(cwd, ".agents", "skills");
+}
+function ensureUniversalSkillsDir(cwd = process.cwd()) {
+  const skillsPath = getUniversalSkillsPath(cwd);
+  if (!fs2.existsSync(skillsPath)) {
+    fs2.mkdirSync(skillsPath, { recursive: true });
+  }
+  return skillsPath;
+}
+
+// src/utils/symlink.ts
+import fs3 from "fs";
+import path4 from "path";
+function createSymlink(target, linkPath, type = "dir") {
+  try {
+    if (fs3.existsSync(linkPath)) {
+      const stats = fs3.lstatSync(linkPath);
+      if (stats.isSymbolicLink()) {
+        const existingTarget = fs3.readlinkSync(linkPath);
+        if (existingTarget === target) {
+          return true;
+        }
+        fs3.unlinkSync(linkPath);
+      } else {
+        console.warn(`Path exists but is not a symlink: ${linkPath}`);
+        return false;
+      }
+    }
+    const parentDir = path4.dirname(linkPath);
+    if (!fs3.existsSync(parentDir)) {
+      fs3.mkdirSync(parentDir, { recursive: true });
+    }
+    fs3.symlinkSync(target, linkPath, type);
+    return true;
+  } catch (error) {
+    if (error.code === "EPERM" && process.platform === "win32") {
+      console.error(
+        "Permission denied. On Windows, you need to either:\n1. Run as Administrator, or\n2. Enable Developer Mode in Windows Settings"
+      );
+    } else {
+      console.error(`Failed to create symlink: ${error.message}`);
+    }
+    return false;
+  }
+}
+function linkSkillToAgents(skillName, universalPath, agents) {
+  const linked = [];
+  const skillSource = path4.join(universalPath, skillName);
+  for (const agent of agents) {
+    const linkPath = path4.join(agent.skillsPath, skillName);
+    if (!fs3.existsSync(agent.skillsPath)) {
+      fs3.mkdirSync(agent.skillsPath, { recursive: true });
+    }
+    if (createSymlink(skillSource, linkPath, "dir")) {
+      linked.push(agent.type);
+    }
+  }
+  return {
+    success: linked.length > 0,
+    linked
+  };
+}
+
+// src/utils/analytics.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+import * as os2 from "os";
+import * as crypto from "crypto";
+var ANALYTICS_DIR = path5.join(os2.homedir(), ".trusttools");
+var ANALYTICS_FILE = path5.join(ANALYTICS_DIR, "analytics.json");
+var MACHINE_ID_FILE = path5.join(ANALYTICS_DIR, "machine-id");
+var ANALYTICS_ENABLED_FILE = path5.join(ANALYTICS_DIR, "analytics-enabled");
+function getMachineId() {
+  try {
+    if (fs4.existsSync(MACHINE_ID_FILE)) {
+      return fs4.readFileSync(MACHINE_ID_FILE, "utf-8").trim();
+    }
+    const machineId = crypto.randomUUID();
+    ensureAnalyticsDir();
+    fs4.writeFileSync(MACHINE_ID_FILE, machineId, "utf-8");
+    return machineId;
+  } catch (error) {
+    return "unknown";
+  }
+}
+function isAnalyticsEnabled() {
+  try {
+    if (process.env.SKILLSMAP_ANALYTICS === "false") {
+      return false;
+    }
+    if (fs4.existsSync(ANALYTICS_ENABLED_FILE)) {
+      const enabled = fs4.readFileSync(ANALYTICS_ENABLED_FILE, "utf-8").trim();
+      return enabled === "true";
+    }
+    return true;
+  } catch (error) {
+    return true;
+  }
+}
+function ensureAnalyticsDir() {
+  if (!fs4.existsSync(ANALYTICS_DIR)) {
+    fs4.mkdirSync(ANALYTICS_DIR, { recursive: true });
+  }
+}
+function loadInstallationRecords() {
+  try {
+    if (!fs4.existsSync(ANALYTICS_FILE)) {
+      return [];
+    }
+    const data = fs4.readFileSync(ANALYTICS_FILE, "utf-8");
+    return JSON.parse(data);
+  } catch (error) {
+    return [];
+  }
+}
+function saveInstallationRecords(records) {
+  ensureAnalyticsDir();
+  fs4.writeFileSync(ANALYTICS_FILE, JSON.stringify(records, null, 2), "utf-8");
+}
+function trackInstallation(skillName, skillSlug, source, sourceType, agents, isGlobal, version) {
+  const record = {
+    id: crypto.randomUUID(),
+    skillName,
+    skillSlug,
+    source,
+    sourceType,
+    agents,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    isGlobal,
+    machineId: getMachineId(),
+    version
+  };
+  const records = loadInstallationRecords();
+  records.push(record);
+  saveInstallationRecords(records);
+  if (isAnalyticsEnabled()) {
+    sendAnalytics("install", record).catch(() => {
+    });
+  }
+  return record;
+}
+function trackRemoval(skillName, skillSlug, agents) {
+  const record = {
+    id: crypto.randomUUID(),
+    skillName,
+    skillSlug,
+    source: "",
+    sourceType: "local",
+    agents,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    isGlobal: false,
+    machineId: getMachineId()
+  };
+  if (isAnalyticsEnabled()) {
+    sendAnalytics("remove", record).catch(() => {
+    });
+  }
+}
+async function sendAnalytics(event, record) {
+  try {
+    const payload = {
+      event,
+      skillName: record.skillName,
+      skillSlug: record.skillSlug,
+      source: record.source,
+      sourceType: record.sourceType,
+      agents: record.agents,
+      timestamp: record.timestamp,
+      isGlobal: record.isGlobal,
+      machineId: record.machineId,
+      version: record.version,
+      cliVersion: getCliVersion()
+    };
+    const analyticsUrl = process.env.SKILLSMAP_ANALYTICS_URL || "http://localhost:8000/api/analytics/track";
+    const response = await fetch(analyticsUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`Analytics request failed: ${response.status}`);
+    }
+  } catch (error) {
+    console.debug("Analytics error:", error);
+  }
+}
+function getCliVersion() {
+  try {
+    const packageJsonPath = path5.join(__dirname, "../../package.json");
+    const packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.version || "1.0.0";
+  } catch (error) {
+    return "1.0.0";
+  }
+}
+function getInstallationStats() {
+  const records = loadInstallationRecords();
+  const skillsByAgent = {};
+  const skillCounts = {};
+  records.forEach((record) => {
+    record.agents.forEach((agent) => {
+      skillsByAgent[agent] = (skillsByAgent[agent] || 0) + 1;
+    });
+    skillCounts[record.skillSlug] = (skillCounts[record.skillSlug] || 0) + 1;
+  });
+  const topSkills = Object.entries(skillCounts).map(([name, count]) => ({ name, count })).sort((a, b) => b.count - a.count).slice(0, 10);
+  const recentInstalls = records.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()).slice(0, 20);
+  return {
+    totalInstalls: records.length,
+    skillsByAgent,
+    topSkills,
+    recentInstalls
+  };
+}
+
+// src/commands/add.ts
+async function addSkill(source, options = {}) {
+  const cwd = process.cwd();
+  const logger = createLogger();
+  logger.start("Parsing source...");
+  try {
+    const parsedSource = parseSource(source);
+    logger.succeed("Source parsed: " + parsedSource.type);
+    let skillsDir;
+    let tempDir = null;
+    if (parsedSource.type === "github") {
+      logger.start("Cloning repository...");
+      const cloneUrl = getGitHubCloneUrl(parsedSource);
+      if (!cloneUrl) {
+        throw new Error("Invalid GitHub URL");
+      }
+      tempDir = path6.join(cwd, ".tmp", `${parsedSource.owner}-${parsedSource.repo}`);
+      if (fs5.existsSync(tempDir)) {
+        fs5.rmSync(tempDir, { recursive: true, force: true });
+      }
+      fs5.mkdirSync(tempDir, { recursive: true });
+      const git = simpleGit();
+      await git.clone(cloneUrl, tempDir, ["--depth", "1"]);
+      skillsDir = parsedSource.path ? path6.join(tempDir, parsedSource.path) : tempDir;
+      logger.succeed("Repository cloned");
+    } else if (parsedSource.type === "local") {
+      skillsDir = path6.resolve(cwd, parsedSource.value);
+      if (!fs5.existsSync(skillsDir)) {
+        throw new Error(`Local path not found: ${skillsDir}`);
+      }
+      logger.succeed("Local path found");
+    } else {
+      throw new Error(`Unsupported source type: ${parsedSource.type}`);
+    }
+    logger.start("Discovering skills...");
+    let skills = discoverSkills(skillsDir, source);
+    if (skills.length === 0) {
+      logger.fail("No valid skills found");
+      console.log(chalk2.yellow("\nA valid skill must have a SKILL.md file with:"));
+      console.log(chalk2.yellow("  - name: <skill name>"));
+      console.log(chalk2.yellow("  - description: <description>"));
+      return;
+    }
+    if (options.skill) {
+      const skillFilter = options.skill.toLowerCase();
+      skills = skills.filter(
+        (s) => s.metadata.name.toLowerCase().replace(/\s+/g, "-") === skillFilter || s.metadata.name.toLowerCase() === skillFilter
+      );
+      if (skills.length === 0) {
+        logger.fail(`No skill found matching: ${options.skill}`);
+        console.log(chalk2.yellow("\nAvailable skills:"));
+        const allSkills = discoverSkills(skillsDir, source);
+        allSkills.forEach((s) => {
+          console.log(chalk2.gray(`  - ${s.metadata.name.toLowerCase().replace(/\s+/g, "-")}`));
+        });
+        return;
+      }
+      logger.succeed(`Found skill: ${skills[0].metadata.name}`);
+    } else {
+      logger.succeed(`Found ${skills.length} skill(s)`);
+    }
+    const universalPath = ensureUniversalSkillsDir(cwd);
+    const agents = detectAgents(cwd);
+    const detectedAgents = agents.filter((a) => a.detected);
+    if (detectedAgents.length === 0) {
+      console.log(chalk2.yellow("\nNo AI agents detected in current directory."));
+      console.log(chalk2.yellow("Looking for: .cursor, .claude, .windsurf"));
+    } else {
+      console.log(chalk2.green(`
+Detected agents: ${detectedAgents.map((a) => a.type).join(", ")}`));
+    }
+    for (const skill of skills) {
+      logger.start(`Installing ${skill.metadata.name}...`);
+      const skillName = skill.metadata.name.toLowerCase().replace(/\s+/g, "-");
+      const skillDestDir = path6.join(universalPath, skillName);
+      const skillSourceDir = path6.dirname(skill.path);
+      if (fs5.existsSync(skillDestDir)) {
+        fs5.rmSync(skillDestDir, { recursive: true, force: true });
+      }
+      fs5.mkdirSync(skillDestDir, { recursive: true });
+      copyDirectory(skillSourceDir, skillDestDir);
+      const sourceFile = path6.join(skillDestDir, ".source");
+      fs5.writeFileSync(sourceFile, source, "utf-8");
+      console.log(chalk2.cyan(`  Linking ${skill.metadata.name} to agents...`));
+      const { success, linked } = linkSkillToAgents(skillName, universalPath, detectedAgents);
+      if (success) {
+        logger.succeed(
+          `${skill.metadata.name} installed and linked to: ${linked.join(", ")}`
+        );
+      } else {
+        logger.warn(
+          `${skill.metadata.name} installed but not linked (no agents detected)`
+        );
+      }
+      console.log(chalk2.gray(`  Location: ${skillDestDir}`));
+      trackInstallation(
+        skill.metadata.name,
+        skillName,
+        source,
+        parsedSource.type,
+        linked.map((a) => a),
+        options.global || false,
+        skill.metadata.version
+      );
+    }
+    if (tempDir && fs5.existsSync(tempDir)) {
+      fs5.rmSync(tempDir, { recursive: true, force: true });
+    }
+    console.log(chalk2.green("\n\u2713 All skills installed successfully!"));
+  } catch (error) {
+    logger.fail("Installation failed");
+    console.error(chalk2.red(`
+Error: ${error.message}`));
+    throw error;
+  }
+}
+function copyDirectory(src, dest) {
+  if (!fs5.existsSync(dest)) {
+    fs5.mkdirSync(dest, { recursive: true });
+  }
+  const entries = fs5.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path6.join(src, entry.name);
+    const destPath = path6.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectory(srcPath, destPath);
+    } else {
+      fs5.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// src/commands/list.ts
+import fs6 from "fs";
+import path7 from "path";
+import chalk3 from "chalk";
+function listSkills() {
+  const cwd = process.cwd();
+  const universalPath = getUniversalSkillsPath(cwd);
+  if (!fs6.existsSync(universalPath)) {
+    console.log(chalk3.yellow("No skills installed yet."));
+    console.log(chalk3.gray(`Run 'trusttools add <source>' to install skills.`));
+    return;
+  }
+  const entries = fs6.readdirSync(universalPath);
+  const skills = entries.filter((entry) => {
+    const entryPath = path7.join(universalPath, entry);
+    return fs6.statSync(entryPath).isDirectory();
+  });
+  if (skills.length === 0) {
+    console.log(chalk3.yellow("No skills installed yet."));
+    return;
+  }
+  console.log(chalk3.bold(`
+\u{1F4E6} Installed Skills (${skills.length}):
+`));
+  for (const skillDir of skills) {
+    const skillPath = path7.join(universalPath, skillDir);
+    const skillMdPath = path7.join(skillPath, "SKILL.md");
+    if (fs6.existsSync(skillMdPath)) {
+      const skill = parseSkillFile(skillMdPath, "local");
+      if (skill) {
+        console.log(chalk3.green(`  \u2713 ${skill.metadata.name}`));
+        console.log(chalk3.gray(`    ${skill.metadata.description}`));
+        if (skill.metadata.version) {
+          console.log(chalk3.gray(`    Version: ${skill.metadata.version}`));
+        }
+        if (skill.metadata.tags && skill.metadata.tags.length > 0) {
+          console.log(chalk3.gray(`    Tags: ${skill.metadata.tags.join(", ")}`));
+        }
+        console.log(chalk3.gray(`    Path: ${skillPath}`));
+        console.log();
+      }
+    } else {
+      console.log(chalk3.yellow(`  \u26A0 ${skillDir} (no SKILL.md found)`));
+      console.log();
+    }
+  }
+}
+
+// src/commands/find.ts
+import fs7 from "fs";
+import path8 from "path";
+import simpleGit2 from "simple-git";
+import chalk4 from "chalk";
+import { render } from "ink";
+import React2 from "react";
+
+// src/ui/SkillSelector.tsx
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+var SkillSelector = ({ skills, onSelect, onCancel }) => {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  useInput((input, key) => {
+    if (key.upArrow) {
+      setSelectedIndex((prev) => Math.max(0, prev - 1));
+    } else if (key.downArrow) {
+      setSelectedIndex((prev) => Math.min(skills.length - 1, prev + 1));
+    } else if (key.return) {
+      onSelect(skills[selectedIndex]);
+    } else if (key.escape || input === "q") {
+      onCancel();
+    }
+  });
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true, color: "cyan" }, "\u{1F4E6} Found ", skills.length, " skill(s). Use \u2191\u2193 to navigate, Enter to select, Esc to cancel:")), skills.map((skill, index) => {
+    const getSecurityColor = (score) => {
+      if (!score) return "gray";
+      if (score >= 81) return "green";
+      if (score >= 61) return "yellow";
+      if (score >= 41) return "yellow";
+      if (score >= 21) return "red";
+      return "red";
+    };
+    const getSecurityLabel = (score) => {
+      if (!score) return "?";
+      if (score >= 81) return "\u2713";
+      if (score >= 61) return "\u26A0";
+      if (score >= 41) return "\u26A0";
+      if (score >= 21) return "\u2717";
+      return "\u2717";
+    };
+    return /* @__PURE__ */ React.createElement(Box, { key: index, marginLeft: 2, flexDirection: "column" }, /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { color: index === selectedIndex ? "green" : "white" }, index === selectedIndex ? "\u25B6 " : "  ", /* @__PURE__ */ React.createElement(Text, { bold: true }, skill.metadata.name), skill.metadata.security_score !== void 0 && /* @__PURE__ */ React.createElement(Text, { color: getSecurityColor(skill.metadata.security_score) }, " [", getSecurityLabel(skill.metadata.security_score), " ", skill.metadata.security_score, "]"), skill.metadata.install_count !== void 0 && /* @__PURE__ */ React.createElement(Text, { dimColor: true }, " (\u2193", skill.metadata.install_count, ")"))), /* @__PURE__ */ React.createElement(Box, { marginLeft: 4 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, skill.metadata.description)));
+  }), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, skills[selectedIndex]?.metadata.tags && `Tags: ${skills[selectedIndex].metadata.tags.join(", ")}`)));
+};
+
+// src/commands/find.ts
+import dotenv from "dotenv";
+dotenv.config();
+async function findFromAPI(query) {
+  const logger = createLogger();
+  logger.start(`Searching for "${query}"...`);
+  try {
+    const apiUrl = process.env.TRUSTTOOLS_API_URL || "https://skills.seebug.ai";
+    const response = await fetch(`${apiUrl}/api/skills?search=${encodeURIComponent(query)}&limit=20`);
+    if (!response.ok) {
+      throw new Error(`API request failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!data.success || !data.data || data.data.length === 0) {
+      logger.fail("No skills found");
+      console.log(chalk4.yellow(`
+No skills found for "${query}"`));
+      console.log(chalk4.gray("\nTry different keywords or browse skills at:"));
+      console.log(chalk4.cyan(`  ${apiUrl}`));
+      return;
+    }
+    logger.succeed(`Found ${data.data.length} skill(s)`);
+    const skills = data.data.map((skill) => {
+      let skillPath = skill.repo_path || "";
+      if (skillPath.endsWith("/SKILL.md")) {
+        skillPath = skillPath.slice(0, -9);
+      } else if (skillPath.endsWith("SKILL.md")) {
+        skillPath = skillPath.slice(0, -8);
+      }
+      return {
+        metadata: {
+          name: skill.name,
+          description: skill.description,
+          version: skill.version,
+          author: skill.author,
+          tags: skill.tags || [],
+          security_score: skill.security_score,
+          security_level: skill.security_level,
+          install_count: skill.install_count
+        },
+        content: "",
+        path: skillPath,
+        source: `${skill.repo_owner}/${skill.repo_name}${skillPath ? "/" + skillPath : ""}`
+      };
+    });
+    const { waitUntilExit } = render(
+      React2.createElement(SkillSelector, {
+        skills,
+        onSelect: (skill) => {
+          console.log(chalk4.green(`
+\u2713 Selected: ${skill.metadata.name}`));
+          console.log(chalk4.gray(`
+To install this skill, run:`));
+          console.log(chalk4.cyan(`  trusttools add ${skill.source}`));
+          process.exit(0);
+        },
+        onCancel: () => {
+          console.log(chalk4.yellow("\nCancelled"));
+          process.exit(0);
+        }
+      })
+    );
+    await waitUntilExit();
+  } catch (error) {
+    logger.fail("Search failed");
+    console.error(chalk4.red(`
+Error: ${error.message}`));
+    throw error;
+  }
+}
+async function findFromRepository(source, parsedSource) {
+  const cwd = process.cwd();
+  const logger = createLogger();
+  let skillsDir;
+  let tempDir = null;
+  try {
+    if (parsedSource.type === "github") {
+      logger.start("Cloning repository...");
+      const cloneUrl = getGitHubCloneUrl(parsedSource);
+      if (!cloneUrl) {
+        throw new Error("Invalid GitHub URL");
+      }
+      tempDir = path8.join(cwd, ".tmp", `${parsedSource.owner}-${parsedSource.repo}`);
+      if (fs7.existsSync(tempDir)) {
+        fs7.rmSync(tempDir, { recursive: true, force: true });
+      }
+      fs7.mkdirSync(tempDir, { recursive: true });
+      const git = simpleGit2();
+      await git.clone(cloneUrl, tempDir, ["--depth", "1"]);
+      skillsDir = parsedSource.path ? path8.join(tempDir, parsedSource.path) : tempDir;
+      logger.succeed("Repository cloned");
+    } else if (parsedSource.type === "local") {
+      skillsDir = path8.resolve(cwd, parsedSource.value);
+      if (!fs7.existsSync(skillsDir)) {
+        throw new Error(`Local path not found: ${skillsDir}`);
+      }
+      logger.succeed("Local path found");
+    } else {
+      throw new Error(`Unsupported source type: ${parsedSource.type}`);
+    }
+    logger.start("Discovering skills...");
+    const skills = discoverSkills(skillsDir, source);
+    if (skills.length === 0) {
+      logger.fail("No valid skills found");
+      console.log(chalk4.yellow("\nA valid skill must have a SKILL.md file with:"));
+      console.log(chalk4.yellow("  - name: <skill name>"));
+      console.log(chalk4.yellow("  - description: <description>"));
+      if (tempDir && fs7.existsSync(tempDir)) {
+        fs7.rmSync(tempDir, { recursive: true, force: true });
+      }
+      return;
+    }
+    logger.succeed(`Found ${skills.length} skill(s)`);
+    const { waitUntilExit } = render(
+      React2.createElement(SkillSelector, {
+        skills,
+        onSelect: (skill) => {
+          console.log(chalk4.green(`
+\u2713 Selected: ${skill.metadata.name}`));
+          console.log(chalk4.gray(`
+To install this skill, run:`));
+          console.log(chalk4.cyan(`  trusttools add ${source} --skill ${skill.metadata.name.toLowerCase().replace(/\s+/g, "-")}`));
+          process.exit(0);
+        },
+        onCancel: () => {
+          console.log(chalk4.yellow("\nCancelled"));
+          process.exit(0);
+        }
+      })
+    );
+    await waitUntilExit();
+    if (tempDir && fs7.existsSync(tempDir)) {
+      fs7.rmSync(tempDir, { recursive: true, force: true });
+    }
+  } catch (error) {
+    logger.fail("Failed to find skills");
+    console.error(chalk4.red(`
+Error: ${error.message}`));
+    throw error;
+  }
+}
+async function findSkills(source) {
+  const logger = createLogger();
+  logger.start("Parsing source...");
+  try {
+    const parsedSource = parseSource(source);
+    logger.succeed(`Source parsed: ${parsedSource.type}`);
+    if (parsedSource.type === "search") {
+      await findFromAPI(parsedSource.value);
+    } else {
+      await findFromRepository(source, parsedSource);
+    }
+  } catch (error) {
+    console.error(chalk4.red(`
+Error: ${error.message}`));
+    throw error;
+  }
+}
+
+// src/commands/manage.ts
+import fs8 from "fs";
+import path9 from "path";
+import chalk5 from "chalk";
+import { render as render2 } from "ink";
+import React3 from "react";
+import SelectInput from "ink-select-input";
+import { Box as Box2, Text as Text2 } from "ink";
+async function manageSkills() {
+  const cwd = process.cwd();
+  const universalPath = getUniversalSkillsPath(cwd);
+  if (!fs8.existsSync(universalPath)) {
+    console.log(chalk5.yellow("No skills installed yet."));
+    return;
+  }
+  const skillDirs = fs8.readdirSync(universalPath).filter((item) => {
+    const itemPath = path9.join(universalPath, item);
+    return fs8.statSync(itemPath).isDirectory();
+  });
+  if (skillDirs.length === 0) {
+    console.log(chalk5.yellow("No skills installed yet."));
+    return;
+  }
+  const skills = skillDirs.map((dir) => {
+    const skillPath = path9.join(universalPath, dir);
+    const skillMdPath = path9.join(skillPath, "SKILL.md");
+    let label = dir;
+    if (fs8.existsSync(skillMdPath)) {
+      try {
+        const skill = parseSkillFile(skillMdPath, dir);
+        if (skill) {
+          label = `${skill.metadata.name} (${dir})`;
+        }
+      } catch (error) {
+      }
+    }
+    return { label, value: dir };
+  });
+  skills.push({ label: chalk5.gray("\u2190 Back"), value: "__back__" });
+  console.log(chalk5.cyan("\n\u{1F4CB} Installed Skills:\n"));
+  const { waitUntilExit } = render2(
+    React3.createElement(
+      Box2,
+      { flexDirection: "column", padding: 1 },
+      React3.createElement(Text2, { dimColor: true }, "Select a skill to manage:"),
+      React3.createElement(SelectInput, {
+        items: skills,
+        onSelect: (item) => {
+          if (item.value === "__back__") {
+            process.exit(0);
+          }
+          showActionMenu(item.value, universalPath, cwd).then(() => {
+          });
+        }
+      })
+    )
+  );
+  await waitUntilExit();
+}
+async function showActionMenu(skillSlug, universalPath, cwd) {
+  const actions = [
+    { label: "\u{1F5D1}\uFE0F  Delete", value: "delete" },
+    { label: "\u2139\uFE0F  Show Info", value: "info" },
+    { label: "\u2190 Back", value: "back" }
+  ];
+  const { waitUntilExit, clear } = render2(
+    React3.createElement(
+      Box2,
+      { flexDirection: "column", padding: 1 },
+      React3.createElement(Text2, { bold: true }, `Manage: ${skillSlug}`),
+      React3.createElement(Text2, { dimColor: true }, "\nSelect an action:"),
+      React3.createElement(SelectInput, {
+        items: actions,
+        onSelect: (item) => {
+          clear();
+          if (item.value === "back") {
+            process.exit(0);
+          } else if (item.value === "delete") {
+            deleteSkill(skillSlug, universalPath, cwd).then(() => process.exit(0));
+          } else if (item.value === "info") {
+            showSkillInfo(skillSlug, universalPath).then(() => process.exit(0));
+          }
+        }
+      })
+    )
+  );
+  await waitUntilExit();
+}
+async function deleteSkill(skillSlug, universalPath, cwd) {
+  const logger = createLogger();
+  const skillPath = path9.join(universalPath, skillSlug);
+  logger.start(`Deleting ${skillSlug}...`);
+  try {
+    const agentDirs = [".cursor", ".claude", ".windsurf", ".cline", ".continue", ".goose"];
+    const removedLinks = [];
+    for (const agentDir of agentDirs) {
+      const agentSkillsPath = path9.join(cwd, agentDir, "skills");
+      const linkPath = path9.join(agentSkillsPath, skillSlug);
+      if (fs8.existsSync(linkPath)) {
+        const stats = fs8.lstatSync(linkPath);
+        if (stats.isSymbolicLink()) {
+          fs8.unlinkSync(linkPath);
+          removedLinks.push(agentDir.replace(".", ""));
+        }
+      }
+    }
+    fs8.rmSync(skillPath, { recursive: true, force: true });
+    trackRemoval(skillSlug, skillSlug, removedLinks);
+    logger.succeed(`${skillSlug} deleted successfully`);
+    if (removedLinks.length > 0) {
+      console.log(chalk5.gray(`  Removed from: ${removedLinks.join(", ")}`));
+    }
+  } catch (error) {
+    logger.fail(`Failed to delete ${skillSlug}`);
+    console.error(chalk5.red(`Error: ${error.message}`));
+  }
+}
+async function showSkillInfo(skillSlug, universalPath) {
+  const skillPath = path9.join(universalPath, skillSlug);
+  const skillMdPath = path9.join(skillPath, "SKILL.md");
+  console.log(chalk5.cyan(`
+\u{1F4C4} Skill: ${skillSlug}
+`));
+  console.log(chalk5.gray(`Location: ${skillPath}
+`));
+  if (fs8.existsSync(skillMdPath)) {
+    try {
+      const skill = parseSkillFile(skillMdPath, skillSlug);
+      if (!skill) {
+        console.log(chalk5.yellow("Could not parse SKILL.md"));
+        return;
+      }
+      const { metadata, content } = skill;
+      console.log(chalk5.bold("Metadata:"));
+      console.log(`  Name: ${metadata.name}`);
+      console.log(`  Description: ${metadata.description}`);
+      if (metadata.version) console.log(`  Version: ${metadata.version}`);
+      if (metadata.author) console.log(`  Author: ${metadata.author}`);
+      if (metadata.tags) console.log(`  Tags: ${metadata.tags.join(", ")}`);
+      console.log(chalk5.bold("\nContent Preview:"));
+      const preview = content.split("\n").slice(0, 10).join("\n");
+      console.log(chalk5.gray(preview));
+      if (content.split("\n").length > 10) {
+        console.log(chalk5.gray("..."));
+      }
+    } catch (error) {
+      console.log(chalk5.yellow("Could not parse SKILL.md"));
+    }
+  } else {
+    console.log(chalk5.yellow("No SKILL.md found"));
+  }
+}
+
+// src/commands/update.ts
+import fs9 from "fs";
+import path10 from "path";
+import chalk6 from "chalk";
+async function updateSkills(skillNames) {
+  const cwd = process.cwd();
+  const universalPath = getUniversalSkillsPath(cwd);
+  const logger = createLogger();
+  if (!fs9.existsSync(universalPath)) {
+    console.log(chalk6.yellow("No skills installed yet."));
+    return;
+  }
+  const skillDirs = fs9.readdirSync(universalPath).filter((item) => {
+    const itemPath = path10.join(universalPath, item);
+    return fs9.statSync(itemPath).isDirectory();
+  });
+  if (skillDirs.length === 0) {
+    console.log(chalk6.yellow("No skills installed yet."));
+    return;
+  }
+  let skillsToUpdate = skillDirs;
+  if (skillNames && skillNames.length > 0) {
+    skillsToUpdate = skillDirs.filter((dir) => skillNames.includes(dir));
+    if (skillsToUpdate.length === 0) {
+      console.log(chalk6.yellow("No matching skills found."));
+      console.log(chalk6.gray("\nInstalled skills:"));
+      skillDirs.forEach((dir) => console.log(chalk6.gray(`  - ${dir}`)));
+      return;
+    }
+  }
+  console.log(chalk6.cyan(`
+\u{1F504} Updating ${skillsToUpdate.length} skill(s)...
+`));
+  let updated = 0;
+  let failed = 0;
+  let skipped = 0;
+  for (const skillSlug of skillsToUpdate) {
+    const skillPath = path10.join(universalPath, skillSlug);
+    const skillMdPath = path10.join(skillPath, "SKILL.md");
+    const sourceFile = path10.join(skillPath, ".source");
+    if (!fs9.existsSync(sourceFile)) {
+      logger.warn(`${skillSlug}: No source information, skipping`);
+      skipped++;
+      continue;
+    }
+    try {
+      const source = fs9.readFileSync(sourceFile, "utf-8").trim();
+      let currentVersion = "unknown";
+      if (fs9.existsSync(skillMdPath)) {
+        const skill = parseSkillFile(skillMdPath, skillSlug);
+        if (skill && skill.metadata.version) {
+          currentVersion = skill.metadata.version;
+        }
+      }
+      logger.start(`Updating ${skillSlug} (current: ${currentVersion})...`);
+      await addSkill(source, { skill: skillSlug });
+      logger.succeed(`${skillSlug} updated successfully`);
+      updated++;
+    } catch (error) {
+      logger.fail(`${skillSlug}: Update failed`);
+      console.error(chalk6.red(`  Error: ${error.message}`));
+      failed++;
+    }
+  }
+  console.log(chalk6.cyan("\n\u{1F4CA} Update Summary:"));
+  console.log(chalk6.green(`  \u2713 Updated: ${updated}`));
+  if (skipped > 0) console.log(chalk6.yellow(`  \u2298 Skipped: ${skipped}`));
+  if (failed > 0) console.log(chalk6.red(`  \u2716 Failed: ${failed}`));
+}
+
+// src/commands/stats.ts
+import chalk7 from "chalk";
+function showStats() {
+  const stats = getInstallationStats();
+  console.log(chalk7.cyan("\n\u{1F4CA} Installation Statistics\n"));
+  console.log(chalk7.bold("Total Installations:"), stats.totalInstalls);
+  if (Object.keys(stats.skillsByAgent).length > 0) {
+    console.log(chalk7.bold("\nInstallations by Agent:"));
+    const sortedAgents = Object.entries(stats.skillsByAgent).sort(([, a], [, b]) => b - a);
+    sortedAgents.forEach(([agent, count]) => {
+      const bar = "\u2588".repeat(Math.min(count, 20));
+      console.log(`  ${agent.padEnd(20)} ${bar} ${count}`);
+    });
+  }
+  if (stats.topSkills.length > 0) {
+    console.log(chalk7.bold("\nTop Installed Skills:"));
+    stats.topSkills.forEach((skill, index) => {
+      console.log(`  ${index + 1}. ${skill.name.padEnd(30)} (${skill.count} installs)`);
+    });
+  }
+  if (stats.recentInstalls.length > 0) {
+    console.log(chalk7.bold("\nRecent Installations:"));
+    stats.recentInstalls.slice(0, 5).forEach((record) => {
+      const date = new Date(record.timestamp).toLocaleString();
+      const agents = record.agents.join(", ");
+      console.log(chalk7.gray(`  ${date}`));
+      console.log(`    ${record.skillName} \u2192 ${agents}`);
+    });
+  }
+  if (stats.totalInstalls === 0) {
+    console.log(chalk7.yellow("No installation data yet. Install some skills to see statistics!"));
+  }
+}
+
+// src/commands/scan.ts
+import fs10 from "fs";
+import path11 from "path";
+import chalk8 from "chalk";
+function getSecurityDisplay(score) {
+  if (!score) {
+    return { label: "UNKNOWN", color: "gray", icon: "?" };
+  }
+  if (score >= 81) {
+    return { label: "SAFE", color: "green", icon: "\u2713" };
+  }
+  if (score >= 61) {
+    return { label: "LOW RISK", color: "yellow", icon: "\u26A0" };
+  }
+  if (score >= 41) {
+    return { label: "MEDIUM RISK", color: "yellow", icon: "\u26A0" };
+  }
+  if (score >= 21) {
+    return { label: "HIGH RISK", color: "red", icon: "\u2717" };
+  }
+  return { label: "CRITICAL", color: "red", icon: "\u2717" };
+}
+async function checkSkillSecurity(skillName, source) {
+  try {
+    const apiUrl = process.env.TRUSTTOOLS_API_URL || "https://skills.seebug.ai";
+    const response = await fetch(`${apiUrl}/api/skills?search=${encodeURIComponent(skillName)}&limit=5`);
+    if (!response.ok) {
+      return {
+        skillName,
+        skillPath: "",
+        source,
+        status: "unknown"
+      };
+    }
+    const data = await response.json();
+    if (data.success && data.data && data.data.length > 0) {
+      const match = data.data.find(
+        (s) => s.name.toLowerCase() === skillName.toLowerCase()
+      ) || data.data[0];
+      const score = match.security_score;
+      let status = "unknown";
+      if (score !== void 0) {
+        if (score >= 61) status = "safe";
+        else if (score >= 41) status = "warning";
+        else status = "danger";
+      }
+      return {
+        skillName,
+        skillPath: "",
+        source: `${match.repo_owner}/${match.repo_name}`,
+        security_score: match.security_score,
+        security_level: match.security_level,
+        status
+      };
+    }
+    return {
+      skillName,
+      skillPath: "",
+      source,
+      status: "unknown"
+    };
+  } catch (error) {
+    return {
+      skillName,
+      skillPath: "",
+      source,
+      status: "unknown"
+    };
+  }
+}
+async function scanSkills() {
+  const cwd = process.cwd();
+  const logger = createLogger();
+  logger.start("Detecting installed agents...");
+  const agents = detectAgents(cwd);
+  const detectedAgents = agents.filter((a) => a.detected);
+  if (detectedAgents.length === 0) {
+    logger.fail("No agents detected");
+    console.log(chalk8.yellow("\nNo AI agents found in current directory."));
+    console.log(chalk8.gray("Run this command in a project with .cursor/, .claude/, or .windsurf/ directories."));
+    return;
+  }
+  logger.succeed(`Found ${detectedAgents.length} agent(s)`);
+  const allSkills = [];
+  for (const agent of detectedAgents) {
+    if (fs10.existsSync(agent.skillsPath)) {
+      const skillDirs = fs10.readdirSync(agent.skillsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+      for (const skillName of skillDirs) {
+        const skillPath = path11.join(agent.skillsPath, skillName);
+        const skillMdPath = path11.join(skillPath, "SKILL.md");
+        if (fs10.existsSync(skillMdPath)) {
+          allSkills.push({
+            name: skillName,
+            path: skillPath,
+            agent: agent.name
+          });
+        }
+      }
+    }
+  }
+  if (allSkills.length === 0) {
+    logger.info("No skills installed");
+    console.log(chalk8.yellow("\nNo skills found in detected agents."));
+    return;
+  }
+  console.log(chalk8.cyan(`
+\u{1F50D} Scanning ${allSkills.length} skill(s) for security issues...
+`));
+  const results = [];
+  for (const skill of allSkills) {
+    const result = await checkSkillSecurity(skill.name);
+    result.skillPath = skill.path;
+    results.push(result);
+  }
+  const safe = results.filter((r) => r.status === "safe");
+  const warning = results.filter((r) => r.status === "warning");
+  const danger = results.filter((r) => r.status === "danger");
+  const unknown = results.filter((r) => r.status === "unknown");
+  console.log(chalk8.bold("\u{1F4CA} Security Scan Results:\n"));
+  console.log(chalk8.bold("Summary:"));
+  console.log(chalk8.green(`  \u2713 Safe: ${safe.length}`));
+  console.log(chalk8.yellow(`  \u26A0 Warning: ${warning.length}`));
+  console.log(chalk8.red(`  \u2717 Danger: ${danger.length}`));
+  console.log(chalk8.gray(`  ? Unknown: ${unknown.length}`));
+  console.log();
+  if (danger.length > 0) {
+    console.log(chalk8.bold.red("\u{1F6A8} High Risk Skills:\n"));
+    for (const skill of danger) {
+      const display = getSecurityDisplay(skill.security_score);
+      console.log(chalk8.red(`  ${display.icon} ${skill.skillName}`));
+      console.log(chalk8.gray(`     Score: ${skill.security_score || "N/A"}`));
+      console.log(chalk8.gray(`     Level: ${display.label}`));
+      if (skill.source) {
+        console.log(chalk8.gray(`     Source: ${skill.source}`));
+      }
+      console.log();
+    }
+  }
+  if (warning.length > 0) {
+    console.log(chalk8.bold.yellow("\u26A0\uFE0F  Medium Risk Skills:\n"));
+    for (const skill of warning) {
+      const display = getSecurityDisplay(skill.security_score);
+      console.log(chalk8.yellow(`  ${display.icon} ${skill.skillName}`));
+      console.log(chalk8.gray(`     Score: ${skill.security_score || "N/A"}`));
+      console.log(chalk8.gray(`     Level: ${display.label}`));
+      if (skill.source) {
+        console.log(chalk8.gray(`     Source: ${skill.source}`));
+      }
+      console.log();
+    }
+  }
+  if (safe.length > 0) {
+    console.log(chalk8.bold.green(`\u2713 ${safe.length} skill(s) are safe
+`));
+  }
+  if (unknown.length > 0) {
+    console.log(chalk8.bold.gray(`? ${unknown.length} skill(s) could not be verified
+`));
+  }
+  if (danger.length > 0 || warning.length > 0) {
+    console.log(chalk8.bold("\n\u{1F4A1} Recommendations:\n"));
+    if (danger.length > 0) {
+      console.log(chalk8.red("  \u2022 Consider removing high-risk skills immediately"));
+    }
+    if (warning.length > 0) {
+      console.log(chalk8.yellow("  \u2022 Review medium-risk skills and update if possible"));
+    }
+    console.log(chalk8.gray("  \u2022 Check skill sources and verify they are from trusted repositories"));
+    console.log(chalk8.gray("  \u2022 Keep skills updated to the latest versions"));
+  }
+}
+
+// src/ui/MainMenu.tsx
+import React4 from "react";
+import { Box as Box3, Text as Text3 } from "ink";
+import SelectInput2 from "ink-select-input";
+var MainMenu = ({ onSelect }) => {
+  const items = [
+    { label: "\u{1F50D} Find Skills", value: "find" },
+    { label: "\u2795 Add Skill", value: "add" },
+    { label: "\u{1F4CB} List Installed Skills", value: "list" },
+    { label: "\u{1F504} Update Skills", value: "update" },
+    { label: "\u2699\uFE0F  Manage Skills", value: "manage" },
+    { label: "\u2139\uFE0F  Environment Info", value: "info" },
+    { label: "\u{1F4CA} Installation Stats", value: "stats" },
+    { label: "\u274C Exit", value: "exit" }
+  ];
+  return /* @__PURE__ */ React4.createElement(Box3, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React4.createElement(Box3, { marginBottom: 1 }, /* @__PURE__ */ React4.createElement(Text3, { bold: true, color: "cyan" }, "TrustTools - Universal AI Agent Skills Manager")), /* @__PURE__ */ React4.createElement(Box3, { marginBottom: 1 }, /* @__PURE__ */ React4.createElement(Text3, { dimColor: true }, "Select an action:")), /* @__PURE__ */ React4.createElement(SelectInput2, { items, onSelect: (item) => onSelect(item.value) }));
+};
+
+// src/index.ts
+var program = new Command();
+program.name("trusttools").description("Universal CLI tool for managing AI agent skills").version("1.0.0");
+program.command("add").description("Add a skill from GitHub, local path, or URL").argument("[type]", 'Optional: "skill" or "docs"').argument("[source]", "Skill source (user/repo, https://..., or local path)").option("-s, --skill <name>", "Specific skill name to install").option("-g, --global", "Install globally to home directory").action(async (type, source, options) => {
+  try {
+    let actualSource;
+    if (type === "skill" || type === "docs") {
+      if (!source) {
+        console.error(chalk9.red("Error: source is required"));
+        console.log(chalk9.gray("Usage: trusttools add skill <source> [--skill <name>]"));
+        process.exit(1);
+      }
+      actualSource = source;
+    } else if (type) {
+      actualSource = type;
+    } else {
+      console.error(chalk9.red("Error: source is required"));
+      console.log(chalk9.gray("Usage: trusttools add [skill] <source> [--skill <name>]"));
+      process.exit(1);
+    }
+    await addSkill(actualSource, options);
+  } catch (error) {
+    process.exit(1);
+  }
+});
+program.command("find").description("Find and interactively select skills from a source").argument("<source>", "Skill source (user/repo, https://..., or local path)").action(async (source) => {
+  try {
+    await findSkills(source);
+  } catch (error) {
+    process.exit(1);
+  }
+});
+program.command("list").alias("ls").description("List all installed skills").action(() => {
+  listSkills();
+});
+program.command("manage").description("Manage installed skills (delete, view info)").action(async () => {
+  try {
+    await manageSkills();
+  } catch (error) {
+    process.exit(1);
+  }
+});
+program.command("update").description("Update installed skills to latest version").argument("[names...]", "Specific skill names to update (updates all if not specified)").action(async (names) => {
+  try {
+    await updateSkills(names);
+  } catch (error) {
+    process.exit(1);
+  }
+});
+program.command("stats").description("Show installation statistics").action(() => {
+  showStats();
+});
+program.command("scan").description("Scan installed skills for security issues").action(async () => {
+  try {
+    await scanSkills();
+  } catch (error) {
+    process.exit(1);
+  }
+});
+program.command("info").description("Show information about the current environment").action(() => {
+  const cwd = process.cwd();
+  const agents = detectAgents(cwd);
+  const universalPath = getUniversalSkillsPath(cwd);
+  console.log(chalk9.bold("\n\u{1F50D} Environment Information:\n"));
+  console.log(chalk9.gray(`Current directory: ${cwd}`));
+  console.log(chalk9.gray(`Universal skills path: ${universalPath}
+`));
+  console.log(chalk9.bold("Detected AI Agents:"));
+  const detected = agents.filter((a) => a.detected);
+  if (detected.length > 0) {
+    detected.forEach((agent) => {
+      console.log(chalk9.green(`  \u2713 ${agent.name} (${agent.type})`));
+      console.log(chalk9.gray(`    Skills path: ${agent.skillsPath}`));
+    });
+  } else {
+    console.log(chalk9.yellow("  No agents detected"));
+    console.log(chalk9.gray("  Looking for: .cursor, .claude, .windsurf, etc."));
+  }
+  console.log();
+});
+if (!process.argv.slice(2).length) {
+  const { waitUntilExit } = render3(
+    React5.createElement(MainMenu, {
+      onSelect: async (value) => {
+        process.exit(0);
+      }
+    })
+  );
+  waitUntilExit().then(() => {
+  });
+} else {
+  program.parse();
+}
+//# sourceMappingURL=index.js.map