skill-search 0.0.1

package/src/store.js

@@ -0,0 +1,156 @@
+// src/store.js
+// Local Data Store Management
+
+const fs = require('fs');
+const path = require('path');
+const config = require('./config');
+
+const paths = config.getPaths();
+
+/**
+ * Check if local data is empty
+ */
+function isEmpty() {
+    return !fs.existsSync(paths.indexFile);
+}
+
+/**
+ * Get local index
+ */
+function getIndex() {
+    if (!fs.existsSync(paths.indexFile)) {
+        return { skills: [], categories: [] };
+    }
+    try {
+        return JSON.parse(fs.readFileSync(paths.indexFile, 'utf8'));
+    } catch (error) {
+        return { skills: [], categories: [] };
+    }
+}
+
+/**
+ * Set local index
+ */
+function setIndex(data) {
+    config.ensureDataDir();
+    fs.writeFileSync(paths.indexFile, JSON.stringify(data, null, 2));
+}
+
+/**
+ * Get Sync Metadata
+ */
+function getMeta() {
+    if (!fs.existsSync(paths.metaFile)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(paths.metaFile, 'utf8'));
+    } catch (error) {
+        return null;
+    }
+}
+
+/**
+ * Set Sync Metadata
+ */
+function setMeta(data) {
+    config.ensureDataDir();
+    // Merge with existing meta
+    const current = getMeta() || {};
+    const merged = { ...current, ...data };
+    fs.writeFileSync(paths.metaFile, JSON.stringify(merged, null, 2));
+}
+
+/**
+ * Get local doc content
+ */
+function getDoc(skillId) {
+    const docPath = path.join(paths.docsDir, `${skillId}.md`);
+    if (fs.existsSync(docPath)) {
+        return fs.readFileSync(docPath, 'utf8');
+    }
+    return null;
+}
+
+/**
+ * Set local doc content
+ */
+function setDoc(skillId, content) {
+    const docsDir = paths.docsDir;
+    if (!fs.existsSync(docsDir)) {
+        fs.mkdirSync(docsDir, { recursive: true });
+    }
+    const docPath = path.join(docsDir, `${skillId}.md`);
+    fs.writeFileSync(docPath, content);
+}
+
+/**
+ * Check if full skill folder exists
+ */
+function hasFullSkill(skillId) {
+    const folderName = getSkillFolderName(skillId);
+    const skillDir = path.join(paths.skillsDir, folderName);
+    // Requirement says folder must contain skill.md. Usually it's SKILL.md or skill.md
+    // We check both or just SKILL.md as standardized? Original code checked 'SKILL.md'
+    return fs.existsSync(skillDir) &&
+        (fs.existsSync(path.join(skillDir, 'SKILL.md')) || fs.existsSync(path.join(skillDir, 'skill.md')));
+}
+
+/**
+ * Get full skill folder path
+ */
+function getFullSkillPath(skillId) {
+    const folderName = getSkillFolderName(skillId);
+    return path.join(paths.skillsDir, folderName);
+}
+
+/**
+ * Set skill file (by specific folder name)
+ */
+function setSkillFileByFolder(folderName, relativePath, content) {
+    const skillDir = path.join(paths.skillsDir, folderName);
+    const filePath = path.join(skillDir, relativePath);
+    const fileDir = path.dirname(filePath);
+
+    if (!fs.existsSync(fileDir)) {
+        fs.mkdirSync(fileDir, { recursive: true });
+    }
+
+    fs.writeFileSync(filePath, content);
+}
+
+/**
+ * Helper: Resolve folder name from Skill ID
+ */
+function getSkillFolderName(skillId) {
+    const index = getIndex();
+    const skill = index.skills.find(s => s.id === skillId);
+    return (skill && skill.localFolder) ? skill.localFolder : skillId;
+}
+
+/**
+ * Set skill file (for full sync)
+ * @param {string} skillId 
+ * @param {string} relativePath Relative path (e.g. scripts/test.py)
+ * @param {string|Buffer} content 
+ */
+function setSkillFile(skillId, relativePath, content) {
+    // Try to find folder name from index, otherwise use ID
+    const folderName = getSkillFolderName(skillId);
+    setSkillFileByFolder(folderName, relativePath, content);
+}
+
+module.exports = {
+    isEmpty,
+    getIndex,
+    setIndex,
+    getMeta,
+    setMeta,
+    getDoc,
+    setDoc,
+    hasFullSkill,
+    getFullSkillPath,
+    setSkillFile,
+    setSkillFileByFolder,
+    getPaths: config.getPaths // Expose getPaths if needed
+};

package/src/syncer.js

@@ -0,0 +1,226 @@
+// src/syncer.js
+// Sync Module
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const api = require('./api');
+const store = require('./store');
+const { crawlLocalSkills } = require('./localCrawler');
+const { parseFrontMatter } = require('./utils');
+
+/**
+ * Execute sync
+ * @param {object} options
+ * @param {string} options.mode - 'local', 'remote', 'all'
+ */
+async function sync(options = {}) {
+    // console.log('Starting Sync with options:', options);
+    const mode = options.mode || 'all';
+    const spinner = ora('Initializing Sync...').start();
+    const startTime = Date.now();
+
+    try {
+        let stats = {
+            local: 0,
+            remote: 0,
+            failed: 0
+        };
+
+        // 1. Sync Local Skills (Copy from found locations to cache)
+        if (mode === 'local' || mode === 'all') {
+            spinner.text = 'Scanning and syncing local skills...';
+            const localStats = await syncLocal(spinner);
+            stats.local = localStats.success;
+            stats.failed += localStats.failed;
+        }
+
+        // 2. Sync Remote Skills (Download from GitHub)
+        if (mode === 'remote' || mode === 'all') {
+            spinner.text = 'Fetching remote index...';
+            const remoteStats = await syncRemote(spinner);
+            stats.remote = remoteStats.success;
+            stats.failed += remoteStats.failed;
+        }
+
+        // 3. Update Meta
+        updateMeta();
+
+        const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+        spinner.succeed(chalk.green(`Sync completed in ${duration}s`));
+        console.log(chalk.cyan(`   Local Synced: ${stats.local}`));
+        console.log(chalk.cyan(`  Remote Synced: ${stats.remote}`));
+        if (stats.failed > 0) {
+            console.log(chalk.red(`         Failed: ${stats.failed}`));
+        }
+
+    } catch (error) {
+        spinner.fail(chalk.red('Sync failed'));
+        console.error(chalk.red(error.message));
+        if (process.env.DEBUG) console.error(error);
+        throw error; // Re-throw for UI to catch
+    }
+}
+
+/**
+ * Sync Local Skills
+ * Scans for local skills and copies them to ~/.skill-data/skills/
+ */
+async function syncLocal(spinner) {
+    const results = { success: 0, failed: 0 };
+
+    // 1. Crawl
+    spinner.text = 'Crawling local directories...';
+    const localSkills = await crawlLocalSkills();
+
+    if (localSkills.length === 0) {
+        return results;
+    }
+
+    spinner.text = `Found ${localSkills.length} local skills. Syncing to cache...`;
+
+    // 2. Copy each skill to cache
+    for (const skill of localSkills) {
+        try {
+            const destDir = store.getFullSkillPath(skill.id);
+            // Ensure distinct folder for local skills if needed, but ID should be unique enough?
+            // User requested "separate folder". Use ID.
+
+            await copyRecursive(skill.path, destDir);
+
+            // Ensure metadata is saved
+            store.setSkillFileByFolder(skill.id, 'skill.json', JSON.stringify(skill, null, 2));
+
+            results.success++;
+            // spinner.text = `Synced local: ${skill.id}`;
+        } catch (err) {
+            results.failed++;
+            console.error(chalk.yellow(`Failed to sync local skill ${skill.id}: ${err.message}`));
+        }
+    }
+
+    return results;
+}
+
+/**
+ * Sync Remote Skills
+ * Fetches index and downloads content for ALL remote skills
+ */
+async function syncRemote(spinner) {
+    const results = { success: 0, failed: 0 };
+
+    // 1. Fetch Index
+    spinner.text = 'Fetching remote index...';
+    const allSkills = await api.fetchAllSkills();
+
+    // Update Store Index
+    store.setIndex({
+        skills: allSkills,
+        updated: new Date().toISOString()
+    });
+
+    // 2. Download Content
+    const skillsToDownload = allSkills.filter(s => s.githubUrl);
+
+    // Warn if too many? User requested "All". Let's throttle or just do it.
+    // For TUI, let's just do it.
+
+    for (let i = 0; i < skillsToDownload.length; i++) {
+        const skill = skillsToDownload[i];
+        spinner.text = `Downloading remote [${i + 1}/${skillsToDownload.length}]: ${skill.name || skill.id}`;
+
+        try {
+            // Logic from old syncFull
+            // Construct base folder name: owner.repo.skillName
+            let folderName = skill.id;
+
+            // Try to extract better folder structure if GitHub URL is present
+            if (skill.githubUrl) {
+                const parsed = api.parseGitHubUrl(skill.githubUrl);
+                if (parsed) {
+                    // Keep the original skill folder name from the URL path end
+                    const originalSkillName = parsed.path.split('/').pop();
+                    folderName = `${parsed.owner}.${parsed.repo}.${originalSkillName}`;
+                }
+            }
+
+            // Fetch contents recursively and preserve relative paths
+            await api.fetchGitHubDirectoryRecursive(skill.githubUrl, (file) => {
+                // file.path is relative to the skill root (e.g., "SKILL.md", "references/foo.md")
+                // file.content is the file content
+                store.setSkillFileByFolder(folderName, file.path, file.content);
+            });
+
+            // Also ensure skill.json or similar metadata exists if needed
+            // store.setSkillFileByFolder(folderName, 'meta.json', JSON.stringify(skill, null, 2));
+
+            results.success++;
+        } catch (err) {
+            results.failed++;
+            // Don't spam console in TUI mode unless verbose
+            // console.error(chalk.yellow(`Failed to download ${skill.id}: ${err.message}`));
+        }
+    }
+
+    return results;
+}
+
+// Helper: Copy Recursive
+async function copyRecursive(src, dest) {
+    const stats = await fs.promises.stat(src);
+    if (stats.isDirectory()) {
+        await fs.promises.mkdir(dest, { recursive: true });
+        const entries = await fs.promises.readdir(src);
+        for (const entry of entries) {
+            await copyRecursive(path.join(src, entry), path.join(dest, entry));
+        }
+    } else {
+        await fs.promises.copyFile(src, dest);
+    }
+}
+
+/**
+ * Update Metadata
+ */
+function updateMeta() {
+    const meta = store.getMeta() || {};
+    const index = store.getIndex();
+
+    meta.lastSync = new Date().toISOString();
+    meta.totalSkills = index.skills ? index.skills.length : 0;
+
+    // We can count actual folders in skillsDir to allow correct "Cached" count
+    try {
+        const skillsDir = store.getPaths().skillsDir;
+        if (fs.existsSync(skillsDir)) {
+            const folders = fs.readdirSync(skillsDir);
+            meta.syncedDocs = folders.length; // Use syncedDocs field to store count of cached skills
+        }
+    } catch (e) { }
+
+    store.setMeta(meta);
+}
+
+/**
+ * Get Sync Status
+ */
+function getStatus() {
+    const meta = store.getMeta();
+    const index = store.getIndex();
+
+    if (!meta) {
+        return null;
+    }
+
+    return {
+        lastSync: meta.lastSync,
+        totalSkills: index.skills ? index.skills.length : 0,
+        syncedDocs: meta.syncedDocs || 0 // Reusing this field name as "Cached Skills"
+    };
+}
+
+module.exports = {
+    sync,
+    getStatus
+};

package/src/theme.js

@@ -0,0 +1,191 @@
+// src/theme.js
+// Theme Management for TUI
+
+const config = require('./config');
+
+/**
+ * Theme Definitions
+ */
+const THEMES = {
+    dark: {
+        name: 'Dark',
+        // Primary colors
+        primary: 'cyan',
+        secondary: 'green',
+        accent: 'yellow',
+        // Text colors
+        text: 'white',
+        textDim: 'gray',
+        textMuted: 'gray',
+        // UI colors
+        border: 'cyan',
+        borderInactive: 'gray',
+        // Status colors
+        success: 'green',
+        warning: 'yellow',
+        error: 'red',
+        info: 'cyan',
+        // List colors
+        localHighlight: 'green',
+        remoteHighlight: 'yellow',
+        selected: 'cyan',
+        // Logo color
+        logo: 'cyan',
+        // Background (for inverse text)
+        bgHighlight: 'cyan'
+    },
+    light: {
+        name: 'Light',
+        // Primary colors
+        primary: 'blue',
+        secondary: 'magenta',
+        accent: 'red',
+        // Text colors  
+        text: 'black',
+        textDim: 'gray',
+        textMuted: 'gray',
+        // UI colors
+        border: 'blue',
+        borderInactive: 'gray',
+        // Status colors
+        success: 'green',
+        warning: 'red',
+        error: 'red',
+        info: 'blue',
+        // List colors
+        localHighlight: 'magenta',
+        remoteHighlight: 'red',
+        selected: 'blue',
+        // Logo color
+        logo: 'blue',
+        // Background (for inverse text)
+        bgHighlight: 'blue'
+    }
+};
+
+// Current theme cache
+let currentTheme = null;
+
+/**
+ * Detect terminal color scheme
+ * Returns 'dark' or 'light' based on environment variables and heuristics
+ */
+function detectTerminalTheme() {
+    // Check common environment variables
+    const colorTerm = process.env.COLORFGBG;
+    const termProgram = process.env.TERM_PROGRAM;
+    const wtSession = process.env.WT_SESSION; // Windows Terminal
+    const iterm = process.env.ITERM_SESSION_ID;
+
+    // COLORFGBG format: "foreground;background" (e.g., "15;0" = white on black = dark)
+    if (colorTerm) {
+        const parts = colorTerm.split(';');
+        if (parts.length >= 2) {
+            const bg = parseInt(parts[parts.length - 1], 10);
+            // Background 0-6 or 8 typically means dark, 7 or 9-15 means light
+            if (bg === 0 || bg === 8 || (bg >= 0 && bg <= 6)) {
+                return 'dark';
+            } else if (bg === 7 || bg === 15 || (bg >= 9 && bg <= 15)) {
+                return 'light';
+            }
+        }
+    }
+
+    // macOS Terminal.app and iTerm2 - usually respect system dark mode
+    if (process.platform === 'darwin') {
+        // Try to detect macOS dark mode via AppleInterfaceStyle
+        try {
+            const { execSync } = require('child_process');
+            const result = execSync('defaults read -g AppleInterfaceStyle 2>/dev/null', { encoding: 'utf8' });
+            if (result.trim().toLowerCase() === 'dark') {
+                return 'dark';
+            }
+        } catch (e) {
+            // AppleInterfaceStyle not set = light mode
+            return 'light';
+        }
+    }
+
+    // Windows Terminal detection
+    if (wtSession) {
+        // Windows Terminal - default to dark as it's the common default
+        return 'dark';
+    }
+
+    // VS Code integrated terminal
+    if (termProgram === 'vscode') {
+        // Check VS Code theme via environment
+        const vscodeTheme = process.env.VSCODE_GIT_ASKPASS_NODE;
+        // Default to dark as VS Code default is dark
+        return 'dark';
+    }
+
+    // Default to dark theme (most terminal users prefer dark)
+    return 'dark';
+}
+
+/**
+ * Get current theme name from config
+ */
+function getThemeName() {
+    const userConfig = config.getUserConfig();
+    if (userConfig.theme) {
+        return userConfig.theme;
+    }
+    // First run - detect and save
+    const detected = detectTerminalTheme();
+    setThemeName(detected);
+    return detected;
+}
+
+/**
+ * Set theme name in config
+ */
+function setThemeName(themeName) {
+    const userConfig = config.getUserConfig();
+    userConfig.theme = themeName;
+    config.setUserConfig(userConfig);
+    currentTheme = null; // Reset cache
+}
+
+/**
+ * Get current theme object
+ */
+function getTheme() {
+    if (currentTheme) {
+        return currentTheme;
+    }
+    const themeName = getThemeName();
+    currentTheme = THEMES[themeName] || THEMES.dark;
+    return currentTheme;
+}
+
+/**
+ * Toggle between dark and light themes
+ */
+function toggleTheme() {
+    const current = getThemeName();
+    const next = current === 'dark' ? 'light' : 'dark';
+    setThemeName(next);
+    return next;
+}
+
+/**
+ * Get list of available themes
+ */
+function getAvailableThemes() {
+    return Object.keys(THEMES).map(key => ({
+        key,
+        name: THEMES[key].name
+    }));
+}
+
+module.exports = {
+    THEMES,
+    detectTerminalTheme,
+    getThemeName,
+    setThemeName,
+    getTheme,
+    toggleTheme,
+    getAvailableThemes
+};