library-skills 0.0.1 → 0.0.2

package/ts/dist/cli.js

@@ -1,7 +1,1315 @@
 #!/usr/bin/env node
+
+// ts/src/cli.ts
+import checkbox from "@inquirer/checkbox";
+import { Command } from "commander";
+import { statSync as statSync4 } from "fs";
+import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// ts/src/deps.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { parse as parse2 } from "smol-toml";
+
+// ts/src/scanner.ts
+import {
+  existsSync,
+  lstatSync,
+  readFileSync,
+  readdirSync,
+  realpathSync,
+  statSync
+} from "fs";
 import {
-  main
-} from "./chunk-L5NY3HR3.js";
+  basename,
+  dirname,
+  isAbsolute,
+  join,
+  relative,
+  resolve
+} from "path";
+import { fileURLToPath } from "url";
+import { parse } from "csv-parse/sync";
+var SKILL_NAME_RE = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
+function scanPythonDistributions(sitePackages) {
+  const result = { skills: [], warnings: [] };
+  const seenSkillDirs = /* @__PURE__ */ new Set();
+  if (!isDirectory(sitePackages)) {
+    result.warnings.push(`Site-packages directory not found: ${sitePackages}`);
+    return result;
+  }
+  for (const distInfo of readdirSync(sitePackages).filter((entry) => entry.endsWith(".dist-info")).sort().map((entry) => join(sitePackages, entry))) {
+    if (!isDirectory(distInfo)) {
+      continue;
+    }
+    const dist = readDistributionInfo(distInfo);
+    if (dist === null) {
+      result.warnings.push(
+        `Skipping invalid distribution metadata: ${distInfo}`
+      );
+      continue;
+    }
+    const found = scanDistributionRecords({
+      sitePackages,
+      distInfo,
+      packageName: dist.name,
+      packageVersion: dist.version,
+      seenSkillDirs
+    });
+    result.skills.push(...found.skills);
+    result.warnings.push(...found.warnings);
+    if (found.skills.length === 0) {
+      const fallback = scanEditableDirectUrl({
+        distInfo,
+        packageName: dist.name,
+        packageVersion: dist.version,
+        seenSkillDirs
+      });
+      result.skills.push(...fallback.skills);
+      result.warnings.push(...fallback.warnings);
+    }
+  }
+  return result;
+}
+function scanNodePackages(nodeModules) {
+  const result = { skills: [], warnings: [] };
+  const seenSkillDirs = /* @__PURE__ */ new Set();
+  if (!isDirectory(nodeModules)) {
+    result.warnings.push(`node_modules directory not found: ${nodeModules}`);
+    return result;
+  }
+  for (const packageRoot of iterNodePackageRoots(nodeModules)) {
+    const packageInfo = readNodePackageInfo(packageRoot);
+    if (packageInfo === null) {
+      result.warnings.push(`Skipping invalid package metadata: ${packageRoot}`);
+      continue;
+    }
+    for (const skillMd of findNodeSkillMarkdownFiles(packageRoot)) {
+      const skillDir = realpathOrResolve(dirname(skillMd));
+      if (seenSkillDirs.has(skillDir)) {
+        continue;
+      }
+      seenSkillDirs.add(skillDir);
+      const [skill, warning] = loadSkill({
+        skillDir,
+        skillMd: realpathOrResolve(skillMd),
+        packageName: packageInfo.name,
+        packageVersion: packageInfo.version
+      });
+      if (skill) {
+        result.skills.push(skill);
+      } else if (warning) {
+        result.warnings.push(warning);
+      }
+    }
+  }
+  return result;
+}
+function iterNodePackageRoots(nodeModules) {
+  const packageRoots = [];
+  for (const entry of readdirSync(nodeModules).sort()) {
+    const fullPath = join(nodeModules, entry);
+    if (!isDirectory(fullPath)) {
+      continue;
+    }
+    if (entry.startsWith("@")) {
+      for (const scopedEntry of readdirSync(fullPath).sort()) {
+        const scopedPath = join(fullPath, scopedEntry);
+        if (isDirectory(scopedPath)) {
+          packageRoots.push(scopedPath);
+        }
+      }
+    } else {
+      packageRoots.push(fullPath);
+    }
+  }
+  return packageRoots;
+}
+function readNodePackageInfo(packageRoot) {
+  let data;
+  try {
+    data = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8"));
+  } catch {
+    return null;
+  }
+  if (!isRecord(data)) {
+    return null;
+  }
+  const name = data["name"];
+  if (typeof name !== "string" || name === "") {
+    return null;
+  }
+  const version = data["version"];
+  return { name, version: typeof version === "string" ? version : "" };
+}
+function findNodeSkillMarkdownFiles(packageRoot) {
+  const skillsRoot = join(packageRoot, ".agents", "skills");
+  if (!isDirectory(skillsRoot)) {
+    return [];
+  }
+  return readdirSync(skillsRoot).sort().map((entry) => join(skillsRoot, entry, "SKILL.md")).filter((skillMd) => existsSync(skillMd));
+}
+function readDistributionInfo(distInfo) {
+  let metadataText;
+  try {
+    metadataText = readFileSync(join(distInfo, "METADATA"), "utf8");
+  } catch {
+    return null;
+  }
+  const headers = parseMetadataHeaders(metadataText);
+  const name = headers.get("name");
+  if (!name) {
+    return null;
+  }
+  return { name, version: headers.get("version") ?? "" };
+}
+function parseMetadataHeaders(text) {
+  const headers = /* @__PURE__ */ new Map();
+  let currentKey;
+  for (const line of text.split(/\r?\n/)) {
+    if (line === "") {
+      break;
+    }
+    if (/^\s/.test(line) && currentKey) {
+      headers.set(
+        currentKey,
+        `${headers.get(currentKey) ?? ""} ${line.trim()}`
+      );
+      continue;
+    }
+    const index = line.indexOf(":");
+    if (index === -1) {
+      continue;
+    }
+    currentKey = line.slice(0, index).trim().toLowerCase();
+    headers.set(currentKey, line.slice(index + 1).trim());
+  }
+  return headers;
+}
+function scanDistributionRecords({
+  sitePackages,
+  distInfo,
+  packageName,
+  packageVersion,
+  seenSkillDirs
+}) {
+  const result = { skills: [], warnings: [] };
+  let recordText;
+  try {
+    recordText = readFileSync(join(distInfo, "RECORD"), "utf8");
+  } catch {
+    return result;
+  }
+  const rows = parse(recordText, {
+    relaxColumnCount: true,
+    skipEmptyLines: true
+  });
+  for (const row of rows) {
+    const installedPath = row[0];
+    if (!isSkillFileRecord(installedPath)) {
+      continue;
+    }
+    const skillMd = resolve(sitePackages, installedPath);
+    const skillDir = dirname(skillMd);
+    const resolvedSkillDir = realpathOrResolve(skillDir);
+    if (seenSkillDirs.has(resolvedSkillDir)) {
+      continue;
+    }
+    seenSkillDirs.add(resolvedSkillDir);
+    const [skill, warning] = loadSkill({
+      skillDir,
+      skillMd,
+      packageName,
+      packageVersion
+    });
+    if (skill) {
+      result.skills.push(skill);
+    } else if (warning) {
+      result.warnings.push(warning);
+    }
+  }
+  return result;
+}
+function isSkillFileRecord(installedPath) {
+  const parts = installedPath.split("/").filter((part) => part.length > 0);
+  for (const [index, part] of parts.entries()) {
+    if (part !== ".agents") {
+      continue;
+    }
+    if (parts.length > index + 3 && parts[index + 1] === "skills" && parts.at(-1) === "SKILL.md") {
+      return true;
+    }
+  }
+  return false;
+}
+function scanEditableDirectUrl({
+  distInfo,
+  packageName,
+  packageVersion,
+  seenSkillDirs
+}) {
+  const result = { skills: [], warnings: [] };
+  const sourceRoot = readEditableSourceRoot(distInfo);
+  if (sourceRoot === null) {
+    return result;
+  }
+  for (const skillMd of findSkillMarkdownFiles(sourceRoot)) {
+    const resolvedSkillMd = realpathOrResolve(skillMd);
+    if (!isRelativeTo(resolvedSkillMd, sourceRoot)) {
+      continue;
+    }
+    const skillDir = dirname(resolvedSkillMd);
+    if (seenSkillDirs.has(skillDir)) {
+      continue;
+    }
+    seenSkillDirs.add(skillDir);
+    const [skill, warning] = loadSkill({
+      skillDir,
+      skillMd: resolvedSkillMd,
+      packageName,
+      packageVersion
+    });
+    if (skill) {
+      result.skills.push(skill);
+    } else if (warning) {
+      result.warnings.push(warning);
+    }
+  }
+  return result;
+}
+function readEditableSourceRoot(distInfo) {
+  let data;
+  try {
+    data = JSON.parse(readFileSync(join(distInfo, "direct_url.json"), "utf8"));
+  } catch {
+    return null;
+  }
+  if (!isRecord(data)) {
+    return null;
+  }
+  const dirInfo = data["dir_info"];
+  if (!isRecord(dirInfo) || dirInfo["editable"] !== true) {
+    return null;
+  }
+  const url = data["url"];
+  if (typeof url !== "string") {
+    return null;
+  }
+  let sourceRoot;
+  try {
+    sourceRoot = fileURLToPath(url);
+  } catch {
+    return null;
+  }
+  return isDirectory(sourceRoot) ? realpathOrResolve(sourceRoot) : null;
+}
+function findSkillMarkdownFiles(root) {
+  const found = [];
+  function walk(directory) {
+    let entries;
+    try {
+      entries = readdirSync(directory).sort();
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(directory, entry);
+      let stat;
+      try {
+        stat = lstatSync(fullPath);
+      } catch {
+        continue;
+      }
+      if (stat.isSymbolicLink()) {
+        if (entry === "SKILL.md" && isSkillMarkdownPath(root, fullPath)) {
+          found.push(fullPath);
+        }
+        continue;
+      }
+      if (stat.isDirectory()) {
+        walk(fullPath);
+      } else if (entry === "SKILL.md" && isSkillMarkdownPath(root, fullPath)) {
+        found.push(fullPath);
+      }
+    }
+  }
+  walk(root);
+  return found;
+}
+function loadSkill({
+  skillDir,
+  skillMd,
+  packageName,
+  packageVersion
+}) {
+  const [metadata, warning] = parseSkillFrontmatter(skillMd);
+  if (warning) {
+    return [null, `${skillMd}: ${warning}`];
+  }
+  const name = metadata["name"] ?? "";
+  const description = metadata["description"] ?? "";
+  const validationError = validateSkillMetadata({
+    name,
+    description,
+    parentDirName: basename(skillDir)
+  });
+  if (validationError) {
+    return [null, `${skillMd}: ${validationError}`];
+  }
+  return [
+    {
+      name,
+      description,
+      path: skillMd,
+      packageName,
+      packageVersion,
+      skillDir
+    },
+    null
+  ];
+}
+function parseSkillFrontmatter(skillMd) {
+  let text;
+  try {
+    text = readFileSync(skillMd, "utf8");
+  } catch (error) {
+    return [{}, `could not read SKILL.md (${String(error)})`];
+  }
+  if (!text.startsWith("---")) {
+    return [{}, "missing YAML frontmatter"];
+  }
+  const end = text.indexOf("\n---", 3);
+  if (end === -1) {
+    return [{}, "unterminated YAML frontmatter"];
+  }
+  const metadata = {};
+  for (const line of text.slice(3, end).split(/\r?\n/)) {
+    const stripped = line.trim();
+    if (stripped === "" || stripped.startsWith("#")) {
+      continue;
+    }
+    const separator = stripped.indexOf(":");
+    if (separator === -1) {
+      continue;
+    }
+    const key = stripped.slice(0, separator).trim();
+    if (key === "name" || key === "description") {
+      metadata[key] = stripped.slice(separator + 1).trim().replace(/^["']|["']$/g, "");
+    }
+  }
+  return [metadata, null];
+}
+function validateSkillMetadata({
+  name,
+  description,
+  parentDirName
+}) {
+  if (!name) {
+    return "missing required 'name' field";
+  }
+  if (!SKILL_NAME_RE.test(name) || name.includes("--")) {
+    return "invalid 'name' field; use lowercase letters, numbers, and hyphens only";
+  }
+  if (name !== parentDirName) {
+    return `'name' field must match parent directory name (${parentDirName})`;
+  }
+  if (!description) {
+    return "missing required 'description' field";
+  }
+  if (description.length > 1024) {
+    return "'description' field must be at most 1024 characters";
+  }
+  return null;
+}
+function normalizePackageName(name) {
+  return name.replace(/[-_.]+/g, "-").toLowerCase();
+}
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isRelativeTo(path, parent) {
+  const childPath = resolve(path);
+  const parentPath = resolve(parent);
+  const childRelative = relative(parentPath, childPath);
+  return childRelative === "" || !childRelative.startsWith("..") && !isAbsolute(childRelative);
+}
+function isSkillMarkdownPath(root, skillMd) {
+  const relativePath = relative(root, skillMd);
+  if (relativePath === "" || relativePath.startsWith("..")) {
+    return false;
+  }
+  const parts = relativePath.split(/[\\/]+/);
+  return isSkillFileRecord(parts.join("/"));
+}
+function realpathOrResolve(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ts/src/deps.ts
+function getPythonTopLevelDeps(projectRoot) {
+  const pyproject = join2(projectRoot, "pyproject.toml");
+  if (!existsSync2(pyproject)) {
+    return null;
+  }
+  let data;
+  try {
+    data = parse2(readFileSync2(pyproject, "utf8"));
+  } catch {
+    return null;
+  }
+  const deps = /* @__PURE__ */ new Set();
+  const project = data["project"];
+  if (!isRecord2(project)) {
+    return deps;
+  }
+  const dependencies = project["dependencies"];
+  if (Array.isArray(dependencies)) {
+    extractDepsFromSpecs(dependencies, deps);
+  }
+  const optionalDependencies = project["optional-dependencies"];
+  if (isRecord2(optionalDependencies)) {
+    for (const groupDependencies of Object.values(optionalDependencies)) {
+      if (Array.isArray(groupDependencies)) {
+        extractDepsFromSpecs(groupDependencies, deps);
+      }
+    }
+  }
+  return deps;
+}
+function getNodeTopLevelDeps(projectRoot) {
+  const packageJson = join2(projectRoot, "package.json");
+  if (!existsSync2(packageJson)) {
+    return null;
+  }
+  let data;
+  try {
+    data = JSON.parse(readFileSync2(packageJson, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!isRecord2(data)) {
+    return /* @__PURE__ */ new Set();
+  }
+  const deps = /* @__PURE__ */ new Set();
+  for (const field of [
+    "dependencies",
+    "devDependencies",
+    "optionalDependencies",
+    "peerDependencies"
+  ]) {
+    const dependencies = data[field];
+    if (!isRecord2(dependencies)) {
+      continue;
+    }
+    for (const packageName of Object.keys(dependencies)) {
+      deps.add(normalizePackageName(packageName));
+    }
+  }
+  return deps;
+}
+function getTopLevelDeps(projectRoot) {
+  const dependencySets = [
+    getPythonTopLevelDeps(projectRoot),
+    getNodeTopLevelDeps(projectRoot)
+  ].filter((deps) => deps !== null);
+  if (dependencySets.length === 0) {
+    return null;
+  }
+  return new Set(dependencySets.flatMap((deps) => [...deps]));
+}
+function extractDepsFromSpecs(depSpecs, deps) {
+  for (const depSpec of depSpecs) {
+    if (typeof depSpec !== "string") {
+      continue;
+    }
+    const packageName = depSpec.split(/[>=<![\];,\s]/)[0]?.trim();
+    if (packageName && !packageName.startsWith("#")) {
+      deps.add(normalizePackageName(packageName));
+    }
+  }
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ts/src/installer.ts
+import {
+  cpSync,
+  existsSync as existsSync3,
+  lstatSync as lstatSync2,
+  mkdirSync,
+  readdirSync as readdirSync2,
+  readlinkSync,
+  statSync as statSync2,
+  symlinkSync,
+  unlinkSync
+} from "fs";
+import { dirname as dirname2, join as join3, relative as relative2, resolve as resolve2 } from "path";
+var UNIVERSAL_SKILLS_DIR = ".agents/skills";
+var CLAUDE_SKILLS_DIR = ".claude/skills";
+var InstallError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InstallError";
+  }
+};
+function getTargetDirs(projectRoot, options = {}) {
+  const targets = [
+    { name: "universal", path: join3(projectRoot, UNIVERSAL_SKILLS_DIR) }
+  ];
+  if (options.includeClaude) {
+    targets.push({
+      name: "claude-compatible",
+      path: join3(projectRoot, CLAUDE_SKILLS_DIR)
+    });
+  }
+  return targets;
+}
+function installSkill(skill, targetDir, options = {}) {
+  const dest = join3(targetDir, skill.name);
+  const source = resolve2(skill.skillDir);
+  if (existsSync3(dest) || isSymlink(dest)) {
+    if (isSymlink(dest)) {
+      unlinkSync(dest);
+    } else if (lstatSync2(dest).isFile()) {
+      throw new InstallError(`Cannot overwrite non-symlink file: ${dest}`);
+    } else if (lstatSync2(dest).isDirectory()) {
+      throw new InstallError(`Cannot overwrite non-symlink directory: ${dest}`);
+    }
+  }
+  mkdirSync(dirname2(dest), { recursive: true });
+  if (options.copy) {
+    cpSync(source, dest, { recursive: true });
+  } else {
+    symlinkSync(getSymlinkTarget({ source, dest }), dest, "dir");
+  }
+  return dest;
+}
+function uninstallSkill(skillName, targetDir) {
+  const dest = join3(targetDir, skillName);
+  if (isSymlink(dest)) {
+    unlinkSync(dest);
+    return true;
+  }
+  return false;
+}
+function listInstalledSkills(targetDir) {
+  if (!isDirectory2(targetDir)) {
+    return [];
+  }
+  return readdirSync2(targetDir).sort().flatMap((name) => {
+    const path = join3(targetDir, name);
+    if (!isSymlink(path) && !isDirectory2(path)) {
+      return [];
+    }
+    const type = isSymlink(path) ? "symlink" : "directory";
+    return [
+      {
+        name,
+        type,
+        path,
+        target: type === "symlink" ? resolveSymlink(path) : null,
+        hasSkillMd: existsSync3(join3(path, "SKILL.md"))
+      }
+    ];
+  });
+}
+function getSymlinkTarget({ source, dest }) {
+  const relativeTarget = relative2(dirname2(resolve2(dest)), source);
+  return relativeTarget === "" ? source : relativeTarget;
+}
+function resolveSymlink(path) {
+  try {
+    return resolve2(dirname2(path), readlinkSync(path));
+  } catch {
+    return null;
+  }
+}
+function isSymlink(path) {
+  try {
+    return lstatSync2(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function isDirectory2(path) {
+  try {
+    return statSync2(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// ts/src/python-env.ts
+import { readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join4, resolve as resolve3, sep } from "path";
+function findProjectRoot(cwd) {
+  for (const directory of ancestors(cwd)) {
+    if (isFile(join4(directory, "pyproject.toml")) || isFile(join4(directory, "uv.lock")) || isFile(join4(directory, ".venv", "pyvenv.cfg")) || isFile(join4(directory, "package.json")) || isDirectory3(join4(directory, "node_modules"))) {
+      return directory;
+    }
+  }
+  return null;
+}
+function findVenv(cwd = process.cwd()) {
+  const projectRoot = findProjectRoot(cwd) ?? cwd;
+  const uvProjectEnvironment = process.env["UV_PROJECT_ENVIRONMENT"];
+  if (uvProjectEnvironment) {
+    const path = isAbsolute2(uvProjectEnvironment) ? uvProjectEnvironment : join4(projectRoot, uvProjectEnvironment);
+    if (isVenvDir(path)) {
+      return path;
+    }
+  }
+  for (const directory of ancestors(cwd)) {
+    const dotVenv = join4(directory, ".venv");
+    if (isVenvDir(dotVenv)) {
+      return dotVenv;
+    }
+  }
+  const virtualEnv = process.env["VIRTUAL_ENV"];
+  if (virtualEnv && isVenvDir(virtualEnv) && isRelativeTo2(virtualEnv, projectRoot)) {
+    return virtualEnv;
+  }
+  const condaPrefix = process.env["CONDA_PREFIX"];
+  if (condaPrefix && isDirectory3(condaPrefix)) {
+    return condaPrefix;
+  }
+  return null;
+}
+function getSitePackagesDir(venvPath) {
+  const windowsSitePackages = join4(venvPath, "Lib", "site-packages");
+  if (isDirectory3(windowsSitePackages)) {
+    return windowsSitePackages;
+  }
+  for (const libName of ["lib", "lib64"]) {
+    const libDir = join4(venvPath, libName);
+    if (!isDirectory3(libDir)) {
+      continue;
+    }
+    for (const child of readdirSync3(libDir).sort().reverse()) {
+      const sitePackages = join4(libDir, child, "site-packages");
+      if (child.startsWith("python") && isDirectory3(sitePackages)) {
+        return sitePackages;
+      }
+    }
+  }
+  return null;
+}
+function findNodeModules(cwd = process.cwd()) {
+  for (const directory of ancestors(cwd)) {
+    const nodeModules = join4(directory, "node_modules");
+    if (isDirectory3(nodeModules)) {
+      return nodeModules;
+    }
+  }
+  return null;
+}
+function isVenvDir(directory) {
+  return isFile(join4(directory, "pyvenv.cfg"));
+}
+function ancestors(start) {
+  const result = [];
+  let directory = resolve3(start);
+  while (true) {
+    result.push(directory);
+    const parent = dirname3(directory);
+    if (parent === directory) {
+      break;
+    }
+    directory = parent;
+  }
+  return result;
+}
+function isRelativeTo2(path, parent) {
+  const normalizedPath = resolve3(path);
+  const normalizedParent = resolve3(parent);
+  return normalizedPath === normalizedParent || normalizedPath.startsWith(`${normalizedParent}${sep}`);
+}
+function isFile(path) {
+  try {
+    return statSync3(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function isDirectory3(path) {
+  try {
+    return statSync3(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
 
 // ts/src/cli.ts
-main();
+function getProjectContext(cwd = process.cwd()) {
+  const projectRoot = findProjectRoot(cwd) ?? cwd;
+  const targetEnvironment = findVenv(cwd);
+  const sitePackagesDir = targetEnvironment === null ? null : getSitePackagesDir(targetEnvironment);
+  const nodeModulesDir = findNodeModules(cwd);
+  return { cwd, projectRoot, targetEnvironment, sitePackagesDir, nodeModulesDir };
+}
+function scanContext(context) {
+  const result = {
+    skills: [],
+    warnings: [],
+    environmentPath: context.targetEnvironment ?? void 0
+  };
+  if (context.sitePackagesDir !== null) {
+    const pythonResult = scanPythonDistributions(context.sitePackagesDir);
+    result.skills.push(...pythonResult.skills);
+    result.warnings.push(...pythonResult.warnings);
+  }
+  if (context.nodeModulesDir !== null) {
+    const nodeResult = scanNodePackages(context.nodeModulesDir);
+    result.skills.push(...nodeResult.skills);
+    result.warnings.push(...nodeResult.warnings);
+  }
+  if (context.sitePackagesDir === null && context.nodeModulesDir === null) {
+    result.warnings.push(
+      "No target Python environment with site-packages or node_modules was found. Run from a project root after installing dependencies, for example with 'uv sync' for Python or 'npm install' for Node.js."
+    );
+  }
+  return result;
+}
+function topLevelSkills({
+  context,
+  skills,
+  includeAll
+}) {
+  if (includeAll) {
+    return skills;
+  }
+  const topLevelDeps = getTopLevelDeps(context.projectRoot);
+  if (topLevelDeps === null) {
+    return skills;
+  }
+  return skills.filter(
+    (skill) => topLevelDeps.has(normalizePackageName(skill.packageName))
+  );
+}
+function printWarnings(warnings) {
+  for (const warning of warnings) {
+    console.log(`Warning: ${warning}`);
+  }
+}
+function displayPath(path, projectRoot) {
+  if (!path) {
+    return "";
+  }
+  const relativePath = relative3(resolve4(projectRoot), resolve4(path));
+  if (relativePath === "") {
+    return ".";
+  }
+  if (!relativePath.startsWith("..") && !isAbsolute3(relativePath)) {
+    return relativePath;
+  }
+  return path;
+}
+function printContext(context) {
+  console.log(`Project root: ${context.projectRoot}`);
+  console.log(
+    `Target Python environment: ${context.targetEnvironment ? displayPath(context.targetEnvironment, context.projectRoot) : "not found"}`
+  );
+  if (context.sitePackagesDir) {
+    console.log(
+      `Site-packages: ${displayPath(
+        context.sitePackagesDir,
+        context.projectRoot
+      )}`
+    );
+  }
+  if (context.nodeModulesDir) {
+    console.log(
+      `node_modules: ${displayPath(context.nodeModulesDir, context.projectRoot)}`
+    );
+  }
+}
+function printSkills(skills) {
+  if (skills.length === 0) {
+    console.log("No skills found in installed packages.");
+    return;
+  }
+  printTable(
+    ["Skill", "Package", "Version", "Description"],
+    skills.map((skill) => ({
+      Skill: skill.name,
+      Package: skill.packageName,
+      Version: skill.packageVersion,
+      Description: skill.description
+    }))
+  );
+}
+function scanJsonPayload({
+  context,
+  skills,
+  result
+}) {
+  return {
+    project_root: context.projectRoot,
+    target_environment: context.targetEnvironment ?? "",
+    node_modules: context.nodeModulesDir ?? "",
+    skills: skills.map((skill) => ({
+      name: skill.name,
+      description: skill.description,
+      package: skill.packageName,
+      version: skill.packageVersion,
+      path: skill.skillDir
+    })),
+    warnings: result.warnings
+  };
+}
+function printTable(columns, rows) {
+  const widths = columns.map(
+    (column) => Math.max(column.length, ...rows.map((row) => row[column].length))
+  );
+  const formatRow = (row) => columns.map((column, index) => row[column].padEnd(widths[index])).join("  ");
+  console.log(formatRow(Object.fromEntries(columns.map((column) => [column, column]))));
+  console.log(widths.map((width) => "-".repeat(width)).join("  "));
+  for (const row of rows) {
+    console.log(formatRow(row));
+  }
+}
+function findCollisions(skills) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    counts.set(skill.name, (counts.get(skill.name) ?? 0) + 1);
+  }
+  return new Set(
+    [...counts.entries()].filter(([, count]) => count > 1).map(([name]) => name)
+  );
+}
+function filterInstallableSkills({
+  skills,
+  selectedNames,
+  includeAll
+}) {
+  const collisions = findCollisions(skills);
+  if (collisions.size > 0) {
+    console.log(
+      `Skipping colliding skill names: ${[...collisions].sort().join(", ")}`
+    );
+  }
+  const installable = skills.filter((skill) => !collisions.has(skill.name));
+  if (selectedNames.length > 0) {
+    const selected = new Set(selectedNames);
+    return installable.filter((skill) => selected.has(skill.name));
+  }
+  return includeAll ? installable : [];
+}
+function installedStatuses({
+  targets,
+  skills
+}) {
+  const skillsByDir = new Map(
+    skills.map((skill) => [resolve4(skill.skillDir), skill])
+  );
+  const skillsByName = new Map(skills.map((skill) => [skill.name, skill]));
+  const statuses = [];
+  for (const target of targets) {
+    for (const installed of listInstalledSkills(target.path)) {
+      const skill = installed.target ? skillsByDir.get(resolve4(installed.target)) : null;
+      let matchedSkill = skill ?? null;
+      let status = "hand-authored";
+      if (installed.type === "symlink") {
+        if (installed.target === null || !exists(installed.target)) {
+          status = "broken";
+          matchedSkill = skillsByName.get(installed.name) ?? null;
+        } else if (skill) {
+          status = installed.name === skill.name ? "up to date" : "name mismatch";
+        } else if (skillsByName.has(installed.name)) {
+          matchedSkill = skillsByName.get(installed.name) ?? null;
+          status = "outdated";
+        } else {
+          status = "orphaned";
+        }
+      }
+      statuses.push({
+        target,
+        name: installed.name,
+        type: installed.type,
+        path: installed.path,
+        targetPath: installed.target,
+        status,
+        skill: matchedSkill
+      });
+    }
+  }
+  const installedNames = new Set(
+    statuses.filter(
+      (status) => ["up to date", "outdated", "broken", "name mismatch"].includes(
+        status.status
+      )
+    ).map((status) => `${status.target.name}\0${status.name}`)
+  );
+  for (const target of targets) {
+    for (const skill of skills) {
+      if (!installedNames.has(`${target.name}\0${skill.name}`)) {
+        statuses.push({
+          target,
+          name: skill.name,
+          type: "missing",
+          path: `${target.path}/${skill.name}`,
+          targetPath: skill.skillDir,
+          status: "new",
+          skill
+        });
+      }
+    }
+  }
+  return statuses;
+}
+function printStatusTable(statuses, projectRoot) {
+  printTable(
+    ["Target", "Skill", "Status", "Path", "Source"],
+    statuses.map((status) => ({
+      Target: status.target.name,
+      Skill: status.name,
+      Status: status.status,
+      Path: displayPath(status.path, projectRoot),
+      Source: displayPath(status.targetPath, projectRoot)
+    }))
+  );
+}
+function printInstalledSkillsTable(statuses, projectRoot) {
+  const installed = statuses.filter((status) => status.type !== "missing");
+  if (installed.length === 0) {
+    console.log("No skills installed.");
+    return;
+  }
+  printStatusTable(installed, projectRoot);
+}
+async function selectSkillsInteractive(skills) {
+  return checkbox({
+    message: "Select skills to install (press Space to select, Enter to confirm):",
+    choices: skills.map((skill) => ({
+      name: `${skill.name} (${skill.packageName})`,
+      value: skill
+    }))
+  });
+}
+async function selectInstalledSkillsInteractive(statuses) {
+  const removable = statuses.filter((status) => status.type === "symlink");
+  if (removable.length === 0) {
+    return [];
+  }
+  return checkbox({
+    message: "Select skills to remove (press Space to select, Enter to confirm):",
+    choices: removable.map((status) => ({
+      name: `${status.name} [${status.target.name}]`,
+      value: status
+    }))
+  });
+}
+function installSelected({
+  skills,
+  targets,
+  projectRoot,
+  copy = false
+}) {
+  let installedCount = 0;
+  for (const target of targets) {
+    for (const skill of skills) {
+      try {
+        const dest = installSkill(skill, target.path, { copy });
+        const method = copy ? "Copied" : "Symlinked";
+        console.log(
+          `${method}: ${skill.name} (${skill.packageName}) -> ${displayPath(
+            dest,
+            projectRoot
+          )}`
+        );
+        installedCount++;
+      } catch (error) {
+        if (error instanceof InstallError) {
+          console.log(`Skipped ${skill.name}: ${error.message}`);
+        } else {
+          throw error;
+        }
+      }
+    }
+  }
+  return installedCount;
+}
+async function sync(options) {
+  const context = getProjectContext();
+  const result = scanContext(context);
+  const targets = getTargetDirs(context.projectRoot, {
+    includeClaude: options.claude
+  });
+  printContext(context);
+  console.log();
+  printWarnings(result.warnings);
+  if (result.warnings.length > 0) {
+    console.log();
+  }
+  const selectedNames = options.skill ?? [];
+  const collisions = findCollisions(result.skills);
+  const candidateSkills = topLevelSkills({
+    context,
+    skills: result.skills,
+    includeAll: Boolean(options.all) || selectedNames.length > 0
+  });
+  const candidateSkillNames = new Set(
+    candidateSkills.map((skill) => skill.name)
+  );
+  const statuses = installedStatuses({
+    targets,
+    skills: result.skills.filter((skill) => !collisions.has(skill.name))
+  });
+  const visibleStatuses = statuses.filter(
+    (status) => status.status !== "new" || candidateSkillNames.has(status.name)
+  );
+  if (visibleStatuses.length > 0) {
+    printStatusTable(visibleStatuses, context.projectRoot);
+  } else {
+    console.log("No installed or discovered skills found.");
+  }
+  const drift = statuses.filter(
+    (status) => ["broken", "outdated", "name mismatch", "orphaned"].includes(status.status)
+  );
+  if (options.check) {
+    if (drift.length > 0 || collisions.size > 0) {
+      process.exitCode = 1;
+    }
+    return;
+  }
+  for (const status of drift) {
+    if (options.yes && (status.status === "broken" || status.status === "outdated") && status.skill) {
+      installSkill(status.skill, status.target.path);
+    }
+  }
+  let selected = filterInstallableSkills({
+    skills: candidateSkills,
+    selectedNames,
+    includeAll: Boolean(options.all)
+  });
+  if (selected.length === 0 && !options.yes && selectedNames.length === 0 && !options.all) {
+    const newSkills = visibleStatuses.filter((status) => status.status === "new" && status.skill !== null).map((status) => status.skill);
+    if (newSkills.length > 0) {
+      selected = await selectSkillsInteractive(newSkills);
+    }
+  }
+  if (selected.length > 0) {
+    console.log();
+    const installedCount = installSelected({
+      skills: selected,
+      targets,
+      projectRoot: context.projectRoot
+    });
+    console.log();
+    console.log(`Installed ${installedCount} skill target(s).`);
+  }
+}
+function scanCommand(options) {
+  const context = getProjectContext();
+  const result = scanContext(context);
+  const skills = topLevelSkills({
+    context,
+    skills: result.skills,
+    includeAll: Boolean(options.all)
+  });
+  if (options.json) {
+    console.log(
+      JSON.stringify(scanJsonPayload({ context, skills, result }), null, 2)
+    );
+    return;
+  }
+  printContext(context);
+  console.log();
+  printWarnings(result.warnings);
+  if (result.warnings.length > 0) {
+    console.log();
+  }
+  printSkills(skills);
+}
+function listCommand(options) {
+  const context = getProjectContext();
+  const result = scanContext(context);
+  const skills = topLevelSkills({
+    context,
+    skills: result.skills,
+    includeAll: Boolean(options.all)
+  });
+  const targets = getTargetDirs(context.projectRoot, {
+    includeClaude: options.claude
+  });
+  const statuses = installedStatuses({ targets, skills: result.skills });
+  if (options.json) {
+    const payload = scanJsonPayload({ context, skills, result });
+    console.log(
+      JSON.stringify(
+        {
+          ...payload,
+          installed: statuses.filter((status) => status.type !== "missing").map((status) => ({
+            target: status.target.name,
+            name: status.name,
+            status: status.status,
+            path: status.path,
+            source: status.targetPath ?? ""
+          }))
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  printWarnings(result.warnings);
+  if (options.installed) {
+    printInstalledSkillsTable(statuses, context.projectRoot);
+  } else {
+    printSkills(skills);
+  }
+}
+async function installCommand(options) {
+  const context = getProjectContext();
+  const result = scanContext(context);
+  const selectedNames = options.skill ?? [];
+  const skills = topLevelSkills({
+    context,
+    skills: result.skills,
+    includeAll: Boolean(options.all) || selectedNames.length > 0
+  });
+  const targets = getTargetDirs(context.projectRoot, {
+    includeClaude: options.claude
+  });
+  printWarnings(result.warnings);
+  let selected = filterInstallableSkills({
+    skills,
+    selectedNames,
+    includeAll: Boolean(options.all)
+  });
+  if (selected.length === 0 && !options.yes) {
+    selected = await selectSkillsInteractive(skills);
+  }
+  if (selected.length === 0) {
+    console.log("No skills selected.");
+    return;
+  }
+  const installedCount = installSelected({
+    skills: selected,
+    targets,
+    projectRoot: context.projectRoot,
+    copy: options.copy
+  });
+  console.log();
+  console.log(`Installed ${installedCount} skill target(s).`);
+}
+async function removeCommand(skillNames, options) {
+  const context = getProjectContext();
+  const result = scanContext(context);
+  const targets = getTargetDirs(context.projectRoot, {
+    includeClaude: options.claude
+  });
+  const statuses = installedStatuses({ targets, skills: result.skills });
+  let selectedStatuses = [];
+  if (skillNames.length > 0) {
+    const selected = new Set(skillNames);
+    selectedStatuses = statuses.filter(
+      (status) => selected.has(status.name) && status.type === "symlink"
+    );
+  } else if (!options.yes) {
+    selectedStatuses = await selectInstalledSkillsInteractive(statuses);
+  }
+  if (selectedStatuses.length === 0) {
+    console.log("No skills selected.");
+    return;
+  }
+  for (const status of selectedStatuses) {
+    if (uninstallSkill(status.name, status.target.path)) {
+      console.log(`Removed: ${status.name} (${status.target.name})`);
+    } else {
+      console.log(`Not found: ${status.name} (${status.target.name})`);
+    }
+  }
+}
+function createProgram() {
+  const program = new Command().enablePositionalOptions();
+  program.name("library-skills").description(
+    "Discover and install agent skills from installed library packages."
+  ).option("--claude", "Also manage .claude/skills alongside .agents/skills").option("-y, --yes", "Skip confirmation prompts").option("--check", "Validate only; exit 1 if installs drift").option("--all", "Install all newly discovered unmanaged skills").option(
+    "-s, --skill <name>",
+    "Install a specific discovered skill by name",
+    collect,
+    []
+  ).action(async (options) => {
+    await sync(options);
+  });
+  program.command("scan").description("Discover skills in installed packages.").option("--json", "Output as JSON").option("--all", "Include skills from transitive dependencies").action((options) => {
+    scanCommand(options);
+  });
+  program.command("list").description("List discovered or currently installed skills.").option("--installed", "Only show installed skills").option("--json", "Output as JSON").option("--claude", "Also include .claude/skills alongside .agents/skills").option("--all", "Include skills from transitive dependencies").action((options) => {
+    listCommand(options);
+  });
+  program.command("install").description("Install skills from installed packages.").option(
+    "--claude",
+    "Also install in .claude/skills alongside .agents/skills"
+  ).option("-y, --yes", "Skip interactive selection").option("--all", "Install all newly discovered unmanaged skills").option(
+    "-s, --skill <name>",
+    "Install a specific discovered skill by name",
+    collect,
+    []
+  ).option("--copy", "Copy files instead of creating symlinks").action(async (options) => {
+    await installCommand(options);
+  });
+  program.command("remove").description("Remove installed symlinked skills.").argument("[skills...]", "Names of skills to remove").option(
+    "--claude",
+    "Also remove from .claude/skills alongside .agents/skills"
+  ).option("-y, --yes", "Skip interactive selection").action(
+    async (skillNames, options) => {
+      await removeCommand(skillNames, options);
+    }
+  );
+  return program;
+}
+async function main(argv = process.argv) {
+  await createProgram().parseAsync(argv);
+}
+function collect(value, previous) {
+  previous.push(value);
+  return previous;
+}
+function exists(path) {
+  try {
+    statSync4(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+if (process.argv[1] && fileURLToPath2(import.meta.url) === resolve4(process.argv[1])) {
+  main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}
+var testing = {
+  filterInstallableSkills,
+  findCollisions,
+  getProjectContext,
+  installSelected,
+  installedStatuses,
+  listCommand,
+  scanCommand,
+  sync,
+  topLevelSkills,
+  displayPath,
+  printTable
+};
+export {
+  createProgram,
+  main,
+  testing
+};