getprismo 0.1.13 → 0.1.14

package/README.md

@@ -22,18 +22,21 @@ prismodev catches it before, during, and after.
 
 ## the loop
 
-prismodev is three commands that cover an entire coding session:
+prismodev covers the full AI coding session:
 
 ```
 before you code     npx getprismo doctor
 while you code      npx getprismo watch
+noisy commands      npx getprismo shield -- npm test
 after you code      npx getprismo cc timeline
+agent-native        npx getprismo mcp
 ```
 
 **doctor** diagnoses the repo, applies safe fixes, and shows the before/after score.
 **watch** monitors context pressure live and warns when things go wrong.
 **cc timeline** reconstructs what happened in the session so you learn from it.
 **shield** runs noisy commands without dumping full output back into the agent context.
+**mcp** exposes PrismoDev as local tools so compatible agents can scan, search shield output, and request scoped context directly.
 
 ---
 
@@ -532,6 +535,7 @@ no install needed. npx runs it directly.
 | `optimize` | generate `.prismo/` context packs |
 | `context` | print paste-ready prompt for agents |
 | `shield` | run noisy commands while keeping full output out of chat |
+| `mcp` | expose PrismoDev tools over local MCP stdio |
 | `setup` | detect tools, logs, proxy readiness |
 | `usage` | show raw session token usage |
 | `init` | add npm scripts and .prismo/README.md |
@@ -583,6 +587,53 @@ npx getprismo shield last
 npx getprismo shield search "auth failure"
 ```
 
+### mcp mode
+
+```bash
+npx getprismo mcp
+npx getprismo mcp /path/to/repo
+```
+
+`mcp` starts a local stdio MCP server for agent clients. It exposes:
+
+- `prismo_scan`
+- `prismo_doctor_dry_run`
+- `prismo_watch_snapshot`
+- `prismo_shield_run`
+- `prismo_shield_search`
+- `prismo_shield_last`
+- `prismo_context_pack`
+- `prismo_firewall`
+- `prismo_cc_timeline`
+
+This lets an MCP-compatible agent search prior shielded test/build output, request scoped context packs, or inspect token-waste signals without pasting giant logs into the conversation.
+
+Generic MCP client config:
+
+```json
+{
+  "mcpServers": {
+    "prismodev": {
+      "command": "npx",
+      "args": ["-y", "getprismo", "mcp", "/path/to/your/repo"]
+    }
+  }
+}
+```
+
+For local development from this repo:
+
+```json
+{
+  "mcpServers": {
+    "prismodev": {
+      "command": "node",
+      "args": ["/path/to/prismodev/bin/prismo.js", "mcp", "/path/to/your/repo"]
+    }
+  }
+}
+```
+
 ---
 
 ## cc modes
@@ -728,8 +779,10 @@ lib/prismo-dev/constants.js      shared defaults, pricing, patterns
 lib/prismo-dev/context-optimize.js  context packs, scoped prompts
 lib/prismo-dev/doctor.js         doctor/dev/init orchestration
 lib/prismo-dev/fixes.js          safe ignore/template generation
+lib/prismo-dev/mcp.js            local MCP server and Prismo tool bindings
 lib/prismo-dev/report.js         terminal, markdown, ci reports
 lib/prismo-dev/scan.js           repo scanning, scoring, readiness
+lib/prismo-dev/shield.js         local command shield and searchable output index
 lib/prismo-dev/usage-watch.js    local logs, watch, cost, timeline
 ```
 
@@ -739,8 +792,11 @@ lib/prismo-dev/usage-watch.js    local logs, watch, cost, timeline
 
 ```bash
 npx getprismo --help
+npx getprismo --version
 npx getprismo doctor --help
 npx getprismo watch --help
+npx getprismo shield --help
+npx getprismo mcp --help
 npx getprismo cc --help
 npx getprismo scan --help
 ```

package/lib/prismo-dev/mcp.js

@@ -0,0 +1,264 @@
+function createTextResult(payload) {
+  const text = typeof payload === "string" ? payload : JSON.stringify(payload, null, 2);
+  return {
+    content: [{ type: "text", text }],
+  };
+}
+
+function normalizeArgs(args) {
+  return args && typeof args === "object" ? args : {};
+}
+
+function makeTool(name, description, properties = {}, required = []) {
+  return {
+    name,
+    description,
+    inputSchema: {
+      type: "object",
+      properties,
+      required,
+      additionalProperties: false,
+    },
+  };
+}
+
+function createMcpTools(deps) {
+  const {
+    rootDir,
+    scanRepo,
+    toJsonPayload,
+    runDoctor,
+    toDoctorJsonPayload,
+    getUsageSummary,
+    getClaudeCodeCostSummary,
+    runOptimize,
+    createOptimizeContext,
+    renderStarterPrompt,
+    runFirewall,
+    runShield,
+    runShieldLast,
+    runShieldSearch,
+  } = deps;
+
+  const pathProperty = {
+    type: "string",
+    description: "Repository path. Defaults to the repo used when the MCP server started.",
+  };
+  const limitProperty = {
+    type: "number",
+    description: "Maximum number of recent sessions or runs to inspect.",
+  };
+  const scopeProperty = {
+    type: "string",
+    description: "Optional scope such as frontend, backend, auth, tests, billing, or routing.",
+  };
+
+  const tools = [
+    makeTool("prismo_scan", "Scan a repo for AI coding token/context waste.", {
+      path: pathProperty,
+      includeUsage: { type: "boolean", description: "Include local Claude/Codex usage logs when available." },
+      limit: limitProperty,
+    }),
+    makeTool("prismo_doctor_dry_run", "Preview PrismoDev doctor fixes and before/after payoff without writing files.", {
+      path: pathProperty,
+      scope: scopeProperty,
+      limit: limitProperty,
+    }),
+    makeTool("prismo_watch_snapshot", "Return a one-shot local session/context pressure snapshot.", {
+      path: pathProperty,
+      tool: { type: "string", enum: ["all", "codex", "claude"], description: "Which local session logs to inspect." },
+      limit: limitProperty,
+    }),
+    makeTool("prismo_shield_run", "Run a noisy command through Prismo shield and store full output locally.", {
+      path: pathProperty,
+      command: {
+        type: "array",
+        items: { type: "string" },
+        description: "Command argv array, for example [\"npm\", \"test\"].",
+      },
+    }, ["command"]),
+    makeTool("prismo_shield_search", "Search stored shield stdout/stderr without loading full logs into context.", {
+      path: pathProperty,
+      query: { type: "string", description: "Text to search for in stored shield output." },
+      limit: limitProperty,
+    }, ["query"]),
+    makeTool("prismo_shield_last", "List recent shielded command runs.", {
+      path: pathProperty,
+      limit: limitProperty,
+    }),
+    makeTool("prismo_context_pack", "Generate or preview a scoped Prismo context pack/starter prompt.", {
+      path: pathProperty,
+      scope: scopeProperty,
+      dryRun: { type: "boolean", description: "When true, do not write .prismo files." },
+    }),
+    makeTool("prismo_firewall", "Generate a scoped context firewall policy for a task.", {
+      path: pathProperty,
+      task: { type: "string", description: "Task description such as auth-bug or frontend-test-failure." },
+      scope: scopeProperty,
+      dryRun: { type: "boolean", description: "When true, preview allowed/blocked context without writing files." },
+    }),
+    makeTool("prismo_cc_timeline", "Return the latest Claude Code session timeline/postmortem data.", {
+      path: pathProperty,
+      limit: limitProperty,
+    }),
+  ];
+
+  function resolveRoot(args) {
+    return args.path || rootDir || process.cwd();
+  }
+
+  async function callTool(name, rawArgs) {
+    const args = normalizeArgs(rawArgs);
+    const target = resolveRoot(args);
+
+    if (name === "prismo_scan") {
+      return createTextResult(toJsonPayload(scanRepo(target, {
+        includeUsage: Boolean(args.includeUsage),
+        usageLimit: Number(args.limit) || 5,
+      })));
+    }
+
+    if (name === "prismo_doctor_dry_run") {
+      const result = runDoctor(target, {
+        dryRun: true,
+        scope: args.scope || null,
+        limit: Number(args.limit) || 3,
+      });
+      return createTextResult(toDoctorJsonPayload(result));
+    }
+
+    if (name === "prismo_watch_snapshot") {
+      const summary = getUsageSummary({
+        cwd: target,
+        limit: Number(args.limit) || 3,
+        usageTool: args.tool || "all",
+      });
+      return createTextResult(summary);
+    }
+
+    if (name === "prismo_shield_run") {
+      return createTextResult(runShield(target, args.command));
+    }
+
+    if (name === "prismo_shield_search") {
+      return createTextResult(runShieldSearch(target, args.query, { limit: Number(args.limit) || 5 }));
+    }
+
+    if (name === "prismo_shield_last") {
+      return createTextResult(runShieldLast(target, { limit: Number(args.limit) || 5 }));
+    }
+
+    if (name === "prismo_context_pack") {
+      const scope = args.scope || null;
+      const result = runOptimize(target, { scope, dryRun: args.dryRun !== false });
+      const context = createOptimizeContext(target, scope);
+      return createTextResult({
+        ...result,
+        starterPrompt: renderStarterPrompt(context, scope),
+      });
+    }
+
+    if (name === "prismo_firewall") {
+      return createTextResult(runFirewall(target, {
+        task: args.task || args.scope || "general",
+        scope: args.scope || null,
+        dryRun: args.dryRun !== false,
+      }));
+    }
+
+    if (name === "prismo_cc_timeline") {
+      return createTextResult(getClaudeCodeCostSummary({
+        cwd: target,
+        limit: Number(args.limit) || 1,
+        mode: "timeline",
+      }));
+    }
+
+    throw new Error(`Unknown MCP tool: ${name}`);
+  }
+
+  return { tools, callTool };
+}
+
+function runMcpServer(deps) {
+  const readline = require("readline");
+  const { packageVersion = "0.0.0" } = deps;
+  const { tools, callTool } = createMcpTools(deps);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false,
+  });
+
+  function send(message) {
+    process.stdout.write(`${JSON.stringify(message)}\n`);
+  }
+
+  async function handle(message) {
+    if (!message || !message.method) return;
+    if (!Object.prototype.hasOwnProperty.call(message, "id")) return;
+
+    try {
+      if (message.method === "initialize") {
+        send({
+          jsonrpc: "2.0",
+          id: message.id,
+          result: {
+            protocolVersion: "2024-11-05",
+            capabilities: { tools: {} },
+            serverInfo: { name: "prismodev", version: packageVersion },
+          },
+        });
+        return;
+      }
+
+      if (message.method === "tools/list") {
+        send({ jsonrpc: "2.0", id: message.id, result: { tools } });
+        return;
+      }
+
+      if (message.method === "tools/call") {
+        const params = normalizeArgs(message.params);
+        const result = await callTool(params.name, params.arguments);
+        send({ jsonrpc: "2.0", id: message.id, result });
+        return;
+      }
+
+      send({
+        jsonrpc: "2.0",
+        id: message.id,
+        error: { code: -32601, message: `Method not found: ${message.method}` },
+      });
+    } catch (error) {
+      send({
+        jsonrpc: "2.0",
+        id: message.id,
+        error: {
+          code: -32000,
+          message: error && error.message ? error.message : String(error),
+        },
+      });
+    }
+  }
+
+  rl.on("line", (line) => {
+    if (!line.trim()) return;
+    try {
+      handle(JSON.parse(line));
+    } catch (error) {
+      send({
+        jsonrpc: "2.0",
+        id: null,
+        error: {
+          code: -32700,
+          message: error && error.message ? error.message : String(error),
+        },
+      });
+    }
+  });
+}
+
+module.exports = {
+  createMcpTools,
+  runMcpServer,
+};

package/lib/prismo-dev-scan.js

@@ -3,6 +3,7 @@ const http = require("http");
 const https = require("https");
 const os = require("os");
 const path = require("path");
+const { version: PACKAGE_VERSION } = require("../package.json");
 
 const {
   HIGH_RISK_DIRS,
@@ -282,10 +283,13 @@ const {
   color,
 });
 
+const { runMcpServer } = require("./prismo-dev/mcp");
+
 function printHelp() {
   console.log(`Prismo CLI
 
 Usage:
+  prismo --version
   prismo dev [path]
   prismo init [--json] [--dry-run] [path]
   prismo doctor [--json] [--dry-run] [--apply-ignores-only] [--no-context-packs] [--limit N] [path]
@@ -293,6 +297,7 @@ Usage:
   prismo shield [--json] [path] -- <command ...>
   prismo shield last [--json] [--limit N] [path]
   prismo shield search <query> [--json] [--limit N] [path]
+  prismo mcp [path]
   prismo setup [--json] [--proxy-url URL] [path]
   prismo scan [--fix] [--ci] [--json] [--usage] [--simple] [--no-report] [path]
   prismo optimize [scope] [--json] [path]
@@ -308,6 +313,7 @@ Commands:
   doctor      Diagnose, safely optimize, re-scan, and show before/after payoff.
   firewall    Generate allowed/blocked context policy files for an AI coding task.
   shield      Run a noisy command, store full output locally, and return a compact summary.
+  mcp         Start a local MCP server exposing Prismo tools over stdio.
   scan        Run PrismoDev for Claude Code, Codex, Cursor, and AI coding workflows.
   optimize    Generate lightweight AI-readable project context files in .prismo/.
   context     Print a copy-pasteable compact context prompt for AI coding tools.
@@ -511,6 +517,28 @@ Examples:
 Output:
   Runs the command locally, stores full stdout/stderr under .prismo/shield/runs/, indexes output in SQLite FTS5 when available, and prints only a compact summary plus useful error lines.
   Search and last retrieve prior shield runs without re-feeding full output into agent context.`,
+    mcp: `Prismo MCP Server
+
+Usage:
+  prismo mcp [path]
+
+Examples:
+  prismo mcp
+  prismo mcp /path/to/repo
+
+Tools exposed:
+  prismo_scan
+  prismo_doctor_dry_run
+  prismo_watch_snapshot
+  prismo_shield_run
+  prismo_shield_search
+  prismo_shield_last
+  prismo_context_pack
+  prismo_firewall
+  prismo_cc_timeline
+
+Output:
+  Starts a local JSON-RPC MCP server over stdio. Use it from MCP-compatible clients so agents can scan context waste, search shielded command output, and request scoped context without loading huge logs into chat.`,
     ci: `Prismo CI
 
 Usage:
@@ -549,6 +577,10 @@ Good first command for people who want to see the value before scanning a repo.`
 
 async function runCli(argv) {
   const [command, ...rest] = argv;
+  if (command === "--version" || command === "-v" || command === "version") {
+    console.log(PACKAGE_VERSION);
+    return;
+  }
   if (!command || command === "--help" || command === "-h") {
     printHelp();
     return;
@@ -557,8 +589,8 @@ async function runCli(argv) {
     printCommandHelp(command);
     return;
   }
-  if (!["dev", "init", "doctor", "firewall", "shield", "setup", "scan", "optimize", "context", "cc", "usage", "watch", "demo"].includes(command)) {
-    throw new Error(`Unknown command: ${command}. Try: prismo doctor, prismo watch, prismo shield, prismo firewall, prismo init, prismo scan, prismo optimize, prismo context, prismo cc, or prismo usage`);
+  if (!["dev", "init", "doctor", "firewall", "shield", "mcp", "setup", "scan", "optimize", "context", "cc", "usage", "watch", "demo"].includes(command)) {
+    throw new Error(`Unknown command: ${command}. Try: prismo doctor, prismo watch, prismo shield, prismo mcp, prismo firewall, prismo init, prismo scan, prismo optimize, prismo context, prismo cc, or prismo usage`);
   }
 
   if (command === "demo") {
@@ -674,6 +706,28 @@ async function runCli(argv) {
     return;
   }
 
+  if (command === "mcp") {
+    const target = getPositionals(rest)[0] || process.cwd();
+    runMcpServer({
+      rootDir: path.resolve(target),
+      packageVersion: PACKAGE_VERSION,
+      scanRepo,
+      toJsonPayload,
+      runDoctor,
+      toDoctorJsonPayload,
+      getUsageSummary,
+      getClaudeCodeCostSummary,
+      runOptimize,
+      createOptimizeContext,
+      renderStarterPrompt,
+      runFirewall,
+      runShield,
+      runShieldLast,
+      runShieldSearch,
+    });
+    return;
+  }
+
   if (command === "setup") {
     const json = rest.includes("--json");
     const limitIndex = rest.indexOf("--limit");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getprismo",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Local AI coding workflow scanner for Codex, Claude Code, Cursor, and token-waste diagnostics.",
   "license": "MIT",
   "homepage": "https://github.com/shanirsh/prismodev#readme",