@kurokeita/add-skill 1.4.0 → 1.6.0

package/dist/agents/test-engineer.md

@@ -0,0 +1,158 @@
+---
+name: test-engineer
+description: Expert in testing, TDD, and test automation. Use for writing tests, improving coverage, debugging test failures. Triggers on test, spec, coverage, jest, pytest, playwright, e2e, unit test.
+tools: Read, Grep, Glob, Bash, Edit, Write
+model: inherit
+skills: clean-code, testing-patterns, tdd-workflow, webapp-testing, code-review-checklist, lint-and-validate
+---
+
+# Test Engineer
+
+Expert in test automation, TDD, and comprehensive testing strategies.
+
+## Core Philosophy
+
+> "Find what the developer forgot. Test behavior, not implementation."
+
+## Your Mindset
+
+- **Proactive**: Discover untested paths
+- **Systematic**: Follow testing pyramid
+- **Behavior-focused**: Test what matters to users
+- **Quality-driven**: Coverage is a guide, not a goal
+
+---
+
+## Testing Pyramid
+
+```
+        /\          E2E (Few)
+       /  \         Critical user flows
+      /----\
+     /      \       Integration (Some)
+    /--------\      API, DB, services
+   /          \
+  /------------\    Unit (Many)
+                    Functions, logic
+```
+
+---
+
+## Framework Selection
+
+| Language | Unit | Integration | E2E |
+|----------|------|-------------|-----|
+| TypeScript | Vitest, Jest | Supertest | Playwright |
+| Python | Pytest | Pytest | Playwright |
+| React | Testing Library | MSW | Playwright |
+
+---
+
+## TDD Workflow
+
+```
+🔴 RED    → Write failing test
+🟢 GREEN  → Minimal code to pass
+🔵 REFACTOR → Improve code quality
+```
+
+---
+
+## Test Type Selection
+
+| Scenario | Test Type |
+|----------|-----------|
+| Business logic | Unit |
+| API endpoints | Integration |
+| User flows | E2E |
+| Components | Component/Unit |
+
+---
+
+## AAA Pattern
+
+| Step | Purpose |
+|------|---------|
+| **Arrange** | Set up test data |
+| **Act** | Execute code |
+| **Assert** | Verify outcome |
+
+---
+
+## Coverage Strategy
+
+| Area | Target |
+|------|--------|
+| Critical paths | 100% |
+| Business logic | 80%+ |
+| Utilities | 70%+ |
+| UI layout | As needed |
+
+---
+
+## Deep Audit Approach
+
+### Discovery
+
+| Target | Find |
+|--------|------|
+| Routes | Scan app directories |
+| APIs | Grep HTTP methods |
+| Components | Find UI files |
+
+### Systematic Testing
+
+1. Map all endpoints
+2. Verify responses
+3. Cover critical paths
+
+---
+
+## Mocking Principles
+
+| Mock | Don't Mock |
+|------|------------|
+| External APIs | Code under test |
+| Database (unit) | Simple deps |
+| Network | Pure functions |
+
+---
+
+## Review Checklist
+
+- [ ] Coverage 80%+ on critical paths
+- [ ] AAA pattern followed
+- [ ] Tests are isolated
+- [ ] Descriptive naming
+- [ ] Edge cases covered
+- [ ] External deps mocked
+- [ ] Cleanup after tests
+- [ ] Fast unit tests (<100ms)
+
+---
+
+## Anti-Patterns
+
+| ❌ Don't | ✅ Do |
+|----------|-------|
+| Test implementation | Test behavior |
+| Multiple asserts | One per test |
+| Dependent tests | Independent |
+| Ignore flaky | Fix root cause |
+| Skip cleanup | Always reset |
+
+---
+
+## When You Should Be Used
+
+- Writing unit tests
+- TDD implementation
+- E2E test creation
+- Improving coverage
+- Debugging test failures
+- Test infrastructure setup
+- API integration tests
+
+---
+
+> **Remember:** Good tests are documentation. They explain what the code should do.

package/dist/bin/cli.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { add } from "../src/commands/add.js";
+import { importItem } from "../src/commands/import.js";
+import { list } from "../src/commands/list.js";
+import { remove } from "../src/commands/remove.js";
+const program = new Command();
+program
+    .name("ai-agent")
+    .description("CLI to manage AI agents, skills, and workflows")
+    .version("1.4.0");
+program
+    .command("list [type]")
+    .description("List available items (skills, agents, workflows)")
+    .option("-l, --local", "List installed items locally")
+    .action(list);
+program
+    .command("add <type> [url]")
+    .description("Add an item (skill, agent, workflow) to platforms (Interactive or from GitHub URL)")
+    .action(add);
+program
+    .command("import <type> <url>")
+    .description("Import an item from GitHub to the repo")
+    .action(importItem);
+program
+    .command("remove <type>")
+    .description("Remove locally installed items (skills, agents, workflows)")
+    .action(remove);
+program.parse();

package/dist/src/commands/add.js

@@ -1,39 +1,22 @@
 import os from "node:os";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { cancel, confirm, intro, isCancel, multiselect, note, outro, spinner, } from "@clack/prompts";
 import fs from "fs-extra";
 import pc from "picocolors";
 import { fetchSkillFromGitHub } from "../utils/github.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const PROJECT_ROOT = path.resolve(__dirname, "../..");
-const SKILLS_DIR = path.join(PROJECT_ROOT, "skills");
-const PLATFORM_PATHS = {
-    copilot: path.join(os.homedir(), ".copilot/skills"),
-    windsurf: path.join(os.homedir(), ".codeium/windsurf/skills"),
-    antigravity: path.join(os.homedir(), ".gemini/antigravity/global_skills"),
-    gemini: path.join(os.homedir(), ".gemini/skills"),
-};
-export const PLATFORM_OPTIONS = [
-    {
-        label: "Antigravity",
-        value: "antigravity",
-        hint: "~/.gemini/antigravity/global_skills",
-    },
-    { label: "Gemini CLI", value: "gemini", hint: "~/.gemini/skills" },
-    { label: "GitHub Copilot", value: "copilot", hint: "~/.copilot/skills" },
-    {
-        label: "Windsurf",
-        value: "windsurf",
-        hint: "~/.codeium/windsurf/skills",
-    },
-];
-async function installSkill(skillName, platform, overwrite, sourcePath = path.join(SKILLS_DIR, skillName)) {
-    const targetBaseDir = PLATFORM_PATHS[platform];
-    const targetPath = path.join(targetBaseDir, skillName);
+import { getTargetPaths, PLATFORM_LABELS, TYPE_DIRS, } from "../utils/paths.js";
+function getPlatformOptions(type) {
+    const paths = getTargetPaths(type);
+    return Object.entries(paths).map(([platform, pathStr]) => ({
+        label: PLATFORM_LABELS[platform],
+        value: platform,
+        hint: pathStr.replace(os.homedir(), "~"),
+    }));
+}
+async function installItem(itemName, overwrite, sourcePath, targetBaseDir) {
+    const targetPath = path.join(targetBaseDir, itemName);
     if (!(await fs.pathExists(sourcePath))) {
-        throw new Error(`Skill '${skillName}' not found at ${sourcePath}`);
+        throw new Error(`Item '${itemName}' not found at ${sourcePath}`);
     }
     if (!overwrite && (await fs.pathExists(targetPath))) {
         return false;
@@ -42,58 +25,76 @@ async function installSkill(skillName, platform, overwrite, sourcePath = path.jo
     await fs.copy(sourcePath, targetPath, { overwrite });
     return true;
 }
-export async function addSkill(url) {
-    console.clear();
-    intro(pc.bgCyan(pc.black(" AI Skills Manager ")));
+export async function add(type, url) {
+    intro(pc.bgCyan(pc.black(` AI Manager : Add ${type} `)));
+    // Normalize type
+    const normalizedType = type.toLowerCase().endsWith("s")
+        ? type.slice(0, -1)
+        : type;
+    if (!TYPE_DIRS[normalizedType]) {
+        cancel(`Unknown type: ${type}. Supported: skill, agent, workflow`);
+        process.exit(1);
+    }
     let tempDir = null;
-    let selectedSkills = [];
+    let selectedItems = [];
     try {
         // 1. Determine Source (Local vs GitHub)
         if (url) {
             const s = spinner();
-            s.start("Fetching skill from GitHub...");
+            s.start(`Fetching ${normalizedType} from GitHub...`);
             try {
                 const result = await fetchSkillFromGitHub(url);
                 tempDir = result.tempDir;
-                selectedSkills = [result.skillName];
-                s.stop(pc.green(`Fetched skill: ${result.skillName}`));
+                selectedItems = [result.skillName];
+                s.stop(pc.green(`Fetched ${normalizedType}: ${result.skillName}`));
             }
             catch (e) {
-                s.stop(pc.red("Failed to fetch skill"));
+                s.stop(pc.red("Failed to fetch"));
                 throw e;
             }
         }
         else {
             // Local Selection Logic
-            if (!(await fs.pathExists(SKILLS_DIR))) {
-                cancel(pc.red("Skills directory not found!"));
+            const sourceDir = TYPE_DIRS[normalizedType];
+            if (!(await fs.pathExists(sourceDir))) {
+                cancel(`${normalizedType} directory not found!`);
                 process.exit(1);
             }
-            const entries = await fs.readdir(SKILLS_DIR, { withFileTypes: true });
-            const availableSkills = entries
-                .filter((entry) => entry.isDirectory())
+            const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+            const availableItems = entries
+                .filter((entry) => entry.isDirectory() ||
+                ((normalizedType === "workflow" || normalizedType === "agent") &&
+                    entry.isFile() &&
+                    entry.name.endsWith(".md")))
                 .map((entry) => ({ label: entry.name, value: entry.name }))
                 .sort((a, b) => a.label.localeCompare(b.label));
-            if (availableSkills.length === 0) {
-                cancel("No skills found in the skills directory.");
+            if (availableItems.length === 0) {
+                cancel(`No ${normalizedType}s found in directory.`);
                 process.exit(0);
             }
-            // Select Skills
-            const skills = await multiselect({
-                message: "Select skills to install:",
-                options: availableSkills,
+            // Select Items
+            const items = await multiselect({
+                message: `Select ${normalizedType}s to install:`,
+                options: availableItems,
                 required: true,
             });
-            if (isCancel(skills)) {
+            if (isCancel(items)) {
                 cancel("Operation cancelled.");
                 process.exit(0);
             }
-            selectedSkills = skills;
+            selectedItems = items;
         }
         // 2. Select Platforms
+        // Filter platform options based on support for the type
+        const supportedPaths = getTargetPaths(normalizedType);
+        const currentPlatformOptions = getPlatformOptions(normalizedType);
+        if (currentPlatformOptions.length === 0) {
+            cancel(`No supported platforms found for type '${normalizedType}'.`);
+            process.exit(1);
+        }
         const platforms = await multiselect({
             message: "Select target platforms:",
-            options: PLATFORM_OPTIONS,
+            options: currentPlatformOptions,
             required: true,
         });
         if (isCancel(platforms)) {
@@ -104,30 +105,33 @@ export async function addSkill(url) {
             process.exit(0);
         }
         const selectedPlatforms = platforms;
-        // 3. Check for existing skills
-        const existingSkills = [];
+        // 3. Check for existing items
+        const existingItems = [];
         for (const platform of selectedPlatforms) {
-            for (const skill of selectedSkills) {
-                const targetPath = path.join(PLATFORM_PATHS[platform], skill);
+            const targetBase = supportedPaths[platform];
+            if (!targetBase)
+                continue;
+            for (const item of selectedItems) {
+                const targetPath = path.join(targetBase, item);
                 if (await fs.pathExists(targetPath)) {
-                    existingSkills.push({ skill, platform });
+                    existingItems.push({ item, platform });
                 }
             }
         }
         let overwrite = true;
-        if (existingSkills.length > 0) {
+        if (existingItems.length > 0) {
             const limit = 5;
-            const displayList = existingSkills
+            const displayList = existingItems
                 .slice(0, limit)
-                .map((e) => `${pc.bold(e.skill)} (${e.platform})`)
+                .map((e) => `${pc.bold(e.item)} (${e.platform})`)
                 .join(", ");
-            const remainder = existingSkills.length - limit;
+            const remainder = existingItems.length - limit;
             const message = remainder > 0
-                ? `The following skills already exist: ${displayList}, and ${remainder} others.`
-                : `The following skills already exist: ${displayList}.`;
+                ? `The following items already exist: ${displayList}, and ${remainder} others.`
+                : `The following items already exist: ${displayList}.`;
             note(message, "Attention");
             const shouldOverwrite = await confirm({
-                message: "Do you want to overwrite existing skills?",
+                message: "Do you want to overwrite existing items?",
                 initialValue: false,
             });
             if (isCancel(shouldOverwrite)) {
@@ -139,26 +143,60 @@ export async function addSkill(url) {
             overwrite = shouldOverwrite;
         }
         // 4. Confirmation Note
-        note(`Installing ${selectedSkills.length} skills to ${selectedPlatforms.length} platforms...`, "Summary");
+        note(`Installing ${selectedItems.length} ${normalizedType}s to ${selectedPlatforms.length} platforms...`, "Summary");
         // 5. Installation Loop with Spinner
         const s = spinner();
-        s.start("Installing skills...");
+        s.start("Installing...");
         const errors = [];
         let installedCount = 0;
         let skippedCount = 0;
         for (const platform of selectedPlatforms) {
-            for (const skill of selectedSkills) {
-                const message = `Installing ${pc.bold(skill)} to ${pc.cyan(platform)}...`;
+            const targetBase = supportedPaths[platform];
+            if (!targetBase)
+                continue;
+            for (const item of selectedItems) {
+                const message = `Installing ${pc.bold(item)} to ${pc.cyan(platform)}...`;
                 s.message(message);
                 try {
-                    // Use specific source path for each skill
-                    // If tempDir is set, it means we have a single skill fetched from GitHub
-                    // The sourceDir was set to the parent of tempDir, so joining sourceDir + skillName works
-                    // However, for local skills, sourceDir is SKILLS_DIR
-                    const currentSourcePath = url && tempDir
-                        ? tempDir // Special handling for single downloaded skill
-                        : path.join(SKILLS_DIR, skill);
-                    const installed = await installSkill(skill, platform, overwrite, currentSourcePath);
+                    if (url && tempDir) {
+                        // We already fetched it, check if it was a file
+                        // Wait, fetchSkillFromGitHub returned isFile, but add command logic separated fetch from install loop.
+                        // We need to store isFile state from fetch if using URL.
+                        // However, selectedItems only stores strings.
+                        // Let's assume if it is a URL, we re-verify or change logic slightly.
+                        // Better: modify fetch logic above to store isFile.
+                    }
+                    // Re-implementing logic to be consistent with import.ts
+                    // But wait, add command handles multiple items if LOCAL.
+                    // If URL, it is single item `selectedItems = [result.skillName]`.
+                    let currentSourcePath;
+                    if (url && tempDir) {
+                        // For URL fetch, we need to know if it was a file.
+                        // We can check if tempDir/item exists as file.
+                        const potentialFile = path.join(tempDir, item);
+                        if ((await fs.pathExists(potentialFile)) &&
+                            (await fs.stat(potentialFile)).isFile()) {
+                            currentSourcePath = potentialFile;
+                        }
+                        else {
+                            currentSourcePath = tempDir;
+                        }
+                    }
+                    else {
+                        // Local source
+                        const src = path.join(TYPE_DIRS[normalizedType], item);
+                        if ((await fs.stat(src)).isFile()) {
+                            currentSourcePath = src;
+                        }
+                        else {
+                            currentSourcePath = src; // direct path to dir
+                        }
+                    }
+                    let targetItemName = item;
+                    if (platform === "windsurf" && normalizedType === "agent") {
+                        targetItemName = path.join(path.parse(item).name, "AGENTS.md");
+                    }
+                    const installed = await installItem(targetItemName, overwrite, currentSourcePath, targetBase);
                     if (installed) {
                         installedCount++;
                     }
@@ -168,7 +206,7 @@ export async function addSkill(url) {
                 }
                 catch (err) {
                     const errorMessage = err instanceof Error ? err.message : String(err);
-                    errors.push(`${skill} -> ${platform}: ${errorMessage}`);
+                    errors.push(`${item} -> ${platform}: ${errorMessage}`);
                 }
             }
         }
@@ -184,7 +222,7 @@ export async function addSkill(url) {
             }
         }
         else {
-            s.stop(pc.green(`Successfully installed ${installedCount} skills. (${skippedCount} skipped)`));
+            s.stop(pc.green(`Successfully installed ${installedCount} ${normalizedType}s. (${skippedCount} skipped)`));
         }
         outro("You're all set!");
     }

package/dist/src/commands/import.js

@@ -1,42 +1,80 @@
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { cancel, confirm, intro, isCancel, outro, spinner, } from "@clack/prompts";
 import fs from "fs-extra";
 import pc from "picocolors";
 import { fetchSkillFromGitHub } from "../utils/github.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const PROJECT_ROOT = path.resolve(__dirname, "../..");
-const SKILLS_DIR = path.join(PROJECT_ROOT, "skills");
-export async function importSkill(url) {
-    console.clear();
-    intro(pc.bgCyan(pc.black(" AI Skills Manager : Import ")));
+import { TYPE_DIRS } from "../utils/paths.js";
+export async function importItem(type, url) {
+    intro(pc.bgCyan(pc.black(` AI Manager : Import ${type} `)));
+    // Normalize type
+    const normalizedType = type.toLowerCase().endsWith("s")
+        ? type.slice(0, -1)
+        : type;
+    const targetBaseDir = TYPE_DIRS[normalizedType];
+    if (!targetBaseDir) {
+        cancel(`Unknown type: ${type}. Supported: skill, agent, workflow`);
+        process.exit(1);
+    }
     if (!url) {
         cancel("GitHub URL is required.");
         process.exit(1);
     }
     let tempDir = null;
     try {
-        // 1. Fetch Skill
+        // 1. Fetch Item (using fetchSkillFromGitHub as generic fetcher)
         const s = spinner();
-        s.start("Fetching skill from GitHub...");
-        let skillName = "";
+        s.start(`Fetching ${normalizedType} from GitHub...`);
+        let itemName = "";
+        let isFile = false;
         try {
             const result = await fetchSkillFromGitHub(url);
             tempDir = result.tempDir;
-            skillName = result.skillName;
-            s.stop(pc.green(`Fetched skill: ${skillName}`));
+            if (!tempDir)
+                throw new Error("Failed to create temp directory");
+            itemName = result.skillName; // reuse property or rename if possible. assuming generic repo structure
+            isFile = result.isFile;
+            s.stop(pc.green(`Fetched: ${itemName}`));
         }
         catch (e) {
-            s.stop(pc.red("Failed to fetch skill"));
+            s.stop(pc.red("Failed to fetch"));
             throw e;
         }
         // 2. Determine Target
-        const targetPath = path.join(SKILLS_DIR, skillName);
+        const shouldFlatten = (normalizedType === "agent" || normalizedType === "workflow") && !isFile;
+        const targetPath = shouldFlatten
+            ? targetBaseDir
+            : path.join(targetBaseDir, itemName);
         // 3. Check Existence & Confirm Overwrite
-        if (await fs.pathExists(targetPath)) {
+        if (shouldFlatten) {
+            const srcFiles = await fs.readdir(tempDir);
+            const conflicts = [];
+            for (const file of srcFiles) {
+                if (await fs.pathExists(path.join(targetBaseDir, file))) {
+                    conflicts.push(file);
+                }
+            }
+            if (conflicts.length > 0) {
+                const limit = 5;
+                const displayList = conflicts.slice(0, limit).join(", ");
+                const remainder = conflicts.length - limit;
+                const message = remainder > 0
+                    ? `Files ${displayList} (and ${remainder} others) already exist in ${targetBaseDir}. Overwrite?`
+                    : `Files ${displayList} already exist in ${targetBaseDir}. Overwrite?`;
+                const shouldOverwrite = await confirm({
+                    message,
+                    initialValue: false,
+                });
+                if (isCancel(shouldOverwrite) || !shouldOverwrite) {
+                    if (tempDir)
+                        await fs.remove(tempDir);
+                    cancel("Operation cancelled.");
+                    process.exit(0);
+                }
+            }
+        }
+        else if (await fs.pathExists(targetPath)) {
             const shouldOverwrite = await confirm({
-                message: `Skill '${skillName}' already exists in the repo. Overwrite?`,
+                message: `${normalizedType} '${itemName}' already exists in the repo. Overwrite?`,
                 initialValue: false,
             });
             if (isCancel(shouldOverwrite) || !shouldOverwrite) {
@@ -46,16 +84,28 @@ export async function importSkill(url) {
                 process.exit(0);
             }
         }
-        // 4. Move/Copy to Skills Directory
-        s.start(`Importing ${skillName} to ${SKILLS_DIR}...`);
-        await fs.ensureDir(SKILLS_DIR);
-        await fs.copy(tempDir, targetPath, { overwrite: true });
-        s.stop(pc.green(`Successfully imported ${skillName}!`));
+        // 4. Move/Copy to Target Directory
+        s.start(`Importing ${itemName} to ${targetBaseDir}...`);
+        await fs.ensureDir(targetBaseDir);
+        if (isFile) {
+            await fs.copy(path.join(tempDir, itemName), targetPath, {
+                overwrite: true,
+            });
+        }
+        else {
+            if (shouldFlatten) {
+                await fs.copy(tempDir, targetBaseDir, { overwrite: true });
+            }
+            else {
+                await fs.copy(tempDir, targetPath, { overwrite: true });
+            }
+        }
+        s.stop(pc.green(`Successfully imported ${itemName}!`));
         // Cleanup
         if (tempDir) {
             await fs.remove(tempDir);
         }
-        outro(`Skill available at: ${targetPath}`);
+        outro(`${normalizedType} available at: ${targetPath}`);
     }
     catch (error) {
         if (tempDir)