@robosoft/skillhub-cli 0.1.0

package/bin/skillhub.mjs

@@ -0,0 +1,747 @@
+#!/usr/bin/env node
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+import process from "node:process";
+
+const CONFIG_FILE = "skillhub.json";
+const LOCK_FILE = "skillhub.lock.json";
+const DEFAULT_SKILLS_DIR = ".ai/skills";
+const GENERATED_START = "<!-- skillhub:start -->";
+const GENERATED_END = "<!-- skillhub:end -->";
+
+const colors = {
+  reset: "\x1b[0m",
+  dim: "\x1b[2m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  cyan: "\x1b[36m",
+  bold: "\x1b[1m",
+};
+
+function paint(color, value) {
+  return `${colors[color] ?? ""}${value}${colors.reset}`;
+}
+
+function ok(message) {
+  console.log(`${paint("green", "✓")} ${message}`);
+}
+
+function warn(message) {
+  console.log(`${paint("yellow", "!")} ${message}`);
+}
+
+function info(message) {
+  console.log(`${paint("cyan", "›")} ${message}`);
+}
+
+function fail(message) {
+  console.error(`${paint("red", "✕")} ${message}`);
+}
+
+async function exists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+async function readJson(filePath, fallback = null) {
+  if (!(await exists(filePath))) return fallback;
+  const raw = await fs.readFile(filePath, "utf8");
+  return JSON.parse(raw);
+}
+
+async function writeJson(filePath, value) {
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function now() {
+  return new Date().toISOString();
+}
+
+function normalizeSlashes(value) {
+  return value.split(path.sep).join("/");
+}
+
+function safeJoin(root, relativePath) {
+  const target = path.resolve(root, relativePath);
+  const normalizedRoot = path.resolve(root);
+  if (!target.startsWith(normalizedRoot)) {
+    throw new Error(`Unsafe path detected: ${relativePath}`);
+  }
+  return target;
+}
+
+function parseFlags(argv) {
+  const positional = [];
+  const flags = {};
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+
+    const raw = arg.slice(2);
+    const [name, inlineValue] = raw.split("=");
+
+    if (inlineValue !== undefined) {
+      flags[name] = inlineValue;
+      continue;
+    }
+
+    const next = argv[index + 1];
+    if (next && !next.startsWith("--")) {
+      flags[name] = next;
+      index += 1;
+    } else {
+      flags[name] = true;
+    }
+  }
+
+  return { positional, flags };
+}
+
+function parseSkillSpec(spec) {
+  if (!spec || spec.trim().length === 0) {
+    throw new Error("Skill name is required.");
+  }
+
+  const trimmed = spec.trim();
+  const atIndex = trimmed.lastIndexOf("@");
+
+  if (atIndex > 0) {
+    return {
+      name: trimmed.slice(0, atIndex),
+      version: trimmed.slice(atIndex + 1),
+    };
+  }
+
+  return { name: trimmed, version: null };
+}
+
+function sortVersions(versions) {
+  return versions.sort((left, right) => {
+    const a = left.split(".").map((part) => Number.parseInt(part, 10) || 0);
+    const b = right.split(".").map((part) => Number.parseInt(part, 10) || 0);
+
+    for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
+      const diff = (b[index] ?? 0) - (a[index] ?? 0);
+      if (diff !== 0) return diff;
+    }
+
+    return right.localeCompare(left);
+  });
+}
+
+async function listFiles(root, current = root) {
+  const entries = await fs.readdir(current, { withFileTypes: true });
+  const files = [];
+
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === ".git") continue;
+
+    const fullPath = path.join(current, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...(await listFiles(root, fullPath)));
+    } else {
+      files.push(normalizeSlashes(path.relative(root, fullPath)));
+    }
+  }
+
+  return files.sort();
+}
+
+async function readSkillPackageFiles(packageDir) {
+  const filePaths = await listFiles(packageDir);
+  const files = [];
+
+  for (const relativePath of filePaths) {
+    const fullPath = path.join(packageDir, relativePath);
+    const content = await fs.readFile(fullPath, "utf8");
+    files.push({ path: relativePath, content });
+  }
+
+  return files;
+}
+
+function checksumFiles(files) {
+  const hash = crypto.createHash("sha256");
+  for (const file of files.sort((a, b) => a.path.localeCompare(b.path))) {
+    hash.update(file.path);
+    hash.update("\0");
+    hash.update(file.content);
+    hash.update("\0");
+  }
+  return `sha256-${hash.digest("hex")}`;
+}
+
+function defaultConfig(projectRoot) {
+  return {
+    $schema: "https://skillhub.local/schema/skillhub.schema.json",
+    project: path.basename(projectRoot),
+    registry: "./skillhub-registry",
+    skillsDir: DEFAULT_SKILLS_DIR,
+    skills: {},
+    adapters: {
+      agentsMd: true,
+      cursorRules: true,
+      claude: false,
+      githubCopilot: false,
+    },
+  };
+}
+
+function defaultLock() {
+  return {
+    lockfileVersion: 1,
+    updatedAt: now(),
+    skills: {},
+  };
+}
+
+async function readProjectConfig(projectRoot) {
+  const configPath = path.join(projectRoot, CONFIG_FILE);
+  const config = await readJson(configPath, null);
+  if (!config) {
+    throw new Error(`No ${CONFIG_FILE} found. Run: skillhub init`);
+  }
+  return config;
+}
+
+function resolveRegistry(projectRoot, config, flags = {}) {
+  const value = flags.registry || process.env.SKILLHUB_REGISTRY || config.registry || "./skillhub-registry";
+
+  if (value.startsWith("http://") || value.startsWith("https://")) {
+    return value.replace(/\/$/, "");
+  }
+
+  return path.resolve(projectRoot, value);
+}
+
+async function loadLocalSkill(registryPath, name, requestedVersion) {
+  const skillRoot = safeJoin(registryPath, name);
+
+  if (!(await exists(skillRoot))) {
+    throw new Error(`Skill "${name}" was not found in registry: ${registryPath}`);
+  }
+
+  let packageDir;
+  let version = requestedVersion;
+
+  if (requestedVersion) {
+    packageDir = path.join(skillRoot, requestedVersion);
+  } else if (await exists(path.join(skillRoot, "skill.json"))) {
+    packageDir = skillRoot;
+  } else {
+    const entries = await fs.readdir(skillRoot, { withFileTypes: true });
+    const versions = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    if (versions.length === 0) {
+      throw new Error(`Skill "${name}" has no versions in registry.`);
+    }
+    version = sortVersions(versions)[0];
+    packageDir = path.join(skillRoot, version);
+  }
+
+  if (!(await exists(packageDir))) {
+    throw new Error(`Skill "${name}@${requestedVersion}" was not found.`);
+  }
+
+  const manifestPath = path.join(packageDir, "skill.json");
+  if (!(await exists(manifestPath))) {
+    throw new Error(`Missing skill.json in ${packageDir}`);
+  }
+
+  const manifest = await readJson(manifestPath);
+  const files = await readSkillPackageFiles(packageDir);
+
+  validateSkillManifest(manifest, files);
+
+  return {
+    manifest: {
+      ...manifest,
+      name: manifest.name || name,
+      version: manifest.version || version || "0.0.0",
+    },
+    files,
+    source: normalizeSlashes(path.relative(process.cwd(), packageDir)) || packageDir,
+  };
+}
+
+async function loadRemoteSkill(registryUrl, name, requestedVersion) {
+  const versionPath = requestedVersion ? requestedVersion : "latest";
+  const url = `${registryUrl}/skills/${encodeURIComponent(name)}/${encodeURIComponent(versionPath)}`;
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`Registry returned ${response.status} for ${url}`);
+  }
+
+  const payload = await response.json();
+  const manifest = payload.manifest || payload.skill || payload;
+  const files = payload.files || [];
+
+  validateSkillManifest(manifest, files);
+
+  return {
+    manifest,
+    files,
+    source: url,
+  };
+}
+
+async function loadSkill(registry, name, requestedVersion) {
+  if (registry.startsWith("http://") || registry.startsWith("https://")) {
+    return loadRemoteSkill(registry, name, requestedVersion);
+  }
+
+  return loadLocalSkill(registry, name, requestedVersion);
+}
+
+function validateSkillManifest(manifest, files) {
+  if (!manifest || typeof manifest !== "object") {
+    throw new Error("Invalid skill manifest.");
+  }
+
+  if (!manifest.name) throw new Error("skill.json must include name.");
+  if (!manifest.version) throw new Error("skill.json must include version.");
+
+  const hasSkillMd = files.some((file) => file.path === "SKILL.md");
+  if (!hasSkillMd) {
+    throw new Error(`${manifest.name}@${manifest.version} must include SKILL.md.`);
+  }
+}
+
+async function writeSkillFiles(projectRoot, skillsDir, skillName, files) {
+  const targetDir = path.join(projectRoot, skillsDir, skillName);
+  await fs.rm(targetDir, { recursive: true, force: true });
+  await ensureDir(targetDir);
+
+  for (const file of files) {
+    const targetPath = safeJoin(targetDir, file.path);
+    await ensureDir(path.dirname(targetPath));
+    await fs.writeFile(targetPath, file.content, "utf8");
+  }
+
+  return targetDir;
+}
+
+async function updateAdapters(projectRoot, config, lock) {
+  const adapters = config.adapters || {};
+  const skillsDir = config.skillsDir || DEFAULT_SKILLS_DIR;
+  const installed = Object.entries(lock.skills || {}).sort(([a], [b]) => a.localeCompare(b));
+
+  if (adapters.agentsMd) {
+    await updateAgentsMd(projectRoot, skillsDir, installed);
+  }
+
+  if (adapters.cursorRules) {
+    await updateCursorRules(projectRoot, skillsDir, installed);
+  }
+
+  if (adapters.claude) {
+    await updateClaudeMd(projectRoot, skillsDir, installed);
+  }
+
+  if (adapters.githubCopilot) {
+    await updateCopilotInstructions(projectRoot, skillsDir, installed);
+  }
+}
+
+function generatedSkillList(skillsDir, installed) {
+  if (installed.length === 0) {
+    return "No SkillHub skills installed yet.";
+  }
+
+  return installed
+    .map(([name, meta]) => `- ${name}@${meta.version}: ${skillsDir}/${name}/SKILL.md`)
+    .join("\n");
+}
+
+async function replaceGeneratedBlock(filePath, generatedBlock, defaultPrefix = "") {
+  let content = defaultPrefix;
+
+  if (await exists(filePath)) {
+    content = await fs.readFile(filePath, "utf8");
+  }
+
+  const block = `${GENERATED_START}\n${generatedBlock.trim()}\n${GENERATED_END}`;
+  const pattern = new RegExp(`${GENERATED_START}[\\s\\S]*?${GENERATED_END}`);
+
+  if (pattern.test(content)) {
+    content = content.replace(pattern, block);
+  } else {
+    const separator = content.trim().length > 0 ? "\n\n" : "";
+    content = `${content.trimEnd()}${separator}${block}\n`;
+  }
+
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf8");
+}
+
+async function updateAgentsMd(projectRoot, skillsDir, installed) {
+  const body = `# SkillHub Instructions\n\nWhen working in this project, read and follow the installed skills below before generating or changing code.\n\n${generatedSkillList(skillsDir, installed)}`;
+  await replaceGeneratedBlock(path.join(projectRoot, "AGENTS.md"), body, "# Project Agents\n");
+}
+
+async function updateCursorRules(projectRoot, skillsDir, installed) {
+  const body = `---\ndescription: SkillHub installed project skills\nalwaysApply: true\n---\n\n# SkillHub Rules\n\nFollow these installed skill files before editing code:\n\n${generatedSkillList(skillsDir, installed)}`;
+  await ensureDir(path.join(projectRoot, ".cursor/rules"));
+  await fs.writeFile(path.join(projectRoot, ".cursor/rules/skillhub.mdc"), `${body}\n`, "utf8");
+}
+
+async function updateClaudeMd(projectRoot, skillsDir, installed) {
+  const body = `# SkillHub Instructions\n\nFollow the installed skills below:\n\n${generatedSkillList(skillsDir, installed)}`;
+  await replaceGeneratedBlock(path.join(projectRoot, "CLAUDE.md"), body, "# Claude Project Instructions\n");
+}
+
+async function updateCopilotInstructions(projectRoot, skillsDir, installed) {
+  const body = `# SkillHub Instructions\n\nUse these installed skill files as project coding guidance:\n\n${generatedSkillList(skillsDir, installed)}`;
+  await replaceGeneratedBlock(path.join(projectRoot, ".github/copilot-instructions.md"), body, "# GitHub Copilot Instructions\n");
+}
+
+async function commandInit(projectRoot, flags) {
+  const configPath = path.join(projectRoot, CONFIG_FILE);
+  const lockPath = path.join(projectRoot, LOCK_FILE);
+
+  if (await exists(configPath)) {
+    warn(`${CONFIG_FILE} already exists.`);
+  } else {
+    const config = defaultConfig(projectRoot);
+    if (flags.registry) config.registry = flags.registry;
+    await writeJson(configPath, config);
+    ok(`Created ${CONFIG_FILE}`);
+  }
+
+  if (await exists(lockPath)) {
+    warn(`${LOCK_FILE} already exists.`);
+  } else {
+    await writeJson(lockPath, defaultLock());
+    ok(`Created ${LOCK_FILE}`);
+  }
+
+  await ensureDir(path.join(projectRoot, DEFAULT_SKILLS_DIR));
+  ok(`Created ${DEFAULT_SKILLS_DIR}`);
+
+  info("Next: skillhub install nextjs-clean-architecture");
+}
+
+async function commandInstall(projectRoot, spec, flags = {}) {
+  const configPath = path.join(projectRoot, CONFIG_FILE);
+  const lockPath = path.join(projectRoot, LOCK_FILE);
+  const config = await readProjectConfig(projectRoot);
+  const lock = (await readJson(lockPath, null)) || defaultLock();
+  const registry = resolveRegistry(projectRoot, config, flags);
+  const { name, version } = parseSkillSpec(spec);
+
+  info(`Resolving ${name}${version ? `@${version}` : ""}`);
+  const skill = await loadSkill(registry, name, version);
+  const skillName = skill.manifest.name;
+  const skillsDir = config.skillsDir || DEFAULT_SKILLS_DIR;
+  const checksum = checksumFiles(skill.files);
+
+  await writeSkillFiles(projectRoot, skillsDir, skillName, skill.files);
+
+  config.skills = config.skills || {};
+  config.skills[skillName] = skill.manifest.version;
+  await writeJson(configPath, config);
+
+  lock.updatedAt = now();
+  lock.skills = lock.skills || {};
+  lock.skills[skillName] = {
+    version: skill.manifest.version,
+    source: skill.source,
+    installTo: `${skillsDir}/${skillName}`,
+    checksum,
+    installedAt: now(),
+  };
+  await writeJson(lockPath, lock);
+
+  await updateAdapters(projectRoot, config, lock);
+
+  ok(`Installed ${skillName}@${skill.manifest.version}`);
+  info(`Files written to ${skillsDir}/${skillName}`);
+}
+
+async function commandSync(projectRoot, flags = {}) {
+  const config = await readProjectConfig(projectRoot);
+  const skills = Object.entries(config.skills || {});
+
+  if (skills.length === 0) {
+    warn("No skills configured in skillhub.json.");
+    return;
+  }
+
+  for (const [name, version] of skills) {
+    await commandInstall(projectRoot, `${name}@${version}`, flags);
+  }
+
+  ok(`Synced ${skills.length} skill${skills.length === 1 ? "" : "s"}.`);
+}
+
+async function commandList(projectRoot) {
+  const lock = await readJson(path.join(projectRoot, LOCK_FILE), null);
+
+  if (!lock || !lock.skills || Object.keys(lock.skills).length === 0) {
+    warn("No skills installed yet.");
+    return;
+  }
+
+  console.log(paint("bold", "Installed SkillHub skills"));
+  for (const [name, meta] of Object.entries(lock.skills).sort(([a], [b]) => a.localeCompare(b))) {
+    console.log(`- ${name}@${meta.version} ${paint("dim", `→ ${meta.installTo}`)}`);
+  }
+}
+
+async function commandRemove(projectRoot, skillName) {
+  if (!skillName) throw new Error("Skill name is required.");
+
+  const configPath = path.join(projectRoot, CONFIG_FILE);
+  const lockPath = path.join(projectRoot, LOCK_FILE);
+  const config = await readProjectConfig(projectRoot);
+  const lock = (await readJson(lockPath, null)) || defaultLock();
+  const skillsDir = config.skillsDir || DEFAULT_SKILLS_DIR;
+
+  delete config.skills?.[skillName];
+  delete lock.skills?.[skillName];
+  lock.updatedAt = now();
+
+  await fs.rm(path.join(projectRoot, skillsDir, skillName), { recursive: true, force: true });
+  await writeJson(configPath, config);
+  await writeJson(lockPath, lock);
+  await updateAdapters(projectRoot, config, lock);
+
+  ok(`Removed ${skillName}`);
+}
+
+async function commandCreate(projectRoot, name, flags = {}) {
+  if (!name) throw new Error("Skill name is required.");
+
+  const config = (await readJson(path.join(projectRoot, CONFIG_FILE), null)) || defaultConfig(projectRoot);
+  const registry = resolveRegistry(projectRoot, config, flags);
+
+  if (registry.startsWith("http://") || registry.startsWith("https://")) {
+    throw new Error("Cannot create a skill inside a remote registry. Use --registry ./path");
+  }
+
+  const version = flags.version || "1.0.0";
+  const category = flags.category || "general";
+  const packageDir = path.join(registry, name, version);
+
+  if (await exists(packageDir)) {
+    throw new Error(`Skill already exists: ${packageDir}`);
+  }
+
+  await ensureDir(path.join(packageDir, "rules"));
+  await ensureDir(path.join(packageDir, "checklist"));
+
+  await writeJson(path.join(packageDir, "skill.json"), {
+    name,
+    version,
+    description: flags.description || `Reusable ${name} project skill`,
+    category,
+    tags: [category],
+    entry: "SKILL.md",
+    compatibleWith: ["cursor", "claude", "chatgpt", "github-copilot"],
+  });
+
+  await fs.writeFile(
+    path.join(packageDir, "SKILL.md"),
+    `# ${name}\n\n## Purpose\n\nDescribe when this skill should be used.\n\n## Rules\n\n1. Add your first rule.\n2. Add examples and edge cases.\n3. Keep outputs consistent across projects.\n\n## Definition of Done\n\n- Requirements are clear\n- Implementation follows project standards\n- Tests or validation steps are documented\n`,
+    "utf8",
+  );
+
+  await fs.writeFile(path.join(packageDir, "rules/main.md"), `# ${name} Rules\n\n- Add project-specific rules here.\n`, "utf8");
+  await fs.writeFile(path.join(packageDir, "checklist/definition-of-done.md"), `# Definition of Done\n\n- [ ] Rules followed\n- [ ] Code reviewed\n- [ ] Edge cases checked\n`, "utf8");
+
+  ok(`Created ${name}@${version}`);
+  info(`Location: ${packageDir}`);
+}
+
+async function commandValidate(projectRoot, specOrPath, flags = {}) {
+  if (!specOrPath) throw new Error("Skill name or path is required.");
+
+  let skill;
+  if (specOrPath.includes("/") || specOrPath.includes("\\") || specOrPath.startsWith(".")) {
+    const packageDir = path.resolve(projectRoot, specOrPath);
+    const manifest = await readJson(path.join(packageDir, "skill.json"));
+    const files = await readSkillPackageFiles(packageDir);
+    validateSkillManifest(manifest, files);
+    skill = { manifest, files };
+  } else {
+    const config = await readProjectConfig(projectRoot);
+    const registry = resolveRegistry(projectRoot, config, flags);
+    const { name, version } = parseSkillSpec(specOrPath);
+    skill = await loadSkill(registry, name, version);
+  }
+
+  const checksum = checksumFiles(skill.files);
+  ok(`Valid skill: ${skill.manifest.name}@${skill.manifest.version}`);
+  info(`Files: ${skill.files.length}`);
+  info(`Checksum: ${checksum}`);
+}
+
+function toWords(value) {
+  return String(value)
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/[_\-/]+/g, " ")
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean);
+}
+
+function toKebabCase(value) {
+  return toWords(value)
+    .map((word) => word.toLowerCase())
+    .join("-");
+}
+
+function toCamelCase(value) {
+  const words = toWords(value).map((word) => word.toLowerCase());
+  return words
+    .map((word, index) => (index === 0 ? word : `${word.charAt(0).toUpperCase()}${word.slice(1)}`))
+    .join("");
+}
+
+function toPascalCase(value) {
+  return toWords(value)
+    .map((word) => `${word.charAt(0).toUpperCase()}${word.slice(1).toLowerCase()}`)
+    .join("");
+}
+
+function toTitleCase(value) {
+  return toWords(value)
+    .map((word) => `${word.charAt(0).toUpperCase()}${word.slice(1).toLowerCase()}`)
+    .join(" ");
+}
+
+function templateVariables(name, flags = {}) {
+  const baseName = name || flags.name;
+  if (!baseName) throw new Error("Generator name is required. Example: skillhub generate shadcn-crud-generator feature users");
+
+  return {
+    name: baseName,
+    kebabName: flags.kebabName || toKebabCase(baseName),
+    camelName: flags.camelName || toCamelCase(baseName),
+    pascalName: flags.pascalName || toPascalCase(baseName),
+    title: flags.title || toTitleCase(baseName),
+  };
+}
+
+function renderTemplate(value, variables) {
+  return value.replace(/{{\s*(\w+)\s*}}/g, (_, key) => variables[key] ?? "");
+}
+
+async function commandGenerate(projectRoot, skillName, templateName, resourceName, flags = {}) {
+  if (!skillName) throw new Error("Skill name is required.");
+  if (!templateName) throw new Error("Template name is required.");
+
+  const config = await readProjectConfig(projectRoot);
+  const skillsDir = config.skillsDir || DEFAULT_SKILLS_DIR;
+  const templateDir = path.join(projectRoot, skillsDir, skillName, "templates", templateName);
+
+  if (!(await exists(templateDir))) {
+    throw new Error(`Template not found: ${skillsDir}/${skillName}/templates/${templateName}. Install the skill first.`);
+  }
+
+  const variables = templateVariables(resourceName || flags.name, flags);
+  const outDir = path.resolve(projectRoot, flags.out || `src/features/${variables.kebabName}`);
+  const templateFiles = await listFiles(templateDir);
+
+  if (templateFiles.length === 0) {
+    warn(`No template files found in ${templateDir}`);
+    return;
+  }
+
+  for (const relativePath of templateFiles) {
+    const renderedRelativePath = renderTemplate(relativePath, variables).replace(/\.hbs$/, "");
+    const targetPath = safeJoin(outDir, renderedRelativePath);
+    const sourcePath = path.join(templateDir, relativePath);
+    const content = await fs.readFile(sourcePath, "utf8");
+
+    if ((await exists(targetPath)) && !flags.force) {
+      throw new Error(`File already exists: ${targetPath}. Use --force to overwrite.`);
+    }
+
+    await ensureDir(path.dirname(targetPath));
+    await fs.writeFile(targetPath, renderTemplate(content, variables), "utf8");
+    ok(`Generated ${normalizeSlashes(path.relative(projectRoot, targetPath))}`);
+  }
+
+  info(`Template variables: ${JSON.stringify(variables)}`);
+}
+
+function printHelp() {
+  console.log(`\n${paint("bold", "SkillHub CLI")}\n\nInstall reusable AI/project skills into any codebase.\n\n${paint("bold", "Usage")}\n  skillhub <command> [options]\n\n${paint("bold", "Commands")}\n  init                         Create skillhub.json, lockfile, and .ai/skills\n  install <skill[@version]>    Install a skill from the registry\n  sync                         Reinstall all skills from skillhub.json\n  list                         Show installed skills\n  remove <skill>               Remove an installed skill\n  create <skill>               Scaffold a new local skill package\n  validate <skill|path>        Validate skill.json and SKILL.md\n\n${paint("bold", "Options")}\n  --registry <path|url>         Registry location. Default: ./skillhub-registry\n  --version <version>           Version used by create. Default: 1.0.0\n  --category <name>             Category used by create. Default: general\n\n${paint("bold", "Examples")}\n  skillhub init\n  skillhub install nextjs-clean-architecture\n  skillhub install shadcn-crud-generator@1.0.0\n  skillhub sync\n  skillhub create api-security-rules --category security\n`);
+}
+
+async function main() {
+  const [, , command, ...rest] = process.argv;
+  const { positional, flags } = parseFlags(rest);
+  const projectRoot = process.cwd();
+
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    printHelp();
+    return;
+  }
+
+  switch (command) {
+    case "init":
+      await commandInit(projectRoot, flags);
+      break;
+    case "install":
+    case "add":
+      await commandInstall(projectRoot, positional[0], flags);
+      break;
+    case "sync":
+      await commandSync(projectRoot, flags);
+      break;
+    case "list":
+    case "ls":
+      await commandList(projectRoot);
+      break;
+    case "remove":
+    case "rm":
+      await commandRemove(projectRoot, positional[0]);
+      break;
+    case "create":
+      await commandCreate(projectRoot, positional[0], flags);
+      break;
+    case "validate":
+      await commandValidate(projectRoot, positional[0], flags);
+      break;
+    case "generate":
+    case "gen":
+      await commandGenerate(projectRoot, positional[0], positional[1], positional[2], flags);
+      break;
+    default:
+      throw new Error(`Unknown command: ${command}`);
+  }
+}
+
+main().catch((error) => {
+  fail(error.message);
+  process.exitCode = 1;
+});
+
+export {
+  parseSkillSpec,
+  checksumFiles,
+  sortVersions,
+  validateSkillManifest,
+  defaultConfig,
+};
+
+// Let people run this file through `node packages/skillhub-cli/bin/skillhub.mjs`.