@kurokeita/add-skill 1.4.0 → 1.6.0

package/dist/src/commands/list.js

@@ -1,31 +1,92 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
 import fs from "fs-extra";
 import pc from "picocolors";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-// Assuming skills are in the root 'skills' directory relative to the project root
-// bin/skills.ts -> ../ -> src/commands -> ../../ -> root -> skills
-const PROJECT_ROOT = path.resolve(__dirname, "../..");
-const SKILLS_DIR = path.join(PROJECT_ROOT, "skills");
-export async function listSkills() {
+import { getTargetPaths, TYPE_DIRS } from "../utils/paths.js";
+export async function list(type, options) {
     try {
-        if (!(await fs.pathExists(SKILLS_DIR))) {
-            console.log(pc.yellow("No existing skills directory found at:"), SKILLS_DIR);
-            return;
+        const typesToList = type
+            ? [type.toLowerCase()]
+            : ["skill", "agent", "workflow"];
+        for (const t of typesToList) {
+            // Handle plural/singular input for convenience
+            const normalizedType = t.endsWith("s") ? t.slice(0, -1) : t;
+            if (options?.local) {
+                // List installed items locally
+                console.log(pc.bold(pc.blue(`Installed ${normalizedType}s (Local):`)));
+                const targetPaths = getTargetPaths(normalizedType);
+                let foundAny = false;
+                for (const [platform, pathStr] of Object.entries(targetPaths)) {
+                    const fullPath = pathStr;
+                    if (await fs.pathExists(fullPath)) {
+                        const entries = await fs.readdir(fullPath, {
+                            withFileTypes: true,
+                        });
+                        const items = entries
+                            .filter((entry) => entry.isDirectory() ||
+                            // For local items, agents/workflows might be directories OR .md files depending on how they were installed/flattened.
+                            // Usually flattened -> directory (if unpacked) or file (if generic).
+                            // Existing add logic:
+                            // Agents/Workflows can be flattened (unpacked to base) or not.
+                            // If flattened, they are files in the base dir? No, unpacked to base means they are files/dirs IN the base dir.
+                            // Wait, if I import "agent-a" (dir) and flatten, it copies contents of agent-a to agents/.
+                            // So "agents/skill.md" might exist.
+                            // The user requirement says "list all installed agents/skills/workflows".
+                            // In local global_skills (antigravity), they are directories.
+                            // In local global_agents, they might be directories or .md files.
+                            // Let's list directories and .md files.
+                            (entry.isFile() && entry.name.endsWith(".md")))
+                            .map((entry) => entry.name)
+                            .sort();
+                        if (items.length > 0) {
+                            foundAny = true;
+                            console.log(pc.cyan(`  ${platform}:`));
+                            for (const item of items) {
+                                console.log(`    - ${item}`);
+                            }
+                        }
+                    }
+                }
+                if (!foundAny) {
+                    console.log(pc.dim(`  No installed ${normalizedType}s found.`));
+                }
+                console.log(""); // Newline for separation
+            }
+            else {
+                // List available items in repo (existing logic)
+                if (!TYPE_DIRS[normalizedType]) {
+                    if (type) {
+                        console.error(pc.red(`Unknown type: ${type}. Supported types: skill, agent, workflow`));
+                    }
+                    continue;
+                }
+                const dirPath = TYPE_DIRS[normalizedType];
+                if (!(await fs.pathExists(dirPath))) {
+                    if (type) {
+                        console.log(pc.yellow(`No ${t} directory found at: ${dirPath}`));
+                    }
+                    continue;
+                }
+                const entries = await fs.readdir(dirPath, { withFileTypes: true });
+                const items = entries
+                    .filter((entry) => entry.isDirectory() ||
+                    (normalizedType !== "skill" &&
+                        entry.isFile() &&
+                        entry.name.endsWith(".md")))
+                    .map((entry) => entry.name)
+                    .sort();
+                if (items.length > 0) {
+                    console.log(pc.bold(pc.blue(`Available ${normalizedType}s:`)));
+                    for (const item of items) {
+                        console.log(`- ${item}`);
+                    }
+                    console.log(pc.dim(`Total: ${items.length} ${normalizedType}s\n`));
+                }
+                else if (type) {
+                    console.log(pc.dim(`No ${normalizedType}s found.`));
+                }
+            }
         }
-        const entries = await fs.readdir(SKILLS_DIR, { withFileTypes: true });
-        const skills = entries
-            .filter((entry) => entry.isDirectory())
-            .map((entry) => entry.name)
-            .sort();
-        console.log(pc.bold(pc.blue("Available Skills:")));
-        for (const skill of skills) {
-            console.log(`- ${skill}`);
-        }
-        console.log(pc.dim(`\nTotal: ${skills.length} skills`));
     }
     catch (error) {
-        console.error(pc.red("Error listing skills:"), error);
+        console.error(pc.red("Error listing items:"), error);
     }
 }

package/dist/src/commands/remove.js

@@ -0,0 +1,118 @@
+import path from "node:path";
+import { cancel, confirm, intro, isCancel, multiselect, outro, spinner, } from "@clack/prompts";
+import fs from "fs-extra";
+import pc from "picocolors";
+import { getTargetPaths, PLATFORM_LABELS, } from "../utils/paths.js";
+export async function remove(type) {
+    intro(pc.bgCyan(pc.black(` AI Manager : Remove ${type} `)));
+    // Normalize type
+    const normalizedType = type.toLowerCase().endsWith("s")
+        ? type.slice(0, -1)
+        : type;
+    const targetPaths = getTargetPaths(normalizedType);
+    // 1. Collect unique installed items across all platforms
+    const uniqueItems = new Set();
+    const s = spinner();
+    s.start("Scanning for installed items...");
+    for (const pathStr of Object.values(targetPaths)) {
+        if (await fs.pathExists(pathStr)) {
+            const entries = await fs.readdir(pathStr, {
+                withFileTypes: true,
+            });
+            for (const entry of entries) {
+                if (entry.isDirectory() ||
+                    (normalizedType === "workflow" &&
+                        entry.isFile() &&
+                        entry.name.endsWith(".md")) ||
+                    (normalizedType === "agent" &&
+                        entry.isFile() &&
+                        entry.name.endsWith(".md"))) {
+                    uniqueItems.add(entry.name);
+                }
+            }
+        }
+    }
+    s.stop(`Found ${uniqueItems.size} unique installed ${normalizedType}s.`);
+    if (uniqueItems.size === 0) {
+        cancel(`No installed ${normalizedType}s found.`);
+        process.exit(0);
+    }
+    // Sort explicitly
+    const sortedItems = Array.from(uniqueItems).sort();
+    // 2. Select Items
+    const itemSelections = await multiselect({
+        message: `Select ${normalizedType}s to remove:`,
+        options: sortedItems.map((item) => ({ value: item, label: item })),
+        required: true,
+    });
+    if (isCancel(itemSelections)) {
+        cancel("Operation cancelled.");
+        process.exit(0);
+    }
+    const selectedItems = itemSelections;
+    // 3. Select Platforms
+    // Only show platforms relevant to the type
+    const platformOptions = Object.entries(targetPaths).map(([platform]) => ({
+        label: PLATFORM_LABELS[platform],
+        value: platform,
+    }));
+    const platformSelections = await multiselect({
+        message: "Select platforms to remove from:",
+        options: platformOptions,
+        required: true,
+    });
+    if (isCancel(platformSelections)) {
+        cancel("Operation cancelled.");
+        process.exit(0);
+    }
+    const selectedPlatforms = platformSelections;
+    // 4. Confirmation
+    const confirmDelete = await confirm({
+        message: `Are you sure you want to remove ${selectedItems.length} item(s) from ${selectedPlatforms.length} platform(s)?`,
+        initialValue: false,
+    });
+    if (isCancel(confirmDelete) || !confirmDelete) {
+        cancel("Operation cancelled.");
+        process.exit(0);
+    }
+    // 5. Deletion Loop
+    const sDel = spinner();
+    sDel.start("Removing items...");
+    let removedCount = 0;
+    let notFoundCount = 0;
+    const errors = [];
+    for (const platform of selectedPlatforms) {
+        const targetBase = targetPaths[platform];
+        if (!targetBase)
+            continue;
+        for (const item of selectedItems) {
+            const targetPath = path.join(targetBase, item);
+            // Check if exists before trying to remove, to correctly count "removed" vs "not found"
+            if (await fs.pathExists(targetPath)) {
+                sDel.message(`Removing ${pc.bold(item)} from ${pc.cyan(platform)}...`);
+                try {
+                    await fs.remove(targetPath);
+                    removedCount++;
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    errors.push(`${item} (${platform}): ${msg}`);
+                }
+            }
+            else {
+                notFoundCount++;
+            }
+        }
+    }
+    if (errors.length > 0) {
+        sDel.stop(pc.yellow(`Completed with errors. Removed: ${removedCount}, Not Found: ${notFoundCount}, Errors: ${errors.length}`));
+        console.error(pc.red("\nErrors encountered:"));
+        for (const e of errors) {
+            console.error(pc.red(`- ${e}`));
+        }
+    }
+    else {
+        sDel.stop(pc.green(`Successfully removed ${removedCount} items. (${notFoundCount} not found)`));
+    }
+    outro("Done!");
+}

package/dist/src/utils/github.js

@@ -2,19 +2,18 @@ import os from "node:os";
 import path from "node:path";
 import fs from "fs-extra";
 export async function fetchSkillFromGitHub(url) {
-    const regex = /github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)/;
+    const regex = /github\.com\/([^/]+)\/([^/]+)\/(?:tree|blob)\/([^/]+)\/(.+)/;
     const match = url.match(regex);
     if (!match) {
-        throw new Error("Invalid GitHub URL. Format: https://github.com/owner/repo/tree/branch/path/to/skill");
+        throw new Error("Invalid GitHub URL. Format: https://github.com/owner/repo/tree/branch/path/to/skill or blob/branch/path/to/file");
     }
     const [, owner, repo, ref, skillPath] = match;
     const skillName = path.basename(skillPath);
-    // Initial API URL for the root of the skill
     const initialApiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${skillPath}?ref=${ref}`;
     const tempDir = path.join(os.tmpdir(), "ai-agents-install", skillName);
     await fs.ensureDir(tempDir);
     await fs.emptyDir(tempDir);
-    // Recursive function to download directory contents
+    let isFile = false;
     async function downloadDirectory(apiUrl, localDir) {
         const response = await fetch(apiUrl, {
             headers: {
@@ -25,13 +24,26 @@ export async function fetchSkillFromGitHub(url) {
         if (!response.ok) {
             throw new Error(`Failed to fetch from GitHub (${response.status}): ${response.statusText}`);
         }
-        const data = (await response.json());
+        const data = await response.json();
+        // Handle single file response
+        if (!Array.isArray(data) && data.type === "file") {
+            isFile = true;
+            const item = data;
+            if (item.download_url) {
+                const fileContentResponse = await fetch(item.download_url);
+                if (!fileContentResponse.ok) {
+                    throw new Error(`Failed to download ${item.name}: ${fileContentResponse.statusText}`);
+                }
+                const content = await fileContentResponse.text();
+                await fs.writeFile(path.join(localDir, item.name), content);
+            }
+            return;
+        }
         if (!Array.isArray(data)) {
-            // If it's not an array, it might be a single file if the URL pointed to a file,
-            // but we expect a directory here per the Contents API usage for directories.
-            throw new Error("Invalid response from GitHub API. Expected directory listing.");
+            throw new Error("Invalid response from GitHub API. Expected directory listing or file object.");
         }
-        for (const item of data) {
+        const files = data;
+        for (const item of files) {
             if (item.type === "file" && item.download_url) {
                 const fileContentResponse = await fetch(item.download_url);
                 if (!fileContentResponse.ok) {
@@ -44,11 +56,10 @@ export async function fetchSkillFromGitHub(url) {
             else if (item.type === "dir") {
                 const newLocalDir = path.join(localDir, item.name);
                 await fs.ensureDir(newLocalDir);
-                // Recursively download subdirectory using its API URL
                 await downloadDirectory(item.url, newLocalDir);
             }
         }
     }
     await downloadDirectory(initialApiUrl, tempDir);
-    return { tempDir, skillName };
+    return { tempDir, skillName, isFile };
 }

package/dist/src/utils/paths.js

@@ -0,0 +1,45 @@
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export const PROJECT_ROOT = path.resolve(__dirname, "../..");
+export const PLATFORM_LABELS = {
+    antigravity: "Antigravity",
+    gemini: "Gemini CLI",
+    copilot: "GitHub Copilot",
+    windsurf: "Windsurf",
+};
+export const PLATFORM_PATHS_SKILLS = {
+    antigravity: path.join(os.homedir(), ".gemini/antigravity/global_skills"),
+    copilot: path.join(os.homedir(), ".copilot/skills"),
+    gemini: path.join(os.homedir(), ".gemini/skills"),
+    windsurf: path.join(os.homedir(), ".codeium/windsurf/skills"),
+};
+export const PLATFORM_PATHS_AGENTS = {
+    antigravity: path.join(os.homedir(), ".gemini/antigravity/global_agents"),
+    copilot: path.join(os.homedir(), ".copilot/agents"),
+    gemini: path.join(os.homedir(), ".gemini/agents"),
+    windsurf: path.join(os.homedir(), ".codeium/windsurf/agents"),
+};
+export const PLATFORM_PATHS_WORKFLOWS = {
+    antigravity: path.join(os.homedir(), ".gemini/antigravity/global_workflows"),
+    copilot: path.join(os.homedir(), ".copilot/prompts"),
+    gemini: path.join(os.homedir(), ".gemini/workflows"),
+    windsurf: path.join(os.homedir(), ".codeium/windsurf/global_workflows"),
+};
+export const TYPE_DIRS = {
+    skill: path.join(PROJECT_ROOT, "skills"),
+    agent: path.join(PROJECT_ROOT, "agents"),
+    workflow: path.join(PROJECT_ROOT, "workflows"),
+};
+export function getTargetPaths(type) {
+    switch (type) {
+        case "agent":
+            return PLATFORM_PATHS_AGENTS;
+        case "workflow":
+            return PLATFORM_PATHS_WORKFLOWS;
+        default:
+            return PLATFORM_PATHS_SKILLS;
+    }
+}

package/dist/workflows/brainstorm.md

@@ -0,0 +1,113 @@
+---
+description: Structured brainstorming for projects and features. Explores multiple options before implementation.
+---
+
+# /brainstorm - Structured Idea Exploration
+
+$ARGUMENTS
+
+---
+
+## Purpose
+
+This command activates BRAINSTORM mode for structured idea exploration. Use when you need to explore options before committing to an implementation.
+
+---
+
+## Behavior
+
+When `/brainstorm` is triggered:
+
+1. **Understand the goal**
+   - What problem are we solving?
+   - Who is the user?
+   - What constraints exist?
+
+2. **Generate options**
+   - Provide at least 3 different approaches
+   - Each with pros and cons
+   - Consider unconventional solutions
+
+3. **Compare and recommend**
+   - Summarize tradeoffs
+   - Give a recommendation with reasoning
+
+---
+
+## Output Format
+
+```markdown
+## 🧠 Brainstorm: [Topic]
+
+### Context
+[Brief problem statement]
+
+---
+
+### Option A: [Name]
+[Description]
+
+✅ **Pros:**
+- [benefit 1]
+- [benefit 2]
+
+❌ **Cons:**
+- [drawback 1]
+
+📊 **Effort:** Low | Medium | High
+
+---
+
+### Option B: [Name]
+[Description]
+
+✅ **Pros:**
+- [benefit 1]
+
+❌ **Cons:**
+- [drawback 1]
+- [drawback 2]
+
+📊 **Effort:** Low | Medium | High
+
+---
+
+### Option C: [Name]
+[Description]
+
+✅ **Pros:**
+- [benefit 1]
+
+❌ **Cons:**
+- [drawback 1]
+
+📊 **Effort:** Low | Medium | High
+
+---
+
+## 💡 Recommendation
+
+**Option [X]** because [reasoning].
+
+What direction would you like to explore?
+```
+
+---
+
+## Examples
+
+```
+/brainstorm authentication system
+/brainstorm state management for complex form
+/brainstorm database schema for social app
+/brainstorm caching strategy
+```
+
+---
+
+## Key Principles
+
+- **No code** - this is about ideas, not implementation
+- **Visual when helpful** - use diagrams for architecture
+- **Honest tradeoffs** - don't hide complexity
+- **Defer to user** - present options, let them decide

package/dist/workflows/create.md

@@ -0,0 +1,60 @@
+---
+description: Create new application command. Triggers App Builder skill and starts interactive dialogue with user.
+---
+
+# /create - Create Application
+
+$ARGUMENTS
+
+---
+
+## Task
+
+This command starts a new application creation process.
+
+### Steps
+
+1. **Request Analysis**
+   - Understand what the user wants
+   - If information is missing, use `conversation-manager` skill to ask
+
+2. **Project Planning**
+   - Use `project-planner` agent for task breakdown
+   - Determine tech stack
+   - Plan file structure
+   - Create plan file and proceed to building
+
+3. **Application Building (After Approval)**
+   - Orchestrate with `app-builder` skill
+   - Coordinate expert agents:
+     - `database-architect` → Schema
+     - `backend-specialist` → API
+     - `frontend-specialist` → UI
+
+4. **Preview**
+   - Start with `auto_preview.py` when complete
+   - Present URL to user
+
+---
+
+## Usage Examples
+
+```
+/create blog site
+/create e-commerce app with product listing and cart
+/create todo app
+/create Instagram clone
+/create crm system with customer management
+```
+
+---
+
+## Before Starting
+
+If request is unclear, ask these questions:
+
+- What type of application?
+- What are the basic features?
+- Who will use it?
+
+Use defaults, add details later.

package/dist/workflows/debug.md

@@ -0,0 +1,107 @@
+---
+description: Debugging command. Activates DEBUG mode for systematic problem investigation.
+---
+
+# /debug - Systematic Problem Investigation
+
+$ARGUMENTS
+
+---
+
+## Purpose
+
+This command activates DEBUG mode for systematic investigation of issues, errors, or unexpected behavior.
+
+---
+
+## Behavior
+
+When `/debug` is triggered:
+
+1. **Gather information**
+   - Error message
+   - Reproduction steps
+   - Expected vs actual behavior
+   - Recent changes
+
+2. **Form hypotheses**
+   - List possible causes
+   - Order by likelihood
+
+3. **Investigate systematically**
+   - Test each hypothesis
+   - Check logs, data flow
+   - Use elimination method
+
+4. **Fix and prevent**
+   - Apply fix
+   - Explain root cause
+   - Add prevention measures
+
+---
+
+## Output Format
+
+```markdown
+## 🔍 Debug: [Issue]
+
+### 1. Symptom
+[What's happening]
+
+### 2. Information Gathered
+- Error: `[error message]`
+- File: `[filepath]`
+- Line: [line number]
+
+### 3. Hypotheses
+1. ❓ [Most likely cause]
+2. ❓ [Second possibility]
+3. ❓ [Less likely cause]
+
+### 4. Investigation
+
+**Testing hypothesis 1:**
+[What I checked] → [Result]
+
+**Testing hypothesis 2:**
+[What I checked] → [Result]
+
+### 5. Root Cause
+🎯 **[Explanation of why this happened]**
+
+### 6. Fix
+```[language]
+// Before
+[broken code]
+
+// After
+[fixed code]
+```
+
+### 7. Prevention
+
+🛡️ [How to prevent this in the future]
+
+```
+
+---
+
+## Examples
+
+```
+
+/debug login not working
+/debug API returns 500
+/debug form doesn't submit
+/debug data not saving
+
+```
+
+---
+
+## Key Principles
+
+- **Ask before assuming** - get full error context
+- **Test hypotheses** - don't guess randomly
+- **Explain why** - not just what to fix
+- **Prevent recurrence** - add tests, validation