@projitive/mcp 2.0.0 → 2.0.2

package/README.md

@@ -5,7 +5,7 @@ Language: English | [简体中文](README_CN.md)
 ## Version
 
 - Current Spec Version: projitive-spec v1.0.0
-- MCP Version: 2.0.0
+- MCP Version: 2.0.1
 
 ## 60-Second Start
 
@@ -157,7 +157,7 @@ sequenceDiagram
 
 ### 3. Evidence-First Execution
 
-- State changes should be backed by report/design/readme evidence.
+- State changes should be backed by report/designs/readme evidence.
 - Tool output format is agent-friendly markdown for chained execution.
 
 ### 4. Deterministic Multi-Agent Workflow

package/output/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@projitive/mcp",
-    "version": "2.0.0",
+    "version": "2.0.2",
     "description": "Projitive MCP Server for project and task discovery/update",
     "license": "ISC",
     "author": "",
@@ -25,14 +25,11 @@
         "output"
     ],
     "dependencies": {
-        "@duckdb/node-api": "1.5.0-r.1",
         "@modelcontextprotocol/sdk": "^1.17.5",
-        "sql.js": "^1.14.1",
         "zod": "^3.23.8"
     },
     "devDependencies": {
         "@types/node": "^24.3.0",
-        "@types/sql.js": "^1.4.9",
         "@vitest/coverage-v8": "^3.2.4",
         "tsx": "^4.20.5",
         "typescript": "^5.9.2",

package/output/source/common/linter.js

@@ -13,6 +13,7 @@ export const TASK_LINT_CODES = {
     ROADMAP_REFS_EMPTY: "TASK_ROADMAP_REFS_EMPTY",
     OUTSIDE_MARKER: "TASK_OUTSIDE_MARKER",
     LINK_TARGET_MISSING: "TASK_LINK_TARGET_MISSING",
+    LINK_PATH_FORMAT_INVALID: "TASK_LINK_PATH_FORMAT_INVALID",
     HOOK_FILE_MISSING: "TASK_HOOK_FILE_MISSING",
     FILTER_EMPTY: "TASK_FILTER_EMPTY",
     CONTEXT_HOOK_HEAD_MISSING: "TASK_CONTEXT_HOOK_HEAD_MISSING",

package/output/source/common/store.js

@@ -1,13 +1,8 @@
 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,
@@ -37,17 +32,6 @@ function defaultStore() {
 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;
@@ -57,12 +41,6 @@ function normalizeTaskStatus(status) {
 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 ?? {};
@@ -129,106 +107,6 @@ function normalizeStore(input) {
         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()}`;
@@ -241,10 +119,6 @@ async function loadStoreFromDisk(dbPath) {
     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 };
@@ -337,119 +211,6 @@ function normalizeStatusForSort(status) {
         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);
 }
@@ -487,11 +248,8 @@ export async function markMarkdownViewDirty(dbPath, viewName) {
     });
 }
 export async function loadTasksFromStore(dbPath) {
-    const tasksFromDuckdb = await loadTasksFromDuckdb(dbPath);
-    if (!tasksFromDuckdb) {
-        throw new Error("DuckDB task query failed");
-    }
-    return tasksFromDuckdb.map(toPublicTask);
+    const store = await openStore(dbPath);
+    return store.tasks.map(toPublicTask);
 }
 export async function loadTaskStatusStatsFromStore(dbPath) {
     const tasks = await loadTasksFromStore(dbPath);
@@ -568,11 +326,8 @@ export async function replaceTasksInStore(dbPath, tasks) {
     });
 }
 export async function loadRoadmapsFromStore(dbPath) {
-    const roadmapsFromDuckdb = await loadRoadmapsFromDuckdb(dbPath);
-    if (!roadmapsFromDuckdb) {
-        throw new Error("DuckDB roadmap query failed");
-    }
-    return roadmapsFromDuckdb.map(toPublicRoadmap);
+    const store = await openStore(dbPath);
+    return store.roadmaps.map(toPublicRoadmap);
 }
 export async function loadRoadmapIdsFromStore(dbPath) {
     const roadmaps = await loadRoadmapsFromStore(dbPath);

package/output/source/prompts/quickStart.js

@@ -99,7 +99,7 @@ export function registerQuickStartPrompt(server) {
             "2. If roadmap has active goals, split milestones into 1-3 executable TODO tasks",
             "3. Apply task creation gate before adding each task:",
             "   - Clear outcome: one-sentence done condition",
-            "   - Verifiable evidence: at least one report/design/readme link target",
+            "   - Verifiable evidence: at least one report/designs/readme link target",
             "   - Small slice: should be completable in one focused execution cycle",
             "   - Traceability: include at least one roadmapRefs item when applicable",
             "   - Distinct scope: avoid overlap with existing DONE/BLOCKED tasks",

package/output/source/resources/readme.test.js

@@ -10,7 +10,7 @@ describe("readme module", () => {
                 "",
                 "## Required Reading for Agents",
                 "",
-                "- Local: ./design/README.md",
+                "- Local: ./designs/README.md",
                 "- Local: .projitive/tasks.md",
                 "- External: https://example.com/docs",
                 "",
@@ -22,7 +22,7 @@ describe("readme module", () => {
             expect(result.length).toBe(3);
             expect(result[0]).toEqual({
                 source: "Local",
-                value: "./design/README.md",
+                value: "./designs/README.md",
             });
             expect(result[1]).toEqual({
                 source: "Local",

package/output/source/tools/task.js

@@ -42,7 +42,7 @@ const DEFAULT_NO_TASK_DISCOVERY_GUIDANCE = [
     "- If all remaining tasks are BLOCKED, create one unblock task with explicit unblock condition and dependency owner.",
     "- Start from active roadmap milestones and split into the smallest executable slices with a single done condition each.",
     "- Prefer slices that unlock multiple downstream tasks before isolated refactors or low-impact cleanups.",
-    "- Create TODO tasks only when evidence is clear: each new task must produce at least one report/design/readme artifact update.",
+    "- Create TODO tasks only when evidence is clear: each new task must produce at least one report/designs/readme artifact update.",
     "- Skip duplicate scope: do not create tasks that overlap existing TODO/IN_PROGRESS/BLOCKED task intent.",
     "- Use quality gates for discovery candidates: user value, delivery risk reduction, or measurable throughput improvement.",
     "- Keep each discovery round small (1-3 tasks), then rerun taskNext immediately for re-ranking and execution.",
@@ -85,11 +85,33 @@ export function renderTaskSeedTemplate(roadmapRef) {
         "- updatedAt: 2026-01-01T00:00:00.000Z",
         `- roadmapRefs: ${roadmapRef}`,
         "- links:",
-        "  - ./README.md",
-        "  - ./roadmap.md",
+        "  - README.md",
+        "  - .projitive/roadmap.md",
         "```",
     ];
 }
+function isHttpUrl(value) {
+    return /^https?:\/\//i.test(value);
+}
+function isProjectRootRelativePath(value) {
+    return value.length > 0
+        && !value.startsWith("/")
+        && !value.startsWith("./")
+        && !value.startsWith("../")
+        && !/^[A-Za-z]:\//.test(value);
+}
+function normalizeTaskLink(link) {
+    const trimmed = link.trim();
+    if (trimmed.length === 0 || isHttpUrl(trimmed)) {
+        return trimmed;
+    }
+    const slashNormalized = trimmed.replace(/\\/g, "/");
+    const withoutDotPrefix = slashNormalized.replace(/^\.\//, "");
+    return withoutDotPrefix.replace(/^\/+/, "");
+}
+function resolveTaskLinkPath(projectPath, link) {
+    return path.join(projectPath, link);
+}
 async function readActionableTaskCandidates(governanceDirs) {
     const snapshots = await Promise.all(governanceDirs.map(async (governanceDir) => {
         const tasksPath = path.join(governanceDir, ".projitive");
@@ -206,7 +228,12 @@ export function normalizeTask(task) {
         owner: task.owner ? String(task.owner) : "",
         summary: task.summary ? String(task.summary) : "",
         updatedAt: task.updatedAt ? String(task.updatedAt) : nowIso(),
-        links: Array.isArray(task.links) ? task.links.map(String) : [],
+        links: Array.isArray(task.links)
+            ? Array.from(new Set(task.links
+                .map(String)
+                .map((value) => normalizeTaskLink(value))
+                .filter((value) => value.length > 0)))
+            : [],
         roadmapRefs: Array.from(new Set(normalizedRoadmapRefs)),
     };
     // Include optional v1.1.0 fields if present
@@ -274,6 +301,17 @@ function collectTaskLintSuggestionItems(tasks) {
             fixHint: "Bind at least one ROADMAP-xxxx when applicable.",
         });
     }
+    const invalidLinkPathFormat = tasks.filter((task) => task.links.some((link) => {
+        const normalized = link.trim();
+        return normalized.length > 0 && !isHttpUrl(normalized) && !isProjectRootRelativePath(normalized);
+    }));
+    if (invalidLinkPathFormat.length > 0) {
+        suggestions.push({
+            code: TASK_LINT_CODES.LINK_PATH_FORMAT_INVALID,
+            message: `${invalidLinkPathFormat.length} task(s) contain invalid links path format.`,
+            fixHint: "Use project-root-relative paths without leading slash (for example reports/task-0001.md) or http(s) URL.",
+        });
+    }
     // ============================================================================
     // Spec v1.1.0 - Blocker Categorization Validation
     // ============================================================================
@@ -349,6 +387,17 @@ function collectSingleTaskLintSuggestions(task) {
             fixHint: "Add at least one evidence link.",
         });
     }
+    const invalidLinkPathFormat = task.links.some((link) => {
+        const normalized = link.trim();
+        return normalized.length > 0 && !isHttpUrl(normalized) && !isProjectRootRelativePath(normalized);
+    });
+    if (invalidLinkPathFormat) {
+        suggestions.push({
+            code: TASK_LINT_CODES.LINK_PATH_FORMAT_INVALID,
+            message: "Current task has invalid links path format.",
+            fixHint: "Use project-root-relative paths without leading slash (for example reports/task-0001.md) or http(s) URL.",
+        });
+    }
     if (task.status === "BLOCKED" && task.summary.trim().length === 0) {
         suggestions.push({
             code: TASK_LINT_CODES.BLOCKED_SUMMARY_EMPTY,
@@ -422,6 +471,7 @@ function collectSingleTaskLintSuggestions(task) {
 }
 async function collectTaskFileLintSuggestions(governanceDir, task) {
     const suggestions = [];
+    const projectPath = toProjectPath(governanceDir);
     for (const link of task.links) {
         const normalized = link.trim();
         if (normalized.length === 0) {
@@ -430,7 +480,15 @@ async function collectTaskFileLintSuggestions(governanceDir, task) {
         if (/^https?:\/\//i.test(normalized)) {
             continue;
         }
-        const resolvedPath = path.resolve(governanceDir, normalized);
+        if (!isProjectRootRelativePath(normalized)) {
+            suggestions.push({
+                code: TASK_LINT_CODES.LINK_PATH_FORMAT_INVALID,
+                message: `Link path should be project-root-relative without leading slash: ${normalized}.`,
+                fixHint: "Use path/from/project/root format.",
+            });
+            continue;
+        }
+        const resolvedPath = resolveTaskLinkPath(projectPath, normalized);
         const exists = await fs.access(resolvedPath).then(() => true).catch(() => false);
         if (!exists) {
             suggestions.push({

package/output/source/tools/task.test.js

@@ -111,6 +111,30 @@ describe("tasks module", () => {
         expect(lint.some((line) => line.includes("BLOCKED_WITHOUT_BLOCKER"))).toBe(true);
         expect(lint.some((line) => line.includes("IN_PROGRESS_WITHOUT_SUBSTATE"))).toBe(true);
     });
+    it("normalizes links to project-root-relative format without leading slash", () => {
+        const task = normalizeTask({
+            id: "TASK-0003",
+            title: "link normalize",
+            status: "TODO",
+            links: ["/reports/a.md", "./designs/b.md", "reports/c.md", "https://example.com/evidence"],
+        });
+        expect(task.links).toContain("reports/a.md");
+        expect(task.links).toContain("designs/b.md");
+        expect(task.links).toContain("reports/c.md");
+        expect(task.links).toContain("https://example.com/evidence");
+        expect(task.links.some((item) => item.startsWith("/"))).toBe(false);
+    });
+    it("lints invalid links path format", () => {
+        const task = normalizeTask({
+            id: "TASK-0004",
+            title: "invalid link",
+            status: "TODO",
+            links: ["../outside.md"],
+            roadmapRefs: ["ROADMAP-0001"],
+        });
+        const lint = collectTaskLintSuggestions([task]);
+        expect(lint.some((line) => line.includes("TASK_LINK_PATH_FORMAT_INVALID"))).toBe(true);
+    });
     it("renders seed task template with provided roadmap ref", () => {
         const lines = renderTaskSeedTemplate("ROADMAP-0099");
         const markdown = lines.join("\n");

package/output/source/types.js

@@ -36,6 +36,7 @@ export const TASK_LINT_CODES = {
     OUTSIDE_MARKER: "TASK_OUTSIDE_MARKER",
     FILTER_EMPTY: "TASK_FILTER_EMPTY",
     LINK_TARGET_MISSING: "TASK_LINK_TARGET_MISSING",
+    LINK_PATH_FORMAT_INVALID: "TASK_LINK_PATH_FORMAT_INVALID",
     // Spec v1.1.0 - Blocker Categorization
     BLOCKED_WITHOUT_BLOCKER: "TASK_BLOCKED_WITHOUT_BLOCKER",
     BLOCKER_TYPE_INVALID: "TASK_BLOCKER_TYPE_INVALID",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projitive/mcp",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Projitive MCP Server for project and task discovery/update",
   "license": "ISC",
   "author": "",
@@ -25,14 +25,11 @@
     "output"
   ],
   "dependencies": {
-    "@duckdb/node-api": "1.5.0-r.1",
     "@modelcontextprotocol/sdk": "^1.17.5",
-    "sql.js": "^1.14.1",
     "zod": "^3.23.8"
   },
   "devDependencies": {
     "@types/node": "^24.3.0",
-    "@types/sql.js": "^1.4.9",
     "@vitest/coverage-v8": "^3.2.4",
     "tsx": "^4.20.5",
     "typescript": "^5.9.2",

package/output/source/common/migrations/runner.js

@@ -1,68 +0,0 @@
-import { MIGRATION_STEPS } from "./steps.js";
-function setStoreSchemaVersion(db, nextVersion) {
-    const statement = db.prepare(`
-    INSERT INTO meta (key, value)
-    VALUES (?, ?)
-    ON CONFLICT(key) DO UPDATE SET value=excluded.value
-  `);
-    statement.run(["store_schema_version", String(nextVersion)]);
-    statement.free();
-}
-function writeMigrationHistory(db, migrationId, fromVersion, toVersion, checksum, status, startedAt, finishedAt, errorMessage) {
-    const statement = db.prepare(`
-    INSERT INTO migration_history (
-      id,
-      from_version,
-      to_version,
-      checksum,
-      started_at,
-      finished_at,
-      status,
-      error_message
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-    statement.run([
-        migrationId,
-        fromVersion,
-        toVersion,
-        checksum,
-        startedAt,
-        finishedAt,
-        status,
-        errorMessage,
-    ]);
-    statement.free();
-}
-export function runPendingMigrations(db, currentVersion, targetVersion) {
-    let versionCursor = currentVersion;
-    if (versionCursor >= targetVersion) {
-        return;
-    }
-    const steps = MIGRATION_STEPS
-        .filter((item) => item.fromVersion >= currentVersion && item.toVersion <= targetVersion)
-        .sort((a, b) => a.fromVersion - b.fromVersion);
-    for (const step of steps) {
-        if (step.fromVersion !== versionCursor) {
-            throw new Error(`Migration chain broken at version ${versionCursor}. Missing step ${versionCursor} -> ${step.toVersion}.`);
-        }
-        const startedAt = new Date().toISOString();
-        try {
-            db.exec("BEGIN TRANSACTION;");
-            step.up(db);
-            setStoreSchemaVersion(db, step.toVersion);
-            const finishedAt = new Date().toISOString();
-            writeMigrationHistory(db, step.id, step.fromVersion, step.toVersion, step.checksum, "SUCCESS", startedAt, finishedAt, null);
-            db.exec("COMMIT;");
-            versionCursor = step.toVersion;
-        }
-        catch (error) {
-            db.exec("ROLLBACK;");
-            const finishedAt = new Date().toISOString();
-            writeMigrationHistory(db, step.id, step.fromVersion, step.toVersion, step.checksum, "FAILED", startedAt, finishedAt, error instanceof Error ? error.message : String(error));
-            throw error;
-        }
-    }
-    if (versionCursor !== targetVersion) {
-        throw new Error(`Migration target not reached. expected=${targetVersion}, actual=${versionCursor}`);
-    }
-}

package/output/source/common/migrations/steps.js

@@ -1,55 +0,0 @@
-function hasColumn(db, tableName, columnName) {
-    const result = db.exec(`PRAGMA table_info(${tableName});`);
-    if (result.length === 0) {
-        return false;
-    }
-    const rows = result[0].values;
-    return rows.some((row) => String(row[1]) === columnName);
-}
-function ensureRecordVersionColumns(db) {
-    const tables = ["tasks", "roadmaps", "meta", "view_state"];
-    for (const tableName of tables) {
-        if (!hasColumn(db, tableName, "record_version")) {
-            db.exec(`ALTER TABLE ${tableName} ADD COLUMN record_version INTEGER NOT NULL DEFAULT 1;`);
-        }
-    }
-}
-function ensurePerformanceIndexes(db) {
-    db.exec(`
-    CREATE INDEX IF NOT EXISTS idx_tasks_status_updated
-      ON tasks(status, updated_at DESC);
-    CREATE INDEX IF NOT EXISTS idx_tasks_updated
-      ON tasks(updated_at DESC);
-    CREATE INDEX IF NOT EXISTS idx_roadmaps_updated
-      ON roadmaps(updated_at DESC);
-  `);
-}
-export const MIGRATION_STEPS = [
-    {
-        id: "20260313_baseline_v1",
-        fromVersion: 0,
-        toVersion: 1,
-        checksum: "baseline-v1",
-        up: () => {
-            // Baseline marker for pre-versioned stores.
-        },
-    },
-    {
-        id: "20260313_add_record_version_v2",
-        fromVersion: 1,
-        toVersion: 2,
-        checksum: "add-record-version-v2",
-        up: (db) => {
-            ensureRecordVersionColumns(db);
-        },
-    },
-    {
-        id: "20260313_add_indexes_v3",
-        fromVersion: 2,
-        toVersion: 3,
-        checksum: "add-indexes-v3",
-        up: (db) => {
-            ensurePerformanceIndexes(db);
-        },
-    },
-];

package/output/source/common/migrations/types.js

@@ -1 +0,0 @@
-export {};