getprismo 0.1.53 → 0.1.54

package/lib/prismo-dev/help.js

@@ -475,9 +475,13 @@ Tools exposed:
   prismo_firewall
   prismo_cc_timeline
   prismo_cursor_sessions
+  prismo_should_shield   (agent-native: should I shield this command?)
+  prismo_loop_check      (agent-native: am I looping?)
+  prismo_context_guard   (agent-native: what repo am I in / what to avoid rereading?)
 
 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.
+  The agent-native tools answer single mid-session questions directly so Claude Code, Codex, and Cursor can call Prismo while they work, not just after.
 
   prismo mcp doctor validates the local MCP tool surface and prints a ready-to-use client config snippet.`,
   connect: `PrismoDev Connect

package/lib/prismo-dev/mcp.js

@@ -1,3 +1,40 @@
+const path = require("path");
+
+// Commands whose output reliably floods agent context and should run through
+// shield (full output to disk, compact summary to the model).
+const NOISY_COMMAND_PATTERNS = [
+  { re: /(^|\s)(jest|vitest|mocha|pytest|rspec|phpunit|ava|tap)(\s|$)|(\b(npm|yarn|pnpm|bun)\s+(run\s+)?test\b)|\b(go|cargo)\s+test\b/, why: "test runs emit large pass/fail output" },
+  { re: /(^|\s)(webpack|rollup|esbuild|vite|tsc)(\s|$)|\b(next|nuxt|astro)\s+build\b|\b(npm|yarn|pnpm|bun)\s+(run\s+)?build\b|\b(go|cargo)\s+build\b|(^|\s)make(\s|$)/, why: "builds emit long compiler/bundler output" },
+  { re: /\b(npm|pnpm|bun)\s+(install|ci|i)\b|\byarn(\s+install)?\b|\bpip\s+install\b|\bbundle\s+install\b/, why: "installs print large dependency trees" },
+  { re: /(^|\s)(eslint|ruff|flake8|mypy|pylint)(\s|$)|\b(npm|yarn|pnpm)\s+(run\s+)?lint\b|tsc\s+--noEmit/, why: "linters/type-checkers emit many diagnostics" },
+  { re: /\b(playwright|cypress|e2e)\b/, why: "e2e runs dump verbose logs" },
+  { re: /\bdocker\s+build\b|\bterraform\b|\bkubectl\s+logs\b|\bcoverage\b|--verbose\b/, why: "infra/coverage/verbose commands flood output" },
+];
+const QUICK_COMMAND_PATTERNS = [
+  /(^|\s)(git\s+(status|log|diff|branch|show)|ls|pwd|whoami|which|echo|cat|head|tail|wc|env|date|node\s+-v|--version)(\s|$)/,
+];
+
+function classifyCommandForShield(command, repeatedCommands = []) {
+  const cmd = String(command || "").trim();
+  if (!cmd) return { shouldShield: false, confidence: "low", reason: "No command provided." };
+  const normalized = cmd.replace(/\s+/g, " ");
+  const repeated = (repeatedCommands || []).some((item) => {
+    const value = String(item.value || "").replace(/\s+/g, " ");
+    return value && (normalized.includes(value) || value.includes(normalized)) && Number(item.count || 0) >= 3;
+  });
+  if (repeated) {
+    return { shouldShield: true, confidence: "high", reason: "This command has already repeated several times in recent sessions; shield it so each retry costs a summary, not full output." };
+  }
+  const noisy = NOISY_COMMAND_PATTERNS.find((entry) => entry.re.test(normalized));
+  if (noisy) {
+    return { shouldShield: true, confidence: "high", reason: `Shield recommended: ${noisy.why}.` };
+  }
+  if (QUICK_COMMAND_PATTERNS.some((re) => re.test(normalized))) {
+    return { shouldShield: false, confidence: "high", reason: "Quick, low-output command; shielding is unnecessary." };
+  }
+  return { shouldShield: false, confidence: "low", reason: "No known flooding pattern; shield only if you expect large output." };
+}
+
 function createTextResult(payload) {
   const text = typeof payload === "string" ? payload : JSON.stringify(payload, null, 2);
   return {
@@ -147,6 +184,20 @@ function createMcpTools(deps) {
       tool: { type: "string", enum: ["all", "codex", "claude", "cursor"], description: "Which local session logs to inspect." },
       limit: limitProperty,
     }),
+    // Agent-native, mid-loop decision tools: tight yes/no answers an agent can
+    // act on during a session, not analysis dumps.
+    makeTool("prismo_should_shield", "Decide whether a shell command should be run through Prismo shield (full output to disk, compact summary to context) before you run it. Call this before any command that might print a lot.", {
+      command: { type: "string", description: "The exact shell command you are about to run." },
+      path: pathProperty,
+    }, ["command"]),
+    makeTool("prismo_loop_check", "Check whether the current coding session is stuck in a loop (repeating the same command or failing repeatedly). Call this when you have retried something more than once.", {
+      path: pathProperty,
+      tool: { type: "string", enum: ["all", "codex", "claude", "cursor"], description: "Which local session logs to inspect." },
+    }),
+    makeTool("prismo_context_guard", "Get what repo you are in, which paths to avoid rereading, files you have already read repeatedly, and the compact context pack to start from. Call this at the start of a session or before broad exploration.", {
+      path: pathProperty,
+      scope: scopeProperty,
+    }),
   ];
 
   function resolveRoot(args) {
@@ -292,6 +343,75 @@ function createMcpTools(deps) {
       }));
     }
 
+    if (name === "prismo_should_shield") {
+      let repeatedCommands = [];
+      try {
+        const summary = getUsageSummary({ cwd: target, limit: 3, tool: "all" });
+        const latest = (summary.sessions || [])[0];
+        repeatedCommands = (latest && latest.repeatedCommands) || [];
+      } catch { /* command classification still works without session context */ }
+      const decision = classifyCommandForShield(args.command, repeatedCommands);
+      return createTextResult({
+        schemaVersion: 1,
+        command: args.command,
+        shouldShield: decision.shouldShield,
+        confidence: decision.confidence,
+        reason: decision.reason,
+        recommended: decision.shouldShield
+          ? `npx -y getprismo@latest shield -- ${String(args.command || "").trim()}`
+          : null,
+        note: "Shield stores full stdout/stderr locally and returns a compact summary, so the output never floods context.",
+      });
+    }
+
+    if (name === "prismo_loop_check") {
+      const summary = getUsageSummary({ cwd: target, limit: 3, tool: args.tool || "all" });
+      const latest = (summary.sessions || [])[0] || null;
+      const repeatedCommands = (latest && latest.repeatedCommands) || [];
+      const looping = Boolean(latest && latest.loopSuspicion) || repeatedCommands.some((c) => Number(c.count || 0) >= 4);
+      const topRepeat = repeatedCommands[0] || null;
+      return createTextResult({
+        schemaVersion: 1,
+        looping,
+        confidence: latest ? (latest.loopConfidence || (looping ? "medium" : "low")) : "low",
+        signals: {
+          repeatedCommands: repeatedCommands.slice(0, 5),
+          failureMentions: latest ? Number(latest.failureMentions || 0) : 0,
+          turns: latest ? Number(latest.turns || 0) : 0,
+        },
+        advice: looping
+          ? `You appear to be looping${topRepeat ? ` on \`${topRepeat.value}\` (${topRepeat.count}x)` : ""}. Stop retrying, change the approach, and capture the command once with \`npx -y getprismo@latest shield -- <command>\` instead of re-running it.`
+          : "No loop detected. Keep going.",
+      });
+    }
+
+    if (name === "prismo_context_guard") {
+      const scope = args.scope || null;
+      const scan = scanRepo(target, { includeUsage: true, usageLimit: 3 });
+      const ctx = createOptimizeContext(target, scope);
+      const usage = scan.realUsage && scan.realUsage.sessions ? scan.realUsage.sessions : [];
+      const repeatedlyRead = [];
+      for (const session of usage) {
+        for (const item of session.repeatedPathMentions || []) {
+          if (Number(item.count || 0) >= 4) repeatedlyRead.push({ path: item.value, reads: item.count });
+        }
+      }
+      const blocked = (scan.recommendedClaudeIgnore || []).slice(0, 24);
+      return createTextResult({
+        schemaVersion: 1,
+        repo: path.basename(path.resolve(target)),
+        avoidRereading: {
+          blockedContext: blocked,
+          alreadyReadRepeatedly: repeatedlyRead.slice(0, 12),
+        },
+        startFrom: {
+          contextFile: scope ? `.prismo/${scope}-summary.md` : ".prismo/architecture-summary.md",
+          starterPrompt: renderStarterPrompt(ctx, scope),
+        },
+        advice: "Read the start-from context pack first. Do not reread blocked paths or files you have already read several times; quote what you already saw instead.",
+      });
+    }
+
     throw new Error(`Unknown MCP tool: ${name}`);
   }
 
@@ -397,6 +517,9 @@ async function runMcpDoctor(deps) {
     "prismo_timeline",
     "prismo_replay",
     "prismo_boundaries",
+    "prismo_should_shield",
+    "prismo_loop_check",
+    "prismo_context_guard",
   ];
   const toolNames = tools.map((tool) => tool.name);
   const missingTools = requiredTools.filter((name) => !toolNames.includes(name));

package/package.json

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