@dealdeploy/skl 1.2.0 → 1.4.0

package/index.ts

@@ -6,14 +6,21 @@ import { join } from "path";
 import { homedir } from "os";
 import { getCatalogSkills, removeFromLock, catalogDir, buildAddArgs, readLock, detectProjectAgents } from "./lib.ts";
 import { createTui, type ColId } from "./tui.ts";
+import { checkForUpdate } from "./update-check.ts";
 
 // @ts-ignore - bun supports JSON imports
 const { version: VERSION } = await import("./package.json");
 
+// Fire update check in background (non-blocking)
+const updateMsg = checkForUpdate(VERSION);
+
 // ── Flags ────────────────────────────────────────────────────────────
+const debug = process.argv.includes("--debug");
 const arg = process.argv[2];
 if (arg === "-v" || arg === "--version") {
   console.log(`skl ${VERSION}`);
+  const msg = await updateMsg;
+  if (msg) console.log(msg);
   process.exit(0);
 }
 if (arg === "-h" || arg === "--help" || arg === "help") {
@@ -30,21 +37,30 @@ Usage:
 
 Options:
   -h, --help         Show this help message
-  -v, --version      Show version`);
+  -v, --version      Show version
+  --debug            Show full error output on failures`);
   process.exit(0);
 }
 
 // ── Subcommand routing ───────────────────────────────────────────────
+async function printUpdateMsg() {
+  const msg = await updateMsg;
+  if (msg) console.log(`\n${msg}`);
+}
+
 if (arg === "add") {
   await import("./add.ts");
+  await printUpdateMsg();
   process.exit(0);
 }
 if (arg === "update") {
   await import("./update.ts");
+  await printUpdateMsg();
   process.exit(0);
 }
 if (arg === "migrate") {
   await import("./migrate.ts");
+  await printUpdateMsg();
   process.exit(0);
 }
 
@@ -101,8 +117,16 @@ const tui = createTui(renderer, {
       stdout: "pipe",
       stderr: "pipe",
     });
-    const code = await proc.exited;
-    return code === 0;
+    const [code, stdout, stderr] = await Promise.all([
+      proc.exited,
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
+    if (code === 0) return true;
+    if (debug) {
+      return (stderr || stdout).trim() || `exit code ${code}`;
+    }
+    return false;
   },
 
   async onDelete(name: string) {
@@ -141,8 +165,9 @@ const tui = createTui(renderer, {
     process.exit(0);
   },
 
-  onQuit() {
+  async onQuit() {
     renderer.destroy();
+    await printUpdateMsg();
     process.exit(0);
   },
 });

package/lib.test.ts

@@ -16,6 +16,7 @@ import {
   findSkillEntries,
   parseRepoArg,
   buildAddArgs,
+  readSkillFrontmatterName,
   detectProjectAgents,
   parseSkillsListOutput,
   planUpdates,
@@ -326,6 +327,67 @@ describe("buildAddArgs", () => {
     const args = buildAddArgs("/my/catalog", "custom-skill", true);
     expect(args).toEqual(["add", "/my/catalog/custom-skill", "-y", "-g"]);
   });
+
+  test("uses SKILL.md frontmatter name for --skill flag when it differs from dir name", () => {
+    const catalog = catalogDir();
+    mkdirSync(join(catalog, "code-review"), { recursive: true });
+    writeFileSync(
+      join(catalog, "code-review", "SKILL.md"),
+      "---\nname: code-review:code-review\ndescription: Review PRs\n---\n# Code Review"
+    );
+
+    const entry: LockEntry = {
+      source: "owner/repo",
+      sourceUrl: "https://github.com/owner/repo",
+      skillPath: "skills/code-review",
+      treeSHA: "abc",
+      addedAt: "2026-01-01",
+    };
+    addToLock("code-review", entry);
+
+    const args = buildAddArgs(catalog, "code-review", true);
+    expect(args).toContain("--skill");
+    expect(args).toContain("code-review:code-review");
+    expect(args).not.toContain("--agent");
+    expect(args).toContain("-g");
+  });
+});
+
+// ── readSkillFrontmatterName ────────────────────────────────────────
+
+describe("readSkillFrontmatterName", () => {
+  test("reads name from valid frontmatter", () => {
+    const catalog = catalogDir();
+    mkdirSync(join(catalog, "my-skill"), { recursive: true });
+    writeFileSync(
+      join(catalog, "my-skill", "SKILL.md"),
+      "---\nname: my-skill:variant\ndescription: test\n---\n# Content"
+    );
+    expect(readSkillFrontmatterName(catalog, "my-skill")).toBe("my-skill:variant");
+  });
+
+  test("returns null when no frontmatter", () => {
+    const catalog = catalogDir();
+    mkdirSync(join(catalog, "no-fm"), { recursive: true });
+    writeFileSync(join(catalog, "no-fm", "SKILL.md"), "# Just markdown");
+    expect(readSkillFrontmatterName(catalog, "no-fm")).toBeNull();
+  });
+
+  test("returns null when SKILL.md missing", () => {
+    const catalog = catalogDir();
+    mkdirSync(join(catalog, "empty"), { recursive: true });
+    expect(readSkillFrontmatterName(catalog, "empty")).toBeNull();
+  });
+
+  test("returns null when name field missing from frontmatter", () => {
+    const catalog = catalogDir();
+    mkdirSync(join(catalog, "no-name"), { recursive: true });
+    writeFileSync(
+      join(catalog, "no-name", "SKILL.md"),
+      "---\ndescription: has no name\n---\n# Content"
+    );
+    expect(readSkillFrontmatterName(catalog, "no-name")).toBeNull();
+  });
 });
 
 // ── detectProjectAgents ─────────────────────────────────────────────

package/lib.ts

@@ -160,6 +160,19 @@ export function detectProjectAgents(cwd: string): string[] {
   return agents;
 }
 
+/** Read the frontmatter `name` from a skill's SKILL.md in the catalog. */
+export function readSkillFrontmatterName(catalogPath: string, dirName: string): string | null {
+  try {
+    const content = readFileSync(join(catalogPath, dirName, "SKILL.md"), "utf-8");
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!match) return null;
+    const nameMatch = match[1]!.match(/^name:\s*(.+)$/m);
+    return nameMatch ? nameMatch[1]!.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
 /** Build npx skills add args for a skill. */
 export function buildAddArgs(
   catalogPath: string,
@@ -172,7 +185,8 @@ export function buildAddArgs(
     ? ["--agent", ...projectAgents]
     : [];
   if (lockEntry) {
-    const args = ["add", lockEntry.sourceUrl, "--skill", name, "-y", ...agentArgs];
+    const skillName = readSkillFrontmatterName(catalogPath, name) ?? name;
+    const args = ["add", lockEntry.sourceUrl, "--skill", skillName, "-y", ...agentArgs];
     if (isGlobal) args.push("-g");
     return args;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dealdeploy/skl",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "TUI skill manager for Claude Code agents",
   "module": "index.ts",
   "bin": {

package/tui.ts

@@ -18,8 +18,8 @@ export type TuiDeps = {
   globalInstalled: Set<string>;
   localInstalled: Set<string>;
   catalogPath: string;
-  /** Called when a skill toggle is requested. Return true on success. */
-  onToggle: (col: ColId, name: string, enable: boolean) => Promise<boolean>;
+  /** Called when a skill toggle is requested. Return true on success, false or error string on failure. */
+  onToggle: (col: ColId, name: string, enable: boolean) => Promise<boolean | string>;
   /** Called when a skill delete is requested. */
   onDelete: (name: string) => Promise<void>;
   /** Called when edit is requested. Return false to stay in TUI. */
@@ -239,6 +239,14 @@ export function createTui(renderer: CliRenderer, deps: TuiDeps) {
   const rows: RowRefs[] = new Array(allSkills.length);
 
   scrollBox.add(searchRow);
+  scrollBox.add(
+    new BoxRenderable(renderer, {
+      id: "spacer-search",
+      height: 1,
+      width: "100%",
+      backgroundColor: C.rowBg,
+    })
+  );
 
   for (let di = 0; di < displayItems.length; di++) {
     const item = displayItems[di]!;
@@ -490,7 +498,7 @@ export function createTui(renderer: CliRenderer, deps: TuiDeps) {
           if (rows[item.skillIndex]!.row.visible) visibleBefore++;
         }
       }
-      scrollBox.scrollTo(Math.max(0, visibleBefore + 1 - 2));
+      scrollBox.scrollTo(Math.max(0, visibleBefore + 2 - 2));
     }
   }
 
@@ -505,8 +513,8 @@ export function createTui(renderer: CliRenderer, deps: TuiDeps) {
     refreshAll();
 
     try {
-      const ok = await deps.onToggle(col, name, !enabled);
-      if (ok) {
+      const result = await deps.onToggle(col, name, !enabled);
+      if (result === true) {
         const set = col === "global" ? globalInstalled : localInstalled;
         if (enabled) {
           set.delete(name);
@@ -516,7 +524,8 @@ export function createTui(renderer: CliRenderer, deps: TuiDeps) {
           setStatus(`Added ${name}`, C.statusOk);
         }
       } else {
-        setStatus(`Failed to ${enabled ? "remove" : "add"} ${name}`, C.statusErr);
+        const detail = typeof result === "string" ? `: ${result}` : "";
+        setStatus(`Failed to ${enabled ? "remove" : "add"} ${name}${detail}`, C.statusErr);
       }
     } finally {
       pendingToggles.delete(key);

package/update-check.ts

@@ -0,0 +1,59 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const CACHE_PATH = join(homedir(), ".skl", "update-check.json");
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 1 day
+const PKG_NAME = "@dealdeploy/skl";
+
+type Cache = { latest: string; checkedAt: number };
+
+function readCache(): Cache | null {
+  try {
+    return JSON.parse(readFileSync(CACHE_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(cache: Cache): void {
+  mkdirSync(join(homedir(), ".skl"), { recursive: true });
+  writeFileSync(CACHE_PATH, JSON.stringify(cache));
+}
+
+/**
+ * Check npm for the latest version. Non-blocking — fire and forget.
+ * Returns a message string if an update is available, or null.
+ */
+export async function checkForUpdate(currentVersion: string): Promise<string | null> {
+  const cache = readCache();
+  const now = Date.now();
+
+  // Use cache if fresh
+  if (cache && now - cache.checkedAt < CHECK_INTERVAL_MS) {
+    return compareVersions(currentVersion, cache.latest);
+  }
+
+  // Fetch from registry
+  try {
+    const resp = await fetch(`https://registry.npmjs.org/${PKG_NAME}/latest`, {
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!resp.ok) return null;
+    const data = (await resp.json()) as { version: string };
+    writeCache({ latest: data.version, checkedAt: now });
+    return compareVersions(currentVersion, data.version);
+  } catch {
+    return null;
+  }
+}
+
+function compareVersions(current: string, latest: string): string | null {
+  if (current === latest) return null;
+  const [cMaj, cMin, cPat] = current.split(".").map(Number);
+  const [lMaj, lMin, lPat] = latest.split(".").map(Number);
+  if (lMaj > cMaj || lMin > cMin || lPat > cPat) {
+    return `Update available: ${current} → ${latest}  (run: bun install -g ${PKG_NAME})`;
+  }
+  return null;
+}