@hasna/skills 0.1.14 → 0.1.16

package/dist/index.js

@@ -1,5 +1,8 @@
 // @bun
 // src/lib/registry.ts
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
 var CATEGORIES = [
   "Development Tools",
   "Business & Marketing",
@@ -1036,6 +1039,20 @@ var SKILLS = [
     category: "Design & Branding",
     tags: ["testimonials", "graphics", "social-proof", "marketing"]
   },
+  {
+    name: "colorextract",
+    displayName: "Color Extract",
+    description: "Extract complete color palettes from screenshots and images using Claude Vision. Outputs open-styles compatible profiles.",
+    category: "Design & Branding",
+    tags: ["colors", "palette", "design", "vision", "screenshot", "extract", "open-styles"]
+  },
+  {
+    name: "siteanalyze",
+    displayName: "Site Analyze",
+    description: "Analyze any website's design system \u2014 detects shadcn/ui, Tailwind, extracts colors, typography, and components via Playwright + Claude Vision.",
+    category: "Design & Branding",
+    tags: ["design", "shadcn", "tailwind", "colors", "typography", "playwright", "analysis", "open-styles"]
+  },
   {
     name: "browse",
     displayName: "Browse",
@@ -1436,8 +1453,94 @@ var SKILLS = [
     tags: ["seating", "chart", "events", "venues"]
   }
 ];
+function parseSkillMdFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match)
+    return null;
+  const result = {};
+  for (const line of match[1].split(`
+`)) {
+    const colon = line.indexOf(":");
+    if (colon === -1)
+      continue;
+    const key = line.slice(0, colon).trim();
+    const value = line.slice(colon + 1).trim();
+    if (!key || !value)
+      continue;
+    if (key === "name")
+      result.name = value;
+    else if (key === "description")
+      result.description = value;
+    else if (key === "displayName" || key === "display_name")
+      result.displayName = value;
+    else if (key === "category")
+      result.category = value;
+    else if (key === "tags") {
+      result.tags = value.replace(/[\[\]]/g, "").split(",").map((t) => t.trim()).filter(Boolean);
+    }
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+function discoverSkillsInDir(dir) {
+  if (!existsSync(dir))
+    return [];
+  const result = [];
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const skillMdPath = join(dir, entry.name, "SKILL.md");
+      if (!existsSync(skillMdPath))
+        continue;
+      let content;
+      try {
+        content = readFileSync(skillMdPath, "utf-8");
+      } catch {
+        continue;
+      }
+      const fm = parseSkillMdFrontmatter(content);
+      if (!fm?.name)
+        continue;
+      const name = fm.name.replace(/^skill-/, "");
+      result.push({
+        name,
+        displayName: fm.displayName || name.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+        description: fm.description || "",
+        category: fm.category || "Development Tools",
+        tags: fm.tags || [],
+        source: "custom"
+      });
+    }
+  } catch {}
+  return result;
+}
+var _registryCache = null;
+var _registryCacheTime = 0;
+var REGISTRY_CACHE_TTL = 5000;
+function loadRegistry(cwd) {
+  const now = Date.now();
+  if (_registryCache && now - _registryCacheTime < REGISTRY_CACHE_TTL) {
+    return _registryCache;
+  }
+  const official = SKILLS.map((s) => ({ ...s, source: "official" }));
+  const globalCustomNew = discoverSkillsInDir(join(homedir(), ".hasna", "skills", "custom"));
+  const globalCustomOld = discoverSkillsInDir(join(homedir(), ".skills"));
+  const oldNames = new Set(globalCustomNew.map((s) => s.name));
+  const globalCustom = [...globalCustomNew, ...globalCustomOld.filter((s) => !oldNames.has(s.name))];
+  const projectCustom = discoverSkillsInDir(join(cwd || process.cwd(), ".skills", "custom-skills"));
+  const customNames = new Set([...globalCustom, ...projectCustom].map((s) => s.name));
+  const filtered = official.filter((s) => !customNames.has(s.name));
+  _registryCache = [...filtered, ...globalCustom, ...projectCustom];
+  _registryCacheTime = now;
+  return _registryCache;
+}
+function clearRegistryCache() {
+  _registryCache = null;
+  _registryCacheTime = 0;
+}
 function getSkillsByCategory(category) {
-  return SKILLS.filter((s) => s.category === category);
+  return loadRegistry().filter((s) => s.category === category);
 }
 function editDistance(a, b) {
   if (a === b)
@@ -1483,7 +1586,7 @@ function searchSkills(query) {
   if (words.length === 0)
     return [];
   const scored = [];
-  for (const skill of SKILLS) {
+  for (const skill of loadRegistry()) {
     const nameLower = skill.name.toLowerCase();
     const displayNameLower = skill.displayName.toLowerCase();
     const descriptionLower = skill.description.toLowerCase();
@@ -1519,15 +1622,15 @@ function searchSkills(query) {
   return scored.map((s) => s.skill);
 }
 function getSkill(name) {
-  return SKILLS.find((s) => s.name === name);
+  return loadRegistry().find((s) => s.name === name);
 }
 function getSkillsByTag(tag) {
   const needle = tag.toLowerCase();
-  return SKILLS.filter((s) => s.tags.some((t) => t.toLowerCase().includes(needle)));
+  return loadRegistry().filter((s) => s.tags.some((t) => t.toLowerCase().includes(needle)));
 }
 function getAllTags() {
   const tagSet = new Set;
-  for (const skill of SKILLS) {
+  for (const skill of loadRegistry()) {
     for (const tag of skill.tags) {
       tagSet.add(tag.toLowerCase());
     }
@@ -1546,13 +1649,13 @@ function levenshtein(a, b) {
 }
 function findSimilarSkills(query, maxResults = 3) {
   const q = query.toLowerCase();
-  const scored = SKILLS.map((s) => ({ name: s.name, dist: levenshtein(q, s.name.toLowerCase()) })).filter((s) => s.dist <= Math.max(3, Math.floor(q.length / 2))).sort((a, b) => a.dist - b.dist);
+  const scored = loadRegistry().map((s) => ({ name: s.name, dist: levenshtein(q, s.name.toLowerCase()) })).filter((s) => s.dist <= Math.max(3, Math.floor(q.length / 2))).sort((a, b) => a.dist - b.dist);
   return scored.slice(0, maxResults).map((s) => s.name);
 }
 // src/lib/installer.ts
-import { existsSync, cpSync, mkdirSync, writeFileSync, rmSync, readdirSync, statSync, readFileSync, accessSync, constants } from "fs";
-import { join, dirname } from "path";
-import { homedir } from "os";
+import { existsSync as existsSync2, cpSync, mkdirSync, writeFileSync, rmSync, readdirSync as readdirSync2, statSync, readFileSync as readFileSync2, accessSync, constants } from "fs";
+import { join as join2, dirname } from "path";
+import { homedir as homedir2 } from "os";
 import { fileURLToPath } from "url";
 
 // src/lib/utils.ts
@@ -1565,36 +1668,36 @@ var __dirname2 = dirname(fileURLToPath(import.meta.url));
 function findSkillsDir() {
   let dir = __dirname2;
   for (let i = 0;i < 5; i++) {
-    const candidate = join(dir, "skills");
-    if (existsSync(candidate)) {
+    const candidate = join2(dir, "skills");
+    if (existsSync2(candidate) && !dir.includes(".skills")) {
       return candidate;
     }
     dir = dirname(dir);
   }
-  return join(__dirname2, "..", "skills");
+  return join2(__dirname2, "..", "skills");
 }
 var SKILLS_DIR = findSkillsDir();
 function getSkillPath(name) {
   const skillName = normalizeSkillName(name);
-  return join(SKILLS_DIR, skillName);
+  return join2(SKILLS_DIR, skillName);
 }
 function skillExists(name) {
-  return existsSync(getSkillPath(name));
+  return existsSync2(getSkillPath(name));
 }
 function installSkill(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
   const skillName = normalizeSkillName(name);
   const sourcePath = getSkillPath(name);
-  const destDir = join(targetDir, ".skills");
-  const destPath = join(destDir, skillName);
-  if (!existsSync(sourcePath)) {
+  const destDir = join2(targetDir, ".skills");
+  const destPath = join2(destDir, skillName);
+  if (!existsSync2(sourcePath)) {
     return {
       skill: name,
       success: false,
       error: `Skill '${name}' not found`
     };
   }
-  if (existsSync(destPath) && !overwrite) {
+  if (existsSync2(destPath) && !overwrite) {
     return {
       skill: name,
       success: false,
@@ -1603,10 +1706,10 @@ function installSkill(name, options = {}) {
     };
   }
   try {
-    if (!existsSync(destDir)) {
+    if (!existsSync2(destDir)) {
       mkdirSync(destDir, { recursive: true });
     }
-    if (existsSync(destPath) && overwrite) {
+    if (existsSync2(destPath) && overwrite) {
       rmSync(destPath, { recursive: true, force: true });
     }
     cpSync(sourcePath, destPath, {
@@ -1645,10 +1748,10 @@ function installSkills(names, options = {}) {
   return names.map((name) => installSkill(name, options));
 }
 function updateSkillsIndex(skillsDir) {
-  const indexPath = join(skillsDir, "index.ts");
+  const indexPath = join2(skillsDir, "index.ts");
   const meta = loadMeta(skillsDir);
   const disabledSet = new Set(meta.disabled || []);
-  const skills = readdirSync(skillsDir).filter((f) => f.startsWith("skill-") && !f.includes(".") && !disabledSet.has(f.replace("skill-", "")));
+  const skills = readdirSync2(skillsDir).filter((f) => f.startsWith("skill-") && !f.includes(".") && !disabledSet.has(f.replace("skill-", "")));
   const exports = skills.map((s) => {
     const name = s.replace("skill-", "").replace(/-/g, "_");
     return `export * as ${name} from './${s}/src/index.js';`;
@@ -1664,13 +1767,13 @@ ${exports}
   writeFileSync(indexPath, content);
 }
 function getMetaPath(skillsDir) {
-  return join(skillsDir, ".meta.json");
+  return join2(skillsDir, ".meta.json");
 }
 function loadMeta(skillsDir) {
   const metaPath = getMetaPath(skillsDir);
-  if (existsSync(metaPath)) {
+  if (existsSync2(metaPath)) {
     try {
-      return JSON.parse(readFileSync(metaPath, "utf-8"));
+      return JSON.parse(readFileSync2(metaPath, "utf-8"));
     } catch {}
   }
   return { skills: {} };
@@ -1683,9 +1786,9 @@ function recordInstall(skillsDir, name) {
   const skillName = normalizeSkillName(name);
   let version = "unknown";
   try {
-    const pkgPath = join(skillsDir, skillName, "package.json");
-    if (existsSync(pkgPath)) {
-      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const pkgPath = join2(skillsDir, skillName, "package.json");
+    if (existsSync2(pkgPath)) {
+      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
       version = pkg.version || "unknown";
     }
   } catch {}
@@ -1698,12 +1801,12 @@ function recordRemove(skillsDir, name) {
   saveMeta(skillsDir, meta);
 }
 function getInstallMeta(targetDir = process.cwd()) {
-  return loadMeta(join(targetDir, ".skills"));
+  return loadMeta(join2(targetDir, ".skills"));
 }
 function disableSkill(name, targetDir = process.cwd()) {
-  const skillsDir = join(targetDir, ".skills");
+  const skillsDir = join2(targetDir, ".skills");
   const skillName = normalizeSkillName(name);
-  if (!existsSync(join(skillsDir, skillName)))
+  if (!existsSync2(join2(skillsDir, skillName)))
     return false;
   const meta = loadMeta(skillsDir);
   const disabled = new Set(meta.disabled || []);
@@ -1716,7 +1819,7 @@ function disableSkill(name, targetDir = process.cwd()) {
   return true;
 }
 function enableSkill(name, targetDir = process.cwd()) {
-  const skillsDir = join(targetDir, ".skills");
+  const skillsDir = join2(targetDir, ".skills");
   const meta = loadMeta(skillsDir);
   const disabled = new Set(meta.disabled || []);
   if (!disabled.has(name))
@@ -1728,24 +1831,24 @@ function enableSkill(name, targetDir = process.cwd()) {
   return true;
 }
 function getDisabledSkills(targetDir = process.cwd()) {
-  const meta = loadMeta(join(targetDir, ".skills"));
+  const meta = loadMeta(join2(targetDir, ".skills"));
   return meta.disabled || [];
 }
 function getInstalledSkills(targetDir = process.cwd()) {
-  const skillsDir = join(targetDir, ".skills");
-  if (!existsSync(skillsDir)) {
+  const skillsDir = join2(targetDir, ".skills");
+  if (!existsSync2(skillsDir)) {
     return [];
   }
-  return readdirSync(skillsDir).filter((f) => {
-    const fullPath = join(skillsDir, f);
+  return readdirSync2(skillsDir).filter((f) => {
+    const fullPath = join2(skillsDir, f);
     return f.startsWith("skill-") && statSync(fullPath).isDirectory();
   }).map((f) => f.replace("skill-", ""));
 }
 function removeSkill(name, targetDir = process.cwd()) {
   const skillName = normalizeSkillName(name);
-  const skillsDir = join(targetDir, ".skills");
-  const skillPath = join(skillsDir, skillName);
-  if (!existsSync(skillPath)) {
+  const skillsDir = join2(targetDir, ".skills");
+  const skillPath = join2(skillsDir, skillName);
+  if (!existsSync2(skillPath)) {
     return false;
   }
   rmSync(skillPath, { recursive: true, force: true });
@@ -1753,29 +1856,40 @@ function removeSkill(name, targetDir = process.cwd()) {
   recordRemove(skillsDir, name);
   return true;
 }
-var AGENT_TARGETS = ["claude", "codex", "gemini"];
+var AGENT_TARGETS = ["claude", "codex", "gemini", "pi", "opencode"];
+var AGENT_LABELS = {
+  claude: "Claude Code",
+  codex: "Codex CLI",
+  gemini: "Gemini CLI",
+  pi: "pi.dev",
+  opencode: "OpenCode"
+};
 function getAgentSkillsDir(agent, scope = "global", projectDir) {
-  const agentDir = `.${agent}`;
-  if (scope === "project") {
-    return join(projectDir || process.cwd(), agentDir, "skills");
+  const base = projectDir || process.cwd();
+  switch (agent) {
+    case "pi":
+      return scope === "project" ? join2(base, ".pi", "skills") : join2(homedir2(), ".pi", "agent", "skills");
+    case "opencode":
+      return scope === "project" ? join2(base, ".opencode", "skills") : join2(homedir2(), ".opencode", "skills");
+    default:
+      return scope === "project" ? join2(base, `.${agent}`, "skills") : join2(homedir2(), `.${agent}`, "skills");
   }
-  return join(homedir(), agentDir, "skills");
 }
 function getAgentSkillPath(name, agent, scope = "global", projectDir) {
   const skillName = normalizeSkillName(name);
-  return join(getAgentSkillsDir(agent, scope, projectDir), skillName);
+  return join2(getAgentSkillsDir(agent, scope, projectDir), skillName);
 }
 function installSkillForAgent(name, options, generateSkillMd) {
   const { agent, scope = "global", projectDir } = options;
   const skillName = normalizeSkillName(name);
   const sourcePath = getSkillPath(name);
-  if (!existsSync(sourcePath)) {
+  if (!existsSync2(sourcePath)) {
     return { skill: name, success: false, error: `Skill '${name}' not found` };
   }
   let skillMdContent = null;
-  const skillMdPath = join(sourcePath, "SKILL.md");
-  if (existsSync(skillMdPath)) {
-    skillMdContent = readFileSync(skillMdPath, "utf-8");
+  const skillMdPath = join2(sourcePath, "SKILL.md");
+  if (existsSync2(skillMdPath)) {
+    skillMdContent = readFileSync2(skillMdPath, "utf-8");
   } else if (generateSkillMd) {
     skillMdContent = generateSkillMd(name);
   }
@@ -1784,17 +1898,12 @@ function installSkillForAgent(name, options, generateSkillMd) {
   }
   const destDir = getAgentSkillPath(name, agent, scope, projectDir);
   if (scope === "global") {
-    const agentBaseDir = join(homedir(), `.${agent}`);
-    if (!existsSync(agentBaseDir)) {
-      const agentLabels = {
-        claude: "Claude Code",
-        codex: "Codex CLI",
-        gemini: "Gemini CLI"
-      };
+    const agentBaseDir = agent === "pi" ? join2(homedir2(), ".pi", "agent") : join2(homedir2(), `.${agent}`);
+    if (!existsSync2(agentBaseDir)) {
       return {
         skill: name,
         success: false,
-        error: `Agent directory ${agentBaseDir} does not exist. Is ${agentLabels[agent]} installed?`
+        error: `Agent directory ${agentBaseDir} does not exist. Is ${AGENT_LABELS[agent]} installed?`
       };
     }
     try {
@@ -1809,7 +1918,7 @@ function installSkillForAgent(name, options, generateSkillMd) {
   }
   try {
     mkdirSync(destDir, { recursive: true });
-    writeFileSync(join(destDir, "SKILL.md"), skillMdContent);
+    writeFileSync(join2(destDir, "SKILL.md"), skillMdContent);
     return { skill: name, success: true, path: destDir };
   } catch (error) {
     return {
@@ -1822,23 +1931,23 @@ function installSkillForAgent(name, options, generateSkillMd) {
 function removeSkillForAgent(name, options) {
   const { agent, scope = "global", projectDir } = options;
   const destDir = getAgentSkillPath(name, agent, scope, projectDir);
-  if (!existsSync(destDir)) {
+  if (!existsSync2(destDir)) {
     return false;
   }
   rmSync(destDir, { recursive: true, force: true });
   return true;
 }
 // src/lib/skillinfo.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync3 } from "fs";
+import { join as join3 } from "path";
 function getSkillDocs(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync2(skillPath))
+  if (!existsSync3(skillPath))
     return null;
   return {
-    skillMd: readIfExists(join2(skillPath, "SKILL.md")),
-    readme: readIfExists(join2(skillPath, "README.md")),
-    claudeMd: readIfExists(join2(skillPath, "CLAUDE.md"))
+    skillMd: readIfExists(join3(skillPath, "SKILL.md")),
+    readme: readIfExists(join3(skillPath, "README.md")),
+    claudeMd: readIfExists(join3(skillPath, "CLAUDE.md"))
   };
 }
 function getSkillBestDoc(name) {
@@ -1849,11 +1958,11 @@ function getSkillBestDoc(name) {
 }
 function getSkillRequirements(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync2(skillPath))
+  if (!existsSync3(skillPath))
     return null;
   const texts = [];
   for (const file of ["SKILL.md", "README.md", "CLAUDE.md", ".env.example", ".env.local.example"]) {
-    const content = readIfExists(join2(skillPath, file));
+    const content = readIfExists(join3(skillPath, file));
     if (content)
       texts.push(content);
   }
@@ -1880,10 +1989,10 @@ function getSkillRequirements(name) {
   }
   let cliCommand = null;
   let dependencies = {};
-  const pkgPath = join2(skillPath, "package.json");
-  if (existsSync2(pkgPath)) {
+  const pkgPath = join3(skillPath, "package.json");
+  if (existsSync3(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
       if (pkg.bin) {
         const binKeys = Object.keys(pkg.bin);
         if (binKeys.length > 0)
@@ -1903,25 +2012,25 @@ async function runSkill(name, args, options = {}) {
   const skillName = normalizeSkillName(name);
   let skillPath;
   if (options.installed) {
-    skillPath = join2(process.cwd(), ".skills", skillName);
+    skillPath = join3(process.cwd(), ".skills", skillName);
   } else {
-    const installedPath = join2(process.cwd(), ".skills", skillName);
-    if (existsSync2(installedPath)) {
+    const installedPath = join3(process.cwd(), ".skills", skillName);
+    if (existsSync3(installedPath)) {
       skillPath = installedPath;
     } else {
       skillPath = getSkillPath(name);
     }
   }
-  if (!existsSync2(skillPath)) {
+  if (!existsSync3(skillPath)) {
     return { exitCode: 1, error: `Skill '${name}' not found` };
   }
-  const pkgPath = join2(skillPath, "package.json");
-  if (!existsSync2(pkgPath)) {
+  const pkgPath = join3(skillPath, "package.json");
+  if (!existsSync3(pkgPath)) {
     return { exitCode: 1, error: `No package.json in skill '${name}'` };
   }
   let entryPoint;
   try {
-    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
     if (pkg.bin) {
       const binValues = Object.values(pkg.bin);
       entryPoint = binValues[0];
@@ -1935,12 +2044,12 @@ async function runSkill(name, args, options = {}) {
   } catch {
     return { exitCode: 1, error: `Failed to parse package.json for skill '${name}'` };
   }
-  const entryPath = join2(skillPath, entryPoint);
-  if (!existsSync2(entryPath)) {
+  const entryPath = join3(skillPath, entryPoint);
+  if (!existsSync3(entryPath)) {
     return { exitCode: 1, error: `Entry point '${entryPoint}' not found in skill '${name}'` };
   }
-  const nodeModules = join2(skillPath, "node_modules");
-  if (!existsSync2(nodeModules)) {
+  const nodeModules = join3(skillPath, "node_modules");
+  if (!existsSync3(nodeModules)) {
     const install = Bun.spawn(["bun", "install", "--no-save"], {
       cwd: skillPath,
       stdout: "pipe",
@@ -1958,17 +2067,17 @@ async function runSkill(name, args, options = {}) {
   return { exitCode };
 }
 function generateEnvExample(targetDir = process.cwd()) {
-  const skillsDir = join2(targetDir, ".skills");
-  if (!existsSync2(skillsDir))
+  const skillsDir = join3(targetDir, ".skills");
+  if (!existsSync3(skillsDir))
     return "";
-  const dirs = readdirSync2(skillsDir).filter((f) => f.startsWith("skill-") && existsSync2(join2(skillsDir, f, "package.json")));
+  const dirs = readdirSync3(skillsDir).filter((f) => f.startsWith("skill-") && existsSync3(join3(skillsDir, f, "package.json")));
   const envMap = new Map;
   for (const dir of dirs) {
     const skillName = dir.replace("skill-", "");
-    const skillPath = join2(skillsDir, dir);
+    const skillPath = join3(skillsDir, dir);
     const texts = [];
     for (const file of ["SKILL.md", "README.md", "CLAUDE.md", ".env.example"]) {
-      const content = readIfExists(join2(skillPath, file));
+      const content = readIfExists(join3(skillPath, file));
       if (content)
         texts.push(content);
     }
@@ -2013,7 +2122,7 @@ function generateSkillMd(name) {
   if (!meta)
     return null;
   const skillPath = getSkillPath(name);
-  if (!existsSync2(skillPath))
+  if (!existsSync3(skillPath))
     return null;
   const frontmatter = [
     "---",
@@ -2022,13 +2131,13 @@ function generateSkillMd(name) {
     "---"
   ].join(`
 `);
-  const readme = readIfExists(join2(skillPath, "README.md"));
-  const claudeMd = readIfExists(join2(skillPath, "CLAUDE.md"));
+  const readme = readIfExists(join3(skillPath, "README.md"));
+  const claudeMd = readIfExists(join3(skillPath, "CLAUDE.md"));
   let cliCommand = null;
-  const pkgPath = join2(skillPath, "package.json");
-  if (existsSync2(pkgPath)) {
+  const pkgPath = join3(skillPath, "package.json");
+  if (existsSync3(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
       if (pkg.bin) {
         const binKeys = Object.keys(pkg.bin);
         if (binKeys.length > 0)
@@ -2103,32 +2212,45 @@ function extractEnvVars(text) {
 }
 function readIfExists(path) {
   try {
-    if (existsSync2(path)) {
-      return readFileSync2(path, "utf-8");
+    if (existsSync3(path)) {
+      return readFileSync3(path, "utf-8");
     }
   } catch {}
   return null;
 }
 // src/lib/config.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join3, dirname as dirname2 } from "path";
-import { homedir as homedir2 } from "os";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, copyFileSync } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
+import { homedir as homedir3 } from "os";
 var VALID_KEYS = {
   defaultAgent: ["claude", "codex", "gemini", "all"],
   defaultScope: ["global", "project"],
   format: ["compact", "json", "csv"]
 };
+function getDataDir() {
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir3();
+  const newDir = join4(home, ".hasna", "skills");
+  const oldConfigFile = join4(home, ".skillsrc");
+  if (existsSync4(oldConfigFile) && !existsSync4(join4(newDir, "config.json"))) {
+    mkdirSync2(newDir, { recursive: true });
+    try {
+      copyFileSync(oldConfigFile, join4(newDir, "config.json"));
+    } catch {}
+  }
+  mkdirSync2(newDir, { recursive: true });
+  return newDir;
+}
 function getConfigPath(scope) {
   if (scope === "global") {
-    return join3(homedir2(), ".skillsrc");
+    return join4(getDataDir(), "config.json");
   }
-  return join3(process.cwd(), "skills.config.json");
+  return join4(process.cwd(), "skills.config.json");
 }
 function readConfigFile(path) {
-  if (!existsSync3(path))
+  if (!existsSync4(path))
     return {};
   try {
-    const raw = readFileSync3(path, "utf-8");
+    const raw = readFileSync4(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
       return {};
@@ -2159,9 +2281,9 @@ function saveConfig(key, value, scope = "project") {
   }
   const filePath = getConfigPath(scope);
   let existing = {};
-  if (existsSync3(filePath)) {
+  if (existsSync4(filePath)) {
     try {
-      existing = JSON.parse(readFileSync3(filePath, "utf-8"));
+      existing = JSON.parse(readFileSync4(filePath, "utf-8"));
       if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
         existing = {};
       }
@@ -2170,7 +2292,7 @@ function saveConfig(key, value, scope = "project") {
     }
   } else {
     const dir = dirname2(filePath);
-    if (!existsSync3(dir)) {
+    if (!existsSync4(dir)) {
       mkdirSync2(dir, { recursive: true });
     }
   }
@@ -2178,14 +2300,174 @@ function saveConfig(key, value, scope = "project") {
   writeFileSync2(filePath, JSON.stringify(existing, null, 2) + `
 `);
 }
+// src/lib/scheduler.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { join as join5 } from "path";
+function getSchedulesPath(targetDir = process.cwd()) {
+  return join5(targetDir, ".skills", "schedules.json");
+}
+function loadSchedules(targetDir = process.cwd()) {
+  const path = getSchedulesPath(targetDir);
+  if (existsSync5(path)) {
+    try {
+      return JSON.parse(readFileSync5(path, "utf-8"));
+    } catch {}
+  }
+  return { version: 1, schedules: [] };
+}
+function saveSchedules(data, targetDir = process.cwd()) {
+  const path = getSchedulesPath(targetDir);
+  const dir = join5(targetDir, ".skills");
+  if (!existsSync5(dir))
+    mkdirSync3(dir, { recursive: true });
+  writeFileSync3(path, JSON.stringify(data, null, 2));
+}
+function validateCron(expr) {
+  const fields = expr.trim().split(/\s+/);
+  if (fields.length !== 5) {
+    return { valid: false, error: `Expected 5 fields, got ${fields.length}. Format: "minute hour day-of-month month day-of-week"` };
+  }
+  return { valid: true };
+}
+function getNextRun(cron, from = new Date) {
+  const { valid } = validateCron(cron);
+  if (!valid)
+    return null;
+  const [minuteF, hourF, domF, monthF, dowF] = cron.trim().split(/\s+/);
+  function parseField(f, min, max) {
+    if (f === "*")
+      return Array.from({ length: max - min + 1 }, (_, i) => i + min);
+    if (f.startsWith("*/")) {
+      const step = parseInt(f.slice(2));
+      if (isNaN(step))
+        return [];
+      const vals = [];
+      for (let i = min;i <= max; i += step)
+        vals.push(i);
+      return vals;
+    }
+    return f.split(",").flatMap((part) => {
+      if (part.includes("-")) {
+        const [lo, hi] = part.split("-").map(Number);
+        return Array.from({ length: hi - lo + 1 }, (_, i) => i + lo);
+      }
+      const n = parseInt(part);
+      return isNaN(n) ? [] : [n];
+    });
+  }
+  const minutes = parseField(minuteF, 0, 59);
+  const hours = parseField(hourF, 0, 23);
+  const doms = parseField(domF, 1, 31);
+  const months = parseField(monthF, 1, 12);
+  const dows = parseField(dowF, 0, 6);
+  const candidate = new Date(from);
+  candidate.setSeconds(0, 0);
+  candidate.setMinutes(candidate.getMinutes() + 1);
+  const limit = new Date(from);
+  limit.setFullYear(limit.getFullYear() + 1);
+  while (candidate < limit) {
+    const month = candidate.getMonth() + 1;
+    const dom = candidate.getDate();
+    const dow = candidate.getDay();
+    const hour = candidate.getHours();
+    const minute = candidate.getMinutes();
+    if (!months.includes(month)) {
+      candidate.setMonth(candidate.getMonth() + 1, 1);
+      candidate.setHours(0, 0, 0, 0);
+      continue;
+    }
+    if (!doms.includes(dom) || !dows.includes(dow)) {
+      candidate.setDate(candidate.getDate() + 1);
+      candidate.setHours(0, 0, 0, 0);
+      continue;
+    }
+    if (!hours.includes(hour)) {
+      candidate.setHours(candidate.getHours() + 1, 0, 0, 0);
+      continue;
+    }
+    if (!minutes.includes(minute)) {
+      candidate.setMinutes(candidate.getMinutes() + 1, 0, 0);
+      continue;
+    }
+    return new Date(candidate);
+  }
+  return null;
+}
+function addSchedule(skill, cron, options = {}) {
+  const { valid, error } = validateCron(cron);
+  if (!valid)
+    return { schedule: null, error };
+  const data = loadSchedules(options.targetDir);
+  const id = `${skill}-${Date.now()}`;
+  const now = new Date;
+  const nextRun = getNextRun(cron, now);
+  const schedule = {
+    id,
+    name: options.name || `${skill} (${cron})`,
+    skill,
+    cron,
+    args: options.args,
+    enabled: true,
+    createdAt: now.toISOString(),
+    nextRun: nextRun?.toISOString()
+  };
+  data.schedules.push(schedule);
+  saveSchedules(data, options.targetDir);
+  return { schedule };
+}
+function listSchedules(targetDir) {
+  return loadSchedules(targetDir).schedules;
+}
+function removeSchedule(idOrName, targetDir) {
+  const data = loadSchedules(targetDir);
+  const before = data.schedules.length;
+  data.schedules = data.schedules.filter((s) => s.id !== idOrName && s.name !== idOrName);
+  if (data.schedules.length === before)
+    return false;
+  saveSchedules(data, targetDir);
+  return true;
+}
+function setScheduleEnabled(idOrName, enabled, targetDir) {
+  const data = loadSchedules(targetDir);
+  const schedule = data.schedules.find((s) => s.id === idOrName || s.name === idOrName);
+  if (!schedule)
+    return false;
+  schedule.enabled = enabled;
+  if (enabled) {
+    schedule.nextRun = getNextRun(schedule.cron)?.toISOString();
+  }
+  saveSchedules(data, targetDir);
+  return true;
+}
+function getDueSchedules(targetDir) {
+  const now = new Date;
+  return listSchedules(targetDir).filter((s) => s.enabled && s.nextRun && new Date(s.nextRun) <= now);
+}
+function recordScheduleRun(id, status, targetDir) {
+  const data = loadSchedules(targetDir);
+  const schedule = data.schedules.find((s) => s.id === id);
+  if (!schedule)
+    return;
+  const now = new Date;
+  schedule.lastRun = now.toISOString();
+  schedule.lastRunStatus = status;
+  schedule.nextRun = getNextRun(schedule.cron, now)?.toISOString();
+  saveSchedules(data, targetDir);
+}
 export {
+  validateCron,
   skillExists,
+  setScheduleEnabled,
   searchSkills,
   saveConfig,
   runSkill,
   removeSkillForAgent,
   removeSkill,
+  removeSchedule,
+  recordScheduleRun,
+  loadRegistry,
   loadConfig,
+  listSchedules,
   installSkills,
   installSkillForAgent,
   installSkill,
@@ -2196,8 +2478,10 @@ export {
   getSkillDocs,
   getSkillBestDoc,
   getSkill,
+  getNextRun,
   getInstalledSkills,
   getInstallMeta,
+  getDueSchedules,
   getDisabledSkills,
   getConfigPath,
   getAllTags,
@@ -2208,6 +2492,8 @@ export {
   findSimilarSkills,
   enableSkill,
   disableSkill,
+  clearRegistryCache,
+  addSchedule,
   SKILLS,
   CATEGORIES,
   AGENT_TARGETS