prism-mcp-server 20.0.5 → 20.0.7

package/dist/utils/changelogGenerator.js

@@ -0,0 +1,158 @@
+/**
+ * v12.4: AI-Generated Changelogs from Session Ledger History
+ *
+ * Reads session ledger entries and generates human-readable changelogs
+ * in Keep a Changelog format. Uses local LLM (if available) for
+ * natural language summarization, with rule-based fallback.
+ */
+import { debugLog } from "./logger.js";
+// ─── Changelog Generation ────────────────────────────────────
+/**
+ * Classify a ledger summary into a changelog section.
+ */
+export function classifySummary(summary) {
+    const lower = summary.toLowerCase();
+    if (/\b(fix|bug|patch|resolve|repair|correct)\b/.test(lower))
+        return "fixed";
+    if (/\b(remov|delet|drop|deprecat|rip out)\b/.test(lower))
+        return "removed";
+    if (/\b(secur|vulnerab|cve|auth|encrypt|permission)\b/.test(lower))
+        return "security";
+    if (/\b(deprecat|sunset|legacy|phase out)\b/.test(lower))
+        return "deprecated";
+    if (/\b(add|creat|new|implement|introduc|support|feat)\b/.test(lower))
+        return "added";
+    return "changed";
+}
+/**
+ * Generate a changelog from ledger entries (rule-based).
+ */
+export function generateChangelog(entries, options = {}) {
+    const { fromDate, toDate, groupBy = "date", includeFileChanges = false, } = options;
+    // Filter by date range
+    let filtered = entries;
+    if (fromDate) {
+        filtered = filtered.filter(e => new Date(e.created_at) >= new Date(fromDate));
+    }
+    if (toDate) {
+        filtered = filtered.filter(e => new Date(e.created_at) <= new Date(toDate));
+    }
+    // Sort by date (newest first)
+    filtered.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+    const sections = {
+        added: [],
+        changed: [],
+        fixed: [],
+        removed: [],
+        security: [],
+        deprecated: [],
+    };
+    for (const entry of filtered) {
+        const section = classifySummary(entry.summary);
+        let line = entry.summary;
+        if (includeFileChanges && entry.files_changed?.length) {
+            line += ` (${entry.files_changed.join(", ")})`;
+        }
+        sections[section].push(line);
+        // Also classify decisions
+        if (entry.decisions) {
+            for (const decision of entry.decisions) {
+                const dSection = classifySummary(decision);
+                sections[dSection].push(`Decision: ${decision}`);
+            }
+        }
+    }
+    const now = new Date().toISOString().split("T")[0];
+    return {
+        version: "Unreleased",
+        date: now,
+        sections,
+    };
+}
+/**
+ * Format a changelog entry as Markdown (Keep a Changelog format).
+ */
+export function formatChangelogMarkdown(entry) {
+    const lines = [];
+    lines.push(`## [${entry.version}] - ${entry.date}`);
+    lines.push("");
+    const sectionNames = [
+        ["added", "Added"],
+        ["changed", "Changed"],
+        ["fixed", "Fixed"],
+        ["removed", "Removed"],
+        ["security", "Security"],
+        ["deprecated", "Deprecated"],
+    ];
+    for (const [key, label] of sectionNames) {
+        if (entry.sections[key].length > 0) {
+            lines.push(`### ${label}`);
+            for (const item of entry.sections[key]) {
+                lines.push(`- ${item}`);
+            }
+            lines.push("");
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a changelog entry as HTML.
+ */
+export function formatChangelogHtml(entry) {
+    let html = `<h2>[${entry.version}] - ${entry.date}</h2>\n`;
+    const sectionNames = [
+        ["added", "Added"],
+        ["changed", "Changed"],
+        ["fixed", "Fixed"],
+        ["removed", "Removed"],
+        ["security", "Security"],
+        ["deprecated", "Deprecated"],
+    ];
+    for (const [key, label] of sectionNames) {
+        if (entry.sections[key].length > 0) {
+            html += `<h3>${label}</h3>\n<ul>\n`;
+            for (const item of entry.sections[key]) {
+                html += `  <li>${escapeHtml(item)}</li>\n`;
+            }
+            html += `</ul>\n`;
+        }
+    }
+    return html;
+}
+function escapeHtml(str) {
+    return str
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+/**
+ * Generate a changelog with optional LLM summarization.
+ */
+export async function generateChangelogWithLlm(entries, options = {}) {
+    const changelog = generateChangelog(entries, options);
+    const format = options.format || "markdown";
+    if (!options.useLlm) {
+        return format === "html"
+            ? formatChangelogHtml(changelog)
+            : format === "json"
+                ? JSON.stringify(changelog, null, 2)
+                : formatChangelogMarkdown(changelog);
+    }
+    // LLM-enhanced: summarize each section
+    try {
+        const { callLocalLlm } = await import("./localLlm.js");
+        const rawMarkdown = formatChangelogMarkdown(changelog);
+        const enhanced = await callLocalLlm(`You are a technical writer. Rewrite this changelog to be more concise and professional. ` +
+            `Keep the Keep a Changelog format. Combine duplicate entries. ` +
+            `Use action verbs (Added, Fixed, Changed). Output markdown only:\n\n${rawMarkdown}`);
+        return enhanced || rawMarkdown;
+    }
+    catch {
+        debugLog("Changelog: LLM unavailable, using rule-based output");
+        return format === "html"
+            ? formatChangelogHtml(changelog)
+            : formatChangelogMarkdown(changelog);
+    }
+}
+debugLog("v12.4: Changelog generator loaded");

package/dist/utils/fallbackClient.js

@@ -0,0 +1,52 @@
+/**
+ * Supabase Direct Fallback Client
+ *
+ * When prism-mcp Railway/Fly endpoints are unreachable, this module
+ * allows critical tools (load_context, save_ledger, save_handoff) to
+ * call Supabase REST API directly — bypassing the prism-mcp server.
+ *
+ * Used by smithery-bridge.mjs health monitor: if /healthz fails 3× in
+ * a row, responses include a Retry-After + x-fallback-mode: supabase
+ * header so Claude Code can switch to direct-Supabase mode.
+ *
+ * Architecture:
+ *   Normal:   Agent → Railway prism-mcp → Supabase
+ *   Fallback: Agent → Supabase REST API directly (read-only for safety)
+ */
+const SUPABASE_URL = process.env.SUPABASE_URL || '';
+const SUPABASE_ANON_KEY = process.env.SUPABASE_ANON_KEY || '';
+/**
+ * Direct Supabase read — returns last handoff for a project.
+ * Called when prism-mcp is unreachable.
+ */
+export async function directLoadContext(project) {
+    if (!SUPABASE_URL || !SUPABASE_ANON_KEY)
+        return null;
+    try {
+        const res = await fetch(`${SUPABASE_URL}/rest/v1/session_handoffs?project=eq.${encodeURIComponent(project)}&order=updated_at.desc&limit=1`, { headers: { apikey: SUPABASE_ANON_KEY, Authorization: `Bearer ${SUPABASE_ANON_KEY}` } });
+        if (!res.ok)
+            return null;
+        const [row] = await res.json();
+        if (!row)
+            return null;
+        return {
+            project,
+            lastSummary: row.last_summary ?? '',
+            openTodos: row.open_todos ?? [],
+            keyContext: row.key_context ?? '',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Returns true if Railway prism-mcp primary is reachable. */
+export async function isPrimaryHealthy(primaryUrl) {
+    try {
+        const res = await fetch(`${primaryUrl}/healthz`, { signal: AbortSignal.timeout(3000) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/groundingVerifier.js

@@ -9,9 +9,9 @@
  * stateless MCP), pointed at free-form generation instead of tool-call
  * responses.
  *
- * Cascade role: qwen3.5:4b is the default verifier (fast, 2.5GB).
+ * Cascade role: prism-coder:4b is the default verifier (fast, 2.5GB).
  * 14b drafts; 4b verifies. Different model = Patronus rule satisfied.
- * Falls back to 2b on devices with <4GB free RAM.
+ * Falls back to 1b7 on devices with <4GB free RAM.
  *
  * Failure modes:
  *   - Verifier model unreachable / timeout → fail-closed refusal
@@ -93,7 +93,7 @@ function refusalText(action, failedClaim) {
     }
 }
 export async function verifyGrounding(opts) {
-    const verifierModel = opts.verifierModel ?? "qwen3.5:4b";
+    const verifierModel = opts.verifierModel ?? "prism-coder:4b";
     const timeoutMs = opts.timeoutMs ?? 2000;
     const ollamaUrl = opts.ollamaUrl ?? PRISM_LOCAL_LLM_URL;
     const fetchImpl = opts.fetchImpl ?? fetch;

package/dist/utils/inferenceMetrics.js

@@ -12,6 +12,7 @@
  *   undercounts on repeated system-prompt calls; submittedEst shows actual load.
  */
 import { debugLog } from "./logger.js";
+import { appendInferMetric, queryInferMetrics } from "../storage/inferMetricsLedger.js";
 // T1 fix: content-aware token estimator. Replaces flat text.length / 4 which
 // underestimates emoji (~2 UTF-16 units but 1.5-2.5 BPE tokens) and CJK
 // (~1 char ≈ 1 token) by 15-40%, and overestimates dense code (~3.3 chars/token).
@@ -52,6 +53,19 @@ export function recordPromptSeen(delegated) {
 export function recordInference(result) {
     if (result.backend === "safety_gate")
         return;
+    // Durable ledger row (fire-and-forget; in-memory counters below remain the
+    // per-session view). safety_gate is excluded by the early return above.
+    appendInferMetric({
+        backend: result.backend,
+        model: result.model_picked,
+        used_cloud: result.used_cloud,
+        mode: result.mode,
+        gate_outcome: result.quality_gate_failed ? "gate_failed_served" : undefined,
+        prompt_tokens: result.prompt_tokens,
+        completion_tokens: result.completion_tokens,
+        latency_ms: result.latency_ms,
+        ram_free_mb: result.ram_free_mb,
+    });
     const key = result.model_picked ?? result.backend;
     if (result.used_cloud) {
         cloudCalls++;
@@ -135,7 +149,30 @@ export function resetInferenceMetrics() {
     }
     debugLog("[inference-metrics] Session metrics reset");
 }
-export async function inferenceMetricsHandler() {
+export async function inferenceMetricsHandler(args) {
+    if (args?.period === "all") {
+        const agg = await queryInferMetrics();
+        if (!agg || agg.total === 0) {
+            return { content: [{ type: "text", text: "No persisted prism_infer calls yet (ledger empty)." }] };
+        }
+        const localPct = agg.total ? Math.round((agg.local / agg.total) * 100) : 0;
+        const cloudPct = agg.total ? Math.round((agg.cloud / agg.total) * 100) : 0;
+        const span = agg.first_ts && agg.last_ts
+            ? `${new Date(agg.first_ts).toISOString().slice(0, 10)} → ${new Date(agg.last_ts).toISOString().slice(0, 10)}`
+            : "n/a";
+        const byB = Object.entries(agg.by_backend)
+            .sort((a, b) => b[1] - a[1])
+            .map(([k, v]) => `  ${k}: ${v}`).join("\n");
+        return {
+            content: [{
+                    type: "text",
+                    text: `📊 Delegation Metrics — ALL TIME (persisted ledger, ${span})\n` +
+                        `Total calls: ${agg.total} — Local: ${agg.local} (${localPct}%) | Cloud: ${agg.cloud} (${cloudPct}%)\n` +
+                        `Prompt tokens: ${agg.prompt_tokens} | Completion tokens: ${agg.completion_tokens}\n` +
+                        `Avg latency: ${agg.avg_latency_ms}ms\nBy backend:\n${byB}`,
+                }],
+        };
+    }
     const block = formatInferenceMetrics();
     return {
         content: [{

package/dist/utils/memoryAttestation.js

@@ -0,0 +1,163 @@
+/**
+ * v12.4: Memory Attestation — SHA-256 Merkle Tree
+ *
+ * Provides cryptographic proof of memory integrity.
+ * Builds a Merkle tree from session entries, enabling:
+ *   - Tamper detection on individual entries
+ *   - Provable audit trail for compliance
+ *   - Efficient partial verification
+ */
+import { createHash } from "node:crypto";
+import { debugLog } from "./logger.js";
+// ─── Hashing ─────────────────────────────────────────────────
+/**
+ * SHA-256 hash of a string.
+ */
+export function sha256(data) {
+    return createHash("sha256").update(data, "utf8").digest("hex");
+}
+/**
+ * Hash two child hashes into a parent hash.
+ */
+export function hashPair(left, right) {
+    return sha256(left + right);
+}
+/**
+ * Hash a memory entry's content for use as a leaf node.
+ */
+export function hashEntry(entryId, content, timestamp) {
+    return sha256(`${entryId}:${content}:${timestamp}`);
+}
+// ─── Merkle Tree Construction ────────────────────────────────
+/**
+ * Build a Merkle tree from leaf hashes.
+ */
+export function buildMerkleTree(entries) {
+    if (entries.length === 0)
+        return null;
+    // Create leaf nodes
+    let nodes = entries.map(e => ({
+        hash: e.hash,
+        entryId: e.id,
+        depth: 0,
+    }));
+    // If odd number of leaves, duplicate the last one
+    if (nodes.length % 2 !== 0) {
+        nodes.push({ ...nodes[nodes.length - 1] });
+    }
+    let depth = 0;
+    // Build tree bottom-up
+    while (nodes.length > 1) {
+        depth++;
+        const next = [];
+        for (let i = 0; i < nodes.length; i += 2) {
+            const left = nodes[i];
+            const right = nodes[i + 1] || left; // Duplicate last if odd
+            next.push({
+                hash: hashPair(left.hash, right.hash),
+                left,
+                right,
+                depth,
+            });
+        }
+        nodes = next;
+    }
+    return nodes[0];
+}
+/**
+ * Get the Merkle root hash.
+ */
+export function getMerkleRoot(entries) {
+    const tree = buildMerkleTree(entries);
+    return tree?.hash || sha256("empty");
+}
+// ─── Proof Generation & Verification ─────────────────────────
+/**
+ * Generate a Merkle proof for a specific entry.
+ */
+export function generateProof(entries, targetEntryId) {
+    const targetIdx = entries.findIndex(e => e.id === targetEntryId);
+    if (targetIdx === -1)
+        return null;
+    // Pad to even length
+    const padded = [...entries];
+    if (padded.length % 2 !== 0) {
+        padded.push({ ...padded[padded.length - 1] });
+    }
+    const proof = [];
+    let idx = targetIdx;
+    let currentLevel = padded.map(e => e.hash);
+    while (currentLevel.length > 1) {
+        const nextLevel = [];
+        const siblingIdx = idx % 2 === 0 ? idx + 1 : idx - 1;
+        if (siblingIdx < currentLevel.length) {
+            proof.push({
+                hash: currentLevel[siblingIdx],
+                position: idx % 2 === 0 ? "right" : "left",
+            });
+        }
+        for (let i = 0; i < currentLevel.length; i += 2) {
+            const left = currentLevel[i];
+            const right = currentLevel[i + 1] || left;
+            nextLevel.push(hashPair(left, right));
+        }
+        idx = Math.floor(idx / 2);
+        currentLevel = nextLevel;
+    }
+    const root = currentLevel[0];
+    const entryHash = entries[targetIdx].hash;
+    return {
+        entryId: targetEntryId,
+        entryHash,
+        proof,
+        root,
+        verified: verifyProof(entryHash, proof, root),
+    };
+}
+/**
+ * Verify a Merkle proof.
+ */
+export function verifyProof(entryHash, proof, expectedRoot) {
+    let currentHash = entryHash;
+    for (const step of proof) {
+        if (step.position === "right") {
+            currentHash = hashPair(currentHash, step.hash);
+        }
+        else {
+            currentHash = hashPair(step.hash, currentHash);
+        }
+    }
+    return currentHash === expectedRoot;
+}
+// ─── Attestation Report ──────────────────────────────────────
+/**
+ * Generate a full attestation report for a project's memory.
+ */
+export function generateAttestationReport(project, entries) {
+    const hashedEntries = entries.map(e => ({
+        id: e.id,
+        hash: hashEntry(e.id, e.content, e.timestamp),
+    }));
+    const tree = buildMerkleTree(hashedEntries);
+    const report = {
+        root: tree?.hash || sha256("empty"),
+        entryCount: entries.length,
+        treeDepth: tree?.depth || 0,
+        generatedAt: new Date().toISOString(),
+        project,
+        entries: hashedEntries,
+    };
+    debugLog(`Attestation: Generated report for '${project}' — ${entries.length} entries, root: ${report.root.slice(0, 16)}...`);
+    return report;
+}
+/**
+ * Verify that a single entry hasn't been tampered with.
+ */
+export function verifyEntry(entryId, content, timestamp, report) {
+    const expectedHash = hashEntry(entryId, content, timestamp);
+    const storedEntry = report.entries.find(e => e.id === entryId);
+    if (!storedEntry)
+        return false;
+    return storedEntry.hash === expectedHash;
+}
+debugLog("v12.4: Memory attestation (Merkle tree) loaded");