getprismo 0.1.8 → 0.1.10

package/README.md

@@ -394,7 +394,7 @@ 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.
+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.
 
 what doctor never touches:
 

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

@@ -10,6 +10,7 @@ module.exports = function createContextOptimize(deps) {
     color,
     writeGeneratedFile,
   } = deps;
+  const { execFileSync } = require("child_process");
 
 function findRepoFiles(result, predicate, limit = 40) {
   return result.files
@@ -59,6 +60,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 +188,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.");
@@ -205,6 +219,7 @@ function createOptimizeContext(rootDir = process.cwd(), scope = null) {
     frontendDetected,
     backend,
     frontend,
+    gitActivity: getGitActivity(root),
     warnings,
     suggestions,
     estimatedContextReduction: scan.avoidableWaste,
@@ -217,20 +232,139 @@ function mdList(items, empty = "None detected.") {
   return items.map((item) => `- \`${item}\``).join("\n");
 }
 
-function topLoadBearing(root, files, allFiles, limit = 8) {
+function moduleNameForPath(rel) {
+  return rel
+    .replace(/\.[^.]+$/, "")
+    .replace(/\/__init__$/, "")
+    .replace(/\/index$/, "")
+    .replace(/\//g, ".");
+}
+
+function basenameStem(rel) {
+  return path.basename(rel).replace(/\.[^.]+$/, "");
+}
+
+function extractPythonImports(text) {
+  const imports = new Set();
+  const importRe = /^\s*import\s+([a-zA-Z0-9_.,\s]+)/gm;
+  const fromRe = /^\s*from\s+([a-zA-Z0-9_.]+)\s+import\s+/gm;
+  let match;
+  while ((match = importRe.exec(text))) {
+    match[1].split(",").map((part) => part.trim().split(/\s+as\s+/)[0]).filter(Boolean).forEach((name) => imports.add(name));
+  }
+  while ((match = fromRe.exec(text))) imports.add(match[1]);
+  return imports;
+}
+
+function resolveJsImport(fromRel, specifier, sourcePaths) {
+  if (!specifier.startsWith(".")) return null;
+  const fromDir = path.posix.dirname(fromRel);
+  const base = path.posix.normalize(path.posix.join(fromDir, specifier));
+  const candidates = [
+    base,
+    `${base}.ts`,
+    `${base}.tsx`,
+    `${base}.js`,
+    `${base}.jsx`,
+    `${base}/index.ts`,
+    `${base}/index.tsx`,
+    `${base}/index.js`,
+    `${base}/index.jsx`,
+  ];
+  return candidates.find((candidate) => sourcePaths.has(candidate)) || null;
+}
+
+function extractJsImports(fromRel, text, sourcePaths) {
+  const imports = new Set();
+  const importRe = /\bfrom\s+["']([^"']+)["']|import\s*\(\s*["']([^"']+)["']\s*\)|require\s*\(\s*["']([^"']+)["']\s*\)/g;
+  let match;
+  while ((match = importRe.exec(text))) {
+    const specifier = match[1] || match[2] || match[3];
+    const resolved = resolveJsImport(fromRel, specifier, sourcePaths);
+    if (resolved) imports.add(resolved);
+  }
+  return imports;
+}
+
+function getGitActivity(root) {
+  const activity = new Map();
+  try {
+    const output = execFileSync("git", ["-C", root, "log", "--since=180 days ago", "--name-only", "--format=%ct"], {
+      encoding: "utf8",
+      maxBuffer: 8 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    let currentTs = 0;
+    for (const rawLine of output.split(/\r?\n/)) {
+      const line = rawLine.trim();
+      if (!line) continue;
+      if (/^\d{9,}$/.test(line)) {
+        currentTs = Number(line);
+        continue;
+      }
+      const rel = line.replace(/\\/g, "/");
+      const previous = activity.get(rel) || { touches: 0, lastTouched: 0 };
+      previous.touches += 1;
+      previous.lastTouched = Math.max(previous.lastTouched, currentTs);
+      activity.set(rel, previous);
+    }
+  } catch {
+    return activity;
+  }
+  return activity;
+}
+
+function formatGitActivity(activity) {
+  if (!activity || !activity.touches) return "no recent git touches";
+  const date = activity.lastTouched ? new Date(activity.lastTouched * 1000).toISOString().slice(0, 10) : "unknown date";
+  return `${activity.touches} recent git touch${activity.touches === 1 ? "" : "es"}, last ${date}`;
+}
+
+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 corpus = textFiles.map((file) => `${file.path}\n${readIfText(path.join(root, 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"))) {
+    pythonModuleToPath.set(moduleNameForPath(file.path), file.path);
+    pythonModuleToPath.set(basenameStem(file.path), file.path);
+  }
+
+  const importRefs = new Map();
+  const textRefs = new Map();
+  const corpus = textFiles.map((file) => {
+    const text = readIfText(path.join(root, file.path), 512 * 1024) || "";
+    if (file.path.endsWith(".py")) {
+      for (const imported of extractPythonImports(text)) {
+        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)) {
+      for (const target of extractJsImports(file.path, text, sourcePaths)) {
+        if (target !== file.path) importRefs.set(target, (importRefs.get(target) || 0) + 1);
+      }
+    }
+    return `${file.path}\n${text}`;
+  });
+
+  for (const file of files || []) {
+    const base = basenameStem(file.path);
+    const importName = base.replace(/[-.]/g, "_");
+    const refs = corpus.reduce((sum, text) => sum + (text.includes(base) || text.includes(importName) ? 1 : 0), 0);
+    textRefs.set(file.path, refs);
+  }
+
   return [...(files || [])]
     .filter((file) => !file.ignored && file.kind !== "binary")
     .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 };
+      const imports = importRefs.get(file.path) || 0;
+      const refs = textRefs.get(file.path) || 0;
+      const git = gitActivity.get(file.path) || { touches: 0, lastTouched: 0 };
+      const score = imports * 1000 + refs * 25 + Math.min(git.touches, 20) * 10 + Math.log10(file.size + 1);
+      return { file, imports, refs, git, score };
     })
-    .sort((a, b) => b.refs - a.refs || b.file.size - a.file.size)
+    .sort((a, b) => b.score - a.score || b.file.size - a.file.size)
     .slice(0, limit)
-    .map(({ file, refs }) => `${file.path} (${refs} reference signal${refs === 1 ? "" : "s"}, ${formatBytes(file.size)})`);
+    .map(({ file, imports, refs, git }) => `${file.path} (${imports} import ref${imports === 1 ? "" : "s"}, ${refs} text reference signal${refs === 1 ? "" : "s"}, ${formatGitActivity(git)}, ${formatBytes(file.size)})`);
 }
 
 function inferGaps(ctx) {
@@ -342,7 +476,7 @@ function renderArchitectureSummary(ctx) {
 }
 
 function renderBackendSummary(ctx) {
-  const backendCandidates = topLoadBearing(ctx.root, ctx.scan.files.filter((file) => file.path.endsWith(".py") && !isNonSourcePath(file.path)), ctx.scan.files, 8);
+  const backendCandidates = topLoadBearing(ctx.root, ctx.scan.files.filter((file) => file.path.endsWith(".py") && !isNonSourcePath(file.path)), ctx.scan.files, ctx.gitActivity, 8);
   return [
     "# Backend Summary",
     "",
@@ -386,7 +520,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, 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, ctx.gitActivity, 8);
   return [
     "# Frontend Summary",
     "",

package/package.json

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