skill-search 0.0.1

package/bin/skill.js

@@ -0,0 +1,348 @@
+#!/usr/bin/env node
+// bin/skill.js
+
+// Check for TUI mode first (before Commander parsing)
+const args = process.argv.slice(2);
+const shouldLaunchTUI = args.length === 0 || args.includes('--tui') || args.includes('-t');
+
+if (shouldLaunchTUI && !args.includes('--help') && !args.includes('-h')) {
+    // Launch TUI mode
+    require('./tui.js');
+} else {
+    // Original CLI mode
+    const { program } = require('commander');
+    const chalk = require('chalk');
+    const { exec } = require('child_process');
+    const path = require('path');
+    const api = require('../src/api');
+    const syncer = require('../src/syncer');
+    const store = require('../src/store');
+    const { matchSkill, listSkills, searchSkills } = require('../src/matcher');
+    const { formatMarkdown } = require('../src/utils');
+    const { selectSkill } = require('../src/interactive');
+    const pkg = require('../package.json');
+
+    program
+        .name('skill')
+        .description('Skill Search: Retrieve skill documentation from SkillsMP')
+        .version(pkg.version, '-v, --version')
+        .option('-t, --tui', 'Launch in TUI (Text User Interface) mode');
+
+    // Main command: Fetch skill documentation
+    program
+        .argument('[keyword]', 'Skill ID or keyword')
+        .option('-r, --remote', 'Force fetch from remote API')
+        .action(async (keyword, options) => {
+            try {
+                let skill;
+                let isRemoteFetch = false;
+
+                // 1. Remote Mode
+                if (options.remote) {
+                    console.log(chalk.gray('Searching remote...'));
+                    const results = await api.searchSkills(keyword, { limit: 5 });
+
+                    if (results.skills.length === 0) {
+                        throw new Error(`No results found for "${keyword}" (Remote)`);
+                    }
+
+                    if (results.skills.length === 1) {
+                        skill = results.skills[0];
+                    } else {
+                        skill = await selectSkill(results.skills);
+                    }
+                    isRemoteFetch = true;
+                }
+                // 2. Local Mode
+                else {
+                    const result = await matchSkill(keyword);
+
+                    if (result.type === 'empty') {
+                        return;
+                    }
+
+                    switch (result.type) {
+                        case 'exact':
+                        case 'keyword':
+                        case 'fuzzy':
+                            skill = result.skill;
+                            break;
+                        case 'multiple':
+                            skill = await selectSkill(result.matches);
+                            break;
+                        case 'none':
+                            console.log(chalk.red(`✗ No documentation found for "${keyword}"`));
+                            console.log(chalk.gray('\nHints:'));
+                            console.log(chalk.gray('  skill list        List all available skills'));
+                            console.log(chalk.gray('  skill sync        Sync latest data'));
+                            process.exit(1);
+                    }
+                }
+
+                console.log(chalk.green(`✓ Selected: ${skill.name || skill.id}`));
+
+                // Handle content
+                let content;
+                let docPath;
+
+                // Check local cache first unless remote forced
+                if (!options.remote) {
+                    content = store.getDoc(skill.id);
+                }
+
+                // Download if missing or remote mode
+                if (!content || isRemoteFetch) {
+                    if (!skill.githubUrl) {
+                        throw new Error('This skill has no associated GitHub repository.');
+                    }
+
+                    console.log(chalk.gray('Fetching document content...'));
+                    content = await api.fetchSkillContent(skill.githubUrl);
+
+                    // Save to local store
+                    store.setDoc(skill.id, content);
+
+                    // Also cache the skill info to index if it doesn't exist
+                    const index = store.getIndex();
+                    if (!index.skills.find(s => s.id === skill.id)) {
+                        index.skills.push(skill);
+                        store.setIndex(index);
+                    }
+
+                    console.log(chalk.green('✓ Saved to local storage.'));
+                }
+
+                // Implementation of #v26011801: Open option logic
+                docPath = path.join(store.getPaths().docsDir, `${skill.id}.md`);
+
+                if (options.remote) {
+                    // In remote mode, offer to open instead of printing
+                    const inquirer = require('inquirer');
+                    const prompt = inquirer.createPromptModule();
+
+                    const answer = await prompt([
+                        {
+                            type: 'list',
+                            name: 'action',
+                            message: 'Content saved. What would you like to do?',
+                            choices: [
+                                { name: 'View in Terminal', value: 'view' },
+                                { name: 'Open in Editor', value: 'open' },
+                                { name: 'Exit', value: 'exit' }
+                            ]
+                        }
+                    ]);
+
+                    if (answer.action === 'open') {
+                        // Try to open with default editor
+                        const cmd = process.platform === 'win32' ? 'start' : (process.platform === 'darwin' ? 'open' : 'xdg-open');
+                        // Windows start command needs an extra pair of quotes for the title if path has spaces, but here path is safe-ish.
+                        // Actually 'start "" "path"' is safer on Windows.
+                        const finalCmd = process.platform === 'win32' ? `start "" "${docPath}"` : `${cmd} "${docPath}"`;
+
+                        exec(finalCmd, (err) => {
+                            if (err) console.error(chalk.red('Failed to open file:', err.message));
+                        });
+                    } else if (answer.action === 'view') {
+                        console.log('\n' + formatMarkdown(content));
+                    }
+                } else {
+                    // Local mode default behavior: print to terminal
+                    console.log('\n' + formatMarkdown(content));
+                }
+
+            } catch (error) {
+                console.error(chalk.red(`✗ ${error.message}`));
+                if (process.env.DEBUG) console.error(error);
+                process.exit(1);
+            }
+        });
+
+    // Sync command
+    program
+        .command('sync')
+        .description('Sync data from remote repository')
+        .option('-f, --force', 'Force full sync')
+        .option('--docs', 'Sync all document contents')
+        .option('--full', 'Sync full Skill folders')
+        .option('--id <id>', 'Sync specific Skill only')
+        .option('--status', 'View sync status')
+        .action(async (options) => {
+            try {
+                if (options.status) {
+                    const status = syncer.getStatus();
+                    if (!status) {
+                        console.log(chalk.yellow('No sync history found.'));
+                    } else {
+                        console.log(chalk.cyan('📊 Sync Status:'));
+                        console.log(`  Last Sync: ${new Date(status.lastSync).toLocaleString()}`);
+                        console.log(`  Local Skills: ${status.totalSkills}`);
+                        console.log(`  Cached Docs: ${status.syncedDocs}`);
+                        console.log(`  Full Synced: ${status.fullSynced}`);
+                    }
+                    return;
+                }
+
+                await syncer.sync(options);
+            } catch (error) {
+                console.error(chalk.red(`✗ Sync failed: ${error.message}`));
+            }
+        });
+
+    // List command
+    program
+        .command('list')
+        .alias('ls')
+        .description('List all local skills')
+        .action(async () => {
+            try {
+                const skills = await listSkills();
+                if (skills.length === 0) {
+                    console.log(chalk.yellow('No local data. Please run "skill sync" first.'));
+                    return;
+                }
+
+                console.log(chalk.cyan.bold('\n📚 Available Skills:\n'));
+                skills.forEach(skill => {
+                    const id = chalk.green(skill.id.padEnd(30));
+                    const desc = (skill.description || '').slice(0, 50) + (skill.description?.length > 50 ? '...' : '');
+                    console.log(`  ${id} ${desc}`);
+                });
+                console.log(chalk.gray(`\nTotal: ${skills.length} skills`));
+            } catch (error) {
+                console.error(chalk.red(`✗ ${error.message}`));
+            }
+        });
+
+    // Search command
+    program
+        .command('search <query>')
+        .alias('s')
+        .description('Search skills locally')
+        .action(async (query) => {
+            try {
+                const results = await searchSkills(query);
+                if (results.length === 0) {
+                    console.log(chalk.yellow(`No results found for "${query}"`));
+                    return;
+                }
+
+                console.log(chalk.cyan.bold('\n🔍 Search Results:\n'));
+                results.forEach(r => {
+                    const score = Math.round((1 - r.score) * 100);
+                    const id = chalk.green(r.id.padEnd(30));
+                    console.log(`  ${id} ${r.name || ''} ${chalk.gray(`(${score}%)`)}`);
+                });
+            } catch (error) {
+                console.error(chalk.red(`✗ ${error.message}`));
+            }
+        });
+
+    // Config command
+    program
+        .command('config')
+        .description('Manage configuration')
+        .option('--api-key <key>', 'Set SkillsMP API Key')
+        .action((options) => {
+            const config = require('../src/config');
+            if (options.apiKey) {
+                config.setApiKey(options.apiKey);
+                console.log(chalk.green('✓ API Key saved'));
+            } else {
+                console.log(JSON.stringify(config.getUserConfig(), null, 2));
+            }
+        });
+
+    // Add Custom Path
+    program
+        .command('add <path>')
+        .description('Add a custom skill directory')
+        .action((dirPath) => {
+            const config = require('../src/config');
+            const path = require('path');
+            const absolutePath = path.resolve(dirPath);
+            if (config.addCustomPath(absolutePath)) {
+                console.log(chalk.green(`✓ Added custom path: ${absolutePath}`));
+            } else {
+                console.log(chalk.yellow(`! Path already exists: ${absolutePath}`));
+            }
+        });
+
+    // Remove Custom Path
+    program
+        .command('remove <path>')
+        .alias('rm')
+        .description('Remove a custom skill directory')
+        .action((dirPath) => {
+            const config = require('../src/config');
+            const path = require('path');
+            const absolutePath = path.resolve(dirPath);
+            const currentPaths = config.getCustomPaths();
+
+            // Try partial match first if it's unique? No, explicit is better.
+            // Try exact string first, then absolute path.
+            let target = dirPath;
+            if (!currentPaths.includes(target)) {
+                target = absolutePath;
+            }
+
+            if (config.removeCustomPath(target)) {
+                console.log(chalk.green(`✓ Removed custom path: ${target}`));
+            } else {
+                console.log(chalk.red(`✗ Path not found: ${dirPath}`));
+                console.log(chalk.gray('Use "skill config" to list all paths.'));
+            }
+        });
+
+    // Primary Directory
+    program
+        .command('primary [dir]')
+        .description('Set or list primary directory')
+        .action((dir) => {
+            const config = require('../src/config');
+            const available = config.getAvailablePrimaryDirs();
+
+            if (!dir) {
+                console.log(chalk.cyan.bold('\nPossible Primary Directories:'));
+                const current = config.getPrimaryDirName();
+                available.forEach(d => {
+                    const isCurrent = d.key === current;
+                    const prefix = isCurrent ? chalk.green('->') : '  ';
+                    const name = isCurrent ? chalk.green(d.name.padEnd(20)) : d.name.padEnd(20);
+                    console.log(`${prefix} ${name} ${chalk.gray(d.desc)}`);
+                });
+                return;
+            }
+
+            const match = available.find(d => d.key === dir || d.name === dir || d.name === '.' + dir);
+            if (match) {
+                config.setPrimaryDir(match.key);
+                console.log(chalk.green(`✓ Primary directory set to: ${match.name}`));
+            } else {
+                console.log(chalk.red(`✗ Invalid directory: ${dir}`));
+                console.log(chalk.gray('Use "skill primary" to see available options.'));
+            }
+        });
+
+    // Theme (TUI setting)
+    program
+        .command('theme [mode]')
+        .description('Set or toggle TUI theme (dark/light)')
+        .action((mode) => {
+            const theme = require('../src/theme');
+            if (!mode) {
+                const newTheme = theme.toggleTheme();
+                console.log(chalk.green(`✓ TUI Theme toggled to: ${newTheme}`));
+            } else {
+                const m = mode.toLowerCase();
+                if (['dark', 'light'].includes(m)) {
+                    theme.setThemeName(m);
+                    console.log(chalk.green(`✓ TUI Theme set to: ${m}`));
+                } else {
+                    console.log(chalk.red('✗ Invalid theme. Use "dark" or "light".'));
+                }
+            }
+        });
+
+    program.parse();
+}

package/bin/tui.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// bin/tui.js - TUI Mode Entry Point (Alternate Buffer)
+
+const React = require('react');
+const { render } = require('ink');
+const App = require('../src/tui/App');
+
+// Enter Alternate Screen Buffer, Clear Screen, Move Cursor to Top-Left, Show Cursor
+process.stdout.write('\x1b[?1049h\x1b[2J\x1b[H\x1b[?25h');
+
+// Config Ink to use fullscreen mode which handles clearing automatically
+const { waitUntilExit, clear, unmount } = render(React.createElement(App), {
+    exitOnCtrlC: true,
+    patchConsole: false,
+    debug: false,
+    // Note: 'fullscreen' option isn't directly exposed in render options like this in older Ink versions,
+    // but clearing screen manually is good. However, Ink v3+ handles full screen by taking over stdout.
+    // Let's rely on standard clearing.
+});
+
+// Capture exit to ensure we restore screen
+process.on('SIGINT', () => {
+    unmount();
+    process.stdout.write('\x1b[?1049l\x1b[?25h'); // Restore buffer and cursor
+    process.exit(0);
+});
+
+waitUntilExit().then(() => {
+    unmount();
+    // Exit Alternate Screen Buffer and show cursor
+    process.stdout.write('\x1b[?1049l\x1b[?25h');
+    process.exit(0);
+});

package/package.json

@@ -0,0 +1,53 @@
+{
+    "name": "skill-search",
+    "version": "0.0.1",
+    "description": "Quickly retrieve skill documentation from GitHub",
+    "keywords": [
+        "cli",
+        "skill",
+        "documentation",
+        "markdown"
+    ],
+    "homepage": "https://github.com/LLMist/Skill-Search#readme",
+    "bugs": {
+        "url": "https://github.com/LLMist/Skill-Search/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/LLMist/Skill-Search.git"
+    },
+    "license": "ISC",
+    "author": "LLM.ist",
+    "type": "commonjs",
+    "main": "bin/skill.js",
+    "bin": {
+        "skill": "bin/skill.js"
+    },
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1",
+        "build": "pkg . --out-path=dist --targets=node18-linux-x64,node18-macos-x64,node18-win-x64"
+    },
+    "dependencies": {
+        "axios": "^1.6.0",
+        "chalk": "^4.1.2",
+        "clipboardy": "^2.3.0",
+        "commander": "^11.1.0",
+        "fuse.js": "^7.0.0",
+        "ink": "^3.2.0",
+        "ink-select-input": "^4.2.2",
+        "ink-spinner": "^4.0.3",
+        "ink-text-input": "^4.0.3",
+        "inquirer": "^8.2.6",
+        "marked": "^11.0.0",
+        "marked-terminal": "^6.1.0",
+        "ora": "^5.4.1",
+        "react": "^17.0.2",
+        "terminal-link": "^5.0.0"
+    },
+    "devDependencies": {
+        "eslint": "^8.0.0",
+        "jest": "^29.0.0",
+        "pkg": "^5.8.1",
+        "prettier": "^3.0.0"
+    }
+}

package/scripts/package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "scripts",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

package/scripts/setup-env.bat

@@ -0,0 +1,58 @@
+@echo off
+setlocal
+
+:: ==========================================
+:: Skill Search 多设备开发环境配置脚本
+:: ==========================================
+
+echo [INFO] Detected Device Name: %COMPUTERNAME%
+
+:: 1. 定义本地隔离路径
+set "LOCAL_DIR=.local\%COMPUTERNAME%"
+set "TARGET_MODULES=%LOCAL_DIR%\node_modules"
+
+:: 2. 确保目录存在
+if not exist ".local" (
+    mkdir ".local"
+)
+if not exist "%LOCAL_DIR%" (
+    mkdir "%LOCAL_DIR%"
+)
+if not exist "%TARGET_MODULES%" (
+    echo [INFO] Creating directory: %TARGET_MODULES%
+    mkdir "%TARGET_MODULES%"
+)
+
+:: 3. 处理根目录 node_modules
+if exist "node_modules" (
+    :: 检查 node_modules 是否已经是链接
+    fsutil reparsepoint query "node_modules" >nul 2>&1
+    if %errorlevel% equ 0 (
+        echo [INFO] node_modules is already a symlink/junction.
+        rmdir "node_modules"
+    ) else (
+        echo [WARNING] Found existing standard node_modules folder.
+        echo [WARNING] Removing standard folder to replace with device-specific link...
+        rmdir /s /q "node_modules"
+    )
+)
+
+:: 4. 创建符号链接 (Junction)
+:: node_modules -> .local/DEVICE_NAME/node_modules
+echo [INFO] Linking node_modules -^> %TARGET_MODULES%
+mklink /J "node_modules" "%TARGET_MODULES%"
+
+if %errorlevel% neq 0 (
+    echo [ERROR] Failed to create symlink. Please run as Administrator.
+    pause
+    exit /b 1
+)
+
+:: 5. 安装依赖
+echo [INFO] Installing dependencies via npm...
+npm install
+
+echo.
+echo [SUCCESS] Environment setup complete for %COMPUTERNAME%!
+echo [INFO] Dependencies are stored in: %TARGET_MODULES%
+pause

package/scripts/test-scan.js

@@ -0,0 +1,42 @@
+const { scanForSkillDirectories } = require('../src/localCrawler');
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+async function run() {
+    console.log('Home dir:', os.homedir());
+    
+    // Create a dummy dot-folder with skills to ensure it's found
+    const dummyDir = path.join(os.homedir(), '.test-auto-scan-dir');
+    const skillsDir = path.join(dummyDir, 'skills');
+    
+    if (!fs.existsSync(skillsDir)) {
+        fs.mkdirSync(skillsDir, { recursive: true });
+        console.log('Created dummy dir:', dummyDir);
+    }
+    
+    try {
+        const results = await scanForSkillDirectories();
+        console.log('Found directories:', results);
+        
+        if (results.includes('.test-auto-scan-dir')) {
+            console.log('SUCCESS: Found the test directory.');
+        } else {
+            console.log('FAILURE: Did not find the test directory.');
+        }
+    } catch (err) {
+        console.error('Error:', err);
+    } finally {
+        // Cleanup
+        try {
+            if (fs.existsSync(dummyDir)) {
+                fs.rmSync(dummyDir, { recursive: true, force: true });
+                console.log('Cleaned up dummy dir');
+            }
+        } catch (e) {
+            console.error('Cleanup error:', e);
+        }
+    }
+}
+
+run();