@dealdeploy/skl 0.4.0 → 1.1.0

package/lib.test.ts

@@ -1,70 +1,500 @@
-import { test, expect, beforeEach, afterEach } from "bun:test";
-import { mkdirSync, rmSync, existsSync, writeFileSync, symlinkSync } from "fs";
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync, existsSync, readdirSync, cpSync } 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,
+  lockPath,
+  findSkillEntries,
+  parseRepoArg,
+  buildAddArgs,
+  parseSkillsListOutput,
+  planUpdates,
+  groupByRepo,
+  type LockFile,
+  type LockEntry,
+  type TreeEntry,
+} 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"));
+// ── Lock file ───────────────────────────────────────────────────────
 
-  const orphans = findOrphanSkills([localDir], library);
+describe("lock file", () => {
+  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("writeLock creates .skl directory if missing", () => {
+    expect(existsSync(join(tmp, ".skl"))).toBe(false);
+    writeLock({ version: 1, skills: {} });
+    expect(existsSync(join(tmp, ".skl"))).toBe(true);
+  });
+
+  test("readLock returns empty on corrupted JSON", () => {
+    mkdirSync(join(tmp, ".skl"), { recursive: true });
+    writeFileSync(lockPath(), "not json");
+    expect(readLock()).toEqual({ version: 1, skills: {} });
+  });
+
+  test("readLock returns empty on wrong version", () => {
+    mkdirSync(join(tmp, ".skl"), { recursive: true });
+    writeFileSync(lockPath(), JSON.stringify({ version: 99, skills: {} }));
+    expect(readLock()).toEqual({ version: 1, skills: {} });
+  });
+
+  test("addToLock adds a new entry", () => {
+    writeLock({ version: 1, skills: {} });
+    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);
+    const lock = readLock();
+    expect(lock.skills["my-skill"]).toEqual(entry);
+  });
+
+  test("addToLock overwrites existing entry", () => {
+    const entry1: LockEntry = {
+      source: "a/b", sourceUrl: "https://github.com/a/b",
+      skillPath: "skills/x", treeSHA: "old", addedAt: "2026-01-01",
+    };
+    const entry2: LockEntry = {
+      source: "a/b", sourceUrl: "https://github.com/a/b",
+      skillPath: "skills/x", treeSHA: "new", addedAt: "2026-01-02",
+    };
+    addToLock("x", entry1);
+    addToLock("x", entry2);
+    expect(getLockEntry("x")!.treeSHA).toBe("new");
+  });
+
+  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-12",
+        },
+        "remove-me": {
+          source: "a/b", sourceUrl: "https://github.com/a/b",
+          skillPath: "skills/remove-me", treeSHA: "222", addedAt: "2026-03-12",
+        },
+      },
+    });
+    removeFromLock("remove-me");
+    const lock = readLock();
+    expect(lock.skills["keep-me"]).toBeDefined();
+    expect(lock.skills["remove-me"]).toBeUndefined();
+  });
+
+  test("removeFromLock is no-op for missing entry", () => {
+    writeLock({ version: 1, skills: {} });
+    removeFromLock("nonexistent");
+    expect(readLock()).toEqual({ version: 1, skills: {} });
+  });
+
+  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-12",
+        },
+      },
+    });
+    expect(getLockEntry("exists")).not.toBeNull();
+    expect(getLockEntry("exists")!.treeSHA).toBe("333");
+    expect(getLockEntry("nope")).toBeNull();
+  });
+});
+
+// ── Catalog ─────────────────────────────────────────────────────────
+
+describe("catalog", () => {
+  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");
+
+    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"]);
+  });
+
+  test("getCatalogSkills returns empty array when catalog doesn't exist", () => {
+    expect(getCatalogSkills()).toEqual([]);
+  });
+
+  test("getCatalogSkills returns sorted list", () => {
+    const catalog = catalogDir();
+    mkdirSync(catalog, { recursive: true });
+    for (const name of ["zebra", "apple", "mango"]) {
+      mkdirSync(join(catalog, name));
+      writeFileSync(join(catalog, name, "SKILL.md"), "# Skill");
+    }
+    expect(getCatalogSkills()).toEqual(["apple", "mango", "zebra"]);
+  });
 });
 
-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"));
+// ── findSkillEntries ────────────────────────────────────────────────
+
+describe("findSkillEntries", () => {
+  test("finds flat skills (name/SKILL.md)", () => {
+    const tree: TreeEntry[] = [
+      { path: "commit", type: "tree", sha: "aaa" },
+      { path: "commit/SKILL.md", type: "blob", sha: "bbb" },
+      { path: "commit/prompt.md", type: "blob", sha: "ccc" },
+      { path: "opentui", type: "tree", sha: "ddd" },
+      { path: "opentui/SKILL.md", type: "blob", sha: "eee" },
+    ];
+    const entries = findSkillEntries(tree);
+    expect(entries).toEqual([
+      { prefix: "commit", name: "commit", treeSHA: "aaa" },
+      { prefix: "opentui", name: "opentui", treeSHA: "ddd" },
+    ]);
+  });
 
-  const orphans = findOrphanSkills([localDir, localDir2], library);
+  test("finds nested skills (dir/name/SKILL.md)", () => {
+    const tree: TreeEntry[] = [
+      { path: "skills", type: "tree", sha: "000" },
+      { path: "skills/commit", type: "tree", sha: "aaa" },
+      { path: "skills/commit/SKILL.md", type: "blob", sha: "bbb" },
+      { path: "skills/opentui", type: "tree", sha: "ddd" },
+      { path: "skills/opentui/SKILL.md", type: "blob", sha: "eee" },
+    ];
+    const entries = findSkillEntries(tree);
+    expect(entries).toEqual([
+      { prefix: "skills/commit", name: "commit", treeSHA: "aaa" },
+      { prefix: "skills/opentui", name: "opentui", treeSHA: "ddd" },
+    ]);
+  });
 
-  expect(orphans).toHaveLength(1);
-  expect(orphans[0]!.name).toBe("shared-skill");
+  test("returns empty for tree with no SKILL.md", () => {
+    const tree: TreeEntry[] = [
+      { path: "README.md", type: "blob", sha: "aaa" },
+      { path: "src", type: "tree", sha: "bbb" },
+    ];
+    expect(findSkillEntries(tree)).toEqual([]);
+  });
+
+  test("sorts by name", () => {
+    const tree: TreeEntry[] = [
+      { path: "zeta", type: "tree", sha: "z" },
+      { path: "zeta/SKILL.md", type: "blob", sha: "z1" },
+      { path: "alpha", type: "tree", sha: "a" },
+      { path: "alpha/SKILL.md", type: "blob", sha: "a1" },
+    ];
+    const entries = findSkillEntries(tree);
+    expect(entries[0]!.name).toBe("alpha");
+    expect(entries[1]!.name).toBe("zeta");
+  });
+
+  test("handles missing tree entry for directory (empty SHA)", () => {
+    const tree: TreeEntry[] = [
+      { path: "orphan/SKILL.md", type: "blob", sha: "ooo" },
+      // No tree entry for "orphan"
+    ];
+    const entries = findSkillEntries(tree);
+    expect(entries).toEqual([
+      { prefix: "orphan", name: "orphan", treeSHA: "" },
+    ]);
+  });
 });
 
-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");
+// ── parseRepoArg ────────────────────────────────────────────────────
+
+describe("parseRepoArg", () => {
+  test("accepts owner/repo format", () => {
+    expect(parseRepoArg("vercel-labs/agent-skills")).toBe("vercel-labs/agent-skills");
+  });
 
-  const orphans = [{ dir: localDir, name: "cool-skill" }];
-  const results = adoptSkills(orphans, library);
+  test("extracts from GitHub URL", () => {
+    expect(parseRepoArg("https://github.com/vercel-labs/agent-skills")).toBe("vercel-labs/agent-skills");
+  });
 
-  expect(results).toEqual([{ name: "cool-skill", copied: true }]);
-  expect(existsSync(join(library, "cool-skill", "prompt.md"))).toBe(true);
+  test("strips .git suffix from URL", () => {
+    expect(parseRepoArg("https://github.com/owner/repo.git")).toBe("owner/repo");
+  });
+
+  test("extracts from URL with trailing path", () => {
+    expect(parseRepoArg("https://github.com/owner/repo/tree/main")).toBe("owner/repo");
+  });
+
+  test("returns null for empty string", () => {
+    expect(parseRepoArg("")).toBeNull();
+  });
+
+  test("returns null for invalid format", () => {
+    expect(parseRepoArg("just-a-name")).toBeNull();
+  });
+
+  test("returns null for triple-segment path", () => {
+    expect(parseRepoArg("a/b/c")).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"));
+// ── buildAddArgs ────────────────────────────────────────────────────
+
+describe("buildAddArgs", () => {
+  test("uses lock entry sourceUrl for remote skill", () => {
+    const entry: LockEntry = {
+      source: "owner/repo",
+      sourceUrl: "https://github.com/owner/repo",
+      skillPath: "skills/myskill",
+      treeSHA: "abc",
+      addedAt: "2026-01-01",
+    };
+    addToLock("myskill", entry);
+
+    const args = buildAddArgs("/catalog", "myskill", false);
+    expect(args).toEqual(["add", "https://github.com/owner/repo", "--skill", "myskill", "-y"]);
+  });
+
+  test("adds -g flag for global remote skill", () => {
+    const entry: LockEntry = {
+      source: "owner/repo",
+      sourceUrl: "https://github.com/owner/repo",
+      skillPath: "skills/myskill",
+      treeSHA: "abc",
+      addedAt: "2026-01-01",
+    };
+    addToLock("myskill", entry);
+
+    const args = buildAddArgs("/catalog", "myskill", true);
+    expect(args).toContain("-g");
+  });
+
+  test("uses catalog path for hand-authored skill", () => {
+    // No lock entry for this skill
+    const args = buildAddArgs("/my/catalog", "custom-skill", false);
+    expect(args).toEqual(["add", "/my/catalog/custom-skill", "-y"]);
+  });
+
+  test("adds -g flag for global hand-authored skill", () => {
+    const args = buildAddArgs("/my/catalog", "custom-skill", true);
+    expect(args).toEqual(["add", "/my/catalog/custom-skill", "-y", "-g"]);
+  });
+});
+
+// ── parseSkillsListOutput ───────────────────────────────────────────
+
+describe("parseSkillsListOutput", () => {
+  test("parses valid JSON array", () => {
+    const json = JSON.stringify([
+      { name: "opentui", path: "/some/path", scope: "project", agents: ["Claude Code"] },
+      { name: "commit", path: "/other/path", scope: "global", agents: ["Cursor"] },
+    ]);
+    expect(parseSkillsListOutput(json)).toEqual(["opentui", "commit"]);
+  });
+
+  test("returns empty for empty array", () => {
+    expect(parseSkillsListOutput("[]")).toEqual([]);
+  });
+
+  test("returns empty for invalid JSON", () => {
+    expect(parseSkillsListOutput("not json")).toEqual([]);
+  });
+
+  test("returns empty for non-array JSON", () => {
+    expect(parseSkillsListOutput('{"foo": "bar"}')).toEqual([]);
+  });
+
+  test("returns empty for empty string", () => {
+    expect(parseSkillsListOutput("")).toEqual([]);
+  });
+});
+
+// ── planUpdates ─────────────────────────────────────────────────────
+
+describe("planUpdates", () => {
+  const remoteTree: TreeEntry[] = [
+    { path: "skills", type: "tree", sha: "root" },
+    { path: "skills/alpha", type: "tree", sha: "new-alpha-sha" },
+    { path: "skills/alpha/SKILL.md", type: "blob", sha: "f1" },
+    { path: "skills/beta", type: "tree", sha: "same-beta-sha" },
+    { path: "skills/beta/SKILL.md", type: "blob", sha: "f2" },
+  ];
+
+  test("detects skills that need updating (SHA changed)", () => {
+    const skills = [
+      { name: "alpha", skillPath: "skills/alpha", treeSHA: "old-alpha-sha" },
+    ];
+    const plan = planUpdates(skills, remoteTree);
+    expect(plan.updated).toEqual([{
+      name: "alpha",
+      skillPath: "skills/alpha",
+      oldSHA: "old-alpha-sha",
+      newSHA: "new-alpha-sha",
+    }]);
+    expect(plan.upToDate).toEqual([]);
+    expect(plan.notFound).toEqual([]);
+  });
+
+  test("detects skills that are up to date (SHA matches)", () => {
+    const skills = [
+      { name: "beta", skillPath: "skills/beta", treeSHA: "same-beta-sha" },
+    ];
+    const plan = planUpdates(skills, remoteTree);
+    expect(plan.updated).toEqual([]);
+    expect(plan.upToDate).toEqual(["beta"]);
+    expect(plan.notFound).toEqual([]);
+  });
+
+  test("detects skills not found in remote tree", () => {
+    const skills = [
+      { name: "gamma", skillPath: "skills/gamma", treeSHA: "whatever" },
+    ];
+    const plan = planUpdates(skills, remoteTree);
+    expect(plan.updated).toEqual([]);
+    expect(plan.upToDate).toEqual([]);
+    expect(plan.notFound).toEqual(["gamma"]);
+  });
+
+  test("handles mix of updated, up-to-date, and missing", () => {
+    const skills = [
+      { name: "alpha", skillPath: "skills/alpha", treeSHA: "old-alpha-sha" },
+      { name: "beta", skillPath: "skills/beta", treeSHA: "same-beta-sha" },
+      { name: "gamma", skillPath: "skills/gamma", treeSHA: "missing" },
+    ];
+    const plan = planUpdates(skills, remoteTree);
+    expect(plan.updated.length).toBe(1);
+    expect(plan.upToDate.length).toBe(1);
+    expect(plan.notFound.length).toBe(1);
+  });
+
+  test("empty skills list returns empty plan", () => {
+    const plan = planUpdates([], remoteTree);
+    expect(plan.updated).toEqual([]);
+    expect(plan.upToDate).toEqual([]);
+    expect(plan.notFound).toEqual([]);
+  });
+});
+
+// ── groupByRepo ─────────────────────────────────────────────────────
+
+describe("groupByRepo", () => {
+  test("groups skills by source repo", () => {
+    const lock: LockFile = {
+      version: 1,
+      skills: {
+        "skill-a": {
+          source: "owner/repo1", sourceUrl: "https://github.com/owner/repo1",
+          skillPath: "skills/skill-a", treeSHA: "aaa", addedAt: "2026-01-01",
+        },
+        "skill-b": {
+          source: "owner/repo1", sourceUrl: "https://github.com/owner/repo1",
+          skillPath: "skills/skill-b", treeSHA: "bbb", addedAt: "2026-01-01",
+        },
+        "skill-c": {
+          source: "other/repo2", sourceUrl: "https://github.com/other/repo2",
+          skillPath: "skills/skill-c", treeSHA: "ccc", addedAt: "2026-01-01",
+        },
+      },
+    };
+    const byRepo = groupByRepo(lock);
+    expect(byRepo.size).toBe(2);
+    expect(byRepo.get("owner/repo1")!.length).toBe(2);
+    expect(byRepo.get("other/repo2")!.length).toBe(1);
+  });
+
+  test("skips skills without source or treeSHA", () => {
+    const lock: LockFile = {
+      version: 1,
+      skills: {
+        "has-source": {
+          source: "a/b", sourceUrl: "https://github.com/a/b",
+          skillPath: "skills/x", treeSHA: "aaa", addedAt: "2026-01-01",
+        },
+        "no-source": {
+          source: "", sourceUrl: "",
+          skillPath: "skills/y", treeSHA: "bbb", addedAt: "2026-01-01",
+        },
+        "no-sha": {
+          source: "a/b", sourceUrl: "https://github.com/a/b",
+          skillPath: "skills/z", treeSHA: "", addedAt: "2026-01-01",
+        },
+      },
+    };
+    const byRepo = groupByRepo(lock);
+    expect(byRepo.size).toBe(1);
+    expect(byRepo.get("a/b")!.length).toBe(1);
+  });
+
+  test("empty lock file returns empty map", () => {
+    const byRepo = groupByRepo({ version: 1, skills: {} });
+    expect(byRepo.size).toBe(0);
+  });
+});
+
+// ── Migration (integration test) ────────────────────────────────────
+
+describe("migration", () => {
+  test("copies skills from old library to catalog", () => {
+    const oldLib = join(tmp, "dotfiles/skills");
+    mkdirSync(join(oldLib, "skill-one"), { recursive: true });
+    writeFileSync(join(oldLib, "skill-one", "SKILL.md"), "# One");
+    mkdirSync(join(oldLib, "skill-two"), { recursive: true });
+    writeFileSync(join(oldLib, "skill-two", "SKILL.md"), "# Two");
+
+    const catalog = catalogDir();
+    mkdirSync(catalog, { recursive: true });
 
-  const orphans = findOrphanSkills([localDir], library);
+    // Simulate migration
+    for (const name of readdirSync(oldLib)) {
+      cpSync(join(oldLib, name), join(catalog, name), { recursive: true });
+    }
 
-  expect(orphans).toEqual([{ dir: localDir, name: "real-skill" }]);
+    expect(getCatalogSkills()).toEqual(["skill-one", "skill-two"]);
+  });
 });