@dealdeploy/skl 0.4.0 → 1.1.0

package/lib.ts

@@ -1,50 +1,253 @@
-import { readdirSync, lstatSync, existsSync, cpSync } from "fs";
+import { readdirSync, existsSync, readFileSync, writeFileSync, mkdirSync, statSync } from "fs";
 import { join } from "path";
+import { homedir } from "os";
 
-export function findOrphanSkills(
-  localDirs: string[],
-  library: string,
-): { dir: string; name: string }[] {
-  const orphans: { dir: string; name: string }[] = [];
-  const seen = new Set<string>();
-
-  for (const dir of localDirs) {
-    try {
-      for (const name of readdirSync(dir)) {
-        if (seen.has(name)) continue;
+function home(): string {
+  return process.env.HOME || homedir();
+}
+
+export function catalogDir(): string {
+  return join(home(), ".skl/catalog");
+}
+
+export function lockPath(): string {
+  return join(home(), ".skl/catalog.lock.json");
+}
+
+export type LockEntry = {
+  source: string;
+  sourceUrl: string;
+  skillPath: string;
+  treeSHA: string;
+  addedAt: string;
+};
+
+export type LockFile = {
+  version: 1;
+  skills: Record<string, LockEntry>;
+};
+
+export function readLock(): LockFile {
+  try {
+    const data = JSON.parse(readFileSync(lockPath(), "utf-8"));
+    if (data.version === 1 && data.skills) return data;
+  } catch {}
+  return { version: 1, skills: {} };
+}
+
+export function writeLock(lock: LockFile): void {
+  mkdirSync(join(home(), ".skl"), { recursive: true });
+  writeFileSync(lockPath(), JSON.stringify(lock, null, 2) + "\n");
+}
+
+export function addToLock(name: string, entry: LockEntry): void {
+  const lock = readLock();
+  lock.skills[name] = entry;
+  writeLock(lock);
+}
+
+export function removeFromLock(name: string): void {
+  const lock = readLock();
+  delete lock.skills[name];
+  writeLock(lock);
+}
+
+export function getLockEntry(name: string): LockEntry | null {
+  const lock = readLock();
+  return lock.skills[name] ?? null;
+}
+
+export function getCatalogSkills(): string[] {
+  const dir = catalogDir();
+  try {
+    return readdirSync(dir)
+      .filter((name) => {
         const full = join(dir, name);
         try {
-          const stat = lstatSync(full);
-          if (stat.isSymbolicLink()) continue;
-          if (!stat.isDirectory()) continue;
-          if (!existsSync(join(library, name))) {
-            seen.add(name);
-            orphans.push({ dir, name });
-          }
-        } catch {}
-      }
-    } catch {}
+          return (
+            statSync(full).isDirectory() &&
+            existsSync(join(full, "SKILL.md"))
+          );
+        } catch {
+          return false;
+        }
+      })
+      .sort();
+  } catch {
+    return [];
   }
+}
+
+// ── Tree / skill discovery ────────────────────────────────────────────
+
+export type TreeEntry = { path: string; type: string; sha: string };
 
-  return orphans;
+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));
 }
 
-export function adoptSkills(
-  orphans: { dir: string; name: string }[],
-  library: string,
-): { name: string; copied: boolean }[] {
-  const results: { name: string; copied: boolean }[] = [];
+/** 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;
+}
 
-  for (const { dir, name } of orphans) {
-    const src = join(dir, name);
-    const dest = join(library, name);
-    try {
-      cpSync(src, dest, { recursive: true });
-      results.push({ name, copied: true });
-    } catch {
-      results.push({ name, copied: false });
+/** 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 results;
+  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,
+  token?: string,
+): Promise<string | null> {
+  const headers: Record<string, string> = {
+    Accept: "application/vnd.github+json",
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+
+  const repoResp = await fetch(`https://api.github.com/repos/${ownerRepo}`, { headers });
+  if (!repoResp.ok) return null;
+  const repoData = (await repoResp.json()) as { default_branch: string };
+  const branch = repoData.default_branch;
+
+  const treeResp = await fetch(
+    `https://api.github.com/repos/${ownerRepo}/git/trees/${branch}?recursive=1`,
+    { headers },
+  );
+  if (!treeResp.ok) return null;
+  const treeData = (await treeResp.json()) as { tree?: { path: string; type: string; sha: string }[] };
+
+  const entry = treeData.tree?.find(
+    (e: { path: string; type: string; sha: string }) =>
+      e.path === skillPath && e.type === "tree",
+  );
+  return entry?.sha ?? null;
+}
+
+export async function downloadSkillFiles(
+  repo: string,
+  branch: string,
+  prefix: string,
+  destDir: string,
+  tree: { path: string; type: string }[],
+): Promise<number> {
+  const prefixSlash = prefix + "/";
+  const files = tree
+    .filter((e) => e.type === "blob" && e.path.startsWith(prefixSlash))
+    .map((e) => e.path);
+
+  const baseUrl = `https://raw.githubusercontent.com/${repo}/${branch}`;
+
+  for (const filePath of files) {
+    const url = `${baseUrl}/${filePath}`;
+    const resp = await fetch(url);
+    if (!resp.ok) continue;
+    const content = await resp.arrayBuffer();
+    const relativePath = filePath.substring(prefixSlash.length);
+    const dest = join(destDir, relativePath);
+    const dir = dest.substring(0, dest.lastIndexOf("/"));
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(dest, Buffer.from(content));
+  }
+
+  return files.length;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dealdeploy/skl",
-  "version": "0.4.0",
+  "version": "1.1.0",
   "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"
+    }
+  }
+}