prism-mcp-server 9.1.1 → 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "9.1.1",
+  "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",