getprismo 0.1.7 → 0.1.9

package/README.md

@@ -392,6 +392,10 @@ what doctor creates:
 prismo-dev-report.md                       full diagnostic report
 ```
 
+if an existing `.claudeignore` or `.cursorignore` already covers prismo's recommendations, doctor skips the suggested ignore file instead of creating redundant noise. the default recommendations include common project state, local db, export, credential, and token patterns such as `*_state.json`, `*_tokens.json`, `*_export.json`, `*.sqlite`, `models/`, and `state-backups/`.
+
+backend and frontend summaries include load-bearing candidates ranked by lightweight reference signals plus file size, not just directory listings.
+
 what doctor never touches:
 
 - your real `CLAUDE.md`

package/lib/prismo-dev/constants.js

@@ -122,6 +122,19 @@ const DEFAULT_CLAUDEIGNORE = [
   "pnpm-lock.yaml",
   "test-results/",
   "playwright-report/",
+  "models/",
+  "state-backups/",
+  "backups/",
+  "*.sqlite",
+  "*.sqlite3",
+  "*.db",
+  "*_state.json",
+  "*_tokens.json",
+  "*_export.json",
+  "*secret*.json",
+  "*credential*.json",
+  ".env",
+  ".env.*",
 ];
 
 const NPX_COMMAND = "npx getprismo";

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

@@ -59,6 +59,15 @@ function detectFrameworks(root, result) {
   }
 
   if (pyprojectFiles.length && !frameworks.has("Python")) frameworks.add("Python");
+  const pythonFiles = [...textFiles.values()].filter((file) => file.path.endsWith(".py") && !isNonSourcePath(file.path)).slice(0, 80);
+  for (const file of pythonFiles) {
+    const text = readIfText(path.join(root, file.path), 128 * 1024) || "";
+    if (/FastAPI\s*\(|from\s+fastapi\s+import|APIRouter\s*\(/.test(text)) frameworks.add("FastAPI");
+    if (/from\s+django|import\s+django|DJANGO_SETTINGS_MODULE/.test(text)) frameworks.add("Django");
+    if (/Flask\s*\(|from\s+flask\s+import/.test(text)) frameworks.add("Flask");
+    if (/sqlalchemy|create_engine|SessionLocal/i.test(text)) frameworks.add("SQLAlchemy");
+  }
+  if (pythonFiles.length) frameworks.add("Python");
   if ([...textFiles.keys()].some((rel) => rel.endsWith("Cargo.toml"))) frameworks.add("Rust");
   if ([...textFiles.keys()].some((rel) => rel.endsWith("go.mod"))) frameworks.add("Go");
   if ([...textFiles.keys()].some((rel) => rel.endsWith("docker-compose.yml") || rel.endsWith("docker-compose.yaml"))) frameworks.add("Docker");
@@ -178,10 +187,14 @@ function createOptimizeContext(rootDir = process.cwd(), scope = null) {
   const frameworks = detectFrameworks(root, scan);
   const folders = topLevelDirectories(root);
   const entrypoints = detectEntrypoints(scan);
-  const backendDetected = folders.includes("backend") || frameworks.some((name) => ["FastAPI", "Django", "Flask"].includes(name));
-  const frontendDetected = folders.includes("frontend") || frameworks.some((name) => ["Next.js", "React", "Vite"].includes(name));
   const backend = detectBackendPaths(scan);
   const frontend = detectFrontendPaths(scan);
+  const backendDetected = folders.includes("backend") ||
+    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)) ||
+    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.`);
   if (!scan.hasClaudeIgnore) warnings.push(".claudeignore is missing.");
@@ -217,12 +230,20 @@ function mdList(items, empty = "None detected.") {
   return items.map((item) => `- \`${item}\``).join("\n");
 }
 
-function topBySize(files, limit = 8) {
+function topLoadBearing(root, files, allFiles, limit = 8) {
+  const textFiles = (allFiles || []).filter((file) => !file.ignored && file.kind !== "binary" && /\.(py|tsx?|jsx?)$/.test(file.path));
+  const corpus = textFiles.map((file) => `${file.path}\n${readIfText(path.join(root, file.path)) || ""}`);
   return [...(files || [])]
     .filter((file) => !file.ignored && file.kind !== "binary")
-    .sort((a, b) => b.size - a.size)
+    .map((file) => {
+      const base = path.basename(file.path).replace(/\.[^.]+$/, "");
+      const importName = base.replace(/[-.]/g, "_");
+      const refs = corpus.reduce((sum, text) => sum + (text.includes(base) || text.includes(importName) ? 1 : 0), 0);
+      return { file, refs };
+    })
+    .sort((a, b) => b.refs - a.refs || b.file.size - a.file.size)
     .slice(0, limit)
-    .map((file) => `${file.path} (${formatBytes(file.size)})`);
+    .map(({ file, refs }) => `${file.path} (${refs} reference signal${refs === 1 ? "" : "s"}, ${formatBytes(file.size)})`);
 }
 
 function inferGaps(ctx) {
@@ -334,7 +355,7 @@ function renderArchitectureSummary(ctx) {
 }
 
 function renderBackendSummary(ctx) {
-  const backendCandidates = topBySize(ctx.scan.files.filter((file) => file.path.endsWith(".py") && !isNonSourcePath(file.path)), 8);
+  const backendCandidates = topLoadBearing(ctx.root, ctx.scan.files.filter((file) => file.path.endsWith(".py") && !isNonSourcePath(file.path)), ctx.scan.files, 8);
   return [
     "# Backend Summary",
     "",
@@ -378,7 +399,7 @@ function renderBackendSummary(ctx) {
 }
 
 function renderFrontendSummary(ctx) {
-  const frontendCandidates = topBySize(ctx.scan.files.filter((file) => /\.(tsx?|jsx?)$/.test(file.path) && /(^|\/)(frontend|src|app|components|hooks)\//.test(file.path)), 8);
+  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, 8);
   return [
     "# Frontend Summary",
     "",

package/lib/prismo-dev/fixes.js

@@ -60,18 +60,24 @@ function applyFixes(result, options = {}) {
   if (!result.hasClaudeIgnore) {
     if (!options.dryRun) fs.writeFileSync(claudeIgnorePath, `${result.recommendedClaudeIgnore.join("\n")}\n`, "utf8");
     actions.push(`${dryRunPrefix} .claudeignore`);
+  } else if (result.missingClaudeIgnoreSuggestions && result.missingClaudeIgnoreSuggestions.length === 0) {
+    actions.push("Skipped .claudeignore.prismo-suggested because existing .claudeignore already covers Prismo recommendations");
   } else {
     const backupPath = options.dryRun ? null : backupIfExists(suggestedClaudeIgnorePath);
-    if (!options.dryRun) fs.writeFileSync(suggestedClaudeIgnorePath, `${result.recommendedClaudeIgnore.join("\n")}\n`, "utf8");
+    const suggestions = result.missingClaudeIgnoreSuggestions || result.recommendedClaudeIgnore;
+    if (!options.dryRun) fs.writeFileSync(suggestedClaudeIgnorePath, `${suggestions.join("\n")}\n`, "utf8");
     actions.push(`${dryRunPrefix} .claudeignore.prismo-suggested because .claudeignore already exists`);
     if (backupPath) actions.push(`Backed up existing .claudeignore.prismo-suggested to ${path.basename(backupPath)}`);
   }
   if (!result.hasCursorIgnore) {
     if (!options.dryRun) fs.writeFileSync(cursorIgnorePath, `${result.recommendedCursorIgnore.join("\n")}\n`, "utf8");
     actions.push(`${dryRunPrefix} .cursorignore`);
+  } else if (result.missingCursorIgnoreSuggestions && result.missingCursorIgnoreSuggestions.length === 0) {
+    actions.push("Skipped .cursorignore.prismo-suggested because existing .cursorignore already covers Prismo recommendations");
   } else {
     const backupPath = options.dryRun ? null : backupIfExists(suggestedCursorIgnorePath);
-    if (!options.dryRun) fs.writeFileSync(suggestedCursorIgnorePath, `${result.recommendedCursorIgnore.join("\n")}\n`, "utf8");
+    const suggestions = result.missingCursorIgnoreSuggestions || result.recommendedCursorIgnore;
+    if (!options.dryRun) fs.writeFileSync(suggestedCursorIgnorePath, `${suggestions.join("\n")}\n`, "utf8");
     actions.push(`${dryRunPrefix} .cursorignore.prismo-suggested because .cursorignore already exists`);
     if (backupPath) actions.push(`Backed up existing .cursorignore.prismo-suggested to ${path.basename(backupPath)}`);
   }

package/lib/prismo-dev/report.js

@@ -312,14 +312,22 @@ function renderMarkdownReport(result) {
   lines.push("");
   lines.push("## Recommended .claudeignore");
   lines.push("");
+  if (result.hasClaudeIgnore && result.missingClaudeIgnoreSuggestions && !result.missingClaudeIgnoreSuggestions.length) {
+    lines.push("Existing .claudeignore already covers Prismo recommendations.");
+    lines.push("");
+  }
   lines.push("```gitignore");
-  result.recommendedClaudeIgnore.forEach((line) => lines.push(line));
+  (result.hasClaudeIgnore && result.missingClaudeIgnoreSuggestions ? result.missingClaudeIgnoreSuggestions : result.recommendedClaudeIgnore).forEach((line) => lines.push(line));
   lines.push("```");
   lines.push("");
   lines.push("## Recommended .cursorignore");
   lines.push("");
+  if (result.hasCursorIgnore && result.missingCursorIgnoreSuggestions && !result.missingCursorIgnoreSuggestions.length) {
+    lines.push("Existing .cursorignore already covers Prismo recommendations.");
+    lines.push("");
+  }
   lines.push("```gitignore");
-  result.recommendedCursorIgnore.forEach((line) => lines.push(line));
+  (result.hasCursorIgnore && result.missingCursorIgnoreSuggestions ? result.missingCursorIgnoreSuggestions : result.recommendedCursorIgnore).forEach((line) => lines.push(line));
   lines.push("```");
   lines.push("");
   lines.push("## Recommended Next Steps");

package/lib/prismo-dev/scan.js

@@ -77,6 +77,26 @@ 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));
+}
+
 function getFileKind(filePath) {
   const ext = path.extname(filePath).toLowerCase();
   const name = path.basename(filePath).toLowerCase();
@@ -703,6 +723,8 @@ function toJsonPayload(result) {
     proxyTrackingReadiness: result.proxyTrackingReadiness,
     suggestedClaudeIgnore: result.recommendedClaudeIgnore,
     suggestedCursorIgnore: result.recommendedCursorIgnore,
+    missingClaudeIgnoreSuggestions: result.missingClaudeIgnoreSuggestions || [],
+    missingCursorIgnoreSuggestions: result.missingCursorIgnoreSuggestions || [],
     nextCommands: getNextCommands(result),
     generatedAt: result.generatedAt,
     scannedPath: result.root,
@@ -1062,6 +1084,8 @@ function scanRepo(rootDir = process.cwd(), options = {}) {
     ".prismo/",
     "prismo-optimized-CLAUDE.template.md",
   ]));
+  const missingClaudeIgnoreSuggestions = hasClaudeIgnore ? missingIgnoreSuggestions(recommendedClaudeIgnore, claudeIgnorePatterns) : recommendedClaudeIgnore;
+  const missingCursorIgnoreSuggestions = hasCursorIgnore ? missingIgnoreSuggestions(recommendedCursorIgnore, cursorIgnorePatterns) : recommendedCursorIgnore;
   const recommendations = buildRecommendations({
     hasClaudeIgnore,
     gitignorePatterns,
@@ -1103,6 +1127,8 @@ function scanRepo(rootDir = process.cwd(), options = {}) {
     repoDetected,
     recommendedClaudeIgnore,
     recommendedCursorIgnore,
+    missingClaudeIgnoreSuggestions,
+    missingCursorIgnoreSuggestions,
     topTokenLeaks: getTopTokenLeaks(issues),
     generatedAt: new Date().toISOString(),
   };

package/package.json

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