skill-linker 2.0.0 → 3.0.0

package/src/utils/agents.js

@@ -0,0 +1,91 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Supported AI Agent configurations
+ * Format: { name, projectDir, globalDir }
+ */
+const AGENTS = [
+    {
+        name: 'Claude Code',
+        projectDir: '.claude/skills',
+        globalDir: path.join(os.homedir(), '.claude/skills')
+    },
+    {
+        name: 'GitHub Copilot',
+        projectDir: '.github/skills',
+        globalDir: path.join(os.homedir(), '.copilot/skills')
+    },
+    {
+        name: 'Google Antigravity',
+        projectDir: '.agent/skills',
+        globalDir: path.join(os.homedir(), '.gemini/antigravity/skills')
+    },
+    {
+        name: 'Cursor',
+        projectDir: '.cursor/skills',
+        globalDir: path.join(os.homedir(), '.cursor/skills')
+    },
+    {
+        name: 'OpenCode',
+        projectDir: '.opencode/skill',
+        globalDir: path.join(os.homedir(), '.config/opencode/skill')
+    },
+    {
+        name: 'OpenAI Codex',
+        projectDir: '.codex/skills',
+        globalDir: path.join(os.homedir(), '.codex/skills')
+    },
+    {
+        name: 'Gemini CLI',
+        projectDir: '.gemini/skills',
+        globalDir: path.join(os.homedir(), '.gemini/skills')
+    },
+    {
+        name: 'Windsurf',
+        projectDir: '.windsurf/skills',
+        globalDir: path.join(os.homedir(), '.codeium/windsurf/skills')
+    }
+];
+
+/**
+ * Detect which agents are installed on the system
+ * @returns {Array} List of detected agent indices
+ */
+function detectInstalledAgents() {
+    const installed = [];
+
+    AGENTS.forEach((agent, index) => {
+        // Check if global directory exists
+        if (fs.existsSync(agent.globalDir)) {
+            installed.push(index);
+        }
+    });
+
+    return installed;
+}
+
+/**
+ * Get agent configuration by index
+ * @param {number} index
+ * @returns {Object} Agent configuration
+ */
+function getAgent(index) {
+    return AGENTS[index];
+}
+
+/**
+ * Get all agents
+ * @returns {Array} All agent configurations
+ */
+function getAllAgents() {
+    return AGENTS;
+}
+
+module.exports = {
+    AGENTS,
+    detectInstalledAgents,
+    getAgent,
+    getAllAgents
+};

package/src/utils/file-system.js

@@ -0,0 +1,166 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Check if a directory exists
+ * @param {string} dirPath
+ * @returns {boolean}
+ */
+function dirExists(dirPath) {
+    try {
+        return fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory();
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Ensure directory exists (create if not)
+ * @param {string} dirPath
+ */
+function ensureDir(dirPath) {
+    if (!dirExists(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+
+/**
+ * Create a symbolic link
+ * @param {string} source - Source path
+ * @param {string} target - Target symlink path
+ * @returns {boolean} Success status
+ */
+function createSymlink(source, target) {
+    try {
+        // Remove existing link/file if present
+        if (fs.existsSync(target) || fs.lstatSync(target).isSymbolicLink()) {
+            fs.unlinkSync(target);
+        }
+
+        fs.symlinkSync(source, target, 'dir');
+        return true;
+    } catch (error) {
+        console.error(`Failed to create symlink: ${error.message}`);
+        return false;
+    }
+}
+
+/**
+ * List directories in a path
+ * @param {string} dirPath
+ * @returns {Array<string>} List of directory names
+ */
+function listDirectories(dirPath) {
+    if (!dirExists(dirPath)) {
+        return [];
+    }
+
+    try {
+        return fs.readdirSync(dirPath)
+            .filter(item => {
+                const fullPath = path.join(dirPath, item);
+                return fs.statSync(fullPath).isDirectory();
+            });
+    } catch {
+        return [];
+    }
+}
+
+
+/**
+ * Find all repositories in library
+ * @param {string} libPath - Library root path
+ * @returns {Array<{name: string, path: string, owner: string, repo: string, hasSkillsDir: boolean}>}
+ */
+function findRepos(libPath) {
+    if (!dirExists(libPath)) {
+        return [];
+    }
+
+    const repos = [];
+
+    // Scan owner directories
+    const owners = listDirectories(libPath);
+
+    for (const owner of owners) {
+        const ownerPath = path.join(libPath, owner);
+        const repoList = listDirectories(ownerPath);
+
+        for (const repo of repoList) {
+            const repoPath = path.join(ownerPath, repo);
+            const skillsDir = path.join(repoPath, 'skills');
+
+            repos.push({
+                name: `${owner}/${repo}`,
+                path: repoPath,
+                owner,
+                repo,
+                hasSkillsDir: dirExists(skillsDir)
+            });
+        }
+    }
+
+    return repos;
+}
+
+/**
+ * Find all skill directories in library
+ * @param {string} libPath - Library root path
+ * @returns {Array<{name: string, path: string, owner: string, repo: string}>}
+ */
+function findSkills(libPath) {
+    if (!dirExists(libPath)) {
+        return [];
+    }
+
+    const skills = [];
+
+    // Scan owner directories
+    const owners = listDirectories(libPath);
+
+    for (const owner of owners) {
+        const ownerPath = path.join(libPath, owner);
+        const repos = listDirectories(ownerPath);
+
+        for (const repo of repos) {
+            const repoPath = path.join(ownerPath, repo);
+
+            // Check if this repo has a skills/ subdirectory
+            const skillsDir = path.join(repoPath, 'skills');
+
+            if (dirExists(skillsDir)) {
+                // Multi-skill repo
+                const subSkills = listDirectories(skillsDir);
+
+                for (const skill of subSkills) {
+                    skills.push({
+                        name: `${owner}/${repo}/${skill}`,
+                        path: path.join(skillsDir, skill),
+                        owner,
+                        repo,
+                        skill
+                    });
+                }
+            } else {
+                // Single skill repo
+                skills.push({
+                    name: `${owner}/${repo}`,
+                    path: repoPath,
+                    owner,
+                    repo
+                });
+            }
+        }
+    }
+
+    return skills;
+}
+
+module.exports = {
+    dirExists,
+    ensureDir,
+    createSymlink,
+    listDirectories,
+    findRepos,
+    findSkills
+};

package/src/utils/git.js

@@ -0,0 +1,108 @@
+const execa = require('execa');
+const path = require('path');
+const os = require('os');
+const { dirExists } = require('./file-system');
+
+const DEFAULT_LIB_PATH = path.join(os.homedir(), 'Documents/AgentSkills');
+
+/**
+ * Parse GitHub URL to extract owner, repo, branch, and subpath
+ * @param {string} url - GitHub URL
+ * @returns {Object} Parsed components
+ */
+function parseGitHubUrl(url) {
+    let cleanUrl = url;
+    let subpath = '';
+    let branch = 'main';
+
+    // Check for /tree/branch/path format
+    const treeMatch = url.match(/(.+)\/tree\/([^/]+)\/(.+)$/);
+    if (treeMatch) {
+        cleanUrl = treeMatch[1];
+        branch = treeMatch[2];
+        subpath = treeMatch[3];
+    }
+
+    // Extract owner/repo
+    const repoMatch = cleanUrl.match(/github\.com[/:]([^/]+)\/([^/]+?)(\.git)?$/);
+
+    if (!repoMatch) {
+        throw new Error('Invalid GitHub URL format');
+    }
+
+    return {
+        owner: repoMatch[1],
+        repo: repoMatch[2].replace('.git', ''),
+        branch,
+        subpath,
+        cleanUrl
+    };
+}
+
+/**
+ * Clone a GitHub repository
+ * @param {string} url - GitHub URL
+ * @param {string} targetPath - Target directory
+ * @returns {Promise<void>}
+ */
+async function cloneRepo(url, targetPath) {
+    try {
+        await execa('git', ['clone', url, targetPath]);
+    } catch (error) {
+        throw new Error(`Failed to clone repository: ${error.message}`);
+    }
+}
+
+/**
+ * Pull latest changes in a repository
+ * @param {string} repoPath - Path to repository
+ * @returns {Promise<void>}
+ */
+async function pullRepo(repoPath) {
+    try {
+        await execa('git', ['-C', repoPath, 'pull']);
+    } catch (error) {
+        throw new Error(`Failed to pull repository: ${error.message}`);
+    }
+}
+
+/**
+ * Clone or update a GitHub repository
+ * @param {string} url - GitHub URL
+ * @returns {Promise<{skillPath: string, needsUpdate: boolean}>}
+ */
+async function cloneOrUpdateRepo(url) {
+    const parsed = parseGitHubUrl(url);
+    const targetPath = path.join(DEFAULT_LIB_PATH, parsed.owner, parsed.repo);
+
+    let needsUpdate = false;
+
+    if (dirExists(targetPath)) {
+        // Repo exists, ask if user wants to update
+        needsUpdate = true;
+    } else {
+        // Clone new repo
+        await cloneRepo(parsed.cleanUrl, targetPath);
+    }
+
+    // Determine final skill path
+    let skillPath = targetPath;
+    if (parsed.subpath) {
+        skillPath = path.join(targetPath, parsed.subpath);
+    }
+
+    return {
+        skillPath,
+        targetPath,
+        needsUpdate,
+        hasSubpath: !!parsed.subpath
+    };
+}
+
+module.exports = {
+    DEFAULT_LIB_PATH,
+    parseGitHubUrl,
+    cloneRepo,
+    pullRepo,
+    cloneOrUpdateRepo
+};