prism-mcp-server 9.1.1 → 9.2.1

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>
@@ -727,8 +778,9 @@ The Generator strips the `console.log`, resubmits, and the next `EVALUATE` retur
 
 ## 🆕 What's New
 
-> **Current release: v9.1.0 — Task Router v2 & Local Agent Hardening**
+> **Current release: v9.2.1 — CLI Full Feature Parity**
 
+- 💻 **v9.2.1 — CLI Full Feature Parity:** `prism load` text mode now delegates to the real `session_load_context` handler, giving CLI-only users the same enriched output as MCP clients: morning briefings, reality drift detection, SDM intuitive recall, visual memory index, role-scoped skill injection, behavioral warnings, importance scores, and agent identity. JSON mode now includes `agent_name` from dashboard settings. Session loader script PATH fix for Homebrew/nvm/volta environments.
 - 🚦 **v9.1.0 — Task Router v2:** File-type complexity signal for intelligent code-vs-config routing, 6-signal weighted heuristic engine, multi-step false-positive fix, expanded file extension classification. Local agent hardened with buffered streaming, system prompts, memory trimming, and stateful `/api/chat` API.
 - 🔒 **v9.0.5 — JWKS Auth Security Hardening:** JWT audience/issuer claim validation (`PRISM_JWT_AUDIENCE`, `PRISM_JWT_ISSUER`), structured error logging for JWT failures, typed `PrismAuthenticatedRequest` interface, 11 new JWKS unit tests, Smithery server card fix. Vendor-neutral — tested with Auth0, AgentLair ([llms.txt](https://agentlair.com/llms.txt)), Keycloak, and custom JWKS endpoints.
 - 🧠 **v9.0.0 — Autonomous Cognitive OS:** Token-Economic Reinforcement Learning (Surprisal Gate + Cognitive Budget), Affect-Tagged Memory (valence-scored retrieval), and Episodic→Semantic Consolidation. Your agents learn compression and develop intuition. → [Cognitive OS](#-autonomous-cognitive-os-v90)
@@ -791,6 +843,33 @@ 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).
+
+**Text mode** delegates to the real `session_load_context` handler — full feature parity with MCP clients, including morning briefings, reality drift detection, SDM intuitive recall, visual memory, role-scoped skills, behavioral warnings, and agent identity.
+
+**JSON mode** emits a structured envelope for programmatic consumption (scripts, CI/CD, session loaders).
+
+```bash
+# Load session context (full enrichments — same as MCP tool)
+prism load my-project                          # Human-readable, standard depth
+prism load my-project --level deep             # Full context with all enrichments
+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,115 @@ 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';
+import { sessionLoadContextHandler } from './tools/ledgerHandlers.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).
+//
+// TEXT MODE: Delegates to the real sessionLoadContextHandler for
+// full feature parity — morning briefing, reality drift detection,
+// SDM recall, visual memory, skill injection, behavioral warnings,
+// importance scores, recent validations. Any future MCP enrichments
+// automatically appear in CLI too.
+//
+// JSON MODE: Structured envelope for programmatic consumption
+// (session loader scripts, CI/CD pipelines, etc.).
+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);
+        }
+        if (jsonOutput) {
+            // ── JSON mode: structured output for programmatic consumption ──
+            const storage = await getStorage();
+            const effectiveRole = role || await getSetting('default_role', '') || undefined;
+            const agentName = await getSetting('agent_name', '') || undefined;
+            const data = await storage.loadContext(project, level, PRISM_USER_ID, effectiveRole);
+            if (!data) {
+                console.log(JSON.stringify({ error: `No session context found for project "${project}"` }));
+                await closeStorage();
+                process.exit(0);
+            }
+            const d = data;
+            const gitState = getCurrentGitState();
+            const output = {
+                agent_name: agentName || null,
+                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 {
+            // ── Text mode: full parity with MCP session_load_context ──
+            // Delegates to the real handler so all enrichments (morning briefing,
+            // reality drift, SDM recall, visual memory, skill injection,
+            // behavioral warnings, etc.) are included automatically.
+            const result = await sessionLoadContextHandler({ project, level, role });
+            // Surface handler-level errors (e.g. invalid args, storage failures)
+            if (result.isError) {
+                console.error(result.content[0]?.text || 'Unknown error loading context');
+                await closeStorage();
+                process.exit(1);
+            }
+            let output = '';
+            if (result.content?.[0]) {
+                output = result.content[0].text;
+            }
+            // Append git state (not included in the MCP handler output)
+            const gitState = getCurrentGitState();
+            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.1",
   "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",