skissue 0.1.11

package/dist/entry.js

@@ -0,0 +1,1127 @@
+#!/usr/bin/env node
+
+
+// src/entry.ts
+import { Command } from "commander";
+import { createRequire } from "node:module";
+import { resolve as resolve2 } from "node:path";
+
+// src/commands/init.ts
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { existsSync as existsSync3 } from "node:fs";
+import { mkdir as mkdir3 } from "node:fs/promises";
+
+// src/config.ts
+import { existsSync } from "node:fs";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import YAML from "yaml";
+import { z } from "zod";
+
+// src/paths.ts
+import { join } from "node:path";
+function skillIssueDir(cwd) {
+  return join(cwd, ".skill-issue");
+}
+function configPath(cwd) {
+  return join(skillIssueDir(cwd), "config.yaml");
+}
+function lockPath(cwd) {
+  return join(skillIssueDir(cwd), "lock.json");
+}
+function skillInstallPath(cwd, skillsRoot, skillId) {
+  const root = skillsRoot.startsWith("/") ? skillsRoot : join(cwd, skillsRoot);
+  return join(root, skillId);
+}
+
+// src/config.ts
+var RegistryConfigSchema = z.object({
+  owner: z.string().optional(),
+  repo: z.string().optional(),
+  branch: z.string().min(1).default("main"),
+  /**
+   * When true: always use SSH. When false: always use HTTPS (with token if set).
+   * When omitted: use HTTPS if GITHUB_TOKEN/GH_TOKEN is set, else SSH (typical local dev).
+   */
+  useSsh: z.boolean().optional(),
+  path: z.string().optional()
+}).superRefine((data, ctx) => {
+  const local = data.path != null && data.path.trim().length > 0;
+  const remote = Boolean(data.owner?.trim() && data.repo?.trim());
+  if (local && remote) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Use either registry.path (local) or registry.owner + registry.repo (remote), not both.",
+      path: ["path"]
+    });
+  }
+  if (!local && !remote) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Set registry.path to a local directory, or registry.owner and registry.repo for a GitHub registry."
+    });
+  }
+});
+var ConfigSchema = z.object({
+  registry: RegistryConfigSchema,
+  skillsRoot: z.string().min(1).default(".agents/skills")
+});
+var DEFAULT_CONFIG_YAML = `# Remote (GitHub) \u2014 omit useSsh for auto (SSH if no token, else HTTPS+token):
+# registry:
+#   owner: your-org
+#   repo: skill-registry
+#   branch: main
+#   useSsh: false  # optional: force HTTPS; true forces SSH
+#
+# Local (path is relative to the consumer project root):
+# registry:
+#   path: ../skill-registry
+#   branch: main
+#
+skillsRoot: .agents/skills
+`;
+function isLocalRegistry(config) {
+  return Boolean(config.registry.path?.trim());
+}
+async function needsSetup(cwd) {
+  const path = configPath(cwd);
+  if (!existsSync(path)) {
+    return true;
+  }
+  try {
+    const raw = await readFile(path, "utf8");
+    parseConfigYaml(raw);
+    return false;
+  } catch {
+    return true;
+  }
+}
+async function loadConfig(cwd) {
+  const path = configPath(cwd);
+  const raw = await readFile(path, "utf8");
+  const data = YAML.parse(raw);
+  return ConfigSchema.parse(data);
+}
+async function writeConfig(cwd, config) {
+  const path = configPath(cwd);
+  await mkdir(dirname(path), { recursive: true });
+  const obj = ConfigSchema.parse(config);
+  await writeFile(path, YAML.stringify(obj, { lineWidth: 0 }), "utf8");
+}
+function parseConfigYaml(raw) {
+  return ConfigSchema.parse(YAML.parse(raw));
+}
+function defaultConfigTemplate() {
+  return DEFAULT_CONFIG_YAML;
+}
+
+// src/git/registry-repo.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2, statSync } from "node:fs";
+import { mkdir as mkdir2, access, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join as join2, resolve } from "node:path";
+
+// src/git/exec.ts
+import { spawn } from "node:child_process";
+function execGit(args, options = {}) {
+  return new Promise((resolve3) => {
+    const env = { ...process.env, ...options.env };
+    if (env.GIT_TERMINAL_PROMPT === void 0) {
+      env.GIT_TERMINAL_PROMPT = "0";
+    }
+    const child = spawn("git", args, {
+      cwd: options.cwd,
+      env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const { timeoutMs } = options;
+    const timeout = timeoutMs != null && timeoutMs > 0 ? setTimeout(() => {
+      child.kill("SIGTERM");
+    }, timeoutMs) : void 0;
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("close", (code, signal) => {
+      if (timeout !== void 0) clearTimeout(timeout);
+      if (signal === "SIGTERM") {
+        resolve3({
+          code: 124,
+          stdout,
+          stderr: `${stderr}
+skissue: git timed out after ${timeoutMs}ms`.trim()
+        });
+        return;
+      }
+      resolve3({ code: code ?? 1, stdout, stderr });
+    });
+    child.on("error", (err) => {
+      if (timeout !== void 0) clearTimeout(timeout);
+      resolve3({ code: 1, stdout, stderr: String(err) });
+    });
+  });
+}
+
+// src/git/registry-repo.ts
+function githubTokenFromEnv() {
+  const raw = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+  const t = typeof raw === "string" ? raw.trim() : "";
+  return t.length > 0 ? t : void 0;
+}
+function resolveRegistryTransport(config) {
+  if (isLocalRegistry(config)) {
+    return "https";
+  }
+  const { useSsh } = config.registry;
+  if (useSsh === true) {
+    return "ssh";
+  }
+  if (useSsh === false) {
+    return "https";
+  }
+  return githubTokenFromEnv() ? "https" : "ssh";
+}
+function registryCacheDir(config) {
+  const owner = config.registry.owner ?? "";
+  const repo = config.registry.repo ?? "";
+  const transport = resolveRegistryTransport(config);
+  const key = `${owner}/${repo}/${transport}`;
+  const hash = createHash("sha256").update(key).digest("hex").slice(0, 16);
+  return join2(homedir(), ".cache", "skissue", "registries", hash);
+}
+function remoteFailureHint(transport, url, exitCode) {
+  if (exitCode === 124) {
+    return "\n\nTimed out. Check the network or set registry.path to a local clone.";
+  }
+  if (transport === "ssh") {
+    return [
+      "",
+      `
+
+Used SSH: ${url}`,
+      'GitHub often reports "Repository not found" when the repo is private and your SSH key has no access, or when owner/repo is wrong.',
+      "Check registry.owner and registry.repo in .skill-issue/config.yaml, run `ssh -T git@github.com`, and confirm your GitHub user can access that repository.",
+      "Alternatives: clone the registry repo locally and set registry.path, or set GITHUB_TOKEN and registry.useSsh: false to use HTTPS."
+    ].join("\n");
+  }
+  return [
+    "",
+    `
+
+Used HTTPS: ${url}`,
+    "Private repos need GITHUB_TOKEN or GH_TOKEN (or omit registry.useSsh with no token to use SSH).",
+    "Or set registry.path to a local clone."
+  ].join("\n");
+}
+function registryGitUrl(config) {
+  const owner = config.registry.owner;
+  const repo = config.registry.repo;
+  const transport = resolveRegistryTransport(config);
+  if (transport === "ssh") {
+    return `git@github.com:${owner}/${repo}.git`;
+  }
+  const token = githubTokenFromEnv();
+  if (token) {
+    return `https://x-access-token:${token}@github.com/${owner}/${repo}.git`;
+  }
+  return `https://github.com/${owner}/${repo}.git`;
+}
+async function ensureRegistryCheckout(cwd, config) {
+  if (isLocalRegistry(config)) {
+    const root = resolve(cwd, config.registry.path.trim());
+    if (!existsSync2(root) || !statSync(root).isDirectory()) {
+      throw new Error(`Local registry path does not exist or is not a directory: ${root}`);
+    }
+    const hasRegistry = existsSync2(join2(root, "registry.json")) || existsSync2(join2(root, "registry"));
+    if (!hasRegistry) {
+      throw new Error(
+        `Local registry must contain registry.json or a registry/ directory: ${root}`
+      );
+    }
+    const before = await execGit(["rev-parse", "HEAD"], { cwd: root });
+    if (before.code !== 0) {
+      throw new Error(
+        `Local registry must be a git repository root (with commits) so installs can be locked: ${root}`
+      );
+    }
+    const pull = await execGit(["pull", "--ff-only"], { cwd: root, timeoutMs: 12e4 });
+    if (pull.code !== 0) {
+      process.stderr.write(
+        `skissue: could not fast-forward local registry (using current checkout): ${(pull.stderr || pull.stdout || "unknown").trim()}
+`
+      );
+    }
+    const head2 = await execGit(["rev-parse", "HEAD"], { cwd: root });
+    if (head2.code !== 0) {
+      throw new Error(`Local registry git rev-parse failed: ${root}`);
+    }
+    return { path: root, head: head2.stdout.trim() };
+  }
+  const dir = registryCacheDir(config);
+  const transport = resolveRegistryTransport(config);
+  const url = registryGitUrl(config);
+  const branch = config.registry.branch;
+  const parent = join2(homedir(), ".cache", "skissue", "registries");
+  await mkdir2(parent, { recursive: true });
+  let hasGit = false;
+  try {
+    await access(join2(dir, ".git"));
+    hasGit = true;
+  } catch {
+    hasGit = false;
+  }
+  if (!hasGit) {
+    await rm(dir, { recursive: true, force: true }).catch(() => void 0);
+    const clone = await execGit(["clone", "--depth", "1", "--branch", branch, url, dir], {
+      timeoutMs: 6e5
+    });
+    if (clone.code !== 0) {
+      const base = `git clone failed (${clone.code}): ${clone.stderr || clone.stdout}`.trim();
+      throw new Error(base + remoteFailureHint(transport, url, clone.code));
+    }
+  } else {
+    const fetch = await execGit(
+      ["fetch", "origin", `refs/heads/${branch}:refs/remotes/origin/${branch}`, "--depth", "1"],
+      { cwd: dir, timeoutMs: 3e5 }
+    );
+    if (fetch.code !== 0) {
+      const base = `git fetch failed (${fetch.code}): ${fetch.stderr || fetch.stdout}`.trim();
+      throw new Error(base + remoteFailureHint(transport, url, fetch.code));
+    }
+    const reset = await execGit(["reset", "--hard", `origin/${branch}`], {
+      cwd: dir,
+      timeoutMs: 6e4
+    });
+    if (reset.code !== 0) {
+      throw new Error(`git reset failed (${reset.code}): ${reset.stderr || reset.stdout}`.trim());
+    }
+  }
+  const head = await execGit(["rev-parse", "HEAD"], { cwd: dir });
+  if (head.code !== 0) {
+    throw new Error(`git rev-parse failed: ${head.stderr}`);
+  }
+  return { path: dir, head: head.stdout.trim() };
+}
+async function ensureCommit(repoPath, sha) {
+  const have = await execGit(["cat-file", "-e", `${sha}^{commit}`], { cwd: repoPath });
+  if (have.code === 0) return;
+  const fetch = await execGit(["fetch", "origin", sha, "--depth", "1"], {
+    cwd: repoPath,
+    timeoutMs: 3e5
+  });
+  if (fetch.code !== 0) {
+    const fetch2 = await execGit(["fetch", "origin", `${sha}:${sha}`, "--depth", "1"], {
+      cwd: repoPath,
+      timeoutMs: 3e5
+    });
+    if (fetch2.code !== 0) {
+      throw new Error(
+        `Could not fetch commit ${sha}: ${fetch.stderr || fetch2.stderr || fetch.stdout}`
+      );
+    }
+  }
+}
+async function diffPath(repoPath, fromCommit, toCommit, pathInRepo) {
+  await ensureCommit(repoPath, fromCommit);
+  await ensureCommit(repoPath, toCommit);
+  const p3 = pathInRepo.replace(/^\.\/+/, "").replace(/\/+$/, "");
+  const diff = await execGit(["diff", fromCommit, toCommit, "--", p3], { cwd: repoPath });
+  if (diff.code !== 0) {
+    throw new Error(`git diff failed: ${diff.stderr}`);
+  }
+  return diff.stdout;
+}
+function isPathStale(diffStdout) {
+  return diffStdout.trim().length > 0;
+}
+
+// src/commands/init.ts
+function summarizeConfig(cfg) {
+  const r = cfg.registry;
+  if (r.path?.trim()) {
+    return `Local registry: ${r.path}
+Branch label: ${r.branch}
+skillsRoot: ${cfg.skillsRoot}`;
+  }
+  const t = resolveRegistryTransport(cfg);
+  const mode = r.useSsh === void 0 ? `${t.toUpperCase()} (auto)` : `${t.toUpperCase()} (registry.useSsh: ${r.useSsh})`;
+  return `Remote registry: ${r.owner}/${r.repo}
+Transport: ${mode}
+Branch: ${r.branch}
+skillsRoot: ${cfg.skillsRoot}`;
+}
+async function runInit(cwd) {
+  p.intro(chalk.bold("skissue init"));
+  const existingPath = configPath(cwd);
+  let hasExistingConfig = false;
+  if (existsSync3(existingPath)) {
+    hasExistingConfig = true;
+    try {
+      const existing = await loadConfig(cwd);
+      p.note(summarizeConfig(existing), "Current config");
+    } catch (err) {
+      p.note(err instanceof Error ? err.message : String(err), "Existing config (could not parse)");
+    }
+    const overwrite = await p.confirm({
+      message: "Overwrite existing .skill-issue/config.yaml?",
+      initialValue: false
+    });
+    if (p.isCancel(overwrite) || !overwrite) {
+      p.cancel("Aborted. Existing config unchanged.");
+      process.exit(0);
+    }
+  }
+  const source = await p.select({
+    message: "Where does the skill registry live?",
+    options: [
+      {
+        value: "local",
+        label: "Local directory \u2014 skill-registry repo root (registry.json + registry/)"
+      },
+      {
+        value: "remote",
+        label: "GitHub \u2014 clone registry from owner/repo"
+      }
+    ],
+    initialValue: "local"
+  });
+  if (p.isCancel(source)) {
+    p.cancel("Aborted.");
+    process.exit(0);
+  }
+  let cfg;
+  if (source === "local") {
+    const regPath = await p.text({
+      message: "Path to registry repo root (relative to this project or absolute). Must contain registry/ and be a git repository.",
+      placeholder: ".",
+      initialValue: ".",
+      validate: (v) => v?.trim() ? void 0 : "Required"
+    });
+    if (p.isCancel(regPath)) {
+      p.cancel("Aborted.");
+      process.exit(0);
+    }
+    const branch = await p.text({
+      message: "Branch label (stored in config; installs use git HEAD from that directory)",
+      initialValue: "main",
+      validate: (v) => v?.trim() ? void 0 : "Required"
+    });
+    if (p.isCancel(branch)) {
+      p.cancel("Aborted.");
+      process.exit(0);
+    }
+    cfg = ConfigSchema.parse({
+      registry: {
+        path: String(regPath).trim(),
+        branch: String(branch).trim()
+      },
+      skillsRoot: ".agents/skills"
+    });
+  } else {
+    const owner = await p.text({
+      message: "GitHub registry owner (org or user)",
+      placeholder: "acme",
+      validate: (v) => v?.trim() ? void 0 : "Required"
+    });
+    if (p.isCancel(owner)) {
+      p.cancel("Aborted.");
+      process.exit(0);
+    }
+    const repo = await p.text({
+      message: "Registry repository name",
+      placeholder: "skill-registry",
+      validate: (v) => v?.trim() ? void 0 : "Required"
+    });
+    if (p.isCancel(repo)) {
+      p.cancel("Aborted.");
+      process.exit(0);
+    }
+    const branch = await p.text({
+      message: "Branch to track",
+      initialValue: "main",
+      validate: (v) => v?.trim() ? void 0 : "Required"
+    });
+    if (p.isCancel(branch)) {
+      p.cancel("Aborted.");
+      process.exit(0);
+    }
+    cfg = ConfigSchema.parse({
+      registry: {
+        owner: String(owner).trim(),
+        repo: String(repo).trim(),
+        branch: String(branch).trim()
+      },
+      skillsRoot: ".agents/skills"
+    });
+  }
+  const skillsRoot = await p.text({
+    message: "Install skills under (relative to project root)",
+    initialValue: cfg.skillsRoot,
+    validate: (v) => v?.trim() ? void 0 : "Required"
+  });
+  if (p.isCancel(skillsRoot)) {
+    p.cancel("Aborted.");
+    process.exit(0);
+  }
+  cfg = ConfigSchema.parse({ ...cfg, skillsRoot: String(skillsRoot).trim() });
+  const confirm3 = await p.confirm({
+    message: hasExistingConfig ? `Overwrite ${chalk.cyan(".skill-issue/config.yaml")} and use ${chalk.cyan(cfg.skillsRoot)} for installs?` : `Create ${chalk.cyan(".skill-issue/config.yaml")} and use ${chalk.cyan(cfg.skillsRoot)} for installs?`,
+    initialValue: true
+  });
+  if (p.isCancel(confirm3) || !confirm3) {
+    p.cancel("Aborted.");
+    process.exit(0);
+  }
+  const dir = skillIssueDir(cwd);
+  await mkdir3(dir, { recursive: true });
+  await writeConfig(cwd, cfg);
+  p.note(defaultConfigTemplate().trim(), "Template reference");
+  p.outro(
+    chalk.green(
+      "Wrote .skill-issue/config.yaml. Run skissue install <id>, or skissue for the manage menu."
+    )
+  );
+}
+
+// src/commands/install.ts
+import chalk2 from "chalk";
+import ora from "ora";
+import { join as join5 } from "node:path";
+
+// src/lockfile.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir4 } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+import { z as z2 } from "zod";
+var LockSkillEntrySchema = z2.object({
+  registryCommit: z2.string().min(1),
+  skillPath: z2.string().min(1),
+  ref: z2.string().min(1)
+});
+var LockSchema = z2.object({
+  version: z2.literal(1),
+  skills: z2.record(z2.string(), LockSkillEntrySchema)
+});
+function emptyLock() {
+  return { version: 1, skills: {} };
+}
+async function readLock(cwd) {
+  const path = lockPath(cwd);
+  const raw = await readFile2(path, "utf8");
+  const data = JSON.parse(raw);
+  return LockSchema.parse(data);
+}
+async function writeLock(cwd, lock) {
+  const path = lockPath(cwd);
+  await mkdir4(dirname2(path), { recursive: true });
+  const parsed = LockSchema.parse(lock);
+  await writeFile2(path, JSON.stringify(parsed, null, 2) + "\n", "utf8");
+}
+async function readLockOrEmpty(cwd) {
+  try {
+    return await readLock(cwd);
+  } catch {
+    return emptyLock();
+  }
+}
+function upsertSkillLock(lock, skillId, entry) {
+  return {
+    ...lock,
+    skills: { ...lock.skills, [skillId]: entry }
+  };
+}
+function removeSkillLock(lock, skillId) {
+  const skills = { ...lock.skills };
+  delete skills[skillId];
+  return { ...lock, skills };
+}
+
+// src/registry/resolve.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+import { z as z3 } from "zod";
+var RegistryJsonSchema = z3.object({
+  skills: z3.record(z3.string(), z3.string()).optional()
+}).passthrough();
+async function resolveSkillPath(registryRepoRoot, skillId) {
+  const registryFile = join3(registryRepoRoot, "registry.json");
+  let raw;
+  try {
+    raw = await readFile3(registryFile, "utf8");
+  } catch {
+    return { skillPath: join3("registry", skillId).replace(/\\/g, "/"), source: "convention" };
+  }
+  const parsed = JSON.parse(raw);
+  const reg = RegistryJsonSchema.safeParse(parsed);
+  if (!reg.success || !reg.data.skills) {
+    return { skillPath: join3("registry", skillId).replace(/\\/g, "/"), source: "convention" };
+  }
+  const mapped = reg.data.skills[skillId];
+  if (mapped !== void 0 && mapped.length > 0) {
+    return { skillPath: normalizeRelPath(mapped), source: "registry.json" };
+  }
+  return { skillPath: join3("registry", skillId).replace(/\\/g, "/"), source: "convention" };
+}
+function normalizeRelPath(p3) {
+  return p3.replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+$/, "");
+}
+
+// src/io.ts
+import { access as access2, cp, rm as rm2 } from "node:fs/promises";
+import { constants } from "node:fs";
+import { join as join4 } from "node:path";
+async function assertSkillMdPresent(skillSourceDir) {
+  const p3 = join4(skillSourceDir, "SKILL.md");
+  try {
+    await access2(p3, constants.R_OK);
+  } catch {
+    throw new Error(`Expected SKILL.md in skill path: ${skillSourceDir}`);
+  }
+}
+async function copySkillTree(fromDir, toDir) {
+  await rm2(toDir, { recursive: true, force: true }).catch(() => void 0);
+  await cp(fromDir, toDir, { recursive: true, force: true });
+}
+
+// src/commands/install.ts
+async function installSkillFromCheckout(cwd, config, repoPath, head, skillId) {
+  const { skillPath } = await resolveSkillPath(repoPath, skillId);
+  const src = join5(repoPath, skillPath);
+  await assertSkillMdPresent(src);
+  const dest = skillInstallPath(cwd, config.skillsRoot, skillId);
+  await copySkillTree(src, dest);
+  const lock = await readLockOrEmpty(cwd);
+  const ref = isLocalRegistry(config) ? "local" : `refs/heads/${config.registry.branch}`;
+  const next = upsertSkillLock(lock, skillId, {
+    registryCommit: head,
+    skillPath,
+    ref
+  });
+  await writeLock(cwd, next);
+  return dest;
+}
+async function runInstall(cwd, skillId) {
+  const config = await loadConfig(cwd);
+  const spin = ora(`Resolving registry and installing ${skillId}`).start();
+  try {
+    const { path: repoPath, head } = await ensureRegistryCheckout(cwd, config);
+    const dest = await installSkillFromCheckout(cwd, config, repoPath, head, skillId);
+    spin.succeed(chalk2.green(`Installed ${skillId} \u2192 ${dest}`));
+  } catch (err) {
+    spin.fail(chalk2.red(err instanceof Error ? err.message : String(err)));
+    throw err;
+  }
+}
+async function runInstallMany(cwd, skillIds, options) {
+  const config = await loadConfig(cwd);
+  let repoPath;
+  let head;
+  if (options?.checkout) {
+    ({ path: repoPath, head } = options.checkout);
+  } else {
+    const prep = ora("Preparing registry\u2026").start();
+    try {
+      const c = await ensureRegistryCheckout(cwd, config);
+      repoPath = c.path;
+      head = c.head;
+      prep.succeed(chalk2.green("Registry ready."));
+    } catch (err) {
+      prep.fail(chalk2.red(err instanceof Error ? err.message : String(err)));
+      throw err;
+    }
+  }
+  for (const skillId of skillIds) {
+    const spin = ora(`Installing ${skillId}\u2026`).start();
+    try {
+      const dest = await installSkillFromCheckout(cwd, config, repoPath, head, skillId);
+      spin.succeed(chalk2.green(`Installed ${skillId} \u2192 ${dest}`));
+    } catch (err) {
+      spin.fail(chalk2.red(err instanceof Error ? err.message : String(err)));
+      throw err;
+    }
+  }
+}
+
+// src/commands/uninstall.ts
+import chalk3 from "chalk";
+import ora2 from "ora";
+import { rm as rm3 } from "node:fs/promises";
+async function runUninstall(cwd, skillId) {
+  const config = await loadConfig(cwd);
+  const spin = ora2(`Removing ${skillId}`).start();
+  try {
+    const dest = skillInstallPath(cwd, config.skillsRoot, skillId);
+    await rm3(dest, { recursive: true, force: true });
+    const lock = await readLockOrEmpty(cwd);
+    if (!lock.skills[skillId]) {
+      spin.stopAndPersist({
+        symbol: chalk3.yellow("\u26A0"),
+        text: chalk3.yellow(`No lock entry for ${skillId}; removed directory if present.`)
+      });
+    } else {
+      await writeLock(cwd, removeSkillLock(lock, skillId));
+      spin.succeed(chalk3.green(`Uninstalled ${skillId}`));
+    }
+  } catch (err) {
+    spin.fail(chalk3.red(err instanceof Error ? err.message : String(err)));
+    throw err;
+  }
+}
+
+// src/commands/list.ts
+import chalk4 from "chalk";
+async function runList(cwd) {
+  const config = await loadConfig(cwd);
+  const lock = await readLockOrEmpty(cwd);
+  const ids = Object.keys(lock.skills).sort();
+  if (ids.length === 0) {
+    console.log(chalk4.dim("No skills installed (lock empty)."));
+    return;
+  }
+  for (const id of ids) {
+    const e = lock.skills[id];
+    const dest = skillInstallPath(cwd, config.skillsRoot, id);
+    console.log(
+      [
+        chalk4.bold(id),
+        chalk4.dim("\u2192"),
+        dest,
+        chalk4.dim(`commit=${e.registryCommit.slice(0, 7)} path=${e.skillPath}`)
+      ].join(" ")
+    );
+  }
+}
+
+// src/commands/outdated.ts
+import chalk5 from "chalk";
+import ora3 from "ora";
+async function runOutdated(cwd) {
+  const config = await loadConfig(cwd);
+  const lock = await readLockOrEmpty(cwd);
+  const ids = Object.keys(lock.skills).sort();
+  if (ids.length === 0) {
+    console.log(chalk5.dim("Nothing installed."));
+    return;
+  }
+  const spin = ora3("Fetching registry and comparing paths").start();
+  try {
+    const { path: repoPath, head } = await ensureRegistryCheckout(cwd, config);
+    spin.stop();
+    for (const id of ids) {
+      const e = lock.skills[id];
+      const d = await diffPath(repoPath, e.registryCommit, head, e.skillPath);
+      const stale = isPathStale(d);
+      if (stale) {
+        console.log(
+          chalk5.yellow(`${id}`) + chalk5.dim(
+            ` outdated (path changed ${e.registryCommit.slice(0, 7)} \u2192 ${head.slice(0, 7)})`
+          )
+        );
+      } else {
+        console.log(chalk5.green(`${id}`) + chalk5.dim(` up to date @ ${head.slice(0, 7)}`));
+      }
+    }
+  } catch (err) {
+    spin.fail(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/update.ts
+import chalk6 from "chalk";
+async function runUpdate(cwd, skillId) {
+  await loadConfig(cwd);
+  const lock = await readLockOrEmpty(cwd);
+  if (skillId) {
+    if (!lock.skills[skillId]) {
+      console.error(chalk6.red(`Unknown skill in lock: ${skillId}`));
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      await runInstall(cwd, skillId);
+    } catch {
+      process.exitCode = 1;
+    }
+    return;
+  }
+  const ids = Object.keys(lock.skills).sort();
+  if (ids.length === 0) {
+    console.log(chalk6.dim("Nothing to update (lock empty)."));
+    return;
+  }
+  try {
+    await runInstallMany(cwd, ids);
+  } catch {
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/manage.ts
+import * as p2 from "@clack/prompts";
+import chalk8 from "chalk";
+
+// src/commands/banner.ts
+import chalk7 from "chalk";
+var LOGO = [
+  "  \u2597\u2584\u2584\u2596\u2597\u2596 \u2597\u2596\u2597\u2584\u2584\u2584\u2596\u2597\u2596   \u2597\u2596   ",
+  "  \u2590\u258C   \u2590\u258C\u2597\u259E\u2598  \u2588  \u2590\u258C   \u2590\u258C   ",
+  "  \u259D\u2580\u259A\u2596 \u2590\u259B\u259A\u2596   \u2588  \u2590\u258C   \u2590\u258C   ",
+  "  \u2597\u2584\u2584\u259E\u2598\u2590\u258C \u2590\u258C\u2597\u2584\u2588\u2584\u2596\u2590\u2599\u2584\u2584\u2596\u2590\u2599\u2584\u2584\u2596",
+  "  \u2597\u2584\u2584\u2584\u2596\u2597\u2584\u2584\u2596\u2597\u2584\u2584\u2596\u2597\u2596 \u2597\u2596\u2597\u2584\u2584\u2584\u2596  ",
+  "    \u2588  \u2590\u258C   \u2590\u258C   \u2590\u258C \u2590\u258C\u2590\u258C    ",
+  "    \u2588   \u259D\u2580\u259A\u2596 \u259D\u2580\u259A\u2596\u2590\u258C \u2590\u258C\u2590\u259B\u2580\u2580\u2598 ",
+  "  \u2597\u2584\u2588\u2584\u2596\u2597\u2584\u2584\u259E\u2598\u2597\u2584\u2584\u259E\u2598\u259D\u259A\u2584\u259E\u2598\u2590\u2599\u2584\u2584\u2596 "
+];
+var GRADIENT_STOPS = [
+  [99, 102, 241],
+  [139, 92, 246],
+  [192, 132, 252],
+  [233, 213, 255],
+  [192, 132, 252],
+  [139, 92, 246],
+  [99, 102, 241],
+  [79, 70, 229]
+];
+function lerpColor(a, b, t) {
+  return [
+    Math.round(a[0] + (b[0] - a[0]) * t),
+    Math.round(a[1] + (b[1] - a[1]) * t),
+    Math.round(a[2] + (b[2] - a[2]) * t)
+  ];
+}
+function gradientLine(line, row, totalRows) {
+  const stopIdx = row / Math.max(1, totalRows - 1) * (GRADIENT_STOPS.length - 1);
+  const lo = Math.floor(stopIdx);
+  const hi = Math.min(lo + 1, GRADIENT_STOPS.length - 1);
+  const t = stopIdx - lo;
+  const [r, g, b] = lerpColor(GRADIENT_STOPS[lo], GRADIENT_STOPS[hi], t);
+  return chalk7.rgb(r, g, b)(line);
+}
+function printSkillIssueBanner(version) {
+  console.log("");
+  for (let i = 0; i < LOGO.length; i++) {
+    console.log(gradientLine(LOGO[i], i, LOGO.length));
+  }
+  if (version) {
+    console.log(chalk7.dim(`  v${version}`));
+  }
+  console.log("");
+}
+
+// src/registry/catalog.ts
+import { access as access3, readFile as readFile4, readdir } from "node:fs/promises";
+import { constants as constants2 } from "node:fs";
+import { join as join6 } from "node:path";
+import { z as z4 } from "zod";
+var RegistryJsonSchema2 = z4.object({
+  skills: z4.record(z4.string(), z4.string()).optional()
+}).passthrough();
+async function listRegistrySkillIds(registryRepoRoot) {
+  const ids = /* @__PURE__ */ new Set();
+  const registryFile = join6(registryRepoRoot, "registry.json");
+  try {
+    const raw = await readFile4(registryFile, "utf8");
+    const parsed = JSON.parse(raw);
+    const reg = RegistryJsonSchema2.safeParse(parsed);
+    if (reg.success && reg.data.skills) {
+      for (const id of Object.keys(reg.data.skills)) {
+        if (id.trim()) ids.add(id);
+      }
+    }
+  } catch {
+  }
+  const registryDir = join6(registryRepoRoot, "registry");
+  try {
+    const entries = await readdir(registryDir, { withFileTypes: true });
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      const id = e.name;
+      if (!id.trim()) continue;
+      const skillRoot = join6(registryDir, id);
+      try {
+        await access3(join6(skillRoot, "SKILL.md"), constants2.R_OK);
+        ids.add(id);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return [...ids].sort((a, b) => a.localeCompare(b));
+}
+
+// src/commands/manage.ts
+function printRegistryStats(catalogLen, installed, canInstall) {
+  const sep = chalk8.dim(" \xB7 ");
+  const line = [
+    chalk8.dim("Registry"),
+    chalk8.cyan(catalogLen),
+    chalk8.dim("skills"),
+    sep,
+    chalk8.dim("installed"),
+    chalk8.cyan(installed),
+    sep,
+    chalk8.dim("not installed"),
+    chalk8.cyan(canInstall)
+  ].join(" ");
+  p2.log.info(line);
+}
+async function runManage(cwd) {
+  printSkillIssueBanner();
+  p2.intro(chalk8.dim("manage"));
+  const config = await loadConfig(cwd);
+  const spin = p2.spinner();
+  spin.start("Preparing registry\u2026");
+  let checkout;
+  try {
+    checkout = await ensureRegistryCheckout(cwd, config);
+    spin.stop(chalk8.green("Registry ready."));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    spin.stop(chalk8.red(msg));
+    throw err;
+  }
+  const catalog = await listRegistrySkillIds(checkout.path);
+  let lock = await readLockOrEmpty(cwd);
+  while (true) {
+    const installedIds = Object.keys(lock.skills).sort();
+    const available = catalog.filter((id) => !lock.skills[id]);
+    printRegistryStats(catalog.length, installedIds.length, available.length);
+    const action = await p2.select({
+      message: chalk8.bold("Next step"),
+      initialValue: "install",
+      options: [
+        {
+          value: "install",
+          label: "Install",
+          hint: chalk8.dim(`${available.length} available`)
+        },
+        {
+          value: "uninstall",
+          label: "Uninstall",
+          hint: chalk8.dim(`${installedIds.length} installed`)
+        },
+        { value: "done", label: "Exit", hint: chalk8.dim("back to shell") }
+      ]
+    });
+    if (p2.isCancel(action)) {
+      p2.cancel("Aborted.");
+      process.exit(0);
+    }
+    if (action === "done") {
+      p2.outro(chalk8.green("Finished."));
+      return;
+    }
+    if (action === "install") {
+      if (available.length === 0) {
+        p2.log.warn(
+          chalk8.dim("Nothing left to install \u2014 everything in the registry is already installed.")
+        );
+        continue;
+      }
+      p2.log.message(chalk8.dim("Space toggle \xB7 Enter confirm \xB7 Esc cancel"));
+      const selected2 = await p2.multiselect({
+        message: "Skills to install",
+        options: available.map((id) => ({ value: id, label: id })),
+        required: false
+      });
+      if (p2.isCancel(selected2)) {
+        p2.cancel("Aborted.");
+        process.exit(0);
+      }
+      if (selected2.length === 0) {
+        p2.log.warn(chalk8.dim("No selection \u2014 back to the menu."));
+        continue;
+      }
+      const ok2 = await p2.confirm({
+        message: `Install ${chalk8.cyan(selected2.join(", "))}?`,
+        initialValue: true
+      });
+      if (p2.isCancel(ok2)) {
+        p2.cancel("Aborted.");
+        process.exit(0);
+      }
+      if (!ok2) continue;
+      await runInstallMany(cwd, selected2, { checkout });
+      lock = await readLockOrEmpty(cwd);
+      continue;
+    }
+    if (installedIds.length === 0) {
+      p2.log.warn(chalk8.dim("Nothing installed yet."));
+      continue;
+    }
+    p2.log.message(chalk8.dim("Space toggle \xB7 Enter confirm \xB7 Esc cancel"));
+    const selected = await p2.multiselect({
+      message: "Skills to remove",
+      options: installedIds.map((id) => ({ value: id, label: id })),
+      required: false
+    });
+    if (p2.isCancel(selected)) {
+      p2.cancel("Aborted.");
+      process.exit(0);
+    }
+    if (selected.length === 0) {
+      p2.log.warn(chalk8.dim("No selection \u2014 back to the menu."));
+      continue;
+    }
+    const ok = await p2.confirm({
+      message: `Remove ${chalk8.cyan(selected.join(", "))}?`,
+      initialValue: false
+    });
+    if (p2.isCancel(ok)) {
+      p2.cancel("Aborted.");
+      process.exit(0);
+    }
+    if (!ok) continue;
+    const toRemove = [...selected].sort((a, b) => a.localeCompare(b));
+    for (const id of toRemove) {
+      await runUninstall(cwd, id);
+    }
+    lock = await readLockOrEmpty(cwd);
+  }
+}
+
+// src/commands/default.ts
+async function runDefault(cwd) {
+  if (await needsSetup(cwd)) {
+    await runInit(cwd);
+    await runManage(cwd);
+  } else {
+    await runManage(cwd);
+  }
+}
+
+// src/commands/doctor.ts
+import chalk9 from "chalk";
+function nodeOk() {
+  const major = Number(process.versions.node.split(".")[0]);
+  if (Number.isFinite(major) && major >= 24) {
+    return { ok: true, detail: `Node ${process.version}` };
+  }
+  return { ok: false, detail: `Node ${process.version} (need >=24)` };
+}
+function authHint(config) {
+  if (isLocalRegistry(config)) {
+    return "";
+  }
+  const t = resolveRegistryTransport(config);
+  if (t === "ssh") {
+    return "Registry uses SSH (or auto: no token in env); ensure `ssh -T git@github.com` succeeds.";
+  }
+  if (process.env.GITHUB_TOKEN || process.env.GH_TOKEN) {
+    return "Registry uses HTTPS with GITHUB_TOKEN or GH_TOKEN.";
+  }
+  return "HTTPS without a token (registry.useSsh: false). Public repos only, or set a token / omit registry.useSsh for auto SSH when no token.";
+}
+async function runDoctor(cwd) {
+  const n = nodeOk();
+  console.log(n.ok ? chalk9.green(`\u2713 ${n.detail}`) : chalk9.red(`\u2717 ${n.detail}`));
+  let config;
+  try {
+    config = await loadConfig(cwd);
+    console.log(chalk9.green("\u2713 .skill-issue/config.yaml valid"));
+  } catch (e) {
+    console.log(chalk9.red(`\u2717 config: ${e instanceof Error ? e.message : String(e)}`));
+    process.exitCode = 1;
+    return;
+  }
+  if (!isLocalRegistry(config)) {
+    console.log(chalk9.dim(`\u2022 ${authHint(config)}`));
+  }
+  try {
+    const { path: repoPath, head } = await ensureRegistryCheckout(cwd, config);
+    const label = isLocalRegistry(config) ? "Local registry" : "Registry cache";
+    console.log(chalk9.green(`\u2713 ${label} synced (${repoPath}) @ ${head.slice(0, 7)}`));
+  } catch (e) {
+    console.log(chalk9.red(`\u2717 Registry: ${e instanceof Error ? e.message : String(e)}`));
+    process.exitCode = 1;
+  }
+}
+
+// src/entry.ts
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var program = new Command();
+program.name("skissue").description("Install and sync agent skills from a GitHub registry or a local registry path").version(pkg.version);
+program.command("init").description("Create .skill-issue/config and confirm skills install path").action(async () => {
+  const cwd = process.cwd();
+  try {
+    await runInit(cwd);
+  } catch (e) {
+    console.error(e);
+    process.exitCode = 1;
+  }
+});
+program.command("install").description("Install a skill by id from the registry").argument("<id>", "Skill id").action(async (id) => {
+  const cwd = process.cwd();
+  try {
+    await runInstall(cwd, id);
+  } catch {
+    process.exitCode = 1;
+  }
+});
+program.command("uninstall").description("Remove an installed skill and lock entry").argument("<id>", "Skill id").action(async (id) => {
+  const cwd = process.cwd();
+  try {
+    await runUninstall(cwd, id);
+  } catch {
+    process.exitCode = 1;
+  }
+});
+program.command("list").description("List installed skills and lock info").action(async () => {
+  const cwd = process.cwd();
+  try {
+    await runList(cwd);
+  } catch {
+    process.exitCode = 1;
+  }
+});
+program.command("manage").alias("browse").description("Interactive menu: install or uninstall skills from the registry").action(async () => {
+  const cwd = process.cwd();
+  try {
+    await runManage(cwd);
+  } catch {
+    process.exitCode = 1;
+  }
+});
+program.command("outdated").description("Show skills whose registry path changed since lock").action(async () => {
+  const cwd = process.cwd();
+  try {
+    await runOutdated(cwd);
+  } catch {
+    process.exitCode = 1;
+  }
+});
+program.command("update").description("Re-fetch and overwrite installed skill(s); refresh lock").argument("[id]", "Optional skill id (default: all locked skills)").action(async (id) => {
+  const cwd = process.cwd();
+  try {
+    await runUpdate(cwd, id);
+  } catch {
+    process.exitCode = 1;
+  }
+});
+program.command("doctor").description("Check Node, config, and sync registry checkout").option("-C, --cwd <path>", "Project root", process.cwd()).action(async (opts) => {
+  const cwd = resolve2(opts.cwd ?? process.cwd());
+  try {
+    await runDoctor(cwd);
+  } catch {
+    process.exitCode = 1;
+  }
+});
+program.action(async () => {
+  const cwd = process.cwd();
+  try {
+    await runDefault(cwd);
+  } catch {
+    process.exitCode = 1;
+  }
+});
+program.parseAsync(process.argv).catch((e) => {
+  console.error(e);
+  process.exit(1);
+});