@dealdeploy/skl 1.0.0 → 1.1.1

package/lib.test.ts

@@ -1,5 +1,5 @@
-import { test, expect, beforeEach, afterEach } from "bun:test";
-import { mkdirSync, rmSync, writeFileSync } 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";
@@ -12,8 +12,16 @@ import {
   getCatalogSkills,
   getLockEntry,
   catalogDir,
+  lockPath,
+  findSkillEntries,
+  parseRepoArg,
+  buildAddArgs,
+  parseSkillsListOutput,
+  planUpdates,
+  groupByRepo,
   type LockFile,
   type LockEntry,
+  type TreeEntry,
 } from "./lib.ts";
 
 let tmp: string;
@@ -30,110 +38,463 @@ afterEach(() => {
   rmSync(tmp, { recursive: true, force: true });
 });
 
-test("readLock returns empty structure when file doesn't exist", () => {
-  const lock = readLock();
-  expect(lock).toEqual({ version: 1, skills: {} });
-});
+// ── Lock file ───────────────────────────────────────────────────────
+
+describe("lock file", () => {
+  test("readLock returns empty structure when file doesn't exist", () => {
+    const lock = readLock();
+    expect(lock).toEqual({ version: 1, skills: {} });
+  });
 
-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",
+  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);
-});
+    };
+    writeLock(lock);
+    const read = readLock();
+    expect(read).toEqual(lock);
+  });
 
-test("addToLock adds a new entry", () => {
-  writeLock({ version: 1, skills: {} });
+  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);
+  });
 
-  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);
+  test("readLock returns empty on corrupted JSON", () => {
+    mkdirSync(join(tmp, ".skl"), { recursive: true });
+    writeFileSync(lockPath(), "not json");
+    expect(readLock()).toEqual({ version: 1, skills: {} });
+  });
 
-  const lock = readLock();
-  expect(lock.skills["my-skill"]).toEqual(entry);
-});
+  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-12T00:00:00.000Z",
+  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",
+        },
       },
-      "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();
+  });
+
+  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"]);
   });
 
-  removeFromLock("remove-me");
-  const lock = readLock();
-  expect(lock.skills["keep-me"]).toBeDefined();
-  expect(lock.skills["remove-me"]).toBeUndefined();
+  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("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",
-      },
-    },
+// ── 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" },
+    ]);
+  });
+
+  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" },
+    ]);
+  });
+
+  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: "" },
+    ]);
+  });
+});
+
+// ── parseRepoArg ────────────────────────────────────────────────────
+
+describe("parseRepoArg", () => {
+  test("accepts owner/repo format", () => {
+    expect(parseRepoArg("vercel-labs/agent-skills")).toBe("vercel-labs/agent-skills");
+  });
+
+  test("extracts from GitHub URL", () => {
+    expect(parseRepoArg("https://github.com/vercel-labs/agent-skills")).toBe("vercel-labs/agent-skills");
+  });
+
+  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();
   });
 
-  expect(getLockEntry("exists")).not.toBeNull();
-  expect(getLockEntry("exists")!.treeSHA).toBe("333");
-  expect(getLockEntry("nope")).toBeNull();
+  test("returns null for triple-segment path", () => {
+    expect(parseRepoArg("a/b/c")).toBeNull();
+  });
 });
 
-test("getCatalogSkills finds directories with SKILL.md", () => {
-  const catalog = catalogDir();
-  mkdirSync(catalog, { recursive: true });
+// ── buildAddArgs ────────────────────────────────────────────────────
 
-  mkdirSync(join(catalog, "good-skill"));
-  writeFileSync(join(catalog, "good-skill", "SKILL.md"), "# Good");
+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);
 
-  mkdirSync(join(catalog, "no-manifest"));
+    const args = buildAddArgs("/catalog", "myskill", false);
+    expect(args).toEqual(["add", "https://github.com/owner/repo", "--skill", "myskill", "-y"]);
+  });
 
-  writeFileSync(join(catalog, "just-a-file"), "nope");
+  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);
 
-  mkdirSync(join(catalog, "another-skill"));
-  writeFileSync(join(catalog, "another-skill", "SKILL.md"), "# Another");
+    const args = buildAddArgs("/catalog", "myskill", true);
+    expect(args).toContain("-g");
+  });
 
-  const skills = getCatalogSkills();
-  expect(skills).toEqual(["another-skill", "good-skill"]);
+  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"]);
+  });
 });
 
-test("getCatalogSkills returns empty array when catalog doesn't exist", () => {
-  const skills = getCatalogSkills();
-  expect(skills).toEqual([]);
+// ── 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 });
+
+    // Simulate migration
+    for (const name of readdirSync(oldLib)) {
+      cpSync(join(oldLib, name), join(catalog, name), { recursive: true });
+    }
+
+    expect(getCatalogSkills()).toEqual(["skill-one", "skill-two"]);
+  });
 });