lsh-framework 1.2.1 → 1.3.1

package/dist/lib/fuzzy-match.js

@@ -0,0 +1,123 @@
+/**
+ * Fuzzy matching utilities for secret keys
+ */
+/**
+ * Normalize a string for fuzzy matching by removing spaces and special chars
+ */
+function normalizeForMatching(str) {
+    // Remove spaces, hyphens, and convert to lowercase
+    return str.toLowerCase().replace(/[\s-]/g, '');
+}
+/**
+ * Calculate fuzzy match score between search string and key
+ * Returns a score where higher is better, or -1 if no match
+ *
+ * Supports space-separated searches:
+ *  - "stripe api" matches "STRIPE_API_KEY"
+ *  - "stripe secret" matches "STRIPE_SECRET_KEY"
+ */
+export function calculateMatchScore(searchTerm, key) {
+    // Empty search term matches nothing
+    if (!searchTerm || searchTerm.trim() === '') {
+        return -1;
+    }
+    const searchLower = searchTerm.toLowerCase();
+    const keyLower = key.toLowerCase();
+    // Normalize both for space-insensitive matching
+    const searchNormalized = normalizeForMatching(searchTerm);
+    const keyNormalized = normalizeForMatching(key);
+    // Exact match (case sensitive) - highest priority
+    if (searchTerm === key) {
+        return 1100;
+    }
+    // Exact match (case insensitive)
+    if (searchLower === keyLower || searchNormalized === keyNormalized) {
+        return 1000;
+    }
+    // Key starts with search term (case sensitive)
+    if (key.startsWith(searchTerm)) {
+        return 950;
+    }
+    // Key starts with search term (case insensitive, normalized)
+    if (keyLower.startsWith(searchLower) || keyNormalized.startsWith(searchNormalized)) {
+        return 900;
+    }
+    // Check if search with spaces can match multiple words in key
+    // e.g., "stripe api" should match "STRIPE_API_KEY"
+    // Only do multi-word matching if user provided spaces (not underscores)
+    const hasSpaces = /\s/.test(searchTerm);
+    if (hasSpaces) {
+        const searchWords = searchTerm.toLowerCase().split(/[\s_-]+/).filter(w => w.length > 0);
+        const keyWords = key.toLowerCase().split(/[_-]/).filter(w => w.length > 0);
+        if (searchWords.length > 1) {
+            // Try to match all search words in order within key words
+            let matchCount = 0;
+            let lastMatchIndex = -1;
+            for (const searchWord of searchWords) {
+                let found = false;
+                for (let i = lastMatchIndex + 1; i < keyWords.length; i++) {
+                    if (keyWords[i].startsWith(searchWord) || keyWords[i].includes(searchWord)) {
+                        matchCount++;
+                        lastMatchIndex = i;
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    break; // If any word doesn't match, stop
+                }
+            }
+            // If all search words matched, score based on how many matched
+            if (matchCount === searchWords.length) {
+                // Perfect multi-word match - higher than substring matches
+                return 850 - (lastMatchIndex * 10); // Earlier matches score higher
+            }
+            else if (matchCount > 0) {
+                // Partial multi-word match
+                return 300 + (matchCount * 50);
+            }
+        }
+    }
+    // Key contains search term (case insensitive, normalized)
+    // Only apply this for single-word searches (no spaces)
+    if (!hasSpaces && (keyLower.includes(searchLower) || keyNormalized.includes(searchNormalized))) {
+        // Score based on position (earlier is better)
+        const position = keyNormalized.indexOf(searchNormalized);
+        const relativePosition = position / keyNormalized.length;
+        return 500 - (relativePosition * 100);
+    }
+    // Substring match with underscores/boundaries
+    // e.g., "stripe" matches "STRIPE_API_KEY" or "MY_STRIPE_SECRET"
+    const words = keyLower.split('_');
+    for (let i = 0; i < words.length; i++) {
+        if (words[i].startsWith(searchLower)) {
+            // Earlier words get higher scores
+            return 700 - (i * 50);
+        }
+        if (words[i].includes(searchLower)) {
+            return 400 - (i * 50);
+        }
+    }
+    // No match
+    return -1;
+}
+/**
+ * Find fuzzy matches for a search term in a list of key-value pairs
+ * Returns matches sorted by relevance (best match first)
+ */
+export function findFuzzyMatches(searchTerm, secrets) {
+    const results = [];
+    for (const secret of secrets) {
+        const score = calculateMatchScore(searchTerm, secret.key);
+        if (score >= 0) {
+            results.push({
+                key: secret.key,
+                value: secret.value,
+                score,
+            });
+        }
+    }
+    // Sort by score (descending - best match first)
+    results.sort((a, b) => b.score - a.score);
+    return results;
+}

package/dist/services/secrets/secrets.js

@@ -404,6 +404,7 @@ API_KEY=
         .option('--all', 'Get all secrets from the file')
         .option('--export', 'Output in export format for shell evaluation (alias for --format export)')
         .option('--format <type>', 'Output format: env, json, yaml, toml, export', 'env')
+        .option('--exact', 'Require exact key match (disable fuzzy matching)')
         .action(async (key, options) => {
         try {
             const envPath = path.resolve(options.file);
@@ -413,24 +414,25 @@ API_KEY=
             }
             const content = fs.readFileSync(envPath, 'utf8');
             const lines = content.split('\n');
-            // Handle --all flag
-            if (options.all) {
-                const secrets = [];
-                for (const line of lines) {
-                    if (line.trim().startsWith('#') || !line.trim())
-                        continue;
-                    const match = line.match(/^([^=]+)=(.*)$/);
-                    if (match) {
-                        const key = match[1].trim();
-                        let value = match[2].trim();
-                        // Remove quotes if present
-                        if ((value.startsWith('"') && value.endsWith('"')) ||
-                            (value.startsWith("'") && value.endsWith("'"))) {
-                            value = value.slice(1, -1);
-                        }
-                        secrets.push({ key, value });
+            // Parse all secrets from file
+            const secrets = [];
+            for (const line of lines) {
+                if (line.trim().startsWith('#') || !line.trim())
+                    continue;
+                const match = line.match(/^([^=]+)=(.*)$/);
+                if (match) {
+                    const key = match[1].trim();
+                    let value = match[2].trim();
+                    // Remove quotes if present
+                    if ((value.startsWith('"') && value.endsWith('"')) ||
+                        (value.startsWith("'") && value.endsWith("'"))) {
+                        value = value.slice(1, -1);
                     }
+                    secrets.push({ key, value });
                 }
+            }
+            // Handle --all flag
+            if (options.all) {
                 // Handle format output
                 const format = options.export ? 'export' : options.format.toLowerCase();
                 const validFormats = ['env', 'json', 'yaml', 'toml', 'export'];
@@ -451,22 +453,56 @@ API_KEY=
                 console.error('❌ Please provide a key or use --all flag');
                 process.exit(1);
             }
-            for (const line of lines) {
-                if (line.trim().startsWith('#') || !line.trim())
-                    continue;
-                const match = line.match(/^([^=]+)=(.*)$/);
-                if (match && match[1].trim() === key) {
-                    let value = match[2].trim();
-                    // Remove quotes if present
-                    if ((value.startsWith('"') && value.endsWith('"')) ||
-                        (value.startsWith("'") && value.endsWith("'"))) {
-                        value = value.slice(1, -1);
-                    }
-                    console.log(value);
+            // Try exact match first
+            const exactMatch = secrets.find(s => s.key === key);
+            if (exactMatch) {
+                console.log(exactMatch.value);
+                return;
+            }
+            // If exact match enabled, don't do fuzzy matching
+            if (options.exact) {
+                console.error(`❌ Key '${key}' not found in ${options.file}`);
+                process.exit(1);
+            }
+            // Use fuzzy matching
+            const { findFuzzyMatches } = await import('../../lib/fuzzy-match.js');
+            const matches = findFuzzyMatches(key, secrets);
+            if (matches.length === 0) {
+                console.error(`❌ No matches found for '${key}' in ${options.file}`);
+                console.error('💡 Tip: Use --exact flag for exact matching only');
+                process.exit(1);
+            }
+            // If single match, return it
+            if (matches.length === 1) {
+                console.log(matches[0].value);
+                return;
+            }
+            // If best match score is significantly higher than second best (clear winner)
+            // then auto-select it
+            if (matches.length > 1) {
+                const bestScore = matches[0].score;
+                const secondBestScore = matches[1].score;
+                // If best match scores 700+ and is at least 2x better than second best,
+                // consider it a clear match
+                if (bestScore >= 700 && bestScore >= secondBestScore * 2) {
+                    console.log(matches[0].value);
                     return;
                 }
             }
-            console.error(`❌ Key '${key}' not found in ${options.file}`);
+            // Multiple matches - show all matches for user to choose
+            console.error(`🔍 Found ${matches.length} matches for '${key}':\n`);
+            for (const match of matches) {
+                // Mask value for display
+                const maskedValue = match.value.length > 4
+                    ? match.value.substring(0, 4) + '*'.repeat(Math.min(match.value.length - 4, 10))
+                    : '****';
+                console.error(`  ${match.key}=${maskedValue}`);
+            }
+            console.error('');
+            console.error('💡 Please specify the exact key name or use one of:');
+            for (const match of matches) {
+                console.error(`   lsh get ${match.key}`);
+            }
             process.exit(1);
         }
         catch (error) {
@@ -507,6 +543,42 @@ API_KEY=
             process.exit(1);
         }
     });
+    /**
+     * Detect if file should use 'export' prefix based on file type
+     */
+    function shouldUseExport(filePath) {
+        const filename = path.basename(filePath);
+        const ext = path.extname(filePath);
+        // Shell script files - use export
+        if (['.sh', '.bash', '.zsh'].includes(ext)) {
+            return true;
+        }
+        // Shell profile/rc files - use export
+        if (['.bashrc', '.zshrc', '.profile', '.bash_profile', '.zprofile'].includes(filename)) {
+            return true;
+        }
+        // .envrc files (direnv) - use export
+        if (filename === '.envrc' || filename.endsWith('.envrc')) {
+            return true;
+        }
+        // .env files - do NOT use export
+        if (filename === '.env' || filename.startsWith('.env.')) {
+            return false;
+        }
+        // Default: no export (safest for most env files)
+        return false;
+    }
+    /**
+     * Format a line based on file type
+     */
+    function formatEnvLine(key, value, filePath) {
+        const needsQuotes = /[\s#]/.test(value);
+        const quotedValue = needsQuotes ? `"${value}"` : value;
+        const useExport = shouldUseExport(filePath);
+        return useExport
+            ? `export ${key}=${quotedValue}`
+            : `${key}=${quotedValue}`;
+    }
     /**
      * Set a single secret value
      */
@@ -527,12 +599,11 @@ API_KEY=
                     newLines.push(line);
                     continue;
                 }
-                const match = line.match(/^([^=]+)=(.*)$/);
+                // Match both with and without export
+                const match = line.match(/^(?:export\s+)?([^=]+)=(.*)$/);
                 if (match && match[1].trim() === key) {
-                    // Quote values with spaces or special characters
-                    const needsQuotes = /[\s#]/.test(value);
-                    const quotedValue = needsQuotes ? `"${value}"` : value;
-                    newLines.push(`${key}=${quotedValue}`);
+                    // Use appropriate format for this file type
+                    newLines.push(formatEnvLine(key, value, envPath));
                     found = true;
                 }
                 else {
@@ -543,9 +614,8 @@ API_KEY=
         }
         // If key wasn't found, append it
         if (!found) {
-            const needsQuotes = /[\s#]/.test(value);
-            const quotedValue = needsQuotes ? `"${value}"` : value;
-            content = content.trimRight() + `\n${key}=${quotedValue}\n`;
+            const formattedLine = formatEnvLine(key, value, envPath);
+            content = content.trimRight() + `\n${formattedLine}\n`;
         }
         fs.writeFileSync(envPath, content, 'utf8');
         console.log(`✅ Set ${key}`);
@@ -602,8 +672,8 @@ API_KEY=
                         // Skip comments and empty lines
                         if (trimmed.startsWith('#') || !trimmed)
                             continue;
-                        // Parse KEY=VALUE format
-                        const match = trimmed.match(/^([^=]+)=(.*)$/);
+                        // Parse KEY=VALUE format (with or without export)
+                        const match = trimmed.match(/^(?:export\s+)?([^=]+)=(.*)$/);
                         if (!match) {
                             errors.push(`Invalid format: ${trimmed}`);
                             continue;
@@ -635,15 +705,14 @@ API_KEY=
                                 newLines.push(line);
                                 continue;
                             }
-                            const match = line.match(/^([^=]+)=(.*)$/);
+                            // Match both with and without export
+                            const match = line.match(/^(?:export\s+)?([^=]+)=(.*)$/);
                             if (match) {
                                 const key = match[1].trim();
                                 if (newKeys.has(key)) {
-                                    // Update existing key
+                                    // Update existing key with appropriate format
                                     const value = newKeys.get(key);
-                                    const needsQuotes = /[\s#]/.test(value);
-                                    const quotedValue = needsQuotes ? `"${value}"` : value;
-                                    newLines.push(`${key}=${quotedValue}`);
+                                    newLines.push(formatEnvLine(key, value, envPath));
                                     newKeys.delete(key); // Mark as processed
                                     hasContent = true;
                                 }
@@ -660,13 +729,12 @@ API_KEY=
                     }
                     // Add new keys that weren't in the existing file
                     for (const [key, value] of newKeys.entries()) {
-                        const needsQuotes = /[\s#]/.test(value);
-                        const quotedValue = needsQuotes ? `"${value}"` : value;
+                        const formattedLine = formatEnvLine(key, value, envPath);
                         if (hasContent) {
-                            newLines.push(`${key}=${quotedValue}`);
+                            newLines.push(formattedLine);
                         }
                         else {
-                            newLines.push(`${key}=${quotedValue}`);
+                            newLines.push(formattedLine);
                             hasContent = true;
                         }
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lsh-framework",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "Simple, cross-platform encrypted secrets manager with automatic sync and multi-environment support. Just run lsh sync and start managing your secrets.",
   "main": "dist/app.js",
   "bin": {