prism-mcp-server 9.1.0 → 9.2.0

package/README.md

@@ -35,6 +35,7 @@ https://github.com/dcostenco/prism-mcp/raw/main/docs/prism_mcp_demo.mp4
 - [Use Cases](#use-cases)
 - [What's New](#whats-new)
 - [How Prism Compares](#how-prism-compares)
+- [CLI Reference](#-cli-reference)
 - [Tool Reference](#tool-reference)
 - [Environment Variables](#environment-variables)
 - [Architecture](#architecture)
@@ -248,6 +249,16 @@ When wrapping up, always call `mcp__prism-mcp__session_save_ledger` and `mcp__pr
 
 > **Format Note:** Claude automatically wraps MCP tools with double underscores (`mcp__prism-mcp__...`), while most other clients use single underscores (`mcp_prism-mcp_...`). Prism's backend natively handles both formats seamlessly.
 
+**CLI Alternative:** If MCP tools aren't available or you're scripting around Claude Code:
+
+```bash
+# Load context before a session
+prism load my-project --level deep
+
+# Machine-readable JSON for parsing in scripts
+prism load my-project --level deep --json
+```
+
 </details>
 
 <details id="antigravity-auto-load">
@@ -255,6 +266,46 @@ When wrapping up, always call `mcp__prism-mcp__session_save_ledger` and `mcp__pr
 
 See the [Gemini Setup Guide](docs/SETUP_GEMINI.md) for the proven three-layer prompt architecture to ensure reliable session auto-loading.
 
+Antigravity doesn't expose MCP tools to the model. Use the `prism load` CLI as a fallback:
+
+```bash
+# From a shell or run_command tool
+prism load my-project --level standard --json
+
+# Or via the wrapper script
+bash ~/.gemini/antigravity/scratch/prism_session_loader.sh my-project
+```
+
+The CLI uses the same storage layer as the MCP tool (SQLite or Supabase).
+
+</details>
+
+<details>
+<summary><strong>Bash / CI/CD / Scripts</strong></summary>
+
+Use the `prism load` CLI to access session context from any shell environment:
+
+```bash
+# Quick check — human-readable
+prism load my-project
+
+# Parse JSON in scripts
+CONTEXT=$(prism load my-project --level quick --json)
+SUMMARY=$(echo "$CONTEXT" | jq -r '.handoff[0].last_summary')
+VERSION=$(echo "$CONTEXT" | jq -r '.handoff[0].version')
+echo "Project at v$VERSION: $SUMMARY"
+
+# Role-scoped loading
+prism load my-project --role qa --json
+
+# Use in CI/CD to verify context exists before deploying
+if ! prism load my-project --level quick --json | jq -e '.handoff[0].version' > /dev/null 2>&1; then
+  echo "No Prism context found — skipping context-aware deploy"
+fi
+```
+
+> 📦 **Install:** `npm install -g prism-mcp-server` makes the `prism` CLI available globally. For local builds: `node /path/to/prism/dist/cli.js load`.
+
 </details>
 
 <details>
@@ -791,6 +842,29 @@ Every other AI coding pipeline has a fatal flaw: it asks the same model that wro
 
 ---
 
+## 💻 CLI Reference
+
+Prism includes a CLI for environments where MCP tools aren't available (CI/CD pipelines, Bash scripts, non-MCP IDEs like Antigravity):
+
+```bash
+# Load session context (same output as session_load_context MCP tool)
+prism load my-project                          # Human-readable, standard depth
+prism load my-project --level deep             # Full context
+prism load my-project --level quick --json     # Machine-readable JSON
+prism load my-project --role dev --json        # Role-scoped loading
+
+# Verification harness
+prism verify status                            # Check verification state
+prism verify status --json                     # Machine-readable output
+prism verify generate                          # Bless current rubric as canonical
+```
+
+> 💡 **When to use the CLI vs MCP tools:** If your environment supports MCP (Claude Desktop, Cursor, Windsurf, Cline), always use the MCP tools — they integrate seamlessly with the agent's tool-calling flow. Use the CLI when you need session context in scripts, CI/CD, or non-MCP IDEs.
+
+> 📦 **Installation:** The CLI is available as `prism` when installed globally (`npm install -g prism-mcp-server`), or via `node dist/cli.js` for local dev builds.
+
+---
+
 ## 🔧 Tool Reference
 
 Prism ships 30+ tools, but **90% of your workflow uses just three:**

package/dist/cli.js

@@ -3,11 +3,117 @@ import { Command } from 'commander';
 import { SqliteStorage } from './storage/sqlite.js';
 import { handleVerifyStatus, handleGenerateHarness } from './verification/cliHandler.js';
 import * as path from 'path';
+import { getStorage, closeStorage } from './storage/index.js';
+import { getSetting } from './storage/configStorage.js';
+import { PRISM_USER_ID, SERVER_CONFIG } from './config.js';
+import { getCurrentGitState } from './utils/git.js';
 const program = new Command();
 program
     .name('prism')
-    .description('Prism Configuration & CLI')
-    .version('7.3.1');
+    .description('Prism — The Mind Palace for AI Agents')
+    .version(SERVER_CONFIG.version);
+// ─── prism load <project> ─────────────────────────────────────
+// Loads session context using the same storage layer as the MCP
+// session_load_context tool. Works with both SQLite and Supabase.
+// Designed for environments that cannot use MCP tools directly
+// (Antigravity, Bash scripts, CI/CD pipelines).
+program
+    .command('load <project>')
+    .description('Load session context for a project (same output as session_load_context MCP tool)')
+    .option('-l, --level <level>', 'Context depth: quick, standard, deep', 'standard')
+    .option('-r, --role <role>', 'Role scope for context loading')
+    .option('--json', 'Emit machine-readable JSON instead of formatted text')
+    .action(async (project, options) => {
+    try {
+        const { level, role, json: jsonOutput } = options;
+        const validLevels = ['quick', 'standard', 'deep'];
+        if (!validLevels.includes(level)) {
+            console.error(`Error: Invalid level "${level}". Must be one of: ${validLevels.join(', ')}`);
+            process.exit(1);
+        }
+        // Use the shared storage singleton (respects PRISM_STORAGE, dashboard config, etc.)
+        const storage = await getStorage();
+        const effectiveRole = role || await getSetting('default_role', '') || undefined;
+        const data = await storage.loadContext(project, level, PRISM_USER_ID, effectiveRole);
+        if (!data) {
+            if (jsonOutput) {
+                console.log(JSON.stringify({ error: `No session context found for project "${project}"` }));
+            }
+            else {
+                console.log(`No session context found for project "${project}" at level ${level}.`);
+                console.log('This project has no previous session history. Starting fresh.');
+            }
+            await closeStorage();
+            process.exit(0);
+        }
+        const d = data;
+        // Gather git state for enrichment
+        const gitState = getCurrentGitState();
+        if (jsonOutput) {
+            // Machine-readable JSON envelope — matches what prism_session_loader.sh produced
+            const output = {
+                handoff: [{
+                        project,
+                        role: effectiveRole || d.role || 'global',
+                        last_summary: d.last_summary || null,
+                        pending_todo: d.pending_todo || null,
+                        active_decisions: d.active_decisions || null,
+                        keywords: d.keywords || null,
+                        key_context: d.key_context || null,
+                        active_branch: d.active_branch || null,
+                        version: d.version ?? null,
+                        updated_at: d.updated_at || null,
+                    }],
+                recent_ledger: (d.recent_sessions || []).map((s) => ({
+                    summary: s.summary || null,
+                    decisions: s.decisions || null,
+                    keywords: s.keywords || null,
+                    created_at: s.session_date || s.created_at || null,
+                })),
+                git_hash: gitState.commitSha ? gitState.commitSha.substring(0, 7) : null,
+                git_branch: gitState.branch || null,
+                pkg_version: SERVER_CONFIG.version,
+            };
+            console.log(JSON.stringify(output, null, 2));
+        }
+        else {
+            // Human-readable formatted output (same format as MCP tool)
+            let output = `📋 Session context for "${project}" (${level}):\n\n`;
+            if (d.last_summary)
+                output += `📝 Last Summary: ${d.last_summary}\n`;
+            if (d.active_branch)
+                output += `🌿 Active Branch: ${d.active_branch}\n`;
+            if (d.key_context)
+                output += `💡 Key Context: ${d.key_context}\n`;
+            if (d.pending_todo?.length) {
+                output += `\n✅ Open TODOs:\n` + d.pending_todo.map((t) => `  - ${t}`).join('\n') + '\n';
+            }
+            if (d.active_decisions?.length) {
+                output += `\n⚖️ Active Decisions:\n` + d.active_decisions.map((dec) => `  - ${dec}`).join('\n') + '\n';
+            }
+            if (d.keywords?.length) {
+                output += `\n🔑 Keywords: ${d.keywords.join(', ')}\n`;
+            }
+            if (d.recent_sessions?.length) {
+                output += `\n⏳ Recent Sessions:\n` + d.recent_sessions.map((s) => `  [${s.session_date?.split('T')[0]}] ${s.summary}`).join('\n') + '\n';
+            }
+            if (d.version != null) {
+                output += `\n🔑 Session version: ${d.version}. Pass expected_version: ${d.version} when saving handoff.`;
+            }
+            if (gitState.isRepo) {
+                output += `\n\n🔧 Git: ${gitState.branch} @ ${gitState.commitSha?.substring(0, 7)} (Prism v${SERVER_CONFIG.version})`;
+            }
+            console.log(output);
+        }
+        await closeStorage();
+    }
+    catch (err) {
+        console.error(`Error loading context: ${err instanceof Error ? err.message : String(err)}`);
+        await closeStorage().catch(() => { });
+        process.exit(1);
+    }
+});
+// ─── prism verify ─────────────────────────────────────────────
 const verifyCmd = program
     .command('verify')
     .description('Manage the verification harness');

package/dist/config.js

@@ -46,21 +46,21 @@ export const SERVER_CONFIG = {
 };
 // ─── Required: Brave Search API Key ───────────────────────────
 export const BRAVE_API_KEY = process.env.BRAVE_API_KEY;
-if (!BRAVE_API_KEY) {
+if (!BRAVE_API_KEY && process.env.PRISM_DEBUG_LOGGING === "true") {
     console.error("Warning: BRAVE_API_KEY environment variable is missing. Search tools will return errors when called.");
 }
 // ─── Optional: Google Gemini API Key ──────────────────────────
 // Used by the gemini_research_paper_analysis tool.
 // Without this, the tool will still appear but will error when called.
 export const GOOGLE_API_KEY = process.env.GOOGLE_API_KEY;
-if (!GOOGLE_API_KEY) {
+if (!GOOGLE_API_KEY && process.env.PRISM_DEBUG_LOGGING === "true") {
     console.error("Warning: GOOGLE_API_KEY environment variable is missing. Gemini research features will be unavailable.");
 }
 // ─── Optional: Brave Answers API Key ──────────────────────────
 // Used by the brave_answers tool for AI-grounded answers.
 // This is a separate API key from the main Brave Search key.
 export const BRAVE_ANSWERS_API_KEY = process.env.BRAVE_ANSWERS_API_KEY;
-if (!BRAVE_ANSWERS_API_KEY) {
+if (!BRAVE_ANSWERS_API_KEY && process.env.PRISM_DEBUG_LOGGING === "true") {
     console.error("Warning: BRAVE_ANSWERS_API_KEY environment variable is missing. Brave Answers tool will be unavailable.");
 }
 // ─── Optional: Voyage AI API Key ──────────────────────────────

package/dist/storage/index.js

@@ -16,9 +16,31 @@ export async function getStorage() {
     // Use environment variable if explicitly set, otherwise fall back to db config
     const envStorage = process.env.PRISM_STORAGE;
     const requestedBackend = (envStorage || await getSetting("PRISM_STORAGE", ENV_PRISM_STORAGE));
-    // Guardrail: if Supabase is requested but credentials are unresolved/invalid,
-    // transparently fall back to local mode to keep dashboard + core tools usable.
-    if (requestedBackend === "supabase" && !SUPABASE_CONFIGURED) {
+    // Guardrail: if Supabase is requested but env-var credentials are missing,
+    // check the dashboard config DB (prism-config.db) as a fallback before
+    // giving up. Dashboard settings take precedence over absent env vars.
+    let supabaseReady = SUPABASE_CONFIGURED;
+    if (!supabaseReady && requestedBackend === "supabase") {
+        const dashUrl = await getSetting("SUPABASE_URL");
+        const dashKey = await getSetting("SUPABASE_KEY");
+        if (dashUrl && dashKey) {
+            try {
+                const parsed = new URL(dashUrl);
+                if (parsed.protocol === "http:" || parsed.protocol === "https:") {
+                    supabaseReady = true;
+                    // Inject into process.env so downstream consumers (SupabaseStorage,
+                    // SyncBus) pick them up without needing their own dashboard lookups.
+                    process.env.SUPABASE_URL = dashUrl;
+                    process.env.SUPABASE_KEY = dashKey;
+                    debugLog("[Prism Storage] Using Supabase credentials from dashboard config");
+                }
+            }
+            catch {
+                // Invalid URL — fall through to local fallback
+            }
+        }
+    }
+    if (requestedBackend === "supabase" && !supabaseReady) {
         activeStorageBackend = "local";
         console.error("[Prism Storage] Supabase backend requested but SUPABASE_URL/SUPABASE_KEY are invalid or unresolved. Falling back to local storage.");
     }

package/dist/sync/factory.js

@@ -1,13 +1,6 @@
-/**
- * SyncBus Factory — Routes to the correct sync implementation (v2.0 — Step 6)
- *
- * Returns SqliteSyncBus for local mode, SupabaseSyncBus for cloud mode.
- * Uses the same PRISM_STORAGE env var as the storage factory.
- *
- * Singleton pattern — only one bus per process (prevents duplicate watchers).
- */
 import { PRISM_STORAGE } from "../config.js";
 import { debugLog } from "../utils/logger.js";
+import { getSetting } from "../storage/configStorage.js";
 let _bus = null;
 export async function getSyncBus() {
     if (_bus)
@@ -18,10 +11,11 @@ export async function getSyncBus() {
     }
     else {
         const { SupabaseSyncBus } = await import("./supabaseSync.js");
-        const url = process.env.SUPABASE_URL;
-        const key = process.env.SUPABASE_KEY || process.env.SUPABASE_ANON_KEY;
+        // Check env vars first, then fall back to dashboard config (prism-config.db)
+        const url = process.env.SUPABASE_URL || await getSetting("SUPABASE_URL");
+        const key = process.env.SUPABASE_KEY || process.env.SUPABASE_ANON_KEY || await getSetting("SUPABASE_KEY");
         if (!url || !key) {
-            console.error("[SyncBus] Supabase credentials not found — falling back to local sync bus");
+            debugLog("[SyncBus] Supabase credentials not found in env or dashboard — falling back to local sync bus");
             const { SqliteSyncBus } = await import("./sqliteSync.js");
             _bus = new SqliteSyncBus();
         }

package/dist/utils/supabaseApi.js

@@ -1,26 +1,30 @@
-import { SUPABASE_URL, SUPABASE_KEY } from "../config.js";
+// SUPABASE_URL / SUPABASE_KEY are read at call-time from process.env
+// (not import-time) so dashboard-injected credentials are picked up.
 /**
  * Makes a single authenticated HTTP request to the Supabase REST API.
  * All public functions below delegate to this.
  */
 async function supabaseRequest(opts) {
-    // Guard: ensure Supabase is configured before making any request
-    if (!SUPABASE_URL || !SUPABASE_KEY) {
+    // Read credentials at call time (not import time) so that dashboard-injected
+    // values in process.env are picked up after storage/index.ts resolves them.
+    const url = process.env.SUPABASE_URL;
+    const key = process.env.SUPABASE_KEY;
+    if (!url || !key) {
         throw new Error("Supabase not configured (SUPABASE_URL / SUPABASE_KEY missing)");
     }
     // Build the full URL with any query parameters
-    const url = new URL(`${SUPABASE_URL}${opts.path}`);
+    const reqUrl = new URL(`${url}${opts.path}`);
     if (opts.params) {
         for (const [k, v] of Object.entries(opts.params)) {
-            url.searchParams.set(k, v);
+            reqUrl.searchParams.set(k, v);
         }
     }
     // Make the HTTP request with authentication headers
-    const response = await fetch(url.toString(), {
+    const response = await fetch(reqUrl.toString(), {
         method: opts.method,
         headers: {
-            "apikey": SUPABASE_KEY, // Supabase API key (required for all requests)
-            "Authorization": `Bearer ${SUPABASE_KEY}`, // Also passed as Bearer token
+            "apikey": key, // Supabase API key (required for all requests)
+            "Authorization": `Bearer ${key}`, // Also passed as Bearer token
             "Content-Type": "application/json",
             // "Prefer" header controls response behavior:
             //   - "return=representation" means return the inserted/updated row in the response

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "9.1.0",
+  "version": "9.2.0",
   "mcpName": "io.github.dcostenco/prism-mcp",
   "description": "The Mind Palace for AI Agents — a true Cognitive Architecture with Hebbian learning (episodic→semantic consolidation), ACT-R spreading activation (multi-hop causal reasoning), uncertainty-aware rejection gates (agents that know when they don't know), adversarial evaluation (anti-sycophancy), fail-closed Dark Factory pipelines, persistent memory (SQLite/Supabase), multi-agent Hivemind, time travel & visual dashboard. Zero-config local mode.",
   "module": "index.ts",