getprismo 0.1.10 → 0.1.11

package/README.md

@@ -41,6 +41,7 @@ after you code      npx getprismo cc timeline
 - missing `.claudeignore` / `.cursorignore` (the biggest single fix for most repos)
 - lockfiles entering context (`package-lock.json`, `yarn.lock`, `pnpm-lock.yaml`)
 - generated artifacts leaking in (`__pycache__`, `dist/`, `coverage/`, `.next/`)
+- operational source-stream dumps leaking in (`events/`, `source-streams/`, inbox/calendar/GitHub JSONL exports)
 - oversized instruction files (`CLAUDE.md` or `AGENTS.md` over 500 tokens)
 - tool output dominating sessions (repeated reads, large command output)
 - long-running sessions with stale context accumulation
@@ -396,6 +397,8 @@ if an existing `.claudeignore` or `.cursorignore` already covers prismo's recomm
 
 backend and frontend summaries include load-bearing candidates ranked by import references, text-reference signals, recent git touches when available, and file size, not just directory listings.
 
+prismo also flags source-stream dumps separately from normal build artifacts. large inbox/calendar/github/event payload files are treated as operational noise because they often get summarized once, written near the repo, and then accidentally re-read by later coding sessions.
+
 what doctor never touches:
 
 - your real `CLAUDE.md`
@@ -656,7 +659,7 @@ then your team can run `npm run ai:doctor` without remembering the full command.
 - openai codex
 - cursor
 - any tool that respects `.claudeignore` or `.cursorignore`
-- any repo (node, python, go, rust, monorepos, whatever)
+- any repo (node, python, go, rust, vue, svelte, astro, monorepos, whatever)
 
 ---
 

package/lib/prismo-dev/constants.js

@@ -84,6 +84,10 @@ const SOURCE_EXTENSIONS = new Set([
   ".html",
   ".vue",
   ".svelte",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
 ]);
 
 const INSTRUCTION_FILES = [
@@ -120,8 +124,15 @@ const DEFAULT_CLAUDEIGNORE = [
   "package-lock.json",
   "yarn.lock",
   "pnpm-lock.yaml",
+  "bun.lockb",
   "test-results/",
   "playwright-report/",
+  "events/",
+  "event-dumps/",
+  "session-dumps/",
+  "source-streams/",
+  "inbox-dumps/",
+  "calendar-dumps/",
   "models/",
   "state-backups/",
   "backups/",
@@ -158,6 +169,7 @@ const GENERATED_ARTIFACT_PATTERNS = [
   /(^|\/)coverage\//,
   /(^|\/)playwright-report\//,
   /(^|\/)test-results\//,
+  /(^|\/)(events|event-dumps|session-dumps|source-streams|inbox-dumps|calendar-dumps)\//,
   /(^|\/)__pycache__\//,
   /(^|\/)\.pytest_cache\//,
   /(^|\/)\.cache\//,

package/lib/prismo-dev/context-optimize.js

@@ -26,6 +26,11 @@ function detectFrameworks(root, result) {
     const deps = { ...(pkg && pkg.dependencies), ...(pkg && pkg.devDependencies) };
     if (deps.next) frameworks.add("Next.js");
     if (deps.react) frameworks.add("React");
+    if (deps.vue || deps["@vue/runtime-core"]) frameworks.add("Vue");
+    if (deps.svelte || deps["@sveltejs/kit"]) frameworks.add(deps["@sveltejs/kit"] ? "SvelteKit" : "Svelte");
+    if (deps["solid-js"]) frameworks.add("Solid");
+    if (deps.astro) frameworks.add("Astro");
+    if (deps.nuxt) frameworks.add("Nuxt");
     if (deps.express) frameworks.add("Express");
     if (deps["@nestjs/core"]) frameworks.add("NestJS");
     if (deps.prisma || deps["@prisma/client"]) frameworks.add("Prisma");
@@ -75,6 +80,11 @@ function detectFrameworks(root, result) {
   if ([...textFiles.keys()].some((rel) => rel.includes("prisma/schema.prisma"))) frameworks.add("Prisma");
   if ([...textFiles.keys()].some((rel) => rel.includes("next.config."))) frameworks.add("Next.js");
   if ([...textFiles.keys()].some((rel) => rel.includes("vite.config."))) frameworks.add("Vite");
+  if ([...textFiles.keys()].some((rel) => rel.includes("svelte.config."))) frameworks.add("SvelteKit");
+  if ([...textFiles.keys()].some((rel) => rel.includes("astro.config."))) frameworks.add("Astro");
+  if ([...textFiles.keys()].some((rel) => rel.includes("nuxt.config."))) frameworks.add("Nuxt");
+  if ([...textFiles.keys()].some((rel) => rel.endsWith(".vue"))) frameworks.add("Vue");
+  if ([...textFiles.keys()].some((rel) => rel.endsWith(".svelte"))) frameworks.add("Svelte");
   if ([...textFiles.keys()].some((rel) => rel.includes("tailwind.config."))) frameworks.add("Tailwind");
   if ([...textFiles.keys()].some((rel) => rel.endsWith("tsconfig.json"))) frameworks.add("TypeScript");
   if ([...textFiles.keys()].some((rel) => rel.includes("alembic/") || rel.endsWith("alembic.ini"))) frameworks.add("Alembic");
@@ -109,6 +119,11 @@ function detectEntrypoints(result) {
     "src/app/page.tsx",
     "src/main.tsx",
     "src/index.tsx",
+    "src/App.vue",
+    "src/App.svelte",
+    "src/routes/+page.svelte",
+    "src/pages/index.astro",
+    "app.vue",
     "server.js",
     "index.js",
     "docker/docker-compose.yml",
@@ -173,12 +188,18 @@ function detectBackendPaths(result) {
 }
 
 function detectFrontendPaths(result) {
+  const appSurface = /(^|\/)(frontend\/)?src\/(app|pages|routes)\//;
+  const appFile = /(^|\/)(frontend\/)?src\/(App|main|index)\.(jsx?|tsx?|vue|svelte)$/;
+  const componentFile = /(^|\/)(frontend\/)?src\/(components|ui|widgets)\//;
+  const apiFile = /(^|\/)(frontend\/)?src\/(lib|hooks|composables|stores|services|api)\/.*(api|client|query|fetch|request|finops)/;
+  const stylingFile = /tailwind\.config|globals\.css|app\.css|\.module\.css|\.scss$|(^|\/)(frontend\/)?src\/styles?\//;
+  const stateFile = /providers?\.(tsx?|jsx?)|react-query|use[A-Z].*\.(ts|tsx|js|jsx)|(^|\/)(stores?|state|pinia|zustand|redux)\//;
   return {
-    app: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (/frontend\/src\/app\//.test(rel) || /frontend\/src\/App\.[jt]sx?$/.test(rel) || /src\/App\.[jt]sx?$/.test(rel) || /src\/app\//.test(rel) || /apps\/[^/]+\/app\//.test(rel) || /apps\/[^/]+\/src\/app\//.test(rel)), 24).map((f) => f.path),
-    components: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (/frontend\/src\/components\//.test(rel) || /src\/components\//.test(rel) || /apps\/[^/]+\/.*components\//.test(rel) || /packages\/[^/]+\/.*components\//.test(rel)), 20).map((f) => f.path),
-    apiClient: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (/frontend\/src\/(lib|hooks)\/.*(api|client|query|finops)/.test(rel) || /src\/(lib|hooks)\/.*(api|client|query)/.test(rel)), 20).map((f) => f.path),
-    styling: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (/tailwind\.config|globals\.css|\.module\.css|frontend\/src\/app\/globals/.test(rel)), 20).map((f) => f.path),
-    state: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (/providers\.tsx|react-query|use[A-Z].*\.ts/.test(rel)), 20).map((f) => f.path),
+    app: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (appSurface.test(rel) || appFile.test(rel) || /(^|\/)app\.vue$/.test(rel) || /apps\/[^/]+\/(app|pages|routes|src\/app|src\/pages|src\/routes)\//.test(rel)), 24).map((f) => f.path),
+    components: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (componentFile.test(rel) || /apps\/[^/]+\/.*(components|ui|widgets)\//.test(rel) || /packages\/[^/]+\/.*(components|ui|widgets)\//.test(rel)), 24).map((f) => f.path),
+    apiClient: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (apiFile.test(rel) || /apps\/[^/]+\/.*(lib|hooks|composables|services|api)\/.*(api|client|query|fetch|request)/.test(rel)), 24).map((f) => f.path),
+    styling: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && stylingFile.test(rel), 24).map((f) => f.path),
+    state: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && stateFile.test(rel), 24).map((f) => f.path),
   };
 }
 
@@ -194,7 +215,7 @@ function createOptimizeContext(rootDir = process.cwd(), scope = null) {
     frameworks.some((name) => ["FastAPI", "Django", "Flask"].includes(name)) ||
     Boolean(backend.api.length || backend.services.length || backend.db.length || backend.auth.length);
   const frontendDetected = folders.includes("frontend") ||
-    frameworks.some((name) => ["Next.js", "React", "Vite"].includes(name)) ||
+    frameworks.some((name) => ["Next.js", "React", "Vite", "Vue", "Svelte", "SvelteKit", "Solid", "Astro", "Nuxt"].includes(name)) ||
     Boolean(frontend.app.length || frontend.components.length || frontend.apiClient.length || frontend.state.length);
   const warnings = [];
   if (scan.exposedLargeFiles.length) warnings.push(`${scan.exposedLargeFiles.length} exposed large file(s) may bloat AI context.`);
@@ -321,7 +342,7 @@ function formatGitActivity(activity) {
 }
 
 function topLoadBearing(root, files, allFiles, gitActivity, limit = 8) {
-  const textFiles = (allFiles || []).filter((file) => !file.ignored && file.kind !== "binary" && /\.(py|tsx?|jsx?)$/.test(file.path));
+  const textFiles = (allFiles || []).filter((file) => !file.ignored && file.kind !== "binary" && /\.(py|tsx?|jsx?|mjs|cjs|vue|svelte)$/.test(file.path));
   const sourcePaths = new Set(textFiles.map((file) => file.path));
   const pythonModuleToPath = new Map();
   for (const file of textFiles.filter((candidate) => candidate.path.endsWith(".py"))) {
@@ -338,7 +359,7 @@ function topLoadBearing(root, files, allFiles, gitActivity, limit = 8) {
         const target = pythonModuleToPath.get(imported) || pythonModuleToPath.get(imported.split(".").pop());
         if (target && target !== file.path) importRefs.set(target, (importRefs.get(target) || 0) + 1);
       }
-    } else if (/\.(tsx?|jsx?)$/.test(file.path)) {
+    } else if (/\.(tsx?|jsx?|mjs|cjs|vue|svelte)$/.test(file.path)) {
       for (const target of extractJsImports(file.path, text, sourcePaths)) {
         if (target !== file.path) importRefs.set(target, (importRefs.get(target) || 0) + 1);
       }
@@ -520,7 +541,7 @@ function renderBackendSummary(ctx) {
 }
 
 function renderFrontendSummary(ctx) {
-  const frontendCandidates = topLoadBearing(ctx.root, ctx.scan.files.filter((file) => /\.(tsx?|jsx?)$/.test(file.path) && /(^|\/)(frontend|src|app|components|hooks)\//.test(file.path)), ctx.scan.files, ctx.gitActivity, 8);
+  const frontendCandidates = topLoadBearing(ctx.root, ctx.scan.files.filter((file) => /\.(tsx?|jsx?|mjs|cjs|vue|svelte)$/.test(file.path) && /(^|\/)(frontend|src|app|pages|routes|components|ui|hooks|composables|stores)\//.test(file.path)), ctx.scan.files, ctx.gitActivity, 8);
   return [
     "# Frontend Summary",
     "",

package/lib/prismo-dev/firewall.js

@@ -78,7 +78,15 @@ function buildBlockedContext(ctx) {
     "playwright-report/**",
     "test-results/**",
     "logs/**",
+    "events/**",
+    "event-dumps/**",
+    "session-dumps/**",
+    "source-streams/**",
+    "inbox-dumps/**",
+    "calendar-dumps/**",
     "**/*.log",
+    "**/*.jsonl",
+    "**/*.ndjson",
     "**/*.map",
     "**/__pycache__/**",
     "package-lock.json",

package/lib/prismo-dev/report.js

@@ -68,6 +68,13 @@ function renderTerminalReport(result, options = {}) {
   if (result.toolOutputRisk.exposedNoisyDirectories.length) lines.push(`- Exposed noisy dirs: ${result.toolOutputRisk.exposedNoisyDirectories.slice(0, 6).join(", ")}`);
   if (result.toolOutputRisk.exposedNoisyFiles.length) lines.push(`- Exposed noisy files: ${result.toolOutputRisk.exposedNoisyFiles.slice(0, 4).map((file) => file.path).join(", ")}`);
   lines.push("");
+  if (result.operationalNoise && result.operationalNoise.level !== "Low") {
+    lines.push(color("Operational Noise Risk", "bold", useColor));
+    lines.push(`- Level: ${result.operationalNoise.level}`);
+    lines.push(`- ${result.operationalNoise.summary}`);
+    result.operationalNoise.files.slice(0, 4).forEach((file) => lines.push(`- ${file.path}: ${file.signals.join(", ")}`));
+    lines.push("");
+  }
   lines.push(color("Prismo Proxy Tracking", "bold", useColor));
   lines.push("- Exact API tracking: available when traffic uses the Prismo OpenAI/Anthropic base URL");
   lines.push(`- Codex API/base-url mode: ${result.proxyTrackingReadiness.codingAgentBaseUrlMode.codex}`);
@@ -233,6 +240,18 @@ function renderMarkdownReport(result) {
     });
   }
   lines.push("");
+  lines.push("## Operational Source-Stream Noise");
+  lines.push("");
+  if (result.operationalNoise && result.operationalNoise.files.length) {
+    lines.push(`- Level: ${result.operationalNoise.level}`);
+    lines.push(`- ${result.operationalNoise.summary}`);
+    result.operationalNoise.files.slice(0, 20).forEach((file) => {
+      lines.push(`- \`${file.path}\` - ${formatBytes(file.sizeBytes)} - ${file.signals.join(", ")} - ~${file.estimatedTokensIfRead.toLocaleString()} tokens if read`);
+    });
+  } else {
+    lines.push("- No obvious inbox/calendar/GitHub/source-stream dumps detected.");
+  }
+  lines.push("");
   lines.push("## Prismo Proxy Tracking Readiness");
   lines.push("");
   lines.push("- Exact API tracking: available when app/tool traffic uses the Prismo OpenAI/Anthropic base URL.");

package/lib/prismo-dev/scan.js

@@ -364,6 +364,57 @@ function detectToolOutputRisk({ exposedLargeFiles, exposedHighRiskDirs, highRisk
   };
 }
 
+function detectOperationalNoise(files) {
+  const candidates = files
+    .filter((file) => !file.ignored && file.size >= 16 * 1024 && file.kind !== "binary")
+    .filter((file) => /\.(json|jsonl|ndjson|log|md|txt)$/i.test(file.path) || /(events?|inbox|calendar|github|issues?|heartbeat|poll|source-stream|session-dump|activity|notifications?)/i.test(file.path))
+    .slice(0, 120);
+  const findings = [];
+
+  for (const file of candidates) {
+    const text = readIfText(file.fullPath, 512 * 1024) || "";
+    if (!text) continue;
+    const signals = [];
+    const timestampCount = (text.match(/\b20\d{2}-\d{2}-\d{2}[T ][0-2]\d:/g) || []).length;
+    const emailCount = (text.match(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi) || []).length;
+    const eventKeyCount = (text.match(/"(event|type|timestamp|created_at|updated_at|attendees|organizer|sender|subject|body|issue|pull_request|repository|payload)"\s*:/gi) || []).length;
+    const markdownEventCount = (text.match(/\b(calendar|inbox|email|github|issue|pull request|notification|attendee|heartbeat|poll(ed|ing)?)\b/gi) || []).length;
+    const repeatedObjectCount = (text.match(/^\s*\{.*\}\s*$/gm) || []).length;
+
+    if (timestampCount >= 12) signals.push(`${timestampCount} timestamps`);
+    if (emailCount >= 8) signals.push(`${emailCount} email-like strings`);
+    if (eventKeyCount >= 30) signals.push(`${eventKeyCount} event-shaped JSON keys`);
+    if (markdownEventCount >= 20) signals.push(`${markdownEventCount} operational keywords`);
+    if (repeatedObjectCount >= 15) signals.push(`${repeatedObjectCount} JSONL-style objects`);
+
+    if (signals.length >= 2 || eventKeyCount >= 60 || (timestampCount >= 20 && markdownEventCount >= 15)) {
+      findings.push({
+        path: file.path,
+        sizeBytes: file.size,
+        estimatedTokensIfRead: estimateTokens(file.size),
+        signals: signals.slice(0, 4),
+      });
+    }
+  }
+
+  const estimatedExposureTokens = findings.reduce((sum, item) => sum + item.estimatedTokensIfRead, 0);
+  let level = "Low";
+  if (findings.length >= 3 || estimatedExposureTokens >= 150000) level = "High";
+  else if (findings.length || estimatedExposureTokens >= 25000) level = "Medium";
+
+  return {
+    level,
+    files: findings.slice(0, 12),
+    estimatedExposureTokens,
+    summary:
+      level === "High"
+        ? "Operational source-stream dumps may be leaking inbox/calendar/GitHub-style noise back into coding context."
+        : level === "Medium"
+          ? "Possible operational source-stream dumps detected; these can become second-order context leaks."
+          : "No obvious operational source-stream dumps detected.",
+  };
+}
+
 function buildProxyTrackingReadiness({ codexConfig, claudeConfig, realUsage }) {
   return {
     exactApiTracking: {
@@ -578,7 +629,7 @@ function addIssue(issues, severity, category, title, description, recommendation
   });
 }
 
-function buildRecommendations({ hasClaudeIgnore, gitignorePatterns, exposedHighRiskDirs, largeFiles, instructionFiles, claudeConfig, toolOutputRisk, agentReadiness }) {
+function buildRecommendations({ hasClaudeIgnore, gitignorePatterns, exposedHighRiskDirs, largeFiles, instructionFiles, claudeConfig, toolOutputRisk, operationalNoise, agentReadiness }) {
   const recs = [];
   if (!hasClaudeIgnore) {
     recs.push("Create .claudeignore with generated/cache folders and large artifacts excluded.");
@@ -595,6 +646,9 @@ function buildRecommendations({ hasClaudeIgnore, gitignorePatterns, exposedHighR
   if (toolOutputRisk && toolOutputRisk.level !== "Low") {
     recs.push("Use command-output filtering or narrower shell commands for noisy tests, logs, diffs, and generated reports.");
   }
+  if (operationalNoise && operationalNoise.level !== "Low") {
+    recs.push("Keep inbox/calendar/GitHub polling dumps out of coding-agent context; summarize them outside the repo or add them to AI ignore files.");
+  }
   if (instructionFiles.some((file) => file.isClaude && file.tokens > 1500)) {
     recs.push("Review CLAUDE.md for content that could move to linked docs; keep persistent instructions focused on durable rules.");
   }
@@ -665,7 +719,7 @@ function calculateReductionPercent(beforeTokens, afterTokens) {
 
 function chooseRecommendedScope(ctx) {
   if (ctx.scope) return ctx.scope;
-  if (ctx.frameworks.some((name) => ["Next.js", "React", "Vite"].includes(name))) return "frontend";
+  if (ctx.frameworks.some((name) => ["Next.js", "React", "Vite", "Vue", "Svelte", "SvelteKit", "Solid", "Astro", "Nuxt"].includes(name))) return "frontend";
   if (ctx.frameworks.some((name) => ["FastAPI", "Django", "Flask", "Python"].includes(name))) return "backend";
   return null;
 }
@@ -720,6 +774,7 @@ function toJsonPayload(result) {
     agentReadiness: result.agentReadiness,
     optimizationStack: result.optimizationStack,
     toolOutputRisk: result.toolOutputRisk,
+    operationalNoise: result.operationalNoise,
     proxyTrackingReadiness: result.proxyTrackingReadiness,
     suggestedClaudeIgnore: result.recommendedClaudeIgnore,
     suggestedCursorIgnore: result.recommendedCursorIgnore,
@@ -1010,6 +1065,7 @@ function scanRepo(rootDir = process.cwd(), options = {}) {
   const optimizationStack = detectOptimizationStack(root, claudeConfig, codexConfig);
   const agentReadiness = detectAgentReadiness(root, claudeConfig, codexConfig, realUsage);
   const toolOutputRisk = detectToolOutputRisk({ exposedLargeFiles, exposedHighRiskDirs, highRiskDirs });
+  const operationalNoise = detectOperationalNoise(files);
   const proxyTrackingReadiness = buildProxyTrackingReadiness({ codexConfig, claudeConfig, realUsage });
 
   if (toolOutputRisk.level !== "Low") {
@@ -1026,6 +1082,20 @@ function scanRepo(rootDir = process.cwd(), options = {}) {
     );
   }
 
+  if (operationalNoise.level !== "Low") {
+    addIssue(
+      issues,
+      operationalNoise.level === "High" ? "high" : "medium",
+      "operational_noise",
+      `${operationalNoise.files.length} source-stream dump${operationalNoise.files.length === 1 ? "" : "s"} may leak into context`,
+      operationalNoise.files.slice(0, 5).map((file) => `${file.path} (${file.signals.join(", ")})`).join(", "),
+      "Do not feed raw inbox/calendar/GitHub/event dumps back into coding sessions; summarize externally or add them to .claudeignore/.cursorignore.",
+      operationalNoise.estimatedExposureTokens
+        ? `Likely avoidable token exposure: up to ~${operationalNoise.estimatedExposureTokens.toLocaleString()} tokens from operational noise files.`
+        : "Potential savings estimate: prevents source-stream dumps from becoming recurring context."
+    );
+  }
+
   if (optimizationStack.mcpServerTotal >= 8) {
     addIssue(
       issues,
@@ -1074,10 +1144,12 @@ function scanRepo(rootDir = process.cwd(), options = {}) {
   const largeFileSuggestions = exposedLargeFiles
     .filter((file) => file.size >= 1024 * 1024 || ["log", "json", "minified", "lock/generated"].includes(file.kind))
     .map((file) => file.path);
+  const operationalNoiseSuggestions = operationalNoise.files.map((file) => file.path);
   const recommendedClaudeIgnore = Array.from(new Set([
     ...DEFAULT_CLAUDEIGNORE,
     ...gitignorePatterns.filter((line) => !line.startsWith("!")),
     ...largeFileSuggestions,
+    ...operationalNoiseSuggestions,
   ]));
   const recommendedCursorIgnore = Array.from(new Set([
     ...recommendedClaudeIgnore,
@@ -1094,6 +1166,7 @@ function scanRepo(rootDir = process.cwd(), options = {}) {
     instructionFiles,
     claudeConfig,
     toolOutputRisk,
+    operationalNoise,
     agentReadiness,
   });
   buildRealUsageRecommendations(realUsage).forEach((rec) => recommendations.push(rec));
@@ -1109,6 +1182,7 @@ function scanRepo(rootDir = process.cwd(), options = {}) {
     agentReadiness,
     optimizationStack,
     toolOutputRisk,
+    operationalNoise,
     proxyTrackingReadiness,
     frameworks,
     files,

package/package.json

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