@projitive/mcp 1.2.0 → 2.0.0

package/output/source/common/store.js

@@ -0,0 +1,623 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import duckdb from "@duckdb/node-api";
+import initSqlJs from "sql.js";
+const STORE_SCHEMA_VERSION = 3;
+const SQL_HEADER = Buffer.from("SQLite format 3\0", "utf8");
+const sqlRuntimePromise = initSqlJs();
+const storeCache = new Map();
+const storeLocks = new Map();
+let duckdbConnectionPromise;
+function defaultViewState(name) {
+    return {
+        name,
+        dirty: true,
+        lastSourceVersion: 0,
+        lastBuiltAt: "",
+        recordVersion: 1,
+    };
+}
+function defaultStore() {
+    return {
+        schema: "projitive-json-store",
+        tasks: [],
+        roadmaps: [],
+        meta: {
+            tasks_version: 0,
+            roadmaps_version: 0,
+            store_schema_version: STORE_SCHEMA_VERSION,
+        },
+        view_state: {
+            tasks_markdown: defaultViewState("tasks_markdown"),
+            roadmaps_markdown: defaultViewState("roadmaps_markdown"),
+        },
+        migration_history: [],
+    };
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function parseJsonOr(raw, fallback) {
+    if (typeof raw !== "string" || raw.trim().length === 0) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return fallback;
+    }
+}
+function normalizeTaskStatus(status) {
+    if (status === "IN_PROGRESS" || status === "BLOCKED" || status === "DONE") {
+        return status;
+    }
+    return "TODO";
+}
+function normalizeRoadmapStatus(status) {
+    return status === "done" ? "done" : "active";
+}
+function isSqliteBuffer(data) {
+    if (data.length < SQL_HEADER.length) {
+        return false;
+    }
+    return data.subarray(0, SQL_HEADER.length).equals(SQL_HEADER);
+}
+function normalizeStore(input) {
+    const base = defaultStore();
+    const meta = input.meta ?? {};
+    const tasks = Array.isArray(input.tasks)
+        ? input.tasks.map((task) => ({
+            id: String(task.id ?? ""),
+            title: String(task.title ?? ""),
+            status: normalizeTaskStatus(String(task.status ?? "TODO")),
+            owner: String(task.owner ?? ""),
+            summary: String(task.summary ?? ""),
+            updatedAt: String(task.updatedAt ?? nowIso()),
+            links: Array.isArray(task.links) ? task.links.map((item) => String(item)) : [],
+            roadmapRefs: Array.isArray(task.roadmapRefs) ? task.roadmapRefs.map((item) => String(item)) : [],
+            subState: task.subState,
+            blocker: task.blocker,
+            recordVersion: Number.isFinite(Number(task.recordVersion)) ? Number(task.recordVersion) : 1,
+        }))
+        : [];
+    const roadmaps = Array.isArray(input.roadmaps)
+        ? input.roadmaps.map((milestone) => ({
+            id: String(milestone.id ?? ""),
+            title: String(milestone.title ?? ""),
+            status: normalizeRoadmapStatus(String(milestone.status ?? "active")),
+            time: typeof milestone.time === "string" && milestone.time.length > 0 ? milestone.time : undefined,
+            updatedAt: String(milestone.updatedAt ?? nowIso()),
+            recordVersion: Number.isFinite(Number(milestone.recordVersion)) ? Number(milestone.recordVersion) : 1,
+        }))
+        : [];
+    const tasksView = input.view_state?.tasks_markdown;
+    const roadmapsView = input.view_state?.roadmaps_markdown;
+    return {
+        schema: "projitive-json-store",
+        tasks,
+        roadmaps,
+        meta: {
+            tasks_version: Number.isFinite(Number(meta.tasks_version)) ? Number(meta.tasks_version) : base.meta.tasks_version,
+            roadmaps_version: Number.isFinite(Number(meta.roadmaps_version)) ? Number(meta.roadmaps_version) : base.meta.roadmaps_version,
+            store_schema_version: STORE_SCHEMA_VERSION,
+        },
+        view_state: {
+            tasks_markdown: {
+                ...base.view_state.tasks_markdown,
+                dirty: typeof tasksView?.dirty === "boolean" ? tasksView.dirty : base.view_state.tasks_markdown.dirty,
+                lastSourceVersion: Number.isFinite(Number(tasksView?.lastSourceVersion))
+                    ? Number(tasksView?.lastSourceVersion)
+                    : base.view_state.tasks_markdown.lastSourceVersion,
+                lastBuiltAt: typeof tasksView?.lastBuiltAt === "string" ? tasksView.lastBuiltAt : base.view_state.tasks_markdown.lastBuiltAt,
+                recordVersion: Number.isFinite(Number(tasksView?.recordVersion))
+                    ? Number(tasksView?.recordVersion)
+                    : base.view_state.tasks_markdown.recordVersion,
+            },
+            roadmaps_markdown: {
+                ...base.view_state.roadmaps_markdown,
+                dirty: typeof roadmapsView?.dirty === "boolean" ? roadmapsView.dirty : base.view_state.roadmaps_markdown.dirty,
+                lastSourceVersion: Number.isFinite(Number(roadmapsView?.lastSourceVersion))
+                    ? Number(roadmapsView?.lastSourceVersion)
+                    : base.view_state.roadmaps_markdown.lastSourceVersion,
+                lastBuiltAt: typeof roadmapsView?.lastBuiltAt === "string" ? roadmapsView.lastBuiltAt : base.view_state.roadmaps_markdown.lastBuiltAt,
+                recordVersion: Number.isFinite(Number(roadmapsView?.recordVersion))
+                    ? Number(roadmapsView?.recordVersion)
+                    : base.view_state.roadmaps_markdown.recordVersion,
+            },
+        },
+        migration_history: Array.isArray(input.migration_history) ? input.migration_history : [],
+    };
+}
+async function migrateSqliteToJson(data) {
+    const SQL = await sqlRuntimePromise;
+    const db = new SQL.Database(new Uint8Array(data));
+    try {
+        const tasksResult = db.exec(`
+      SELECT id, title, status, owner, summary, updated_at, links_json, roadmap_refs_json, sub_state_json, blocker_json, COALESCE(record_version, 1)
+      FROM tasks
+    `);
+        const roadmapsResult = db.exec(`
+      SELECT id, title, status, time, updated_at, COALESCE(record_version, 1)
+      FROM roadmaps
+    `);
+        const metaResult = db.exec(`
+      SELECT key, value
+      FROM meta
+      WHERE key IN ('tasks_version', 'roadmaps_version', 'store_schema_version')
+    `);
+        const viewStateResult = db.exec(`
+      SELECT name, dirty, last_source_version, last_built_at, COALESCE(record_version, 1)
+      FROM view_state
+      WHERE name IN ('tasks_markdown', 'roadmaps_markdown')
+    `);
+        const tasks = tasksResult[0]?.values?.map((row) => ({
+            id: String(row[0]),
+            title: String(row[1]),
+            status: normalizeTaskStatus(String(row[2])),
+            owner: String(row[3]),
+            summary: String(row[4]),
+            updatedAt: String(row[5]),
+            links: parseJsonOr(row[6], []),
+            roadmapRefs: parseJsonOr(row[7], []),
+            subState: parseJsonOr(row[8], undefined),
+            blocker: parseJsonOr(row[9], undefined),
+            recordVersion: Number(row[10]) || 1,
+        })) ?? [];
+        const roadmaps = roadmapsResult[0]?.values?.map((row) => ({
+            id: String(row[0]),
+            title: String(row[1]),
+            status: normalizeRoadmapStatus(String(row[2])),
+            time: row[3] == null ? undefined : String(row[3]),
+            updatedAt: String(row[4]),
+            recordVersion: Number(row[5]) || 1,
+        })) ?? [];
+        const meta = defaultStore().meta;
+        const metaRows = metaResult[0]?.values ?? [];
+        for (const row of metaRows) {
+            const key = String(row[0]);
+            const value = Number.parseInt(String(row[1]), 10);
+            if (!Number.isFinite(value)) {
+                continue;
+            }
+            if (key === "tasks_version")
+                meta.tasks_version = value;
+            if (key === "roadmaps_version")
+                meta.roadmaps_version = value;
+            if (key === "store_schema_version")
+                meta.store_schema_version = value;
+        }
+        const tasksView = defaultViewState("tasks_markdown");
+        const roadmapsView = defaultViewState("roadmaps_markdown");
+        const viewRows = viewStateResult[0]?.values ?? [];
+        for (const row of viewRows) {
+            const name = String(row[0]);
+            const dirty = Number(row[1]) === 1;
+            const lastSourceVersion = Number(row[2]) || 0;
+            const lastBuiltAt = String(row[3] ?? "");
+            const recordVersion = Number(row[4]) || 1;
+            if (name === "tasks_markdown") {
+                tasksView.dirty = dirty;
+                tasksView.lastSourceVersion = lastSourceVersion;
+                tasksView.lastBuiltAt = lastBuiltAt;
+                tasksView.recordVersion = recordVersion;
+            }
+            if (name === "roadmaps_markdown") {
+                roadmapsView.dirty = dirty;
+                roadmapsView.lastSourceVersion = lastSourceVersion;
+                roadmapsView.lastBuiltAt = lastBuiltAt;
+                roadmapsView.recordVersion = recordVersion;
+            }
+        }
+        return normalizeStore({
+            schema: "projitive-json-store",
+            tasks,
+            roadmaps,
+            meta: {
+                tasks_version: meta.tasks_version,
+                roadmaps_version: meta.roadmaps_version,
+                store_schema_version: STORE_SCHEMA_VERSION,
+            },
+            view_state: {
+                tasks_markdown: tasksView,
+                roadmaps_markdown: roadmapsView,
+            },
+            migration_history: [],
+        });
+    }
+    finally {
+        db.close();
+    }
+}
+async function persistStore(dbPath, store) {
+    await fs.mkdir(path.dirname(dbPath), { recursive: true });
+    const tempPath = `${dbPath}.tmp-${process.pid}-${Date.now()}`;
+    const body = `${JSON.stringify(store, null, 2)}\n`;
+    await fs.writeFile(tempPath, body, "utf8");
+    await fs.rename(tempPath, dbPath);
+}
+async function loadStoreFromDisk(dbPath) {
+    const file = await fs.readFile(dbPath).catch(() => undefined);
+    if (!file || file.length === 0) {
+        return { store: defaultStore(), shouldPersist: true };
+    }
+    if (isSqliteBuffer(file)) {
+        const migrated = await migrateSqliteToJson(file);
+        return { store: migrated, shouldPersist: true };
+    }
+    const text = file.toString("utf8").trim();
+    if (text.length === 0) {
+        return { store: defaultStore(), shouldPersist: true };
+    }
+    try {
+        const parsed = JSON.parse(text);
+        const normalized = normalizeStore(parsed);
+        return { store: normalized, shouldPersist: normalized.meta.store_schema_version !== STORE_SCHEMA_VERSION };
+    }
+    catch {
+        // Legacy plain-text marker or corrupted content: bootstrap empty JSON store.
+        return { store: defaultStore(), shouldPersist: true };
+    }
+}
+async function openStore(dbPath) {
+    const cached = storeCache.get(dbPath);
+    if (cached) {
+        return cached;
+    }
+    const { store, shouldPersist } = await loadStoreFromDisk(dbPath);
+    storeCache.set(dbPath, store);
+    if (shouldPersist) {
+        await persistStore(dbPath, store);
+    }
+    return store;
+}
+async function withStoreLock(dbPath, action) {
+    const previous = storeLocks.get(dbPath) ?? Promise.resolve();
+    let resolveCurrent;
+    const current = new Promise((resolve) => {
+        resolveCurrent = resolve;
+    });
+    storeLocks.set(dbPath, previous.then(() => current));
+    await previous;
+    try {
+        return await action();
+    }
+    finally {
+        resolveCurrent?.();
+        if (storeLocks.get(dbPath) === current) {
+            storeLocks.delete(dbPath);
+        }
+    }
+}
+function bumpVersionAndDirtyView(store, kind) {
+    if (kind === "tasks") {
+        store.meta.tasks_version += 1;
+        const view = store.view_state.tasks_markdown;
+        view.dirty = true;
+        view.recordVersion += 1;
+        return store.meta.tasks_version;
+    }
+    store.meta.roadmaps_version += 1;
+    const view = store.view_state.roadmaps_markdown;
+    view.dirty = true;
+    view.recordVersion += 1;
+    return store.meta.roadmaps_version;
+}
+function toPublicTask(stored) {
+    return {
+        id: stored.id,
+        title: stored.title,
+        status: stored.status,
+        owner: stored.owner,
+        summary: stored.summary,
+        updatedAt: stored.updatedAt,
+        links: [...stored.links],
+        roadmapRefs: [...stored.roadmapRefs],
+        subState: stored.subState,
+        blocker: stored.blocker,
+    };
+}
+function toPublicRoadmap(stored) {
+    return {
+        id: stored.id,
+        title: stored.title,
+        status: stored.status,
+        time: stored.time,
+        updatedAt: stored.updatedAt,
+    };
+}
+function safeTime(value) {
+    const t = new Date(value).getTime();
+    return Number.isFinite(t) ? t : 0;
+}
+function normalizeStatusForSort(status) {
+    if (status === "IN_PROGRESS")
+        return 2;
+    if (status === "TODO")
+        return 1;
+    return 0;
+}
+async function getDuckdbConnection() {
+    if (!duckdbConnectionPromise) {
+        duckdbConnectionPromise = (async () => {
+            const instance = await duckdb.DuckDBInstance.create(":memory:");
+            return instance.connect();
+        })();
+    }
+    return duckdbConnectionPromise;
+}
+function normalizeStoredTaskLike(raw) {
+    if (!raw || typeof raw !== "object") {
+        return null;
+    }
+    const value = raw;
+    const id = value.id;
+    const title = value.title;
+    if (typeof id !== "string" || typeof title !== "string") {
+        return null;
+    }
+    const statusRaw = typeof value.status === "string" ? value.status : "TODO";
+    const owner = typeof value.owner === "string" ? value.owner : "";
+    const summary = typeof value.summary === "string" ? value.summary : "";
+    const updatedAt = typeof value.updatedAt === "string"
+        ? value.updatedAt
+        : (typeof value.updated_at === "string" ? value.updated_at : nowIso());
+    const links = Array.isArray(value.links) ? value.links.map((item) => String(item)) : [];
+    const roadmapRefs = Array.isArray(value.roadmapRefs)
+        ? value.roadmapRefs.map((item) => String(item))
+        : (Array.isArray(value.roadmap_refs) ? value.roadmap_refs.map((item) => String(item)) : []);
+    const recordVersionRaw = value.recordVersion ?? value.record_version;
+    const recordVersion = Number.isFinite(Number(recordVersionRaw)) ? Number(recordVersionRaw) : 1;
+    return {
+        id,
+        title,
+        status: normalizeTaskStatus(statusRaw),
+        owner,
+        summary,
+        updatedAt,
+        links,
+        roadmapRefs,
+        subState: value.subState,
+        blocker: value.blocker,
+        recordVersion,
+    };
+}
+function normalizeStoredRoadmapLike(raw) {
+    if (!raw || typeof raw !== "object") {
+        return null;
+    }
+    const value = raw;
+    const id = value.id;
+    const title = value.title;
+    if (typeof id !== "string" || typeof title !== "string") {
+        return null;
+    }
+    const statusRaw = typeof value.status === "string" ? value.status : "active";
+    const time = typeof value.time === "string" ? value.time : undefined;
+    const updatedAt = typeof value.updatedAt === "string"
+        ? value.updatedAt
+        : (typeof value.updated_at === "string" ? value.updated_at : nowIso());
+    const recordVersionRaw = value.recordVersion ?? value.record_version;
+    const recordVersion = Number.isFinite(Number(recordVersionRaw)) ? Number(recordVersionRaw) : 1;
+    return {
+        id,
+        title,
+        status: normalizeRoadmapStatus(statusRaw),
+        time,
+        updatedAt,
+        recordVersion,
+    };
+}
+async function runDuckdbQuery(sql) {
+    try {
+        const connection = await getDuckdbConnection();
+        const result = await connection.run(sql);
+        const rows = await result.getRowObjectsJS();
+        if (!rows || rows.length === 0) {
+            return undefined;
+        }
+        return rows;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function loadTasksFromDuckdb(dbPath) {
+    const sql = `SELECT tasks FROM read_json_auto('${dbPath.replace(/'/g, "''")}') LIMIT 1;`;
+    const rows = await runDuckdbQuery(sql);
+    if (!rows || rows.length === 0) {
+        return undefined;
+    }
+    const rawTasks = rows[0]?.tasks;
+    if (!Array.isArray(rawTasks)) {
+        return undefined;
+    }
+    return rawTasks
+        .map((item) => normalizeStoredTaskLike(item))
+        .filter((item) => item != null);
+}
+async function loadRoadmapsFromDuckdb(dbPath) {
+    const sql = `SELECT roadmaps FROM read_json_auto('${dbPath.replace(/'/g, "''")}') LIMIT 1;`;
+    const rows = await runDuckdbQuery(sql);
+    if (!rows || rows.length === 0) {
+        return undefined;
+    }
+    const rawRoadmaps = rows[0]?.roadmaps;
+    if (!Array.isArray(rawRoadmaps)) {
+        return undefined;
+    }
+    return rawRoadmaps
+        .map((item) => normalizeStoredRoadmapLike(item))
+        .filter((item) => item != null);
+}
+export async function ensureStore(dbPath) {
+    await openStore(dbPath);
+}
+export async function getStoreVersion(dbPath, kind) {
+    const store = await openStore(dbPath);
+    return kind === "tasks" ? store.meta.tasks_version : store.meta.roadmaps_version;
+}
+export async function getMarkdownViewState(dbPath, viewName) {
+    const store = await openStore(dbPath);
+    const view = store.view_state[viewName];
+    return {
+        dirty: view.dirty,
+        lastSourceVersion: view.lastSourceVersion,
+        lastBuiltAt: view.lastBuiltAt,
+    };
+}
+export async function markMarkdownViewBuilt(dbPath, viewName, sourceVersion, builtAt = nowIso()) {
+    await withStoreLock(dbPath, async () => {
+        const store = await openStore(dbPath);
+        const view = store.view_state[viewName];
+        view.dirty = false;
+        view.lastSourceVersion = sourceVersion;
+        view.lastBuiltAt = builtAt;
+        view.recordVersion += 1;
+        await persistStore(dbPath, store);
+    });
+}
+export async function markMarkdownViewDirty(dbPath, viewName) {
+    await withStoreLock(dbPath, async () => {
+        const store = await openStore(dbPath);
+        const view = store.view_state[viewName];
+        view.dirty = true;
+        view.recordVersion += 1;
+        await persistStore(dbPath, store);
+    });
+}
+export async function loadTasksFromStore(dbPath) {
+    const tasksFromDuckdb = await loadTasksFromDuckdb(dbPath);
+    if (!tasksFromDuckdb) {
+        throw new Error("DuckDB task query failed");
+    }
+    return tasksFromDuckdb.map(toPublicTask);
+}
+export async function loadTaskStatusStatsFromStore(dbPath) {
+    const tasks = await loadTasksFromStore(dbPath);
+    const todo = tasks.filter((task) => task.status === "TODO").length;
+    const inProgress = tasks.filter((task) => task.status === "IN_PROGRESS").length;
+    const blocked = tasks.filter((task) => task.status === "BLOCKED").length;
+    const done = tasks.filter((task) => task.status === "DONE").length;
+    const total = tasks.length;
+    const latestUpdatedAt = tasks
+        .map((task) => task.updatedAt)
+        .sort((a, b) => safeTime(b) - safeTime(a))[0] ?? "";
+    return { todo, inProgress, blocked, done, total, latestUpdatedAt };
+}
+export async function loadActionableTasksFromStore(dbPath, limit) {
+    const tasks = await loadTasksFromStore(dbPath);
+    const sorted = tasks
+        .filter((task) => task.status === "IN_PROGRESS" || task.status === "TODO")
+        .sort((a, b) => {
+        const ap = normalizeStatusForSort(a.status);
+        const bp = normalizeStatusForSort(b.status);
+        if (bp !== ap) {
+            return bp - ap;
+        }
+        const timeDelta = safeTime(b.updatedAt) - safeTime(a.updatedAt);
+        if (timeDelta !== 0) {
+            return timeDelta;
+        }
+        return b.id.localeCompare(a.id);
+    });
+    if (typeof limit === "number" && Number.isFinite(limit) && limit > 0) {
+        return sorted.slice(0, Math.floor(limit));
+    }
+    return sorted;
+}
+export async function upsertTaskInStore(dbPath, task) {
+    await withStoreLock(dbPath, async () => {
+        const store = await openStore(dbPath);
+        const index = store.tasks.findIndex((item) => item.id === task.id);
+        if (index >= 0) {
+            const previous = store.tasks[index];
+            store.tasks[index] = {
+                ...task,
+                status: normalizeTaskStatus(task.status),
+                links: [...(task.links ?? [])],
+                roadmapRefs: [...(task.roadmapRefs ?? [])],
+                recordVersion: previous.recordVersion + 1,
+            };
+        }
+        else {
+            store.tasks.push({
+                ...task,
+                status: normalizeTaskStatus(task.status),
+                links: [...(task.links ?? [])],
+                roadmapRefs: [...(task.roadmapRefs ?? [])],
+                recordVersion: 1,
+            });
+        }
+        bumpVersionAndDirtyView(store, "tasks");
+        await persistStore(dbPath, store);
+    });
+}
+export async function replaceTasksInStore(dbPath, tasks) {
+    await withStoreLock(dbPath, async () => {
+        const store = await openStore(dbPath);
+        store.tasks = tasks.map((task) => ({
+            ...task,
+            status: normalizeTaskStatus(task.status),
+            links: [...(task.links ?? [])],
+            roadmapRefs: [...(task.roadmapRefs ?? [])],
+            recordVersion: 1,
+        }));
+        bumpVersionAndDirtyView(store, "tasks");
+        await persistStore(dbPath, store);
+    });
+}
+export async function loadRoadmapsFromStore(dbPath) {
+    const roadmapsFromDuckdb = await loadRoadmapsFromDuckdb(dbPath);
+    if (!roadmapsFromDuckdb) {
+        throw new Error("DuckDB roadmap query failed");
+    }
+    return roadmapsFromDuckdb.map(toPublicRoadmap);
+}
+export async function loadRoadmapIdsFromStore(dbPath) {
+    const roadmaps = await loadRoadmapsFromStore(dbPath);
+    return roadmaps
+        .sort((a, b) => {
+        const timeDelta = safeTime(b.updatedAt) - safeTime(a.updatedAt);
+        if (timeDelta !== 0) {
+            return timeDelta;
+        }
+        return b.id.localeCompare(a.id);
+    })
+        .map((item) => item.id);
+}
+export async function replaceRoadmapsInStore(dbPath, milestones) {
+    await withStoreLock(dbPath, async () => {
+        const store = await openStore(dbPath);
+        store.roadmaps = milestones.map((milestone) => ({
+            ...milestone,
+            status: normalizeRoadmapStatus(milestone.status),
+            recordVersion: 1,
+        }));
+        bumpVersionAndDirtyView(store, "roadmaps");
+        await persistStore(dbPath, store);
+    });
+}
+export async function upsertRoadmapInStore(dbPath, milestone) {
+    await withStoreLock(dbPath, async () => {
+        const store = await openStore(dbPath);
+        const index = store.roadmaps.findIndex((item) => item.id === milestone.id);
+        if (index >= 0) {
+            const previous = store.roadmaps[index];
+            store.roadmaps[index] = {
+                ...milestone,
+                status: normalizeRoadmapStatus(milestone.status),
+                recordVersion: previous.recordVersion + 1,
+            };
+        }
+        else {
+            store.roadmaps.push({
+                ...milestone,
+                status: normalizeRoadmapStatus(milestone.status),
+                recordVersion: 1,
+            });
+        }
+        bumpVersionAndDirtyView(store, "roadmaps");
+        await persistStore(dbPath, store);
+    });
+}