@khalidsaidi/skillrunner 0.1.2 → 0.1.3

package/dist/cli.js

@@ -1,95 +1,1910 @@
 #!/usr/bin/env node
+
+// src/cli.ts
 import { Command } from "commander";
 import { createRequire } from "module";
-import { doctorCmd } from "./commands/doctor.js";
-import { listCmd } from "./commands/list.js";
-import { searchCmd } from "./commands/search.js";
-import { infoCmd } from "./commands/info.js";
-import { installCmd } from "./commands/install.js";
-import { uninstallCmd } from "./commands/uninstall.js";
-import { planCmd } from "./commands/plan.js";
-import { runCmd } from "./commands/run.js";
-import { logsCmd } from "./commands/logs.js";
-import { openCmd } from "./commands/open.js";
-import { cursorInstallCmd, cursorListCmd } from "./commands/cursor.js";
-const program = new Command();
-const require = createRequire(import.meta.url);
-const pkg = require("../package.json");
-const cliVersion = typeof pkg.version === "string" && pkg.version.trim() ? pkg.version : "0.0.0";
-program
-    .name("skill")
-    .description("SkillRunner — browse, install, and run skills")
-    .version(cliVersion)
-    .option("-j, --json", "Output JSON for extension integration");
-program
-    .command("doctor")
-    .option("--json")
-    .description("Check env, providers, registry")
-    .action(doctorCmd);
-program
-    .command("list")
-    .option("--json")
-    .description("List installed skills")
-    .action(listCmd);
-program
-    .command("search <query>")
-    .option("--json")
-    .description("Search registry")
-    .action(searchCmd);
-program
-    .command("info <name>")
-    .option("--json")
-    .description("Show skill details")
-    .action(infoCmd);
-program
-    .command("install <name>")
-    .option("--json")
-    .description("Install skill")
-    .action(installCmd);
-program
-    .command("uninstall <name>")
-    .option("--json")
-    .description("Uninstall skill")
-    .action(uninstallCmd);
-program
-    .command("plan <name>")
-    .option("--json")
-    .description("Show plan only")
-    .option("--inputs <pairs...>", "input k=v")
-    .action(planCmd);
-program
-    .command("run <name>")
-    .option("--json")
-    .description("Run skill")
-    .option("--yes", "Skip confirmation")
-    .option("--inputs <pairs...>", "input k=v")
-    .option("--cwd <dir>", "Working directory")
-    .option("--allow-dirty", "Allow dirty repo")
-    .option("--no-branch", "Do not create branch")
-    .action(runCmd);
-program
-    .command("logs")
-    .option("--json")
-    .description("Show run logs")
-    .option("--last", "Last run")
-    .option("--id <runId>", "Run ID")
-    .action(logsCmd);
-program
-    .command("open")
-    .option("--json")
-    .description("Open dashboard")
-    .action(openCmd);
-const cursorCmd = new Command("cursor").description("Cursor integration");
-cursorCmd
-    .command("install <name>")
-    .option("--json")
-    .option("--scope <scope>", "project|global", "project")
-    .action(cursorInstallCmd);
-cursorCmd
-    .command("list")
-    .option("--json")
-    .option("--scope <scope>", "project|global|both", "both")
-    .action(cursorListCmd);
+
+// src/commands/doctor.ts
+import chalk from "chalk";
+import { execSync } from "child_process";
+
+// ../engine/dist/parser.js
+import { existsSync, readFileSync, readdirSync } from "fs";
+import matter from "gray-matter";
+import { basename, extname, join } from "path";
+import YAML from "yaml";
+var REQUIRED_KEYS = ["name", "description"];
+var AVAILABILITY_VALUES = [
+  "default",
+  "advanced",
+  "conditional"
+];
+var CONTRACT_CANDIDATES = [
+  { file: "SKILL.md", type: "skill_md" },
+  { file: "skill.md", type: "skill_md" },
+  { file: "skill.yaml", type: "skill_yaml" },
+  { file: "skill.yml", type: "skill_yaml" },
+  { file: "skill.json", type: "skill_json" },
+  { file: "AGENTS.md", type: "agent_markdown" },
+  { file: "AGENT.md", type: "agent_markdown" },
+  { file: "CLAUDE.md", type: "agent_markdown" },
+  { file: "README.md", type: "readme_markdown" }
+];
+var ADAPTER_FALLBACK_PATTERNS = /(skill|agent|claude|instruction|contract)/i;
+var SUPPORTED_SKILL_CONTRACT_FILES = CONTRACT_CANDIDATES.map((v) => v.file);
+function parseSkillMd(content) {
+  const { data } = matter(content);
+  const meta = asRecord(data);
+  if (!meta) {
+    throw new Error("SKILL.md must have YAML frontmatter");
+  }
+  for (const key of REQUIRED_KEYS) {
+    if (!isNonEmptyString(meta[key])) {
+      throw new Error(`SKILL.md frontmatter must have "${key}" (string)`);
+    }
+  }
+  return normalizeSkillMeta(meta, { sourceLabel: "SKILL.md" });
+}
+function parseSkillContract(content, opts = {}) {
+  const sourcePath = opts.sourcePath || "";
+  const sourceLabel = sourcePath || "skill contract";
+  const contractType = opts.contractType || inferSkillContractType(sourcePath || "SKILL.md");
+  if (contractType === "skill_json") {
+    return parseSkillJson(content, sourceLabel, opts.fallbackName);
+  }
+  if (contractType === "skill_yaml") {
+    return parseSkillYaml(content, sourceLabel, opts.fallbackName);
+  }
+  if (contractType === "skill_md") {
+    try {
+      return parseSkillMd(content);
+    } catch {
+      return parseMarkdownContract(content, sourceLabel, opts.fallbackName);
+    }
+  }
+  return parseMarkdownContract(content, sourceLabel, opts.fallbackName);
+}
+function inferSkillContractType(pathOrFile) {
+  const normalized = pathOrFile.trim().toLowerCase();
+  const file = normalized.split("/").filter(Boolean).pop() || normalized;
+  if (file === "skill.md")
+    return "skill_md";
+  if (file === "skill.yaml" || file === "skill.yml")
+    return "skill_yaml";
+  if (file === "skill.json")
+    return "skill_json";
+  if (file === "agent.md" || file === "agents.md" || file === "claude.md") {
+    return "agent_markdown";
+  }
+  if (file === "readme.md")
+    return "readme_markdown";
+  const ext = extname(file);
+  if (ext === ".json")
+    return "skill_json";
+  if (ext === ".yaml" || ext === ".yml")
+    return "skill_yaml";
+  if (ext === ".md")
+    return "agent_markdown";
+  return "skill_md";
+}
+function findSkillContractFile(skillDir) {
+  for (const candidate of CONTRACT_CANDIDATES) {
+    if (existsSync(join(skillDir, candidate.file))) {
+      return { ...candidate };
+    }
+  }
+  try {
+    const files = readdirSync(skillDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => {
+      const ext = extname(name).toLowerCase();
+      return ext === ".md" || ext === ".json" || ext === ".yaml" || ext === ".yml";
+    });
+    const fallback = files.find((name) => ADAPTER_FALLBACK_PATTERNS.test(name));
+    if (fallback) {
+      return {
+        file: fallback,
+        type: inferSkillContractType(fallback)
+      };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function loadSkillMetaFromDir(skillDir) {
+  const contract = findSkillContractFile(skillDir);
+  if (!contract) {
+    throw new Error(`No supported skill contract found in ${skillDir}. Supported files: ${SUPPORTED_SKILL_CONTRACT_FILES.join(", ")}`);
+  }
+  const contractPath = join(skillDir, contract.file);
+  const content = readFileSync(contractPath, "utf-8");
+  const fallbackName = inferFallbackNameFromDir(skillDir);
+  const meta = parseSkillContract(content, {
+    contractType: contract.type,
+    sourcePath: contract.file,
+    fallbackName
+  });
+  return {
+    meta,
+    contract,
+    contractPath
+  };
+}
+function parseSkillYaml(content, sourceLabel, fallbackName) {
+  let data;
+  try {
+    data = YAML.parse(content);
+  } catch (e) {
+    throw new Error(`Invalid YAML in ${sourceLabel}: ${e.message}`);
+  }
+  const meta = asRecord(data);
+  if (!meta) {
+    throw new Error(`Expected YAML object in ${sourceLabel}`);
+  }
+  return normalizeSkillMeta(meta, {
+    sourceLabel,
+    fallbackName
+  });
+}
+function parseSkillJson(content, sourceLabel, fallbackName) {
+  let data;
+  try {
+    data = JSON.parse(content);
+  } catch (e) {
+    throw new Error(`Invalid JSON in ${sourceLabel}: ${e.message}`);
+  }
+  const meta = asRecord(data);
+  if (!meta) {
+    throw new Error(`Expected JSON object in ${sourceLabel}`);
+  }
+  return normalizeSkillMeta(meta, {
+    sourceLabel,
+    fallbackName
+  });
+}
+function parseMarkdownContract(content, sourceLabel, fallbackName) {
+  const parsed = matter(content);
+  const frontmatter = asRecord(parsed.data);
+  const nameFromHeading = extractFirstHeading(parsed.content);
+  const descFromBody = extractFirstParagraph(parsed.content);
+  if (frontmatter && Object.keys(frontmatter).length > 0) {
+    return normalizeSkillMeta(frontmatter, {
+      sourceLabel,
+      fallbackName: fallbackName || nameFromHeading,
+      fallbackDescription: descFromBody
+    });
+  }
+  return normalizeSkillMeta({}, {
+    sourceLabel,
+    fallbackName: fallbackName || nameFromHeading,
+    fallbackDescription: descFromBody || `Skill instructions in ${sourceLabel}`
+  });
+}
+function normalizeSkillMeta(meta, opts) {
+  const name = pickString(meta, [["name"], ["title"], ["id"], ["slug"]]) || opts.fallbackName;
+  const description = pickString(meta, [
+    ["description"],
+    ["summary"],
+    ["short_description"],
+    ["shortDescription"],
+    ["metadata", "short-description"],
+    ["metadata", "short_description"],
+    ["metadata", "description"]
+  ]) || opts.fallbackDescription;
+  if (!isNonEmptyString(name)) {
+    throw new Error(`${opts.sourceLabel} must define a name`);
+  }
+  if (!isNonEmptyString(description)) {
+    throw new Error(`${opts.sourceLabel} must define a description`);
+  }
+  const prerequisites = normalizePrerequisites(pick(meta, ["prerequisites"]) || pick(meta, ["requirements"]));
+  const capabilities = normalizeCapabilities(pick(meta, ["capabilities"]) || pick(meta, ["permissions"]));
+  const scripts = normalizeScripts(pick(meta, ["scripts"]), pickString(meta, [["check_script"], ["checkScript"]]), pickString(meta, [["run_script"], ["runScript"]]));
+  const docs = normalizeDocs(pick(meta, ["docs"]), pickString(meta, [["homepage"]]), pickString(meta, [["source"], ["repo"], ["repository"]]));
+  return {
+    name: String(name).trim(),
+    description: String(description).trim(),
+    version: normalizeString(pick(meta, ["version"])),
+    tags: normalizeStringArray(pick(meta, ["tags"]) || pick(meta, ["keywords"]), "comma"),
+    kind: normalizeKind(pick(meta, ["kind"]) || pick(meta, ["type"])),
+    risk: normalizeRisk(pick(meta, ["risk"])),
+    availability: normalizeAvailability(pick(meta, ["availability"]) || pick(meta, ["tier"])),
+    prerequisites,
+    capabilities,
+    scripts,
+    inputs: normalizeInputs(pick(meta, ["inputs"]) || pick(meta, ["parameters"])),
+    docs
+  };
+}
+function normalizeKind(v) {
+  if (!isNonEmptyString(v))
+    return void 0;
+  if (v === "automation" || v === "knowledge")
+    return v;
+  return void 0;
+}
+function normalizeRisk(v) {
+  if (!isNonEmptyString(v))
+    return void 0;
+  if (v === "low" || v === "moderate" || v === "high")
+    return v;
+  return void 0;
+}
+function normalizeAvailability(v) {
+  if (!isNonEmptyString(v))
+    return void 0;
+  return AVAILABILITY_VALUES.includes(v) ? v : void 0;
+}
+function normalizePrerequisites(v) {
+  const obj = asRecord(v);
+  if (!obj)
+    return void 0;
+  const out = {};
+  out.tools = normalizeStringArray(obj.tools || obj.tooling || obj.commands || obj.bins);
+  out.files = normalizeStringArray(obj.files || obj.paths || obj.filePaths);
+  out.env = normalizeStringArray(obj.env || obj.environment || obj.envVars);
+  out.packageJsonDeps = normalizeStringArray(obj.packageJsonDeps || obj.dependencies || obj.npmDeps);
+  if (!out.tools?.length && !out.files?.length && !out.env?.length && !out.packageJsonDeps?.length) {
+    return void 0;
+  }
+  return out;
+}
+function normalizeCapabilities(v) {
+  const obj = asRecord(v);
+  if (!obj && !Array.isArray(v))
+    return void 0;
+  const out = {};
+  if (obj) {
+    out.shell = toBoolean(obj.shell);
+    out.network = toBoolean(obj.network);
+    out.fs_read = toBoolean(obj.fs_read ?? obj.fsRead ?? obj.read);
+    out.fs_write = toBoolean(obj.fs_write ?? obj.fsWrite ?? obj.write);
+  }
+  if (Array.isArray(v)) {
+    for (const value of v.map(String)) {
+      const item = value.trim().toLowerCase();
+      if (!item)
+        continue;
+      if (item === "shell")
+        out.shell = true;
+      if (item === "network")
+        out.network = true;
+      if (item === "fs_read" || item === "fs-read" || item === "read") {
+        out.fs_read = true;
+      }
+      if (item === "fs_write" || item === "fs-write" || item === "write") {
+        out.fs_write = true;
+      }
+    }
+  }
+  if (out.shell === void 0 && out.network === void 0 && out.fs_read === void 0 && out.fs_write === void 0) {
+    return void 0;
+  }
+  return out;
+}
+function normalizeScripts(scriptsValue, checkFallback, runFallback) {
+  const scripts = asRecord(scriptsValue);
+  const check = normalizeString(scripts?.check || scripts?.validate || checkFallback) || void 0;
+  const run = normalizeString(scripts?.run || scripts?.execute || runFallback) || void 0;
+  if (!check && !run)
+    return void 0;
+  return { check, run };
+}
+function normalizeInputs(v) {
+  const obj = asRecord(v);
+  if (!obj)
+    return void 0;
+  return obj;
+}
+function normalizeDocs(docsValue, homepageFallback, sourceFallback) {
+  const docs = asRecord(docsValue);
+  const homepage = normalizeString(docs?.homepage || homepageFallback);
+  const source = normalizeString(docs?.source || sourceFallback);
+  if (!homepage && !source)
+    return void 0;
+  return { homepage, source };
+}
+function normalizeString(v) {
+  if (!isNonEmptyString(v))
+    return void 0;
+  const value = String(v).trim();
+  return value || void 0;
+}
+function normalizeStringArray(value, splitMode = "none") {
+  if (Array.isArray(value)) {
+    const out2 = value.map(String).map((v) => v.trim()).filter(Boolean);
+    return out2.length ? out2 : void 0;
+  }
+  if (!isNonEmptyString(value))
+    return void 0;
+  const source = value.trim();
+  const out = splitMode === "comma" ? source.split(",").map((v) => v.trim()).filter(Boolean) : [source];
+  return out.length ? out : void 0;
+}
+function extractFirstHeading(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    if (/^#{1,6}\s+/.test(trimmed)) {
+      const heading = trimmed.replace(/^#{1,6}\s+/, "").trim();
+      return heading || void 0;
+    }
+  }
+  return void 0;
+}
+function extractFirstParagraph(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  const parts = [];
+  let inFence = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("```")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence)
+      continue;
+    if (!trimmed) {
+      if (parts.length > 0)
+        break;
+      continue;
+    }
+    if (/^#{1,6}\s+/.test(trimmed))
+      continue;
+    if (/^[-*]\s+/.test(trimmed) && parts.length === 0)
+      continue;
+    if (/^\d+\.\s+/.test(trimmed) && parts.length === 0)
+      continue;
+    parts.push(trimmed);
+  }
+  if (!parts.length)
+    return void 0;
+  return parts.join(" ");
+}
+function inferFallbackNameFromDir(skillDir) {
+  const value = basename(skillDir);
+  const at = value.lastIndexOf("@");
+  if (at > 0) {
+    const suffix = value.slice(at + 1);
+    if (suffix === "latest" || /^\d+\.\d+\.\d+/.test(suffix)) {
+      return value.slice(0, at);
+    }
+  }
+  return value;
+}
+function pickString(obj, paths) {
+  for (const path of paths) {
+    const value = pick(obj, path);
+    if (isNonEmptyString(value)) {
+      return String(value).trim();
+    }
+  }
+  return void 0;
+}
+function pick(obj, path) {
+  let current = obj;
+  for (const segment of path) {
+    const record = asRecord(current);
+    if (!record || !(segment in record))
+      return void 0;
+    current = record[segment];
+  }
+  return current;
+}
+function asRecord(v) {
+  if (!v || typeof v !== "object" || Array.isArray(v))
+    return null;
+  return v;
+}
+function toBoolean(v) {
+  if (typeof v === "boolean")
+    return v;
+  if (typeof v === "string") {
+    const normalized = v.trim().toLowerCase();
+    if (normalized === "true")
+      return true;
+    if (normalized === "false")
+      return false;
+  }
+  return void 0;
+}
+function isNonEmptyString(v) {
+  return typeof v === "string" && v.trim().length > 0;
+}
+
+// ../engine/dist/registry.js
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+import { dirname, join as join3 } from "path";
+import { fileURLToPath } from "url";
+
+// ../engine/dist/paths.js
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+function findRegistryRoot(startCwd = process.cwd()) {
+  let d = startCwd;
+  for (let i = 0; i < 10; i++) {
+    if (existsSync2(join2(d, "registry", "skills")))
+      return d;
+    const parent = join2(d, "..");
+    if (parent === d)
+      break;
+    d = parent;
+  }
+  return "";
+}
+
+// ../engine/dist/registry.js
+var DEFAULT_REGISTRY_URLS = [
+  "https://khalidsaidi.github.io/skillrunner/index.json",
+  "https://khalidsaidi.github.io/skillrunner/registry/dist/index.json",
+  "https://raw.githubusercontent.com/khalidsaidi/skillrunner/main/registry/dist/index.json",
+  "https://raw.githubusercontent.com/khalidsaidi/skillrunner/master/registry/dist/index.json"
+];
+var CACHE_DIR = join3(process.env.HOME || "", ".skillrunner");
+var REGISTRY_CACHE_DIR = join3(CACHE_DIR, "registry-cache");
+var SKILLS_DIR = join3(CACHE_DIR, "skills");
+var RUNS_DIR = join3(CACHE_DIR, "runs");
+function getSkillsDir() {
+  return SKILLS_DIR;
+}
+function getRunsDir() {
+  return RUNS_DIR;
+}
+function getRegistryCandidates(baseUrl) {
+  const urls = [
+    baseUrl,
+    process.env.SKILLRUNNER_REGISTRY_URL,
+    ...DEFAULT_REGISTRY_URLS
+  ].filter((v) => Boolean(v));
+  const deduped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const u of urls) {
+    if (seen.has(u))
+      continue;
+    seen.add(u);
+    deduped.push(u);
+  }
+  return deduped;
+}
+function normalizeLookup(value) {
+  return value.trim().toLowerCase();
+}
+function stripVersionSpecifier(value) {
+  const trimmed = value.trim();
+  const at = trimmed.lastIndexOf("@");
+  if (at > 0)
+    return trimmed.slice(0, at);
+  return trimmed;
+}
+function pathBasename(value) {
+  const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
+  const parts = normalized.split("/").filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] : "";
+}
+function extractSkillSlugFromPaths(skill) {
+  const contractPath = skill.paths?.contract || "";
+  if (contractPath) {
+    const normalized2 = contractPath.replace(/\\/g, "/");
+    const parts2 = normalized2.split("/").filter(Boolean);
+    if (parts2.length > 1)
+      return parts2[parts2.length - 2];
+  }
+  const fromDir = pathBasename(skill.paths?.dir || "");
+  if (fromDir)
+    return fromDir;
+  const skillMd = skill.paths?.skill_md || "";
+  const normalized = skillMd.replace(/\\/g, "/");
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length >= 2 && parts[parts.length - 1].toLowerCase() === "skill.md") {
+    return parts[parts.length - 2];
+  }
+  return "";
+}
+function parseRegistryPayload(payload) {
+  if (!payload || typeof payload !== "object")
+    return null;
+  const maybe = payload;
+  if (Array.isArray(maybe.skills)) {
+    return {
+      ...payload,
+      skills: maybe.skills,
+      packs: Array.isArray(maybe.packs) ? maybe.packs : []
+    };
+  }
+  const nestedIndex = maybe.index;
+  if (nestedIndex && Array.isArray(nestedIndex.skills)) {
+    return {
+      ...nestedIndex,
+      skills: nestedIndex.skills,
+      packs: Array.isArray(nestedIndex.packs) ? nestedIndex.packs : []
+    };
+  }
+  return null;
+}
+function getRegistrySkillSlug(skill) {
+  return extractSkillSlugFromPaths(skill) || skill.name;
+}
+async function fetchRemoteRegistry(baseUrl) {
+  const candidates = getRegistryCandidates(baseUrl);
+  if (candidates.length === 0) {
+    throw new Error("No registry URL configured");
+  }
+  const errors = [];
+  for (const url of candidates) {
+    try {
+      const res = await fetch(url);
+      if (!res.ok) {
+        errors.push(`${url} -> ${res.status} ${res.statusText}`);
+        continue;
+      }
+      const payload = await res.json();
+      const parsed = parseRegistryPayload(payload);
+      if (!parsed) {
+        errors.push(`${url} -> invalid registry payload`);
+        continue;
+      }
+      return parsed;
+    } catch (e) {
+      errors.push(`${url} -> ${e.message}`);
+    }
+  }
+  throw new Error(`Failed to fetch registry from all sources: ${errors.join("; ")}`);
+}
+function loadLocalRegistry(repoRoot) {
+  const path = join3(repoRoot, "registry", "dist", "index.json");
+  if (!existsSync3(path))
+    return null;
+  const content = readFileSync2(path, "utf-8");
+  return JSON.parse(content);
+}
+function resolveRegistryRoot(startCwd = process.cwd()) {
+  const cwdRoot = findRegistryRoot(startCwd);
+  if (cwdRoot)
+    return cwdRoot;
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const moduleRoot = findRegistryRoot(moduleDir);
+  if (moduleRoot)
+    return moduleRoot;
+  return "";
+}
+function loadBundledRegistry() {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join3(moduleDir, "registry", "dist", "index.json"),
+    join3(moduleDir, "..", "registry", "dist", "index.json")
+  ];
+  const moduleRoot = findRegistryRoot(moduleDir);
+  if (moduleRoot) {
+    candidates.push(join3(moduleRoot, "registry", "dist", "index.json"));
+  }
+  for (const path of candidates) {
+    if (!existsSync3(path))
+      continue;
+    try {
+      const content = readFileSync2(path, "utf-8");
+      return JSON.parse(content);
+    } catch {
+    }
+  }
+  return null;
+}
+async function resolveRegistryIndex(startCwd = process.cwd()) {
+  const root = resolveRegistryRoot(startCwd);
+  const local = root ? loadLocalRegistry(root) : null;
+  if (local)
+    return local;
+  try {
+    return await fetchRemoteRegistry();
+  } catch (remoteError) {
+    const bundled = loadBundledRegistry();
+    if (bundled)
+      return bundled;
+    throw remoteError;
+  }
+}
+function searchRegistry(index, query) {
+  const q = normalizeLookup(query);
+  return index.skills.filter((s) => normalizeLookup(s.name).includes(q) || normalizeLookup(getRegistrySkillSlug(s)).includes(q) || normalizeLookup(s.description).includes(q) || s.tags && s.tags.some((t) => t.toLowerCase().includes(q)));
+}
+function getSkillFromIndex(index, name) {
+  const lookup = normalizeLookup(stripVersionSpecifier(name));
+  if (!lookup)
+    return void 0;
+  return index.skills.find((s) => {
+    if (normalizeLookup(s.name) === lookup)
+      return true;
+    return normalizeLookup(getRegistrySkillSlug(s)) === lookup;
+  });
+}
+
+// ../engine/dist/guard.js
+import { readFileSync as readFileSync3 } from "fs";
+var isComment = (line) => /^\s*#/.test(line);
+var HARD_BLOCK_PATTERNS = [
+  /\bsudo\b/,
+  /\bsu\s+/,
+  /\brm\s+(-rf|-\s*rf|-r\s*f)\b/,
+  /\brm\s+-r\s+-f\b/,
+  /\bcurl\s+[^|]+\|\s*(sh|bash)\b/,
+  /~\/(\.ssh|\.aws)\b/,
+  /\bchmod\s+777\b/,
+  /\bchown\s+-R\b/
+];
+var DANGEROUS_PATH_PATTERN = /(^|[^#])\s*\/(etc|usr\/bin|bin)\b/;
+function scanScriptForBannedPatterns(scriptPath) {
+  const violations = [];
+  let content;
+  try {
+    content = readFileSync3(scriptPath, "utf-8");
+  } catch {
+    return { passed: true, violations: [] };
+  }
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (isComment(line))
+      continue;
+    for (const pat of HARD_BLOCK_PATTERNS) {
+      if (pat.test(line)) {
+        violations.push(`Line ${i + 1}: banned pattern: ${line.trim()}`);
+      }
+    }
+    if (DANGEROUS_PATH_PATTERN.test(line)) {
+      violations.push(`Line ${i + 1}: writes to system path: ${line.trim()}`);
+    }
+  }
+  return {
+    passed: violations.length === 0,
+    violations
+  };
+}
+function blockMessage(violations) {
+  return [
+    "Skill blocked by guard. Hard-block patterns detected:",
+    ...violations.map((v) => `  - ${v}`),
+    "Fix the script and try again."
+  ].join("\n");
+}
+
+// ../engine/dist/preflight.js
+import { existsSync as existsSync4, readFileSync as readFileSync4, statSync } from "fs";
+import { isAbsolute, join as join4 } from "path";
+function normalizeArray(values) {
+  if (!Array.isArray(values))
+    return [];
+  return values.map((v) => String(v).trim()).filter(Boolean);
+}
+function isExecutableFile(path) {
+  if (!existsSync4(path))
+    return false;
+  try {
+    const st = statSync(path);
+    if (!st.isFile())
+      return false;
+    if (process.platform === "win32")
+      return true;
+    return (st.mode & 73) !== 0;
+  } catch {
+    return false;
+  }
+}
+function isToolAvailable(tool) {
+  const trimmed = tool.trim();
+  if (!trimmed)
+    return false;
+  if (trimmed.includes("/") || trimmed.includes("\\")) {
+    return isExecutableFile(trimmed);
+  }
+  const pathEnv = process.env.PATH || "";
+  const delimiter = process.platform === "win32" ? ";" : ":";
+  const dirs = pathEnv.split(delimiter).filter(Boolean);
+  const extensions = process.platform === "win32" ? (process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM").split(";").map((e) => e.toLowerCase()).filter(Boolean) : [""];
+  for (const dir of dirs) {
+    if (process.platform === "win32") {
+      const hasExt = /\.[a-z0-9]+$/i.test(trimmed);
+      const candidates = hasExt ? [join4(dir, trimmed)] : extensions.map((ext) => join4(dir, `${trimmed}${ext}`));
+      if (candidates.some((candidate) => isExecutableFile(candidate))) {
+        return true;
+      }
+      continue;
+    }
+    if (isExecutableFile(join4(dir, trimmed)))
+      return true;
+  }
+  return false;
+}
+function readPackageJsonDependencyNames(cwd) {
+  const packageJsonPath = join4(cwd, "package.json");
+  if (!existsSync4(packageJsonPath))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
+    const names = /* @__PURE__ */ new Set();
+    for (const section of [
+      parsed.dependencies,
+      parsed.devDependencies,
+      parsed.peerDependencies,
+      parsed.optionalDependencies
+    ]) {
+      if (!section || typeof section !== "object")
+        continue;
+      for (const key of Object.keys(section)) {
+        const normalized = key.trim();
+        if (normalized)
+          names.add(normalized);
+      }
+    }
+    return names;
+  } catch {
+    return null;
+  }
+}
+function checkSkillPrerequisites(meta, cwd) {
+  const prerequisites = meta.prerequisites || {};
+  const tools = normalizeArray(prerequisites.tools);
+  const files = normalizeArray(prerequisites.files);
+  const env = normalizeArray(prerequisites.env);
+  const packageJsonDeps = normalizeArray(prerequisites.packageJsonDeps);
+  const missingTools = tools.filter((tool) => !isToolAvailable(tool));
+  const missingFiles = files.filter((file) => {
+    const path = isAbsolute(file) ? file : join4(cwd, file);
+    return !existsSync4(path);
+  });
+  const missingEnv = env.filter((name) => {
+    const value = process.env[name];
+    return typeof value !== "string" || value.trim() === "";
+  });
+  const packageJsonDepNames = packageJsonDeps.length > 0 ? readPackageJsonDependencyNames(cwd) : null;
+  const missingPackageJsonDeps = packageJsonDeps.filter((name) => {
+    return !packageJsonDepNames?.has(name);
+  });
+  return {
+    passed: missingTools.length === 0 && missingFiles.length === 0 && missingEnv.length === 0 && missingPackageJsonDeps.length === 0,
+    missingTools,
+    missingFiles,
+    missingEnv,
+    missingPackageJsonDeps
+  };
+}
+
+// ../engine/dist/planner.js
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+function buildPlan(skillDir, meta) {
+  const steps = [];
+  const requires = {};
+  if (meta.capabilities?.shell)
+    requires.shell = true;
+  if (meta.capabilities?.network)
+    requires.network = true;
+  if (meta.capabilities?.fs_read)
+    requires.fs_read = true;
+  if (meta.capabilities?.fs_write)
+    requires.fs_write = true;
+  const checkPath = meta.scripts?.check ? join5(skillDir, meta.scripts.check) : join5(skillDir, "scripts", "check.sh");
+  if (existsSync5(checkPath)) {
+    steps.push({
+      type: "shell",
+      cmd: `./${meta.scripts?.check || "scripts/check.sh"}`
+    });
+  }
+  const runPath = meta.scripts?.run ? join5(skillDir, meta.scripts.run) : join5(skillDir, "scripts", "run.sh");
+  if (existsSync5(runPath)) {
+    steps.push({
+      type: "shell",
+      cmd: `./${meta.scripts?.run || "scripts/run.sh"}`
+    });
+  }
+  return {
+    steps,
+    requires,
+    risk: meta.risk || "low"
+  };
+}
+
+// ../engine/dist/runner.js
+import { spawn } from "child_process";
+import { mkdirSync, writeFileSync, existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+import { randomUUID } from "crypto";
+async function runScript(cwd, scriptPath, runId) {
+  const rid = runId || randomUUID();
+  const runsDir = join6(getRunsDir(), rid);
+  mkdirSync(runsDir, { recursive: true });
+  return new Promise((resolve) => {
+    const proc = spawn("bash", [scriptPath], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (d) => stdout += d.toString());
+    proc.stderr?.on("data", (d) => stderr += d.toString());
+    proc.on("close", (code, signal) => {
+      const exitCode = code ?? (signal ? 1 : 0);
+      const success = exitCode === 0;
+      writeFileSync(join6(runsDir, "stdout.log"), stdout);
+      writeFileSync(join6(runsDir, "stderr.log"), stderr);
+      resolve({
+        runId: rid,
+        success,
+        exitCode,
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+async function executePlan(cwd, skillDir, plan) {
+  const results = [];
+  for (const step of plan.steps) {
+    if (step.type === "shell") {
+      const parts = step.cmd.split(/\s+/);
+      const script = parts[0].startsWith("./") ? join6(skillDir, parts[0].slice(2)) : join6(skillDir, step.cmd);
+      if (existsSync6(script)) {
+        const r = await runScript(cwd, script, results.length === 0 ? void 0 : void 0);
+        results.push(r);
+        if (!r.success)
+          break;
+      }
+    }
+  }
+  return results;
+}
+
+// ../engine/dist/artifacts.js
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join7 } from "path";
+function writeRunArtifacts(runId, skillName, cwd, plan, guardResult, runResult) {
+  const runsDir = join7(getRunsDir(), runId);
+  mkdirSync2(runsDir, { recursive: true });
+  const meta = {
+    runId,
+    skillName,
+    cwd,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (runResult) {
+    meta.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    meta.success = runResult.success;
+  }
+  writeFileSync2(join7(runsDir, "meta.json"), JSON.stringify(meta, null, 2));
+  writeFileSync2(join7(runsDir, "plan.json"), JSON.stringify(plan, null, 2));
+  writeFileSync2(join7(runsDir, "guard.json"), JSON.stringify(guardResult, null, 2));
+  if (runResult) {
+    writeFileSync2(join7(runsDir, "stdout.log"), runResult.stdout);
+    writeFileSync2(join7(runsDir, "stderr.log"), runResult.stderr);
+    writeFileSync2(join7(runsDir, "summary.json"), JSON.stringify({
+      success: runResult.success,
+      exitCode: runResult.exitCode
+    }, null, 2));
+  }
+}
+
+// src/utils/json.ts
+function readJsonFlag(value) {
+  return Boolean(value?.json);
+}
+function shouldUseJson(opts, cmd) {
+  if (readJsonFlag(opts)) return true;
+  if (readJsonFlag(cmd?.opts?.())) return true;
+  if (readJsonFlag(cmd?.parent?.opts?.())) return true;
+  return false;
+}
+
+// src/commands/doctor.ts
+async function doctorCmd(opts, cmd) {
+  const json = shouldUseJson(opts, cmd);
+  const results = {
+    node: null,
+    pnpm: null,
+    git: null,
+    registry: null,
+    paths: { skills: getSkillsDir(), runs: getRunsDir() }
+  };
+  try {
+    results.node = execSync("node -v", { encoding: "utf-8" }).trim();
+  } catch {
+    results.node = null;
+  }
+  try {
+    results.pnpm = execSync("pnpm -v 2>/dev/null || npm -v 2>/dev/null", {
+      encoding: "utf-8",
+      shell: "/bin/bash"
+    }).trim();
+  } catch {
+    results.pnpm = null;
+  }
+  try {
+    results.git = execSync("git --version", { encoding: "utf-8" }).trim();
+  } catch {
+    results.git = null;
+  }
+  try {
+    const index = await resolveRegistryIndex();
+    results.registry = index ? "ok" : null;
+  } catch (e) {
+    results.registry = e.message;
+  }
+  if (json) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+  console.log(chalk.bold("SkillRunner Doctor\n"));
+  console.log(
+    "Node:   ",
+    results.node ? chalk.green(results.node) : chalk.red("not found")
+  );
+  console.log(
+    "pnpm:   ",
+    results.pnpm ? chalk.green(results.pnpm) : chalk.yellow("optional")
+  );
+  console.log(
+    "Git:    ",
+    results.git ? chalk.green(results.git) : chalk.red("not found")
+  );
+  console.log(
+    "Registry:",
+    results.registry === "ok" ? chalk.green("reachable") : chalk.red(String(results.registry))
+  );
+  console.log("\nPaths:");
+  console.log("  skills:", getSkillsDir());
+  console.log("  runs: ", getRunsDir());
+}
+
+// src/commands/list.ts
+import chalk2 from "chalk";
+import { readdirSync as readdirSync2, existsSync as existsSync7 } from "fs";
+import { join as join8 } from "path";
+async function listCmd(opts, cmd) {
+  const json = shouldUseJson(opts, cmd);
+  const skillsDir = getSkillsDir();
+  const skills = [];
+  if (existsSync7(skillsDir)) {
+    for (const entry of readdirSync2(skillsDir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        const skillDir = join8(skillsDir, entry.name);
+        try {
+          const loaded = loadSkillMetaFromDir(skillDir);
+          skills.push({
+            name: loaded.meta.name,
+            version: loaded.meta.version,
+            description: loaded.meta.description,
+            availability: loaded.meta.availability
+          });
+        } catch {
+          skills.push({
+            name: entry.name,
+            version: void 0,
+            description: void 0
+          });
+        }
+      }
+    }
+  }
+  if (json) {
+    console.log(JSON.stringify({ skills }, null, 2));
+    return;
+  }
+  console.log(chalk2.bold("Installed skills:\n"));
+  if (skills.length === 0) {
+    console.log(chalk2.dim('  (none) \u2014 use "skill install <name>" to install'));
+    return;
+  }
+  for (const s of skills) {
+    console.log(
+      `  ${chalk2.cyan(s.name)}${s.version ? chalk2.dim(`@${s.version}`) : ""}${chalk2.dim(` [${s.availability || "default"}]`)}`
+    );
+    if (s.description) console.log(`    ${chalk2.dim(s.description)}`);
+  }
+}
+
+// src/commands/search.ts
+import chalk3 from "chalk";
+async function searchCmd(query, opts, cmd) {
+  const json = shouldUseJson(opts, cmd);
+  let index;
+  try {
+    index = await resolveRegistryIndex();
+  } catch (e) {
+    if (json) {
+      console.log(
+        JSON.stringify({ error: e.message, skills: [] }, null, 2)
+      );
+    } else {
+      console.error(chalk3.red("Registry unreachable:"), e.message);
+    }
+    process.exit(1);
+  }
+  const hits = searchRegistry(index, query || "");
+  if (json) {
+    console.log(JSON.stringify({ query: query || "", skills: hits }, null, 2));
+    return;
+  }
+  console.log(chalk3.bold(`Search: "${query || ""}"
+`));
+  for (const s of hits) {
+    const risk = s.risk || "low";
+    const availability = s.availability || "default";
+    console.log(
+      `  ${chalk3.cyan(s.name)}${chalk3.dim(` [${risk}|${availability}]`)}`
+    );
+    console.log(`    ${s.description}`);
+  }
+}
+
+// src/commands/info.ts
+import chalk4 from "chalk";
+import { existsSync as existsSync8, readdirSync as readdirSync3 } from "fs";
+import { join as join9 } from "path";
+function findInstalledSkillDir(name) {
+  const skillsDir = getSkillsDir();
+  if (!existsSync8(skillsDir)) return null;
+  const entries = readdirSync3(skillsDir, { withFileTypes: true });
+  const match = entries.find(
+    (e) => e.isDirectory() && (e.name === name || e.name.startsWith(`${name}@`))
+  );
+  return match ? join9(skillsDir, match.name) : null;
+}
+async function infoCmd(name, opts, cmd) {
+  const json = shouldUseJson(opts, cmd);
+  let skill;
+  const localPath = findInstalledSkillDir(name);
+  if (localPath) {
+    try {
+      const loaded = loadSkillMetaFromDir(localPath);
+      skill = {
+        name: loaded.meta.name,
+        description: loaded.meta.description,
+        version: loaded.meta.version,
+        tags: loaded.meta.tags,
+        kind: loaded.meta.kind,
+        risk: loaded.meta.risk,
+        availability: loaded.meta.availability,
+        prerequisites: loaded.meta.prerequisites,
+        capabilities: loaded.meta.capabilities,
+        scripts: loaded.meta.scripts,
+        inputs: loaded.meta.inputs,
+        contract: loaded.contract,
+        paths: {
+          dir: localPath,
+          skill_md: join9(localPath, loaded.contract.file),
+          raw_skill_md: "",
+          contract: join9(localPath, loaded.contract.file),
+          raw_contract: ""
+        }
+      };
+    } catch {
+    }
+  }
+  if (!skill) {
+    try {
+      const idx = await resolveRegistryIndex();
+      skill = getSkillFromIndex(idx, name);
+    } catch (e) {
+      if (json) {
+        console.log(JSON.stringify({ error: e.message }, null, 2));
+      } else {
+        console.error(chalk4.red("Registry unreachable:"), e.message);
+      }
+      process.exit(1);
+    }
+  }
+  if (!skill) {
+    if (json)
+      console.log(JSON.stringify({ error: "Skill not found" }, null, 2));
+    else console.error(chalk4.red("Skill not found:"), name);
+    process.exit(1);
+  }
+  if (json) {
+    console.log(JSON.stringify(skill, null, 2));
+    return;
+  }
+  console.log(chalk4.bold(skill.name));
+  if (skill.version) console.log(chalk4.dim(`Version: ${skill.version}`));
+  console.log(chalk4.dim(`Kind: ${skill.kind || "unknown"}`));
+  console.log(chalk4.dim(`Risk: ${skill.risk || "low"}`));
+  console.log(chalk4.dim(`Availability: ${skill.availability || "default"}`));
+  console.log();
+  console.log(skill.description);
+  if (skill.prerequisites) {
+    const tools = Array.isArray(skill.prerequisites.tools) ? skill.prerequisites.tools : [];
+    const files = Array.isArray(skill.prerequisites.files) ? skill.prerequisites.files : [];
+    const env = Array.isArray(skill.prerequisites.env) ? skill.prerequisites.env : [];
+    const packageJsonDeps = Array.isArray(skill.prerequisites.packageJsonDeps) ? skill.prerequisites.packageJsonDeps : [];
+    if (tools.length || files.length || env.length || packageJsonDeps.length) {
+      console.log(chalk4.dim("\nPrerequisites:"));
+      if (tools.length) console.log(chalk4.dim(`  tools: ${tools.join(", ")}`));
+      if (files.length) console.log(chalk4.dim(`  files: ${files.join(", ")}`));
+      if (env.length)
+        console.log(chalk4.dim(`  env: ${env.map((v) => `$${v}`).join(", ")}`));
+      if (packageJsonDeps.length) {
+        console.log(
+          chalk4.dim(`  packageJsonDeps: ${packageJsonDeps.join(", ")}`)
+        );
+      }
+    }
+  }
+  if (skill.tags?.length)
+    console.log(chalk4.dim("\nTags: " + skill.tags.join(", ")));
+}
+
+// src/commands/install.ts
+import chalk5 from "chalk";
+import {
+  cpSync,
+  mkdirSync as mkdirSync3,
+  existsSync as existsSync9,
+  rmSync,
+  writeFileSync as writeFileSync3,
+  chmodSync
+} from "fs";
+import { dirname as dirname2, join as join10 } from "path";
+function normalizeRelativePath(path) {
+  return path.replace(/^\.\/+/, "");
+}
+function toSkillRelativePath(path, skillSlug) {
+  const normalized = normalizeRelativePath(path);
+  const canonicalPrefix = `registry/skills/${skillSlug}/`;
+  if (normalized.startsWith(canonicalPrefix)) {
+    return normalized.slice(canonicalPrefix.length);
+  }
+  const slugMarker = `/${skillSlug}/`;
+  const markerIndex = normalized.lastIndexOf(slugMarker);
+  if (markerIndex >= 0) {
+    return normalized.slice(markerIndex + slugMarker.length);
+  }
+  return normalized;
+}
+function dedupe(values) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const v of values) {
+    if (seen.has(v)) continue;
+    seen.add(v);
+    out.push(v);
+  }
+  return out;
+}
+function isHttpUrl(value) {
+  return typeof value === "string" && /^https?:\/\//i.test(value);
+}
+function stripTrailingSlashes(value) {
+  return value.replace(/\/+$/, "");
+}
+function buildSkillFileUrls(index, skill, relativePath) {
+  const skillSlug = getRegistrySkillSlug(skill) || skill.name;
+  const normalizedPath = toSkillRelativePath(relativePath, skillSlug);
+  const contractPath = toSkillRelativePath(
+    skill.paths?.contract || skill.paths?.skill_md || "SKILL.md",
+    skillSlug
+  );
+  const candidates = [];
+  const rawSkillMd = skill.paths?.raw_skill_md;
+  const rawContract = skill.paths?.raw_contract || rawSkillMd;
+  if (normalizedPath === contractPath && isHttpUrl(rawContract)) {
+    candidates.push(rawContract);
+  }
+  if (normalizedPath === "SKILL.md" && isHttpUrl(rawSkillMd)) {
+    candidates.push(rawSkillMd);
+  }
+  const skillBases = [];
+  if (isHttpUrl(rawContract) && rawContract.endsWith(`/${normalizeRelativePath(contractPath)}`)) {
+    skillBases.push(
+      rawContract.slice(0, -`/${normalizeRelativePath(contractPath)}`.length)
+    );
+  }
+  if (isHttpUrl(rawSkillMd) && rawSkillMd.endsWith("/SKILL.md")) {
+    skillBases.push(rawSkillMd.slice(0, -"/SKILL.md".length));
+  }
+  if (isHttpUrl(index.source?.base_url)) {
+    skillBases.push(
+      `${stripTrailingSlashes(index.source.base_url)}/${skillSlug}`
+    );
+  }
+  for (const base of dedupe(skillBases)) {
+    candidates.push(`${stripTrailingSlashes(base)}/${normalizedPath}`);
+  }
+  return dedupe(candidates);
+}
+async function fetchFirstText(urls) {
+  for (const url of urls) {
+    try {
+      const res = await fetch(url);
+      if (!res.ok) continue;
+      return { url, body: await res.text() };
+    } catch {
+    }
+  }
+  return null;
+}
+function writeDownloadedFile(destDir, relativePath, content) {
+  const normalizedPath = normalizeRelativePath(relativePath);
+  const target = join10(destDir, normalizedPath);
+  mkdirSync3(dirname2(target), { recursive: true });
+  writeFileSync3(target, content);
+  if (normalizedPath.endsWith(".sh")) {
+    chmodSync(target, 493);
+  }
+}
+async function installSkillFromRemote(index, skill, destDir) {
+  const skillSlug = getRegistrySkillSlug(skill) || skill.name;
+  const contractRelativePath = toSkillRelativePath(
+    skill.paths?.contract || skill.paths?.skill_md || "SKILL.md",
+    skillSlug
+  );
+  const contractUrls = buildSkillFileUrls(index, skill, contractRelativePath);
+  const contractFile = await fetchFirstText(contractUrls);
+  if (!contractFile) {
+    throw new Error(
+      `Could not download contract "${contractRelativePath}" for ${skillSlug}`
+    );
+  }
+  writeDownloadedFile(destDir, contractRelativePath, contractFile.body);
+  const meta = parseSkillContract(contractFile.body, {
+    contractType: inferSkillContractType(contractRelativePath),
+    sourcePath: contractRelativePath,
+    fallbackName: skill.name
+  });
+  const requiredScripts = /* @__PURE__ */ new Set();
+  if (meta.scripts?.check) {
+    requiredScripts.add(normalizeRelativePath(meta.scripts.check));
+  }
+  if (meta.scripts?.run) {
+    requiredScripts.add(normalizeRelativePath(meta.scripts.run));
+  }
+  const optionalScripts = ["scripts/check.sh", "scripts/run.sh"].filter(
+    (p) => !requiredScripts.has(p)
+  );
+  const scriptPaths = [...requiredScripts, ...optionalScripts];
+  for (const scriptPath of scriptPaths) {
+    const scriptUrls = buildSkillFileUrls(index, skill, scriptPath);
+    const script = await fetchFirstText(scriptUrls);
+    if (!script) {
+      if (requiredScripts.has(scriptPath)) {
+        throw new Error(
+          `Could not download required script "${scriptPath}" for ${skillSlug}`
+        );
+      }
+      continue;
+    }
+    writeDownloadedFile(destDir, scriptPath, script.body);
+  }
+}
+async function installCmd(name, opts, cmd) {
+  const json = shouldUseJson(opts, cmd);
+  let index;
+  try {
+    index = await resolveRegistryIndex();
+  } catch (e) {
+    if (json) {
+      console.log(
+        JSON.stringify(
+          { success: false, error: e.message },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(chalk5.red("Registry unreachable:"), e.message);
+    }
+    process.exit(1);
+  }
+  const skill = getSkillFromIndex(index, name);
+  if (!skill) {
+    if (json) {
+      console.log(
+        JSON.stringify(
+          { success: false, error: `Skill not found: ${name}` },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(chalk5.red("Skill not found:"), name);
+    }
+    process.exit(1);
+  }
+  const skillsDir = getSkillsDir();
+  mkdirSync3(skillsDir, { recursive: true });
+  const skillSlug = getRegistrySkillSlug(skill) || skill.name;
+  const destDir = join10(skillsDir, `${skillSlug}@${skill.version || "latest"}`);
+  rmSync(destDir, { recursive: true, force: true });
+  try {
+    const repoRoot = resolveRegistryRoot();
+    const sourceDir = repoRoot ? join10(repoRoot, "registry", "skills", skillSlug) : "";
+    if (sourceDir && existsSync9(sourceDir)) {
+      cpSync(sourceDir, destDir, { recursive: true });
+    } else {
+      await installSkillFromRemote(index, skill, destDir);
+    }
+  } catch (e) {
+    rmSync(destDir, { recursive: true, force: true });
+    if (json) {
+      console.log(
+        JSON.stringify(
+          {
+            success: false,
+            error: `Install failed: ${e.message}`
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(chalk5.red("Install failed:"), e.message);
+    }
+    process.exit(1);
+  }
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          success: true,
+          name: skill.name,
+          slug: skillSlug,
+          path: destDir
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    const label = skillSlug === skill.name ? skill.name : `${skill.name} (${skillSlug})`;
+    console.log(chalk5.green("Installed:"), label, chalk5.dim(`\u2192 ${destDir}`));
+  }
+}
+
+// src/commands/uninstall.ts
+import chalk6 from "chalk";
+import { rmSync as rmSync2, existsSync as existsSync10, readdirSync as readdirSync4 } from "fs";
+import { join as join11 } from "path";
+async function uninstallCmd(name, opts, cmd) {
+  const json = shouldUseJson(opts, cmd);
+  const skillsDir = getSkillsDir();
+  if (!existsSync10(skillsDir)) {
+    if (json)
+      console.log(
+        JSON.stringify(
+          { success: false, error: "No skills installed" },
+          null,
+          2
+        )
+      );
+    else console.log(chalk6.dim("No skills installed."));
+    return;
+  }
+  const entries = readdirSync4(skillsDir, { withFileTypes: true });
+  const match = entries.find(
+    (e) => e.isDirectory() && (e.name === name || e.name.startsWith(name + "@"))
+  );
+  if (!match) {
+    if (json) {
+      console.log(
+        JSON.stringify(
+          { success: false, error: `Skill not found: ${name}` },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(chalk6.red("Skill not found:"), name);
+    }
+    process.exit(1);
+  }
+  rmSync2(join11(skillsDir, match.name), { recursive: true });
+  if (json) {
+    console.log(JSON.stringify({ success: true }, null, 2));
+  } else {
+    console.log(chalk6.green("Uninstalled:"), match.name);
+  }
+}
+
+// src/commands/plan.ts
+import chalk7 from "chalk";
+import { existsSync as existsSync11, readdirSync as readdirSync5 } from "fs";
+import { join as join12 } from "path";
+function findSkillDir(name) {
+  const skillsDir = getSkillsDir();
+  if (!existsSync11(skillsDir)) return null;
+  const entries = readdirSync5(skillsDir, { withFileTypes: true });
+  const match = entries.find(
+    (e) => e.isDirectory() && (e.name === name || e.name.startsWith(name + "@"))
+  );
+  return match ? join12(skillsDir, match.name) : null;
+}
+async function planCmd(name, opts, cmd) {
+  const json = shouldUseJson(opts, cmd);
+  const skillDir = findSkillDir(name);
+  if (!skillDir) {
+    if (json) {
+      console.log(
+        JSON.stringify(
+          { success: false, error: `Skill not installed: ${name}` },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(chalk7.red("Skill not installed:"), name);
+    }
+    process.exit(1);
+  }
+  let loaded = null;
+  try {
+    loaded = loadSkillMetaFromDir(skillDir);
+  } catch (e) {
+    if (json) {
+      console.log(
+        JSON.stringify(
+          { success: false, error: e.message },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(chalk7.red(e.message));
+    }
+    process.exit(1);
+  }
+  if (!loaded) process.exit(1);
+  const meta = loaded.meta;
+  const plan = buildPlan(skillDir, meta);
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          success: true,
+          skill: meta.name,
+          availability: meta.availability || "default",
+          prerequisites: meta.prerequisites || {},
+          plan
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.log(chalk7.bold(meta.name));
+  console.log(chalk7.dim(meta.description));
+  console.log(chalk7.dim(`Risk: ${plan.risk}
+`));
+  if (meta.availability) {
+    console.log(chalk7.dim(`Availability: ${meta.availability}`));
+  }
+  if (meta.prerequisites) {
+    const tools = meta.prerequisites.tools || [];
+    const files = meta.prerequisites.files || [];
+    const env = meta.prerequisites.env || [];
+    const packageJsonDeps = meta.prerequisites.packageJsonDeps || [];
+    if (tools.length || files.length || env.length || packageJsonDeps.length) {
+      console.log(chalk7.dim("Prerequisites:"));
+      if (tools.length) console.log(chalk7.dim(`  tools: ${tools.join(", ")}`));
+      if (files.length) console.log(chalk7.dim(`  files: ${files.join(", ")}`));
+      if (env.length) {
+        console.log(chalk7.dim(`  env: ${env.map((v) => `$${v}`).join(", ")}`));
+      }
+      if (packageJsonDeps.length) {
+        console.log(
+          chalk7.dim(`  packageJsonDeps: ${packageJsonDeps.join(", ")}`)
+        );
+      }
+    }
+  }
+  console.log("Steps:");
+  plan.steps.forEach((s, i) => console.log(`  ${i + 1}. ${s.cmd}`));
+}
+
+// src/commands/run.ts
+import chalk8 from "chalk";
+import { existsSync as existsSync12, readdirSync as readdirSync6 } from "fs";
+import { join as join13 } from "path";
+import prompts from "prompts";
+import { randomUUID as randomUUID2 } from "crypto";
+function findSkillDir2(name) {
+  const skillsDir = getSkillsDir();
+  if (!existsSync12(skillsDir)) return null;
+  const entries = readdirSync6(skillsDir, { withFileTypes: true });
+  const match = entries.find(
+    (e) => e.isDirectory() && (e.name === name || e.name.startsWith(name + "@"))
+  );
+  return match ? join13(skillsDir, match.name) : null;
+}
+async function runCmd(name, opts, cmd) {
+  const json = shouldUseJson(opts, cmd);
+  const cwd = opts.cwd || process.cwd();
+  const skillDir = findSkillDir2(name);
+  if (!skillDir) {
+    if (json) {
+      console.log(
+        JSON.stringify(
+          { success: false, error: `Skill not installed: ${name}` },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(chalk8.red("Skill not installed:"), name);
+    }
+    process.exit(1);
+  }
+  let metaResult = null;
+  try {
+    metaResult = loadSkillMetaFromDir(skillDir);
+  } catch (e) {
+    if (json) {
+      console.log(
+        JSON.stringify(
+          { success: false, error: e.message },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(chalk8.red(e.message));
+    }
+    process.exit(1);
+  }
+  if (!metaResult) process.exit(1);
+  const meta = metaResult.meta;
+  const plan = buildPlan(skillDir, meta);
+  const preflight = checkSkillPrerequisites(meta, cwd);
+  if (!preflight.passed) {
+    if (json) {
+      console.log(
+        JSON.stringify(
+          {
+            success: false,
+            error: "Preflight check failed",
+            preflight
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(chalk8.red("Preflight check failed."));
+      if (preflight.missingTools.length) {
+        console.error(
+          chalk8.dim(`  Missing tools: ${preflight.missingTools.join(", ")}`)
+        );
+      }
+      if (preflight.missingFiles.length) {
+        console.error(
+          chalk8.dim(`  Missing files: ${preflight.missingFiles.join(", ")}`)
+        );
+      }
+      if (preflight.missingEnv.length) {
+        console.error(
+          chalk8.dim(
+            `  Missing env vars: ${preflight.missingEnv.map((v) => `$${v}`).join(", ")}`
+          )
+        );
+      }
+      if (preflight.missingPackageJsonDeps.length) {
+        console.error(
+          chalk8.dim(
+            `  Missing package.json deps: ${preflight.missingPackageJsonDeps.join(", ")}`
+          )
+        );
+      }
+      console.error(chalk8.dim(`  Skill: ${meta.name}`));
+    }
+    process.exit(1);
+  }
+  const checkPath = meta.scripts?.check ? join13(skillDir, meta.scripts.check) : join13(skillDir, "scripts", "check.sh");
+  const runPath = meta.scripts?.run ? join13(skillDir, meta.scripts.run) : join13(skillDir, "scripts", "run.sh");
+  const guardCheck = scanScriptForBannedPatterns(checkPath);
+  const guardRun = scanScriptForBannedPatterns(runPath);
+  const guardResult = {
+    passed: guardCheck.passed && guardRun.passed,
+    violations: [...guardCheck.violations, ...guardRun.violations]
+  };
+  if (!guardResult.passed) {
+    if (json) {
+      console.log(
+        JSON.stringify(
+          {
+            success: false,
+            error: "Guard block",
+            violations: guardResult.violations
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(chalk8.red(blockMessage(guardResult.violations)));
+    }
+    process.exit(1);
+  }
+  if (!opts.yes && !json) {
+    const { confirm } = await prompts({
+      type: "confirm",
+      name: "confirm",
+      message: `Run ${meta.name}? (${plan.steps.length} step(s), risk: ${plan.risk})`,
+      initial: false
+    });
+    if (!confirm) {
+      console.log(chalk8.dim("Cancelled."));
+      return;
+    }
+  }
+  const runId = randomUUID2();
+  writeRunArtifacts(runId, meta.name, cwd, plan, guardResult);
+  const results = await executePlan(cwd, skillDir, plan);
+  const last = results[results.length - 1];
+  const success = last ? last.success : true;
+  const exitCode = last ? last.exitCode : 0;
+  const failureMessage = !success ? last?.stderr?.trim() || last?.stdout?.trim() || "Skill script failed" : void 0;
+  writeRunArtifacts(
+    runId,
+    meta.name,
+    cwd,
+    plan,
+    guardResult,
+    last ? {
+      success,
+      stdout: last.stdout,
+      stderr: last.stderr,
+      exitCode
+    } : void 0
+  );
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          success,
+          runId,
+          exitCode,
+          error: failureMessage,
+          stdout: last?.stdout,
+          stderr: last?.stderr
+        },
+        null,
+        2
+      )
+    );
+    if (!success) {
+      process.exit(exitCode || 1);
+    }
+  } else {
+    if (success) {
+      console.log(chalk8.green("Done."), chalk8.dim(`Run ID: ${runId}`));
+    } else {
+      console.error(chalk8.red("Failed."), chalk8.dim(`Run ID: ${runId}`));
+      if (failureMessage) console.error(chalk8.dim(failureMessage));
+      process.exit(exitCode || 1);
+    }
+  }
+}
+
+// src/commands/logs.ts
+import chalk9 from "chalk";
+import { readdirSync as readdirSync7, readFileSync as readFileSync5, existsSync as existsSync13, statSync as statSync2 } from "fs";
+import { join as join14 } from "path";
+function getRunIdsByRecent(runsDir) {
+  const entries = readdirSync7(runsDir, { withFileTypes: true }).filter(
+    (e) => e.isDirectory() && existsSync13(join14(runsDir, e.name, "meta.json"))
+  ).map((e) => ({
+    name: e.name,
+    mtime: statSync2(join14(runsDir, e.name)).mtimeMs
+  }));
+  return entries.sort((a, b) => b.mtime - a.mtime).map((e) => e.name);
+}
+async function logsCmd(opts, cmd) {
+  const json = shouldUseJson(opts, cmd);
+  const runsDir = getRunsDir();
+  if (!existsSync13(runsDir)) {
+    if (json) console.log(JSON.stringify({ runs: [] }, null, 2));
+    else console.log(chalk9.dim("No runs yet."));
+    return;
+  }
+  const ids = getRunIdsByRecent(runsDir);
+  if (ids.length === 0) {
+    if (json) console.log(JSON.stringify({ runs: [] }, null, 2));
+    else console.log(chalk9.dim("No runs yet."));
+    return;
+  }
+  let targetId = opts.id;
+  if (opts.last && ids.length) targetId = ids[0];
+  if (!targetId) {
+    const runs = ids.slice(0, 20).map((id) => {
+      try {
+        const metaPath2 = join14(runsDir, id, "meta.json");
+        const meta2 = JSON.parse(readFileSync5(metaPath2, "utf-8"));
+        return { id, ...meta2 };
+      } catch {
+        return null;
+      }
+    }).filter((v) => Boolean(v));
+    if (json) {
+      console.log(JSON.stringify({ runs }, null, 2));
+    } else {
+      console.log(chalk9.bold("Recent runs:\n"));
+      for (const r of runs) {
+        console.log(`  ${r.id}  ${r.skillName || "?"}  ${r.startedAt || ""}`);
+      }
+    }
+    return;
+  }
+  const runPath = join14(runsDir, targetId);
+  if (!existsSync13(runPath)) {
+    if (json) console.log(JSON.stringify({ error: "Run not found" }, null, 2));
+    else console.error(chalk9.red("Run not found:"), targetId);
+    process.exit(1);
+  }
+  const metaPath = join14(runPath, "meta.json");
+  const stdoutPath = join14(runPath, "stdout.log");
+  const stderrPath = join14(runPath, "stderr.log");
+  const meta = existsSync13(metaPath) ? JSON.parse(readFileSync5(metaPath, "utf-8")) : {};
+  const stdout = existsSync13(stdoutPath) ? readFileSync5(stdoutPath, "utf-8") : "";
+  const stderr = existsSync13(stderrPath) ? readFileSync5(stderrPath, "utf-8") : "";
+  if (json) {
+    console.log(JSON.stringify({ ...meta, stdout, stderr }, null, 2));
+    return;
+  }
+  console.log(chalk9.bold(`Run ${targetId}
+`));
+  console.log("Skill:", meta.skillName ?? "(unknown)");
+  console.log("CWD: ", meta.cwd ?? "(unknown)");
+  console.log("Started:", meta.startedAt ?? "(unknown)");
+  console.log("Success:", meta.success ?? "(unknown)");
+  if (stdout) {
+    console.log(chalk9.bold("\n--- stdout ---"));
+    console.log(stdout);
+  }
+  if (stderr) {
+    console.log(chalk9.bold("\n--- stderr ---"));
+    console.log(chalk9.red(stderr));
+  }
+}
+
+// src/commands/open.ts
+import chalk10 from "chalk";
+import { spawn as spawn2 } from "child_process";
+import { platform } from "os";
+async function openCmd(opts, cmd) {
+  const json = shouldUseJson(opts, cmd);
+  const url = "http://localhost:5173";
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          url,
+          message: "Start dashboard server with: pnpm --filter dashboard dev"
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  spawn2("pnpm", ["--filter", "dashboard", "dev"], {
+    stdio: "inherit",
+    shell: true
+  });
+  const openUrl = () => {
+    const cmd2 = platform() === "darwin" ? "open" : platform() === "win32" ? "start" : "xdg-open";
+    spawn2(cmd2, [url], { stdio: "ignore", detached: true });
+  };
+  setTimeout(openUrl, 3e3);
+  console.log(chalk10.green("Dashboard starting at"), url);
+}
+
+// src/commands/cursor.ts
+import chalk11 from "chalk";
+import { cpSync as cpSync2, existsSync as existsSync14, mkdirSync as mkdirSync4, readdirSync as readdirSync8 } from "fs";
+import { join as join15 } from "path";
+function getCursorSkillsDir(scope) {
+  if (scope === "global") {
+    return join15(process.env.HOME || "", ".cursor", "skills");
+  }
+  return join15(process.cwd(), ".cursor", "skills");
+}
+async function cursorInstallCmd(name, opts, cmd) {
+  const json = shouldUseJson(opts, cmd);
+  const scope = opts.scope || "project";
+  const skillsDir = getSkillsDir();
+  if (!existsSync14(skillsDir)) {
+    if (json)
+      console.log(
+        JSON.stringify(
+          { success: false, error: "No skills installed" },
+          null,
+          2
+        )
+      );
+    else
+      console.error(
+        chalk11.red('No skills installed. Run "skill install <name>" first.')
+      );
+    process.exit(1);
+  }
+  const entries = readdirSync8(skillsDir, { withFileTypes: true });
+  const match = entries.find(
+    (e) => e.isDirectory() && (e.name === name || e.name.startsWith(name + "@"))
+  );
+  if (!match) {
+    if (json) {
+      console.log(
+        JSON.stringify(
+          { success: false, error: `Skill not installed: ${name}` },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(chalk11.red("Skill not installed:"), name);
+    }
+    process.exit(1);
+  }
+  const srcDir = join15(skillsDir, match.name);
+  const destDir = getCursorSkillsDir(scope);
+  mkdirSync4(destDir, { recursive: true });
+  const dest = join15(destDir, match.name.split("@")[0]);
+  cpSync2(srcDir, dest, { recursive: true });
+  if (json) {
+    console.log(JSON.stringify({ success: true, path: dest, scope }, null, 2));
+  } else {
+    console.log(
+      chalk11.green("Installed to Cursor:"),
+      dest,
+      chalk11.dim(`(${scope})`)
+    );
+  }
+}
+async function cursorListCmd(opts, cmd) {
+  const json = shouldUseJson(opts, cmd);
+  const scope = opts.scope || "both";
+  const dirs = [];
+  if (scope === "project" || scope === "both") {
+    dirs.push({ scope: "project", path: getCursorSkillsDir("project") });
+  }
+  if (scope === "global" || scope === "both") {
+    dirs.push({ scope: "global", path: getCursorSkillsDir("global") });
+  }
+  const result = {};
+  for (const { scope: s, path: p } of dirs) {
+    if (existsSync14(p)) {
+      result[s] = readdirSync8(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    } else {
+      result[s] = [];
+    }
+  }
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  for (const [s, skills] of Object.entries(result)) {
+    console.log(chalk11.bold(`${s} skills:`));
+    if (skills.length) skills.forEach((n) => console.log(`  ${n}`));
+    else console.log(chalk11.dim("  (none)"));
+    console.log();
+  }
+}
+
+// src/cli.ts
+var program = new Command();
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var cliVersion = typeof pkg.version === "string" && pkg.version.trim() ? pkg.version : "0.0.0";
+program.name("skill").description("SkillRunner \u2014 browse, install, and run skills").version(cliVersion).option("-j, --json", "Output JSON for extension integration");
+program.command("doctor").option("--json").description("Check env, providers, registry").action(doctorCmd);
+program.command("list").option("--json").description("List installed skills").action(listCmd);
+program.command("search <query>").option("--json").description("Search registry").action(searchCmd);
+program.command("info <name>").option("--json").description("Show skill details").action(infoCmd);
+program.command("install <name>").option("--json").description("Install skill").action(installCmd);
+program.command("uninstall <name>").option("--json").description("Uninstall skill").action(uninstallCmd);
+program.command("plan <name>").option("--json").description("Show plan only").option("--inputs <pairs...>", "input k=v").action(planCmd);
+program.command("run <name>").option("--json").description("Run skill").option("--yes", "Skip confirmation").option("--inputs <pairs...>", "input k=v").option("--cwd <dir>", "Working directory").option("--allow-dirty", "Allow dirty repo").option("--no-branch", "Do not create branch").action(runCmd);
+program.command("logs").option("--json").description("Show run logs").option("--last", "Last run").option("--id <runId>", "Run ID").action(logsCmd);
+program.command("open").option("--json").description("Open dashboard").action(openCmd);
+var cursorCmd = new Command("cursor").description("Cursor integration");
+cursorCmd.command("install <name>").option("--json").option("--scope <scope>", "project|global", "project").action(cursorInstallCmd);
+cursorCmd.command("list").option("--json").option("--scope <scope>", "project|global|both", "both").action(cursorListCmd);
 program.addCommand(cursorCmd);
 program.parse();
 //# sourceMappingURL=cli.js.map