@dealdeploy/skl 1.0.0 → 1.1.1

package/lib.ts

@@ -78,6 +78,122 @@ export function getCatalogSkills(): string[] {
   }
 }
 
+// ── Tree / skill discovery ────────────────────────────────────────────
+
+export type TreeEntry = { path: string; type: string; sha: string };
+
+export type SkillEntry = {
+  name: string;
+  prefix: string;
+  treeSHA: string;
+};
+
+/** Find all skill directories (containing SKILL.md) in a GitHub tree. */
+export function findSkillEntries(tree: TreeEntry[]): SkillEntry[] {
+  return tree
+    .filter((e) => e.type === "blob" && e.path.endsWith("/SKILL.md"))
+    .map((e) => {
+      const prefix = e.path.replace(/\/SKILL\.md$/, "");
+      const name = prefix.split("/").pop()!;
+      const dirEntry = tree.find(
+        (t) => t.path === prefix && t.type === "tree"
+      );
+      return { prefix, name, treeSHA: dirEntry?.sha ?? "" };
+    })
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/** Parse a repo argument: "owner/repo" or GitHub URL → "owner/repo". Returns null if invalid. */
+export function parseRepoArg(input: string): string | null {
+  let repo = input;
+  const urlMatch = repo.match(/github\.com\/([^/]+\/[^/]+)/);
+  if (urlMatch) repo = urlMatch[1]!.replace(/\.git$/, "");
+  if (!repo || !/^[^/]+\/[^/]+$/.test(repo)) return null;
+  return repo;
+}
+
+/** Build npx skills add args for a skill. */
+export function buildAddArgs(
+  catalogPath: string,
+  name: string,
+  isGlobal: boolean,
+): string[] {
+  const lockEntry = getLockEntry(name);
+  if (lockEntry) {
+    const args = ["add", lockEntry.sourceUrl, "--skill", name, "-y"];
+    if (isGlobal) args.push("-g");
+    return args;
+  }
+  const args = ["add", join(catalogPath, name), "-y"];
+  if (isGlobal) args.push("-g");
+  return args;
+}
+
+/** Parse JSON output from `npx skills list --json`. */
+export function parseSkillsListOutput(jsonStr: string): string[] {
+  try {
+    const data = JSON.parse(jsonStr);
+    if (Array.isArray(data)) {
+      return data.map((s: { name: string }) => s.name);
+    }
+  } catch {}
+  return [];
+}
+
+// ── Update planning ─────────────────────────────────────────────────
+
+export type UpdatePlan = {
+  updated: { name: string; skillPath: string; oldSHA: string; newSHA: string }[];
+  upToDate: string[];
+  notFound: string[];
+};
+
+/** Compare lock entries against a remote tree and plan which skills need updating. */
+export function planUpdates(
+  skills: { name: string; skillPath: string; treeSHA: string }[],
+  remoteTree: TreeEntry[],
+): UpdatePlan {
+  const updated: UpdatePlan["updated"] = [];
+  const upToDate: string[] = [];
+  const notFound: string[] = [];
+
+  for (const skill of skills) {
+    const remoteEntry = remoteTree.find(
+      (e) => e.path === skill.skillPath && e.type === "tree"
+    );
+    if (!remoteEntry) {
+      notFound.push(skill.name);
+      continue;
+    }
+    if (remoteEntry.sha === skill.treeSHA) {
+      upToDate.push(skill.name);
+    } else {
+      updated.push({
+        name: skill.name,
+        skillPath: skill.skillPath,
+        oldSHA: skill.treeSHA,
+        newSHA: remoteEntry.sha,
+      });
+    }
+  }
+
+  return { updated, upToDate, notFound };
+}
+
+/** Group lock file skills by source repo. */
+export function groupByRepo(
+  lock: LockFile,
+): Map<string, { name: string; skillPath: string; treeSHA: string }[]> {
+  const byRepo = new Map<string, { name: string; skillPath: string; treeSHA: string }[]>();
+  for (const [name, entry] of Object.entries(lock.skills)) {
+    if (!entry.source || !entry.treeSHA) continue;
+    const list = byRepo.get(entry.source) ?? [];
+    list.push({ name, skillPath: entry.skillPath, treeSHA: entry.treeSHA });
+    byRepo.set(entry.source, list);
+  }
+  return byRepo;
+}
+
 export async function fetchTreeSHA(
   ownerRepo: string,
   skillPath: string,

package/package.json

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

package/skills-lock.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "skills": {
+    "agent-browser": {
+      "source": "vercel-labs/agent-browser",
+      "sourceType": "github",
+      "computedHash": "46eddb8bcb7de8e7c75ff53ee54bf764a576a923d19765b4ef6a71bb04755db6"
+    }
+  }
+}

package/update.ts

@@ -1,11 +1,14 @@
 import { rmSync, mkdirSync } from "fs";
 import { join } from "path";
-import { readLock, writeLock, catalogDir, downloadSkillFiles } from "./lib.ts";
+import {
+  readLock, writeLock, catalogDir, downloadSkillFiles,
+  groupByRepo, planUpdates, type TreeEntry,
+} from "./lib.ts";
 
 const lock = readLock();
-const remoteSkills = Object.entries(lock.skills).filter(([, e]) => e.source && e.treeSHA);
+const byRepo = groupByRepo(lock);
 
-if (remoteSkills.length === 0) {
+if (byRepo.size === 0) {
   console.log("No remote skills to update.");
   process.exit(0);
 }
@@ -23,41 +26,31 @@ const headers: Record<string, string> = {
 };
 if (token) headers.Authorization = `Bearer ${token}`;
 
-// Group skills by source repo
-const byRepo = new Map<string, { name: string; skillPath: string; treeSHA: string }[]>();
-for (const [name, entry] of remoteSkills) {
-  const list = byRepo.get(entry.source) ?? [];
-  list.push({ name, skillPath: entry.skillPath, treeSHA: entry.treeSHA });
-  byRepo.set(entry.source, list);
-}
-
-let updated = 0;
-let upToDate = 0;
-let errors = 0;
+let totalUpdated = 0;
+let totalUpToDate = 0;
+let totalErrors = 0;
 const CATALOG = catalogDir();
 
 for (const [repo, skills] of byRepo) {
   process.stdout.write(`Checking ${repo}...`);
 
-  // Get default branch
   let branch: string;
   try {
     const repoResp = await fetch(`https://api.github.com/repos/${repo}`, { headers });
     if (!repoResp.ok) {
       console.log(` failed (${repoResp.status})`);
-      errors += skills.length;
+      totalErrors += skills.length;
       continue;
     }
     const repoData = (await repoResp.json()) as { default_branch: string };
     branch = repoData.default_branch;
   } catch (e: any) {
     console.log(` failed (${e.message})`);
-    errors += skills.length;
+    totalErrors += skills.length;
     continue;
   }
 
-  // Fetch full tree
-  let tree: { path: string; type: string; sha: string }[];
+  let tree: TreeEntry[];
   try {
     const treeResp = await fetch(
       `https://api.github.com/repos/${repo}/git/trees/${branch}?recursive=1`,
@@ -65,36 +58,29 @@ for (const [repo, skills] of byRepo) {
     );
     if (!treeResp.ok) {
       console.log(` failed (${treeResp.status})`);
-      errors += skills.length;
+      totalErrors += skills.length;
       continue;
     }
-    const treeData = (await treeResp.json()) as { tree: { path: string; type: string; sha: string }[] };
+    const treeData = (await treeResp.json()) as { tree: TreeEntry[] };
     tree = treeData.tree;
   } catch (e: any) {
     console.log(` failed (${e.message})`);
-    errors += skills.length;
+    totalErrors += skills.length;
     continue;
   }
 
   console.log("");
 
-  for (const skill of skills) {
-    const remoteEntry = tree.find(
-      (e) => e.path === skill.skillPath && e.type === "tree"
-    );
+  const plan = planUpdates(skills, tree);
 
-    if (!remoteEntry) {
-      console.log(`  ${skill.name}: not found in remote tree (skipped)`);
-      errors++;
-      continue;
-    }
+  totalUpToDate += plan.upToDate.length;
+  totalErrors += plan.notFound.length;
 
-    if (remoteEntry.sha === skill.treeSHA) {
-      upToDate++;
-      continue;
-    }
+  for (const name of plan.notFound) {
+    console.log(`  ${name}: not found in remote tree (skipped)`);
+  }
 
-    // SHA differs — re-download
+  for (const skill of plan.updated) {
     const skillDir = join(CATALOG, skill.name);
     rmSync(skillDir, { recursive: true, force: true });
     mkdirSync(skillDir, { recursive: true });
@@ -102,19 +88,18 @@ for (const [repo, skills] of byRepo) {
     process.stdout.write(`  ${skill.name}...`);
     const fileCount = await downloadSkillFiles(repo, branch, skill.skillPath, skillDir, tree);
 
-    // Update lock entry
-    lock.skills[skill.name]!.treeSHA = remoteEntry.sha;
+    lock.skills[skill.name]!.treeSHA = skill.newSHA;
     console.log(` updated (${fileCount} files)`);
-    updated++;
+    totalUpdated++;
   }
 }
 
-if (updated > 0) {
+if (totalUpdated > 0) {
   writeLock(lock);
 }
 
 const parts: string[] = [];
-if (updated > 0) parts.push(`Updated ${updated} skill(s)`);
-if (upToDate > 0) parts.push(`${upToDate} already up to date`);
-if (errors > 0) parts.push(`${errors} error(s)`);
+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(", ")}`);