@adhisang/minecraft-modding-mcp 1.0.0

package/dist/storage/schema.js

@@ -0,0 +1,160 @@
+export const SCHEMA_V1_STATEMENTS = [
+    `CREATE TABLE IF NOT EXISTS artifacts (
+    artifact_id TEXT PRIMARY KEY,
+    origin TEXT NOT NULL,
+    coordinate TEXT,
+    binary_jar_path TEXT,
+    source_jar_path TEXT,
+    repo_url TEXT,
+    is_decompiled INTEGER NOT NULL CHECK (is_decompiled IN (0,1)),
+    artifact_signature TEXT,
+    version TEXT,
+    requested_mapping TEXT,
+    mapping_applied TEXT,
+    provenance_json TEXT,
+    quality_flags_json TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )`,
+    `CREATE TABLE IF NOT EXISTS files (
+    artifact_id TEXT NOT NULL,
+    file_path TEXT NOT NULL,
+    content TEXT NOT NULL,
+    content_bytes INTEGER NOT NULL,
+    content_hash TEXT NOT NULL,
+    PRIMARY KEY (artifact_id, file_path),
+    FOREIGN KEY (artifact_id) REFERENCES artifacts(artifact_id) ON DELETE CASCADE
+  )`,
+    `CREATE VIRTUAL TABLE IF NOT EXISTS files_fts USING fts5(
+    artifact_id UNINDEXED,
+    file_path,
+    content,
+    tokenize = 'unicode61 separators ''._$'''
+  )`,
+    `CREATE TABLE IF NOT EXISTS symbols (
+    artifact_id TEXT NOT NULL,
+    file_path TEXT NOT NULL,
+    symbol_kind TEXT NOT NULL,
+    symbol_name TEXT NOT NULL,
+    qualified_name TEXT,
+    line INTEGER NOT NULL,
+    PRIMARY KEY (artifact_id, file_path, symbol_kind, symbol_name, line),
+    FOREIGN KEY (artifact_id, file_path) REFERENCES files(artifact_id, file_path) ON DELETE CASCADE
+  )`,
+    `CREATE TABLE IF NOT EXISTS artifact_index_meta (
+    artifact_id TEXT PRIMARY KEY,
+    artifact_signature TEXT NOT NULL,
+    index_schema_version INTEGER NOT NULL,
+    files_count INTEGER NOT NULL,
+    symbols_count INTEGER NOT NULL,
+    fts_rows_count INTEGER NOT NULL,
+    indexed_at TEXT NOT NULL,
+    index_duration_ms INTEGER NOT NULL,
+    last_error TEXT,
+    FOREIGN KEY (artifact_id) REFERENCES artifacts(artifact_id) ON DELETE CASCADE
+  )`,
+    `CREATE TABLE IF NOT EXISTS artifact_content_bytes (
+    artifact_id TEXT PRIMARY KEY,
+    total_content_bytes INTEGER NOT NULL CHECK (total_content_bytes >= 0),
+    FOREIGN KEY (artifact_id) REFERENCES artifacts(artifact_id) ON DELETE CASCADE
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_files_artifact ON files(artifact_id)`,
+    `CREATE INDEX IF NOT EXISTS idx_files_path ON files(artifact_id, file_path)`,
+    `CREATE INDEX IF NOT EXISTS idx_symbols_lookup ON symbols(artifact_id, symbol_kind, symbol_name)`,
+    `CREATE INDEX IF NOT EXISTS idx_symbols_qname ON symbols(artifact_id, qualified_name)`,
+    `CREATE INDEX IF NOT EXISTS idx_artifacts_updated_at ON artifacts(updated_at)`,
+    `CREATE INDEX IF NOT EXISTS idx_index_meta_indexed_at ON artifact_index_meta(indexed_at)`,
+    `CREATE INDEX IF NOT EXISTS idx_symbols_name_lower ON symbols(artifact_id, lower(symbol_name))`,
+    `CREATE INDEX IF NOT EXISTS idx_symbols_file_line ON symbols(artifact_id, file_path, line)`,
+    `CREATE INDEX IF NOT EXISTS idx_symbols_kind_file ON symbols(artifact_id, symbol_kind, file_path)`,
+    `CREATE INDEX IF NOT EXISTS idx_artifact_content_bytes_total ON artifact_content_bytes(total_content_bytes)`,
+    `CREATE INDEX IF NOT EXISTS idx_symbols_scoped_lookup
+   ON symbols(artifact_id, symbol_kind, lower(symbol_name), file_path, line)`,
+    `CREATE INDEX IF NOT EXISTS idx_symbols_scoped_lookup_no_kind
+   ON symbols(artifact_id, lower(symbol_name), file_path, line)`,
+    `INSERT INTO artifact_content_bytes (artifact_id, total_content_bytes)
+   SELECT
+     artifacts.artifact_id,
+     COALESCE(
+       SUM(
+         CASE
+           WHEN files.content_bytes > 0 THEN files.content_bytes
+           ELSE 0
+         END
+       ),
+       0
+     ) AS total_content_bytes
+   FROM artifacts
+   LEFT JOIN files ON files.artifact_id = artifacts.artifact_id
+   GROUP BY artifacts.artifact_id
+   ON CONFLICT(artifact_id) DO UPDATE SET
+     total_content_bytes = excluded.total_content_bytes`,
+    `DELETE FROM artifact_content_bytes
+   WHERE artifact_id NOT IN (SELECT artifact_id FROM artifacts)`,
+    `CREATE TRIGGER IF NOT EXISTS trg_files_content_bytes_insert
+   AFTER INSERT ON files
+   BEGIN
+     INSERT INTO artifact_content_bytes (artifact_id, total_content_bytes)
+     VALUES (
+       NEW.artifact_id,
+       CASE
+         WHEN NEW.content_bytes > 0 THEN NEW.content_bytes
+         ELSE 0
+       END
+     )
+     ON CONFLICT(artifact_id) DO UPDATE SET
+       total_content_bytes = artifact_content_bytes.total_content_bytes + (
+         CASE
+           WHEN NEW.content_bytes > 0 THEN NEW.content_bytes
+           ELSE 0
+         END
+       );
+   END`,
+    `CREATE TRIGGER IF NOT EXISTS trg_files_content_bytes_delete
+   AFTER DELETE ON files
+   BEGIN
+     UPDATE artifact_content_bytes
+     SET total_content_bytes = MAX(
+       0,
+       total_content_bytes - (
+         CASE
+           WHEN OLD.content_bytes > 0 THEN OLD.content_bytes
+           ELSE 0
+         END
+       )
+     )
+     WHERE artifact_id = OLD.artifact_id;
+   END`,
+    `CREATE TRIGGER IF NOT EXISTS trg_files_content_bytes_update
+   AFTER UPDATE OF artifact_id, content_bytes ON files
+   BEGIN
+     UPDATE artifact_content_bytes
+     SET total_content_bytes = MAX(
+       0,
+       total_content_bytes - (
+         CASE
+           WHEN OLD.content_bytes > 0 THEN OLD.content_bytes
+           ELSE 0
+         END
+       )
+     )
+     WHERE artifact_id = OLD.artifact_id;
+
+     INSERT INTO artifact_content_bytes (artifact_id, total_content_bytes)
+     VALUES (
+       NEW.artifact_id,
+       CASE
+         WHEN NEW.content_bytes > 0 THEN NEW.content_bytes
+         ELSE 0
+       END
+     )
+     ON CONFLICT(artifact_id) DO UPDATE SET
+       total_content_bytes = artifact_content_bytes.total_content_bytes + (
+         CASE
+           WHEN NEW.content_bytes > 0 THEN NEW.content_bytes
+           ELSE 0
+         END
+       );
+   END`
+];
+//# sourceMappingURL=schema.js.map

package/dist/storage/sqlite.d.ts

@@ -0,0 +1,20 @@
+import { type StatementSync } from "node:sqlite";
+export declare class Statement<T = unknown> {
+    private readonly stmt;
+    constructor(stmt: StatementSync);
+    run(...params: unknown[]): unknown;
+    get(...params: unknown[]): T | undefined;
+    all(...params: unknown[]): T[];
+    iterate(...params: unknown[]): Iterable<T>;
+    private invoke;
+}
+export default class Database {
+    private readonly inner;
+    private transactionDepth;
+    constructor(path: string);
+    pragma(pragma: string): unknown;
+    prepare<T = Record<string, unknown>>(sql: string): Statement<T>;
+    transaction<T>(fn: () => T): () => T;
+    close(): void;
+    private runInTransaction;
+}

package/dist/storage/sqlite.js

@@ -0,0 +1,111 @@
+import { DatabaseSync } from "node:sqlite";
+function isPlainObject(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value) || ArrayBuffer.isView(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function normalizeParameters(args) {
+    if (args.length === 1) {
+        const [single] = args;
+        if (Array.isArray(single)) {
+            return { positional: single };
+        }
+        if (isPlainObject(single)) {
+            return { named: single };
+        }
+    }
+    return { positional: args };
+}
+export class Statement {
+    stmt;
+    constructor(stmt) {
+        this.stmt = stmt;
+    }
+    run(...params) {
+        return this.invoke("run", params);
+    }
+    get(...params) {
+        return this.invoke("get", params);
+    }
+    all(...params) {
+        return this.invoke("all", params);
+    }
+    iterate(...params) {
+        return this.invoke("iterate", params);
+    }
+    invoke(method, params) {
+        const normalized = normalizeParameters(params);
+        const target = this.stmt[method];
+        if (normalized.named !== undefined) {
+            return target.call(this.stmt, normalized.named);
+        }
+        return target.call(this.stmt, ...(normalized.positional ?? []));
+    }
+}
+let transactionSerial = 0;
+export default class Database {
+    inner;
+    transactionDepth = 0;
+    constructor(path) {
+        this.inner = new DatabaseSync(path);
+    }
+    pragma(pragma) {
+        const sql = `PRAGMA ${pragma}`;
+        if (pragma.includes("=")) {
+            this.inner.exec(sql);
+            return undefined;
+        }
+        return this.inner.prepare(sql).all();
+    }
+    prepare(sql) {
+        return new Statement(this.inner.prepare(sql));
+    }
+    transaction(fn) {
+        return () => this.runInTransaction(fn);
+    }
+    close() {
+        this.inner.close();
+    }
+    runInTransaction(fn) {
+        const initialDepth = this.transactionDepth;
+        const isOutermost = initialDepth === 0;
+        const savepoint = `sp_${++transactionSerial}`;
+        try {
+            if (isOutermost) {
+                this.inner.exec("BEGIN");
+            }
+            else {
+                this.inner.exec(`SAVEPOINT ${savepoint}`);
+            }
+            this.transactionDepth = initialDepth + 1;
+            const result = fn();
+            this.transactionDepth = initialDepth;
+            if (isOutermost) {
+                this.inner.exec("COMMIT");
+            }
+            else {
+                this.inner.exec(`RELEASE SAVEPOINT ${savepoint}`);
+            }
+            return result;
+        }
+        catch (error) {
+            this.transactionDepth = initialDepth;
+            try {
+                if (isOutermost) {
+                    this.inner.exec("ROLLBACK");
+                }
+                else {
+                    this.inner.exec(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+                    this.inner.exec(`RELEASE SAVEPOINT ${savepoint}`);
+                }
+            }
+            catch {
+                // best-effort rollback cleanup
+            }
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=sqlite.js.map

package/dist/storage/symbols-repo.d.ts

@@ -0,0 +1,63 @@
+import Database from "./sqlite.js";
+import type { PagedResult, SymbolRow } from "../types.js";
+type SqliteDatabase = InstanceType<typeof Database>;
+export interface IndexedSymbol {
+    filePath: string;
+    symbolKind: string;
+    symbolName: string;
+    qualifiedName: string | undefined;
+    line: number;
+}
+export interface FindSymbolsOptions {
+    artifactId: string;
+    symbolKind?: string;
+    symbolNamePrefix?: string;
+    exact?: boolean;
+    limit: number;
+    cursor?: string;
+}
+type ScopedSymbolMatch = "exact" | "prefix" | "contains";
+export interface FindScopedSymbolsOptions {
+    artifactId: string;
+    query: string;
+    match: ScopedSymbolMatch;
+    symbolKind?: string;
+    packagePrefix?: string;
+    filePathLike?: string;
+    limit?: number;
+    cursor?: {
+        symbolName: string;
+        filePath: string;
+        line: number;
+    };
+}
+export declare class SymbolsRepo {
+    private readonly db;
+    private readonly deleteStmt;
+    private readonly insertStmt;
+    private readonly searchStmt;
+    private readonly searchExactStmt;
+    private readonly listByArtifactStmt;
+    private readonly listByArtifactKindStmt;
+    private readonly listByFileStmt;
+    constructor(db: SqliteDatabase);
+    clearSymbolsForArtifact(artifactId: string): void;
+    insertSymbolsForArtifact(artifactId: string, symbols: IndexedSymbol[]): void;
+    replaceSymbolsForArtifact(artifactId: string, symbols: IndexedSymbol[]): void;
+    findSymbols(options: FindSymbolsOptions): PagedResult<SymbolRow>;
+    listSymbolsForArtifact(artifactId: string, symbolKind?: string): SymbolRow[];
+    listSymbolsForFile(artifactId: string, filePath: string): SymbolRow[];
+    listSymbolsForFiles(artifactId: string, filePaths: string[], symbolKind?: string): Map<string, SymbolRow[]>;
+    findBySymbolNames(artifactId: string, symbolNames: string[]): SymbolRow[];
+    findScopedSymbols(options: FindScopedSymbolsOptions): PagedResult<SymbolRow>;
+    countScopedSymbols(options: {
+        artifactId: string;
+        query: string;
+        match: ScopedSymbolMatch;
+        symbolKind?: string;
+        packagePrefix?: string;
+    }): number;
+    listDistinctFilePathsByKind(artifactId: string, symbolKind: string): string[];
+    findBestClassFilePath(artifactId: string, className: string, simpleName: string): string | undefined;
+}
+export {};