mdkg 0.1.2 → 0.1.4

package/dist/graph/sqlite_index.js

@@ -0,0 +1,293 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLITE_SCHEMA_VERSION = void 0;
+exports.isSqliteBackend = isSqliteBackend;
+exports.resolveSqlitePath = resolveSqlitePath;
+exports.writeSqliteIndex = writeSqliteIndex;
+exports.reserveSqliteNumericId = reserveSqliteNumericId;
+exports.sqliteHealth = sqliteHealth;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const staleness_1 = require("./staleness");
+exports.SQLITE_SCHEMA_VERSION = 2;
+function loadDatabaseCtor() {
+    try {
+        const loaded = require("node:sqlite");
+        if (!loaded.DatabaseSync) {
+            throw new Error("node:sqlite DatabaseSync is unavailable");
+        }
+        return loaded.DatabaseSync;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`node:sqlite is required for mdkg SQLite index support: ${message}`);
+    }
+}
+function toPosixPath(value) {
+    return value.split(path_1.default.sep).join("/");
+}
+function sha256File(filePath) {
+    return `sha256:${crypto_1.default.createHash("sha256").update(fs_1.default.readFileSync(filePath)).digest("hex")}`;
+}
+function stripVolatileCacheFields(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => stripVolatileCacheFields(item));
+    }
+    if (value && typeof value === "object") {
+        const input = value;
+        const output = {};
+        for (const key of Object.keys(input).sort()) {
+            if (key === "generated_at" || key === "indexed_at") {
+                continue;
+            }
+            output[key] = stripVolatileCacheFields(input[key]);
+        }
+        return output;
+    }
+    return value;
+}
+function stableCacheJson(value) {
+    return JSON.stringify(stripVolatileCacheFields(value));
+}
+function isSqliteBackend(config) {
+    return config.index.backend === "sqlite";
+}
+function resolveSqlitePath(root, config) {
+    return path_1.default.resolve(root, config.index.sqlite_path);
+}
+function sqliteTempPath(sqlitePath) {
+    return path_1.default.join(path_1.default.dirname(sqlitePath), `.${path_1.default.basename(sqlitePath)}.${process.pid}.${Date.now()}.tmp`);
+}
+function createSchema(db) {
+    db.exec(`
+    PRAGMA journal_mode = DELETE;
+    PRAGMA synchronous = FULL;
+    CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+    CREATE TABLE nodes (
+      qid TEXT PRIMARY KEY,
+      id TEXT NOT NULL,
+      ws TEXT NOT NULL,
+      type TEXT NOT NULL,
+      title TEXT NOT NULL,
+      path TEXT NOT NULL,
+      status TEXT,
+      priority INTEGER,
+      updated TEXT,
+      source_hash TEXT,
+      json TEXT NOT NULL
+    );
+    CREATE TABLE edges (
+      source_qid TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      target_qid TEXT NOT NULL,
+      PRIMARY KEY (source_qid, kind, target_qid)
+    );
+    CREATE TABLE skills (
+      qid TEXT PRIMARY KEY,
+      slug TEXT NOT NULL,
+      ws TEXT NOT NULL,
+      name TEXT NOT NULL,
+      path TEXT NOT NULL,
+      json TEXT NOT NULL
+    );
+    CREATE TABLE capabilities (
+      qid TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      workspace TEXT NOT NULL,
+      visibility TEXT NOT NULL,
+      id TEXT NOT NULL,
+      path TEXT NOT NULL,
+      source_hash TEXT NOT NULL,
+      json TEXT NOT NULL,
+      PRIMARY KEY (qid, kind, path)
+    );
+    CREATE TABLE archives (
+      qid TEXT PRIMARY KEY,
+      visibility TEXT NOT NULL,
+      compressed_path TEXT,
+      compressed_sha256 TEXT,
+      json TEXT NOT NULL
+    );
+    CREATE TABLE subgraphs (
+      alias TEXT PRIMARY KEY,
+      enabled INTEGER NOT NULL,
+      stale INTEGER NOT NULL,
+      error_count INTEGER NOT NULL,
+      warning_count INTEGER NOT NULL,
+      json TEXT NOT NULL
+    );
+    CREATE TABLE id_allocations (
+      ws TEXT NOT NULL,
+      prefix TEXT NOT NULL,
+      next_value INTEGER NOT NULL,
+      PRIMARY KEY (ws, prefix)
+    );
+  `);
+}
+function insertMeta(db, key, value) {
+    db.prepare("INSERT INTO meta (key, value) VALUES (?, ?)").run(key, value);
+}
+function nodeSourceHash(root, nodePath) {
+    const fullPath = path_1.default.resolve(root, nodePath);
+    if (!fs_1.default.existsSync(fullPath) || !fs_1.default.statSync(fullPath).isFile()) {
+        return undefined;
+    }
+    return sha256File(fullPath);
+}
+function buildSourceFingerprint(options) {
+    const payload = {
+        nodes: Object.values(options.nodeIndex.nodes)
+            .sort((a, b) => a.qid.localeCompare(b.qid))
+            .map((node) => ({
+            qid: node.qid,
+            path: node.path,
+            hash: options.nodeHashes.get(node.qid) ?? "",
+        })),
+        skills: Object.values(options.skillsIndex.skills).sort((a, b) => a.qid.localeCompare(b.qid)),
+        capabilities: options.capabilitiesIndex.records,
+        subgraphs: options.subgraphsIndex.subgraphs,
+    };
+    return `sha256:${crypto_1.default.createHash("sha256").update(stableCacheJson(payload)).digest("hex")}`;
+}
+function writeSqliteIndex(options) {
+    const sqlitePath = resolveSqlitePath(options.root, options.config);
+    fs_1.default.mkdirSync(path_1.default.dirname(sqlitePath), { recursive: true });
+    const tempPath = sqliteTempPath(sqlitePath);
+    fs_1.default.rmSync(tempPath, { force: true });
+    const DatabaseSync = loadDatabaseCtor();
+    const db = new DatabaseSync(tempPath);
+    try {
+        const nodeHashes = new Map();
+        for (const node of Object.values(options.nodeIndex.nodes)) {
+            nodeHashes.set(node.qid, nodeSourceHash(options.root, node.path));
+        }
+        createSchema(db);
+        insertMeta(db, "tool", "mdkg");
+        insertMeta(db, "schema_version", String(exports.SQLITE_SCHEMA_VERSION));
+        insertMeta(db, "package_schema_version", String(options.config.schema_version));
+        insertMeta(db, "backend", options.config.index.backend);
+        insertMeta(db, "source_fingerprint", buildSourceFingerprint({ ...options, nodeHashes }));
+        insertMeta(db, "root", ".");
+        const insertNode = db.prepare("INSERT INTO nodes (qid, id, ws, type, title, path, status, priority, updated, source_hash, json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+        const insertEdge = db.prepare("INSERT OR IGNORE INTO edges (source_qid, kind, target_qid) VALUES (?, ?, ?)");
+        for (const node of Object.values(options.nodeIndex.nodes).sort((a, b) => a.qid.localeCompare(b.qid))) {
+            insertNode.run(node.qid, node.id, node.ws, node.type, node.title, toPosixPath(node.path), node.status ?? null, node.priority ?? null, node.updated ?? null, nodeHashes.get(node.qid) ?? null, stableCacheJson(node));
+            for (const [kind, values] of [
+                ["relates", node.edges.relates],
+                ["blocked_by", node.edges.blocked_by],
+                ["blocks", node.edges.blocks],
+            ]) {
+                for (const target of values) {
+                    insertEdge.run(node.qid, kind, target);
+                }
+            }
+            for (const [kind, target] of [
+                ["epic", node.edges.epic],
+                ["parent", node.edges.parent],
+                ["prev", node.edges.prev],
+                ["next", node.edges.next],
+            ]) {
+                if (target) {
+                    insertEdge.run(node.qid, kind, target);
+                }
+            }
+        }
+        const insertSkill = db.prepare("INSERT INTO skills (qid, slug, ws, name, path, json) VALUES (?, ?, ?, ?, ?, ?)");
+        for (const skill of Object.values(options.skillsIndex.skills).sort((a, b) => a.qid.localeCompare(b.qid))) {
+            insertSkill.run(skill.qid, skill.slug, skill.ws, skill.name, skill.path, stableCacheJson(skill));
+        }
+        const insertCapability = db.prepare("INSERT INTO capabilities (qid, kind, workspace, visibility, id, path, source_hash, json) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
+        for (const record of options.capabilitiesIndex.records) {
+            insertCapability.run(record.qid, record.kind, record.workspace, record.visibility, record.id, record.path, record.source_hash, stableCacheJson(record));
+        }
+        const insertArchive = db.prepare("INSERT INTO archives (qid, visibility, compressed_path, compressed_sha256, json) VALUES (?, ?, ?, ?, ?)");
+        for (const node of Object.values(options.nodeIndex.nodes).filter((item) => item.type === "archive")) {
+            insertArchive.run(node.qid, String(node.attributes.visibility ?? "private"), String(node.attributes.compressed_path ?? ""), String(node.attributes.compressed_sha256 ?? ""), stableCacheJson(node));
+        }
+        const insertSubgraph = db.prepare("INSERT INTO subgraphs (alias, enabled, stale, error_count, warning_count, json) VALUES (?, ?, ?, ?, ?, ?)");
+        for (const item of options.subgraphsIndex.subgraphs) {
+            insertSubgraph.run(item.alias, item.enabled ? 1 : 0, item.stale ? 1 : 0, item.error_count, item.warning_count, stableCacheJson(item));
+        }
+    }
+    finally {
+        db.close();
+    }
+    fs_1.default.renameSync(tempPath, sqlitePath);
+    return sqlitePath;
+}
+function reserveSqliteNumericId(options) {
+    if (!isSqliteBackend(options.config)) {
+        return undefined;
+    }
+    const sqlitePath = resolveSqlitePath(options.root, options.config);
+    fs_1.default.mkdirSync(path_1.default.dirname(sqlitePath), { recursive: true });
+    const DatabaseSync = loadDatabaseCtor();
+    const db = new DatabaseSync(sqlitePath);
+    try {
+        db.exec("CREATE TABLE IF NOT EXISTS id_allocations (ws TEXT NOT NULL, prefix TEXT NOT NULL, next_value INTEGER NOT NULL, PRIMARY KEY (ws, prefix));");
+        db.exec("BEGIN IMMEDIATE");
+        const row = db
+            .prepare("SELECT next_value FROM id_allocations WHERE ws = ? AND prefix = ?")
+            .get(options.ws, options.prefix);
+        const existing = typeof row?.next_value === "number" ? row.next_value : undefined;
+        const nextValue = Math.max(existing ?? 1, options.currentMax + 1);
+        db.prepare("INSERT INTO id_allocations (ws, prefix, next_value) VALUES (?, ?, ?) ON CONFLICT(ws, prefix) DO UPDATE SET next_value = excluded.next_value").run(options.ws, options.prefix, nextValue + 1);
+        db.exec("COMMIT");
+        return `${options.prefix}-${nextValue}`;
+    }
+    catch (err) {
+        try {
+            db.exec("ROLLBACK");
+        }
+        catch {
+            // ignore rollback failures when no transaction is active
+        }
+        throw err;
+    }
+    finally {
+        db.close();
+    }
+}
+function sqliteHealth(root, config) {
+    const sqlitePath = resolveSqlitePath(root, config);
+    const warnings = [];
+    const errors = [];
+    if (!fs_1.default.existsSync(sqlitePath)) {
+        warnings.push(`SQLite cache missing at ${toPosixPath(path_1.default.relative(root, sqlitePath))}; run mdkg index`);
+        return { path: sqlitePath, exists: false, size: 0, warnings, errors };
+    }
+    const size = fs_1.default.statSync(sqlitePath).size;
+    if (config.index.sqlite_commit_warning_bytes > 0 && size > config.index.sqlite_commit_warning_bytes) {
+        warnings.push(`SQLite cache exceeds ${config.index.sqlite_commit_warning_bytes} bytes: ${toPosixPath(path_1.default.relative(root, sqlitePath))} (${size} bytes)`);
+    }
+    for (const suffix of ["-wal", "-shm", "-journal"]) {
+        const transient = `${sqlitePath}${suffix}`;
+        if (fs_1.default.existsSync(transient)) {
+            warnings.push(`transient SQLite file present: ${toPosixPath(path_1.default.relative(root, transient))}`);
+        }
+    }
+    try {
+        const DatabaseSync = loadDatabaseCtor();
+        const db = new DatabaseSync(sqlitePath);
+        try {
+            const row = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+            if (String(row?.value ?? "") !== String(exports.SQLITE_SCHEMA_VERSION)) {
+                errors.push(`SQLite schema mismatch; run mdkg index`);
+            }
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (err) {
+        errors.push(`failed to read SQLite cache: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if ((0, staleness_1.isIndexStale)(root, config)) {
+        warnings.push("SQLite cache may be stale because source graph files or config changed; run mdkg index");
+    }
+    return { path: sqlitePath, exists: true, size, warnings, errors };
+}