skillio 0.1.8 → 0.1.10

package/dist/cli.js

@@ -1,9 +1,16 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+import {
+  __require,
+  cyan,
+  detectColorSupport,
+  green,
+  red,
+  setColorEnabled,
+  yellow
+} from "./shared/chunk-s3421yr2.js";
 
 // src/cli.ts
-import { createRequire as createRequire2 } from "node:module";
+import { createRequire } from "node:module";
 
 // node_modules/citty/dist/_chunks/libs/scule.mjs
 var NUMBER_CHAR_RE = /\d/;
@@ -222,7 +229,7 @@ var noColor = /* @__PURE__ */ (() => {
 })();
 var _c = (c, r = 39) => (t) => noColor ? t : `\x1B[${c}m${t}\x1B[${r}m`;
 var bold = /* @__PURE__ */ _c(1, 22);
-var cyan = /* @__PURE__ */ _c(36);
+var cyan2 = /* @__PURE__ */ _c(36);
 var gray = /* @__PURE__ */ _c(90);
 var underline = /* @__PURE__ */ _c(4, 24);
 function parseArgs(rawArgs, argsDef) {
@@ -274,7 +281,7 @@ function parseArgs(rawArgs, argsDef) {
       const argument = parsedArgsProxy[arg.name];
       const options = arg.options || [];
       if (argument !== undefined && options.length > 0 && !options.includes(argument))
-        throw new CLIError(`Invalid value for argument: ${cyan(`--${arg.name}`)} (${cyan(argument)}). Expected one of: ${options.map((o) => cyan(o)).join(", ")}.`, "EARG");
+        throw new CLIError(`Invalid value for argument: ${cyan2(`--${arg.name}`)} (${cyan2(argument)}). Expected one of: ${options.map((o) => cyan2(o)).join(", ")}.`, "EARG");
     } else if (arg.required && parsedArgsProxy[arg.name] === undefined)
       throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
   return parsedArgsProxy;
@@ -319,7 +326,7 @@ async function runCommand(cmd, opts) {
       if (explicitName) {
         const subCommand = await _findSubCommand(subCommands, explicitName);
         if (!subCommand)
-          throw new CLIError(`Unknown command ${cyan(explicitName)}`, "E_UNKNOWN_COMMAND");
+          throw new CLIError(`Unknown command ${cyan2(explicitName)}`, "E_UNKNOWN_COMMAND");
         await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
       } else {
         const defaultSubCommand = await resolveValue(cmd.default);
@@ -328,7 +335,7 @@ async function runCommand(cmd, opts) {
             throw new CLIError(`Cannot specify both 'run' and 'default' on the same command.`, "E_DEFAULT_CONFLICT");
           const subCommand = await _findSubCommand(subCommands, defaultSubCommand);
           if (!subCommand)
-            throw new CLIError(`Default sub command ${cyan(defaultSubCommand)} not found in subCommands.`, "E_UNKNOWN_COMMAND");
+            throw new CLIError(`Default sub command ${cyan2(defaultSubCommand)} not found in subCommands.`, "E_UNKNOWN_COMMAND");
           await runCommand(subCommand, { rawArgs: opts.rawArgs });
         } else if (!cmd.run)
           throw new CLIError(`No command specified.`, "E_NO_COMMAND");
@@ -432,15 +439,15 @@ async function renderUsage(cmd, parent) {
     if (arg.type === "positional") {
       const name = arg.name.toUpperCase();
       const isRequired = arg.required !== false && arg.default === undefined;
-      posLines.push([cyan(name + renderValueHint(arg)), renderDescription(arg, isRequired)]);
+      posLines.push([cyan2(name + renderValueHint(arg)), renderDescription(arg, isRequired)]);
       usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
     } else {
       const isRequired = arg.required === true && arg.default === undefined;
       const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + renderValueHint(arg);
-      argLines.push([cyan(argStr), renderDescription(arg, isRequired)]);
+      argLines.push([cyan2(argStr), renderDescription(arg, isRequired)]);
       if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
         const negativeArgStr = [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ");
-        argLines.push([cyan(negativeArgStr), [arg.negativeDescription, isRequired ? gray("(Required)") : ""].filter(Boolean).join(" ")]);
+        argLines.push([cyan2(negativeArgStr), [arg.negativeDescription, isRequired ? gray("(Required)") : ""].filter(Boolean).join(" ")]);
       }
       if (isRequired)
         usageLine.push(`--${arg.name}` + renderValueHint(arg));
@@ -454,7 +461,7 @@ async function renderUsage(cmd, parent) {
         continue;
       const aliases = toArray(meta?.alias);
       const label = [name, ...aliases].join(", ");
-      commandsLines.push([cyan(label), meta?.description || ""]);
+      commandsLines.push([cyan2(label), meta?.description || ""]);
       commandNames.push(name, ...aliases);
     }
     usageLine.push(commandNames.join("|"));
@@ -463,7 +470,7 @@ async function renderUsage(cmd, parent) {
   const version = cmdMeta.version || parentMeta.version;
   usageLines.push(gray(`${cmdMeta.description} (${commandName + (version ? ` v${version}` : "")})`), "");
   const hasOptions = argLines.length > 0 || posLines.length > 0;
-  usageLines.push(`${underline(bold("USAGE"))} ${cyan(`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}`)}`, "");
+  usageLines.push(`${underline(bold("USAGE"))} ${cyan2(`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}`)}`, "");
   if (posLines.length > 0) {
     usageLines.push(underline(bold("ARGUMENTS")), "");
     usageLines.push(formatLineColumns(posLines, "  "));
@@ -477,7 +484,7 @@ async function renderUsage(cmd, parent) {
   if (commandsLines.length > 0) {
     usageLines.push(underline(bold("COMMANDS")), "");
     usageLines.push(formatLineColumns(commandsLines, "  "));
-    usageLines.push("", `Use ${cyan(`${commandName} <command> --help`)} for more information about a command.`);
+    usageLines.push("", `Use ${cyan2(`${commandName} <command> --help`)} for more information about a command.`);
   }
   return usageLines.filter((l) => typeof l === "string").join(`
 `);
@@ -577,29 +584,6 @@ function removeSkillFromLock(path, skill) {
   return { removed: true };
 }
 
-// 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 cyan2(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";
@@ -705,23 +689,28 @@ var costCommand = defineCommand({
     const rows = sortRows([...map.values()]);
     const total = rows.reduce((acc, r) => acc + (r.frontmatterTokens ?? 0), 0);
     const { message, paint } = classify(total);
-    console.log(args.global ? "Global" : "Local");
     console.log("");
+    console.log(args.global ? "Global" : "Local");
     if (rows.length === 0) {
       console.log(`No skills in ${lockPath}`);
       return;
     }
     const nameWidth = Math.max(...rows.map((r) => r.name.length));
+    const tokenWidth = Math.max(...rows.map((r) => r.status === "ok" ? `~${r.frontmatterTokens} tok`.length : r.status === "missing" ? "~? tok".length : "(no frontmatter)".length));
     for (const r of rows) {
-      let cell;
-      if (r.status === "ok")
-        cell = `~${r.frontmatterTokens} tok`;
-      else if (r.status === "missing")
-        cell = "missing";
-      else
-        cell = "(no frontmatter)";
-      const pad = " ".repeat(nameWidth - r.name.length);
-      console.log(`${cyan2(r.name)}${pad}  ${cell}`);
+      let tokenCell;
+      let suffix = "";
+      if (r.status === "ok") {
+        tokenCell = `~${r.frontmatterTokens} tok`;
+      } else if (r.status === "missing") {
+        tokenCell = "~? tok";
+        suffix = `  ${red("missing")}`;
+      } else {
+        tokenCell = "(no frontmatter)";
+      }
+      const namePad = " ".repeat(nameWidth - r.name.length);
+      const tokenPad = " ".repeat(Math.max(0, tokenWidth - tokenCell.length));
+      console.log(`${cyan(r.name)}${namePad}  ${tokenCell}${tokenPad}${suffix}`);
     }
     console.log("");
     console.log(`Total: ~${total} tok across ${rows.length} skills    ${paint(message)}`);
@@ -729,8 +718,6 @@ var costCommand = defineCommand({
 });
 
 // src/commands/list.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { dirname as dirname4, join as join4, resolve as resolve3 } from "node:path";
 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();
@@ -757,12 +744,6 @@ function bySource(records) {
     }
   };
 }
-function agentsDirExists(isGlobal, lockPath) {
-  if (isGlobal) {
-    return existsSync4(join4(process.env.HOME ?? "", ".agents", "skills"));
-  }
-  return existsSync4(join4(dirname4(resolve3(lockPath)), ".agents", "skills"));
-}
 var listCommand = defineCommand({
   meta: { description: "List skills per source with totals and lock-vs-disk diff" },
   args: {
@@ -773,38 +754,34 @@ var listCommand = defineCommand({
     const map = discoverSkills({ isGlobal: args.global, cwd: process.cwd(), lockPath });
     const records = [...map.values()];
     const rows = bySource(records);
-    const showAgents = agentsDirExists(args.global, lockPath) || rows.agents.names.length > 0;
     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];
-    if (showAgents)
-      sourceRows.push(rows.agents);
-    sourceRows.push(rows.lock);
+    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 === 0 ? "(empty)" : `${r.names.length} skill${r.names.length === 1 ? "" : "s"}`);
+    const countCells = sourceRows.map((r) => `${r.names.length} skill${r.names.length === 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)
         continue;
       const countCell = countCells[i] ?? "";
-      const namesText = row.names.length ? row.names.map(cyan2).join(" ") : "";
+      const namesText = row.names.length ? row.names.map(cyan).join(" ") : "";
       const line = `${row.label.padEnd(labelWidth)} : ${countCell.padEnd(countWidth)}${namesText ? ` : ${namesText}` : ""}`;
       console.log(line.trimEnd());
     }
     const diffs = [];
     if (lockOnly.length) {
-      diffs.push(`skills-lock.json has ${lockOnly.length} skill${lockOnly.length === 1 ? "" : "s"} missing on disk: ${lockOnly.map(cyan2).join(", ")}`);
+      diffs.push(`skills-lock.json has ${lockOnly.length} skill${lockOnly.length === 1 ? "" : "s"} missing on disk: ${lockOnly.map(cyan).join(", ")}`);
     }
     if (claudeNotInLock.length) {
-      diffs.push(`.claude/skills has ${claudeNotInLock.length} skill${claudeNotInLock.length === 1 ? "" : "s"} not in lock: ${claudeNotInLock.map(cyan2).join(", ")}`);
+      diffs.push(`.claude/skills has ${claudeNotInLock.length} skill${claudeNotInLock.length === 1 ? "" : "s"} not in lock: ${claudeNotInLock.map(cyan).join(", ")}`);
     }
     if (agentsNotInLock.length) {
-      diffs.push(`.agents/skills has ${agentsNotInLock.length} skill${agentsNotInLock.length === 1 ? "" : "s"} not in lock: ${agentsNotInLock.map(cyan2).join(", ")}`);
+      diffs.push(`.agents/skills has ${agentsNotInLock.length} skill${agentsNotInLock.length === 1 ? "" : "s"} not in lock: ${agentsNotInLock.map(cyan).join(", ")}`);
     }
     if (diffs.length) {
       console.log("");
@@ -815,9 +792,9 @@ var listCommand = defineCommand({
 });
 
 // src/commands/remove.ts
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname5, join as join6, resolve as resolve5 } from "node:path";
+import { dirname as dirname5, join as join5, resolve as resolve5 } from "node:path";
 
 // src/utils/confirm.ts
 import { createInterface } from "node:readline/promises";
@@ -837,15 +814,15 @@ async function confirm(question, opts = {}) {
 }
 
 // src/utils/fs-rm.ts
-import { existsSync as existsSync5, lstatSync, readdirSync as readdirSync2, rmSync } from "node:fs";
-import { join as join5, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync4, lstatSync, readdirSync as readdirSync2, rmSync } from "node:fs";
+import { join as join4, resolve as resolve3 } from "node:path";
 function isInside(target, root) {
-  const t = resolve4(target);
-  const r = resolve4(root);
+  const t = resolve3(target);
+  const r = resolve3(root);
   return t === r || t.startsWith(`${r}/`);
 }
 function countFiles(path) {
-  if (!existsSync5(path))
+  if (!existsSync4(path))
     return 0;
   const stat = lstatSync(path);
   if (stat.isFile())
@@ -854,7 +831,7 @@ function countFiles(path) {
     return 0;
   let n = 0;
   for (const entry of readdirSync2(path)) {
-    n += countFiles(join5(path, entry));
+    n += countFiles(join4(path, entry));
   }
   return n;
 }
@@ -863,21 +840,35 @@ function rmSkillDir(path, opts) {
   if (!safe) {
     throw new Error(`Refusing to delete: "${path}" is outside allowed roots`);
   }
-  if (!existsSync5(path))
+  if (!existsSync4(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 ? join6(homedir4(), ".claude", "skills") : join6(dirname5(resolve5(lockPath)), ".claude", "skills");
-  const baseAgents = isGlobal ? join6(homedir4(), ".agents", "skills") : join6(dirname5(resolve5(lockPath)), ".agents", "skills");
-  const claudeDir = existsSync6(join6(baseClaude, name)) ? join6(baseClaude, name) : undefined;
-  const agentsDir = existsSync6(join6(baseAgents, name)) ? join6(baseAgents, name) : undefined;
+  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;
   return { name, inLock, claudeDir, agentsDir };
 }
 function fileCount(dir) {
@@ -891,17 +882,21 @@ function fileCount(dir) {
       n++;
     else if (stat.isDirectory())
       for (const e of readdirSync3(cur))
-        stack.push(join6(cur, e));
+        stack.push(join5(cur, e));
   }
   return n;
 }
-function printPlan(plan) {
+function printPlan(plan, lockTracked) {
   const { target } = plan;
-  console.log(`Will remove "${target.name}":`);
-  if (target.inLock)
-    console.log("  - skills-lock.json");
-  else
+  console.log(`Will remove ${q(target.name)}:`);
+  if (target.inLock) {
+    if (lockTracked)
+      console.log("  - skills-lock.json (skipped: git-tracked; use --force-lock)");
+    else
+      console.log("  - skills-lock.json");
+  } else {
     console.log("  - skills-lock.json (not in lock)");
+  }
   if (target.claudeDir)
     console.log(`  - .claude/skills/${target.name}/  (${plan.claudeFileCount} files)`);
   else
@@ -916,10 +911,15 @@ var removeCommand = defineCommand({
   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" }
+    yes: { type: "boolean", alias: "y", default: false, description: "Skip confirmation prompt" },
+    "force-lock": {
+      type: "boolean",
+      default: false,
+      description: "Modify skills-lock.json even if it is git-tracked"
+    }
   },
   async run({ args }) {
-    const { global: isGlobal, "dry-run": dryRun, yes } = args;
+    const { global: isGlobal, "dry-run": dryRun, yes, "force-lock": forceLock } = 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) {
@@ -931,7 +931,7 @@ var removeCommand = defineCommand({
     const orphan = targets.filter((t) => !t.inLock && !t.claudeDir && !t.agentsDir);
     if (orphan.length) {
       for (const o of orphan)
-        console.log(`"${o.name}" is not in lock or on disk`);
+        console.log(`${q(o.name)} is not in lock or on disk`);
       process.exit(1);
     }
     const plans = targets.map((t) => ({
@@ -939,10 +939,14 @@ 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);
+      printPlan(p, lockTracked);
       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) {
@@ -952,27 +956,28 @@ var removeCommand = defineCommand({
         process.exit(1);
       }
     }
-    const allowedRoots = [
-      isGlobal ? homedir4() : dirname5(resolve5(lockPath)),
-      homedir4()
-    ];
+    const allowedRoots = [isGlobal ? homedir4() : dirname5(resolve5(lockPath)), homedir4()];
     for (const { target } of plans) {
       if (target.inLock) {
-        const r = removeSkillFromLock(lockPath, target.name);
-        if (r.removed)
-          console.log(`Removed "${target.name}" from skills-lock.json`);
+        if (lockTracked) {
+          console.log(`Skipped skills-lock.json (git-tracked) for ${q(target.name)}`);
+        } else {
+          const r = removeSkillFromLock(lockPath, target.name);
+          if (r.removed)
+            console.log(`Removed ${q(target.name)} from skills-lock.json`);
+        }
       } else {
         console.log(`Skipped skills-lock.json (not in lock)`);
       }
       if (target.claudeDir) {
         const r = rmSkillDir(target.claudeDir, { allowedRoots });
-        console.log(`Removed "${target.name}" from .claude/skills (${r.fileCount} files)`);
+        console.log(`Removed ${q(target.name)} from .claude/skills (${r.fileCount} files)`);
       } else {
         console.log("Skipped .claude/skills (not found)");
       }
       if (target.agentsDir) {
         const r = rmSkillDir(target.agentsDir, { allowedRoots });
-        console.log(`Removed "${target.name}" from .agents/skills (${r.fileCount} files)`);
+        console.log(`Removed ${q(target.name)} from .agents/skills (${r.fileCount} files)`);
       } else {
         console.log("Skipped .agents/skills (not found)");
       }
@@ -981,12 +986,91 @@ var removeCommand = defineCommand({
 });
 
 // src/commands/usage.ts
-import { existsSync as existsSync9 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join9 } from "node:path";
 
 // src/readers/claude.ts
 import { readFileSync as readFileSync5 } from "node:fs";
 
+// src/utils/codex-cmd.ts
+var READ_LIKE = new Set(["cat", "sed", "head", "tail", "bat", "batcat", "less", "more"]);
+var SKILL_PATH_RE = /[^\s'"`]*\/([^\s'"`/]+)\/SKILL\.md/g;
+function stripHeredocs(s) {
+  return s.replace(/<<-?\s*['"]?(\w+)['"]?[\s\S]*?\n[\t ]*\1\s*(?:\n|$)/g, "");
+}
+function splitTopLevel(s) {
+  const out = [];
+  let buf = "";
+  let i = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let inBacktick = false;
+  while (i < s.length) {
+    const c = s[i];
+    const next = s[i + 1];
+    if (!inDouble && !inBacktick && c === "'") {
+      inSingle = !inSingle;
+      buf += c;
+      i++;
+      continue;
+    }
+    if (!inSingle && !inBacktick && c === '"') {
+      inDouble = !inDouble;
+      buf += c;
+      i++;
+      continue;
+    }
+    if (!inSingle && !inDouble && c === "`") {
+      inBacktick = !inBacktick;
+      buf += c;
+      i++;
+      continue;
+    }
+    if (!inSingle && !inDouble && !inBacktick) {
+      if (c === "&" && next === "&" || c === "|" && next === "|") {
+        out.push(buf);
+        buf = "";
+        i += 2;
+        continue;
+      }
+      if (c === ";" || c === "|") {
+        out.push(buf);
+        buf = "";
+        i++;
+        continue;
+      }
+    }
+    buf += c;
+    i++;
+  }
+  out.push(buf);
+  return out;
+}
+function hasRedirect(segment) {
+  return /(?<![<2])>>?|&>>?/.test(segment);
+}
+function extractSkillReadsFromCmd(cmd) {
+  const stripped = stripHeredocs(cmd);
+  const segments = splitTopLevel(stripped);
+  const found = new Set;
+  for (const seg of segments) {
+    if (hasRedirect(seg))
+      continue;
+    const trimmed = seg.trimStart();
+    const firstTokenMatch = trimmed.match(/^(\S+)/);
+    if (!firstTokenMatch)
+      continue;
+    const firstToken = firstTokenMatch[1] ?? "";
+    if (!READ_LIKE.has(firstToken))
+      continue;
+    for (const m of seg.matchAll(SKILL_PATH_RE)) {
+      if (m[1])
+        found.add(m[1]);
+    }
+  }
+  return [...found];
+}
+
 // src/utils/walk.ts
 function walk(value, visit) {
   visit(value);
@@ -1047,6 +1131,21 @@ function extractCodexActivations(entry) {
     }
     return [...paths].map(skillNameFromPath).filter((s) => s !== null);
   }
+  if (e.type === "response_item" && payload?.type === "function_call" && payload?.name === "exec_command") {
+    const argsStr = payload?.arguments;
+    if (typeof argsStr !== "string")
+      return [];
+    let parsed;
+    try {
+      parsed = JSON.parse(argsStr);
+    } catch {
+      return [];
+    }
+    const cmd = parsed?.cmd;
+    if (typeof cmd !== "string")
+      return [];
+    return extractSkillReadsFromCmd(cmd);
+  }
   return [];
 }
 
@@ -1092,23 +1191,45 @@ function extractCodexMentions(entry) {
   return [...seen];
 }
 
+// src/utils/claude-entry.ts
+function isUserTurnEntry(entry) {
+  if (typeof entry !== "object" || entry === null)
+    return false;
+  const e = entry;
+  if (e.type !== "user")
+    return false;
+  const msg = e.message;
+  if (!msg || msg.role !== "user")
+    return false;
+  const content = msg.content;
+  if (typeof content === "string")
+    return true;
+  if (!Array.isArray(content))
+    return false;
+  return content.some((c) => {
+    if (typeof c !== "object" || c === null)
+      return false;
+    return c.type === "text";
+  });
+}
+
 // src/utils/expand-home.ts
 import { homedir as homedir5 } from "node:os";
-import { join as join7, resolve as resolve6 } from "node:path";
+import { join as join6, resolve as resolve6 } from "node:path";
 function expandHome(p) {
   if (p === "~")
     return homedir5();
   if (p.startsWith("~/"))
-    return join7(homedir5(), p.slice(2));
+    return join6(homedir5(), p.slice(2));
   return resolve6(p);
 }
 
 // src/utils/jsonl.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync2 } from "node:fs";
-import { join as join8 } from "node:path";
+import { join as join7 } from "node:path";
 function* findJsonlFiles(dir, since) {
   for (const item of readdirSync3(dir, { withFileTypes: true })) {
-    const path = join8(dir, item.name);
+    const path = join7(dir, item.name);
     if (item.isDirectory()) {
       yield* findJsonlFiles(path, since);
     } else if (item.isFile() && item.name.endsWith(".jsonl")) {
@@ -1131,13 +1252,6 @@ function isRecentEntry(entry, since) {
 }
 
 // src/readers/claude.ts
-function extractSkills(entry, mode) {
-  if (mode === "attributed")
-    return extractAttributed(entry);
-  if (mode === "activations")
-    return extractClaudeActivations(entry);
-  return extractClaudeMentions(entry);
-}
 function readClaudeUsage(options) {
   const root = expandHome(options.root ?? "~/.claude/projects");
   const counts = new Map;
@@ -1146,6 +1260,9 @@ function readClaudeUsage(options) {
   const since = options.scanAllFiles ? undefined : options.since;
   for (const file of findJsonlFiles(root, since)) {
     filesRead++;
+    let prevSkill = null;
+    const sessionAttr = new Map;
+    const sessionAct = new Map;
     for (const line of readFileSync5(file, "utf8").split(`
 `)) {
       if (!line.trim())
@@ -1159,8 +1276,39 @@ function readClaudeUsage(options) {
       }
       if (!isRecentEntry(entry, options.since))
         continue;
-      for (const skill of extractSkills(entry, options.mode)) {
-        counts.set(skill, (counts.get(skill) ?? 0) + 1);
+      if (options.mode === "attributed" || options.mode === "merged") {
+        const cur = extractAttributed(entry)[0];
+        if (cur !== undefined) {
+          if (cur !== prevSkill) {
+            sessionAttr.set(cur, (sessionAttr.get(cur) ?? 0) + 1);
+          }
+          prevSkill = cur;
+        } else if (isUserTurnEntry(entry)) {
+          prevSkill = null;
+        }
+      }
+      if (options.mode === "activations" || options.mode === "merged") {
+        for (const skill of extractClaudeActivations(entry)) {
+          sessionAct.set(skill, (sessionAct.get(skill) ?? 0) + 1);
+        }
+      }
+      if (options.mode === "mentions") {
+        for (const skill of extractClaudeMentions(entry)) {
+          counts.set(skill, (counts.get(skill) ?? 0) + 1);
+        }
+      }
+    }
+    if (options.mode === "attributed") {
+      for (const [k, v] of sessionAttr)
+        counts.set(k, (counts.get(k) ?? 0) + v);
+    } else if (options.mode === "activations") {
+      for (const [k, v] of sessionAct)
+        counts.set(k, (counts.get(k) ?? 0) + v);
+    } else if (options.mode === "merged") {
+      const keys = new Set([...sessionAttr.keys(), ...sessionAct.keys()]);
+      for (const k of keys) {
+        const merged = Math.max(sessionAttr.get(k) ?? 0, sessionAct.get(k) ?? 0);
+        counts.set(k, (counts.get(k) ?? 0) + merged);
       }
     }
   }
@@ -1168,12 +1316,12 @@ function readClaudeUsage(options) {
 }
 
 // src/readers/codex.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
 
 // src/utils/scope.ts
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { dirname as dirname6, join as join9 } from "node:path";
+import { dirname as dirname6, join as join8 } from "node:path";
 function detectScope(opts) {
   const home = opts.home ?? homedir6();
   if (opts.global || opts.rootOverride)
@@ -1193,7 +1341,7 @@ function encodeClaudeProjectDir(absPath) {
 function findGitRoot(start) {
   let dir = start;
   while (true) {
-    if (existsSync7(join9(dir, ".git")))
+    if (existsSync6(join8(dir, ".git")))
       return dir;
     const parent = dirname6(dir);
     if (parent === dir)
@@ -1266,7 +1414,7 @@ function readCodexMentions(options) {
   const historyPath = expandHome(options.history ?? "~/.codex/history.jsonl");
   const counts = new Map;
   let linesRead = 0;
-  if (!existsSync8(historyPath))
+  if (!existsSync7(historyPath))
     return { counts, filesRead: 0, linesRead: 0 };
   for (const line of readFileSync6(historyPath, "utf8").split(`
 `)) {
@@ -1318,7 +1466,7 @@ function pad(n, width) {
   return String(n).padStart(width);
 }
 function formatUsageRow(row) {
-  return `${pad(row.count, row.countWidth)} ${cyan2(row.name)}`;
+  return `${pad(row.count, row.countWidth)} ${cyan(row.name)}`;
 }
 function parseAgents(agent) {
   if (!agent)
@@ -1345,7 +1493,10 @@ var usageArgs = {
     description: "30sec, 5min, 12h, 7d, 2w, 1m, 1y, all"
   },
   since: { type: "string", description: "yyyy-mm-dd, overrides --period" },
-  mode: { type: "string", description: "attributed | activations | mentions" },
+  mode: {
+    type: "string",
+    description: "merged (default for claude-code) | attributed | activations | mentions"
+  },
   format: { type: "string", default: "text", description: "text | json" },
   root: { type: "string", description: "Override agent sessions directory; implies global" },
   "scan-all-files": { type: "boolean", default: false, description: "Ignore file mtime" },
@@ -1371,8 +1522,8 @@ async function runUsage(args) {
     cwd: process.cwd()
   });
   const claudeProjectsRoot = expandHome("~/.claude/projects");
-  const claudeRoot = args.root ?? (scope.projectRoot ? join10(claudeProjectsRoot, encodeClaudeProjectDir(scope.projectRoot)) : claudeProjectsRoot);
-  const claudeRootMissing = !args.root && !!scope.projectRoot && !existsSync9(claudeRoot);
+  const claudeRoot = args.root ?? (scope.projectRoot ? join9(claudeProjectsRoot, encodeClaudeProjectDir(scope.projectRoot)) : claudeProjectsRoot);
+  const claudeRootMissing = !args.root && !!scope.projectRoot && !existsSync8(claudeRoot);
   const lockPath = getLockPath(args.global);
   const skillUniverse = discoverSkills({
     isGlobal: args.global,
@@ -1385,7 +1536,7 @@ async function runUsage(args) {
     let stats;
     let mode;
     if (agent === "claude-code") {
-      mode = args.mode ?? "attributed";
+      mode = args.mode ?? "merged";
       const result = claudeRootMissing ? { counts: new Map, filesRead: 0, linesRead: 0 } : readClaudeUsage({ since, mode, root: claudeRoot, scanAllFiles });
       counts = result.counts;
       stats = { filesRead: result.filesRead, linesRead: result.linesRead };
@@ -1402,7 +1553,7 @@ async function runUsage(args) {
       stats = { filesRead: result.filesRead, linesRead: result.linesRead };
     }
     const universeNames = new Set([...skillUniverse.keys(), ...counts.keys()]);
-    const rows = [...universeNames].map((name) => {
+    const allRows = [...universeNames].map((name) => {
       const rec = skillUniverse.get(name);
       return {
         name,
@@ -1411,6 +1562,7 @@ async function runUsage(args) {
         status: rec?.status ?? "ok"
       };
     });
+    const rows = allRows.filter((r) => r.count > 0);
     rows.sort((a, b) => {
       const aOk = a.status === "ok";
       const bOk = b.status === "ok";
@@ -1439,6 +1591,7 @@ async function runUsage(args) {
   }
   const periodLabel = args.since ? `since ${args.since}` : args.period ?? "all";
   const scopeHeader = scope.global ? "Global" : "Local";
+  console.log("");
   console.log(scopeHeader);
   const distinct = new Set;
   let grandActivations = 0;
@@ -1475,12 +1628,12 @@ var usageCommand = defineCommand({
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
 import { get } from "node:https";
 import { homedir as homedir7 } from "node:os";
-import { dirname as dirname7, join as join11 } from "node:path";
+import { dirname as dirname7, join as join10 } from "node:path";
 var PKG = "skillio";
 var TTL_MS = 24 * 60 * 60 * 1000;
 var FETCH_TIMEOUT_MS = 1500;
 function getCachePath() {
-  return join11(homedir7(), ".cache", "skillio", "version.json");
+  return join10(homedir7(), ".cache", "skillio", "version.json");
 }
 function compareVersions(a, b) {
   const pa = a.split(".").map((n) => Number.parseInt(n, 10) || 0);
@@ -1558,7 +1711,7 @@ Run: npm i -g skillio
 }
 
 // src/cli.ts
-var { version } = createRequire2(import.meta.url)("../package.json");
+var { version } = createRequire(import.meta.url)("../package.json");
 function mergeAgentArgs(argv) {
   const out = [];
   const values = [];
@@ -1690,6 +1843,14 @@ var main = defineCommand({
   async run({ args }) {
     if (hasSubcommand(process.argv))
       return;
+    const interactive = process.stdout.isTTY && process.stdin.isTTY;
+    if (interactive) {
+      const { runPicker } = await import("./shared/chunk-eq7h491z.js");
+      const status = await runPicker({
+        global: args.global ?? false
+      });
+      process.exit(status);
+    }
     await costCommand.run?.({
       args,
       cmd: costCommand,

package/dist/shared/chunk-eq7h491z.js

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,27 @@
+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 };

package/package.json

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