@adhisang/minecraft-modding-mcp 1.0.0

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

@@ -0,0 +1,45 @@
+import Database from "./sqlite.js";
+import type { ArtifactProvenance, ArtifactRow, SourceMapping, SourceOrigin } from "../types.js";
+type SqliteDatabase = InstanceType<typeof Database>;
+interface UpsertArtifactInput {
+    artifactId: string;
+    origin: SourceOrigin;
+    coordinate?: string;
+    version?: string;
+    binaryJarPath?: string;
+    sourceJarPath?: string;
+    repoUrl?: string;
+    requestedMapping?: SourceMapping;
+    mappingApplied?: SourceMapping;
+    provenance?: ArtifactProvenance;
+    qualityFlags?: string[];
+    artifactSignature?: string;
+    isDecompiled: boolean;
+    timestamp: string;
+}
+export interface ArtifactContentBytesRow {
+    artifactId: string;
+    totalContentBytes: number;
+    updatedAt: string;
+}
+export declare class ArtifactsRepo {
+    private readonly db;
+    private readonly upsertStmt;
+    private readonly getStmt;
+    private readonly touchStmt;
+    private readonly deleteStmt;
+    private readonly listStmt;
+    private readonly countStmt;
+    private readonly totalContentBytesStmt;
+    private readonly listLruWithContentBytesStmt;
+    constructor(db: SqliteDatabase);
+    upsertArtifact(input: UpsertArtifactInput): void;
+    getArtifact(artifactId: string): ArtifactRow | undefined;
+    touchArtifact(artifactId: string, timestamp: string): void;
+    deleteArtifact(artifactId: string): void;
+    listArtifactsByLru(limit: number): ArtifactRow[];
+    countArtifacts(): number;
+    totalContentBytes(): number;
+    listArtifactsByLruWithContentBytes(limit: number): ArtifactContentBytesRow[];
+}
+export {};

package/dist/storage/artifacts-repo.js

@@ -0,0 +1,209 @@
+import { log } from "../logger.js";
+function parseProvenance(value) {
+    if (!value) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return parsed;
+    }
+    catch {
+        log("warn", "storage.artifacts.invalid_provenance_json", {
+            value: value.slice(0, 200)
+        });
+        return undefined;
+    }
+}
+function parseQualityFlags(value) {
+    if (!value) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed.filter((entry) => typeof entry === "string");
+    }
+    catch {
+        log("warn", "storage.artifacts.invalid_quality_flags_json", {
+            value: value.slice(0, 200)
+        });
+        return [];
+    }
+}
+function toArtifactRow(record) {
+    return {
+        artifactId: record.artifact_id,
+        origin: record.origin,
+        coordinate: record.coordinate ?? undefined,
+        version: record.version ?? undefined,
+        binaryJarPath: record.binary_jar_path ?? undefined,
+        sourceJarPath: record.source_jar_path ?? undefined,
+        repoUrl: record.repo_url ?? undefined,
+        requestedMapping: record.requested_mapping ?? undefined,
+        mappingApplied: record.mapping_applied ?? undefined,
+        provenance: parseProvenance(record.provenance_json),
+        qualityFlags: parseQualityFlags(record.quality_flags_json),
+        artifactSignature: record.artifact_signature ?? undefined,
+        isDecompiled: record.is_decompiled === 1,
+        createdAt: record.created_at,
+        updatedAt: record.updated_at
+    };
+}
+function toBooleanValue(isDecompiled) {
+    return isDecompiled ? 1 : 0;
+}
+export class ArtifactsRepo {
+    db;
+    upsertStmt;
+    getStmt;
+    touchStmt;
+    deleteStmt;
+    listStmt;
+    countStmt;
+    totalContentBytesStmt;
+    listLruWithContentBytesStmt;
+    constructor(db) {
+        this.db = db;
+        this.upsertStmt = this.db.prepare(`
+      INSERT INTO artifacts (
+        artifact_id, origin, coordinate, version, binary_jar_path, source_jar_path, repo_url, requested_mapping, mapping_applied, provenance_json, quality_flags_json, artifact_signature, is_decompiled, created_at, updated_at
+      ) VALUES (
+        @artifact_id, @origin, @coordinate, @version, @binary_jar_path, @source_jar_path, @repo_url, @requested_mapping, @mapping_applied, @provenance_json, @quality_flags_json, @artifact_signature, @is_decompiled, @created_at, @updated_at
+      )
+      ON CONFLICT(artifact_id) DO UPDATE SET
+        origin = excluded.origin,
+        coordinate = excluded.coordinate,
+        version = excluded.version,
+        binary_jar_path = excluded.binary_jar_path,
+        source_jar_path = excluded.source_jar_path,
+        repo_url = excluded.repo_url,
+        requested_mapping = excluded.requested_mapping,
+        mapping_applied = excluded.mapping_applied,
+        provenance_json = excluded.provenance_json,
+        quality_flags_json = excluded.quality_flags_json,
+        artifact_signature = excluded.artifact_signature,
+        is_decompiled = excluded.is_decompiled,
+        updated_at = excluded.updated_at
+    `);
+        this.getStmt = this.db.prepare(`
+      SELECT
+        artifact_id,
+        origin,
+        coordinate,
+        version,
+        binary_jar_path,
+        source_jar_path,
+        repo_url,
+        requested_mapping,
+        mapping_applied,
+        provenance_json,
+        quality_flags_json,
+        artifact_signature,
+        is_decompiled,
+        created_at,
+        updated_at
+      FROM artifacts
+      WHERE artifact_id = ?
+    `);
+        this.touchStmt = this.db.prepare(`
+      UPDATE artifacts
+      SET updated_at = ?
+      WHERE artifact_id = ?
+    `);
+        this.deleteStmt = this.db.prepare(`DELETE FROM artifacts WHERE artifact_id = ?`);
+        this.listStmt = this.db.prepare(`
+      SELECT
+        artifact_id,
+        origin,
+        coordinate,
+        version,
+        binary_jar_path,
+        source_jar_path,
+        repo_url,
+        requested_mapping,
+        mapping_applied,
+        provenance_json,
+        quality_flags_json,
+        artifact_signature,
+        is_decompiled,
+        created_at,
+        updated_at
+      FROM artifacts
+      ORDER BY updated_at ASC
+      LIMIT ?
+    `);
+        this.countStmt = this.db.prepare(`
+      SELECT COUNT(*) AS total
+      FROM artifacts
+    `);
+        this.totalContentBytesStmt = this.db.prepare(`
+      SELECT COALESCE(SUM(total_content_bytes), 0) AS total
+      FROM artifact_content_bytes
+    `);
+        this.listLruWithContentBytesStmt = this.db.prepare(`
+      SELECT
+        artifacts.artifact_id,
+        COALESCE(artifact_content_bytes.total_content_bytes, 0) AS total_content_bytes,
+        artifacts.updated_at
+      FROM artifacts
+      LEFT JOIN artifact_content_bytes
+        ON artifact_content_bytes.artifact_id = artifacts.artifact_id
+      ORDER BY artifacts.updated_at ASC
+      LIMIT ?
+    `);
+    }
+    upsertArtifact(input) {
+        this.upsertStmt.run({
+            artifact_id: input.artifactId,
+            origin: input.origin,
+            coordinate: input.coordinate ?? null,
+            version: input.version ?? null,
+            binary_jar_path: input.binaryJarPath ?? null,
+            source_jar_path: input.sourceJarPath ?? null,
+            repo_url: input.repoUrl ?? null,
+            requested_mapping: input.requestedMapping ?? null,
+            mapping_applied: input.mappingApplied ?? null,
+            provenance_json: input.provenance ? JSON.stringify(input.provenance) : null,
+            quality_flags_json: input.qualityFlags ? JSON.stringify(input.qualityFlags) : null,
+            artifact_signature: input.artifactSignature ?? null,
+            is_decompiled: toBooleanValue(input.isDecompiled),
+            created_at: input.timestamp,
+            updated_at: input.timestamp
+        });
+    }
+    getArtifact(artifactId) {
+        const row = this.getStmt.get([artifactId]);
+        if (!row) {
+            return undefined;
+        }
+        return toArtifactRow(row);
+    }
+    touchArtifact(artifactId, timestamp) {
+        this.touchStmt.run([timestamp, artifactId]);
+    }
+    deleteArtifact(artifactId) {
+        this.deleteStmt.run([artifactId]);
+    }
+    listArtifactsByLru(limit) {
+        return this.listStmt.all([limit]).map(toArtifactRow);
+    }
+    countArtifacts() {
+        const row = this.countStmt.get();
+        return row?.total ?? 0;
+    }
+    totalContentBytes() {
+        const row = this.totalContentBytesStmt.get();
+        return row?.total ?? 0;
+    }
+    listArtifactsByLruWithContentBytes(limit) {
+        const rows = this.listLruWithContentBytesStmt.all([Math.max(1, Math.trunc(limit))]);
+        return rows.map((row) => ({
+            artifactId: row.artifact_id,
+            totalContentBytes: row.total_content_bytes,
+            updatedAt: row.updated_at
+        }));
+    }
+}
+//# sourceMappingURL=artifacts-repo.js.map

package/dist/storage/db.d.ts

@@ -0,0 +1,14 @@
+import Database from "./sqlite.js";
+import type { Config } from "../types.js";
+type SqliteDatabase = InstanceType<typeof Database>;
+type Logger = {
+    warn: (message: string, details?: Record<string, unknown>) => void;
+    info: (message: string, details?: Record<string, unknown>) => void;
+    error: (message: string, details?: Record<string, unknown>) => void;
+};
+export interface InitializedDatabase {
+    db: SqliteDatabase;
+    schemaVersion: number;
+}
+export declare function openDatabase(config: Config, logger?: Logger): InitializedDatabase;
+export {};

package/dist/storage/db.js

@@ -0,0 +1,132 @@
+import { existsSync, renameSync } from "node:fs";
+import { dirname } from "node:path";
+import { mkdirSync } from "node:fs";
+import Database from "./sqlite.js";
+import { runMigrations } from "./migrations.js";
+import { createError, ERROR_CODES, isAppError } from "../errors.js";
+import { log } from "../logger.js";
+function ensureParentDirectory(path) {
+    mkdirSync(dirname(path), { recursive: true });
+}
+function runIntegrityCheck(db) {
+    const result = db.prepare("PRAGMA integrity_check").get();
+    if (!result || result.integrity_check !== "ok") {
+        throw createError({
+            code: ERROR_CODES.DB_FAILURE,
+            message: "SQLite integrity check failed.",
+            details: { integrityCheck: result }
+        });
+    }
+}
+function backupCorruptedDb(sqlitePath) {
+    const backupPath = `${sqlitePath}.corrupted.${Date.now()}`;
+    renameSync(sqlitePath, backupPath);
+    return backupPath;
+}
+function isMissingPath(path) {
+    return !existsSync(path);
+}
+function safeCloseDatabase(db) {
+    if (!db) {
+        return;
+    }
+    try {
+        db.close();
+    }
+    catch {
+        // best-effort cleanup
+    }
+}
+function isSchemaVersionMismatchError(error) {
+    if (!isAppError(error)) {
+        return false;
+    }
+    if (error.code !== ERROR_CODES.DB_FAILURE) {
+        return false;
+    }
+    return (error.details?.reason === "schema_version_unsupported" ||
+        error.details?.reason === "schema_version_invalid");
+}
+function buildDefaultLogger() {
+    return {
+        warn: (message, details) => {
+            log("warn", "db.warn", {
+                message,
+                ...(details ?? {})
+            });
+        },
+        info: (message, details) => {
+            log("info", "db.info", {
+                message,
+                ...(details ?? {})
+            });
+        },
+        error: (message, details) => {
+            log("error", "db.error", {
+                message,
+                ...(details ?? {})
+            });
+        }
+    };
+}
+export function openDatabase(config, logger = buildDefaultLogger()) {
+    let db;
+    try {
+        ensureParentDirectory(config.sqlitePath);
+        db = new Database(config.sqlitePath);
+        db.pragma("foreign_keys = ON");
+        db.pragma("journal_mode = WAL");
+        db.pragma("synchronous = NORMAL");
+        db.pragma("busy_timeout = 5000");
+        const schemaVersion = runMigrations(db);
+        runIntegrityCheck(db);
+        return { db, schemaVersion };
+    }
+    catch (caughtError) {
+        safeCloseDatabase(db);
+        const errorMessage = caughtError instanceof Error ? caughtError.message : String(caughtError);
+        if (caughtError?.code === "ERR_IO") {
+            logger.error("Failed to open SQLite database", {
+                path: config.sqlitePath,
+                reason: errorMessage
+            });
+            throw createError({
+                code: ERROR_CODES.DB_FAILURE,
+                message: `Failed to open SQLite database at ${config.sqlitePath}`,
+                details: { sqlitePath: config.sqlitePath }
+            });
+        }
+        if (isSchemaVersionMismatchError(caughtError)) {
+            logger.error("SQLite schema version mismatch", {
+                path: config.sqlitePath,
+                reason: errorMessage
+            });
+            throw caughtError;
+        }
+        if (!isMissingPath(config.sqlitePath)) {
+            const backupPath = backupCorruptedDb(config.sqlitePath);
+            logger.warn("SQLite database integrity check failed. Recreated database after backup", {
+                sqlitePath: config.sqlitePath,
+                backupPath
+            });
+            const rebuilt = new Database(config.sqlitePath);
+            rebuilt.pragma("foreign_keys = ON");
+            rebuilt.pragma("journal_mode = WAL");
+            rebuilt.pragma("synchronous = NORMAL");
+            rebuilt.pragma("busy_timeout = 5000");
+            const schemaVersion = runMigrations(rebuilt);
+            runIntegrityCheck(rebuilt);
+            return { db: rebuilt, schemaVersion };
+        }
+        logger.error("SQLite initialization failed", {
+            path: config.sqlitePath,
+            reason: errorMessage
+        });
+        throw createError({
+            code: ERROR_CODES.DB_FAILURE,
+            message: "Failed to initialize SQLite database.",
+            details: { sqlitePath: config.sqlitePath }
+        });
+    }
+}
+//# sourceMappingURL=db.js.map

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

@@ -0,0 +1,78 @@
+import Database from "./sqlite.js";
+import type { FileRow, PagedResult } from "../types.js";
+type SqliteDatabase = InstanceType<typeof Database>;
+export interface IndexedFile {
+    filePath: string;
+    content: string;
+    contentBytes: number;
+    contentHash: string;
+}
+export interface ListFilesOptions {
+    limit: number;
+    cursor?: string;
+    prefix?: string;
+}
+export interface SearchFilesOptions {
+    limit: number;
+    query: string;
+    cursor?: string;
+    mode?: "mixed" | "text" | "path";
+    fetchLimitOverride?: number;
+}
+export interface SearchFilesResult {
+    filePath: string;
+    score: number;
+    matchedIn: "path" | "content" | "both";
+    preview: string;
+}
+export interface SearchFileCandidateResult {
+    filePath: string;
+    score: number;
+    matchedIn: "path" | "content" | "both";
+}
+export interface SearchFilesWithContentResult extends SearchFilesResult {
+    content: string;
+}
+export interface ListFileRowsOptions {
+    limit: number;
+    cursor?: string;
+    prefix?: string;
+}
+export declare class FilesRepo {
+    private readonly db;
+    private readonly deleteStmt;
+    private readonly insertFilesStmt;
+    private readonly insertFtsStmt;
+    private readonly deleteFtsStmt;
+    private readonly getContentStmt;
+    private readonly listStmt;
+    private readonly listRowsStmt;
+    private readonly searchPathStmt;
+    private readonly searchFtsStmt;
+    private readonly getByPathsStmtCache;
+    constructor(db: SqliteDatabase);
+    clearFilesForArtifact(artifactId: string): void;
+    insertFilesForArtifact(artifactId: string, files: IndexedFile[]): void;
+    replaceFilesForArtifact(artifactId: string, files: IndexedFile[]): void;
+    deleteFilesForArtifact(artifactId: string): void;
+    getFileContent(artifactId: string, filePath: string): FileRow | undefined;
+    listFiles(artifactId: string, options: ListFilesOptions): PagedResult<string>;
+    listFileRows(artifactId: string, options: ListFileRowsOptions): PagedResult<FileRow>;
+    getFileContentsByPaths(artifactId: string, filePaths: string[]): FileRow[];
+    searchFileCandidates(artifactId: string, options: SearchFilesOptions): PagedResult<SearchFileCandidateResult> & {
+        scannedRows: number;
+        dbRoundtrips: number;
+    };
+    searchFilesWithContent(artifactId: string, options: SearchFilesOptions): PagedResult<SearchFilesWithContentResult> & {
+        scannedRows: number;
+        dbRoundtrips: number;
+    };
+    countTextCandidates(artifactId: string, query: string): number;
+    countPathCandidates(artifactId: string, query: string): number;
+    findFirstFilePathByName(artifactId: string, fileName: string): string | undefined;
+    searchFiles(artifactId: string, options: SearchFilesOptions): PagedResult<SearchFilesResult>;
+    totalContentBytes(): number;
+    contentBytesForArtifact(artifactId: string): number;
+    private getFileContentsByPathsStmt;
+}
+export {};