skillio 0.1.4 → 0.1.5

package/dist/cli.js

@@ -854,15 +854,27 @@ function readCodexMentions(options) {
 }
 
 // src/utils/period.ts
-var UNITS = { d: 1, w: 7, m: 30, y: 365 };
-var MS_PER_DAY = 24 * 60 * 60 * 1000;
+var SECOND_MS = 1000;
+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,
+  h: HOUR_MS,
+  d: DAY_MS,
+  w: 7 * DAY_MS,
+  m: 30 * DAY_MS,
+  y: 365 * DAY_MS
+};
 function parsePeriod(period) {
   if (period === "all")
     return Number.POSITIVE_INFINITY;
-  const match = period.match(/^(\d+)([dwmy])$/);
-  if (!match)
-    throw new Error(`Invalid period: "${period}". Use values like 7d, 2w, 1m, 1y, all.`);
-  const unit = UNITS[match[2] ?? ""] ?? 1;
+  const match = period.match(/^(\d+)(sec|min|[hdwmy])$/);
+  if (!match) {
+    throw new Error(`Invalid period: "${period}". Use values like 30sec, 5min, 12h, 7d, 2w, 1m, 1y, all.`);
+  }
+  const unit = UNITS_MS[match[2] ?? ""] ?? 0;
   return Number(match[1]) * unit;
 }
 
@@ -885,7 +897,7 @@ function toRows(counts) {
 async function runAudit(args) {
   const agents = parseAgents(args.agent);
   const allTime = !args.since && args.period === "all";
-  const since = args.since ? new Date(`${args.since}T00:00:00`) : args.period === "all" ? new Date(0) : new Date(Date.now() - parsePeriod(args.period) * 24 * 60 * 60 * 1000);
+  const since = args.since ? new Date(`${args.since}T00:00:00`) : args.period === "all" ? new Date(0) : new Date(Date.now() - parsePeriod(args.period));
   const scanAllFiles = allTime || args["scan-all-files"];
   if (Number.isNaN(since.getTime())) {
     console.error(`Invalid --since value: ${args.since}`);
@@ -959,7 +971,12 @@ var auditArgs = {
     alias: "a",
     description: "claude-code, codex (default: both; pass space-separated for both)"
   },
-  period: { type: "string", alias: "p", default: "all", description: "7d, 2w, 1m, 1y, all" },
+  period: {
+    type: "string",
+    alias: "p",
+    default: "all",
+    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" },
   format: { type: "string", default: "text", description: "text | json" },
@@ -974,16 +991,9 @@ var auditArgs = {
 };
 
 // src/lock/file.ts
-import {
-  copyFileSync,
-  existsSync as existsSync4,
-  mkdirSync,
-  readFileSync as readFileSync4,
-  renameSync,
-  writeFileSync
-} from "node:fs";
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, renameSync, writeFileSync } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { basename, dirname as dirname2, join as join5 } from "node:path";
+import { dirname as dirname2, join as join5 } from "node:path";
 function getLockPath(global) {
   return global ? join5(homedir3(), ".agents", ".skill-lock.json") : "skills-lock.json";
 }
@@ -999,43 +1009,132 @@ function writeLock(path, lock) {
 `);
   renameSync(tmp, path);
 }
-function getBackupPath(path) {
-  return join5(dirname2(path), ".tmp", `${basename(path)}.bak`);
-}
-function backupLock(path) {
-  const backupPath = getBackupPath(path);
-  mkdirSync(dirname2(backupPath), { recursive: true });
-  copyFileSync(path, backupPath);
-  return backupPath;
-}
-function removeSkillFromLock(path, skill, { skipBackup = false } = {}) {
+function removeSkillFromLock(path, skill) {
   if (!existsSync4(path))
     return { removed: false };
   const lock = readLock(path);
   if (!Object.hasOwn(lock.skills, skill))
     return { removed: false };
-  const backupPath = skipBackup ? undefined : backupLock(path);
   delete lock.skills[skill];
   writeLock(path, lock);
-  return { removed: true, backupPath };
+  return { removed: true };
+}
+
+// src/utils/skill-files.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname3, join as join6, resolve as resolve2 } from "node:path";
+var CHARS_PER_TOKEN = 4;
+function getSkillPathCandidates(name, lockPath, isGlobal) {
+  if (isGlobal) {
+    return [
+      join6(homedir4(), ".claude", "skills", name, "SKILL.md"),
+      join6(homedir4(), ".agents", "skills", name, "SKILL.md")
+    ];
+  }
+  return [join6(dirname3(resolve2(lockPath)), ".claude", "skills", name, "SKILL.md")];
 }
+function findSkillFile(name, lockPath, isGlobal) {
+  for (const p of getSkillPathCandidates(name, lockPath, isGlobal)) {
+    if (existsSync5(p))
+      return p;
+  }
+  return;
+}
+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);
+}
+function countFrontmatterTokens(filePath) {
+  const content = readFileSync5(filePath, "utf8");
+  const fm = extractFrontmatter(content);
+  if (fm === undefined)
+    return;
+  return estimateTokens(fm);
+}
+
+// src/commands/cost.ts
+var costCommand = defineCommand({
+  meta: {
+    description: "Estimate ambient token cost (frontmatter) of each skill in the lock file"
+  },
+  args: {
+    global: { type: "boolean", alias: "g", default: false, description: "Use global lock file" },
+    json: { type: "boolean", default: false, description: "Output as JSON" }
+  },
+  run({ args }) {
+    const lockPath = getLockPath(args.global);
+    const lock = readLock(lockPath);
+    const names = Object.keys(lock.skills).sort();
+    const rows = names.map((skill) => {
+      const file = findSkillFile(skill, lockPath, args.global);
+      if (!file)
+        return { skill, tokens: "missing" };
+      const tokens = countFrontmatterTokens(file);
+      if (tokens === undefined)
+        return { skill, tokens: "no-frontmatter" };
+      return { skill, tokens };
+    });
+    if (args.json) {
+      console.log(JSON.stringify(rows, null, 2));
+      return;
+    }
+    if (rows.length === 0) {
+      console.log(`No skills in ${lockPath}`);
+      return;
+    }
+    const nameWidth = Math.max(...rows.map((r) => r.skill.length));
+    let total = 0;
+    let missing = 0;
+    for (const r of rows) {
+      let cell;
+      if (typeof r.tokens === "number") {
+        cell = `~${r.tokens} tok`;
+        total += r.tokens;
+      } else if (r.tokens === "missing") {
+        cell = "missing";
+        missing += 1;
+      } else {
+        cell = "(no frontmatter)";
+      }
+      console.log(`${r.skill.padEnd(nameWidth)}  ${cell}`);
+    }
+    console.log("");
+    const tail = missing > 0 ? ` (${missing} missing)` : "";
+    console.log(`Total: ~${total} tok across ${rows.length} skills${tail}`);
+  }
+});
 
 // src/commands/list.ts
 var listCommand = defineCommand({
   meta: { description: "List skills in the lock file" },
   args: {
-    global: { type: "boolean", alias: "g", default: false, description: "Use global lock file" }
+    global: { type: "boolean", alias: "g", default: false, description: "Use global lock file" },
+    json: { type: "boolean", default: false, description: "Output as JSON array" }
   },
   run({ args }) {
     const path = getLockPath(args.global);
     const lock = readLock(path);
     const skills = Object.keys(lock.skills).sort();
-    console.log(JSON.stringify(skills, null, 2));
+    if (args.json) {
+      console.log(JSON.stringify(skills, null, 2));
+      return;
+    }
+    if (skills.length === 0) {
+      console.log(`No skills in ${path}`);
+      return;
+    }
+    for (const skill of skills)
+      console.log(skill);
+    console.log("");
+    console.log(`Total: ${skills.length} skill${skills.length === 1 ? "" : "s"} in ${path}`);
   }
 });
 
 // src/commands/remove.ts
-import { existsSync as existsSync5 } from "node:fs";
 var removeCommand = defineCommand({
   meta: { description: "Remove one or more skills from the lock file" },
   args: {
@@ -1057,22 +1156,105 @@ var removeCommand = defineCommand({
       }
       return;
     }
-    const backupPath = existsSync5(path) ? backupLock(path) : undefined;
     for (const skill of skills) {
-      const result = removeSkillFromLock(path, skill, { skipBackup: true });
+      const result = removeSkillFromLock(path, skill);
       if (result.removed) {
         console.log(`Removed "${skill}" from ${path}`);
       } else {
         console.log(`"${skill}" is not in ${path}`);
       }
     }
-    if (backupPath)
-      console.log(`Backup: ${backupPath}`);
     const updated = readLock(path);
     console.log(JSON.stringify(Object.keys(updated.skills).sort(), null, 2));
   }
 });
 
+// src/utils/update-check.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "node:fs";
+import { get } from "node:https";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname4, join as join7 } from "node:path";
+var PKG = "skillio";
+var TTL_MS = 24 * 60 * 60 * 1000;
+var FETCH_TIMEOUT_MS = 1500;
+function getCachePath() {
+  return join7(homedir5(), ".cache", "skillio", "version.json");
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const pb = b.split(".").map((n) => Number.parseInt(n, 10) || 0);
+  for (let i = 0;i < 3; i += 1) {
+    const da = pa[i] ?? 0;
+    const db = pb[i] ?? 0;
+    if (da !== db)
+      return da - db;
+  }
+  return 0;
+}
+function readCache(path = getCachePath()) {
+  try {
+    return JSON.parse(readFileSync6(path, "utf8"));
+  } catch {
+    return;
+  }
+}
+function writeCache(cache, path = getCachePath()) {
+  try {
+    mkdirSync2(dirname4(path), { recursive: true });
+    writeFileSync2(path, JSON.stringify(cache));
+  } catch {}
+}
+function fetchLatest() {
+  return new Promise((resolve3) => {
+    const req = get(`https://registry.npmjs.org/${PKG}/latest`, { timeout: FETCH_TIMEOUT_MS }, (res) => {
+      if (res.statusCode !== 200) {
+        res.resume();
+        resolve3(undefined);
+        return;
+      }
+      let body = "";
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => {
+        body += chunk;
+      });
+      res.on("end", () => {
+        try {
+          const data = JSON.parse(body);
+          resolve3(typeof data.version === "string" ? data.version : undefined);
+        } catch {
+          resolve3(undefined);
+        }
+      });
+    });
+    req.on("error", () => resolve3(undefined));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve3(undefined);
+    });
+  });
+}
+async function maybePrintUpdateNotice(currentVersion) {
+  if (process.env.SKILLIO_NO_UPDATE_CHECK)
+    return;
+  const now = Date.now();
+  const cache = readCache();
+  let latest = cache?.latest;
+  if (!cache || now - cache.checkedAt > TTL_MS) {
+    const fetched = await fetchLatest();
+    if (fetched) {
+      latest = fetched;
+      writeCache({ checkedAt: now, latest });
+    }
+  }
+  if (latest && compareVersions(latest, currentVersion) > 0) {
+    process.stderr.write(`
+Update available: ${currentVersion} → ${latest}
+Run: npm i -g skillio
+
+`);
+  }
+}
+
 // src/cli.ts
 var { version } = createRequire(import.meta.url)("../package.json");
 if (process.argv[2] === "audit") {
@@ -1111,7 +1293,7 @@ function mergeAgentArgs(argv) {
   return out;
 }
 process.argv = mergeAgentArgs(process.argv);
-var SUBCOMMAND_NAMES = new Set(["list", "ls", "remove", "rm"]);
+var SUBCOMMAND_NAMES = new Set(["list", "ls", "remove", "rm", "cost"]);
 var main = defineCommand({
   meta: {
     name: "skillio",
@@ -1133,7 +1315,11 @@ var main = defineCommand({
     list: listCommand,
     ls: listCommand,
     remove: removeCommand,
-    rm: removeCommand
+    rm: removeCommand,
+    cost: costCommand
   }
 });
-runMain(main);
+(async () => {
+  await maybePrintUpdateNotice(version);
+  runMain(main);
+})();

package/package.json

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