skill-search 0.0.1

package/src/config.js

@@ -0,0 +1,220 @@
+// src/config.js
+// SkillsMP API Configuration
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Data Directory
+const DATA_DIR = path.join(os.homedir(), '.skill-search');
+const CONFIG_FILE = path.join(DATA_DIR, 'config.json');
+
+// Default Configuration
+const DEFAULT_CONFIG = {
+    api: {
+        baseUrl: 'https://skillsmp.com/api/v1',
+        // API Key should be configured by user
+        apiKey: process.env.SKILLSMP_API_KEY || ''
+    },
+    sync: {
+        defaultLimit: 20,
+        sortBy: 'recent',
+        marketplaceOnly: false
+    },
+    customPaths: [], // Custom paths to scan for skills
+    cache: {
+        ttl: 24 * 60 * 60 * 1000, // 24 hours
+        indexTtl: 7 * 24 * 60 * 60 * 1000 // 7 days
+    }
+};
+
+/**
+ * Ensure data directory exists
+ */
+function ensureDataDir() {
+    if (!fs.existsSync(DATA_DIR)) {
+        fs.mkdirSync(DATA_DIR, { recursive: true });
+    }
+}
+
+/**
+ * Get user configuration
+ */
+function getUserConfig() {
+    ensureDataDir();
+
+    if (fs.existsSync(CONFIG_FILE)) {
+        try {
+            const content = fs.readFileSync(CONFIG_FILE, 'utf8');
+            return { ...DEFAULT_CONFIG, ...JSON.parse(content) };
+        } catch (err) {
+            return DEFAULT_CONFIG;
+        }
+    }
+    return DEFAULT_CONFIG;
+}
+
+/**
+ * Set user configuration
+ */
+function setUserConfig(config) {
+    ensureDataDir();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Get API Base URL
+ */
+function getApiBaseUrl() {
+    const config = getUserConfig();
+    return config.api.baseUrl;
+}
+
+/**
+ * Get API Key
+ */
+function getApiKey() {
+    const config = getUserConfig();
+    return config.api.apiKey || process.env.SKILLSMP_API_KEY || '';
+}
+
+/**
+ * Set API Key
+ */
+function setApiKey(apiKey) {
+    const config = getUserConfig();
+    config.api.apiKey = apiKey;
+    setUserConfig(config);
+}
+
+/**
+ * Get data directory path
+ */
+function getDataDir() {
+    ensureDataDir();
+    return DATA_DIR;
+}
+
+// Default primary directory name (without leading dot)
+const DEFAULT_PRIMARY_DIR = 'skill-search';
+
+// Available primary directory options
+const AVAILABLE_PRIMARY_DIRS = [
+    { key: 'skill-search', name: '.skill-search', desc: 'Default Skill Search directory' },
+    { key: 'claude', name: '.claude', desc: 'Claude AI directory' },
+    { key: 'codex', name: '.codex', desc: 'OpenAI Codex directory' },
+    { key: 'gemini', name: '.gemini', desc: 'Google Gemini directory' },
+    { key: 'copilot', name: '.copilot', desc: 'GitHub Copilot directory' }
+];
+
+/**
+ * Get primary directory name (the key, not the full path)
+ */
+function getPrimaryDirName() {
+    const config = getUserConfig();
+    return config.primaryDir || DEFAULT_PRIMARY_DIR;
+}
+
+/**
+ * Get primary directory full path
+ */
+function getPrimaryDirPath() {
+    const dirName = getPrimaryDirName();
+    return path.join(os.homedir(), '.' + dirName);
+}
+
+/**
+ * Set primary directory
+ */
+function setPrimaryDir(dirKey) {
+    const config = getUserConfig();
+    config.primaryDir = dirKey;
+    setUserConfig(config);
+}
+
+/**
+ * Get various file paths (uses primary directory)
+ */
+function getPaths() {
+    const dataDir = getPrimaryDirPath();
+    // Ensure data dir exists
+    if (!fs.existsSync(dataDir)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+    }
+    return {
+        dataDir,
+        indexFile: path.join(dataDir, 'index.json'),
+        metaFile: path.join(dataDir, 'meta.json'),
+        configFile: CONFIG_FILE, // Config file stays in .skill-search
+        docsDir: path.join(dataDir, 'docs'),
+        skillsDir: path.join(dataDir, 'skills')
+    };
+}
+
+/**
+ * Get available primary directories
+ */
+function getAvailablePrimaryDirs() {
+    return AVAILABLE_PRIMARY_DIRS;
+}
+
+/**
+ * Get custom paths
+ */
+function getCustomPaths() {
+    const config = getUserConfig();
+    return config.customPaths || [];
+}
+
+/**
+ * Add a custom path
+ */
+function addCustomPath(customPath) {
+    const config = getUserConfig();
+    if (!config.customPaths) {
+        config.customPaths = [];
+    }
+    // Avoid duplicates
+    if (!config.customPaths.includes(customPath)) {
+        config.customPaths.push(customPath);
+        setUserConfig(config);
+        return true;
+    }
+    return false;
+}
+
+/**
+ * Remove a custom path
+ */
+function removeCustomPath(customPath) {
+    const config = getUserConfig();
+    if (!config.customPaths) return false;
+    const idx = config.customPaths.indexOf(customPath);
+    if (idx !== -1) {
+        config.customPaths.splice(idx, 1);
+        setUserConfig(config);
+        return true;
+    }
+    return false;
+}
+
+module.exports = {
+    DEFAULT_CONFIG,
+    DEFAULT_PRIMARY_DIR,
+    AVAILABLE_PRIMARY_DIRS,
+    ensureDataDir,
+    getUserConfig,
+    setUserConfig,
+    getApiBaseUrl,
+    getApiKey,
+    setApiKey,
+    getDataDir,
+    getPaths,
+    getPrimaryDirName,
+    getPrimaryDirPath,
+    setPrimaryDir,
+    getAvailablePrimaryDirs,
+    getCustomPaths,
+    addCustomPath,
+    removeCustomPath
+};

package/src/fallback-index.json

@@ -0,0 +1,6 @@
+{
+    "version": "1.0.0",
+    "updated": "2024-01-01T00:00:00Z",
+    "skills": [],
+    "categories": []
+}

package/src/interactive.js

@@ -0,0 +1,23 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+
+async function selectSkill(matches) {
+    if (!matches || matches.length === 0) return null;
+
+    const { selected } = await inquirer.prompt([{
+        type: 'list',
+        name: 'selected',
+        message: 'Multiple matches found, please select:',
+        choices: matches.map(m => ({
+            name: `${chalk.bold(m.id)} - ${m.name || m.description || ''}`,
+            value: m
+        })),
+        loop: false
+    }]);
+
+    return selected;
+}
+
+module.exports = {
+    selectSkill
+};

package/src/localCrawler.js

@@ -0,0 +1,204 @@
+// src/localCrawler.js
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { promisify } = require('util');
+const config = require('./config');
+
+const readdir = promisify(fs.readdir);
+const stat = promisify(fs.stat);
+
+/**
+ * Crawl local directories for skills
+ * Looks for patterns: ~/{folder}/{*skill*}/{skill}
+ * Matches any subfolder containing 'skill' in its name (case-insensitive):
+ *   - skills, skill, global_skills, etc.
+ */
+async function crawlLocalSkills() {
+    const homeDir = os.homedir();
+    const results = [];
+
+    let homeChildren;
+    try {
+        homeChildren = await readdir(homeDir);
+    } catch (e) {
+        return [];
+    }
+
+    // Scan all folders in home directory for subdirectories containing 'skill' in their name
+    // This matches: skills, skill, global_skills, etc. (case-insensitive)
+
+    for (const child of homeChildren) {
+        if (child === '.skill-search') continue; // Skip own data directory (handled by store)
+        const childPath = path.join(homeDir, child);
+
+        // Check if this is a directory
+        let childStats;
+        try {
+            childStats = await stat(childPath);
+        } catch (e) {
+            continue;
+        }
+        if (!childStats.isDirectory()) continue;
+
+        // List all subdirectories in this folder
+        let subfolders;
+        try {
+            subfolders = await readdir(childPath);
+        } catch (e) {
+            continue;
+        }
+
+        // Find all subdirectories containing 'skill' in their name (case-insensitive)
+        for (const subfolder of subfolders) {
+            // Check if subfolder name contains 'skill' (case-insensitive)
+            if (!subfolder.toLowerCase().includes('skill')) continue;
+
+            const skillsPath = path.join(childPath, subfolder);
+
+            // Check if this is a directory
+            let skillsStats;
+            try {
+                skillsStats = await stat(skillsPath);
+            } catch (e) {
+                continue;
+            }
+            if (!skillsStats.isDirectory()) continue;
+
+            // Found a skill-containing directory, list its content
+            const providerName = child; // e.g. .claude
+
+            let skillFolders;
+            try {
+                skillFolders = await readdir(skillsPath);
+            } catch (e) {
+                continue;
+            }
+
+            for (const skillFolder of skillFolders) {
+                // Ignore system files like .DS_Store
+                if (skillFolder.startsWith('.')) continue;
+
+                const skillPath = path.join(skillsPath, skillFolder);
+                try {
+                    const skillStats = await stat(skillPath);
+                    if (skillStats.isDirectory()) {
+                        results.push({
+                            id: skillFolder,
+                            name: skillFolder,
+                            provider: providerName, // "xxx" level 1
+                            path: skillPath,
+                            updatedAt: skillStats.mtime,
+                            source: 'local_scan',
+                            skillsFolder: subfolder // Track which skill folder this came from
+                        });
+                    }
+                } catch (e) { }
+            }
+        }
+    }
+
+
+    // Scan custom paths from config
+    const customPaths = config.getCustomPaths();
+    for (const customPath of customPaths) {
+        // Resolve ~ to home dir if needed
+        const resolvedPath = customPath.replace(/^~/, homeDir);
+
+        if (!fs.existsSync(resolvedPath)) continue;
+
+        let stats;
+        try {
+            stats = await stat(resolvedPath);
+        } catch (e) { continue; }
+
+        if (!stats.isDirectory()) continue;
+
+        const providerName = path.basename(resolvedPath);
+
+        let skillFolders;
+        try {
+            skillFolders = await readdir(resolvedPath);
+        } catch (e) { continue; }
+
+        for (const skillFolder of skillFolders) {
+            // Ignore system files like .DS_Store
+            if (skillFolder.startsWith('.')) continue;
+
+            const skillPath = path.join(resolvedPath, skillFolder);
+            try {
+                const skillStats = await stat(skillPath);
+                if (skillStats.isDirectory()) {
+                    results.push({
+                        id: skillFolder,
+                        name: skillFolder,
+                        provider: providerName,
+                        path: skillPath,
+                        updatedAt: skillStats.mtime,
+                        source: 'custom_path',
+                        skillsFolder: providerName // Use provider name as skills folder name
+                    });
+                }
+            } catch (e) { }
+        }
+    }
+
+    return results;
+}
+
+/**
+ * Scan home directory for any folders containing subdirectories with 'skill' in their name
+ * Returns list of directory names (e.g. ['.claude', '.codex', '.skill-search'])
+ */
+async function scanForSkillDirectories() {
+    const homeDir = os.homedir();
+    const results = [];
+
+    let homeChildren;
+    try {
+        homeChildren = await readdir(homeDir);
+    } catch (e) {
+        return [];
+    }
+
+    for (const child of homeChildren) {
+        const childPath = path.join(homeDir, child);
+
+        // Check if this is a directory first
+        let childStats;
+        try {
+            childStats = await stat(childPath);
+        } catch (e) {
+            continue;
+        }
+        if (!childStats.isDirectory()) continue;
+
+        // List subdirectories to find any containing 'skill' in their name
+        let subfolders;
+        try {
+            subfolders = await readdir(childPath);
+        } catch (e) {
+            continue;
+        }
+
+        // Check if any subfolder contains 'skill' in its name
+        for (const subfolder of subfolders) {
+            if (subfolder.toLowerCase().includes('skill')) {
+                const subfolderPath = path.join(childPath, subfolder);
+                try {
+                    const subfolderStats = await stat(subfolderPath);
+                    if (subfolderStats.isDirectory()) {
+                        results.push(child);
+                        break; // Found at least one skill folder, add this parent and move on
+                    }
+                } catch (e) {
+                    continue;
+                }
+            }
+        }
+    }
+
+    return results;
+}
+
+module.exports = { crawlLocalSkills, scanForSkillDirectories };

package/src/matcher.js

@@ -0,0 +1,170 @@
+const fs = require('fs');
+const path = require('path');
+const termStyles = require('./utils'); // Assuming needed or just remove if unrelated
+const Fuse = require('fuse.js');
+const store = require('./store');
+const config = require('./config');
+const { crawlLocalSkills } = require('./localCrawler');
+
+let fuseInstance = null;
+let skillsData = null;
+
+/**
+ * Scan all known skills directories (all available primary directories)
+ * This captures skills synced to any of the supported directories
+ */
+async function crawlStoreSkills() {
+    const results = [];
+    const availableDirs = config.getAvailablePrimaryDirs();
+    const os = require('os');
+
+    for (const dir of availableDirs) {
+        const dirPath = path.join(os.homedir(), dir.name, 'skills');
+
+        if (!fs.existsSync(dirPath)) {
+            continue;
+        }
+
+        try {
+            const folders = fs.readdirSync(dirPath);
+            for (const folder of folders) {
+                if (folder.startsWith('.')) continue; // Skip hidden files
+
+                const skillPath = path.join(dirPath, folder);
+                try {
+                    const stats = fs.statSync(skillPath);
+                    if (stats.isDirectory()) {
+                        results.push({
+                            id: folder,
+                            name: folder,
+                            provider: dir.name, // Use the actual directory name (.skill-search, .claude, etc.)
+                            path: skillPath,
+                            updatedAt: stats.mtime,
+                            source: 'store_scan'
+                        });
+                    }
+                } catch (e) { }
+            }
+        } catch (e) { }
+    }
+
+    return results;
+}
+
+/**
+ * Initialize Matcher
+ */
+async function initMatcher() {
+    if (skillsData) return;
+
+    // 1. Scan .skill-search/skills directory directly (highest priority)
+    // This captures skills synced via "Sync Local Skills" command
+    const storeSkills = await crawlStoreSkills();
+
+    // 2. Crawl other local skills directories (e.g., ~/.claude/skills, ~/.codex/skills)
+    const localSkills = await crawlLocalSkills();
+
+    // 3. Create a set of paths already in storeSkills to avoid duplicates
+    const storePathSet = new Set(storeSkills.map(s => s.path));
+
+    // 4. Filter out localSkills that are already in storeSkills (by path)
+    const filteredLocalSkills = localSkills.filter(s => !storePathSet.has(s.path));
+
+    // Merge: store skills first (already synced), then other local skills
+    skillsData = [...storeSkills, ...filteredLocalSkills];
+
+    if (skillsData.length === 0) {
+        // If no data, maybe not synced yet
+        return;
+    }
+
+    fuseInstance = new Fuse(skillsData, {
+        keys: [
+            { name: 'id', weight: 2 },
+            { name: 'name', weight: 1.5 },
+            { name: 'keywords', weight: 1 },
+            { name: 'description', weight: 0.5 },
+            { name: 'provider', weight: 0.8 } // Added provider to keys
+        ],
+        threshold: 0.4,
+        includeScore: true
+    });
+}
+
+/**
+ * Match Skill
+ */
+async function matchSkill(input) {
+    await initMatcher();
+
+    if (!skillsData || skillsData.length === 0) {
+        return { type: 'empty' };
+    }
+
+    const normalized = input.toLowerCase().trim();
+
+    // 1. Exact ID Match
+    const exactMatch = skillsData.find(s =>
+        s.id.toLowerCase() === normalized
+    );
+    if (exactMatch) {
+        return { type: 'exact', skill: exactMatch };
+    }
+
+    // 2. Exact Keyword Match
+    const keywordMatch = skillsData.find(s =>
+        s.keywords && s.keywords.some(k => k.toLowerCase() === normalized)
+    );
+    if (keywordMatch) {
+        return { type: 'keyword', skill: keywordMatch };
+    }
+
+    // 3. Fuzzy Search
+    const fuzzyResults = fuseInstance.search(normalized);
+
+    if (fuzzyResults.length === 0) {
+        return { type: 'none' };
+    }
+
+    // Single high confidence result
+    if (fuzzyResults[0].score < 0.2) {
+        return { type: 'fuzzy', skill: fuzzyResults[0].item };
+    }
+
+    // Multiple candidates
+    if (fuzzyResults.length > 1) {
+        return {
+            type: 'multiple',
+            matches: fuzzyResults.slice(0, 5).map(r => r.item)
+        };
+    }
+
+    return { type: 'fuzzy', skill: fuzzyResults[0].item };
+}
+
+/**
+ * Search Skills
+ */
+async function searchSkills(query) {
+    await initMatcher();
+    if (!fuseInstance) return [];
+
+    return fuseInstance.search(query).slice(0, 10).map(r => ({
+        ...r.item,
+        score: r.score
+    }));
+}
+
+/**
+ * List All Skills
+ */
+async function listSkills(force = false) {
+    if (force) {
+        skillsData = null;
+        fuseInstance = null;
+    }
+    await initMatcher();
+    return skillsData || [];
+}
+
+module.exports = { matchSkill, searchSkills, listSkills };