@dealdeploy/skl 0.3.0 → 1.0.0

package/lib.test.ts

@@ -1,70 +1,139 @@
 import { test, expect, beforeEach, afterEach } from "bun:test";
-import { mkdirSync, rmSync, existsSync, writeFileSync, symlinkSync } from "fs";
+import { mkdirSync, rmSync, writeFileSync } from "fs";
 import { join } from "path";
 import { mkdtempSync } from "fs";
 import { tmpdir } from "os";
 
-import { findOrphanSkills, adoptSkills } from "./lib.ts";
+import {
+  readLock,
+  writeLock,
+  addToLock,
+  removeFromLock,
+  getCatalogSkills,
+  getLockEntry,
+  catalogDir,
+  type LockFile,
+  type LockEntry,
+} from "./lib.ts";
 
 let tmp: string;
-let library: string;
-let localDir: string;
+let origHome: string;
 
 beforeEach(() => {
   tmp = mkdtempSync(join(tmpdir(), "skl-test-"));
-  library = join(tmp, "library");
-  localDir = join(tmp, "local");
-  mkdirSync(library);
-  mkdirSync(localDir);
+  origHome = process.env.HOME!;
+  process.env.HOME = tmp;
 });
 
 afterEach(() => {
+  process.env.HOME = origHome;
   rmSync(tmp, { recursive: true, force: true });
 });
 
-test("detects a local skill not in the library", () => {
-  mkdirSync(join(localDir, "my-skill"));
-  mkdirSync(join(library, "other-skill"));
-
-  const orphans = findOrphanSkills([localDir], library);
+test("readLock returns empty structure when file doesn't exist", () => {
+  const lock = readLock();
+  expect(lock).toEqual({ version: 1, skills: {} });
+});
 
-  expect(orphans).toEqual([{ dir: localDir, name: "my-skill" }]);
+test("writeLock and readLock round-trip", () => {
+  const lock: LockFile = {
+    version: 1,
+    skills: {
+      "test-skill": {
+        source: "owner/repo",
+        sourceUrl: "https://github.com/owner/repo",
+        skillPath: "skills/test-skill",
+        treeSHA: "abc123",
+        addedAt: "2026-03-12T00:00:00.000Z",
+      },
+    },
+  };
+  writeLock(lock);
+  const read = readLock();
+  expect(read).toEqual(lock);
 });
 
-test("deduplicates when same skill exists in multiple local dirs", () => {
-  const localDir2 = join(tmp, "local2");
-  mkdirSync(localDir2);
-  mkdirSync(join(localDir, "shared-skill"));
-  mkdirSync(join(localDir2, "shared-skill"));
+test("addToLock adds a new entry", () => {
+  writeLock({ version: 1, skills: {} });
 
-  const orphans = findOrphanSkills([localDir, localDir2], library);
+  const entry: LockEntry = {
+    source: "owner/repo",
+    sourceUrl: "https://github.com/owner/repo",
+    skillPath: "skills/my-skill",
+    treeSHA: "def456",
+    addedAt: "2026-03-12T00:00:00.000Z",
+  };
+  addToLock("my-skill", entry);
 
-  expect(orphans).toHaveLength(1);
-  expect(orphans[0]!.name).toBe("shared-skill");
+  const lock = readLock();
+  expect(lock.skills["my-skill"]).toEqual(entry);
 });
 
-test("adoptSkills copies orphan skills into the library", () => {
-  // Create a local skill with a file inside
-  mkdirSync(join(localDir, "cool-skill"));
-  writeFileSync(join(localDir, "cool-skill", "prompt.md"), "# Cool Skill\nDo stuff");
-
-  const orphans = [{ dir: localDir, name: "cool-skill" }];
-  const results = adoptSkills(orphans, library);
+test("removeFromLock removes an entry", () => {
+  writeLock({
+    version: 1,
+    skills: {
+      "keep-me": {
+        source: "a/b",
+        sourceUrl: "https://github.com/a/b",
+        skillPath: "skills/keep-me",
+        treeSHA: "111",
+        addedAt: "2026-03-12T00:00:00.000Z",
+      },
+      "remove-me": {
+        source: "a/b",
+        sourceUrl: "https://github.com/a/b",
+        skillPath: "skills/remove-me",
+        treeSHA: "222",
+        addedAt: "2026-03-12T00:00:00.000Z",
+      },
+    },
+  });
+
+  removeFromLock("remove-me");
+  const lock = readLock();
+  expect(lock.skills["keep-me"]).toBeDefined();
+  expect(lock.skills["remove-me"]).toBeUndefined();
+});
 
-  expect(results).toEqual([{ name: "cool-skill", copied: true }]);
-  expect(existsSync(join(library, "cool-skill", "prompt.md"))).toBe(true);
+test("getLockEntry returns entry or null", () => {
+  writeLock({
+    version: 1,
+    skills: {
+      "exists": {
+        source: "a/b",
+        sourceUrl: "https://github.com/a/b",
+        skillPath: "skills/exists",
+        treeSHA: "333",
+        addedAt: "2026-03-12T00:00:00.000Z",
+      },
+    },
+  });
+
+  expect(getLockEntry("exists")).not.toBeNull();
+  expect(getLockEntry("exists")!.treeSHA).toBe("333");
+  expect(getLockEntry("nope")).toBeNull();
 });
 
-test("ignores symlinks and plain files in local dirs", () => {
-  // A regular file (not a directory)
-  writeFileSync(join(localDir, "not-a-skill"), "just a file");
-  // A symlink
-  mkdirSync(join(tmp, "symlink-target"));
-  symlinkSync(join(tmp, "symlink-target"), join(localDir, "linked-skill"));
-  // A real skill directory (should be detected)
-  mkdirSync(join(localDir, "real-skill"));
+test("getCatalogSkills finds directories with SKILL.md", () => {
+  const catalog = catalogDir();
+  mkdirSync(catalog, { recursive: true });
+
+  mkdirSync(join(catalog, "good-skill"));
+  writeFileSync(join(catalog, "good-skill", "SKILL.md"), "# Good");
 
-  const orphans = findOrphanSkills([localDir], library);
+  mkdirSync(join(catalog, "no-manifest"));
+
+  writeFileSync(join(catalog, "just-a-file"), "nope");
+
+  mkdirSync(join(catalog, "another-skill"));
+  writeFileSync(join(catalog, "another-skill", "SKILL.md"), "# Another");
+
+  const skills = getCatalogSkills();
+  expect(skills).toEqual(["another-skill", "good-skill"]);
+});
 
-  expect(orphans).toEqual([{ dir: localDir, name: "real-skill" }]);
+test("getCatalogSkills returns empty array when catalog doesn't exist", () => {
+  const skills = getCatalogSkills();
+  expect(skills).toEqual([]);
 });

package/lib.ts

@@ -1,50 +1,137 @@
-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 [];
   }
+}
+
+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;
 
-  return orphans;
+  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 function adoptSkills(
-  orphans: { dir: string; name: string }[],
-  library: string,
-): { name: string; copied: boolean }[] {
-  const results: { name: string; copied: boolean }[] = [];
+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 { 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 });
-    }
+  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 results;
+  return files.length;
 }

package/package.json

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