@iceinvein/agent-skills 0.1.15 → 0.1.17

package/dist/cli/index.js

@@ -644,6 +644,158 @@ async function updateSkill(cwd, skillName) {
   }
   return { ok: true, from: oldVersion, to: manifestResult.manifest.version };
 }
+async function updateAllSkills(cwd) {
+  const lockfile = await readLockfile(cwd);
+  const skillNames = Object.keys(lockfile.skills);
+  if (skillNames.length === 0)
+    return [];
+  const results = [];
+  for (const name of skillNames) {
+    const result = await updateSkill(cwd, name);
+    results.push({ name, ...result });
+  }
+  return results;
+}
+
+// src/cli/commands/bump.ts
+import { join as join7 } from "node:path";
+
+// src/cli/semver.ts
+function bumpVersion(current, level) {
+  const parts = current.split(".");
+  if (parts.length !== 3 || parts.some((p) => !/^\d+$/.test(p))) {
+    throw new Error(`Invalid semver version: '${current}'`);
+  }
+  const [major, minor, patch] = parts.map(Number);
+  switch (level) {
+    case "major":
+      return `${major + 1}.0.0`;
+    case "minor":
+      return `${major}.${minor + 1}.0`;
+    case "patch":
+      return `${major}.${minor}.${patch + 1}`;
+  }
+}
+
+// src/cli/commands/bump.ts
+async function bumpSkill(repoRoot, skillName, level) {
+  const manifestPath = join7(repoRoot, "skills", skillName, "skill.json");
+  const file = Bun.file(manifestPath);
+  if (!await file.exists()) {
+    return { ok: false, error: `Skill '${skillName}' not found at skills/${skillName}/skill.json` };
+  }
+  const manifest = await file.json();
+  const from = manifest.version;
+  let to;
+  try {
+    to = bumpVersion(from, level);
+  } catch (e) {
+    return { ok: false, error: `Invalid version '${from}' in skills/${skillName}/skill.json` };
+  }
+  manifest.version = to;
+  await Bun.write(manifestPath, JSON.stringify(manifest, null, 2) + `
+`);
+  return { ok: true, from, to };
+}
+function getLatestTag(repoRoot) {
+  const result = Bun.spawnSync(["git", "describe", "--tags", "--abbrev=0"], {
+    cwd: repoRoot
+  });
+  if (result.exitCode !== 0)
+    return null;
+  return result.stdout.toString().trim();
+}
+var EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+function getChangedSkills(repoRoot, sinceTag) {
+  const base = sinceTag ?? EMPTY_TREE;
+  const args = ["git", "diff", "--name-only", base, "HEAD", "--", "skills/"];
+  const result = Bun.spawnSync(args, { cwd: repoRoot });
+  const output = result.stdout.toString().trim();
+  if (!output)
+    return new Set;
+  const names = new Set;
+  for (const line of output.split(`
+`)) {
+    const parts = line.split("/");
+    if (parts.length >= 2 && parts[0] === "skills") {
+      names.add(parts[1]);
+    }
+  }
+  return names;
+}
+function skillVersionChanged(repoRoot, skillName, sinceTag) {
+  const base = sinceTag ?? EMPTY_TREE;
+  const args = ["git", "diff", base, "HEAD", "--", `skills/${skillName}/skill.json`];
+  const result = Bun.spawnSync(args, { cwd: repoRoot });
+  const diff = result.stdout.toString();
+  const hasRemoved = diff.split(`
+`).some((l) => l.startsWith("-") && !l.startsWith("---") && l.includes('"version"'));
+  const hasAdded = diff.split(`
+`).some((l) => l.startsWith("+") && !l.startsWith("+++") && l.includes('"version"'));
+  return hasRemoved && hasAdded;
+}
+async function bumpAllChanged(repoRoot, level, dryRun) {
+  const tag = getLatestTag(repoRoot);
+  const changed = getChangedSkills(repoRoot, tag);
+  const results = [];
+  for (const skillName of changed) {
+    if (skillVersionChanged(repoRoot, skillName, tag))
+      continue;
+    if (dryRun) {
+      const manifestPath = join7(repoRoot, "skills", skillName, "skill.json");
+      const file = Bun.file(manifestPath);
+      if (!await file.exists())
+        continue;
+      const manifest = await file.json();
+      const from = manifest.version;
+      try {
+        const to = bumpVersion(from, level);
+        results.push({ name: skillName, ok: true, from, to });
+      } catch {
+        results.push({ name: skillName, ok: false, error: `Invalid version '${from}'` });
+      }
+    } else {
+      const result = await bumpSkill(repoRoot, skillName, level);
+      results.push({ name: skillName, ...result });
+    }
+  }
+  return results;
+}
+
+// src/cli/update-check.ts
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+async function checkForUpdates(cwd) {
+  try {
+    const lockfile = await readLockfile(cwd);
+    const skillNames = Object.keys(lockfile.skills);
+    if (skillNames.length === 0)
+      return [];
+    if (lockfile.lastUpdateCheck) {
+      const lastCheck = new Date(lockfile.lastUpdateCheck).getTime();
+      if (Date.now() - lastCheck < CHECK_INTERVAL_MS)
+        return [];
+    }
+    const results = await Promise.all(skillNames.map(async (name) => {
+      try {
+        const result = await fetchSkillManifest2(name);
+        if (!result.ok)
+          return null;
+        const installed = lockfile.skills[name].version;
+        if (result.manifest.version !== installed) {
+          return { name, installed, latest: result.manifest.version };
+        }
+        return null;
+      } catch {
+        return null;
+      }
+    }));
+    lockfile.lastUpdateCheck = new Date().toISOString();
+    await writeLockfile(cwd, lockfile);
+    return results.filter((r) => r !== null);
+  } catch {
+    return [];
+  }
+}
 
 // src/cli/types.ts
 var TOOL_NAMES2 = ["claude", "cursor", "codex", "gemini"];
@@ -683,7 +835,7 @@ Select (comma-separated numbers, e.g. 1,3): `);
 
 // src/cli/index.ts
 import { mkdirSync as mkdirSync4 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { homedir } from "os";
 function resolveInstallDir(flags) {
   if (flags.global !== undefined || flags.g !== undefined) {
@@ -691,7 +843,7 @@ function resolveInstallDir(flags) {
   }
   return process.cwd();
 }
-var BOOLEAN_FLAGS = new Set(["global", "g"]);
+var BOOLEAN_FLAGS = new Set(["global", "g", "all", "dry-run"]);
 function parseArgs(argv) {
   if (argv.length === 0)
     return { command: "help", args: [], flags: {} };
@@ -724,12 +876,16 @@ Usage:
   agent-skills install <skill>  [--tool <tool>] [-g]  Install a skill
   agent-skills remove  <skill>  [-g]                   Remove a skill
   agent-skills update  <skill>  [-g]                   Update a skill
+  agent-skills update  --all    [-g]                   Update all installed skills
+  agent-skills bump   <skill>  [patch|minor|major]     Bump a skill's version
+  agent-skills bump   --all    [patch|minor|major]     Bump all changed skills
   agent-skills list                                    List available skills
   agent-skills info    <skill>                         Show skill details
 
 Flags:
   --tool <tool>   Install for a specific tool (${TOOL_NAMES2.join(", ")})
   -g, --global    Install to home directory (available in all projects)
+  --dry-run       With bump --all: check without writing (exit 1 if unbumped)
 `);
 }
 function printInstalled(result, skipped) {
@@ -790,7 +946,7 @@ async function main() {
               gemini: ".gemini"
             };
             if (dirs[tool]) {
-              mkdirSync4(join7(installDir, dirs[tool]), { recursive: true });
+              mkdirSync4(join8(installDir, dirs[tool]), { recursive: true });
             }
           }
         } else {
@@ -823,12 +979,31 @@ async function main() {
       break;
     }
     case "update": {
+      const updateDir = resolveInstallDir(flags);
+      if (flags.all !== undefined) {
+        console.log(`Updating all installed skills...
+`);
+        const results = await updateAllSkills(updateDir);
+        if (results.length === 0) {
+          console.log("No skills installed.");
+          break;
+        }
+        for (const r of results) {
+          if (!r.ok) {
+            console.error(`  \u2717 ${r.name}: ${r.error}`);
+          } else if (r.from === r.to) {
+            console.log(`  \u2298 ${r.name} already up to date (v${r.to})`);
+          } else {
+            console.log(`  \u2713 ${r.name} v${r.from} \u2192 v${r.to}`);
+          }
+        }
+        break;
+      }
       const skillName = args[0];
       if (!skillName) {
         console.error("Error: skill name required. Usage: agent-skills update <skill>");
         process.exit(1);
       }
-      const updateDir = resolveInstallDir(flags);
       console.log(`Updating '${skillName}'...`);
       const result = await updateSkill(updateDir, skillName);
       if (!result.ok) {
@@ -876,11 +1051,68 @@ ${m.name} v${m.version}`);
         console.log(`  Package: ${m.mcp.package}`);
       break;
     }
+    case "bump": {
+      const BUMP_LEVELS = ["patch", "minor", "major"];
+      const repoRoot = import.meta.dir.replace(/\/dist\/cli$|\/src\/cli$/, "");
+      if (flags.all !== undefined) {
+        const levelArg = args[0] ?? "patch";
+        if (!BUMP_LEVELS.includes(levelArg)) {
+          console.error(`Error: invalid bump level '${levelArg}'. Must be one of: ${BUMP_LEVELS.join(", ")}`);
+          process.exit(1);
+        }
+        const dryRun = flags["dry-run"] !== undefined;
+        const results = await bumpAllChanged(repoRoot, levelArg, dryRun);
+        if (results.length === 0) {
+          if (!dryRun)
+            console.log("All skill versions are up to date.");
+          process.exit(0);
+        }
+        for (const r of results) {
+          if (!r.ok) {
+            console.error(`  \u2717 ${r.name}: ${r.error}`);
+          } else if (dryRun) {
+            console.log(`  needs bump: ${r.name} ${r.from} \u2192 ${r.to}`);
+          } else {
+            console.log(`  \u2713 ${r.name} ${r.from} \u2192 ${r.to}`);
+          }
+        }
+        if (dryRun)
+          process.exit(1);
+        break;
+      }
+      const skillName = args[0];
+      if (!skillName) {
+        console.error("Error: skill name required. Usage: agent-skills bump <skill> [patch|minor|major]");
+        process.exit(1);
+      }
+      const level = args[1] ?? "patch";
+      if (!BUMP_LEVELS.includes(level)) {
+        console.error(`Error: invalid bump level '${args[1]}'. Must be one of: ${BUMP_LEVELS.join(", ")}`);
+        process.exit(1);
+      }
+      const result = await bumpSkill(repoRoot, skillName, level);
+      if (!result.ok) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+      console.log(`\u2713 ${skillName} ${result.from} \u2192 ${result.to}`);
+      break;
+    }
     case "help":
     default:
       printHelp();
       break;
   }
+  if (command !== "update") {
+    const checkDir = flags.global !== undefined || flags.g !== undefined ? homedir() : process.cwd();
+    const outdated = await checkForUpdates(checkDir);
+    if (outdated.length > 0) {
+      const list = outdated.map((s) => `${s.name} (v${s.installed} \u2192 v${s.latest})`).join(", ");
+      console.log(`
+\u26A0 Updates available: ${list}`);
+      console.log("  Run: agent-skills update --all");
+    }
+  }
 }
 main().catch((err) => {
   console.error("Fatal:", err.message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iceinvein/agent-skills",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "Install agent skills into AI coding tools",
   "author": "iceinvein",
   "license": "MIT",
@@ -15,7 +15,11 @@
   "scripts": {
     "build": "bun build src/cli/index.ts --outdir dist/cli --target bun",
     "test": "bun test",
-    "dev": "bun run src/cli/index.ts"
+    "dev": "bun run src/cli/index.ts",
+    "skill:bump": "bun run src/cli/index.ts bump",
+    "skill:bump:all": "bun run src/cli/index.ts bump --all",
+    "skill:bump:check": "bun run src/cli/index.ts bump --all --dry-run",
+    "release": "bash scripts/release.sh"
   },
   "keywords": [
     "ai",

package/skills/terse/SKILL.md

@@ -36,9 +36,27 @@ Every response, cut these patterns:
 - Kill: [explanation] "So in summary, what we did was update the middleware to validate tokens correctly, which should fix the authentication issue."
 - Write: [explanation ends]
 
-**Narrating actions** — don't announce what you're about to do. Just do it.
+**Narrating actions** — don't announce what you're about to do. Just do it. The tool call is the communication. Never preface a tool call with text explaining that you're about to make it.
 - Kill: "Let me take a look at the file for you. I'll read it now and analyze what's going on."
-- Write: [reads the file]
+- Kill: "Now let me fix that issue."
+- Kill: "Let me check the tests."
+- Kill: "I'll update the config next."
+- Kill: "We need to update the schema first."
+- Kill: "First, I'll read the file to understand the structure."
+- Write: [tool call — no preamble]
+
+**Banned action-narration openers** — these phrases before a tool call are always filler. Cut them 100% of the time:
+- "Let me..." / "Now let me..." / "Now I'll..."
+- "I'll..." / "I need to..." / "We need to..."
+- "First, let me..." / "Next, I'll..."
+- "Going to..." / "I'm going to..."
+- "Time to..." / "Let's..."
+
+If context is needed between tool calls, state the *finding* or *decision*, not the action:
+- Kill: "Now let me update the handler to fix this."
+- Write: "The handler is missing the null check." [edits file]
+- Kill: "Let me run the tests to verify."
+- Write: [runs tests]
 
 **Over-explaining the obvious** — don't describe trivial operations.
 - Kill: "I'll create a new file called `utils.ts`. This file will contain utility functions that we can reuse across the project."

package/skills/terse/skill.json

@@ -1,10 +1,15 @@
 {
   "name": "terse",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Professional output compression — proper grammar, no fluff, ~50-60% fewer tokens. Three levels: clean, tight, sharp.",
   "author": "iceinvein",
   "type": "prompt",
-  "tools": ["claude", "cursor", "codex", "gemini"],
+  "tools": [
+    "claude",
+    "cursor",
+    "codex",
+    "gemini"
+  ],
   "files": {
     "prompt": "SKILL.md"
   },