@jesdi/skills-cli 0.1.0

package/dist/chunk-OYYAZFA5.js

@@ -0,0 +1,273 @@
+// src/paths.ts
+import { join } from "path";
+var AGENTS = {
+  claude: { label: "Claude Code" },
+  opencode: { label: "OpenCode (.agents standard)" }
+};
+var AGENT_SUBDIR = {
+  claude: join(".claude", "skills"),
+  opencode: join(".agents", "skills")
+};
+function scopeRoot(scope, ctx) {
+  return scope === "global" ? ctx.home : ctx.project;
+}
+function agentSkillsDir(agent, scope, ctx) {
+  return join(scopeRoot(scope, ctx), AGENT_SUBDIR[agent]);
+}
+function storeDir(scope, ctx) {
+  return join(scopeRoot(scope, ctx), ".my-skills");
+}
+function globalStateFile(ctx) {
+  return join(ctx.home, ".config", "my-skills", "state.json");
+}
+function projectStateFile(ctx) {
+  return join(ctx.project, ".my-skills.json");
+}
+function cacheDir(ctx) {
+  return join(ctx.home, ".cache", "my-skills");
+}
+
+// src/registry.ts
+import { mkdir, readFile, readdir, writeFile, rm } from "fs/promises";
+import { existsSync } from "fs";
+import { join as join2 } from "path";
+import * as tar from "tar";
+var PACKAGE = "@jesdi%2fskills";
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+async function loadFromCache(cacheDir2, version) {
+  const pkgDir = join2(cacheDir2, version, "package");
+  const manifest = JSON.parse(
+    await readFile(join2(pkgDir, "skills-manifest.json"), "utf8")
+  );
+  if (manifest.schemaVersion > 1) {
+    throw new Error(
+      `skills manifest schemaVersion ${manifest.schemaVersion} is newer than this CLI supports \u2014 update @jesdi/skills-cli`
+    );
+  }
+  return { packageVersion: version, manifest, skillsDir: join2(pkgDir, "skills") };
+}
+async function newestCached(cacheDir2, cause) {
+  let versions = [];
+  try {
+    versions = (await readdir(cacheDir2)).sort();
+  } catch {
+  }
+  const newest = versions.at(-1);
+  if (!newest) {
+    throw new Error(`could not reach the npm registry and no cached skills exist: ${cause}`);
+  }
+  return loadFromCache(cacheDir2, newest);
+}
+async function fetchLatest(opts) {
+  const f = opts.fetchImpl ?? fetch;
+  const registry = opts.registryUrl ?? DEFAULT_REGISTRY;
+  let meta;
+  try {
+    const res = await f(`${registry}/${PACKAGE}/latest`);
+    if (!res.ok) throw new Error(`registry responded ${res.status}`);
+    meta = await res.json();
+  } catch (err) {
+    return newestCached(opts.cacheDir, err);
+  }
+  const versionDir = join2(opts.cacheDir, meta.version);
+  if (!existsSync(join2(versionDir, "package", "skills-manifest.json"))) {
+    const res = await f(meta.dist.tarball);
+    if (!res.ok) throw new Error(`tarball download failed: ${res.status}`);
+    const buf = Buffer.from(await res.arrayBuffer());
+    await rm(versionDir, { recursive: true, force: true });
+    await mkdir(versionDir, { recursive: true });
+    const tmpTar = join2(versionDir, "pkg.tgz");
+    await writeFile(tmpTar, buf);
+    await tar.extract({ file: tmpTar, cwd: versionDir });
+    await rm(tmpTar);
+  }
+  return loadFromCache(opts.cacheDir, meta.version);
+}
+
+// src/state.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname } from "path";
+function stateFile(scope, ctx) {
+  return scope === "global" ? globalStateFile(ctx) : projectStateFile(ctx);
+}
+function emptyState(scope) {
+  return scope === "global" ? { schemaVersion: 1, skills: {}, declined: {} } : { schemaVersion: 1, skills: {} };
+}
+async function loadState(scope, ctx) {
+  try {
+    return JSON.parse(await readFile2(stateFile(scope, ctx), "utf8"));
+  } catch {
+    return emptyState(scope);
+  }
+}
+async function saveState(scope, ctx, state) {
+  const file = stateFile(scope, ctx);
+  await mkdir2(dirname(file), { recursive: true });
+  await writeFile2(file, JSON.stringify(state, null, 2) + "\n");
+}
+async function loadGlobalState(ctx) {
+  return await loadState("global", ctx);
+}
+async function saveGlobalState(ctx, state) {
+  await saveState("global", ctx, state);
+}
+
+// src/store.ts
+import { cp, lstat, mkdir as mkdir3, readlink, rm as rm2, symlink } from "fs/promises";
+import { join as join3, resolve } from "path";
+var ForeignEntryError = class extends Error {
+};
+async function removeOurEntry(linkPath, storeDir2) {
+  const stat = await lstat(linkPath).catch(() => null);
+  if (!stat) return;
+  if (!stat.isSymbolicLink()) {
+    throw new ForeignEntryError(
+      `${linkPath} exists and was not created by skills-cli \u2014 refusing to touch it`
+    );
+  }
+  const target = await readlink(linkPath);
+  if (!resolve(target).startsWith(resolve(storeDir2))) {
+    throw new ForeignEntryError(
+      `${linkPath} is a symlink to ${target}, outside the skills-cli store \u2014 refusing to touch it`
+    );
+  }
+  await rm2(linkPath);
+}
+async function installSkill(opts) {
+  const storeCopy = join3(opts.storeDir, opts.name);
+  for (const dir of opts.agentDirs) {
+    const stat = await lstat(join3(dir, opts.name)).catch(() => null);
+    if (stat && !stat.isSymbolicLink()) {
+      throw new ForeignEntryError(
+        `${join3(dir, opts.name)} exists and was not created by skills-cli \u2014 refusing to touch it`
+      );
+    }
+  }
+  await rm2(storeCopy, { recursive: true, force: true });
+  await mkdir3(opts.storeDir, { recursive: true });
+  await cp(opts.sourceDir, storeCopy, { recursive: true });
+  for (const dir of opts.agentDirs) {
+    await mkdir3(dir, { recursive: true });
+    const linkPath = join3(dir, opts.name);
+    await removeOurEntry(linkPath, opts.storeDir);
+    await symlink(storeCopy, linkPath, "dir");
+  }
+}
+async function uninstallSkill(opts) {
+  for (const dir of opts.agentDirs) {
+    await removeOurEntry(join3(dir, opts.name), opts.storeDir);
+  }
+  await rm2(join3(opts.storeDir, opts.name), { recursive: true, force: true });
+}
+
+// src/ops.ts
+import { join as join4 } from "path";
+async function fetchSkills(ctx) {
+  return fetchLatest({
+    cacheDir: cacheDir(ctx),
+    registryUrl: ctx.registryUrl,
+    fetchImpl: ctx.fetchImpl
+  });
+}
+async function opInstall(names, agents, scope, ctx) {
+  const { manifest, skillsDir } = await fetchSkills(ctx);
+  const available = new Map(manifest.skills.map((s) => [s.name, s]));
+  for (const name of names) {
+    if (!available.has(name)) throw new Error(`unknown skill: ${name}`);
+  }
+  const state = await loadState(scope, ctx);
+  const installed = [];
+  for (const name of names) {
+    const skill = available.get(name);
+    await installSkill({
+      name,
+      sourceDir: join4(skillsDir, name),
+      storeDir: storeDir(scope, ctx),
+      agentDirs: agents.map((a) => agentSkillsDir(a, scope, ctx))
+    });
+    state.skills[name] = { version: skill.version, agents };
+    installed.push({ name, version: skill.version });
+  }
+  await saveState(scope, ctx, state);
+  return installed;
+}
+async function opUninstall(name, scope, ctx) {
+  const state = await loadState(scope, ctx);
+  const entry = state.skills[name];
+  if (!entry) throw new Error(`skill not installed (${scope}): ${name}`);
+  await uninstallSkill({
+    name,
+    storeDir: storeDir(scope, ctx),
+    agentDirs: entry.agents.map((a) => agentSkillsDir(a, scope, ctx))
+  });
+  delete state.skills[name];
+  await saveState(scope, ctx, state);
+}
+async function opCheckUpdates(scope, ctx) {
+  const { manifest } = await fetchSkills(ctx);
+  const available = new Map(manifest.skills.map((s) => [s.name, s]));
+  const state = await loadState(scope, ctx);
+  const globalState = await loadGlobalState(ctx);
+  const candidates = [];
+  for (const [name, installed] of Object.entries(state.skills)) {
+    const latest = available.get(name);
+    if (!latest || latest.version === installed.version) continue;
+    if (globalState.declined[name] === latest.version) continue;
+    candidates.push({ name, from: installed.version, to: latest.version });
+  }
+  return candidates;
+}
+async function opApplyUpdates(names, scope, ctx) {
+  const state = await loadState(scope, ctx);
+  const globalState = await loadGlobalState(ctx);
+  for (const name of names) {
+    const entry = state.skills[name];
+    if (!entry) throw new Error(`skill not installed (${scope}): ${name}`);
+    await opInstall([name], entry.agents, scope, ctx);
+    if (globalState.declined[name]) {
+      delete globalState.declined[name];
+      await saveGlobalState(ctx, globalState);
+    }
+  }
+}
+async function opDecline(name, version, ctx) {
+  const globalState = await loadGlobalState(ctx);
+  globalState.declined[name] = version;
+  await saveGlobalState(ctx, globalState);
+}
+async function opSync(ctx) {
+  const state = await loadState("local", ctx);
+  const entries = Object.entries(state.skills);
+  if (entries.length === 0) {
+    throw new Error("no .my-skills.json with skills found in this project \u2014 nothing to sync");
+  }
+  const results = [];
+  for (const [name, entry] of entries) {
+    const [installed] = await opInstall([name], entry.agents, "local", ctx);
+    results.push(installed);
+  }
+  return results;
+}
+async function opList(ctx) {
+  const { manifest } = await fetchSkills(ctx);
+  const globalState = await loadState("global", ctx);
+  const localState = await loadState("local", ctx);
+  return manifest.skills.map((s) => ({
+    name: s.name,
+    description: s.description,
+    latest: s.version,
+    installedGlobal: globalState.skills[s.name]?.version,
+    installedLocal: localState.skills[s.name]?.version
+  }));
+}
+
+export {
+  AGENTS,
+  opInstall,
+  opUninstall,
+  opCheckUpdates,
+  opApplyUpdates,
+  opDecline,
+  opSync,
+  opList
+};

package/dist/index.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import {
+  AGENTS,
+  opApplyUpdates,
+  opCheckUpdates,
+  opInstall,
+  opList,
+  opSync,
+  opUninstall
+} from "./chunk-OYYAZFA5.js";
+
+// src/program.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { Command } from "commander";
+var pkg = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8")
+);
+function parseAgents(value) {
+  const agents = value.split(",").map((a) => a.trim());
+  for (const a of agents) {
+    if (!(a in AGENTS)) throw new Error(`unknown agent: ${a} (expected claude|opencode)`);
+  }
+  return agents;
+}
+function scopeOf(opts) {
+  return opts.global ? "global" : "local";
+}
+function buildProgram(ctx) {
+  const cliCtx = ctx ?? { home: homedir(), project: process.cwd() };
+  const program = new Command("skills-cli");
+  program.description("Install jesdi's agent skills into Claude Code and OpenCode").version(pkg.version);
+  program.command("install").argument("<skills...>", "skill names to install").option("--agent <list>", "comma-separated agents: claude,opencode", "claude").option("--global", "install for the whole machine instead of this project").action(async (skills, opts) => {
+    const installed = await opInstall(skills, parseAgents(opts.agent), scopeOf(opts), cliCtx);
+    for (const s of installed) console.log(`installed ${s.name}@${s.version}`);
+  });
+  program.command("update").argument("[skill]", "update a single skill").option("--all", "apply every available update").option("--global", "operate on the global scope").action(async (skill, opts) => {
+    const scope = scopeOf(opts);
+    const candidates = await opCheckUpdates(scope, cliCtx);
+    if (candidates.length === 0) {
+      console.log("everything is up to date");
+      return;
+    }
+    const names = skill ? [skill] : opts.all ? candidates.map((c) => c.name) : null;
+    if (!names) {
+      for (const c of candidates) console.log(`${c.name}: ${c.from} -> ${c.to}`);
+      console.log("run `skills-cli update --all` or `skills-cli update <skill>` to apply");
+      return;
+    }
+    await opApplyUpdates(names, scope, cliCtx);
+    for (const n of names) console.log(`updated ${n}`);
+  });
+  program.command("sync").description("install everything listed in this project's .my-skills.json").action(async () => {
+    const results = await opSync(cliCtx);
+    for (const s of results) console.log(`synced ${s.name}@${s.version}`);
+  });
+  program.command("list").description("list available skills and where they are installed").action(async () => {
+    for (const s of await opList(cliCtx)) {
+      const marks = [
+        s.installedGlobal ? `global@${s.installedGlobal}` : null,
+        s.installedLocal ? `local@${s.installedLocal}` : null
+      ].filter(Boolean).join(", ");
+      console.log(`${s.name}@${s.latest}${marks ? ` [${marks}]` : ""} \u2014 ${s.description}`);
+    }
+  });
+  program.command("uninstall").argument("<skill>").option("--global", "uninstall from the global scope").action(async (skill, opts) => {
+    await opUninstall(skill, scopeOf(opts), cliCtx);
+    console.log(`uninstalled ${skill}`);
+  });
+  program.action(async () => {
+    const { runWizard } = await import("./wizard-RO45GYUU.js");
+    await runWizard(cliCtx);
+  });
+  return program;
+}
+
+// src/index.ts
+await buildProgram().parseAsync(process.argv);

package/dist/wizard-RO45GYUU.js

@@ -0,0 +1,65 @@
+import {
+  AGENTS,
+  opApplyUpdates,
+  opCheckUpdates,
+  opDecline,
+  opInstall,
+  opList
+} from "./chunk-OYYAZFA5.js";
+
+// src/wizard.ts
+import * as p from "@clack/prompts";
+async function runWizard(ctx) {
+  p.intro("@jesdi/skills");
+  for (const scope2 of ["global", "local"]) {
+    const candidates = await opCheckUpdates(scope2, ctx);
+    for (const c of candidates) {
+      const answer = await p.confirm({
+        message: `Update ${c.name} (${scope2}) ${c.from} -> ${c.to}?`
+      });
+      if (p.isCancel(answer)) return cancel2();
+      if (answer) await opApplyUpdates([c.name], scope2, ctx);
+      else await opDecline(c.name, c.to, ctx);
+    }
+  }
+  const available = await opList(ctx);
+  const skills = await p.multiselect({
+    message: "Which skills do you want to install?",
+    options: available.map((s) => ({
+      value: s.name,
+      label: s.name,
+      hint: s.description.slice(0, 80)
+    })),
+    required: true
+  });
+  if (p.isCancel(skills)) return cancel2();
+  const agents = await p.multiselect({
+    message: "Install for which agents?",
+    options: Object.entries(AGENTS).map(([id, a]) => ({
+      value: id,
+      label: a.label
+    })),
+    initialValues: ["claude"],
+    required: true
+  });
+  if (p.isCancel(agents)) return cancel2();
+  const scope = await p.select({
+    message: "Install where?",
+    options: [
+      { value: "local", label: `This project (${ctx.project})` },
+      { value: "global", label: "Globally (whole machine)" }
+    ]
+  });
+  if (p.isCancel(scope)) return cancel2();
+  const spinner2 = p.spinner();
+  spinner2.start("Installing\u2026");
+  const installed = await opInstall(skills, agents, scope, ctx);
+  spinner2.stop(`Installed ${installed.map((s) => `${s.name}@${s.version}`).join(", ")}`);
+  p.outro("Done \u2014 your agents will pick the skills up on next launch.");
+}
+function cancel2() {
+  p.cancel("Cancelled \u2014 nothing was changed.");
+}
+export {
+  runWizard
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@jesdi/skills-cli",
+  "version": "0.1.0",
+  "description": "Install jesdi's agent skills into Claude Code and OpenCode",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jesdi/general-skills.git",
+    "directory": "cli"
+  },
+  "type": "module",
+  "bin": { "skills-cli": "./dist/index.js" },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --clean",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "commander": "^12.1.0",
+    "tar": "^7.4.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.0"
+  },
+  "engines": { "node": ">=20" }
+}