@gotza02/sequential-thinking 2026.2.31 → 2026.2.32

package/dist/codestore.d.ts

@@ -7,22 +7,122 @@ export interface CodeSnippet {
     tags: string[];
     context?: string;
     updatedAt: string;
+    embedding?: number[];
 }
 export interface CodeKnowledge {
+    version: string;
     snippets: CodeSnippet[];
     patterns: Record<string, string>;
+    metadata?: {
+        lastModified: string;
+        snippetCount: number;
+    };
+}
+export interface SearchOptions {
+    fuzzy?: boolean;
+    threshold?: number;
+    limit?: number;
+    includeCode?: boolean;
+}
+export interface SearchResult {
+    snippet: CodeSnippet;
+    relevance: number;
+    matchHighlights?: {
+        title?: string[];
+        description?: string[];
+        tags?: string[];
+    };
 }
 export declare class CodeDatabase {
     private filePath;
     private db;
-    private loaded;
+    private lastModifiedTime;
     private mutex;
     constructor(storagePath?: string);
+    /**
+     * Load database from disk with automatic reload detection.
+     * Uses mtime to detect if file has been modified externally.
+     */
     private load;
+    /**
+     * Attempt to recover database from corrupted JSON
+     */
+    private attemptRecovery;
+    /**
+     * Backup corrupted database file
+     */
+    private backupCorruptedFile;
+    /**
+     * Atomic save using write-to-temp + rename pattern.
+     */
     private save;
+    /**
+     * Reload database from disk
+     */
+    reload(): Promise<void>;
     addSnippet(snippet: Omit<CodeSnippet, 'id' | 'updatedAt'>): Promise<CodeSnippet>;
-    searchSnippets(query: string): Promise<CodeSnippet[]>;
+    /**
+     * Enhanced search with relevance scoring and optional fuzzy matching
+     */
+    searchSnippets(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Get snippet by ID
+     */
+    getSnippet(id: string): Promise<CodeSnippet | null>;
+    /**
+     * Update snippet
+     */
+    updateSnippet(id: string, updates: Partial<Omit<CodeSnippet, 'id' | 'updatedAt'>>): Promise<CodeSnippet | null>;
+    /**
+     * Delete snippet
+     */
+    deleteSnippet(id: string): Promise<boolean>;
+    /**
+     * List all snippets with optional filtering
+     */
+    listSnippets(filter?: {
+        language?: string;
+        tags?: string[];
+        limit?: number;
+    }): Promise<CodeSnippet[]>;
     learnPattern(name: string, description: string): Promise<void>;
     getPattern(name: string): Promise<string | null>;
     listAllPatterns(): Promise<Record<string, string>>;
+    deletePattern(name: string): Promise<boolean>;
+    /**
+     * Search patterns with fuzzy matching
+     */
+    searchPatterns(query: string, limit?: number): Promise<Array<{
+        name: string;
+        description: string;
+        relevance: number;
+    }>>;
+    /**
+     * Get database statistics
+     */
+    getStats(): Promise<{
+        snippetCount: number;
+        patternCount: number;
+        languages: Record<string, number>;
+        totalTags: string[];
+        lastModified: string | null;
+    }>;
+    /**
+     * Export database as JSON string
+     */
+    export(): Promise<string>;
+    /**
+     * Import snippets from JSON string
+     */
+    import(jsonData: string, merge?: boolean): Promise<number>;
+    /**
+     * Clear all data (use with caution!)
+     */
+    clearAll(): Promise<void>;
+    /**
+     * Prepare embeddings for semantic search
+     * This is a placeholder for future integration with embedding models
+     * Call this after adding/updating snippets to enable semantic search
+     */
+    updateEmbeddings(): Promise<void>;
 }

package/dist/codestore.js

@@ -1,35 +1,273 @@
 import * as fs from 'fs/promises';
+import { existsSync, statSync } from 'fs';
 import * as path from 'path';
 import { AsyncMutex } from './utils.js';
+/**
+ * Simple fuzzy matching using character-by-character comparison
+ */
+function fuzzyMatch(pattern, text) {
+    const p = pattern.toLowerCase();
+    const t = text.toLowerCase();
+    let pIdx = 0;
+    let tIdx = 0;
+    let matches = 0;
+    while (pIdx < p.length && tIdx < t.length) {
+        if (p[pIdx] === t[tIdx]) {
+            matches++;
+            pIdx++;
+        }
+        tIdx++;
+    }
+    if (pIdx === p.length) {
+        // All pattern characters found - calculate score
+        const accuracy = matches / t.length;
+        const completeness = matches / p.length;
+        return (accuracy + completeness) / 2;
+    }
+    return 0;
+}
+/**
+ * Calculate relevance score for a snippet against a query
+ */
+function calculateRelevance(query, snippet, includeCode) {
+    const q = query.toLowerCase();
+    const qWords = q.split(/\s+/).filter(w => w.length > 0);
+    let score = 0;
+    const maxScore = qWords.length * 3; // Max possible score
+    for (const word of qWords) {
+        // Exact match in title = 3 points
+        if (snippet.title.toLowerCase().includes(word)) {
+            score += 3;
+        }
+        // Exact match in description = 2 points
+        else if (snippet.description.toLowerCase().includes(word)) {
+            score += 2;
+        }
+        // Match in tags = 2.5 points
+        else if (snippet.tags.some(t => t.toLowerCase().includes(word))) {
+            score += 2.5;
+        }
+        // Match in context = 1.5 points
+        else if (snippet.context?.toLowerCase().includes(word)) {
+            score += 1.5;
+        }
+        // Match in code (if enabled) = 1 point
+        else if (includeCode && snippet.code.toLowerCase().includes(word)) {
+            score += 1;
+        }
+        // Partial match (fuzzy) = 0.5 points
+        else {
+            let fuzzyFound = false;
+            const fields = [
+                snippet.title,
+                snippet.description,
+                ...snippet.tags,
+                snippet.context || '',
+                includeCode ? snippet.code : ''
+            ];
+            for (const field of fields) {
+                if (fuzzyMatch(word, field) > 0.3) {
+                    score += 0.5;
+                    fuzzyFound = true;
+                    break;
+                }
+            }
+            if (!fuzzyFound) {
+                // Very loose match - 0.1 points
+                if (fields.some(f => f.toLowerCase().includes(word.substring(0, Math.min(3, word.length))))) {
+                    score += 0.1;
+                }
+            }
+        }
+    }
+    return Math.min(score / maxScore, 1);
+}
 export class CodeDatabase {
     filePath;
-    db = { snippets: [], patterns: {} };
-    loaded = false;
+    db = { version: '2.0', snippets: [], patterns: {} };
+    lastModifiedTime = 0;
     mutex = new AsyncMutex();
     constructor(storagePath = 'code_database.json') {
         this.filePath = path.resolve(storagePath);
     }
-    async load() {
-        if (this.loaded)
-            return;
+    /**
+     * Load database from disk with automatic reload detection.
+     * Uses mtime to detect if file has been modified externally.
+     */
+    async load(forceReload = false) {
         try {
+            if (!existsSync(this.filePath)) {
+                this.db = { version: '2.0', snippets: [], patterns: {} };
+                this.lastModifiedTime = 0;
+                return;
+            }
+            const stats = statSync(this.filePath);
+            const currentMtime = stats.mtimeMs;
+            // Skip reload if file hasn't been modified (unless forced)
+            if (!forceReload && currentMtime === this.lastModifiedTime && this.db.snippets.length > 0) {
+                return;
+            }
             const data = await fs.readFile(this.filePath, 'utf-8');
-            this.db = JSON.parse(data);
+            if (!data.trim()) {
+                this.db = { version: '2.0', snippets: [], patterns: {} };
+                this.lastModifiedTime = currentMtime;
+                return;
+            }
+            try {
+                const parsed = JSON.parse(data);
+                // New format with version
+                if (parsed.version && parsed.snippets) {
+                    this.db = parsed;
+                }
+                // Legacy format
+                else if (parsed.snippets || parsed.patterns) {
+                    this.db = {
+                        version: '2.0',
+                        snippets: parsed.snippets || [],
+                        patterns: parsed.patterns || {}
+                    };
+                }
+                // Very old format (just array)
+                else if (Array.isArray(parsed)) {
+                    this.db = {
+                        version: '2.0',
+                        snippets: parsed,
+                        patterns: {}
+                    };
+                }
+                this.lastModifiedTime = currentMtime;
+            }
+            catch (parseError) {
+                console.error(`[CodeDatabase] Parse error, attempting recovery:`, parseError);
+                this.attemptRecovery(data);
+                this.lastModifiedTime = currentMtime;
+            }
         }
         catch (error) {
-            this.db = { snippets: [], patterns: {} };
+            if (error.code === 'ENOENT') {
+                this.db = { version: '2.0', snippets: [], patterns: {} };
+                this.lastModifiedTime = 0;
+            }
+            else {
+                console.error(`[CodeDatabase] Load error:`, error);
+                this.db = { version: '2.0', snippets: [], patterns: {} };
+                this.lastModifiedTime = 0;
+            }
         }
-        this.loaded = true;
     }
+    /**
+     * Attempt to recover database from corrupted JSON
+     */
+    attemptRecovery(data) {
+        let braceCount = 0;
+        let lastValidIndex = -1;
+        for (let i = 0; i < data.length; i++) {
+            const char = data[i];
+            if (char === '{') {
+                braceCount++;
+            }
+            else if (char === '}') {
+                braceCount--;
+                if (braceCount === 0) {
+                    lastValidIndex = i;
+                }
+            }
+        }
+        if (lastValidIndex !== -1) {
+            try {
+                const recoveredData = data.substring(0, lastValidIndex + 1).trim();
+                const parsed = JSON.parse(recoveredData);
+                if (parsed.version && parsed.snippets) {
+                    this.db = parsed;
+                }
+                else if (parsed.snippets || parsed.patterns) {
+                    this.db = {
+                        version: '2.0',
+                        snippets: parsed.snippets || [],
+                        patterns: parsed.patterns || {}
+                    };
+                }
+                else if (Array.isArray(parsed)) {
+                    this.db = { version: '2.0', snippets: parsed, patterns: {} };
+                }
+                else {
+                    this.db = { version: '2.0', snippets: [], patterns: {} };
+                }
+                this.backupCorruptedFile(data);
+                console.log(`[CodeDatabase] Recovered ${this.db.snippets.length} snippets.`);
+            }
+            catch (recoveryError) {
+                console.error('[CodeDatabase] Recovery failed:', recoveryError);
+                this.db = { version: '2.0', snippets: [], patterns: {} };
+                this.backupCorruptedFile(data);
+            }
+        }
+        else {
+            console.error('[CodeDatabase] No valid JSON structure found.');
+            this.db = { version: '2.0', snippets: [], patterns: {} };
+        }
+    }
+    /**
+     * Backup corrupted database file
+     */
+    async backupCorruptedFile(corruptedData) {
+        try {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const backupPath = `${this.filePath}.corrupted.${timestamp}`;
+            await fs.writeFile(backupPath, corruptedData, 'utf-8');
+            console.error(`[CodeDatabase] Corrupted data backed up to: ${backupPath}`);
+        }
+        catch (backupError) {
+            console.error('[CodeDatabase] Failed to backup corrupted file:', backupError);
+        }
+    }
+    /**
+     * Atomic save using write-to-temp + rename pattern.
+     */
     async save() {
-        await fs.writeFile(this.filePath, JSON.stringify(this.db, null, 2), 'utf-8');
+        const tmpPath = `${this.filePath}.tmp`;
+        // Prepare storage format
+        const storage = {
+            version: '2.0',
+            snippets: this.db.snippets,
+            patterns: this.db.patterns,
+            metadata: {
+                lastModified: new Date().toISOString(),
+                snippetCount: this.db.snippets.length
+            }
+        };
+        try {
+            // Step 1: Write to temporary file
+            await fs.writeFile(tmpPath, JSON.stringify(storage, null, 2), 'utf-8');
+            // Step 2: Atomic rename
+            await fs.rename(tmpPath, this.filePath);
+            // Step 3: Update mtime cache
+            const stats = await fs.stat(this.filePath);
+            this.lastModifiedTime = stats.mtimeMs;
+        }
+        catch (error) {
+            // Clean up temp file if something went wrong
+            try {
+                await fs.unlink(tmpPath);
+            }
+            catch { }
+            throw error;
+        }
+    }
+    /**
+     * Reload database from disk
+     */
+    async reload() {
+        return this.mutex.dispatch(async () => {
+            await this.load(true);
+        });
     }
     async addSnippet(snippet) {
         return this.mutex.dispatch(async () => {
             await this.load();
             const newSnippet = {
                 ...snippet,
-                id: Math.random().toString(36).substring(2, 9),
+                id: `${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 9)}`,
                 updatedAt: new Date().toISOString()
             };
             this.db.snippets.push(newSnippet);
@@ -37,14 +275,106 @@ export class CodeDatabase {
             return newSnippet;
         });
     }
-    async searchSnippets(query) {
+    /**
+     * Enhanced search with relevance scoring and optional fuzzy matching
+     */
+    async searchSnippets(query, options = {}) {
         return this.mutex.dispatch(async () => {
             await this.load();
-            const q = query.toLowerCase();
-            return this.db.snippets.filter(s => s.title.toLowerCase().includes(q) ||
-                s.description.toLowerCase().includes(q) ||
-                s.tags.some(t => t.toLowerCase().includes(q)) ||
-                s.code.toLowerCase().includes(q));
+            const { fuzzy = true, threshold = 0.1, limit = 50, includeCode = true } = options;
+            if (!query.trim()) {
+                return this.db.snippets.slice(0, limit).map(snippet => ({
+                    snippet,
+                    relevance: 1
+                }));
+            }
+            const results = [];
+            for (const snippet of this.db.snippets) {
+                let relevance = 0;
+                if (fuzzy) {
+                    relevance = calculateRelevance(query, snippet, includeCode);
+                }
+                else {
+                    // Simple exact match only
+                    const q = query.toLowerCase();
+                    relevance =
+                        (snippet.title.toLowerCase().includes(q) ? 1 : 0) +
+                            (snippet.description.toLowerCase().includes(q) ? 0.8 : 0) +
+                            (snippet.tags.some(t => t.toLowerCase().includes(q)) ? 0.9 : 0) +
+                            (includeCode && snippet.code.toLowerCase().includes(q) ? 0.5 : 0);
+                    relevance = Math.min(relevance, 1);
+                }
+                if (relevance >= threshold) {
+                    results.push({
+                        snippet,
+                        relevance
+                    });
+                }
+            }
+            // Sort by relevance (highest first)
+            results.sort((a, b) => b.relevance - a.relevance);
+            return results.slice(0, limit);
+        });
+    }
+    /**
+     * Get snippet by ID
+     */
+    async getSnippet(id) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            return this.db.snippets.find(s => s.id === id) || null;
+        });
+    }
+    /**
+     * Update snippet
+     */
+    async updateSnippet(id, updates) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const index = this.db.snippets.findIndex(s => s.id === id);
+            if (index === -1)
+                return null;
+            this.db.snippets[index] = {
+                ...this.db.snippets[index],
+                ...updates,
+                updatedAt: new Date().toISOString()
+            };
+            await this.save();
+            return this.db.snippets[index];
+        });
+    }
+    /**
+     * Delete snippet
+     */
+    async deleteSnippet(id) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const initialLength = this.db.snippets.length;
+            this.db.snippets = this.db.snippets.filter(s => s.id !== id);
+            if (this.db.snippets.length !== initialLength) {
+                await this.save();
+                return true;
+            }
+            return false;
+        });
+    }
+    /**
+     * List all snippets with optional filtering
+     */
+    async listSnippets(filter) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            let results = this.db.snippets;
+            if (filter?.language) {
+                results = results.filter(s => s.language.toLowerCase() === filter.language.toLowerCase());
+            }
+            if (filter?.tags && filter.tags.length > 0) {
+                results = results.filter(s => filter.tags.some(t => s.tags.includes(t)));
+            }
+            if (filter?.limit) {
+                results = results.slice(0, filter.limit);
+            }
+            return results;
         });
     }
     async learnPattern(name, description) {
@@ -63,7 +393,159 @@ export class CodeDatabase {
     async listAllPatterns() {
         return this.mutex.dispatch(async () => {
             await this.load();
-            return this.db.patterns;
+            return { ...this.db.patterns };
+        });
+    }
+    async deletePattern(name) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            if (name in this.db.patterns) {
+                delete this.db.patterns[name];
+                await this.save();
+                return true;
+            }
+            return false;
+        });
+    }
+    /**
+     * Search patterns with fuzzy matching
+     */
+    async searchPatterns(query, limit = 20) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            if (!query.trim()) {
+                return Object.entries(this.db.patterns)
+                    .slice(0, limit)
+                    .map(([name, description]) => ({ name, description, relevance: 1 }));
+            }
+            const q = query.toLowerCase();
+            const results = [];
+            for (const [name, description] of Object.entries(this.db.patterns)) {
+                let relevance = 0;
+                // Exact name match = highest priority
+                if (name.toLowerCase() === q) {
+                    relevance = 1;
+                }
+                // Name contains query
+                else if (name.toLowerCase().includes(q)) {
+                    relevance = 0.8;
+                }
+                // Description contains query
+                else if (description.toLowerCase().includes(q)) {
+                    relevance = 0.6;
+                }
+                // Fuzzy match
+                else {
+                    const nameScore = fuzzyMatch(q, name);
+                    const descScore = fuzzyMatch(q, description);
+                    relevance = Math.max(nameScore, descScore) * 0.5;
+                }
+                if (relevance > 0.1) {
+                    results.push({ name, description, relevance });
+                }
+            }
+            results.sort((a, b) => b.relevance - a.relevance);
+            return results.slice(0, limit);
         });
     }
+    /**
+     * Get database statistics
+     */
+    async getStats() {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const languages = {};
+            const allTags = new Set();
+            for (const snippet of this.db.snippets) {
+                languages[snippet.language] = (languages[snippet.language] || 0) + 1;
+                snippet.tags.forEach(t => allTags.add(t));
+            }
+            return {
+                snippetCount: this.db.snippets.length,
+                patternCount: Object.keys(this.db.patterns).length,
+                languages,
+                totalTags: Array.from(allTags),
+                lastModified: this.db.metadata?.lastModified || null
+            };
+        });
+    }
+    /**
+     * Export database as JSON string
+     */
+    async export() {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            return JSON.stringify({
+                version: '2.0',
+                snippets: this.db.snippets,
+                patterns: this.db.patterns,
+                exportedAt: new Date().toISOString()
+            }, null, 2);
+        });
+    }
+    /**
+     * Import snippets from JSON string
+     */
+    async import(jsonData, merge = false) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            try {
+                const parsed = JSON.parse(jsonData);
+                let importedSnippets = [];
+                if (parsed.version && parsed.snippets) {
+                    importedSnippets = parsed.snippets;
+                }
+                else if (Array.isArray(parsed)) {
+                    importedSnippets = parsed;
+                }
+                if (merge) {
+                    // Merge: avoid duplicates by ID
+                    const existingIds = new Set(this.db.snippets.map(s => s.id));
+                    for (const snippet of importedSnippets) {
+                        if (!existingIds.has(snippet.id)) {
+                            this.db.snippets.push(snippet);
+                            existingIds.add(snippet.id);
+                        }
+                    }
+                }
+                else {
+                    // Replace all
+                    this.db.snippets = importedSnippets;
+                }
+                // Import patterns too
+                if (parsed.patterns) {
+                    if (merge) {
+                        Object.assign(this.db.patterns, parsed.patterns);
+                    }
+                    else {
+                        this.db.patterns = parsed.patterns;
+                    }
+                }
+                await this.save();
+                return this.db.snippets.length;
+            }
+            catch (error) {
+                throw new Error(`Failed to import database: ${error}`);
+            }
+        });
+    }
+    /**
+     * Clear all data (use with caution!)
+     */
+    async clearAll() {
+        return this.mutex.dispatch(async () => {
+            this.db = { version: '2.0', snippets: [], patterns: {} };
+            await this.save();
+        });
+    }
+    /**
+     * Prepare embeddings for semantic search
+     * This is a placeholder for future integration with embedding models
+     * Call this after adding/updating snippets to enable semantic search
+     */
+    async updateEmbeddings() {
+        // TODO: Integrate with an embedding service (e.g., OpenAI embeddings, local transformers)
+        // For now, this is a no-op placeholder
+        console.log('[CodeDatabase] Embedding update not yet implemented. Requires external embedding service.');
+    }
 }