@dealdeploy/skl 0.2.0 → 0.3.0

package/index.ts

@@ -23,6 +23,7 @@ import {
 } from "fs";
 import { join, resolve } from "path";
 import { homedir } from "os";
+import { findOrphanSkills, adoptSkills } from "./lib.ts";
 
 // @ts-ignore - bun supports JSON imports
 const { version: VERSION } = await import("./package.json");
@@ -292,6 +293,39 @@ function ensureLocalClaudeDir(): string {
   }
 }
 
+// ── Adopt local-only skills into library ────────────────────────────
+{
+  const localDirsToScan: string[] = [];
+  const ld = findLocalDir();
+  if (ld) localDirsToScan.push(ld);
+  const lcd = findLocalClaudeDir();
+  if (lcd) localDirsToScan.push(lcd);
+
+  const orphans = findOrphanSkills(localDirsToScan, LIBRARY);
+
+  if (orphans.length > 0) {
+    console.log("\nFound skills in this repo not in your library:");
+    for (const o of orphans) {
+      console.log(`  ${o.dir.replace(homedir(), "~")}/${o.name}`);
+    }
+    process.stdout.write(`\nCopy to ${LIBRARY.replace(homedir(), "~")}? [y/N] `);
+
+    const buf = new Uint8Array(100);
+    const n = readSync(0, buf);
+    const answer = new TextDecoder().decode(buf.subarray(0, n)).trim().toLowerCase();
+
+    if (answer === "y" || answer === "yes") {
+      const results = adoptSkills(orphans, LIBRARY);
+      for (const r of results) {
+        console.log(`  copied ${r.name}`);
+      }
+      console.log(`\n${results.filter(r => r.copied).length} added to library\n`);
+    } else {
+      console.log("Skipping.\n");
+    }
+  }
+}
+
 const allSkills = readdirSync(LIBRARY).sort();
 
 // ── State ───────────────────────────────────────────────────────────

package/lib.test.ts

@@ -0,0 +1,70 @@
+import { test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, rmSync, existsSync, writeFileSync, symlinkSync } from "fs";
+import { join } from "path";
+import { mkdtempSync } from "fs";
+import { tmpdir } from "os";
+
+import { findOrphanSkills, adoptSkills } from "./lib.ts";
+
+let tmp: string;
+let library: string;
+let localDir: string;
+
+beforeEach(() => {
+  tmp = mkdtempSync(join(tmpdir(), "skl-test-"));
+  library = join(tmp, "library");
+  localDir = join(tmp, "local");
+  mkdirSync(library);
+  mkdirSync(localDir);
+});
+
+afterEach(() => {
+  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);
+
+  expect(orphans).toEqual([{ dir: localDir, name: "my-skill" }]);
+});
+
+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"));
+
+  const orphans = findOrphanSkills([localDir, localDir2], library);
+
+  expect(orphans).toHaveLength(1);
+  expect(orphans[0]!.name).toBe("shared-skill");
+});
+
+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);
+
+  expect(results).toEqual([{ name: "cool-skill", copied: true }]);
+  expect(existsSync(join(library, "cool-skill", "prompt.md"))).toBe(true);
+});
+
+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"));
+
+  const orphans = findOrphanSkills([localDir], library);
+
+  expect(orphans).toEqual([{ dir: localDir, name: "real-skill" }]);
+});

package/lib.ts

@@ -0,0 +1,50 @@
+import { readdirSync, lstatSync, existsSync, cpSync } from "fs";
+import { join } from "path";
+
+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;
+        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 orphans;
+}
+
+export function adoptSkills(
+  orphans: { dir: string; name: string }[],
+  library: string,
+): { name: string; copied: boolean }[] {
+  const results: { name: string; copied: boolean }[] = [];
+
+  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 });
+    }
+  }
+
+  return results;
+}

package/package.json

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

package/update.ts

@@ -3,6 +3,7 @@
 import { readdirSync, existsSync, cpSync, rmSync, lstatSync, readlinkSync, readSync, unlinkSync } from "fs";
 import { join, resolve } from "path";
 import { homedir } from "os";
+import { findOrphanSkills, adoptSkills } from "./lib.ts";
 
 const LIBRARY = join(homedir(), "dotfiles/skills");
 
@@ -27,16 +28,11 @@ type Entry = { dir: string; label: string; name: string; kind: "symlink" | "copy
 
 const symlinks: Entry[] = [];
 const copies: Entry[] = [];
-let skipped = 0;
-
 for (const [dir, label] of localDirs) {
   for (const name of readdirSync(dir)) {
     const localPath = join(dir, name);
     const libPath = join(LIBRARY, name);
-    if (!existsSync(libPath)) {
-      skipped++;
-      continue;
-    }
+    if (!existsSync(libPath)) continue;
     const isSym = lstatSync(localPath).isSymbolicLink();
     const entry: Entry = { dir, label, name, kind: isSym ? "symlink" : "copy" };
     if (isSym) symlinks.push(entry);
@@ -44,6 +40,8 @@ for (const [dir, label] of localDirs) {
   }
 }
 
+const notInLibrary = findOrphanSkills(localDirs.map(([dir]) => dir), LIBRARY);
+
 // Handle symlinks → copies (requires confirmation)
 if (symlinks.length > 0) {
   console.log("\nSymlinks to convert to local copies:");
@@ -79,9 +77,29 @@ if (copies.length > 0) {
   }
 }
 
-if (symlinks.length === 0 && copies.length === 0) {
+if (symlinks.length === 0 && copies.length === 0 && notInLibrary.length === 0) {
   console.log("Nothing to update.");
 }
-if (skipped > 0) {
-  console.log(`${skipped} skipped (not in library)`);
+
+// Offer to copy local-only skills into library
+if (notInLibrary.length > 0) {
+  console.log("\nFound skills in this repo not in your library:");
+  for (const o of notInLibrary) {
+    console.log(`  ${o.dir.replace(homedir(), "~")}/${o.name}`);
+  }
+  process.stdout.write(`\nCopy to ${LIBRARY.replace(homedir(), "~")}? [y/N] `);
+
+  const buf = new Uint8Array(100);
+  const n = readSync(0, buf);
+  const answer = new TextDecoder().decode(buf.subarray(0, n)).trim().toLowerCase();
+
+  if (answer === "y" || answer === "yes") {
+    const results = adoptSkills(notInLibrary, LIBRARY);
+    for (const r of results) {
+      console.log(`  copied ${r.name}`);
+    }
+    console.log(`\n${results.filter(r => r.copied).length} added to library`);
+  } else {
+    console.log("Skipping.");
+  }
 }