@projitive/mcp 1.1.2 → 2.0.0

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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,55 @@
+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

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

package/output/source/common/response.js

@@ -1,3 +1,117 @@
+import fs from "node:fs";
+import path from "node:path";
+const MESSAGE_TEMPLATE_ENV = "PROJITIVE_MESSAGE_TEMPLATE_PATH";
+const CONTENT_TEMPLATE_TOKEN = "{{content}}";
+function baseToolTemplateMarkdown() {
+    return [
+        "# {{tool_name}}",
+        "",
+        "## Summary",
+        "{{summary}}",
+        "",
+        "## Evidence",
+        "{{evidence}}",
+        "",
+        "## Agent Guidance",
+        "{{guidance}}",
+        "",
+        "## Next Call",
+        "{{next_call}}",
+        "",
+        "## Raw Response",
+        "{{content}}",
+    ].join("\n");
+}
+function contextGuideTemplateExtra() {
+    return [
+        "",
+        "## Common Tool Guides To Read First",
+        "- ./CLAUDE.md",
+        "- ./AGENTS.md",
+        "- ./.github/copilot-instructions.md",
+        "- ./.cursorrules",
+        "- ./.github/instructions/*",
+        "- ./.cursor/rules/*",
+    ];
+}
+function idleDiscoveryTemplateExtra() {
+    return [
+        "",
+        "## Idle Discovery Checklist (When No Actionable Task)",
+        "- Scan backlog comments: TODO / FIXME / HACK / XXX.",
+        "- Check lint gaps and create executable fix tasks.",
+        "- Check test quality gaps (missing tests, flaky tests, low-value coverage).",
+        "- Learn current project architecture and consolidate/update design docs in designs/.",
+        "- Re-run {{tool_name}} after creating 1-3 focused TODO tasks.",
+    ];
+}
+function commitReminderTemplateExtra() {
+    return [
+        "",
+        "## Commit Reminder",
+        "- After this update, create a commit to keep progress auditable.",
+        "- Recommended format: type(scope): summary",
+        "- Example: feat(task): complete TASK-0007 validation flow",
+        "- Footer suggestion: Refs: TASK-0007, ROADMAP-0002",
+    ];
+}
+export function getDefaultToolTemplateMarkdown(toolName) {
+    const base = baseToolTemplateMarkdown().split("\n");
+    if (toolName === "taskNext") {
+        return [...base, ...idleDiscoveryTemplateExtra()].join("\n");
+    }
+    if (toolName === "projectContext" || toolName === "taskContext" || toolName === "roadmapContext") {
+        return [...base, ...contextGuideTemplateExtra()].join("\n");
+    }
+    if (toolName === "taskUpdate" || toolName === "roadmapUpdate") {
+        return [...base, ...commitReminderTemplateExtra()].join("\n");
+    }
+    return base.join("\n");
+}
+function loadTemplateFile(templatePath) {
+    try {
+        const content = fs.readFileSync(templatePath, "utf-8").trim();
+        return content.length > 0 ? content : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function ensureTemplateFile(templatePath, toolName) {
+    const existing = loadTemplateFile(templatePath);
+    if (existing) {
+        return existing;
+    }
+    fs.mkdirSync(path.dirname(templatePath), { recursive: true });
+    const generated = getDefaultToolTemplateMarkdown(toolName);
+    fs.writeFileSync(templatePath, `${generated}\n`, "utf-8");
+    return generated;
+}
+function resolveTemplateTarget(toolName) {
+    const configuredPath = process.env[MESSAGE_TEMPLATE_ENV]?.trim();
+    if (!configuredPath) {
+        return path.resolve(process.cwd(), ".projitive", "templates", "tools", `${toolName}.md`);
+    }
+    const absolutePath = path.resolve(configuredPath);
+    try {
+        const stat = fs.statSync(absolutePath);
+        if (stat.isDirectory()) {
+            return path.join(absolutePath, `${toolName}.md`);
+        }
+        return absolutePath;
+    }
+    catch {
+        const ext = path.extname(absolutePath).toLowerCase();
+        if (ext === ".md") {
+            return absolutePath;
+        }
+        return path.join(absolutePath, `${toolName}.md`);
+    }
+}
+function loadMessageTemplate(toolName) {
+    const templatePath = resolveTemplateTarget(toolName);
+    return ensureTemplateFile(templatePath, toolName);
+}
 export function asText(markdown) {
     return {
         content: [{ type: "text", text: markdown }],
@@ -49,17 +163,49 @@ export function lintSection(lines) {
 export function nextCallSection(nextCall) {
     return section("Next Call", nextCall ? [nextCall] : []);
 }
+function toSectionText(section) {
+    if (!section) {
+        return "- (none)";
+    }
+    return withFallback(section.lines).join("\n");
+}
+function resolveSection(payload, title) {
+    return payload.sections.find((item) => item.title === title);
+}
+function buildToolTemplateVariables(payload, classicMarkdown) {
+    return {
+        tool_name: payload.toolName,
+        content: classicMarkdown,
+        summary: toSectionText(resolveSection(payload, "Summary")),
+        evidence: toSectionText(resolveSection(payload, "Evidence")),
+        guidance: toSectionText(resolveSection(payload, "Agent Guidance")),
+        next_call: toSectionText(resolveSection(payload, "Next Call")),
+    };
+}
+function applyTemplateVariables(template, variables) {
+    let rendered = template;
+    for (const [key, value] of Object.entries(variables)) {
+        rendered = rendered.split(`{{${key}}}`).join(value);
+    }
+    if (!rendered.includes(variables.content) && !template.includes(CONTENT_TEMPLATE_TOKEN)) {
+        rendered = `${rendered}\n\n${variables.content}`;
+    }
+    return rendered.trimEnd();
+}
 export function renderToolResponseMarkdown(payload) {
     const body = payload.sections.flatMap((section) => [
         `## ${section.title}`,
         ...withFallback(section.lines),
         "",
     ]);
-    return [
+    const classicMarkdown = [
         `# ${payload.toolName}`,
         "",
         ...body,
     ].join("\n").trimEnd();
+    const template = loadMessageTemplate(payload.toolName);
+    const variables = buildToolTemplateVariables(payload, classicMarkdown);
+    return applyTemplateVariables(template, variables);
 }
 export function renderErrorMarkdown(toolName, cause, nextSteps, retryExample) {
     return renderToolResponseMarkdown({