skillio 0.1.10 → 0.1.12

package/dist/cli.js

@@ -3,11 +3,15 @@ import {
   __require,
   cyan,
   detectColorSupport,
+  discoverSkills,
+  getLockPath,
   green,
+  readLock,
   red,
+  removeSkillFromLock,
   setColorEnabled,
   yellow
-} from "./shared/chunk-s3421yr2.js";
+} from "./shared/chunk-0qvp6v8g.js";
 
 // src/cli.ts
 import { createRequire } from "node:module";
@@ -554,115 +558,6 @@ function _getBuiltinFlags(long, short, userNames, userAliases) {
   return [`--${long}`, `-${short}`];
 }
 
-// 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 writeLock(path, lock) {
-  mkdirSync(dirname(path), { recursive: true });
-  const tmp = join(dirname(path), `.${Date.now()}.skill-lock.json`);
-  writeFileSync(tmp, `${JSON.stringify(lock, null, 2)}
-`);
-  renameSync(tmp, path);
-}
-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/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;
-}
-
 // src/commands/cost.ts
 function classify(total) {
   if (total < 1000)
@@ -718,61 +613,98 @@ var costCommand = defineCommand({
 });
 
 // src/commands/list.ts
-function bySource(records) {
-  const claudeNames = records.filter((r) => r.sources.includes(".claude")).map((r) => r.name).sort();
-  const agentsNames = records.filter((r) => r.sources.includes(".agents")).map((r) => r.name).sort();
-  const lockNames = records.filter((r) => r.sources.includes("lock")).map((r) => r.name).sort();
-  const sumTokens = (names) => names.reduce((acc, n) => acc + (records.find((r) => r.name === n)?.frontmatterTokens ?? 0), 0);
+import { existsSync, lstatSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+function rootFor(isGlobal, lockPath, kind) {
+  if (isGlobal)
+    return join(homedir(), kind, "skills");
+  return join(dirname(resolve(lockPath)), kind, "skills");
+}
+function getInstall(root, name) {
+  const dir = join(root, name);
+  if (!existsSync(dir))
+    return;
+  return lstatSync(dir).isSymbolicLink() ? "symlink" : "real";
+}
+function paintDisk(n) {
+  if (n.install === "symlink")
+    return yellow(n.name);
+  if (n.install === "real")
+    return green(n.name);
+  return cyan(n.name);
+}
+function bySource(records, roots, lockLabel) {
+  const claudeRecords = records.filter((r) => r.sources.includes(".claude"));
+  const agentsRecords = records.filter((r) => r.sources.includes(".agents"));
+  const lockRecords = records.filter((r) => r.sources.includes("lock"));
+  const claudeNames = claudeRecords.map((r) => ({ name: r.name, install: getInstall(roots.claude, r.name) })).sort((a, b) => a.name.localeCompare(b.name));
+  const agentsNames = agentsRecords.map((r) => ({ name: r.name, install: getInstall(roots.agents, r.name) })).sort((a, b) => a.name.localeCompare(b.name));
+  const lockNames = lockRecords.map((r) => ({ name: r.name })).sort((a, b) => a.name.localeCompare(b.name));
   return {
-    claude: {
-      label: ".claude/skills",
-      names: claudeNames,
-      tokens: sumTokens(claudeNames),
-      exists: true
-    },
-    agents: {
-      label: ".agents/skills",
-      names: agentsNames,
-      tokens: sumTokens(agentsNames),
-      exists: true
-    },
-    lock: {
-      label: "skills-lock.json",
-      names: lockNames,
-      tokens: sumTokens(lockNames),
-      exists: true
-    }
+    agents: { label: ".agents/skills", names: agentsNames, totalCount: agentsNames.length },
+    claude: { label: ".claude/skills", names: claudeNames, totalCount: claudeNames.length },
+    lock: { label: lockLabel, names: lockNames, totalCount: lockNames.length }
   };
 }
 var listCommand = defineCommand({
-  meta: { description: "List skills per source with totals and lock-vs-disk diff" },
+  meta: { description: "List skills per source with install-type coloring and lock orphan filter" },
   args: {
     global: { type: "boolean", alias: "g", default: false, description: "Use global scope" }
   },
   run({ args }) {
     const lockPath = getLockPath(args.global);
-    const map = discoverSkills({ isGlobal: args.global, cwd: process.cwd(), lockPath });
-    const records = [...map.values()];
-    const rows = bySource(records);
-    const claudeNames = rows.claude.names;
-    const agentsNames = rows.agents.names;
-    const lockNames = rows.lock.names;
-    const lockOnly = lockNames.filter((n) => !claudeNames.includes(n) && !agentsNames.includes(n));
-    const claudeNotInLock = claudeNames.filter((n) => !lockNames.includes(n));
-    const agentsNotInLock = agentsNames.filter((n) => !lockNames.includes(n));
-    const sourceRows = [rows.claude, rows.agents, rows.lock];
-    const labelWidth = Math.max(...sourceRows.map((r) => r.label.length));
-    const countCells = sourceRows.map((r) => `${r.names.length} skill${r.names.length === 1 ? "" : "s"}`);
+    const records = [
+      ...discoverSkills({ isGlobal: args.global, cwd: process.cwd(), lockPath }).values()
+    ];
+    const roots = {
+      claude: rootFor(args.global, lockPath, ".claude"),
+      agents: rootFor(args.global, lockPath, ".agents")
+    };
+    const lockLabel = args.global ? ".agents/.skill-lock.json" : "skills-lock.json";
+    const rows = bySource(records, roots, lockLabel);
+    console.log(args.global ? "Global" : "Local");
+    const claudeSet = new Set(rows.claude.names.map((n) => n.name));
+    const agentsSet = new Set(rows.agents.names.map((n) => n.name));
+    const orphans = rows.lock.names.filter((n) => !claudeSet.has(n.name) && !agentsSet.has(n.name));
+    const sourceRows = [
+      {
+        row: rows.agents,
+        render: () => rows.agents.names.map(paintDisk).join(" ")
+      },
+      {
+        row: rows.claude,
+        render: () => rows.claude.names.map(paintDisk).join(" ")
+      },
+      {
+        row: rows.lock,
+        render: () => {
+          if (rows.lock.totalCount === 0)
+            return "";
+          if (orphans.length === 0)
+            return green("All skills onboard!");
+          return orphans.map((n) => red(n.name)).join(" ");
+        }
+      }
+    ];
+    const labelWidth = Math.max(...sourceRows.map((r) => r.row.label.length));
+    const countCells = sourceRows.map((r) => `${r.row.totalCount} skill${r.row.totalCount === 1 ? "" : "s"}`);
     const countWidth = Math.max(...countCells.map((c) => c.length));
     for (let i = 0;i < sourceRows.length; i++) {
-      const row = sourceRows[i];
-      if (!row)
+      const entry = sourceRows[i];
+      if (!entry)
         continue;
       const countCell = countCells[i] ?? "";
-      const namesText = row.names.length ? row.names.map(cyan).join(" ") : "";
-      const line = `${row.label.padEnd(labelWidth)} : ${countCell.padEnd(countWidth)}${namesText ? ` : ${namesText}` : ""}`;
+      const namesText = entry.render();
+      const line = `${entry.row.label.padEnd(labelWidth)} : ${countCell.padEnd(countWidth)}${namesText ? ` : ${namesText}` : ""}`;
       console.log(line.trimEnd());
     }
+    const claudeNames = rows.claude.names.map((n) => n.name);
+    const agentsNames = rows.agents.names.map((n) => n.name);
+    const lockNames = rows.lock.names.map((n) => n.name);
+    const lockOnly = lockNames.filter((n) => !claudeNames.includes(n) && !agentsNames.includes(n));
+    const claudeNotInLock = claudeNames.filter((n) => !lockNames.includes(n));
+    const agentsNotInLock = agentsNames.filter((n) => !lockNames.includes(n));
     const diffs = [];
     if (lockOnly.length) {
       diffs.push(`skills-lock.json has ${lockOnly.length} skill${lockOnly.length === 1 ? "" : "s"} missing on disk: ${lockOnly.map(cyan).join(", ")}`);
@@ -792,46 +724,92 @@ var listCommand = defineCommand({
 });
 
 // src/commands/remove.ts
-import { existsSync as existsSync5 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname5, join as join5, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join3, resolve as resolve3 } from "node:path";
 
 // src/utils/confirm.ts
-import { createInterface } from "node:readline/promises";
+import { emitKeypressEvents } from "node:readline";
 async function confirm(question, opts = {}) {
   const input = opts.input ?? process.stdin;
   const output = opts.output ?? process.stdout;
-  const rl = createInterface({
-    input,
-    output
-  });
-  try {
-    const answer = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
-    return answer === "y" || answer === "yes";
-  } finally {
-    rl.close();
+  if (!input.isTTY || !output.isTTY) {
+    const { createInterface } = await import("node:readline/promises");
+    const rl = createInterface({ input, output });
+    try {
+      const answer = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
+      return answer === "y" || answer === "yes";
+    } finally {
+      rl.close();
+    }
   }
+  output.write(`${question} [y/N] `);
+  emitKeypressEvents(input);
+  if (input.setRawMode)
+    input.setRawMode(true);
+  input.resume();
+  return new Promise((resolve2) => {
+    const onKey = (str, key) => {
+      const lower = (str ?? "").toLowerCase();
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        output.write(`
+`);
+        resolve2(false);
+        return;
+      }
+      if (lower === "y") {
+        cleanup();
+        output.write(`y
+`);
+        resolve2(true);
+        return;
+      }
+      if (lower === "n" || key.name === "return" || key.name === "escape" || lower === "q") {
+        cleanup();
+        output.write(`${lower || "n"}
+`);
+        resolve2(false);
+        return;
+      }
+    };
+    function onSigterm() {
+      cleanup();
+      output.write(`
+`);
+      resolve2(false);
+    }
+    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/utils/fs-rm.ts
-import { existsSync as existsSync4, lstatSync, readdirSync as readdirSync2, rmSync } from "node:fs";
-import { join as join4, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync2, lstatSync as lstatSync2, readdirSync, rmSync } from "node:fs";
+import { join as join2, resolve as resolve2 } from "node:path";
 function isInside(target, root) {
-  const t = resolve3(target);
-  const r = resolve3(root);
+  const t = resolve2(target);
+  const r = resolve2(root);
   return t === r || t.startsWith(`${r}/`);
 }
 function countFiles(path) {
-  if (!existsSync4(path))
+  if (!existsSync2(path))
     return 0;
-  const stat = lstatSync(path);
+  const stat = lstatSync2(path);
   if (stat.isFile())
     return 1;
   if (!stat.isDirectory())
     return 0;
   let n = 0;
-  for (const entry of readdirSync2(path)) {
-    n += countFiles(join4(path, entry));
+  for (const entry of readdirSync(path)) {
+    n += countFiles(join2(path, entry));
   }
   return n;
 }
@@ -840,60 +818,51 @@ function rmSkillDir(path, opts) {
   if (!safe) {
     throw new Error(`Refusing to delete: "${path}" is outside allowed roots`);
   }
-  if (!existsSync4(path))
+  if (!existsSync2(path))
     return { removed: false, fileCount: 0 };
   const fileCount = countFiles(path);
   rmSync(path, { recursive: true, force: true });
   return { removed: true, fileCount };
 }
 
-// src/utils/git.ts
-import { spawnSync } from "node:child_process";
-import { dirname as dirname4, resolve as resolve4 } from "node:path";
-function isTrackedByGit(path) {
-  const abs = resolve4(path);
-  const cwd = dirname4(abs);
-  const r = spawnSync("git", ["ls-files", "--error-unmatch", abs], {
-    cwd,
-    stdio: ["ignore", "ignore", "ignore"]
-  });
-  return r.status === 0;
-}
-
 // src/commands/remove.ts
 var q = (name) => `"${cyan(name)}"`;
 function buildTarget(name, isGlobal, lockPath) {
   const lock = readLock(lockPath);
   const inLock = Object.hasOwn(lock.skills, name);
-  const baseClaude = isGlobal ? join5(homedir4(), ".claude", "skills") : join5(dirname5(resolve5(lockPath)), ".claude", "skills");
-  const baseAgents = isGlobal ? join5(homedir4(), ".agents", "skills") : join5(dirname5(resolve5(lockPath)), ".agents", "skills");
-  const claudeDir = existsSync5(join5(baseClaude, name)) ? join5(baseClaude, name) : undefined;
-  const agentsDir = existsSync5(join5(baseAgents, name)) ? join5(baseAgents, name) : undefined;
+  const baseClaude = isGlobal ? join3(homedir2(), ".claude", "skills") : join3(dirname2(resolve3(lockPath)), ".claude", "skills");
+  const baseAgents = isGlobal ? join3(homedir2(), ".agents", "skills") : join3(dirname2(resolve3(lockPath)), ".agents", "skills");
+  const claudeDir = existsSync3(join3(baseClaude, name)) ? join3(baseClaude, name) : undefined;
+  const agentsDir = existsSync3(join3(baseAgents, name)) ? join3(baseAgents, name) : undefined;
   return { name, inLock, claudeDir, agentsDir };
 }
+function collectAllTargets(isGlobal, lockPath) {
+  const map = discoverSkills({ isGlobal, cwd: process.cwd(), lockPath });
+  return [...map.keys()].sort().map((name) => buildTarget(name, isGlobal, lockPath));
+}
 function fileCount(dir) {
-  const { readdirSync: readdirSync3, statSync: statSync2 } = __require("node:fs");
+  const { readdirSync: readdirSync2, statSync } = __require("node:fs");
   let n = 0;
   const stack = [dir];
   while (stack.length) {
     const cur = stack.pop();
-    const stat = statSync2(cur);
+    const stat = statSync(cur);
     if (stat.isFile())
       n++;
     else if (stat.isDirectory())
-      for (const e of readdirSync3(cur))
-        stack.push(join5(cur, e));
+      for (const e of readdirSync2(cur))
+        stack.push(join3(cur, e));
   }
   return n;
 }
-function printPlan(plan, lockTracked) {
+function printPlan(plan, modifyLock) {
   const { target } = plan;
   console.log(`Will remove ${q(target.name)}:`);
   if (target.inLock) {
-    if (lockTracked)
-      console.log("  - skills-lock.json (skipped: git-tracked; use --force-lock)");
-    else
+    if (modifyLock)
       console.log("  - skills-lock.json");
+    else
+      console.log("  - skills-lock.json (kept; use --force-lock to remove lock entry)");
   } else {
     console.log("  - skills-lock.json (not in lock)");
   }
@@ -907,27 +876,38 @@ function printPlan(plan, lockTracked) {
     console.log("  - .agents/skills/  (not found)");
 }
 var removeCommand = defineCommand({
-  meta: { description: "Remove one or more skills from lock and delete their on-disk directories" },
+  meta: {
+    description: "Remove one or more skills from on-disk dirs (lock preserved unless --force-lock)"
+  },
   args: {
     global: { type: "boolean", alias: "g", default: false, description: "Use global scope" },
     "dry-run": { type: "boolean", default: false, description: "Print plan, do not delete" },
     yes: { type: "boolean", alias: "y", default: false, description: "Skip confirmation prompt" },
+    all: { type: "boolean", default: false, description: "Remove every skill in scope" },
     "force-lock": {
       type: "boolean",
       default: false,
-      description: "Modify skills-lock.json even if it is git-tracked"
+      description: "Also remove entry from skills-lock.json (default is to keep lock untouched)"
     }
   },
   async run({ args }) {
-    const { global: isGlobal, "dry-run": dryRun, yes, "force-lock": forceLock } = args;
+    const { global: isGlobal, "dry-run": dryRun, yes, all, "force-lock": modifyLock } = args;
     const subcmdIdx = process.argv.findIndex((a) => a === "remove" || a === "rm");
     const names = process.argv.slice(subcmdIdx + 1).filter((a) => !a.startsWith("-"));
-    if (names.length === 0) {
+    if (all && names.length > 0) {
+      console.error("--all is mutually exclusive with positional skill names");
+      process.exit(1);
+    }
+    if (!all && names.length === 0) {
       console.error("No skill names provided");
       process.exit(1);
     }
     const lockPath = getLockPath(isGlobal);
-    const targets = names.map((n) => buildTarget(n, isGlobal, lockPath));
+    const targets = all ? collectAllTargets(isGlobal, lockPath) : names.map((n) => buildTarget(n, isGlobal, lockPath));
+    if (all && targets.length === 0) {
+      console.log("No skills to remove in scope.");
+      return;
+    }
     const orphan = targets.filter((t) => !t.inLock && !t.claudeDir && !t.agentsDir);
     if (orphan.length) {
       for (const o of orphan)
@@ -939,32 +919,29 @@ var removeCommand = defineCommand({
       claudeFileCount: t.claudeDir ? fileCount(t.claudeDir) : undefined,
       agentsFileCount: t.agentsDir ? fileCount(t.agentsDir) : undefined
     }));
-    const lockTracked = !forceLock && isTrackedByGit(lockPath);
     for (const p of plans) {
-      printPlan(p, lockTracked);
+      printPlan(p, modifyLock);
       console.log("");
     }
-    if (lockTracked && plans.some((p) => p.target.inLock)) {
-      console.error(red("Skipping skills-lock.json (tracked by git; pass --force-lock to override)"));
-    }
     if (dryRun)
       return;
     if (!yes) {
-      const ok = await confirm("Proceed?");
+      const promptText = all ? `Remove ALL ${plans.length} skills?` : "Proceed?";
+      const ok = await confirm(promptText);
       if (!ok) {
         console.log("Aborted");
         process.exit(1);
       }
     }
-    const allowedRoots = [isGlobal ? homedir4() : dirname5(resolve5(lockPath)), homedir4()];
+    const allowedRoots = [isGlobal ? homedir2() : dirname2(resolve3(lockPath)), homedir2()];
     for (const { target } of plans) {
       if (target.inLock) {
-        if (lockTracked) {
-          console.log(`Skipped skills-lock.json (git-tracked) for ${q(target.name)}`);
-        } else {
+        if (modifyLock) {
           const r = removeSkillFromLock(lockPath, target.name);
           if (r.removed)
             console.log(`Removed ${q(target.name)} from skills-lock.json`);
+        } else {
+          console.log(`Kept ${q(target.name)} in skills-lock.json (no --force-lock)`);
         }
       } else {
         console.log(`Skipped skills-lock.json (not in lock)`);
@@ -986,11 +963,11 @@ var removeCommand = defineCommand({
 });
 
 // src/commands/usage.ts
-import { existsSync as existsSync8 } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync6 } from "node:fs";
+import { join as join7 } from "node:path";
 
 // src/readers/claude.ts
-import { readFileSync as readFileSync5 } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
 
 // src/utils/codex-cmd.ts
 var READ_LIKE = new Set(["cat", "sed", "head", "tail", "bat", "batcat", "less", "more"]);
@@ -1214,26 +1191,26 @@ function isUserTurnEntry(entry) {
 }
 
 // src/utils/expand-home.ts
-import { homedir as homedir5 } from "node:os";
-import { join as join6, resolve as resolve6 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { join as join4, resolve as resolve4 } from "node:path";
 function expandHome(p) {
   if (p === "~")
-    return homedir5();
+    return homedir3();
   if (p.startsWith("~/"))
-    return join6(homedir5(), p.slice(2));
-  return resolve6(p);
+    return join4(homedir3(), p.slice(2));
+  return resolve4(p);
 }
 
 // src/utils/jsonl.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync2 } from "node:fs";
-import { join as join7 } from "node:path";
+import { readdirSync as readdirSync2, readFileSync, statSync } from "node:fs";
+import { join as join5 } from "node:path";
 function* findJsonlFiles(dir, since) {
-  for (const item of readdirSync3(dir, { withFileTypes: true })) {
-    const path = join7(dir, item.name);
+  for (const item of readdirSync2(dir, { withFileTypes: true })) {
+    const path = join5(dir, item.name);
     if (item.isDirectory()) {
       yield* findJsonlFiles(path, since);
     } else if (item.isFile() && item.name.endsWith(".jsonl")) {
-      if (!since || statSync2(path).mtime >= since)
+      if (!since || statSync(path).mtime >= since)
         yield path;
     }
   }
@@ -1263,7 +1240,7 @@ function readClaudeUsage(options) {
     let prevSkill = null;
     const sessionAttr = new Map;
     const sessionAct = new Map;
-    for (const line of readFileSync5(file, "utf8").split(`
+    for (const line of readFileSync2(file, "utf8").split(`
 `)) {
       if (!line.trim())
         continue;
@@ -1316,14 +1293,14 @@ function readClaudeUsage(options) {
 }
 
 // src/readers/codex.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
 
 // src/utils/scope.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { dirname as dirname6, join as join8 } from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname3, join as join6 } from "node:path";
 function detectScope(opts) {
-  const home = opts.home ?? homedir6();
+  const home = opts.home ?? homedir4();
   if (opts.global || opts.rootOverride)
     return { global: true };
   if (norm(opts.cwd) === norm(home))
@@ -1341,9 +1318,9 @@ function encodeClaudeProjectDir(absPath) {
 function findGitRoot(start) {
   let dir = start;
   while (true) {
-    if (existsSync6(join8(dir, ".git")))
+    if (existsSync4(join6(dir, ".git")))
       return dir;
-    const parent = dirname6(dir);
+    const parent = dirname3(dir);
     if (parent === dir)
       return;
     dir = parent;
@@ -1357,7 +1334,7 @@ function norm(p) {
 function readSessionCwd(file) {
   let head;
   try {
-    head = readFileSync6(file, "utf8");
+    head = readFileSync3(file, "utf8");
   } catch {
     return;
   }
@@ -1390,7 +1367,7 @@ function readCodexActivations(options) {
         continue;
     }
     filesRead++;
-    for (const line of readFileSync6(file, "utf8").split(`
+    for (const line of readFileSync3(file, "utf8").split(`
 `)) {
       if (!line.trim())
         continue;
@@ -1414,9 +1391,9 @@ function readCodexMentions(options) {
   const historyPath = expandHome(options.history ?? "~/.codex/history.jsonl");
   const counts = new Map;
   let linesRead = 0;
-  if (!existsSync7(historyPath))
+  if (!existsSync5(historyPath))
     return { counts, filesRead: 0, linesRead: 0 };
-  for (const line of readFileSync6(historyPath, "utf8").split(`
+  for (const line of readFileSync3(historyPath, "utf8").split(`
 `)) {
     if (!line.trim())
       continue;
@@ -1442,20 +1419,18 @@ var MINUTE_MS = 60 * SECOND_MS;
 var HOUR_MS = 60 * MINUTE_MS;
 var DAY_MS = 24 * HOUR_MS;
 var UNITS_MS = {
-  sec: SECOND_MS,
-  min: MINUTE_MS,
+  s: SECOND_MS,
+  m: MINUTE_MS,
   h: HOUR_MS,
   d: DAY_MS,
-  w: 7 * DAY_MS,
-  m: 30 * DAY_MS,
-  y: 365 * DAY_MS
+  w: 7 * DAY_MS
 };
 function parsePeriod(period) {
   if (period === "all")
     return Number.POSITIVE_INFINITY;
-  const match = period.match(/^(\d+)(sec|min|[hdwmy])$/);
+  const match = period.match(/^(\d+)([smhdw])$/);
   if (!match) {
-    throw new Error(`Invalid period: "${period}". Use values like 30sec, 5min, 12h, 7d, 2w, 1m, 1y, all.`);
+    throw new Error(`Invalid period: "${period}". Use values like 60s, 30m, 24h, 30d, 2w, all.`);
   }
   const unit = UNITS_MS[match[2] ?? ""] ?? 0;
   return Number(match[1]) * unit;
@@ -1490,7 +1465,7 @@ var usageArgs = {
     type: "string",
     alias: "p",
     default: "all",
-    description: "30sec, 5min, 12h, 7d, 2w, 1m, 1y, all"
+    description: "60s, 30m, 24h, 30d, 2w, all"
   },
   since: { type: "string", description: "yyyy-mm-dd, overrides --period" },
   mode: {
@@ -1522,8 +1497,8 @@ async function runUsage(args) {
     cwd: process.cwd()
   });
   const claudeProjectsRoot = expandHome("~/.claude/projects");
-  const claudeRoot = args.root ?? (scope.projectRoot ? join9(claudeProjectsRoot, encodeClaudeProjectDir(scope.projectRoot)) : claudeProjectsRoot);
-  const claudeRootMissing = !args.root && !!scope.projectRoot && !existsSync8(claudeRoot);
+  const claudeRoot = args.root ?? (scope.projectRoot ? join7(claudeProjectsRoot, encodeClaudeProjectDir(scope.projectRoot)) : claudeProjectsRoot);
+  const claudeRootMissing = !args.root && !!scope.projectRoot && !existsSync6(claudeRoot);
   const lockPath = getLockPath(args.global);
   const skillUniverse = discoverSkills({
     isGlobal: args.global,
@@ -1597,7 +1572,6 @@ async function runUsage(args) {
   let grandActivations = 0;
   for (const { agent, rows } of results) {
     const activations = rows.reduce((acc, r) => acc + r.count, 0);
-    console.log("");
     console.log(`${agent} ${rows.length} skill${rows.length === 1 ? "" : "s"} ${activations} time${activations === 1 ? "" : "s"} by ${periodLabel}`);
     if (rows.length === 0)
       continue;
@@ -1625,15 +1599,15 @@ var usageCommand = defineCommand({
 });
 
 // src/utils/update-check.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
+import { mkdirSync, readFileSync as readFileSync4, writeFileSync } from "node:fs";
 import { get } from "node:https";
-import { homedir as homedir7 } from "node:os";
-import { dirname as dirname7, join as join10 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname4, join as join8 } from "node:path";
 var PKG = "skillio";
 var TTL_MS = 24 * 60 * 60 * 1000;
 var FETCH_TIMEOUT_MS = 1500;
 function getCachePath() {
-  return join10(homedir7(), ".cache", "skillio", "version.json");
+  return join8(homedir5(), ".cache", "skillio", "version.json");
 }
 function compareVersions(a, b) {
   const pa = a.split(".").map((n) => Number.parseInt(n, 10) || 0);
@@ -1648,23 +1622,23 @@ function compareVersions(a, b) {
 }
 function readCache(path = getCachePath()) {
   try {
-    return JSON.parse(readFileSync7(path, "utf8"));
+    return JSON.parse(readFileSync4(path, "utf8"));
   } catch {
     return;
   }
 }
 function writeCache(cache, path = getCachePath()) {
   try {
-    mkdirSync2(dirname7(path), { recursive: true });
-    writeFileSync2(path, JSON.stringify(cache));
+    mkdirSync(dirname4(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(cache));
   } catch {}
 }
 function fetchLatest() {
-  return new Promise((resolve7) => {
+  return new Promise((resolve5) => {
     const req = get(`https://registry.npmjs.org/${PKG}/latest`, { timeout: FETCH_TIMEOUT_MS }, (res) => {
       if (res.statusCode !== 200) {
         res.resume();
-        resolve7(undefined);
+        resolve5(undefined);
         return;
       }
       let body = "";
@@ -1675,16 +1649,16 @@ function fetchLatest() {
       res.on("end", () => {
         try {
           const data = JSON.parse(body);
-          resolve7(typeof data.version === "string" ? data.version : undefined);
+          resolve5(typeof data.version === "string" ? data.version : undefined);
         } catch {
-          resolve7(undefined);
+          resolve5(undefined);
         }
       });
     });
-    req.on("error", () => resolve7(undefined));
+    req.on("error", () => resolve5(undefined));
     req.on("timeout", () => {
       req.destroy();
-      resolve7(undefined);
+      resolve5(undefined);
     });
   });
 }
@@ -1780,7 +1754,7 @@ function printRootHelp() {
     "  -h, --help       Show this help and exit",
     "  -v, --version    Show version and exit",
     "  -g, --global     Use global scope (default: false)",
-    "  -p, --period     Period for `usage`: 30sec, 5min, 12h, 7d, 2w, 1m, 1y, all (default: all)",
+    "  -p, --period     Period for `usage`: 60s, 30m, 24h, 30d, 2w, all (default: all)",
     "  -a, --agent      Agent for `usage`: claude-code, codex (default: both)",
     "",
     "COMMANDS",
@@ -1845,7 +1819,7 @@ var main = defineCommand({
       return;
     const interactive = process.stdout.isTTY && process.stdin.isTTY;
     if (interactive) {
-      const { runPicker } = await import("./shared/chunk-eq7h491z.js");
+      const { runPicker } = await import("./shared/chunk-j1p4zpqy.js");
       const status = await runPicker({
         global: args.global ?? false
       });

package/dist/shared/chunk-0qvp6v8g.js

@@ -0,0 +1,138 @@
+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 writeLock(path, lock) {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = join(dirname(path), `.${Date.now()}.skill-lock.json`);
+  writeFileSync(tmp, `${JSON.stringify(lock, null, 2)}
+`);
+  renameSync(tmp, path);
+}
+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, removeSkillFromLock, setColorEnabled, detectColorSupport, green, yellow, red, cyan, discoverSkills };

package/dist/shared/chunk-j1p4zpqy.js

@@ -0,0 +1,252 @@
+import {
+  cyan,
+  discoverSkills,
+  getLockPath,
+  red
+} from "./chunk-0qvp6v8g.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 (disk-only; lock with --force-lock)" },
+      { 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/package.json

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

package/dist/shared/chunk-eq7h491z.js

@@ -1,113 +0,0 @@
-import {
-  cyan
-} from "./chunk-s3421yr2.js";
-
-// src/commands/picker.ts
-import { spawnSync } from "node:child_process";
-
-// 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);
-  });
-}
-
-// src/commands/picker.ts
-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: "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;
-  }
-  const 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-s3421yr2.js

@@ -1,27 +0,0 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/utils/ansi.ts
-var enabled = false;
-function setColorEnabled(value) {
-  enabled = value;
-}
-function detectColorSupport() {
-  if (process.env.NO_COLOR)
-    return false;
-  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;
-}
-
-export { __require, setColorEnabled, detectColorSupport, green, yellow, red, cyan };