skill-search 0.0.1

package/src/actions.js

@@ -0,0 +1,216 @@
+
+const fs = require('fs');
+const path = require('path');
+const { promisify } = require('util');
+const api = require('./api');
+const store = require('./store');
+const { crawlLocalSkills } = require('./localCrawler');
+
+const stat = promisify(fs.stat);
+const mkdir = promisify(fs.mkdir);
+const readdir = promisify(fs.readdir);
+const copyFile = promisify(fs.copyFile);
+const rename = promisify(fs.rename);
+const rm = promisify(fs.rm);
+
+/**
+ * Recursive Copy Helper
+ */
+async function copyRecursive(src, dest) {
+    const stats = await stat(src);
+    if (stats.isDirectory()) {
+        await mkdir(dest, { recursive: true });
+        const entries = await readdir(src);
+        for (const entry of entries) {
+            await copyRecursive(path.join(src, entry), path.join(dest, entry));
+        }
+    } else {
+        await copyFile(src, dest);
+    }
+}
+
+/**
+ * Handle Actions
+ * @param {string} action - 'sync', 'move', 'delete'
+ * @param {object} item - The selected item object
+ * @param {string} pane - 'local' or 'remote'
+ * @param {number} level - 1 (Provider/Repo) or 2 (Skill)
+ * @param {object} extra - Extra params like { targetPath, allRemoteSkills }
+ */
+async function performAction(action, item, pane, level, extra = {}) {
+    try {
+        if (pane === 'local') {
+            await handleLocalAction(action, item, level, extra);
+        } else if (pane === 'remote') {
+            await handleRemoteAction(action, item, level, extra);
+        }
+        return { success: true };
+    } catch (err) {
+        console.error(`Action failed: ${err.message}`);
+        return { success: false, error: err.message };
+    }
+}
+
+/**
+ * Handle Local Actions
+ */
+async function handleLocalAction(action, item, level, { targetPath }) {
+    let srcPath = item.path;
+
+    // Determine actual source path based on level
+    if (level === 1) {
+        // item.path point to the skill folder, e.g. .../provider/skill
+        // We want the PROVIDER folder, e.g. .../provider
+        // However, we must be careful. App.js calculates providerPath as:
+        // const providerPath = item.path.split(/[\\/]skills[\\/]/)[0]; 
+        // Wait, localCrawler returns: .../provider/skills/skillFolder for item.path?
+        // Let's check localCrawler again.
+        // localCrawler: path.join(childPath, 'skills') -> .../provider/skills
+        // item.path = path.join(skillsPath, skillFolder) -> .../provider/skills/skillFolder
+        // So valid parent is .../provider/skills or .../provider?
+        // User says "Level 1 name's path". Level 1 name is Provider.
+        // If Provider is ".claude", folder is ~/.claude.
+        // But the skills are in ~/.claude/skills.
+        // If I move ~/.claude, I move everything.
+        // If I sync ~/.claude, I sync everything.
+        // Let's assume we target the "skills container" or the "provider root"?
+        // Usually syncing a provider means syncing all its skills.
+        // I will target the `.../provider/skills` folder generally, or the provider root if requested.
+        // Given complexity, let's target the *directory containing the skills* if level 1?
+        // Or better: Re-read `item.path`.
+        // If item.path is `.../skills/skillname`.
+        // Level 1 (Provider) logic:
+        // We should operate on `path.dirname(item.path)`? That is `.../skills`.
+        // That contains ALL skills for that provider. That seems correct for "Level 1" (Provider).
+        srcPath = path.dirname(srcPath);
+    }
+
+    if (action === 'sync') {
+        // Copy to ~/.skill-search/skills/...
+        // Destination:
+        // If Level 2: ~/.skill-search/skills/<id> (or <provider>/<id>?)
+        // Store uses `store.getFullSkillPath(id)`. This usually puts it in `~/.skill-search/skills/<id>`.
+        // BUT if we sync Level 1 (multiple skills), we should preserve their IDs.
+
+        if (level === 1) {
+            // Sync all skills in this provider folder
+            const entries = await readdir(srcPath);
+            for (const entry of entries) {
+                const childPath = path.join(srcPath, entry);
+                const childStat = await stat(childPath);
+                if (childStat.isDirectory()) {
+                    // It's a skill folder
+                    const skillId = entry; // Use folder name as ID
+                    const destDir = store.getFullSkillPath(skillId);
+                    await copyRecursive(childPath, destDir);
+                }
+            }
+        } else {
+            // Level 2: Sync single skill
+            const skillId = item.id || path.basename(item.path);
+            const destDir = store.getFullSkillPath(skillId);
+            await copyRecursive(srcPath, destDir);
+        }
+
+    } else if (action === 'move') {
+        if (!targetPath) throw new Error('Target path required for move');
+
+        // Move srcPath to targetPath
+        // Ensure target directory exists? Or is targetPath the full new path?
+        // Usually "Move to directory".
+        // If targetPath is `/tmp`, and we move `skill1`, result is `/tmp/skill1`.
+
+        const destPath = path.join(targetPath, path.basename(srcPath));
+        await mkdir(targetPath, { recursive: true });
+        await rename(srcPath, destPath);
+
+    } else if (action === 'delete') {
+        await rm(srcPath, { recursive: true, force: true });
+    }
+}
+
+/**
+ * Handle Remote Actions
+ */
+async function handleRemoteAction(action, item, level, { allRemoteSkills }) {
+    if (action !== 'sync') return; // Remote only supports sync
+
+    if (level === 1) {
+        // Sync Level 1: "Owner/Repo"
+        // We need to find all skills that belong to this Repo/Provider.
+        // We can filter `allRemoteSkills` (which we should pass from App state).
+
+        let skillsToSync = [];
+        const providerName = item.provider;
+        const repoName = getRepoNameFromUrl(item.githubUrl || item.url);
+
+        if (allRemoteSkills && repoName) {
+            skillsToSync = allRemoteSkills.filter(s => {
+                const sRepo = getRepoNameFromUrl(s.githubUrl || s.url);
+                return sRepo === repoName;
+            });
+        }
+
+        if (skillsToSync.length === 0) {
+            // Fallback: just sync the current item if we can't find others
+            skillsToSync = [item];
+        }
+
+        for (const skill of skillsToSync) {
+            await syncSingleRemoteSkill(skill);
+        }
+
+    } else {
+        // Level 2: Sync single skill
+        await syncSingleRemoteSkill(item);
+    }
+}
+
+function getRepoNameFromUrl(url) {
+    if (!url) return null;
+    const match = url.match(/github\.com\/([^\/]+\/[^\/]+)/);
+    return match ? match[1] : null;
+}
+
+async function syncSingleRemoteSkill(skill) {
+    if (!skill.githubUrl) return;
+
+    // Determine custom folder name: owner.repo.skillName
+    let folderName = skill.id;
+
+    // Parse GitHub URL to construct nested path
+    const parsed = api.parseGitHubUrl(skill.githubUrl);
+    if (parsed) {
+        // skill.githubUrl path part ends with the skill folder name
+        const skillName = parsed.path.split('/').pop();
+        // Construct: owner.repo.skillName (Flat folder structure)
+        folderName = `${parsed.owner}.${parsed.repo}.${skillName}`;
+    }
+
+    // Download logic using api - ensure relative paths are preserved
+    await api.fetchGitHubDirectoryRecursive(skill.githubUrl, (file) => {
+        // file.path comes from fetchGitHubDirectoryRecursive relative to the skill root
+        store.setSkillFileByFolder(folderName, file.path, file.content);
+    });
+
+    // Update Local Index
+    const index = store.getIndex();
+    if (!index.skills) index.skills = [];
+
+    // Remove existing entry for this ID to update it
+    const existingIdx = index.skills.findIndex(s => s.id === skill.id);
+    if (existingIdx !== -1) {
+        index.skills.splice(existingIdx, 1);
+    }
+
+    // Add new entry with localFolder
+    index.skills.push({
+        ...skill,
+        localFolder: folderName,
+        syncedAt: new Date().toISOString()
+    });
+
+    store.setIndex(index);
+}
+
+module.exports = { performAction };

package/src/api.js

@@ -0,0 +1,306 @@
+// src/api.js
+// SkillsMP API Client
+
+const axios = require('axios');
+const chalk = require('chalk');
+const config = require('./config');
+
+// Create axios instance
+function createClient() {
+    const apiKey = config.getApiKey();
+    const baseUrl = config.getApiBaseUrl();
+
+    return axios.create({
+        baseURL: baseUrl,
+        timeout: 30000,
+        headers: {
+            'Authorization': apiKey ? `Bearer ${apiKey}` : '',
+            'Content-Type': 'application/json',
+            'User-Agent': 'skill-cli/1.0.0'
+        }
+    });
+}
+
+/**
+ * Search Skills
+ * @param {string} query - Search keyword
+ * @param {object} options - Search options
+ */
+async function searchSkills(query, options = {}) {
+    const client = createClient();
+    const params = {
+        q: query,
+        page: options.page || 1,
+        limit: options.limit || 20,
+        sortBy: options.sortBy || 'recent',
+        marketplaceOnly: options.marketplaceOnly || false
+    };
+
+    try {
+        const response = await client.get('/skills/search', { params });
+
+        if (response.data.success) {
+            return response.data.data;
+        } else {
+            throw new Error(response.data.message || 'Search failed');
+        }
+    } catch (error) {
+        handleApiError(error);
+    }
+}
+
+/**
+ * Get Skill Details
+ * @param {string} id - Skill ID
+ */
+async function getSkill(id) {
+    const client = createClient();
+
+    try {
+        const response = await client.get(`/skills/${encodeURIComponent(id)}`);
+
+        if (response.data.success) {
+            return response.data.data;
+        } else {
+            throw new Error(response.data.message || 'Failed to get skill');
+        }
+    } catch (error) {
+        handleApiError(error);
+    }
+}
+
+/**
+ * List All Skills (Pagination)
+ * @param {number} page - Page number
+ * @param {number} limit - Items per page
+ */
+async function listSkills(page = 1, limit = 20) {
+    const client = createClient();
+    const params = { page, limit, sortBy: 'recent' };
+
+    try {
+        const response = await client.get('/skills', { params });
+
+        if (response.data.success) {
+            return response.data.data;
+        } else {
+            throw new Error(response.data.message || 'Failed to get list');
+        }
+    } catch (error) {
+        handleApiError(error);
+    }
+}
+
+/**
+ * Fetch All Skills (For Sync)
+ * Iterates through all pages
+ */
+async function fetchAllSkills(onProgress) {
+    const allSkills = [];
+    let page = 1;
+    let hasNext = true;
+
+    while (hasNext) {
+        const result = await listSkills(page, 100); // Fetch 100 per request
+        allSkills.push(...result.skills);
+
+        if (onProgress) {
+            onProgress({
+                current: allSkills.length,
+                total: result.pagination.total,
+                page: page
+            });
+        }
+
+        hasNext = result.pagination.hasNext;
+        page++;
+    }
+
+    return allSkills;
+}
+
+/**
+ * Fetch SKILL.md Content from GitHub URL
+ * @param {string} githubUrl - GitHub Directory URL
+ */
+async function fetchSkillContent(githubUrl) {
+    // Parse GitHub URL
+    // https://github.com/davila7/claude-code-templates/tree/main/cli-tool/.../seo-optimizer
+    const parsed = parseGitHubUrl(githubUrl);
+    if (!parsed) {
+        throw new Error('Could not parse GitHub URL');
+    }
+
+    // Construct raw URL to get SKILL.md
+    const rawUrl = `https://raw.githubusercontent.com/${parsed.owner}/${parsed.repo}/${parsed.branch}/${parsed.path}/SKILL.md`;
+
+    try {
+        const response = await axios.get(rawUrl, { timeout: 15000 });
+        return response.data;
+    } catch (error) {
+        if (error.response?.status === 404) {
+            throw new Error(`SKILL.md not found: ${parsed.path}`);
+        }
+        throw error;
+    }
+}
+
+/**
+ * Fetch GitHub Directory (For --full sync)
+ * @param {string} githubUrl - GitHub Directory URL
+ */
+async function fetchGitHubDirectory(githubUrl) {
+    const parsed = parseGitHubUrl(githubUrl);
+    if (!parsed) {
+        throw new Error('Could not parse GitHub URL');
+    }
+
+    // Use GitHub Contents API
+    const apiUrl = `https://api.github.com/repos/${parsed.owner}/${parsed.repo}/contents/${parsed.path}`;
+
+    try {
+        const response = await axios.get(apiUrl, {
+            headers: {
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'skill-cli'
+            },
+            timeout: 15000
+        });
+
+        return {
+            parsed,
+            contents: response.data
+        };
+    } catch (error) {
+        if (error.response?.status === 404) {
+            throw new Error(`Directory not found: ${parsed.path}`);
+        }
+        if (error.response?.status === 403) {
+            throw new Error('GitHub API rate limit exceeded. Please try again later.');
+        }
+        throw error;
+    }
+}
+
+/**
+ * Recursively Fetch All Files in GitHub Directory
+ * @param {string} githubUrl - GitHub Directory URL
+ * @param {function} onFile - File callback
+ * @param {string} [rootPath] - The original skill root path (used internally for recursion)
+ */
+async function fetchGitHubDirectoryRecursive(githubUrl, onFile, rootPath = null) {
+    const { parsed, contents } = await fetchGitHubDirectory(githubUrl);
+    const files = [];
+
+    // On the first call, rootPath is null, so we set it to parsed.path (the skill root)
+    // On recursive calls, rootPath is passed through unchanged
+    const effectiveRootPath = rootPath !== null ? rootPath : parsed.path;
+
+    for (const item of contents) {
+        if (item.type === 'file') {
+            // Download file content
+            try {
+                const response = await axios.get(item.download_url, { timeout: 15000 });
+
+                // Calculate relative path from the ORIGINAL skill root (effectiveRootPath)
+                // Example:
+                //   effectiveRootPath = "plugins/claude-code-setup/skills/claude-automation-recommender"
+                //   item.path = "plugins/claude-code-setup/skills/claude-automation-recommender/references/foo.md"
+                //   Result: "references/foo.md"
+                let relativePath = item.path;
+                if (item.path.startsWith(effectiveRootPath)) {
+                    relativePath = item.path.slice(effectiveRootPath.length);
+                    // Remove leading slash if present
+                    if (relativePath.startsWith('/')) {
+                        relativePath = relativePath.slice(1);
+                    }
+                }
+
+                const file = {
+                    name: item.name,
+                    path: relativePath,
+                    content: response.data,
+                    size: item.size
+                };
+                files.push(file);
+
+                if (onFile) {
+                    onFile(file);
+                }
+            } catch (err) {
+                console.warn(chalk.yellow(`  ⚠ Skipping file: ${item.name}`));
+            }
+        } else if (item.type === 'dir') {
+            // Recursively fetch subdirectory, passing the ORIGINAL rootPath
+            const subUrl = `https://github.com/${parsed.owner}/${parsed.repo}/tree/${parsed.branch}/${item.path}`;
+            const subFiles = await fetchGitHubDirectoryRecursive(subUrl, onFile, effectiveRootPath);
+            files.push(...subFiles);
+        }
+    }
+
+    return files;
+}
+
+/**
+ * Parse GitHub URL
+ * @param {string} url - GitHub URL
+ */
+function parseGitHubUrl(url) {
+    // https://github.com/owner/repo/tree/branch/path/to/skill
+    const match = url.match(/github\.com\/([^\/]+)\/([^\/]+)\/tree\/([^\/]+)\/(.+)/);
+
+    if (match) {
+        return {
+            owner: match[1],
+            repo: match[2],
+            branch: match[3],
+            path: match[4]
+        };
+    }
+
+    return null;
+}
+
+/**
+ * Handle API Error
+ */
+function handleApiError(error) {
+    if (error.response) {
+        const status = error.response.status;
+        const message = error.response.data?.message || error.message;
+
+        switch (status) {
+            case 401:
+                throw new Error('Invalid API Key.\nPlease run: skill config --api-key <your-key>');
+            case 403:
+                throw new Error('API request denied. Check API Key permissions.');
+            case 404:
+                throw new Error('Resource not found');
+            case 429:
+                throw new Error('API rate limit exceeded. Please try again later.');
+            default:
+                throw new Error(`API Request Failed (${status}): ${message}`);
+        }
+    }
+
+    if (error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND') {
+        throw new Error('Network connection failed');
+    }
+
+    if (error.code === 'ETIMEDOUT') {
+        throw new Error('Request timed out');
+    }
+
+    throw error;
+}
+
+module.exports = {
+    searchSkills,
+    getSkill,
+    listSkills,
+    fetchAllSkills,
+    fetchSkillContent,
+    fetchGitHubDirectory,
+    fetchGitHubDirectoryRecursive,
+    parseGitHubUrl
+};

package/src/cache.js

@@ -0,0 +1,107 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const chalk = require('chalk');
+
+const CACHE_DIR = path.join(os.homedir(), '.skill-cache');
+const DEFAULT_TTL = 24 * 60 * 60 * 1000; // 24 hours
+
+// Ensure cache directory exists
+if (!fs.existsSync(CACHE_DIR)) {
+    try {
+        fs.mkdirSync(CACHE_DIR, { recursive: true });
+    } catch (err) {
+        console.error(chalk.red('Failed to create cache directory: ' + err.message));
+    }
+}
+
+class Cache {
+    constructor() {
+        this.dir = CACHE_DIR;
+    }
+
+    getFilePath(key) {
+        // Sanitize key to be safe for filename
+        const safeKey = key.replace(/[^a-z0-9_-]/gi, '_');
+        return path.join(this.dir, `${safeKey}.json`);
+    }
+
+    get(key) {
+        try {
+            const file = this.getFilePath(key);
+            if (!fs.existsSync(file)) return null;
+
+            const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+
+            // Check expiry
+            if (Date.now() > data.expireAt) {
+                fs.unlinkSync(file); // Delete expired
+                return null;
+            }
+
+            return data.content;
+        } catch (err) {
+            return null;
+        }
+    }
+
+    set(key, content, ttl = DEFAULT_TTL) {
+        try {
+            const file = this.getFilePath(key);
+            const data = {
+                content,
+                expireAt: Date.now() + ttl,
+                timestamp: Date.now()
+            };
+            fs.writeFileSync(file, JSON.stringify(data, null, 2));
+        } catch (err) {
+            console.error(chalk.yellow('Failed to write cache: ' + err.message));
+        }
+    }
+
+    clear() {
+        try {
+            fs.rmSync(this.dir, { recursive: true, force: true });
+            fs.mkdirSync(this.dir);
+        } catch (err) {
+            console.error(chalk.red('Failed to clear cache: ' + err.message));
+        }
+    }
+
+    list() {
+        try {
+            return fs.readdirSync(this.dir)
+                .filter(f => f.endsWith('.json'))
+                .map(f => f.replace('.json', ''));
+        } catch (err) {
+            return [];
+        }
+    }
+
+    clearExpired() {
+        try {
+            const files = fs.readdirSync(this.dir);
+            let count = 0;
+            for (const file of files) {
+                if (!file.endsWith('.json')) continue;
+                const filePath = path.join(this.dir, file);
+                try {
+                    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+                    if (Date.now() > data.expireAt) {
+                        fs.unlinkSync(filePath);
+                        count++;
+                    }
+                } catch (e) {
+                    // Corrupt file, delete
+                    fs.unlinkSync(filePath);
+                }
+            }
+            return count;
+        } catch (err) {
+            console.error(chalk.red('Failed to clear expired cache: ' + err.message));
+            return 0;
+        }
+    }
+}
+
+module.exports = new Cache();