getprismo 0.1.21 → 0.1.23

package/README.md

@@ -180,6 +180,33 @@ Recommended Stack
 
 This makes PrismoDev the measure-first layer: it tells you whether you need ignore cleanup, output sandboxing, code indexing, repo packing, instruction trimming, session splitting, or MCP/tool hygiene.
 
+For the short version:
+
+```bash
+npx getprismo scan --report-card
+```
+
+That prints the simplest decision:
+
+```text
+PrismoDev Report Card
+
+Biggest waste: Generated artifacts / ignore cleanup: High
+Start with: npx getprismo doctor --apply-suggestions --dry-run
+Then: npx getprismo shield -- <noisy command>
+Code index needed: not yet
+Round-trip risk: Low
+```
+
+To benchmark a noisy command:
+
+```bash
+npx getprismo benchmark -- npm test
+npx getprismo benchmark session
+```
+
+`benchmark -- <command>` measures raw command output tokens versus the compact shield summary. `benchmark session` summarizes recent local Claude/Codex sessions, including round-trip context signals like tool calls, repeated commands, repeated source reads, and MCP/tool surface.
+
 ---
 
 ## new: context shield
@@ -580,6 +607,8 @@ no install needed. npx runs it directly.
 | `cc timeline` | session reconstruction with events |
 | `scan --usage` | full repo scan with local usage data |
 | `scan --optimizer-fit` | recommend which token-optimization path fits your repo/session |
+| `scan --report-card` | shortest decision-layer summary |
+| `benchmark` | measure command-output reduction or recent session round-trip context |
 | `scan --simple` | plain-english summary |
 | `scan --fix` | create safe fix files |
 | `scan --ci` | fail CI when token-risk gates fail |
@@ -835,8 +864,11 @@ 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/scan-path-utils.js scan ignore/path helper logic
 lib/prismo-dev/shield.js         local command shield and searchable output index
+lib/prismo-dev/usage-log-utils.js local session log parsing helpers
 lib/prismo-dev/usage-watch.js    local logs, watch, cost, timeline
+lib/prismo-dev/utils.js          shared terminal/file/token helpers
 ```
 
 ---

package/lib/prismo-dev/benchmark.js

@@ -0,0 +1,122 @@
+module.exports = function createBenchmark(deps) {
+  const {
+    NPX_COMMAND,
+    estimateTokens,
+    formatTokenCount,
+    getUsageSummary,
+    runShield,
+    scanRepo,
+    color,
+  } = deps;
+
+function estimateSummaryTokens(shieldResult) {
+  const lines = shieldResult.output && Array.isArray(shieldResult.output.interestingLines)
+    ? shieldResult.output.interestingLines.join("\n")
+    : "";
+  return estimateTokens([
+    `Command: ${shieldResult.command}`,
+    `Exit: ${shieldResult.exitCode}`,
+    `Duration: ${shieldResult.durationMs}ms`,
+    lines,
+  ].join("\n"));
+}
+
+function runBenchmark(rootDir = process.cwd(), commandArgs = [], options = {}) {
+  if (options.sessionOnly || !commandArgs.length) {
+    const scan = scanRepo(rootDir, { includeUsage: true, usageLimit: options.limit || 5 });
+    const usage = getUsageSummary({ cwd: scan.root, limit: options.limit || 5, tool: "all" });
+    const fit = scan.optimizerFit;
+    return {
+      schemaVersion: 1,
+      mode: "session",
+      scannedPath: scan.root,
+      score: scan.score,
+      riskLevel: scan.risk,
+      sessions: usage.sessions.length,
+      tokens: usage.totals,
+      roundTripContext: fit.roundTripContext,
+      optimizerFit: fit.summary,
+      recommendedStack: fit.recommendedStack,
+      next: [`${NPX_COMMAND} scan --optimizer-fit`, `${NPX_COMMAND} watch --once`, `${NPX_COMMAND} cc timeline`],
+      generatedAt: new Date().toISOString(),
+    };
+  }
+
+  const shield = runShield(rootDir, commandArgs);
+  const rawTokens = shield.output.estimatedTokens || 0;
+  const summaryTokens = estimateSummaryTokens(shield);
+  const reductionPercent = rawTokens > 0 ? Math.max(0, Math.round(((rawTokens - summaryTokens) / rawTokens) * 100)) : 0;
+  return {
+    schemaVersion: 1,
+    mode: "command",
+    scannedPath: shield.cwd,
+    command: shield.command,
+    exitCode: shield.exitCode,
+    durationMs: shield.durationMs,
+    rawOutput: {
+      bytes: shield.output.totalBytes,
+      estimatedTokens: rawTokens,
+    },
+    shieldedSummary: {
+      estimatedTokens: summaryTokens,
+      interestingLines: shield.output.interestingLines,
+    },
+    estimatedTokenReductionPercent: reductionPercent,
+    stored: shield.stored,
+    next: [
+      "Give the shield summary to the agent first.",
+      `${NPX_COMMAND} shield search "<error text>"`,
+      `${NPX_COMMAND} scan --optimizer-fit`,
+    ],
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+function renderBenchmarkTerminal(result) {
+  const lines = [];
+  lines.push("");
+  lines.push(color("Prismo Benchmark", "bold"));
+  lines.push("");
+  if (result.mode === "session") {
+    lines.push(`Mode: session`);
+    lines.push(`Score: ${result.score}/100 (${result.riskLevel} risk)`);
+    lines.push(`Sessions: ${result.sessions}`);
+    lines.push(`Tokens: ${formatTokenCount(result.tokens.displayTokens || 0)} (${result.tokens.exactTokens ? "exact-local-log" : "estimated/local"})`);
+    lines.push(`Optimizer fit: ${result.optimizerFit}`);
+    lines.push("");
+    lines.push("Round-Trip Context:");
+    lines.push(`- Level: ${result.roundTripContext.level}`);
+    lines.push(`- Tool calls: ${result.roundTripContext.toolCalls}`);
+    lines.push(`- Repeated commands: ${result.roundTripContext.repeatedCommandMentions}`);
+    lines.push(`- Repeated source reads: ${result.roundTripContext.repeatedSourceReads}`);
+    lines.push("");
+    lines.push("Next:");
+    result.next.forEach((item, index) => lines.push(`${index + 1}. ${item}`));
+    return lines.join("\n");
+  }
+
+  lines.push(`Mode: command`);
+  lines.push(`Command: ${result.command}`);
+  lines.push(`Exit: ${result.exitCode}`);
+  lines.push(`Duration: ${result.durationMs}ms`);
+  lines.push(`Raw output: ${result.rawOutput.bytes.toLocaleString()} bytes (~${result.rawOutput.estimatedTokens.toLocaleString()} tokens)`);
+  lines.push(`Shield summary: ~${result.shieldedSummary.estimatedTokens.toLocaleString()} tokens`);
+  lines.push(`Estimated reduction: ${result.estimatedTokenReductionPercent}%`);
+  lines.push("");
+  lines.push("Stored Output:");
+  lines.push(`- ${result.stored.stdout}`);
+  lines.push(`- ${result.stored.stderr}`);
+  lines.push("");
+  lines.push("Useful Lines:");
+  result.shieldedSummary.interestingLines.slice(0, 12).forEach((line) => lines.push(`- ${line}`));
+  lines.push("");
+  lines.push("Next:");
+  result.next.forEach((item, index) => lines.push(`${index + 1}. ${item}`));
+  return lines.join("\n");
+}
+
+  return {
+    renderBenchmarkTerminal,
+    runBenchmark,
+  };
+};

package/lib/prismo-dev/report.js

@@ -141,11 +141,47 @@ function renderOptimizerFitTerminal(result, options = {}) {
     lines.push(`  ${item.reason}`);
   });
   lines.push("");
+  lines.push(color("Round-Trip Context", "bold", useColor));
+  lines.push(`- Level: ${fit.roundTripContext.level}`);
+  lines.push(`- Tool calls: ${fit.roundTripContext.toolCalls}`);
+  lines.push(`- Repeated command mentions: ${fit.roundTripContext.repeatedCommandMentions}`);
+  lines.push(`- Repeated source reads: ${fit.roundTripContext.repeatedSourceReads}`);
+  lines.push(`- MCP/tool servers: ${fit.roundTripContext.mcpServers}`);
+  lines.push(`- ${fit.roundTripContext.recommendation}`);
+  lines.push("");
   lines.push("Notes:");
   fit.caveats.forEach((caveat) => lines.push(`- ${caveat}`));
   return lines.join("\n");
 }
 
+function renderReportCardTerminal(result, options = {}) {
+  const useColor = options.color !== false;
+  const fit = result.optimizerFit;
+  const top = fit.recommendedStack[0];
+  const second = fit.recommendedStack[1];
+  const lines = [];
+  lines.push("");
+  lines.push(color("PrismoDev Report Card", "bold", useColor));
+  lines.push("");
+  lines.push(`Score: ${result.score}/100 (${result.risk} risk)`);
+  lines.push(`Biggest waste: ${fit.summary}`);
+  lines.push("");
+  if (top) lines.push(`Start with: ${top.command}`);
+  if (second) lines.push(`Then: ${second.command}`);
+  lines.push("");
+  const codeIndex = fit.bottlenecks.find((item) => item.id === "code-indexing");
+  const output = fit.bottlenecks.find((item) => item.id === "output-sandboxing");
+  const ignore = fit.bottlenecks.find((item) => item.id === "ignore-cleanup");
+  lines.push(`Code index needed: ${codeIndex && codeIndex.level === "High" ? "yes" : codeIndex && codeIndex.level === "Medium" ? "maybe" : "not yet"}`);
+  lines.push(`Output sandbox needed: ${output && output.level !== "Low" ? "yes" : "not yet"}`);
+  lines.push(`Ignore cleanup needed: ${ignore && ignore.level !== "Low" ? "yes" : "not urgent"}`);
+  lines.push(`Round-trip risk: ${fit.roundTripContext.level}`);
+  lines.push("");
+  lines.push("Why:");
+  fit.bottlenecks.slice(0, 3).forEach((item) => lines.push(`- ${item.label}: ${item.evidence[0]}`));
+  return lines.join("\n");
+}
+
 function evaluateCi(result, options = {}) {
   const minScore = Number(options.minScore || 80);
   const failures = [];
@@ -434,6 +470,7 @@ function writeReport(result) {
     renderCiReport,
     renderMarkdownReport,
     renderOptimizerFitTerminal,
+    renderReportCardTerminal,
     renderSimpleScanReport,
     renderTerminalReport,
     writeReport,

package/lib/prismo-dev/scan-path-utils.js

@@ -0,0 +1,203 @@
+module.exports = function createScanPathUtils(deps) {
+  const { fs, path } = deps;
+
+  function normalizeRel(value) {
+    return value.split(path.sep).join("/");
+  }
+
+  function readIgnoreFile(root, fileName) {
+    const filePath = path.join(root, fileName);
+    if (!fs.existsSync(filePath)) return [];
+    const text = fs.readFileSync(filePath, "utf8");
+    return text
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter((line) => line && !line.startsWith("#"))
+      .map((line) => line.replace(/^!/, ""));
+  }
+
+  function patternMatches(pattern, relPath, isDir = false) {
+    const normalizedPattern = pattern.replace(/\\/g, "/").replace(/^\//, "");
+    const normalizedRel = normalizeRel(relPath);
+    const dirRel = isDir && !normalizedRel.endsWith("/") ? `${normalizedRel}/` : normalizedRel;
+
+    if (!normalizedPattern) return false;
+    if (normalizedPattern.endsWith("/")) {
+      const base = normalizedPattern.slice(0, -1);
+      return (
+        normalizedRel === base ||
+        normalizedRel.startsWith(`${base}/`) ||
+        normalizedRel.endsWith(`/${base}`) ||
+        normalizedRel.includes(`/${base}/`) ||
+        dirRel.includes(`/${base}/`)
+      );
+    }
+    if (normalizedPattern.startsWith("*.")) {
+      return normalizedRel.endsWith(normalizedPattern.slice(1));
+    }
+    if (normalizedPattern.includes("*")) {
+      const escaped = normalizedPattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+      return new RegExp(`(^|/)${escaped}$`).test(normalizedRel);
+    }
+    return (
+      normalizedRel === normalizedPattern ||
+      dirRel === normalizedPattern ||
+      normalizedRel.startsWith(`${normalizedPattern}/`) ||
+      normalizedRel.endsWith(`/${normalizedPattern}`)
+    );
+  }
+
+  function isIgnored(relPath, patterns, isDir = false) {
+    return patterns.some((pattern) => patternMatches(pattern, relPath, isDir));
+  }
+
+  function ignoreSuggestionCovered(pattern, existingPatterns) {
+    if (!pattern) return true;
+    if (existingPatterns.includes(pattern)) return true;
+    const sample = pattern
+      .replace(/^\*\//, "")
+      .replace(/^\*\*/, "sample")
+      .replace(/\*/g, "sample")
+      .replace(/\/$/, "");
+    const isDir = pattern.endsWith("/") || pattern.endsWith("/**");
+    return existingPatterns.some((existing) => {
+      if (existing === pattern) return true;
+      if (existing.endsWith("/") && pattern.startsWith(existing)) return true;
+      return patternMatches(existing, sample, isDir);
+    });
+  }
+
+  function missingIgnoreSuggestions(recommended, existingPatterns) {
+    return recommended.filter((pattern) => !ignoreSuggestionCovered(pattern, existingPatterns));
+  }
+
+  const SESSION_NOISE_DIRS = new Set([
+    ".next",
+    ".nuxt",
+    ".prismo",
+    ".pytest_cache",
+    ".turbo",
+    "__pycache__",
+    "build",
+    "calendar-dumps",
+    "coverage",
+    "dist",
+    "event-dumps",
+    "events",
+    "exports",
+    "htmlcov",
+    "inbox-dumps",
+    "logs",
+    "models",
+    "node_modules",
+    "out",
+    "playwright-report",
+    "session-dumps",
+    "source-streams",
+    "state-backups",
+    "test-results",
+    "tmp",
+    "temp",
+  ]);
+
+  const SESSION_NOISE_FILE_NAMES = new Set([
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "yarn.lock",
+    "bun.lockb",
+    "coverage-final.json",
+    "lcov.info",
+  ]);
+
+  const SESSION_NOISE_EXTENSIONS = new Set([
+    ".db",
+    ".jsonl",
+    ".lock",
+    ".log",
+    ".sqlite",
+    ".sqlite3",
+  ]);
+
+  function cleanSessionPath(value) {
+    const text = String(value || "").trim().replace(/\\/g, "/");
+    if (!text || /^https?:\/\//.test(text)) return null;
+    const withoutQuotes = text.replace(/^["'`]+|["'`.,:;)\]]+$/g, "");
+    if (!withoutQuotes || withoutQuotes.includes("\n")) return null;
+    const markerIndex = withoutQuotes.indexOf("/Users/");
+    if (markerIndex > 0) return withoutQuotes.slice(markerIndex);
+    return withoutQuotes;
+  }
+
+  function sessionIgnorePatternForPath(value, root) {
+    const cleaned = cleanSessionPath(value);
+    if (!cleaned) return null;
+    const rootNormalized = normalizeRel(root);
+    let rel = cleaned;
+    if (path.isAbsolute(cleaned)) {
+      const normalized = normalizeRel(cleaned);
+      if (!normalized.startsWith(`${rootNormalized}/`)) return null;
+      rel = normalizeRel(path.relative(root, cleaned));
+    }
+    rel = normalizeRel(rel).replace(/^\.\//, "");
+    if (!rel || rel === "." || rel.startsWith("../") || rel.includes("..")) return null;
+
+    const segments = rel.split("/").filter(Boolean);
+    if (!segments.length) return null;
+    for (let index = 0; index < segments.length; index += 1) {
+      const segment = segments[index];
+      if (SESSION_NOISE_DIRS.has(segment)) {
+        return `${segments.slice(0, index + 1).join("/")}/`;
+      }
+    }
+
+    const fileName = segments[segments.length - 1];
+    const lowerName = fileName.toLowerCase();
+    const ext = path.extname(lowerName);
+    if (SESSION_NOISE_FILE_NAMES.has(lowerName)) return fileName;
+    if (SESSION_NOISE_EXTENSIONS.has(ext)) return rel;
+    if (/_state\.json$/i.test(fileName)) return "*_state.json";
+    if (/_tokens\.json$/i.test(fileName)) return "*_tokens.json";
+    if (/_export\.json$/i.test(fileName)) return "*_export.json";
+    if (/secret|credential|token/i.test(fileName) && /\.json$/i.test(fileName)) return rel;
+    return null;
+  }
+
+  function buildSessionIgnoreSuggestions(realUsage, root) {
+    if (!realUsage || !Array.isArray(realUsage.sessions)) return [];
+    const byPattern = new Map();
+    const add = (pattern, item, source, reason) => {
+      if (!pattern) return;
+      const existing = byPattern.get(pattern) || {
+        pattern,
+        source,
+        reason,
+        count: 0,
+        examples: [],
+      };
+      existing.count += Number(item?.count || 1);
+      const example = item?.value || item?.path || pattern;
+      if (example && !existing.examples.includes(example) && existing.examples.length < 3) existing.examples.push(example);
+      byPattern.set(pattern, existing);
+    };
+
+    for (const session of realUsage.sessions) {
+      for (const item of session.generatedArtifacts || []) {
+        add(sessionIgnorePatternForPath(item.value, root), item, session.tool || "session", "Generated artifact entered local session context.");
+      }
+      for (const item of session.repeatedPathMentions || []) {
+        add(sessionIgnorePatternForPath(item.value, root), item, session.tool || "session", "Noisy path appeared repeatedly in local session context.");
+      }
+    }
+    return Array.from(byPattern.values())
+      .sort((a, b) => b.count - a.count || a.pattern.localeCompare(b.pattern))
+      .slice(0, 25);
+  }
+
+  return {
+    buildSessionIgnoreSuggestions,
+    isIgnored,
+    missingIgnoreSuggestions,
+    normalizeRel,
+    readIgnoreFile,
+  };
+};