mcmodding-mcp 0.3.0 → 0.4.0

package/dist/services/mappings-service.js

@@ -0,0 +1,788 @@
+import Database from 'better-sqlite3';
+import * as fs from 'fs';
+import * as path from 'path';
+const ABBREVIATION_MAP = {
+    msg: ['message'],
+    btn: ['button'],
+    inv: ['inventory'],
+    pos: ['position'],
+    vel: ['velocity'],
+    dir: ['direction'],
+    cfg: ['config', 'configuration'],
+    pkt: ['packet'],
+    tex: ['texture'],
+    gui: ['gui', 'screen', 'interface'],
+    nbt: ['nbt', 'tag', 'compound'],
+    mc: ['minecraft'],
+    bb: ['bounding', 'boundingbox'],
+    aabb: ['aabb', 'boundingbox'],
+    ai: ['ai', 'artificial'],
+    dmg: ['damage'],
+    hp: ['health'],
+    xp: ['experience'],
+    lvl: ['level'],
+    idx: ['index'],
+    len: ['length'],
+    cnt: ['count'],
+    num: ['number'],
+    str: ['string'],
+    obj: ['object'],
+    arr: ['array'],
+    vec: ['vector'],
+    mat: ['matrix', 'material'],
+    col: ['color', 'column', 'collision'],
+    rot: ['rotation'],
+    trans: ['translation', 'transform'],
+    ent: ['entity'],
+    blk: ['block'],
+    itm: ['item'],
+    ply: ['player'],
+    srv: ['server'],
+    cli: ['client'],
+    net: ['network'],
+    reg: ['register', 'registry'],
+    evt: ['event'],
+    cb: ['callback'],
+    fn: ['function'],
+    ctx: ['context'],
+    req: ['request'],
+    res: ['response', 'result'],
+    err: ['error'],
+    def: ['default', 'definition'],
+    init: ['initialize', 'initial'],
+    desc: ['descriptor', 'description'],
+    info: ['information'],
+    src: ['source'],
+    dst: ['destination'],
+    tmp: ['temporary'],
+    max: ['maximum'],
+    min: ['minimum'],
+    avg: ['average'],
+    rnd: ['random', 'render'],
+    gen: ['generate', 'generator'],
+    sync: ['synchronized', 'synchronize'],
+    async: ['asynchronous'],
+};
+const INTERNAL_PREFIXES = ['_', 'lambda$', 'access$', '$'];
+function isInternalName(name) {
+    if (!name)
+        return false;
+    for (const prefix of INTERNAL_PREFIXES) {
+        if (name.startsWith(prefix))
+            return true;
+    }
+    if (name.includes('$') && !name.endsWith('$'))
+        return true;
+    return false;
+}
+function expandAbbreviations(tokens) {
+    const expanded = [];
+    for (const token of tokens) {
+        expanded.push(token);
+        const expansions = ABBREVIATION_MAP[token.toLowerCase()];
+        if (expansions) {
+            for (const exp of expansions) {
+                if (!expanded.includes(exp)) {
+                    expanded.push(exp);
+                }
+            }
+        }
+    }
+    return expanded;
+}
+function tokenizeIdentifier(identifier) {
+    if (!identifier)
+        return [];
+    let normalized = identifier.replace(/[_-]/g, ' ');
+    normalized = normalized.replace(/([a-z])([A-Z])/g, '$1 $2');
+    normalized = normalized.replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2');
+    return normalized
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((t) => t.length > 0);
+}
+function levenshteinDistance(a, b) {
+    if (a.length === 0)
+        return b.length;
+    if (b.length === 0)
+        return a.length;
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++) {
+        matrix[i] = new Array(a.length + 1).fill(0);
+    }
+    for (let i = 0; i <= b.length; i++) {
+        matrix[i][0] = i;
+    }
+    for (let j = 0; j <= a.length; j++) {
+        matrix[0][j] = j;
+    }
+    for (let i = 1; i <= b.length; i++) {
+        for (let j = 1; j <= a.length; j++) {
+            if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+            }
+            else {
+                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+            }
+        }
+    }
+    return matrix[b.length][a.length];
+}
+function stringSimilarity(a, b) {
+    if (a === b)
+        return 1.0;
+    if (a.length === 0 || b.length === 0)
+        return 0.0;
+    const distance = levenshteinDistance(a.toLowerCase(), b.toLowerCase());
+    const maxLength = Math.max(a.length, b.length);
+    return 1 - distance / maxLength;
+}
+function containsCI(str, substr) {
+    return str.toLowerCase().includes(substr.toLowerCase());
+}
+function tokenizeQuery(query) {
+    const parts = query.toLowerCase().split(/[\s_-]+/);
+    const tokens = [];
+    for (const part of parts) {
+        tokens.push(...tokenizeIdentifier(part));
+    }
+    const uniqueTokens = [...new Set(tokens)].filter((t) => t.length >= 2);
+    return expandAbbreviations(uniqueTokens);
+}
+function calculateSemanticScore(identifier, queryTokens, originalQuery) {
+    if (!identifier || queryTokens.length === 0)
+        return 0;
+    const identifierLower = identifier.toLowerCase();
+    const originalLower = originalQuery.toLowerCase().replace(/[\s_-]+/g, '');
+    const internalPenalty = isInternalName(identifier) ? 25 : 0;
+    if (identifierLower === originalLower) {
+        return 100 - internalPenalty;
+    }
+    if (identifierLower.startsWith(originalLower)) {
+        const lengthBonus = Math.max(0, 10 - (identifier.length - originalQuery.length));
+        return Math.min(95, 85 + lengthBonus) - internalPenalty;
+    }
+    const wholeStringSimilarity = stringSimilarity(originalLower, identifierLower);
+    if (wholeStringSimilarity >= 0.75) {
+        const fuzzyScore = 50 + wholeStringSimilarity * 40;
+        return Math.min(Math.round(fuzzyScore), 90) - internalPenalty;
+    }
+    const identifierTokens = tokenizeIdentifier(identifier);
+    const baseQueryTokens = originalQuery
+        .toLowerCase()
+        .split(/[\s_-]+/)
+        .flatMap((p) => tokenizeIdentifier(p))
+        .filter((t) => t.length >= 2);
+    const baseTokenSet = new Set(baseQueryTokens);
+    let exactMatches = 0;
+    let prefixMatches = 0;
+    let containsMatches = 0;
+    let fuzzyMatches = 0;
+    let totalMatchScore = 0;
+    for (const queryToken of queryTokens) {
+        let bestMatch = 0;
+        const isBaseToken = baseTokenSet.has(queryToken);
+        const tokenWeight = isBaseToken ? 1.0 : 0.6;
+        for (const idToken of identifierTokens) {
+            if (idToken === queryToken) {
+                bestMatch = Math.max(bestMatch, 1.0);
+                break;
+            }
+            if (idToken.startsWith(queryToken)) {
+                const prefixScore = 0.9 - (idToken.length - queryToken.length) * 0.02;
+                bestMatch = Math.max(bestMatch, Math.max(0.75, prefixScore));
+                continue;
+            }
+            if (queryToken.startsWith(idToken) && idToken.length >= 3) {
+                const prefixScore = 0.8 - (queryToken.length - idToken.length) * 0.03;
+                bestMatch = Math.max(bestMatch, Math.max(0.65, prefixScore));
+                continue;
+            }
+            if (queryToken.length >= 3 && idToken.includes(queryToken)) {
+                bestMatch = Math.max(bestMatch, 0.7);
+                continue;
+            }
+            if (idToken.length >= 3 && queryToken.includes(idToken)) {
+                bestMatch = Math.max(bestMatch, 0.6);
+                continue;
+            }
+            const minLen = Math.min(idToken.length, queryToken.length);
+            const fuzzyThreshold = minLen >= 6 ? 0.65 : minLen >= 4 ? 0.7 : 0.75;
+            const similarity = stringSimilarity(idToken, queryToken);
+            if (similarity >= fuzzyThreshold) {
+                const fuzzyScore = similarity * 0.7;
+                bestMatch = Math.max(bestMatch, fuzzyScore);
+            }
+        }
+        if (bestMatch >= 0.95) {
+            exactMatches++;
+        }
+        else if (bestMatch >= 0.75) {
+            prefixMatches++;
+        }
+        else if (bestMatch >= 0.55) {
+            containsMatches++;
+        }
+        else if (bestMatch > 0.3) {
+            fuzzyMatches++;
+        }
+        totalMatchScore += bestMatch * tokenWeight;
+    }
+    let score = 0;
+    const totalBaseTokens = baseQueryTokens.length || 1;
+    const matchedBase = exactMatches + prefixMatches >= totalBaseTokens * 0.8 ? totalBaseTokens : exactMatches;
+    if (matchedBase === totalBaseTokens) {
+        score = 75 + (totalMatchScore / queryTokens.length) * 15;
+        const joinedQuery = baseQueryTokens.join('');
+        if (identifierLower.includes(joinedQuery)) {
+            score += 5;
+        }
+        if (identifierTokens[0] === baseQueryTokens[0]) {
+            score += 10;
+        }
+    }
+    else if (exactMatches + prefixMatches >= totalBaseTokens * 0.7) {
+        score = 55 + (totalMatchScore / queryTokens.length) * 20;
+    }
+    else if (exactMatches + prefixMatches + containsMatches >= totalBaseTokens * 0.5) {
+        score = 40 + (totalMatchScore / queryTokens.length) * 20;
+    }
+    else if (fuzzyMatches > 0 || totalMatchScore > 0.3) {
+        score = 20 + (totalMatchScore / queryTokens.length) * 30;
+    }
+    if (identifier.length < 15) {
+        score += 5;
+    }
+    else if (identifier.length > 40) {
+        score -= 5;
+    }
+    if (containsCI(identifier, originalLower) && originalLower.length >= 3) {
+        const containsScore = 55 + (originalLower.length / identifier.length) * 20;
+        score = Math.max(score, containsScore);
+    }
+    score -= internalPenalty;
+    return Math.min(Math.max(Math.round(score), 0), 100);
+}
+export class MappingsService {
+    db;
+    static dbPath = path.join(process.cwd(), 'data', 'parchment-mappings.db');
+    constructor(dbPath) {
+        const finalPath = dbPath || MappingsService.dbPath;
+        console.error(`[MappingsService] Using database at: ${finalPath}`);
+        this.db = new Database(finalPath, { readonly: true });
+    }
+    static isAvailable() {
+        return fs.existsSync(MappingsService.dbPath);
+    }
+    static getDbPath() {
+        return MappingsService.dbPath;
+    }
+    getStats() {
+        const counts = this.db
+            .prepare(`
+        SELECT
+          (SELECT COUNT(*) FROM classes) as totalClasses,
+          (SELECT COUNT(*) FROM methods) as totalMethods,
+          (SELECT COUNT(*) FROM fields) as totalFields,
+          (SELECT COUNT(*) FROM parameters) as totalParameters,
+          (SELECT COUNT(*) FROM methods WHERE javadoc IS NOT NULL AND javadoc != '') as documentedMethods,
+          (SELECT COUNT(*) FROM fields WHERE javadoc IS NOT NULL AND javadoc != '') as documentedFields
+      `)
+            .get();
+        const versions = this.db
+            .prepare(`SELECT DISTINCT minecraft_version FROM classes ORDER BY minecraft_version DESC`)
+            .all();
+        const topPackages = this.db
+            .prepare(`
+        SELECT package_name as packageName, COUNT(*) as count
+        FROM classes
+        GROUP BY package_name
+        ORDER BY count DESC
+        LIMIT 10
+      `)
+            .all();
+        return {
+            ...counts,
+            minecraftVersions: versions.map((v) => v.minecraft_version),
+            topPackages,
+        };
+    }
+    getMinecraftVersions() {
+        const versions = this.db
+            .prepare(`SELECT DISTINCT minecraft_version FROM classes ORDER BY minecraft_version DESC`)
+            .all();
+        return versions.map((v) => v.minecraft_version);
+    }
+    getLatestVersion() {
+        const result = this.db
+            .prepare(`
+        SELECT minecraft_version FROM classes
+        ORDER BY minecraft_version DESC
+        LIMIT 1
+      `)
+            .get();
+        return result?.minecraft_version || null;
+    }
+    search(options) {
+        const { query, type = 'all', minecraftVersion, packageFilter, includeJavadoc = true, limit = 20, } = options;
+        const results = [];
+        const queryTokens = tokenizeQuery(query);
+        console.error(`[MappingsService] Search query: "${query}" → tokens: [${queryTokens.join(', ')}]`);
+        const version = minecraftVersion || this.getLatestVersion();
+        if (!version) {
+            return [];
+        }
+        const sqlPatterns = this.generateSqlPatterns(query, queryTokens);
+        if (type === 'all' || type === 'class') {
+            const classResults = this.searchClassesSemantic(sqlPatterns, queryTokens, query, version, packageFilter, limit * 3);
+            for (const cls of classResults) {
+                results.push({
+                    type: 'class',
+                    name: cls.name,
+                    fullName: `${cls.packageName}.${cls.name}`,
+                    obfuscatedName: cls.obfuscatedName,
+                    descriptor: null,
+                    javadoc: includeJavadoc ? cls.javadoc : null,
+                    className: null,
+                    packageName: cls.packageName,
+                    minecraftVersion: cls.minecraftVersion,
+                    score: cls.score,
+                });
+            }
+        }
+        if (type === 'all' || type === 'method') {
+            const methodResults = this.searchMethodsSemantic(sqlPatterns, queryTokens, query, version, packageFilter, limit * 3);
+            for (const method of methodResults) {
+                results.push({
+                    type: 'method',
+                    name: method.name,
+                    fullName: `${method.className}.${method.name}`,
+                    obfuscatedName: method.obfuscatedName,
+                    descriptor: method.descriptor,
+                    javadoc: includeJavadoc ? method.javadoc : null,
+                    className: method.className,
+                    packageName: method.packageName,
+                    minecraftVersion: method.minecraftVersion,
+                    parameters: method.parameters,
+                    score: method.score,
+                });
+            }
+        }
+        if (type === 'all' || type === 'field') {
+            const fieldResults = this.searchFieldsSemantic(sqlPatterns, queryTokens, query, version, packageFilter, limit * 3);
+            for (const field of fieldResults) {
+                results.push({
+                    type: 'field',
+                    name: field.name,
+                    fullName: `${field.className}.${field.name}`,
+                    obfuscatedName: field.obfuscatedName,
+                    descriptor: field.descriptor,
+                    javadoc: includeJavadoc ? field.javadoc : null,
+                    className: field.className,
+                    packageName: field.packageName,
+                    minecraftVersion: field.minecraftVersion,
+                    score: field.score,
+                });
+            }
+        }
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, limit);
+    }
+    generateSqlPatterns(query, tokens) {
+        const patterns = [];
+        const queryLower = query.toLowerCase();
+        patterns.push(`%${query}%`);
+        const joinedQuery = query.replace(/\s+/g, '');
+        patterns.push(`%${joinedQuery}%`);
+        for (const token of tokens) {
+            if (token.length >= 2) {
+                patterns.push(`%${token}%`);
+                if (token.length >= 4) {
+                    for (let i = 0; i < token.length; i++) {
+                        const variant = token.slice(0, i) + token.slice(i + 1);
+                        if (variant.length >= 3) {
+                            patterns.push(`%${variant}%`);
+                        }
+                    }
+                    for (let i = 1; i < token.length; i++) {
+                        const variant = token.slice(0, i) + '%' + token.slice(i);
+                        patterns.push(`%${variant}%`);
+                    }
+                }
+                if (token.length >= 3) {
+                    patterns.push(`${token}%`);
+                }
+            }
+        }
+        for (let i = 0; i < tokens.length - 1; i++) {
+            const pair = `%${tokens[i]}%${tokens[i + 1]}%`;
+            patterns.push(pair);
+            patterns.push(`%${tokens[i]}${tokens[i + 1]}%`);
+        }
+        if (queryLower.length <= 4 && tokens.length === 1) {
+            const common = ['er', 'ing', 'ed', 'tion', 'ment', 'able', 'ible'];
+            for (const suffix of common) {
+                patterns.push(`%${tokens[0]}${suffix}%`);
+            }
+        }
+        return [...new Set(patterns)];
+    }
+    searchClassesSemantic(patterns, queryTokens, originalQuery, version, packageFilter, limit = 60) {
+        const patternConditions = patterns.map(() => 'name LIKE ?').join(' OR ');
+        const retrievalLimit = Math.max(limit * 3, 200);
+        let sql = `
+      SELECT id, name, obfuscated_name as obfuscatedName, javadoc, package_name as packageName, minecraft_version as minecraftVersion
+      FROM classes
+      WHERE minecraft_version = ?
+        AND (${patternConditions})
+    `;
+        const params = [version, ...patterns];
+        if (packageFilter) {
+            sql += ` AND package_name LIKE ?`;
+            params.push(`%${packageFilter}%`);
+        }
+        sql += ` LIMIT ?`;
+        params.push(retrievalLimit);
+        const rawResults = this.db.prepare(sql).all(...params);
+        return rawResults
+            .map((cls) => ({
+            ...cls,
+            score: calculateSemanticScore(cls.name, queryTokens, originalQuery),
+        }))
+            .filter((cls) => cls.score > 10)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    searchMethodsSemantic(patterns, queryTokens, originalQuery, version, packageFilter, limit = 60) {
+        const patternConditions = patterns.map(() => 'm.name LIKE ?').join(' OR ');
+        const retrievalLimit = Math.max(limit * 3, 200);
+        let sql = `
+      SELECT
+        m.id,
+        m.name,
+        m.obfuscated_name as obfuscatedName,
+        m.descriptor,
+        m.javadoc,
+        c.name as className,
+        c.package_name as packageName,
+        c.minecraft_version as minecraftVersion
+      FROM methods m
+      JOIN classes c ON m.class_id = c.id
+      WHERE c.minecraft_version = ?
+        AND (${patternConditions})
+    `;
+        const params = [version, ...patterns];
+        if (packageFilter) {
+            sql += ` AND c.package_name LIKE ?`;
+            params.push(`%${packageFilter}%`);
+        }
+        sql += ` LIMIT ?`;
+        params.push(retrievalLimit);
+        const rawResults = this.db.prepare(sql).all(...params);
+        const paramStmt = this.db.prepare(`
+      SELECT id, method_id as methodId, param_index as "index", name, javadoc
+      FROM parameters
+      WHERE method_id = ?
+      ORDER BY param_index
+    `);
+        return rawResults
+            .map((method) => ({
+            ...method,
+            parameters: paramStmt.all(method.id),
+            score: calculateSemanticScore(method.name, queryTokens, originalQuery),
+        }))
+            .filter((method) => method.score > 10)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    searchFieldsSemantic(patterns, queryTokens, originalQuery, version, packageFilter, limit = 60) {
+        const patternConditions = patterns.map(() => 'f.name LIKE ?').join(' OR ');
+        const retrievalLimit = Math.max(limit * 3, 200);
+        let sql = `
+      SELECT
+        f.id,
+        f.name,
+        f.obfuscated_name as obfuscatedName,
+        f.descriptor,
+        f.javadoc,
+        c.name as className,
+        c.package_name as packageName,
+        c.minecraft_version as minecraftVersion
+      FROM fields f
+      JOIN classes c ON f.class_id = c.id
+      WHERE c.minecraft_version = ?
+        AND (${patternConditions})
+    `;
+        const params = [version, ...patterns];
+        if (packageFilter) {
+            sql += ` AND c.package_name LIKE ?`;
+            params.push(`%${packageFilter}%`);
+        }
+        sql += ` LIMIT ?`;
+        params.push(retrievalLimit);
+        const rawResults = this.db.prepare(sql).all(...params);
+        return rawResults
+            .map((field) => ({
+            ...field,
+            score: calculateSemanticScore(field.name, queryTokens, originalQuery),
+        }))
+            .filter((field) => field.score > 10)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    getClass(fullName, minecraftVersion) {
+        const version = minecraftVersion || this.getLatestVersion();
+        if (!version)
+            return null;
+        const parts = fullName.split('.');
+        const className = parts.pop() || fullName;
+        const packageName = parts.join('.');
+        let sql = `
+      SELECT
+        c.id,
+        c.name,
+        c.obfuscated_name as obfuscatedName,
+        c.javadoc,
+        c.package_name as packageName,
+        c.minecraft_version as minecraftVersion,
+        (SELECT COUNT(*) FROM methods WHERE class_id = c.id) as methodCount,
+        (SELECT COUNT(*) FROM fields WHERE class_id = c.id) as fieldCount
+      FROM classes c
+      WHERE c.minecraft_version = ?
+        AND c.name = ?
+    `;
+        const params = [version, className];
+        if (packageName) {
+            sql += ` AND c.package_name = ?`;
+            params.push(packageName);
+        }
+        return this.db.prepare(sql).get(...params);
+    }
+    getClassMethods(classId) {
+        const methods = this.db
+            .prepare(`
+        SELECT
+          m.id,
+          m.class_id as classId,
+          c.name as className,
+          m.name,
+          m.obfuscated_name as obfuscatedName,
+          m.descriptor,
+          m.javadoc,
+          c.minecraft_version as minecraftVersion
+        FROM methods m
+        JOIN classes c ON m.class_id = c.id
+        WHERE m.class_id = ?
+        ORDER BY m.name
+      `)
+            .all(classId);
+        const paramStmt = this.db.prepare(`
+      SELECT id, method_id as methodId, param_index as "index", name, javadoc
+      FROM parameters
+      WHERE method_id = ?
+      ORDER BY param_index
+    `);
+        return methods.map((method) => ({
+            ...method,
+            parameters: paramStmt.all(method.id),
+        }));
+    }
+    getClassFields(classId) {
+        return this.db
+            .prepare(`
+        SELECT
+          f.id,
+          f.class_id as classId,
+          c.name as className,
+          f.name,
+          f.obfuscated_name as obfuscatedName,
+          f.descriptor,
+          f.javadoc,
+          c.minecraft_version as minecraftVersion
+        FROM fields f
+        JOIN classes c ON f.class_id = c.id
+        WHERE f.class_id = ?
+        ORDER BY f.name
+      `)
+            .all(classId);
+    }
+    getMethod(className, methodName, minecraftVersion) {
+        const version = minecraftVersion || this.getLatestVersion();
+        if (!version)
+            return null;
+        const method = this.db
+            .prepare(`
+        SELECT
+          m.id,
+          m.class_id as classId,
+          c.name as className,
+          m.name,
+          m.obfuscated_name as obfuscatedName,
+          m.descriptor,
+          m.javadoc,
+          c.minecraft_version as minecraftVersion
+        FROM methods m
+        JOIN classes c ON m.class_id = c.id
+        WHERE c.minecraft_version = ?
+          AND (c.name = ? OR (c.package_name || '.' || c.name) = ?)
+          AND m.name = ?
+        LIMIT 1
+      `)
+            .get(version, className, className, methodName);
+        if (!method)
+            return null;
+        const parameters = this.db
+            .prepare(`
+        SELECT id, method_id as methodId, param_index as "index", name, javadoc
+        FROM parameters
+        WHERE method_id = ?
+        ORDER BY param_index
+      `)
+            .all(method.id);
+        return { ...method, parameters };
+    }
+    lookupObfuscated(obfuscatedName, minecraftVersion) {
+        const version = minecraftVersion || this.getLatestVersion();
+        if (!version)
+            return null;
+        const cls = this.db
+            .prepare(`
+        SELECT id, name, obfuscated_name as obfuscatedName, javadoc, package_name as packageName, minecraft_version as minecraftVersion
+        FROM classes
+        WHERE minecraft_version = ? AND obfuscated_name = ?
+        LIMIT 1
+      `)
+            .get(version, obfuscatedName);
+        if (cls) {
+            return {
+                type: 'class',
+                name: cls.name,
+                fullName: `${cls.packageName}.${cls.name}`,
+                obfuscatedName: cls.obfuscatedName,
+                descriptor: null,
+                javadoc: cls.javadoc,
+                className: null,
+                packageName: cls.packageName,
+                minecraftVersion: cls.minecraftVersion,
+                score: 1.0,
+            };
+        }
+        const method = this.db
+            .prepare(`
+        SELECT
+          m.id,
+          m.name,
+          m.obfuscated_name as obfuscatedName,
+          m.descriptor,
+          m.javadoc,
+          c.name as className,
+          c.package_name as packageName,
+          c.minecraft_version as minecraftVersion
+        FROM methods m
+        JOIN classes c ON m.class_id = c.id
+        WHERE c.minecraft_version = ? AND m.obfuscated_name = ?
+        LIMIT 1
+      `)
+            .get(version, obfuscatedName);
+        if (method) {
+            const parameters = this.db
+                .prepare(`
+          SELECT id, method_id as methodId, param_index as "index", name, javadoc
+          FROM parameters
+          WHERE method_id = ?
+          ORDER BY param_index
+        `)
+                .all(method.id);
+            return {
+                type: 'method',
+                name: method.name,
+                fullName: `${method.className}.${method.name}`,
+                obfuscatedName: method.obfuscatedName,
+                descriptor: method.descriptor,
+                javadoc: method.javadoc,
+                className: method.className,
+                packageName: method.packageName,
+                minecraftVersion: method.minecraftVersion,
+                parameters,
+                score: 1.0,
+            };
+        }
+        const field = this.db
+            .prepare(`
+        SELECT
+          f.id,
+          f.name,
+          f.obfuscated_name as obfuscatedName,
+          f.descriptor,
+          f.javadoc,
+          c.name as className,
+          c.package_name as packageName,
+          c.minecraft_version as minecraftVersion
+        FROM fields f
+        JOIN classes c ON f.class_id = c.id
+        WHERE c.minecraft_version = ? AND f.obfuscated_name = ?
+        LIMIT 1
+      `)
+            .get(version, obfuscatedName);
+        if (field) {
+            return {
+                type: 'field',
+                name: field.name,
+                fullName: `${field.className}.${field.name}`,
+                obfuscatedName: field.obfuscatedName,
+                descriptor: field.descriptor,
+                javadoc: field.javadoc,
+                className: field.className,
+                packageName: field.packageName,
+                minecraftVersion: field.minecraftVersion,
+                score: 1.0,
+            };
+        }
+        return null;
+    }
+    getPackages(minecraftVersion) {
+        const version = minecraftVersion || this.getLatestVersion();
+        if (!version)
+            return [];
+        const packages = this.db
+            .prepare(`
+        SELECT DISTINCT
+          CASE
+            WHEN INSTR(package_name, '.') > 0
+            THEN SUBSTR(package_name, 1, INSTR(package_name, '.') - 1)
+            ELSE package_name
+          END as topPackage
+        FROM classes
+        WHERE minecraft_version = ?
+        ORDER BY topPackage
+      `)
+            .all(version);
+        return packages.map((p) => p.topPackage);
+    }
+    getClassesInPackage(packageName, minecraftVersion) {
+        const version = minecraftVersion || this.getLatestVersion();
+        if (!version)
+            return [];
+        return this.db
+            .prepare(`
+        SELECT
+          c.id,
+          c.name,
+          c.obfuscated_name as obfuscatedName,
+          c.javadoc,
+          c.package_name as packageName,
+          c.minecraft_version as minecraftVersion,
+          (SELECT COUNT(*) FROM methods WHERE class_id = c.id) as methodCount,
+          (SELECT COUNT(*) FROM fields WHERE class_id = c.id) as fieldCount
+        FROM classes c
+        WHERE c.minecraft_version = ?
+          AND c.package_name LIKE ?
+        ORDER BY c.name
+      `)
+            .all(version, `${packageName}%`);
+    }
+    close() {
+        this.db.close();
+    }
+}
+//# sourceMappingURL=mappings-service.js.map