@hasna/skills 0.0.3 → 0.0.4

package/src/lib/installer.test.ts

@@ -1,328 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtempSync, existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import {
-  getSkillPath,
-  skillExists,
-  installSkill,
-  installSkills,
-  getInstalledSkills,
-  removeSkill,
-  getAgentSkillsDir,
-  getAgentSkillPath,
-  installSkillForAgent,
-  removeSkillForAgent,
-  AGENT_TARGETS,
-} from "./installer";
-
-let testDir: string;
-
-beforeEach(() => {
-  testDir = mkdtempSync(join(tmpdir(), "skills-test-"));
-});
-
-afterEach(() => {
-  const { rmSync } = require("fs");
-  rmSync(testDir, { recursive: true, force: true });
-});
-
-describe("installer", () => {
-  describe("getSkillPath", () => {
-    test("returns path for skill name without prefix", () => {
-      const path = getSkillPath("deepresearch");
-      expect(path).toContain("skill-deepresearch");
-    });
-
-    test("returns path for skill name with prefix", () => {
-      const path = getSkillPath("skill-deepresearch");
-      expect(path).toContain("skill-deepresearch");
-      // Should not double-prefix
-      expect(path).not.toContain("skill-skill-");
-    });
-  });
-
-  describe("skillExists", () => {
-    test("returns true for existing skill", () => {
-      expect(skillExists("deepresearch")).toBe(true);
-    });
-
-    test("returns true with skill- prefix", () => {
-      expect(skillExists("skill-deepresearch")).toBe(true);
-    });
-
-    test("returns false for nonexistent skill", () => {
-      expect(skillExists("nonexistent-skill-xyz")).toBe(false);
-    });
-  });
-
-  describe("installSkill", () => {
-    test("installs a skill to target directory", () => {
-      const result = installSkill("deepresearch", { targetDir: testDir });
-      expect(result.success).toBe(true);
-      expect(result.skill).toBe("deepresearch");
-      expect(result.path).toBeDefined();
-      expect(existsSync(join(testDir, ".skills", "skill-deepresearch"))).toBe(true);
-    });
-
-    test("creates .skills directory if it does not exist", () => {
-      expect(existsSync(join(testDir, ".skills"))).toBe(false);
-      installSkill("deepresearch", { targetDir: testDir });
-      expect(existsSync(join(testDir, ".skills"))).toBe(true);
-    });
-
-    test("creates index.ts in .skills directory", () => {
-      installSkill("deepresearch", { targetDir: testDir });
-      const indexPath = join(testDir, ".skills", "index.ts");
-      expect(existsSync(indexPath)).toBe(true);
-      const content = readFileSync(indexPath, "utf-8");
-      expect(content).toContain("deepresearch");
-      expect(content).toContain("skill-deepresearch");
-    });
-
-    test("fails for nonexistent skill", () => {
-      const result = installSkill("nonexistent-xyz", { targetDir: testDir });
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("not found");
-    });
-
-    test("fails if already installed without overwrite", () => {
-      installSkill("deepresearch", { targetDir: testDir });
-      const result = installSkill("deepresearch", { targetDir: testDir });
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("Already installed");
-    });
-
-    test("succeeds with overwrite flag", () => {
-      installSkill("deepresearch", { targetDir: testDir });
-      const result = installSkill("deepresearch", { targetDir: testDir, overwrite: true });
-      expect(result.success).toBe(true);
-    });
-
-    test("does not copy .git directory", () => {
-      installSkill("deepresearch", { targetDir: testDir });
-      const gitDir = join(testDir, ".skills", "skill-deepresearch", ".git");
-      expect(existsSync(gitDir)).toBe(false);
-    });
-
-    test("handles skill- prefix in name", () => {
-      const result = installSkill("skill-deepresearch", { targetDir: testDir });
-      expect(result.success).toBe(true);
-      expect(existsSync(join(testDir, ".skills", "skill-deepresearch"))).toBe(true);
-    });
-  });
-
-  describe("installSkills", () => {
-    test("installs multiple skills", () => {
-      const results = installSkills(["deepresearch", "image"], { targetDir: testDir });
-      expect(results.length).toBe(2);
-      expect(results[0].success).toBe(true);
-      expect(results[1].success).toBe(true);
-    });
-
-    test("returns mixed results for valid and invalid skills", () => {
-      const results = installSkills(["deepresearch", "nonexistent-xyz"], { targetDir: testDir });
-      expect(results.length).toBe(2);
-      expect(results[0].success).toBe(true);
-      expect(results[1].success).toBe(false);
-    });
-
-    test("index.ts contains all installed skills", () => {
-      installSkills(["deepresearch", "image"], { targetDir: testDir });
-      const content = readFileSync(join(testDir, ".skills", "index.ts"), "utf-8");
-      expect(content).toContain("deepresearch");
-      expect(content).toContain("image");
-    });
-  });
-
-  describe("getInstalledSkills", () => {
-    test("returns empty array when no skills installed", () => {
-      const installed = getInstalledSkills(testDir);
-      expect(installed).toEqual([]);
-    });
-
-    test("returns empty array when .skills directory does not exist", () => {
-      const noDir = join(testDir, "nonexistent");
-      const installed = getInstalledSkills(noDir);
-      expect(installed).toEqual([]);
-    });
-
-    test("returns installed skill names without prefix", () => {
-      installSkill("deepresearch", { targetDir: testDir });
-      installSkill("image", { targetDir: testDir });
-      const installed = getInstalledSkills(testDir);
-      expect(installed).toContain("deepresearch");
-      expect(installed).toContain("image");
-      expect(installed.length).toBe(2);
-    });
-
-    test("does not include non-skill files", () => {
-      installSkill("deepresearch", { targetDir: testDir });
-      // Create a non-skill file
-      writeFileSync(join(testDir, ".skills", "random.txt"), "test");
-      const installed = getInstalledSkills(testDir);
-      expect(installed.length).toBe(1);
-    });
-  });
-
-  describe("removeSkill", () => {
-    test("removes an installed skill", () => {
-      installSkill("deepresearch", { targetDir: testDir });
-      expect(getInstalledSkills(testDir)).toContain("deepresearch");
-      const result = removeSkill("deepresearch", testDir);
-      expect(result).toBe(true);
-      expect(getInstalledSkills(testDir)).not.toContain("deepresearch");
-    });
-
-    test("returns false for non-installed skill", () => {
-      const result = removeSkill("nonexistent-xyz", testDir);
-      expect(result).toBe(false);
-    });
-
-    test("updates index.ts after removal", () => {
-      installSkills(["deepresearch", "image"], { targetDir: testDir });
-      removeSkill("deepresearch", testDir);
-      const content = readFileSync(join(testDir, ".skills", "index.ts"), "utf-8");
-      expect(content).not.toContain("deepresearch");
-      expect(content).toContain("image");
-    });
-
-    test("handles skill- prefix in name", () => {
-      installSkill("deepresearch", { targetDir: testDir });
-      const result = removeSkill("skill-deepresearch", testDir);
-      expect(result).toBe(true);
-      expect(getInstalledSkills(testDir)).not.toContain("deepresearch");
-    });
-  });
-
-  describe("agent install", () => {
-    test("AGENT_TARGETS contains all three agents", () => {
-      expect(AGENT_TARGETS).toContain("claude");
-      expect(AGENT_TARGETS).toContain("codex");
-      expect(AGENT_TARGETS).toContain("gemini");
-      expect(AGENT_TARGETS.length).toBe(3);
-    });
-
-    describe("getAgentSkillsDir", () => {
-      test("returns global path for claude", () => {
-        const dir = getAgentSkillsDir("claude", "global");
-        expect(dir).toContain(".claude/skills");
-      });
-
-      test("returns project path for claude", () => {
-        const dir = getAgentSkillsDir("claude", "project", testDir);
-        expect(dir).toBe(join(testDir, ".claude", "skills"));
-      });
-
-      test("returns global path for codex", () => {
-        const dir = getAgentSkillsDir("codex", "global");
-        expect(dir).toContain(".codex/skills");
-      });
-
-      test("returns global path for gemini", () => {
-        const dir = getAgentSkillsDir("gemini", "global");
-        expect(dir).toContain(".gemini/skills");
-      });
-    });
-
-    describe("getAgentSkillPath", () => {
-      test("returns correct path with skill- prefix", () => {
-        const path = getAgentSkillPath("image", "claude", "project", testDir);
-        expect(path).toBe(join(testDir, ".claude", "skills", "skill-image"));
-      });
-
-      test("does not double-prefix", () => {
-        const path = getAgentSkillPath("skill-image", "claude", "project", testDir);
-        expect(path).toContain("skill-image");
-        expect(path).not.toContain("skill-skill-");
-      });
-    });
-
-    describe("installSkillForAgent", () => {
-      test("installs SKILL.md for a skill that has one", () => {
-        const result = installSkillForAgent("image", {
-          agent: "claude",
-          scope: "project",
-          projectDir: testDir,
-        });
-        expect(result.success).toBe(true);
-        expect(result.path).toBeDefined();
-        const skillMdPath = join(result.path!, "SKILL.md");
-        expect(existsSync(skillMdPath)).toBe(true);
-        const content = readFileSync(skillMdPath, "utf-8");
-        expect(content).toContain("Image Generation");
-      });
-
-      test("generates SKILL.md when skill lacks one", () => {
-        const result = installSkillForAgent("deepresearch", {
-          agent: "claude",
-          scope: "project",
-          projectDir: testDir,
-        }, (name) => `---\nname: ${name}\ndescription: test\n---\n\n# Test\n`);
-        expect(result.success).toBe(true);
-        const skillMdPath = join(result.path!, "SKILL.md");
-        expect(existsSync(skillMdPath)).toBe(true);
-      });
-
-      test("fails without generator when skill has no SKILL.md", () => {
-        // scaffold-project has no SKILL.md
-        const result = installSkillForAgent("scaffold-project", {
-          agent: "claude",
-          scope: "project",
-          projectDir: testDir,
-        });
-        expect(result.success).toBe(false);
-        expect(result.error).toContain("SKILL.md");
-      });
-
-      test("fails for nonexistent skill", () => {
-        const result = installSkillForAgent("nonexistent-xyz", {
-          agent: "claude",
-          scope: "project",
-          projectDir: testDir,
-        });
-        expect(result.success).toBe(false);
-        expect(result.error).toContain("not found");
-      });
-
-      test("installs to correct agent directory", () => {
-        for (const agent of AGENT_TARGETS) {
-          installSkillForAgent("image", {
-            agent,
-            scope: "project",
-            projectDir: testDir,
-          });
-          const expected = join(testDir, `.${agent}`, "skills", "skill-image", "SKILL.md");
-          expect(existsSync(expected)).toBe(true);
-        }
-      });
-    });
-
-    describe("removeSkillForAgent", () => {
-      test("removes an installed skill", () => {
-        installSkillForAgent("image", {
-          agent: "claude",
-          scope: "project",
-          projectDir: testDir,
-        });
-        const result = removeSkillForAgent("image", {
-          agent: "claude",
-          scope: "project",
-          projectDir: testDir,
-        });
-        expect(result).toBe(true);
-        const skillDir = join(testDir, ".claude", "skills", "skill-image");
-        expect(existsSync(skillDir)).toBe(false);
-      });
-
-      test("returns false for non-installed skill", () => {
-        const result = removeSkillForAgent("nonexistent-xyz", {
-          agent: "claude",
-          scope: "project",
-          projectDir: testDir,
-        });
-        expect(result).toBe(false);
-      });
-    });
-  });
-});

package/src/lib/installer.ts

@@ -1,297 +0,0 @@
-/**
- * Skill installer - handles copying skills to user projects
- */
-
-import { existsSync, cpSync, mkdirSync, writeFileSync, rmSync, readdirSync, statSync, readFileSync } from "fs";
-import { join, dirname } from "path";
-import { homedir } from "os";
-import { fileURLToPath } from "url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-// Find the skills directory - works from both src/lib/ (dev) and bin/ or dist/ (built)
-function findSkillsDir(): string {
-  let dir = __dirname;
-  for (let i = 0; i < 5; i++) {
-    const candidate = join(dir, "skills");
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-    dir = dirname(dir);
-  }
-  return join(__dirname, "..", "skills");
-}
-
-const SKILLS_DIR = findSkillsDir();
-
-export interface InstallResult {
-  skill: string;
-  success: boolean;
-  error?: string;
-  path?: string;
-}
-
-export interface InstallOptions {
-  targetDir?: string;
-  overwrite?: boolean;
-}
-
-/**
- * Get the path to a skill in the package
- */
-export function getSkillPath(name: string): string {
-  const skillName = name.startsWith("skill-") ? name : `skill-${name}`;
-  return join(SKILLS_DIR, skillName);
-}
-
-/**
- * Check if a skill exists in the package
- */
-export function skillExists(name: string): boolean {
-  return existsSync(getSkillPath(name));
-}
-
-/**
- * Install a single skill to the target directory
- */
-export function installSkill(
-  name: string,
-  options: InstallOptions = {}
-): InstallResult {
-  const { targetDir = process.cwd(), overwrite = false } = options;
-
-  const skillName = name.startsWith("skill-") ? name : `skill-${name}`;
-  const sourcePath = getSkillPath(name);
-  const destDir = join(targetDir, ".skills");
-  const destPath = join(destDir, skillName);
-
-  // Check if skill exists in package
-  if (!existsSync(sourcePath)) {
-    return {
-      skill: name,
-      success: false,
-      error: `Skill '${name}' not found`,
-    };
-  }
-
-  // Check if already installed
-  if (existsSync(destPath) && !overwrite) {
-    return {
-      skill: name,
-      success: false,
-      error: `Already installed. Use --overwrite to replace.`,
-      path: destPath,
-    };
-  }
-
-  try {
-    // Ensure .skills directory exists
-    if (!existsSync(destDir)) {
-      mkdirSync(destDir, { recursive: true });
-    }
-
-    // Remove existing if overwriting
-    if (existsSync(destPath) && overwrite) {
-      rmSync(destPath, { recursive: true, force: true });
-    }
-
-    // Copy skill (skip .git, node_modules)
-    cpSync(sourcePath, destPath, {
-      recursive: true,
-      filter: (src) => {
-        const rel = src.slice(sourcePath.length);
-        return !rel.includes("/.git") && !rel.includes("/node_modules");
-      },
-    });
-
-    // Update or create .skills/index.ts for easy imports
-    updateSkillsIndex(destDir);
-
-    return {
-      skill: name,
-      success: true,
-      path: destPath,
-    };
-  } catch (error) {
-    return {
-      skill: name,
-      success: false,
-      error: error instanceof Error ? error.message : "Unknown error",
-    };
-  }
-}
-
-/**
- * Install multiple skills
- */
-export function installSkills(
-  names: string[],
-  options: InstallOptions = {}
-): InstallResult[] {
-  return names.map((name) => installSkill(name, options));
-}
-
-/**
- * Update the .skills/index.ts file to export all installed skills
- */
-function updateSkillsIndex(skillsDir: string): void {
-  const indexPath = join(skillsDir, "index.ts");
-
-  const skills = readdirSync(skillsDir).filter(
-    (f: string) => f.startsWith("skill-") && !f.includes(".")
-  );
-
-  const exports = skills
-    .map((s: string) => {
-      const name = s.replace("skill-", "").replace(/-/g, "_");
-      return `export * as ${name} from './${s}/src/index.js';`;
-    })
-    .join("\n");
-
-  const content = `/**
- * Auto-generated index of installed skills
- * Do not edit manually - run 'skills install' to update
- */
-
-${exports}
-`;
-
-  writeFileSync(indexPath, content);
-}
-
-/**
- * Get list of installed skills in a directory
- */
-export function getInstalledSkills(targetDir: string = process.cwd()): string[] {
-  const skillsDir = join(targetDir, ".skills");
-
-  if (!existsSync(skillsDir)) {
-    return [];
-  }
-
-  return readdirSync(skillsDir)
-    .filter((f: string) => {
-      const fullPath = join(skillsDir, f);
-      return f.startsWith("skill-") && statSync(fullPath).isDirectory();
-    })
-    .map((f: string) => f.replace("skill-", ""));
-}
-
-/**
- * Remove an installed skill
- */
-export function removeSkill(
-  name: string,
-  targetDir: string = process.cwd()
-): boolean {
-  const skillName = name.startsWith("skill-") ? name : `skill-${name}`;
-  const skillsDir = join(targetDir, ".skills");
-  const skillPath = join(skillsDir, skillName);
-
-  if (!existsSync(skillPath)) {
-    return false;
-  }
-
-  rmSync(skillPath, { recursive: true, force: true });
-  updateSkillsIndex(skillsDir);
-  return true;
-}
-
-// ---- Agent install support ----
-
-export type AgentTarget = "claude" | "codex" | "gemini";
-export type AgentScope = "global" | "project";
-
-export const AGENT_TARGETS: AgentTarget[] = ["claude", "codex", "gemini"];
-
-export interface AgentInstallOptions {
-  agent: AgentTarget;
-  scope?: AgentScope;
-  projectDir?: string;
-}
-
-/**
- * Get the skills directory for a given agent and scope
- */
-export function getAgentSkillsDir(agent: AgentTarget, scope: AgentScope = "global", projectDir?: string): string {
-  const agentDir = `.${agent}`;
-
-  if (scope === "project") {
-    return join(projectDir || process.cwd(), agentDir, "skills");
-  }
-
-  return join(homedir(), agentDir, "skills");
-}
-
-/**
- * Get the full path where a skill's SKILL.md would be installed for an agent
- */
-export function getAgentSkillPath(name: string, agent: AgentTarget, scope: AgentScope = "global", projectDir?: string): string {
-  const skillName = name.startsWith("skill-") ? name : `skill-${name}`;
-  return join(getAgentSkillsDir(agent, scope, projectDir), skillName);
-}
-
-/**
- * Install a skill's SKILL.md for a specific agent
- * If the skill has no SKILL.md, one will be generated using the provided generator function
- */
-export function installSkillForAgent(
-  name: string,
-  options: AgentInstallOptions,
-  generateSkillMd?: (name: string) => string | null
-): InstallResult {
-  const { agent, scope = "global", projectDir } = options;
-
-  const skillName = name.startsWith("skill-") ? name : `skill-${name}`;
-  const sourcePath = getSkillPath(name);
-
-  if (!existsSync(sourcePath)) {
-    return { skill: name, success: false, error: `Skill '${name}' not found` };
-  }
-
-  // Find or generate SKILL.md content
-  let skillMdContent: string | null = null;
-  const skillMdPath = join(sourcePath, "SKILL.md");
-
-  if (existsSync(skillMdPath)) {
-    skillMdContent = readFileSync(skillMdPath, "utf-8");
-  } else if (generateSkillMd) {
-    skillMdContent = generateSkillMd(name);
-  }
-
-  if (!skillMdContent) {
-    return { skill: name, success: false, error: `No SKILL.md found and could not generate one for '${name}'` };
-  }
-
-  const destDir = getAgentSkillPath(name, agent, scope, projectDir);
-
-  try {
-    mkdirSync(destDir, { recursive: true });
-    writeFileSync(join(destDir, "SKILL.md"), skillMdContent);
-    return { skill: name, success: true, path: destDir };
-  } catch (error) {
-    return {
-      skill: name,
-      success: false,
-      error: error instanceof Error ? error.message : "Unknown error",
-    };
-  }
-}
-
-/**
- * Remove a skill from an agent's skill directory
- */
-export function removeSkillForAgent(
-  name: string,
-  options: AgentInstallOptions
-): boolean {
-  const { agent, scope = "global", projectDir } = options;
-  const destDir = getAgentSkillPath(name, agent, scope, projectDir);
-
-  if (!existsSync(destDir)) {
-    return false;
-  }
-
-  rmSync(destDir, { recursive: true, force: true });
-  return true;
-}