mcmodding-mcp 0.1.0

package/dist/indexer/store.js

@@ -0,0 +1,857 @@
+import Database from 'better-sqlite3';
+const SCHEMA_VERSION = 1;
+export class DocumentStore {
+    db;
+    constructor(dbPath) {
+        this.db = new Database(dbPath);
+        this.initializeSchema();
+    }
+    initializeSchema() {
+        this.db.exec(`
+      -- Metadata table for versioning
+      CREATE TABLE IF NOT EXISTS metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      -- Documents table
+      CREATE TABLE IF NOT EXISTS documents (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        url TEXT UNIQUE NOT NULL,
+        title TEXT NOT NULL,
+        content TEXT NOT NULL,
+        raw_html TEXT,
+        category TEXT NOT NULL,
+        loader TEXT NOT NULL,
+        minecraft_version TEXT,
+        hash TEXT NOT NULL,
+        indexed_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      -- Sections table for structured content
+      CREATE TABLE IF NOT EXISTS sections (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        document_id INTEGER NOT NULL,
+        heading TEXT NOT NULL,
+        level INTEGER NOT NULL,
+        content TEXT NOT NULL,
+        order_num INTEGER NOT NULL,
+        FOREIGN KEY (document_id) REFERENCES documents(id) ON DELETE CASCADE
+      );
+
+      -- Code blocks table
+      CREATE TABLE IF NOT EXISTS code_blocks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        section_id INTEGER NOT NULL,
+        language TEXT NOT NULL,
+        code TEXT NOT NULL,
+        caption TEXT,
+        FOREIGN KEY (section_id) REFERENCES sections(id) ON DELETE CASCADE
+      );
+
+      -- Chunks table for optimized search
+      CREATE TABLE IF NOT EXISTS chunks (
+        id TEXT PRIMARY KEY,
+        document_id INTEGER NOT NULL,
+        chunk_type TEXT NOT NULL,
+        content TEXT NOT NULL,
+        section_heading TEXT,
+        section_level INTEGER,
+        code_language TEXT,
+        order_num INTEGER NOT NULL,
+        word_count INTEGER NOT NULL,
+        has_code BOOLEAN NOT NULL,
+        FOREIGN KEY (document_id) REFERENCES documents(id) ON DELETE CASCADE
+      );
+
+      -- Embeddings table for semantic search
+      CREATE TABLE IF NOT EXISTS embeddings (
+        chunk_id TEXT PRIMARY KEY,
+        embedding BLOB NOT NULL,
+        dimension INTEGER NOT NULL,
+        model TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (chunk_id) REFERENCES chunks(id) ON DELETE CASCADE
+      );
+
+      -- Full-text search indexes
+      CREATE VIRTUAL TABLE IF NOT EXISTS documents_fts USING fts5(
+        title,
+        content,
+        category,
+        content='documents',
+        content_rowid='id'
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+        content,
+        section_heading,
+        content='chunks',
+        content_rowid='rowid'
+      );
+
+      -- Indexes for performance
+      CREATE INDEX IF NOT EXISTS idx_documents_loader ON documents(loader);
+      CREATE INDEX IF NOT EXISTS idx_documents_category ON documents(category);
+      CREATE INDEX IF NOT EXISTS idx_documents_hash ON documents(hash);
+      CREATE INDEX IF NOT EXISTS idx_documents_version ON documents(minecraft_version);
+      CREATE INDEX IF NOT EXISTS idx_chunks_document ON chunks(document_id);
+      CREATE INDEX IF NOT EXISTS idx_chunks_type ON chunks(chunk_type);
+      CREATE INDEX IF NOT EXISTS idx_embeddings_model ON embeddings(model);
+
+      -- Triggers for FTS sync
+      CREATE TRIGGER IF NOT EXISTS documents_ai AFTER INSERT ON documents BEGIN
+        INSERT INTO documents_fts(rowid, title, content, category)
+        VALUES (new.id, new.title, new.content, new.category);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS documents_ad AFTER DELETE ON documents BEGIN
+        DELETE FROM documents_fts WHERE rowid = old.id;
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS documents_au AFTER UPDATE ON documents BEGIN
+        UPDATE documents_fts SET
+          title = new.title,
+          content = new.content,
+          category = new.category
+        WHERE rowid = new.id;
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS chunks_ai AFTER INSERT ON chunks BEGIN
+        INSERT INTO chunks_fts(rowid, content, section_heading)
+        VALUES (new.rowid, new.content, new.section_heading);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS chunks_ad AFTER DELETE ON chunks BEGIN
+        DELETE FROM chunks_fts WHERE rowid = old.rowid;
+      END;
+    `);
+        this.initializeMetadata();
+    }
+    initializeMetadata() {
+        const stmt = this.db.prepare('INSERT OR IGNORE INTO metadata (key, value) VALUES (?, ?)');
+        stmt.run('schema_version', SCHEMA_VERSION.toString());
+        stmt.run('index_version', '0.1.0');
+        stmt.run('last_updated', new Date().toISOString());
+    }
+    needsUpdate(url, hash) {
+        const stmt = this.db.prepare('SELECT hash FROM documents WHERE url = ?');
+        const result = stmt.get(url);
+        return !result || result.hash !== hash;
+    }
+    storeDocument(doc) {
+        const insert = this.db.prepare(`
+      INSERT OR REPLACE INTO documents (url, title, content, raw_html, category, loader, hash, minecraft_version, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+    `);
+        const result = insert.run(doc.url, doc.title, doc.content, doc.rawHtml, doc.category, doc.loader, doc.hash, doc.minecraftVersion || null);
+        const documentId = result.lastInsertRowid;
+        this.db.prepare('DELETE FROM sections WHERE document_id = ?').run(documentId);
+        for (const section of doc.sections) {
+            this.storeSection(documentId, section);
+        }
+        return documentId;
+    }
+    storeSection(documentId, section) {
+        const insert = this.db.prepare(`
+      INSERT INTO sections (document_id, heading, level, content, order_num)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        const result = insert.run(documentId, section.heading, section.level, section.content, section.order);
+        const sectionId = result.lastInsertRowid;
+        const codeInsert = this.db.prepare(`
+      INSERT INTO code_blocks (section_id, language, code, caption)
+      VALUES (?, ?, ?, ?)
+    `);
+        for (const block of section.codeBlocks) {
+            codeInsert.run(sectionId, block.language, block.code, block.caption || null);
+        }
+        return sectionId;
+    }
+    storeChunks(chunks, documentId) {
+        this.db.prepare('DELETE FROM chunks WHERE document_id = ?').run(documentId);
+        const insert = this.db.prepare(`
+      INSERT INTO chunks (
+        id, document_id, chunk_type, content, section_heading, section_level,
+        code_language, order_num, word_count, has_code
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        for (const chunk of chunks) {
+            insert.run(chunk.id, documentId, chunk.chunkType, chunk.content, chunk.sectionHeading || null, chunk.sectionLevel || null, chunk.codeLanguage || null, chunk.order, chunk.metadata.wordCount, chunk.metadata.hasCode ? 1 : 0);
+        }
+    }
+    searchChunks(query, category, loader, limit = 10) {
+        let sql = `
+      SELECT
+        c.id,
+        c.content,
+        c.chunk_type,
+        c.section_heading,
+        c.code_language,
+        d.url,
+        d.title,
+        d.category,
+        d.loader,
+        chunks_fts.rank
+      FROM chunks_fts
+      JOIN chunks c ON chunks_fts.rowid = c.rowid
+      JOIN documents d ON c.document_id = d.id
+      WHERE chunks_fts MATCH ?
+    `;
+        const params = [query];
+        if (category && category !== 'all') {
+            sql += ' AND d.category = ?';
+            params.push(category);
+        }
+        if (loader) {
+            sql += ' AND d.loader = ?';
+            params.push(loader);
+        }
+        sql += ` ORDER BY chunks_fts.rank LIMIT ?`;
+        params.push(limit);
+        const stmt = this.db.prepare(sql);
+        return stmt.all(...params);
+    }
+    searchDocuments(query, category, loader, limit = 10) {
+        let sql = `
+      SELECT
+        d.id,
+        d.url,
+        d.title,
+        d.content,
+        d.category,
+        d.loader,
+        documents_fts.rank
+      FROM documents_fts
+      JOIN documents d ON documents_fts.rowid = d.id
+      WHERE documents_fts MATCH ?
+    `;
+        const params = [query];
+        if (category && category !== 'all') {
+            sql += ' AND d.category = ?';
+            params.push(category);
+        }
+        if (loader) {
+            sql += ' AND d.loader = ?';
+            params.push(loader);
+        }
+        sql += ` ORDER BY documents_fts.rank LIMIT ?`;
+        params.push(limit);
+        const stmt = this.db.prepare(sql);
+        return stmt.all(...params);
+    }
+    getStats() {
+        const docCount = this.db.prepare('SELECT COUNT(*) as count FROM documents').get();
+        const sectionCount = this.db.prepare('SELECT COUNT(*) as count FROM sections').get();
+        const codeCount = this.db.prepare('SELECT COUNT(*) as count FROM code_blocks').get();
+        const loaderCounts = this.db
+            .prepare('SELECT loader, COUNT(*) as count FROM documents GROUP BY loader')
+            .all();
+        const lastUpdated = this.db
+            .prepare("SELECT value FROM metadata WHERE key = 'last_updated'")
+            .get();
+        const version = this.db
+            .prepare("SELECT value FROM metadata WHERE key = 'index_version'")
+            .get();
+        const loaders = {
+            fabric: 0,
+            neoforge: 0,
+            shared: 0,
+        };
+        for (const item of loaderCounts) {
+            if (item.loader in loaders) {
+                loaders[item.loader] = item.count;
+            }
+        }
+        return {
+            totalDocuments: docCount.count,
+            totalSections: sectionCount.count,
+            totalCodeBlocks: codeCount.count,
+            lastUpdated: new Date(lastUpdated.value),
+            version: version.value,
+            loaders,
+        };
+    }
+    updateTimestamp() {
+        this.db
+            .prepare("UPDATE metadata SET value = ? WHERE key = 'last_updated'")
+            .run(new Date().toISOString());
+    }
+    getAllUrls() {
+        const results = this.db.prepare('SELECT url FROM documents').all();
+        return results.map((r) => r.url);
+    }
+    storeEmbeddings(embeddings, model) {
+        const insert = this.db.prepare(`
+      INSERT OR REPLACE INTO embeddings (chunk_id, embedding, dimension, model)
+      VALUES (?, ?, ?, ?)
+    `);
+        for (const item of embeddings) {
+            const buffer = Buffer.from(new Float32Array(item.embedding).buffer);
+            insert.run(item.chunkId, buffer, item.embedding.length, model);
+        }
+    }
+    getEmbedding(chunkId) {
+        const stmt = this.db.prepare('SELECT embedding, dimension FROM embeddings WHERE chunk_id = ?');
+        const result = stmt.get(chunkId);
+        if (!result)
+            return undefined;
+        const float32Array = new Float32Array(result.embedding.buffer, result.embedding.byteOffset, result.embedding.byteLength / Float32Array.BYTES_PER_ELEMENT);
+        return Array.from(float32Array);
+    }
+    getAllEmbeddings() {
+        const stmt = this.db.prepare('SELECT chunk_id, embedding, dimension FROM embeddings');
+        const results = stmt.all();
+        return results.map((row) => {
+            const float32Array = new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / Float32Array.BYTES_PER_ELEMENT);
+            return {
+                chunkId: row.chunk_id,
+                embedding: Array.from(float32Array),
+            };
+        });
+    }
+    getEmbeddingsBatch(batchSize = 500, offset = 0) {
+        const stmt = this.db.prepare('SELECT chunk_id, embedding, dimension FROM embeddings LIMIT ? OFFSET ?');
+        const results = stmt.all(batchSize, offset);
+        return results.map((row) => {
+            const float32Array = new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / Float32Array.BYTES_PER_ELEMENT);
+            return {
+                chunkId: row.chunk_id,
+                embedding: Array.from(float32Array),
+            };
+        });
+    }
+    getEmbeddingCount() {
+        const stmt = this.db.prepare('SELECT COUNT(*) as count FROM embeddings');
+        const result = stmt.get();
+        return result.count;
+    }
+    deleteEmbeddings(documentId) {
+        this.db
+            .prepare(`
+      DELETE FROM embeddings
+      WHERE chunk_id IN (
+        SELECT id FROM chunks WHERE document_id = ?
+      )
+    `)
+            .run(documentId);
+    }
+    getDocumentsByVersion(version) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM documents WHERE minecraft_version = ?
+    `);
+        return stmt.all(version);
+    }
+    getAllVersions() {
+        const stmt = this.db.prepare(`
+      SELECT DISTINCT minecraft_version FROM documents
+      WHERE minecraft_version IS NOT NULL
+      ORDER BY minecraft_version DESC
+    `);
+        const results = stmt.all();
+        return results.map((r) => r.minecraft_version);
+    }
+    searchByVersion(query, version, category, loader, limit = 10) {
+        let sql = `
+      SELECT
+        c.id,
+        c.content,
+        c.chunk_type,
+        c.section_heading,
+        c.code_language,
+        d.url,
+        d.title,
+        d.category,
+        d.loader,
+        d.minecraft_version,
+        chunks_fts.rank
+      FROM chunks_fts
+      JOIN chunks c ON chunks_fts.rowid = c.rowid
+      JOIN documents d ON c.document_id = d.id
+      WHERE chunks_fts MATCH ? AND d.minecraft_version = ?
+    `;
+        const params = [query, version];
+        if (category && category !== 'all') {
+            sql += ' AND d.category = ?';
+            params.push(category);
+        }
+        if (loader) {
+            sql += ' AND d.loader = ?';
+            params.push(loader);
+        }
+        sql += ` ORDER BY chunks_fts.rank LIMIT ?`;
+        params.push(limit);
+        const stmt = this.db.prepare(sql);
+        return stmt.all(...params);
+    }
+    getEmbeddingStats() {
+        const total = this.db.prepare('SELECT COUNT(*) as count FROM embeddings').get();
+        const models = this.db
+            .prepare('SELECT model, COUNT(*) as count FROM embeddings GROUP BY model')
+            .all();
+        return {
+            totalEmbeddings: total.count,
+            models,
+        };
+    }
+    searchCodeExamples(topic, options = {}) {
+        const { language, minecraftVersion, loader, category, limit = 10 } = options;
+        const searchQuery = topic.trim();
+        let sql = `
+      SELECT
+        c.id,
+        c.content,
+        c.chunk_type,
+        c.section_heading,
+        c.section_level,
+        c.code_language,
+        c.has_code,
+        d.id as document_id,
+        d.url,
+        d.title,
+        d.category,
+        d.loader,
+        d.minecraft_version,
+        chunks_fts.rank
+      FROM chunks_fts
+      JOIN chunks c ON chunks_fts.rowid = c.rowid
+      JOIN documents d ON c.document_id = d.id
+      WHERE chunks_fts MATCH ?
+        AND c.has_code = 1
+    `;
+        const params = [searchQuery];
+        if (language) {
+            sql += ' AND c.code_language = ?';
+            params.push(language);
+        }
+        if (minecraftVersion) {
+            sql += ' AND d.minecraft_version = ?';
+            params.push(minecraftVersion);
+        }
+        if (loader) {
+            sql += ' AND d.loader = ?';
+            params.push(loader);
+        }
+        if (category && category !== 'all') {
+            sql += ' AND d.category = ?';
+            params.push(category);
+        }
+        sql += ` ORDER BY chunks_fts.rank LIMIT ?`;
+        params.push(limit);
+        const stmt = this.db.prepare(sql);
+        return stmt.all(...params);
+    }
+    getCodeBlocksWithContext(documentId) {
+        const sql = `
+      SELECT
+        cb.id,
+        cb.language,
+        cb.code,
+        cb.caption,
+        s.heading as section_heading,
+        s.level as section_level,
+        s.content as section_content,
+        d.id as document_id,
+        d.title as document_title,
+        d.url as document_url,
+        d.category,
+        d.loader,
+        d.minecraft_version
+      FROM code_blocks cb
+      JOIN sections s ON cb.section_id = s.id
+      JOIN documents d ON s.document_id = d.id
+      WHERE d.id = ?
+      ORDER BY s.order_num, cb.id
+    `;
+        const stmt = this.db.prepare(sql);
+        return stmt.all(documentId);
+    }
+    getCodeBlocksByLanguage(language, options = {}) {
+        const { loader, minecraftVersion, limit = 20 } = options;
+        let sql = `
+      SELECT
+        cb.id,
+        cb.language,
+        cb.code,
+        cb.caption,
+        s.heading as section_heading,
+        s.level as section_level,
+        s.content as section_content,
+        d.id as document_id,
+        d.title as document_title,
+        d.url as document_url,
+        d.category,
+        d.loader,
+        d.minecraft_version
+      FROM code_blocks cb
+      JOIN sections s ON cb.section_id = s.id
+      JOIN documents d ON s.document_id = d.id
+      WHERE cb.language = ?
+    `;
+        const params = [language];
+        if (loader) {
+            sql += ' AND d.loader = ?';
+            params.push(loader);
+        }
+        if (minecraftVersion) {
+            sql += ' AND d.minecraft_version = ?';
+            params.push(minecraftVersion);
+        }
+        sql += ' ORDER BY d.id, s.order_num LIMIT ?';
+        params.push(limit);
+        const stmt = this.db.prepare(sql);
+        return stmt.all(...params);
+    }
+    searchSections(query, options = {}) {
+        const { loader, minecraftVersion, category, limit = 10 } = options;
+        let sql = `
+      SELECT
+        s.id,
+        s.heading,
+        s.level,
+        s.content,
+        s.order_num,
+        d.id as document_id,
+        d.title as document_title,
+        d.url as document_url,
+        d.category,
+        d.loader,
+        d.minecraft_version
+      FROM sections s
+      JOIN documents d ON s.document_id = d.id
+      WHERE s.heading LIKE ? OR s.content LIKE ?
+    `;
+        const searchPattern = `%${query}%`;
+        const params = [searchPattern, searchPattern];
+        if (loader) {
+            sql += ' AND d.loader = ?';
+            params.push(loader);
+        }
+        if (minecraftVersion) {
+            sql += ' AND d.minecraft_version = ?';
+            params.push(minecraftVersion);
+        }
+        if (category && category !== 'all') {
+            sql += ' AND d.category = ?';
+            params.push(category);
+        }
+        sql += ' ORDER BY s.order_num LIMIT ?';
+        params.push(limit);
+        const stmt = this.db.prepare(sql);
+        return stmt.all(...params);
+    }
+    getAvailableLanguages() {
+        const sql = `
+      SELECT code_language as language, COUNT(*) as count
+      FROM chunks
+      WHERE has_code = 1 AND code_language IS NOT NULL
+      GROUP BY code_language
+      ORDER BY count DESC
+    `;
+        const stmt = this.db.prepare(sql);
+        return stmt.all();
+    }
+    findSimilarChunks(embedding, options = {}) {
+        const { limit = 10, loader, minecraftVersion, category } = options;
+        let sql = `
+      SELECT
+        e.chunk_id,
+        e.embedding,
+        c.content,
+        c.chunk_type,
+        c.section_heading,
+        c.section_level,
+        c.code_language,
+        c.has_code,
+        d.id as document_id,
+        d.url,
+        d.title,
+        d.category,
+        d.loader,
+        d.minecraft_version
+      FROM embeddings e
+      JOIN chunks c ON e.chunk_id = c.id
+      JOIN documents d ON c.document_id = d.id
+      WHERE 1=1
+    `;
+        const params = [];
+        if (loader) {
+            sql += ' AND d.loader = ?';
+            params.push(loader);
+        }
+        if (category && category !== 'all') {
+            sql += ' AND d.category = ?';
+            params.push(category);
+        }
+        if (minecraftVersion) {
+            if (minecraftVersion.includes('%')) {
+                sql += ' AND d.minecraft_version LIKE ?';
+                params.push(minecraftVersion);
+            }
+            else {
+                sql += ' AND d.minecraft_version = ?';
+                params.push(minecraftVersion);
+            }
+        }
+        const stmt = this.db.prepare(sql);
+        const candidates = stmt.all(...params);
+        const results = candidates.map((candidate) => {
+            const vector = new Float32Array(candidate.embedding.buffer, candidate.embedding.byteOffset, candidate.embedding.byteLength / 4);
+            const similarity = this.cosineSimilarity(embedding, vector);
+            return { ...candidate, similarity };
+        });
+        return results.sort((a, b) => b.similarity - a.similarity).slice(0, limit);
+    }
+    cosineSimilarity(a, b) {
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+    searchChunksAdvanced(ftsQuery, likePatterns, options = {}) {
+        const { hasCode = true, language, loader, minecraftVersion, category, limit = 30 } = options;
+        let results = [];
+        if (ftsQuery && ftsQuery.length > 0) {
+            try {
+                let sql = `
+          SELECT
+            c.id,
+            c.content,
+            c.chunk_type,
+            c.section_heading,
+            c.section_level,
+            c.code_language,
+            c.has_code,
+            d.id as document_id,
+            d.url,
+            d.title,
+            d.category,
+            d.loader,
+            d.minecraft_version
+          FROM chunks_fts
+          JOIN chunks c ON chunks_fts.rowid = c.rowid
+          JOIN documents d ON c.document_id = d.id
+          WHERE chunks_fts MATCH ?
+        `;
+                const params = [ftsQuery];
+                if (hasCode) {
+                    sql += ' AND c.has_code = 1';
+                }
+                if (language) {
+                    sql += ' AND c.code_language = ?';
+                    params.push(language);
+                }
+                if (loader) {
+                    sql += ' AND d.loader = ?';
+                    params.push(loader);
+                }
+                if (minecraftVersion) {
+                    sql += ' AND d.minecraft_version = ?';
+                    params.push(minecraftVersion);
+                }
+                if (category && category !== 'all') {
+                    sql += ' AND d.category = ?';
+                    params.push(category);
+                }
+                sql += ` ORDER BY rank LIMIT ?`;
+                params.push(limit);
+                const stmt = this.db.prepare(sql);
+                results = stmt.all(...params);
+            }
+            catch {
+                console.error('[store] FTS query failed, trying LIKE fallback');
+            }
+        }
+        if (results.length === 0 && likePatterns.length > 0) {
+            const likeConditions = likePatterns
+                .slice(0, 3)
+                .map(() => '(c.content LIKE ? OR c.section_heading LIKE ?)')
+                .join(' OR ');
+            let sql = `
+        SELECT
+          c.id,
+          c.content,
+          c.chunk_type,
+          c.section_heading,
+          c.section_level,
+          c.code_language,
+          c.has_code,
+          d.id as document_id,
+          d.url,
+          d.title,
+          d.category,
+          d.loader,
+          d.minecraft_version
+        FROM chunks c
+        JOIN documents d ON c.document_id = d.id
+        WHERE (${likeConditions})
+      `;
+            const params = [];
+            for (const pattern of likePatterns.slice(0, 3)) {
+                params.push(pattern, pattern);
+            }
+            if (hasCode) {
+                sql += ' AND c.has_code = 1';
+            }
+            if (language) {
+                sql += ' AND c.code_language = ?';
+                params.push(language);
+            }
+            if (loader) {
+                sql += ' AND d.loader = ?';
+                params.push(loader);
+            }
+            if (minecraftVersion) {
+                sql += ' AND d.minecraft_version = ?';
+                params.push(minecraftVersion);
+            }
+            if (category && category !== 'all') {
+                sql += ' AND d.category = ?';
+                params.push(category);
+            }
+            sql += ` LIMIT ?`;
+            params.push(limit);
+            const stmt = this.db.prepare(sql);
+            results = stmt.all(...params);
+        }
+        return results;
+    }
+    searchDocumentsLike(patterns, options = {}) {
+        const { loader, minecraftVersion, category, limit = 20 } = options;
+        if (patterns.length === 0)
+            return [];
+        const likeConditions = patterns
+            .slice(0, 3)
+            .map(() => '(d.title LIKE ? OR d.content LIKE ?)')
+            .join(' OR ');
+        let sql = `
+      SELECT
+        d.id,
+        d.url,
+        d.title,
+        d.content,
+        d.category,
+        d.loader,
+        d.minecraft_version
+      FROM documents d
+      WHERE (${likeConditions})
+    `;
+        const params = [];
+        for (const pattern of patterns.slice(0, 3)) {
+            params.push(pattern, pattern);
+        }
+        if (loader) {
+            sql += ' AND d.loader = ?';
+            params.push(loader);
+        }
+        if (minecraftVersion) {
+            sql += ' AND d.minecraft_version = ?';
+            params.push(minecraftVersion);
+        }
+        if (category && category !== 'all') {
+            sql += ' AND d.category = ?';
+            params.push(category);
+        }
+        sql += ` LIMIT ?`;
+        params.push(limit);
+        const stmt = this.db.prepare(sql);
+        return stmt.all(...params);
+    }
+    searchCodeBlocksByPatterns(codePatterns, options = {}) {
+        const { language, loader, minecraftVersion, limit = 20 } = options;
+        if (codePatterns.length === 0)
+            return [];
+        const likeConditions = codePatterns
+            .slice(0, 5)
+            .map(() => 'cb.code LIKE ?')
+            .join(' OR ');
+        let sql = `
+      SELECT
+        cb.id,
+        cb.language,
+        cb.code,
+        cb.caption,
+        s.heading as section_heading,
+        s.level as section_level,
+        s.content as section_content,
+        d.id as document_id,
+        d.title as document_title,
+        d.url as document_url,
+        d.category,
+        d.loader,
+        d.minecraft_version
+      FROM code_blocks cb
+      JOIN sections s ON cb.section_id = s.id
+      JOIN documents d ON s.document_id = d.id
+      WHERE (${likeConditions})
+    `;
+        const params = codePatterns.slice(0, 5).map((p) => `%${p}%`);
+        if (language) {
+            sql += ' AND cb.language = ?';
+            params.push(language);
+        }
+        if (loader) {
+            sql += ' AND d.loader = ?';
+            params.push(loader);
+        }
+        if (minecraftVersion) {
+            sql += ' AND d.minecraft_version = ?';
+            params.push(minecraftVersion);
+        }
+        sql += ` ORDER BY d.id, s.order_num LIMIT ?`;
+        params.push(limit);
+        const stmt = this.db.prepare(sql);
+        return stmt.all(...params);
+    }
+    getAllCodeBlocksWithContext(options = {}) {
+        const { language, loader, minecraftVersion, limit = 100 } = options;
+        let sql = `
+      SELECT
+        cb.id,
+        cb.language,
+        cb.code,
+        cb.caption,
+        s.heading as section_heading,
+        s.level as section_level,
+        s.content as section_content,
+        d.id as document_id,
+        d.title as document_title,
+        d.url as document_url,
+        d.category,
+        d.loader,
+        d.minecraft_version
+      FROM code_blocks cb
+      JOIN sections s ON cb.section_id = s.id
+      JOIN documents d ON s.document_id = d.id
+      WHERE 1=1
+    `;
+        const params = [];
+        if (language) {
+            sql += ' AND cb.language = ?';
+            params.push(language);
+        }
+        if (loader) {
+            sql += ' AND d.loader = ?';
+            params.push(loader);
+        }
+        if (minecraftVersion) {
+            sql += ' AND d.minecraft_version = ?';
+            params.push(minecraftVersion);
+        }
+        sql += ` ORDER BY d.id, s.order_num LIMIT ?`;
+        params.push(limit);
+        const stmt = this.db.prepare(sql);
+        return stmt.all(...params);
+    }
+    close() {
+        this.db.close();
+    }
+}
+//# sourceMappingURL=store.js.map