@dealdeploy/skl 1.10.1 → 1.10.2

package/add-tui.ts

@@ -269,3 +269,294 @@ export function createAddTui(renderer: CliRenderer, deps: AddTuiDeps) {
     },
   };
 }
+
+// ── Multi-repo add TUI ──────────────────────────────────────────────
+
+export type AddSkillGroup = {
+  repo: string;
+  skills: AddSkillEntry[];
+};
+
+export type MultiRepoAddTuiDeps = {
+  groups: AddSkillGroup[];
+  onConfirm: (selected: Map<string, AddSkillEntry[]>) => Promise<void>;
+  onCancel: () => void;
+};
+
+type DisplayItem =
+  | { type: "header"; repo: string }
+  | { type: "skill"; skill: AddSkillEntry; groupIndex: number };
+
+export function createMultiRepoAddTui(renderer: CliRenderer, deps: MultiRepoAddTuiDeps) {
+  const { groups } = deps;
+
+  const C = {
+    bg: "#1a1a2e",
+    rowBg: "#1a1a2e",
+    rowAltBg: "#1f1f38",
+    cursorBg: "#2a2a5a",
+    border: "#444477",
+    fg: "#ccccdd",
+    fgDim: "#666688",
+    checked: "#66ff88",
+    unchecked: "#555566",
+    warning: "#ffaa44",
+    accent: "#8888ff",
+    title: "#aaaaff",
+    footer: "#888899",
+    statusOk: "#66ff88",
+    statusErr: "#ff6666",
+    headerFg: "#9999bb",
+  };
+
+  // Build flat display list
+  const items: DisplayItem[] = [];
+  for (let gi = 0; gi < groups.length; gi++) {
+    const group = groups[gi]!;
+    items.push({ type: "header", repo: group.repo });
+    for (const skill of group.skills) {
+      items.push({ type: "skill", skill, groupIndex: gi });
+    }
+  }
+
+  let cursor = items.findIndex((it) => it.type === "skill");
+  if (cursor < 0) cursor = 0;
+  const checked = new Set<number>();
+
+  const outer = new BoxRenderable(renderer, {
+    id: "outer",
+    width: "100%",
+    height: "100%",
+    flexDirection: "column",
+    backgroundColor: C.bg,
+  });
+
+  const header = new TextRenderable(renderer, {
+    id: "header",
+    content: ` New skills  (0 selected)`,
+    fg: C.title,
+    attributes: TextAttributes.BOLD,
+    height: 1,
+  });
+
+  const sep = new TextRenderable(renderer, {
+    id: "sep",
+    content: "\u2500".repeat(60),
+    fg: C.border,
+    height: 1,
+  });
+
+  const scrollBox = new ScrollBoxRenderable(renderer, {
+    id: "skill-list",
+    flexGrow: 1,
+    width: "100%",
+  });
+
+  type RowRef = {
+    row: BoxRenderable;
+    text: TextRenderable;
+    checkText?: TextRenderable;
+  };
+  const rows: RowRef[] = [];
+
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i]!;
+
+    if (item.type === "header") {
+      const row = new BoxRenderable(renderer, {
+        id: `row-${i}`,
+        flexDirection: "row",
+        height: 1,
+        width: "100%",
+        paddingLeft: 1,
+        backgroundColor: C.bg,
+      });
+      const text = new TextRenderable(renderer, {
+        id: `text-${i}`,
+        content: `  ${item.repo}`,
+        fg: C.headerFg,
+        attributes: TextAttributes.BOLD,
+      });
+      row.add(text);
+      scrollBox.add(row);
+      rows.push({ row, text });
+    } else {
+      const row = new BoxRenderable(renderer, {
+        id: `row-${i}`,
+        flexDirection: "row",
+        height: 1,
+        width: "100%",
+        paddingLeft: 1,
+        backgroundColor: i % 2 === 0 ? C.rowBg : C.rowAltBg,
+      });
+      const checkText = new TextRenderable(renderer, {
+        id: `check-${i}`,
+        content: "[ ]",
+        fg: C.unchecked,
+        width: 4,
+      });
+      const text = new TextRenderable(renderer, {
+        id: `name-${i}`,
+        content: `  ${item.skill.name}`,
+        fg: C.fg,
+        width: 40,
+      });
+      row.add(checkText);
+      row.add(text);
+      scrollBox.add(row);
+      rows.push({ row, text, checkText });
+    }
+  }
+
+  const footerSep = new TextRenderable(renderer, {
+    id: "footer-sep",
+    content: "\u2500".repeat(60),
+    fg: C.border,
+    height: 1,
+  });
+
+  const footer = new TextRenderable(renderer, {
+    id: "footer",
+    content: " j/k move  space toggle  a all  enter confirm  q cancel",
+    fg: C.footer,
+    height: 1,
+  });
+
+  const statusLine = new TextRenderable(renderer, {
+    id: "status",
+    content: "",
+    fg: C.statusOk,
+    height: 1,
+  });
+
+  outer.add(header);
+  outer.add(sep);
+  outer.add(scrollBox);
+  outer.add(footerSep);
+  outer.add(footer);
+  outer.add(statusLine);
+  renderer.root.add(outer);
+
+  let statusTimeout: ReturnType<typeof setTimeout> | null = null;
+
+  function setStatus(msg: string, color: string) {
+    statusLine.content = ` ${msg}`;
+    statusLine.fg = color;
+    if (statusTimeout) clearTimeout(statusTimeout);
+    statusTimeout = setTimeout(() => {
+      statusLine.content = "";
+    }, 3000);
+  }
+
+  function updateHeader() {
+    header.content = ` New skills  (${checked.size} selected)`;
+  }
+
+  function updateRow(i: number) {
+    const item = items[i]!;
+    const r = rows[i]!;
+    const isCursor = cursor === i;
+
+    if (item.type === "header") return;
+
+    const baseBg = i % 2 === 0 ? C.rowBg : C.rowAltBg;
+    r.row.backgroundColor = isCursor ? C.cursorBg : baseBg;
+
+    const isChecked = checked.has(i);
+    r.checkText!.content = isChecked ? "[x]" : "[ ]";
+    r.checkText!.fg = isCursor ? C.accent : (isChecked ? C.checked : C.unchecked);
+    const pointer = isCursor ? "\u25b8" : " ";
+    r.text.content = `${pointer} ${item.skill.name}`;
+    r.text.fg = isCursor ? "#ffffff" : C.fg;
+    r.text.attributes = isCursor ? TextAttributes.BOLD : TextAttributes.NONE;
+  }
+
+  function refreshAll() {
+    for (let i = 0; i < items.length; i++) updateRow(i);
+    updateHeader();
+  }
+
+  function ensureVisible() {
+    scrollBox.scrollTo(Math.max(0, cursor - 2));
+  }
+
+  function nextSkill(from: number, dir: 1 | -1): number {
+    let pos = from + dir;
+    while (pos >= 0 && pos < items.length) {
+      if (items[pos]!.type === "skill") return pos;
+      pos += dir;
+    }
+    return from;
+  }
+
+  refreshAll();
+
+  renderer.keyInput.on("keypress", (key: KeyEvent) => {
+    const prevCursor = cursor;
+
+    const navKey = (key.ctrl && { h: "left", j: "down", k: "up", l: "right" }[key.name]) || key.name;
+
+    switch (navKey) {
+      case "j":
+      case "down":
+        cursor = nextSkill(cursor, 1);
+        break;
+      case "k":
+      case "up":
+        cursor = nextSkill(cursor, -1);
+        break;
+      case "space": {
+        if (items[cursor]?.type !== "skill") break;
+        if (checked.has(cursor)) {
+          checked.delete(cursor);
+        } else {
+          checked.add(cursor);
+        }
+        break;
+      }
+      case "a": {
+        const skillIndices = items
+          .map((it, i) => (it.type === "skill" ? i : -1))
+          .filter((i) => i >= 0);
+        const allChecked = skillIndices.every((i) => checked.has(i));
+        if (allChecked) {
+          for (const i of skillIndices) checked.delete(i);
+        } else {
+          for (const i of skillIndices) checked.add(i);
+        }
+        for (const i of skillIndices) updateRow(i);
+        updateHeader();
+        ensureVisible();
+        return;
+      }
+      case "return": {
+        const selected = new Map<string, AddSkillEntry[]>();
+        for (const idx of checked) {
+          const item = items[idx]!;
+          if (item.type !== "skill") continue;
+          const repo = groups[item.groupIndex]!.repo;
+          const list = selected.get(repo) ?? [];
+          list.push(item.skill);
+          selected.set(repo, list);
+        }
+        if (selected.size === 0) {
+          setStatus("Nothing selected \u2014 use space to toggle", C.warning);
+          return;
+        }
+        deps.onConfirm(selected);
+        return;
+      }
+      case "q":
+      case "escape":
+        deps.onCancel();
+        return;
+      default:
+        return;
+    }
+
+    if (prevCursor !== cursor) updateRow(prevCursor);
+    updateRow(cursor);
+    updateHeader();
+    ensureVisible();
+  });
+}

package/index.ts

@@ -30,7 +30,8 @@ Usage:
   skl                Open the interactive TUI
   skl add <repo>     Add skills from a GitHub repo (interactive)
   skl add <repo> --all  Add all skills from a repo (non-interactive)
-  skl update         Update all remote skills
+  skl update            Update all remote skills
+  skl update --new, -n  Update and discover new skills from repos
   skl migrate        Migrate old symlinks to use the catalog
   skl migrate -l     Migrate local project symlinks
   skl help           Show this help message

package/package.json

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

package/update.ts

@@ -1,10 +1,13 @@
-import { rmSync, mkdirSync } from "fs";
+import { rmSync, mkdirSync, lstatSync } from "fs";
 import { join } from "path";
 import {
   readLock, writeLock, catalogDir, downloadSkillFiles,
-  groupByRepo, planUpdates, type TreeEntry,
+  groupByRepo, planUpdates, findSkillEntries, addToLock,
+  type TreeEntry, type LockEntry,
 } from "./lib.ts";
 
+const newFlag = process.argv.includes("--new") || process.argv.includes("-n");
+
 const lock = readLock();
 const byRepo = groupByRepo(lock);
 
@@ -31,6 +34,9 @@ let totalUpToDate = 0;
 let totalErrors = 0;
 const CATALOG = catalogDir();
 
+type RepoTreeInfo = { repo: string; branch: string; tree: TreeEntry[] };
+const repoTrees: RepoTreeInfo[] = [];
+
 for (const [repo, skills] of byRepo) {
   process.stdout.write(`Checking ${repo}...`);
 
@@ -71,6 +77,8 @@ for (const [repo, skills] of byRepo) {
 
   console.log("");
 
+  if (newFlag) repoTrees.push({ repo, branch, tree });
+
   const plan = planUpdates(skills, tree);
 
   totalUpToDate += plan.upToDate.length;
@@ -104,3 +112,87 @@ if (totalUpdated > 0) parts.push(`Updated ${totalUpdated} skill(s)`);
 if (totalUpToDate > 0) parts.push(`${totalUpToDate} already up to date`);
 if (totalErrors > 0) parts.push(`${totalErrors} error(s)`);
 console.log(`\n${parts.join(", ")}`);
+
+// ── New-skills phase ──────────────────────────────────────────────────
+if (newFlag && repoTrees.length > 0) {
+  const { createMultiRepoAddTui } = await import("./add-tui.ts");
+
+  const freshLock = readLock();
+  const groups: { repo: string; branch: string; skills: import("./add-tui.ts").AddSkillEntry[] }[] = [];
+
+  for (const { repo, branch, tree } of repoTrees) {
+    const entries = findSkillEntries(tree);
+    const newSkills = entries.filter((e) => !freshLock.skills[e.name]);
+    if (newSkills.length === 0) continue;
+
+    groups.push({
+      repo,
+      branch,
+      skills: newSkills.map((e) => ({
+        name: e.name,
+        prefix: e.prefix,
+        treeSHA: e.treeSHA,
+        exists: false,
+      })),
+    });
+  }
+
+  if (groups.length === 0) {
+    console.log("\nNo new skills found.");
+  } else {
+    const total = groups.reduce((sum, g) => sum + g.skills.length, 0);
+    console.log(`\nFound ${total} new skill(s) across ${groups.length} repo(s).`);
+
+    const { createCliRenderer } = await import("@opentui/core");
+    const renderer = await createCliRenderer({ exitOnCtrlC: true });
+
+    await new Promise<void>((resolve) => {
+      createMultiRepoAddTui(renderer, {
+        groups,
+        async onConfirm(selected) {
+          renderer.destroy();
+          mkdirSync(CATALOG, { recursive: true });
+          let added = 0;
+
+          for (const [repoKey, skills] of selected) {
+            const repoInfo = repoTrees.find((r) => r.repo === repoKey)!;
+            for (const skill of skills) {
+              const skillDir = join(CATALOG, skill.name);
+              try {
+                if (lstatSync(skillDir).isSymbolicLink()) {
+                  rmSync(skillDir, { force: true });
+                }
+              } catch {}
+              mkdirSync(skillDir, { recursive: true });
+
+              try {
+                const fileCount = await downloadSkillFiles(
+                  repoKey, repoInfo.branch, skill.prefix, skillDir, repoInfo.tree,
+                );
+                const entry: LockEntry = {
+                  source: repoKey,
+                  sourceUrl: `https://github.com/${repoKey}`,
+                  skillPath: skill.prefix,
+                  treeSHA: skill.treeSHA,
+                  addedAt: new Date().toISOString(),
+                };
+                addToLock(skill.name, entry);
+                console.log(`  ${skill.name} — added (${fileCount} files)`);
+                added++;
+              } catch (e: any) {
+                console.log(`  ${skill.name} — failed (${e.message})`);
+              }
+            }
+          }
+
+          console.log(`\nAdded ${added} new skill(s) to ~/.skl/catalog/`);
+          resolve();
+        },
+        onCancel() {
+          renderer.destroy();
+          resolve();
+        },
+      });
+    });
+  }
+}

package/.github/workflows/release.yml

@@ -1,18 +0,0 @@
-name: Publish
-
-on:
-  push:
-    tags:
-      - "v*"
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: oven-sh/setup-bun@v2
-      - run: bun install
-      - run: echo "//registry.npmjs.org/:_authToken=$NPM_TOKEN" > ~/.npmrc
-        env:
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-      - run: npm publish --access public