skill-viewer 0.1.2

package/dist/cli.js

@@ -0,0 +1,1043 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_node_http = __toESM(require("http"));
+var import_node_fs3 = require("fs");
+var import_node_path3 = __toESM(require("path"));
+
+// src/server.ts
+var import_express = __toESM(require("express"));
+var import_node_path2 = __toESM(require("path"));
+var import_node_fs2 = __toESM(require("fs"));
+
+// src/index.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+var import_node_os = __toESM(require("os"));
+
+// src/frontmatter.ts
+var FM_REGEX = /^---\s*\n([\s\S]*?)\n---\s*\n?/;
+function parseFrontmatter(content) {
+  content = content.replace(/\r\n/g, "\n");
+  const match = content.match(FM_REGEX);
+  if (!match) return {};
+  const result = {};
+  let lastKey = null;
+  for (const line of match[1].split("\n")) {
+    const isContinuation = /^\s+/.test(line) || lastKey !== null && line.indexOf(":") === -1;
+    if (isContinuation && lastKey !== null) {
+      result[lastKey] = result[lastKey] + "\n" + line.trimEnd();
+      continue;
+    }
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    if (key === "") continue;
+    let value = line.slice(idx + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+    lastKey = key;
+  }
+  return result;
+}
+function extractFrontmatterRaw(content) {
+  const match = content.match(FM_REGEX);
+  return match ? match[1] : "";
+}
+function stripFrontmatter(content) {
+  return content.replace(FM_REGEX, "");
+}
+
+// src/index.ts
+var AGENT_CONFIGS = [
+  {
+    id: "claude",
+    name: "Claude Code",
+    globalDir: import_node_path.default.join(import_node_os.default.homedir(), ".claude"),
+    projectDirName: ".claude",
+    fileExtensions: [".md"],
+    hasPlugins: true,
+    subdirs: ["skills", "commands"],
+    scanGlobalRoot: false
+  },
+  {
+    id: "gemini",
+    name: "Gemini CLI",
+    globalDir: import_node_path.default.join(import_node_os.default.homedir(), ".gemini"),
+    projectDirName: ".gemini",
+    fileExtensions: [".md", ".toml"],
+    hasPlugins: false,
+    subdirs: ["skills", "commands"],
+    scanGlobalRoot: false
+  },
+  {
+    id: "opencode",
+    name: "OpenCode",
+    globalDir: import_node_path.default.join(import_node_os.default.homedir(), ".config", "opencode"),
+    projectDirName: ".opencode",
+    fileExtensions: [".md"],
+    hasPlugins: false,
+    subdirs: ["skills", "commands", "agents"],
+    scanGlobalRoot: false
+  },
+  {
+    id: "codex",
+    name: "Codex CLI",
+    globalDir: import_node_path.default.join(import_node_os.default.homedir(), ".codex"),
+    projectDirName: ".codex",
+    fileExtensions: [".md"],
+    hasPlugins: false,
+    subdirs: ["skills"],
+    scanGlobalRoot: false
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    globalDir: import_node_path.default.join(import_node_os.default.homedir(), ".cursor"),
+    projectDirName: ".cursor",
+    fileExtensions: [".md", ".mdc"],
+    hasPlugins: false,
+    subdirs: ["rules"],
+    scanGlobalRoot: false
+  },
+  {
+    id: "cline",
+    name: "Cline",
+    globalDir: import_node_path.default.join(import_node_os.default.homedir(), "Documents", "Cline", "Rules"),
+    projectDirName: ".clinerules",
+    fileExtensions: [".md", ".txt"],
+    hasPlugins: false,
+    subdirs: [],
+    scanGlobalRoot: true
+  }
+];
+function getAgentConfig(agentId) {
+  return AGENT_CONFIGS.find((a) => a.id === agentId) || AGENT_CONFIGS[0];
+}
+var activeAgent = AGENT_CONFIGS[0];
+var CLAUDE_DIR = activeAgent.globalDir;
+var PLUGINS_DIR = import_node_path.default.join(CLAUDE_DIR, "plugins", "cache", "claude-plugins-official");
+var CUSTOM_SKILLS_DIR = import_node_path.default.join(CLAUDE_DIR, "skills");
+var COMMANDS_DIR = import_node_path.default.join(CLAUDE_DIR, "commands");
+function updateDirs(agent) {
+  CLAUDE_DIR = agent.globalDir;
+  if (agent.id === "claude") {
+    PLUGINS_DIR = import_node_path.default.join(CLAUDE_DIR, "plugins", "cache", "claude-plugins-official");
+    CUSTOM_SKILLS_DIR = import_node_path.default.join(CLAUDE_DIR, "skills");
+    COMMANDS_DIR = import_node_path.default.join(CLAUDE_DIR, "commands");
+  } else {
+    PLUGINS_DIR = "";
+    CUSTOM_SKILLS_DIR = CLAUDE_DIR;
+    COMMANDS_DIR = "";
+    for (const sub of agent.subdirs) {
+      const subDir = import_node_path.default.join(CLAUDE_DIR, sub);
+      if (sub === "commands") COMMANDS_DIR = subDir;
+      else if (sub === "rules") CUSTOM_SKILLS_DIR = subDir;
+    }
+  }
+}
+var KNOWN_TOOLS = /* @__PURE__ */ new Set([
+  "Agent",
+  "Bash",
+  "Edit",
+  "Read",
+  "Write",
+  "Glob",
+  "Grep",
+  "WebFetch",
+  "WebSearch",
+  "TaskCreate",
+  "TaskUpdate",
+  "TodoWrite",
+  "Skill",
+  "NotebookEdit",
+  "LSP"
+]);
+var SKILL_REF_RE = /\b[\w-]+:[\w-]+\b/g;
+function exists(p) {
+  try {
+    import_node_fs.default.accessSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readdir(p) {
+  try {
+    return import_node_fs.default.readdirSync(p);
+  } catch {
+    return [];
+  }
+}
+function readText(p) {
+  return import_node_fs.default.readFileSync(p, "utf-8");
+}
+function isDir(p) {
+  try {
+    return import_node_fs.default.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(p) {
+  try {
+    return import_node_fs.default.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function mtime(p) {
+  try {
+    return import_node_fs.default.statSync(p).mtimeMs / 1e3;
+  } catch {
+    return 0;
+  }
+}
+function findLatestVersionDir(pluginDir) {
+  const entries = readdir(pluginDir).filter((name) => {
+    const full = import_node_path.default.join(pluginDir, name);
+    return isDir(full) && (name[0] >= "0" && name[0] <= "9" || name === "unknown");
+  });
+  if (entries.length === 0) return null;
+  entries.sort((a, b) => {
+    if (a === "unknown") return 1;
+    if (b === "unknown") return -1;
+    return b.localeCompare(a);
+  });
+  return import_node_path.default.join(pluginDir, entries[0]);
+}
+var SkillIndex = class {
+  skills = [];
+  byPath = /* @__PURE__ */ new Map();
+  projectDirs = /* @__PURE__ */ new Set();
+  getActiveAgent() {
+    return activeAgent;
+  }
+  setAgent(agentId) {
+    activeAgent = getAgentConfig(agentId);
+    updateDirs(activeAgent);
+    this.build();
+  }
+  build() {
+    this.skills = [];
+    this.byPath = /* @__PURE__ */ new Map();
+    if (activeAgent.id === "claude") {
+      this.indexPlugins();
+      this.indexCustomSkills();
+      this.indexCommands();
+    } else {
+      this.indexGenericGlobalDir();
+    }
+    for (const dir of this.projectDirs) {
+      this.indexProjectDir(dir);
+    }
+  }
+  addProjectDir(projectDir) {
+    const configDir = import_node_path.default.join(projectDir, activeAgent.projectDirName);
+    if (!exists(configDir) || !isDir(configDir)) return false;
+    this.projectDirs.add(projectDir);
+    this.indexProjectDir(projectDir);
+    return true;
+  }
+  removeProjectDir(projectDir) {
+    this.projectDirs.delete(projectDir);
+    const configDir = import_node_path.default.join(projectDir, activeAgent.projectDirName);
+    this.skills = this.skills.filter((s) => !s.path.startsWith(configDir + import_node_path.default.sep));
+    for (const [p] of this.byPath) {
+      if (p.startsWith(configDir + import_node_path.default.sep)) this.byPath.delete(p);
+    }
+  }
+  getProjectDirs() {
+    return [...this.projectDirs];
+  }
+  extractCrossReferences(content) {
+    const matches = content.match(SKILL_REF_RE) || [];
+    return [...new Set(matches)].sort();
+  }
+  extractToolReferences(content) {
+    const found = [];
+    for (const tool of KNOWN_TOOLS) {
+      const re = new RegExp(`\\b${tool}\\b`);
+      if (re.test(content)) found.push(tool);
+    }
+    return found.sort();
+  }
+  extractStructuralTags(content) {
+    const tags = [];
+    if (/^[ \t]*-[ \t]*\[[ xX]\]/m.test(content)) tags.push("has-checklist");
+    if (/examples?:|for example|e\.g\./i.test(content)) tags.push("has-examples");
+    if (/```/.test(content)) tags.push("has-code-blocks");
+    if (/^[ \t]*(\d+\.|step \d+)/im.test(content)) tags.push("has-steps");
+    if (/^\|.+\|/m.test(content)) tags.push("has-table");
+    if (/```\s*(mermaid|dot|plantuml)|graph (LR|TD|RL|BT)|digraph /i.test(content)) tags.push("has-diagram");
+    return tags;
+  }
+  indexSkill(filePath, sourceType, sourceName, skillDir) {
+    try {
+      const content = readText(filePath);
+      const frontmatter = parseFrontmatter(content);
+      const body = stripFrontmatter(content);
+      const mt = mtime(filePath);
+      const skill = {
+        name: frontmatter.name || (import_node_path.default.basename(filePath) === "SKILL.md" ? import_node_path.default.basename(import_node_path.default.dirname(filePath)) : import_node_path.default.basename(filePath, import_node_path.default.extname(filePath))),
+        description: frontmatter.description || "",
+        path: filePath,
+        sourceType,
+        sourceName,
+        filename: import_node_path.default.basename(filePath),
+        content: body,
+        frontmatter,
+        frontmatterRaw: extractFrontmatterRaw(content),
+        crossReferences: this.extractCrossReferences(content),
+        toolReferences: this.extractToolReferences(content),
+        structuralTags: this.extractStructuralTags(body),
+        wordCount: body.split(/\s+/).filter(Boolean).length,
+        mtime: mt,
+        skillDir
+      };
+      this.skills.push(skill);
+      this.byPath.set(filePath, skill);
+    } catch {
+    }
+  }
+  indexPlugins() {
+    if (!exists(PLUGINS_DIR)) return;
+    for (const pluginName of readdir(PLUGINS_DIR)) {
+      const pluginDir = import_node_path.default.join(PLUGINS_DIR, pluginName);
+      if (!isDir(pluginDir)) continue;
+      const latestVersion = findLatestVersionDir(pluginDir);
+      if (!latestVersion) continue;
+      const skillsDir = import_node_path.default.join(latestVersion, "skills");
+      if (!exists(skillsDir)) continue;
+      for (const skillName of readdir(skillsDir)) {
+        const skillDir = import_node_path.default.join(skillsDir, skillName);
+        if (!isDir(skillDir)) continue;
+        const skillFile = import_node_path.default.join(skillDir, "SKILL.md");
+        if (exists(skillFile)) {
+          this.indexSkill(skillFile, "plugin", pluginName, skillDir);
+        }
+      }
+    }
+  }
+  indexCustomSkills() {
+    if (!exists(CUSTOM_SKILLS_DIR)) return;
+    for (const name of readdir(CUSTOM_SKILLS_DIR)) {
+      const itemPath = import_node_path.default.join(CUSTOM_SKILLS_DIR, name);
+      if (isDir(itemPath)) {
+        const skillFile = import_node_path.default.join(itemPath, "SKILL.md");
+        if (exists(skillFile)) {
+          this.indexSkill(skillFile, "custom", "Custom Skills", itemPath);
+        }
+      } else if (isFile(itemPath) && itemPath.endsWith(".md")) {
+        this.indexSkill(itemPath, "custom", "Custom Skills", import_node_path.default.dirname(itemPath));
+      }
+    }
+  }
+  indexCommands() {
+    if (!exists(COMMANDS_DIR)) return;
+    for (const name of readdir(COMMANDS_DIR)) {
+      const filePath = import_node_path.default.join(COMMANDS_DIR, name);
+      if (isFile(filePath) && name.endsWith(".md")) {
+        this.indexSkill(filePath, "command", "Commands", COMMANDS_DIR);
+      }
+    }
+  }
+  hasMatchingExtension(filename) {
+    return activeAgent.fileExtensions.some((ext) => filename.endsWith(ext));
+  }
+  indexGenericGlobalDir() {
+    const globalDir = activeAgent.globalDir;
+    if (!exists(globalDir) || !isDir(globalDir)) return;
+    if (activeAgent.scanGlobalRoot) {
+      this.indexGenericDir(globalDir, "custom", activeAgent.name, true);
+    }
+    for (const sub of activeAgent.subdirs) {
+      const subDir = import_node_path.default.join(globalDir, sub);
+      if (exists(subDir) && isDir(subDir)) {
+        const sourceType = sub === "commands" ? "command" : "custom";
+        const sourceName = sub === "commands" ? "Commands" : activeAgent.name;
+        this.indexGenericDir(subDir, sourceType, sourceName, true);
+      }
+    }
+  }
+  indexGenericDir(dir, sourceType, sourceName, recursive) {
+    for (const name of readdir(dir)) {
+      if (name.startsWith(".")) continue;
+      const itemPath = import_node_path.default.join(dir, name);
+      if (isFile(itemPath) && this.hasMatchingExtension(name)) {
+        this.indexSkill(itemPath, sourceType, sourceName, dir);
+      } else if (recursive && isDir(itemPath)) {
+        this.indexGenericDir(itemPath, sourceType, sourceName, true);
+      }
+    }
+  }
+  indexProjectDir(projectDir) {
+    const configDir = import_node_path.default.join(projectDir, activeAgent.projectDirName);
+    const projectName = import_node_path.default.basename(projectDir);
+    if (activeAgent.id === "claude") {
+      const cmdsDir = import_node_path.default.join(configDir, "commands");
+      if (exists(cmdsDir) && isDir(cmdsDir)) {
+        for (const name of readdir(cmdsDir)) {
+          const filePath = import_node_path.default.join(cmdsDir, name);
+          if (isFile(filePath) && name.endsWith(".md")) {
+            this.indexSkill(filePath, "project", projectName, cmdsDir);
+          }
+        }
+      }
+      const skillsDir = import_node_path.default.join(configDir, "skills");
+      if (exists(skillsDir) && isDir(skillsDir)) {
+        for (const name of readdir(skillsDir)) {
+          const itemPath = import_node_path.default.join(skillsDir, name);
+          if (isDir(itemPath)) {
+            const skillFile = import_node_path.default.join(itemPath, "SKILL.md");
+            if (exists(skillFile)) {
+              this.indexSkill(skillFile, "project", projectName, itemPath);
+            }
+          } else if (isFile(itemPath) && itemPath.endsWith(".md")) {
+            this.indexSkill(itemPath, "project", projectName, skillsDir);
+          }
+        }
+      }
+    } else {
+      if (!exists(configDir) || !isDir(configDir)) return;
+      if (activeAgent.subdirs.length > 0) {
+        for (const sub of activeAgent.subdirs) {
+          const subDir = import_node_path.default.join(configDir, sub);
+          if (exists(subDir) && isDir(subDir)) {
+            const sourceType = sub === "commands" ? "command" : "project";
+            this.indexGenericDir(subDir, sourceType, projectName, true);
+          }
+        }
+      } else {
+        this.indexGenericDir(configDir, "project", projectName, false);
+      }
+    }
+  }
+  get(skillPath) {
+    return this.byPath.get(skillPath);
+  }
+  search(query) {
+    if (!query) return [];
+    const q = query.toLowerCase();
+    const results = [];
+    for (const skill of this.skills) {
+      const haystack = `${skill.name} ${skill.description} ${skill.content}`.toLowerCase();
+      if (!haystack.includes(q)) continue;
+      const idx = skill.content.toLowerCase().indexOf(q);
+      let snippet;
+      if (idx >= 0) {
+        const start = Math.max(0, idx - 80);
+        const end = Math.min(skill.content.length, idx + query.length + 80);
+        snippet = skill.content.slice(start, end).trim();
+        if (start > 0) snippet = "\u2026" + snippet;
+        if (end < skill.content.length) snippet += "\u2026";
+      } else {
+        snippet = skill.description;
+      }
+      results.push({
+        name: skill.name,
+        description: skill.description,
+        path: skill.path,
+        sourceType: skill.sourceType,
+        sourceName: skill.sourceName,
+        snippet,
+        structuralTags: skill.structuralTags
+      });
+    }
+    return results;
+  }
+  getGraph() {
+    const nodes = this.skills.map((s) => ({
+      id: s.path,
+      name: s.name,
+      sourceType: s.sourceType,
+      sourceName: s.sourceName,
+      wordCount: s.wordCount,
+      structuralTags: s.structuralTags
+    }));
+    const nameToPath = /* @__PURE__ */ new Map();
+    for (const s of this.skills) {
+      const refKey = `${s.sourceName.toLowerCase().replace(/ /g, "-")}:${s.name.toLowerCase()}`;
+      nameToPath.set(refKey, s.path);
+      nameToPath.set(s.name.toLowerCase(), s.path);
+    }
+    const edges = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const skill of this.skills) {
+      for (const ref of skill.crossReferences) {
+        const targetPath = nameToPath.get(ref.toLowerCase());
+        if (targetPath && targetPath !== skill.path) {
+          const key = `${skill.path}->${targetPath}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            edges.push({ source: skill.path, target: targetPath });
+          }
+        }
+      }
+    }
+    return { nodes, edges };
+  }
+  getHealth(skillPath) {
+    const skill = this.byPath.get(skillPath);
+    if (!skill) return null;
+    const ageDays = (Date.now() / 1e3 - skill.mtime) / 86400;
+    const completenessGaps = [];
+    if (!skill.description) completenessGaps.push("missing-description");
+    if (!skill.structuralTags.includes("has-examples")) completenessGaps.push("no-examples");
+    if (skill.wordCount < 50) completenessGaps.push("very-short");
+    return {
+      mtime: skill.mtime,
+      mtimeIso: new Date(skill.mtime * 1e3).toISOString(),
+      ageDays: Math.round(ageDays * 10) / 10,
+      wordCount: skill.wordCount,
+      completenessGaps,
+      toolCount: skill.toolReferences.length,
+      crossRefCount: skill.crossReferences.length,
+      structuralTags: skill.structuralTags
+    };
+  }
+};
+function getSources(index2) {
+  const sources = { plugins: [], custom: [], commands: [], projects: [] };
+  if (activeAgent.id === "claude") {
+    const pluginGroups = /* @__PURE__ */ new Map();
+    for (const s of index2.skills) {
+      if (s.sourceType !== "plugin") continue;
+      const group = pluginGroups.get(s.sourceName) || [];
+      group.push(s);
+      pluginGroups.set(s.sourceName, group);
+    }
+    for (const [name, skills] of pluginGroups) {
+      const skillsDir = import_node_path.default.dirname(skills[0].skillDir);
+      const version2 = import_node_path.default.basename(import_node_path.default.dirname(skillsDir));
+      sources.plugins.push({
+        name,
+        path: skillsDir,
+        count: skills.length,
+        version: version2,
+        skills: skills.map((s) => ({ name: s.name, path: s.path })).sort((a, b) => a.name.localeCompare(b.name))
+      });
+    }
+  }
+  const customSkills = index2.skills.filter((s) => s.sourceType === "custom");
+  if (customSkills.length > 0) {
+    const sourceName = activeAgent.id === "claude" ? "Custom Skills" : activeAgent.name;
+    const sourcePath = activeAgent.id === "claude" ? CUSTOM_SKILLS_DIR : activeAgent.globalDir;
+    sources.custom.push({
+      name: sourceName,
+      path: sourcePath,
+      count: customSkills.length,
+      files: customSkills.map((s) => ({ name: s.name, path: s.path })).sort((a, b) => a.name.localeCompare(b.name))
+    });
+  }
+  const commandSkills = index2.skills.filter((s) => s.sourceType === "command");
+  if (commandSkills.length > 0) {
+    sources.commands.push({
+      name: "Commands",
+      path: COMMANDS_DIR || import_node_path.default.join(activeAgent.globalDir, "commands"),
+      count: commandSkills.length,
+      files: commandSkills.map((s) => ({ name: s.name, path: s.path })).sort((a, b) => a.name.localeCompare(b.name))
+    });
+  }
+  for (const projectDir of index2.getProjectDirs()) {
+    const configDir = import_node_path.default.join(projectDir, activeAgent.projectDirName);
+    const projectSkills = index2.skills.filter((s) => s.path.startsWith(configDir + import_node_path.default.sep));
+    const commandCount = projectSkills.filter((s) => {
+      const rel = import_node_path.default.relative(configDir, s.path);
+      return rel.startsWith("commands" + import_node_path.default.sep);
+    }).length;
+    sources.projects.push({
+      name: import_node_path.default.basename(projectDir),
+      path: configDir,
+      projectDir,
+      commandCount,
+      skillCount: projectSkills.length - commandCount
+    });
+  }
+  return sources;
+}
+function indexedToSummary(skill) {
+  return {
+    name: skill.name,
+    description: skill.description,
+    path: skill.path,
+    filename: skill.filename,
+    skillDir: skill.skillDir
+  };
+}
+function getSkillsForSource(sourcePath, index2) {
+  const matched = index2.skills.filter((s) => s.path.startsWith(sourcePath + import_node_path.default.sep));
+  const skills = matched.map(indexedToSummary);
+  skills.sort((a, b) => a.name.localeCompare(b.name));
+  for (const s of skills) {
+    s.health = index2.getHealth(s.path) ?? void 0;
+    const indexed = index2.get(s.path);
+    if (indexed) {
+      s.toolReferences = indexed.toolReferences;
+      s.structuralTags = indexed.structuralTags;
+    }
+  }
+  return skills;
+}
+function buildTree(dirPath) {
+  const entries = [];
+  let items;
+  try {
+    items = import_node_fs.default.readdirSync(dirPath);
+  } catch {
+    return entries;
+  }
+  const dirs = items.filter((n) => !n.startsWith(".") && n !== "__pycache__" && isDir(import_node_path.default.join(dirPath, n))).sort();
+  const files = items.filter((n) => {
+    if (n.startsWith(".") && n !== ".claude-plugin") return false;
+    return isFile(import_node_path.default.join(dirPath, n));
+  }).sort();
+  for (const name of dirs) {
+    const full = import_node_path.default.join(dirPath, name);
+    entries.push({ name, path: full, type: "directory", children: buildTree(full) });
+  }
+  for (const name of files) {
+    const full = import_node_path.default.join(dirPath, name);
+    const stat = import_node_fs.default.statSync(full);
+    entries.push({ name, path: full, type: "file", size: stat.size, extension: import_node_path.default.extname(name) });
+  }
+  return entries;
+}
+function getAgentConfigs() {
+  return AGENT_CONFIGS;
+}
+function getWatchDirs() {
+  if (activeAgent.id === "claude") {
+    return [PLUGINS_DIR, CUSTOM_SKILLS_DIR, COMMANDS_DIR].filter((d) => exists(d) && isDir(d));
+  }
+  const dirs = [];
+  if (activeAgent.scanGlobalRoot && exists(activeAgent.globalDir) && isDir(activeAgent.globalDir)) {
+    dirs.push(activeAgent.globalDir);
+  }
+  for (const sub of activeAgent.subdirs) {
+    const subDir = import_node_path.default.join(activeAgent.globalDir, sub);
+    if (exists(subDir) && isDir(subDir)) dirs.push(subDir);
+  }
+  return dirs;
+}
+
+// src/server.ts
+function extractWildcard(params) {
+  const val = params.path;
+  const raw = Array.isArray(val) ? val.join("/") : String(val);
+  return raw.startsWith("/") ? raw : "/" + raw;
+}
+function getReferenceFiles(skillPath) {
+  const skillDir = import_node_path2.default.dirname(skillPath);
+  const skillName = import_node_path2.default.basename(skillPath);
+  const refs = [];
+  let items;
+  try {
+    items = import_node_fs2.default.readdirSync(skillDir);
+  } catch {
+    return refs;
+  }
+  for (const name of items.sort()) {
+    if (name.startsWith(".")) continue;
+    const full = import_node_path2.default.join(skillDir, name);
+    try {
+      const stat = import_node_fs2.default.statSync(full);
+      if (stat.isFile() && name !== skillName && name.endsWith(".md")) {
+        refs.push({ name, path: full, type: "file" });
+      } else if (stat.isDirectory()) {
+        const children = [];
+        for (const sub of import_node_fs2.default.readdirSync(full).sort()) {
+          const subFull = import_node_path2.default.join(full, sub);
+          if (import_node_fs2.default.statSync(subFull).isFile() && sub.endsWith(".md")) {
+            children.push({ name: sub, path: subFull, type: "file" });
+          }
+        }
+        if (children.length > 0) {
+          refs.push({ name, path: full, type: "directory", children });
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return refs;
+}
+function isUnderAllowedRoot(resolvedPath, index2) {
+  const agent = index2.getActiveAgent();
+  const roots = [agent.globalDir, ...index2.getProjectDirs()];
+  return roots.some((root) => resolvedPath.startsWith(root + import_node_path2.default.sep) || resolvedPath === root);
+}
+function createApp(index2) {
+  const app2 = (0, import_express.default)();
+  const publicDir = import_node_path2.default.resolve(__dirname, "..", "public");
+  app2.get("/", (_req, res) => {
+    const html = import_node_fs2.default.readFileSync(import_node_path2.default.join(publicDir, "index.html"), "utf-8");
+    res.type("html").send(html);
+  });
+  app2.use(import_express.default.json());
+  app2.get("/api/agents", (_req, res) => {
+    const agents = getAgentConfigs().map((a) => ({
+      id: a.id,
+      name: a.name,
+      global_dir: a.globalDir,
+      project_dir_name: a.projectDirName
+    }));
+    const active = index2.getActiveAgent();
+    res.json({ agents, active_id: active.id });
+  });
+  app2.post("/api/agent", (req, res) => {
+    const agentId = req.body?.id;
+    if (!agentId) {
+      res.status(400).json({ error: "Missing agent id" });
+      return;
+    }
+    const configs = getAgentConfigs();
+    if (!configs.find((a) => a.id === agentId)) {
+      res.status(400).json({ error: `Unknown agent: ${agentId}` });
+      return;
+    }
+    index2.setAgent(agentId);
+    res.json({ ok: true, active_id: agentId, sources: getSources(index2) });
+  });
+  app2.get("/api/sources", (_req, res) => {
+    res.json(getSources(index2));
+  });
+  app2.post("/api/projects", (req, res) => {
+    const dir = req.body?.path;
+    if (!dir) {
+      res.status(400).json({ error: "Missing path" });
+      return;
+    }
+    const ok = index2.addProjectDir(dir);
+    if (!ok) {
+      const agent = index2.getActiveAgent();
+      res.status(400).json({ error: `No ${agent.projectDirName}/ directory found at that path` });
+      return;
+    }
+    res.json({ ok: true, sources: getSources(index2) });
+  });
+  app2.delete("/api/projects", (req, res) => {
+    const dir = req.body?.path;
+    if (!dir) {
+      res.status(400).json({ error: "Missing path" });
+      return;
+    }
+    index2.removeProjectDir(dir);
+    res.json({ ok: true, sources: getSources(index2) });
+  });
+  app2.get("/api/skills", (req, res) => {
+    const source = req.query.source;
+    if (!source) {
+      res.json([]);
+      return;
+    }
+    const skills = getSkillsForSource(source, index2).map((s) => ({
+      name: s.name,
+      description: s.description,
+      path: s.path,
+      filename: s.filename,
+      skill_dir: s.skillDir,
+      old: s.old,
+      health: s.health ? toSnakeHealth(s.health) : void 0,
+      tool_references: s.toolReferences,
+      structural_tags: s.structuralTags
+    }));
+    res.json(skills);
+  });
+  app2.get("/api/skill/*path", (req, res) => {
+    const skillPath = import_node_path2.default.resolve(extractWildcard(req.params));
+    if (!isUnderAllowedRoot(skillPath, index2)) {
+      res.status(403).json({ error: "Access denied" });
+      return;
+    }
+    if (!import_node_fs2.default.existsSync(skillPath)) {
+      res.status(404).json({ error: "Skill not found" });
+      return;
+    }
+    try {
+      const content = import_node_fs2.default.readFileSync(skillPath, "utf-8");
+      const frontmatter = parseFrontmatter(content);
+      const frontmatterRaw = extractFrontmatterRaw(content);
+      const body = stripFrontmatter(content);
+      const response = {
+        name: frontmatter.name || (import_node_path2.default.basename(skillPath) === "SKILL.md" ? import_node_path2.default.basename(import_node_path2.default.dirname(skillPath)) : import_node_path2.default.basename(skillPath, import_node_path2.default.extname(skillPath))),
+        description: frontmatter.description || "",
+        frontmatter,
+        frontmatter_raw: frontmatterRaw,
+        content: body,
+        path: skillPath,
+        references: getReferenceFiles(skillPath)
+      };
+      const indexed = index2.get(skillPath);
+      if (indexed) {
+        response.cross_references = indexed.crossReferences;
+        response.tool_references = indexed.toolReferences;
+        response.structural_tags = indexed.structuralTags;
+        response.word_count = indexed.wordCount;
+        response.health = toSnakeHealth(index2.getHealth(skillPath));
+        response.skill_dir = import_node_path2.default.basename(skillPath) === "SKILL.md" ? import_node_path2.default.dirname(skillPath) : null;
+      }
+      res.json(response);
+    } catch (e) {
+      res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+    }
+  });
+  app2.get("/api/reference/*path", (req, res) => {
+    const refPath = import_node_path2.default.resolve(extractWildcard(req.params));
+    if (!isUnderAllowedRoot(refPath, index2)) {
+      res.status(403).json({ error: "Access denied" });
+      return;
+    }
+    if (!import_node_fs2.default.existsSync(refPath)) {
+      res.status(404).json({ error: "Reference not found" });
+      return;
+    }
+    try {
+      const content = import_node_fs2.default.readFileSync(refPath, "utf-8");
+      res.json({ name: import_node_path2.default.basename(refPath), content, path: refPath });
+    } catch (e) {
+      res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+    }
+  });
+  app2.get("/api/search", (req, res) => {
+    const query = req.query.q || "";
+    const results = index2.search(query).map((r) => ({
+      name: r.name,
+      description: r.description,
+      path: r.path,
+      source_type: r.sourceType,
+      source_name: r.sourceName,
+      snippet: r.snippet,
+      structural_tags: r.structuralTags
+    }));
+    res.json(results);
+  });
+  app2.get("/api/graph", (_req, res) => {
+    const graph = index2.getGraph();
+    res.json({
+      nodes: graph.nodes.map((n) => ({
+        id: n.id,
+        name: n.name,
+        source_type: n.sourceType,
+        source_name: n.sourceName,
+        word_count: n.wordCount,
+        structural_tags: n.structuralTags
+      })),
+      edges: graph.edges
+    });
+  });
+  app2.get("/api/skill-tree/*path", (req, res) => {
+    const dirPath = import_node_path2.default.resolve(extractWildcard(req.params));
+    if (!isUnderAllowedRoot(dirPath, index2)) {
+      res.status(403).json({ error: "Access denied" });
+      return;
+    }
+    if (!import_node_fs2.default.existsSync(dirPath) || !import_node_fs2.default.statSync(dirPath).isDirectory()) {
+      res.status(404).json({ error: "Directory not found" });
+      return;
+    }
+    res.json({ root: dirPath, tree: buildTree(dirPath) });
+  });
+  app2.get("/api/health/*path", (req, res) => {
+    const skillPath = import_node_path2.default.resolve(extractWildcard(req.params));
+    if (!isUnderAllowedRoot(skillPath, index2)) {
+      res.status(403).json({ error: "Access denied" });
+      return;
+    }
+    const health = index2.getHealth(skillPath);
+    if (!health) {
+      res.status(404).json({ error: "Skill not found in index" });
+      return;
+    }
+    res.json(toSnakeHealth(health));
+  });
+  return app2;
+}
+function toSnakeHealth(h) {
+  return {
+    mtime: h.mtime,
+    mtime_iso: h.mtimeIso,
+    age_days: h.ageDays,
+    word_count: h.wordCount,
+    completeness_gaps: h.completenessGaps,
+    tool_count: h.toolCount,
+    cross_ref_count: h.crossRefCount,
+    structural_tags: h.structuralTags
+  };
+}
+
+// src/watcher.ts
+var import_ws = require("ws");
+var import_chokidar = __toESM(require("chokidar"));
+function setupWebSocket(server2) {
+  const wss2 = new import_ws.WebSocketServer({ server: server2, path: "/ws" });
+  const clients = /* @__PURE__ */ new Set();
+  wss2.on("error", (err) => {
+    console.error("WebSocket server error:", err.message);
+  });
+  wss2.on("connection", (ws) => {
+    clients.add(ws);
+    ws.on("close", () => clients.delete(ws));
+    ws.on("error", () => clients.delete(ws));
+  });
+  function broadcast2(msg) {
+    const data = JSON.stringify(msg);
+    for (const ws of clients) {
+      try {
+        ws.send(data);
+      } catch {
+        clients.delete(ws);
+      }
+    }
+  }
+  return { broadcast: broadcast2, wss: wss2 };
+}
+function setupWatcher(index2, broadcast2) {
+  let watchedDirs = getWatchDirs();
+  const watcher2 = import_chokidar.default.watch(watchedDirs, {
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 300 }
+  });
+  let debounceTimer = null;
+  function handleChange() {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      index2.build();
+      broadcast2({ type: "skill_changed" });
+    }, 500);
+  }
+  watcher2.on("change", handleChange);
+  watcher2.on("add", handleChange);
+  watcher2.on("unlink", handleChange);
+  watcher2.on("error", (err) => console.error("Watcher error:", err));
+  if (watchedDirs.length > 0) {
+    console.log(`Watching ${watchedDirs.length} directories for changes`);
+  }
+  return {
+    add: (dir) => watcher2.add(dir),
+    unwatch: (dir) => watcher2.unwatch(dir),
+    close: () => watcher2.close(),
+    switchAgent: () => {
+      if (watchedDirs.length > 0) watcher2.unwatch(watchedDirs);
+      watchedDirs = getWatchDirs();
+      if (watchedDirs.length > 0) {
+        watcher2.add(watchedDirs);
+        console.log(`Watching ${watchedDirs.length} directories for changes`);
+      }
+    }
+  };
+}
+
+// src/cli.ts
+var version = JSON.parse((0, import_node_fs3.readFileSync)(import_node_path3.default.join(__dirname, "..", "package.json"), "utf-8")).version;
+var args = process.argv.slice(2);
+if (args.includes("--help") || args.includes("-h")) {
+  console.log(`skill-viewer v${version}
+`);
+  console.log(`Browse and inspect Claude Code skills installed in ~/.claude/
+`);
+  console.log(`Usage: skill-viewer [options]
+`);
+  console.log(`Options:`);
+  console.log(`  -h, --help     Show this help message`);
+  console.log(`  -v, --version  Show version number
+`);
+  console.log(`Environment variables:`);
+  console.log(`  PORT           Server port (default: 8080)`);
+  process.exit(0);
+}
+if (args.includes("--version") || args.includes("-v")) {
+  console.log(version);
+  process.exit(0);
+}
+var PORT = parseInt(process.env.PORT || "8080", 10);
+var index = new SkillIndex();
+index.build();
+if (!(0, import_node_fs3.existsSync)(CLAUDE_DIR)) {
+  console.warn(`
+Warning: ${CLAUDE_DIR} does not exist.`);
+  console.warn(`Install Claude Code and run it once to create this directory.
+`);
+} else if (index.skills.length === 0) {
+  console.warn(`
+No skills found. Install a plugin or add custom skills to ~/.claude/skills/
+`);
+} else {
+  console.log(`Indexed ${index.skills.length} skills`);
+}
+var app = createApp(index);
+var server = import_node_http.default.createServer(app);
+var { broadcast, wss } = setupWebSocket(server);
+var watcher = setupWatcher(index, broadcast);
+var originalAdd = index.addProjectDir.bind(index);
+var originalRemove = index.removeProjectDir.bind(index);
+var originalSetAgent = index.setAgent.bind(index);
+index.addProjectDir = (dir) => {
+  const ok = originalAdd(dir);
+  if (ok) watcher.add(dir);
+  return ok;
+};
+index.removeProjectDir = (dir) => {
+  originalRemove(dir);
+  watcher.unwatch(dir);
+};
+index.setAgent = (agentId) => {
+  originalSetAgent(agentId);
+  watcher.switchAgent();
+};
+server.listen(PORT, () => {
+  console.log(`Skill Viewer running at http://localhost:${PORT}`);
+});
+server.on("error", (err) => {
+  if (err.code === "EADDRINUSE") {
+    console.error(`
+Error: Port ${PORT} is already in use.
+`);
+    console.error(`Try one of:`);
+    console.error(`  PORT=3000 npx skill-viewer`);
+    console.error(`  lsof -ti:${PORT} | xargs kill
+`);
+    process.exit(1);
+  }
+  throw err;
+});
+var shuttingDown = false;
+function shutdown() {
+  if (shuttingDown) {
+    process.exit(0);
+  }
+  shuttingDown = true;
+  console.log("Shutting down...");
+  wss.clients.forEach((ws) => ws.terminate());
+  wss.close();
+  server.close();
+  watcher.close().finally(() => process.exit(0));
+}
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);