skillio 0.1.13 → 0.1.15

package/dist/shared/chunk-dwrjph29.js

@@ -0,0 +1,252 @@
+import {
+  cyan,
+  discoverSkills,
+  getLockPath,
+  red
+} from "./chunk-nkpp3h85.js";
+
+// src/commands/picker.ts
+import { spawnSync } from "node:child_process";
+
+// src/utils/list-removable.ts
+function listRemovableTargets(input) {
+  const records = [...discoverSkills(input).values()];
+  const inLock = [];
+  const orphan = [];
+  for (const r of records) {
+    if (r.sources.includes("lock"))
+      inLock.push(r.name);
+    else
+      orphan.push(r.name);
+  }
+  inLock.sort();
+  orphan.sort();
+  return { inLock, orphan };
+}
+
+// src/utils/prompt.ts
+import { emitKeypressEvents } from "node:readline";
+async function select(params) {
+  const input = params.input ?? process.stdin;
+  const output = params.output ?? process.stdout;
+  if (!input.isTTY || !output.isTTY)
+    return null;
+  let cursor = 0;
+  const total = params.options.length;
+  function render() {
+    output.write(`${params.title}
+`);
+    for (let i = 0;i < total; i++) {
+      const opt = params.options[i];
+      if (!opt)
+        continue;
+      const marker = i === cursor ? cyan(">") : " ";
+      output.write(`${marker} ${opt.label}
+`);
+    }
+  }
+  function clear() {
+    output.write(`\x1B[${total + 1}A\x1B[J`);
+  }
+  emitKeypressEvents(input);
+  if (input.setRawMode)
+    input.setRawMode(true);
+  input.resume();
+  render();
+  return await new Promise((resolve) => {
+    const onKey = (_str, key) => {
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        resolve(null);
+        return;
+      }
+      if (key.name === "escape" || key.name === "q") {
+        cleanup();
+        resolve(null);
+        return;
+      }
+      if (key.name === "up" && cursor > 0) {
+        cursor--;
+        clear();
+        render();
+        return;
+      }
+      if (key.name === "down" && cursor < total - 1) {
+        cursor++;
+        clear();
+        render();
+        return;
+      }
+      if (key.name === "return") {
+        cleanup();
+        const chosen = params.options[cursor]?.value ?? null;
+        resolve(chosen);
+        return;
+      }
+    };
+    function onSigterm() {
+      cleanup();
+      resolve(null);
+    }
+    function cleanup() {
+      input.removeListener("keypress", onKey);
+      process.removeListener("SIGTERM", onSigterm);
+      if (input.setRawMode)
+        input.setRawMode(false);
+      input.pause();
+    }
+    process.once("SIGTERM", onSigterm);
+    input.on("keypress", onKey);
+  });
+}
+async function multiSelect(params) {
+  const input = params.input ?? process.stdin;
+  const output = params.output ?? process.stdout;
+  if (!input.isTTY || !output.isTTY)
+    return null;
+  let cursor = 0;
+  const total = params.options.length;
+  const selected = new Set;
+  function render() {
+    output.write(`${params.title}
+`);
+    for (let i = 0;i < total; i++) {
+      const opt = params.options[i];
+      if (!opt)
+        continue;
+      const cursorMark = i === cursor ? cyan(">") : " ";
+      const checkbox = selected.has(i) ? "[x]" : "[ ]";
+      output.write(`${cursorMark} ${checkbox} ${opt.label}
+`);
+    }
+  }
+  function clear() {
+    output.write(`\x1B[${total + 1}A\x1B[J`);
+  }
+  emitKeypressEvents(input);
+  if (input.setRawMode)
+    input.setRawMode(true);
+  input.resume();
+  render();
+  return await new Promise((resolve) => {
+    const onKey = (_str, key) => {
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        resolve(null);
+        return;
+      }
+      if (key.name === "escape" || key.name === "q") {
+        cleanup();
+        resolve(null);
+        return;
+      }
+      if (key.name === "up" && cursor > 0) {
+        cursor--;
+        clear();
+        render();
+        return;
+      }
+      if (key.name === "down" && cursor < total - 1) {
+        cursor++;
+        clear();
+        render();
+        return;
+      }
+      if (key.name === "space") {
+        if (selected.has(cursor))
+          selected.delete(cursor);
+        else
+          selected.add(cursor);
+        clear();
+        render();
+        return;
+      }
+      if (key.name === "return") {
+        cleanup();
+        const values = [];
+        for (let i = 0;i < total; i++) {
+          if (selected.has(i)) {
+            const v = params.options[i]?.value;
+            if (v !== undefined)
+              values.push(v);
+          }
+        }
+        resolve(values);
+        return;
+      }
+    };
+    function onSigterm() {
+      cleanup();
+      resolve(null);
+    }
+    function cleanup() {
+      input.removeListener("keypress", onKey);
+      process.removeListener("SIGTERM", onSigterm);
+      if (input.setRawMode)
+        input.setRawMode(false);
+      input.pause();
+    }
+    process.once("SIGTERM", onSigterm);
+    input.on("keypress", onKey);
+  });
+}
+
+// src/commands/picker.ts
+async function pickRemoveTargets(args) {
+  const lockPath = getLockPath(args.global);
+  const { inLock, orphan } = listRemovableTargets({
+    isGlobal: args.global,
+    cwd: process.cwd(),
+    lockPath
+  });
+  if (inLock.length === 0 && orphan.length === 0) {
+    console.log("No skills found in scope.");
+    return [];
+  }
+  const options = [
+    ...inLock.map((name) => ({ value: name, label: name })),
+    ...orphan.map((name) => ({ value: name, label: `${name} ${red("(orphan)")}` }))
+  ];
+  return await multiSelect({
+    title: "skillio — pick skills to remove (Space toggle, Enter confirm)",
+    options
+  });
+}
+async function runPicker(args) {
+  const choice = await select({
+    title: "skillio — pick a command",
+    options: [
+      { value: "usage", label: "usage  — count of skill invocations" },
+      { value: "cost", label: "cost   — per-skill ambient tokens" },
+      { value: "list", label: "list   — installed skills per source" },
+      { value: "remove", label: "remove — delete a skill (asks about lock cleanup)" },
+      { value: "quit", label: "quit" }
+    ]
+  });
+  if (choice === null || choice === "quit")
+    return 0;
+  const cliPath = process.argv[1];
+  if (!cliPath) {
+    console.error("skillio: cannot resolve CLI path (process.argv[1] missing)");
+    return 1;
+  }
+  let argv;
+  if (choice === "remove") {
+    const targets = await pickRemoveTargets(args);
+    if (targets === null || targets.length === 0)
+      return 0;
+    argv = ["rm", ...targets];
+  } else {
+    argv = [choice];
+  }
+  if (args.global)
+    argv.push("-g");
+  const r = spawnSync(process.execPath, [cliPath, ...argv], {
+    stdio: "inherit",
+    env: process.env
+  });
+  return r.status ?? 0;
+}
+export {
+  runPicker
+};

package/dist/shared/chunk-nkpp3h85.js

@@ -0,0 +1,153 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/lock/file.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+function getLockPath(global) {
+  return global ? join(homedir(), ".agents", ".skill-lock.json") : "skills-lock.json";
+}
+function readLock(path) {
+  if (!existsSync(path))
+    return { skills: {} };
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+function serialize(lock) {
+  return `${JSON.stringify(lock, null, 2)}
+`;
+}
+function writeLock(path, lock) {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = join(dirname(path), `.${Date.now()}.skill-lock.json`);
+  writeFileSync(tmp, serialize(lock));
+  renameSync(tmp, path);
+}
+function countLockLinesToRemove(path, names) {
+  if (!existsSync(path))
+    return 0;
+  const lock = readLock(path);
+  const before = serialize(lock);
+  const after = { skills: { ...lock.skills } };
+  for (const name of names)
+    delete after.skills[name];
+  return before.split(`
+`).length - serialize(after).split(`
+`).length;
+}
+function removeSkillFromLock(path, skill) {
+  if (!existsSync(path))
+    return { removed: false };
+  const lock = readLock(path);
+  if (!Object.hasOwn(lock.skills, skill))
+    return { removed: false };
+  delete lock.skills[skill];
+  writeLock(path, lock);
+  return { removed: true };
+}
+
+// src/utils/ansi.ts
+var enabled = false;
+function setColorEnabled(value) {
+  enabled = value;
+}
+function detectColorSupport() {
+  if (process.env.NO_COLOR)
+    return false;
+  if (process.env.FORCE_COLOR)
+    return true;
+  return Boolean(process.stdout.isTTY);
+}
+function green(s) {
+  return enabled ? `\x1B[32m${s}\x1B[0m` : s;
+}
+function yellow(s) {
+  return enabled ? `\x1B[33m${s}\x1B[0m` : s;
+}
+function red(s) {
+  return enabled ? `\x1B[31m${s}\x1B[0m` : s;
+}
+function cyan(s) {
+  return enabled ? `\x1B[36m${s}\x1B[0m` : s;
+}
+
+// src/utils/discover-skills.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3, statSync } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname3, join as join3, resolve as resolve2 } from "node:path";
+
+// src/utils/skill-files.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join2, resolve } from "node:path";
+var CHARS_PER_TOKEN = 4;
+function extractFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  return match?.[1];
+}
+function estimateTokens(text) {
+  return Math.round(text.length / CHARS_PER_TOKEN);
+}
+
+// src/utils/discover-skills.ts
+function resolveRoots(input) {
+  if (input.isGlobal) {
+    return {
+      claude: join3(homedir3(), ".claude", "skills"),
+      agents: join3(homedir3(), ".agents", "skills")
+    };
+  }
+  const repo = dirname3(resolve2(input.lockPath));
+  return {
+    claude: join3(repo, ".claude", "skills"),
+    agents: join3(repo, ".agents", "skills")
+  };
+}
+function listSkillNames(root) {
+  if (!root || !existsSync3(root))
+    return [];
+  return readdirSync(root).filter((name) => {
+    const skill = join3(root, name, "SKILL.md");
+    return existsSync3(skill) && statSync(skill).isFile();
+  });
+}
+function tokensFromFile(path) {
+  const content = readFileSync3(path, "utf8");
+  const fm = extractFrontmatter(content);
+  if (fm === undefined)
+    return { status: "no-frontmatter" };
+  return { tokens: estimateTokens(fm), status: "ok" };
+}
+function discoverSkills(input) {
+  const roots = resolveRoots(input);
+  const lock = readLock(input.lockPath);
+  const lockNames = Object.keys(lock.skills);
+  const claudeNames = listSkillNames(roots.claude);
+  const agentsNames = listSkillNames(roots.agents);
+  const all = new Set([...lockNames, ...claudeNames, ...agentsNames]);
+  const out = new Map;
+  for (const name of all) {
+    const sources = [];
+    if (lockNames.includes(name))
+      sources.push("lock");
+    if (claudeNames.includes(name))
+      sources.push(".claude");
+    if (agentsNames.includes(name))
+      sources.push(".agents");
+    let skillFile;
+    if (claudeNames.includes(name) && roots.claude) {
+      skillFile = join3(roots.claude, name, "SKILL.md");
+    } else if (agentsNames.includes(name) && roots.agents) {
+      skillFile = join3(roots.agents, name, "SKILL.md");
+    }
+    if (!skillFile) {
+      out.set(name, { name, sources, status: "missing" });
+      continue;
+    }
+    const { tokens, status } = tokensFromFile(skillFile);
+    out.set(name, { name, sources, skillFile, frontmatterTokens: tokens, status });
+  }
+  return out;
+}
+
+export { __require, getLockPath, readLock, countLockLinesToRemove, removeSkillFromLock, setColorEnabled, detectColorSupport, green, yellow, red, cyan, discoverSkills };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillio",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Audit and manage AI agent skills for Claude Code and Codex",
   "license": "MIT",
   "author": "ihororlovskyi",