getprismo 0.1.23 → 0.1.25

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

@@ -10,198 +10,19 @@ module.exports = function createContextOptimize(deps) {
     color,
     writeGeneratedFile,
   } = deps;
-  const { execFileSync } = require("child_process");
 
-function findRepoFiles(result, predicate, limit = 40) {
-  return result.files
-    ? result.files.filter((file) => !file.ignored && file.kind !== "binary" && predicate(file.path, file)).slice(0, limit)
-    : [];
-}
-
-function detectFrameworks(root, result) {
-  const frameworks = new Set();
-  const packageFiles = findRepoFiles(result, (rel) => path.basename(rel) === "package.json" && !rel.includes("node_modules/"), 12);
-  for (const file of packageFiles) {
-    const pkg = safeReadJson(path.join(root, file.path));
-    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");
-    if (deps.tailwindcss) frameworks.add("Tailwind");
-    if (deps.typescript) frameworks.add("TypeScript");
-    if (pkg) frameworks.add("Node.js");
-  }
-
-  const textFiles = new Map(result.files.map((file) => [file.path, file]));
-  const requirements = [...textFiles.keys()].filter((rel) => rel.endsWith("requirements.txt"));
-  for (const rel of requirements) {
-    const text = readIfText(path.join(root, rel)) || "";
-    if (/fastapi/i.test(text)) frameworks.add("FastAPI");
-    if (/django/i.test(text)) frameworks.add("Django");
-    if (/flask/i.test(text)) frameworks.add("Flask");
-    if (/psycopg2|asyncpg|sqlalchemy/i.test(text)) frameworks.add("PostgreSQL");
-    if (/redis/i.test(text)) frameworks.add("Redis");
-    frameworks.add("Python");
-  }
-
-  const pyprojectFiles = [...textFiles.keys()].filter((rel) => rel.endsWith("pyproject.toml") && !rel.includes("node_modules/"));
-  for (const rel of pyprojectFiles) {
-    const text = readIfText(path.join(root, rel)) || "";
-    if (/fastapi/i.test(text)) frameworks.add("FastAPI");
-    if (/django/i.test(text)) frameworks.add("Django");
-    if (/flask/i.test(text)) frameworks.add("Flask");
-    if (/sqlalchemy/i.test(text)) frameworks.add("SQLAlchemy");
-    if (/psycopg|asyncpg/i.test(text)) frameworks.add("PostgreSQL");
-    if (/redis/i.test(text)) frameworks.add("Redis");
-    if (/celery/i.test(text)) frameworks.add("Celery");
-    frameworks.add("Python");
-  }
-
-  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");
-  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");
-  if ([...textFiles.keys()].some((rel) => /postgres|postgresql/i.test(rel))) frameworks.add("PostgreSQL");
-  return Array.from(frameworks).sort();
-}
-
-function topLevelDirectories(root) {
-  try {
-    return fs.readdirSync(root, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules")
-      .map((entry) => entry.name)
-      .sort();
-  } catch {
-    return [];
-  }
-}
-
-function hasPath(result, matcher) {
-  return result.files.some((file) => matcher(file.path));
-}
-
-function detectEntrypoints(result) {
-  const candidates = [
-    "backend/app/main.py",
-    "backend/main.py",
-    "app/main.py",
-    "main.py",
-    "manage.py",
-    "frontend/src/app/page.tsx",
-    "frontend/src/app/layout.tsx",
-    "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",
-    "docker-compose.yml",
-  ];
-  const paths = new Set(result.files.map((file) => file.path));
-  const found = candidates.filter((candidate) => paths.has(candidate));
-  if (!found.length) {
-    const pyMain = result.files.find((f) => /^[^/]+\/__main__\.py$/.test(f.path));
-    if (pyMain) found.push(pyMain.path);
-    const pyInit = result.files.find((f) => /^[^/]+\/__init__\.py$/.test(f.path) && !f.path.includes("test"));
-    if (pyInit && !found.length) found.push(pyInit.path);
-  }
-  return found;
-}
-
-function isNonSourcePath(rel) {
-  if (/\.(test|spec|e2e)\.[jt]sx?$/.test(rel)) return true;
-  return /^(docs|docs_src|examples|samples|tutorials|tests|test|spec|__tests__|fixtures)\//i.test(rel) ||
-    /\/(docs|docs_src|examples|samples|tutorials|tests|test|__tests__|fixtures)\//.test(rel);
-}
-
-function detectBackendPaths(result) {
-  const pythonText = (file) => readIfText(path.join(result.root, file.path), 256 * 1024) || "";
-  const isRootPython = (rel) => /^[^/]+\.py$/.test(rel);
-  const isPython = (rel) => rel.endsWith(".py");
-  const hasFastApiSignal = (file) => /FastAPI\s*\(|APIRouter\s*\(|@app\.(get|post|put|patch|delete)|@router\.(get|post|put|patch|delete)/.test(pythonText(file));
-  const api = findRepoFiles(result, (rel, file) => !isNonSourcePath(rel) && (
-    /(backend|app|src)\/.*(router|routes|api)\//.test(rel) ||
-    /(backend|app|src)\/.*(router|routes).*\.py$/.test(rel) ||
-    /\/(routing|routers?)\.py$/.test(rel) ||
-    (isRootPython(rel) && hasFastApiSignal(file))
-  ), 30).map((f) => f.path);
-  const services = findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (
-    /(backend|app|src)\/.*(service|services|application)/.test(rel) ||
-    /\/applications?\.py$/.test(rel) ||
-    (isRootPython(rel) && /(service|worker|manager|client|heartbeat|memory|chat|tool|orchestrator|pipeline)/i.test(rel))
-  ), 40).map((f) => f.path);
-  const models = findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (
-    /(backend|app|src)\/.*models\.py$/.test(rel) ||
-    /(backend|app|src)\/.*schema/.test(rel) ||
-    /\/models\.py$/.test(rel) ||
-    (isRootPython(rel) && /(model|schema|entity|types?)/i.test(rel))
-  ), 30).map((f) => f.path);
-  const db = findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (
-    /(backend|app|src)\/.*\/(db|database|alembic|migrations)[/.]/.test(rel) ||
-    (isPython(rel) && /(sqlite|qdrant|neo4j|database|storage|repository|vector|graph|migration)/i.test(rel))
-  ), 30).map((f) => f.path);
-  const config = findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (
-    /(backend|app|src)\/.*(config|settings|env).*\.py$/.test(rel) ||
-    (isRootPython(rel) && /(config|settings|env)/i.test(rel)) ||
-    rel.endsWith("requirements.txt") ||
-    rel === "pyproject.toml"
-  ), 20).map((f) => f.path);
-  const auth = findRepoFiles(result, (rel, file) => !isNonSourcePath(rel) && (
-    /(backend|app|src)\/.*auth/.test(rel) ||
-    /\/security\.py$/.test(rel) ||
-    (isPython(rel) && /(auth|security|permission|token|session|oauth|jwt|middleware)/i.test(rel)) ||
-    (isRootPython(rel) && /(Depends|HTTPBearer|OAuth2|JWT|Authorization)/.test(pythonText(file)))
-  ), 30).map((f) => f.path);
-  return { api, services, models, db, config, auth };
-}
+  const {
+    detectBackendPaths,
+    detectEntrypoints,
+    detectFrameworks,
+    detectFrontendPaths,
+    getGitActivity,
+    hasPath,
+    isNonSourcePath,
+    topLevelDirectories,
+    topLoadBearing,
+  } = require("./context-detect")({ fs, path, safeReadJson, readIfText, formatBytes });
 
-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) && (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),
-  };
-}
 
 function createOptimizeContext(rootDir = process.cwd(), scope = null) {
   const scan = scanRepo(rootDir);
@@ -253,140 +74,6 @@ function mdList(items, empty = "None detected.") {
   return items.map((item) => `- \`${item}\``).join("\n");
 }
 
-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?|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"))) {
-    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?|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);
-      }
-    }
-    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 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.score - a.score || b.file.size - a.file.size)
-    .slice(0, limit)
-    .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) {
   const gaps = [];

package/lib/prismo-dev/scan-detect.js

@@ -0,0 +1,306 @@
+module.exports = function createScanDetect(deps) {
+  const { fs, http, https, os, path, readIfText, estimateTokens, getClaudeSessionFiles, getCodexSessionFiles, normalizeRel } = deps;
+
+  function countJsonObjectKeys(value, keyName) {
+    if (!value || typeof value !== "object") return 0;
+    let count = 0;
+    if (value[keyName] && typeof value[keyName] === "object") {
+      count += Array.isArray(value[keyName]) ? value[keyName].length : Object.keys(value[keyName]).length;
+    }
+    for (const child of Object.values(value)) {
+      if (child && typeof child === "object") count += countJsonObjectKeys(child, keyName);
+    }
+    return count;
+  }
+
+  function scanClaudeConfig(root) {
+    const candidates = [
+      path.join(os.homedir(), ".claude", "settings.json"),
+      path.join(os.homedir(), ".claude.json"),
+      path.join(root, ".claude", "settings.json"),
+      path.join(root, ".claude.json"),
+    ];
+    const found = [];
+    let mcpServers = 0;
+    let hooks = 0;
+    let pluginRefs = 0;
+
+    for (const filePath of candidates) {
+      if (!fs.existsSync(filePath)) continue;
+      const text = readIfText(filePath);
+      if (!text) continue;
+      const rel = filePath.startsWith(root) ? normalizeRel(path.relative(root, filePath)) : filePath;
+      found.push(rel);
+      try {
+        const json = JSON.parse(text);
+        mcpServers += countJsonObjectKeys(json, "mcpServers");
+        hooks += countJsonObjectKeys(json, "hooks");
+      } catch {
+        mcpServers += (text.match(/mcpServers|mcp_servers|mcp-server/g) || []).length;
+        hooks += (text.match(/hooks|hook/g) || []).length;
+      }
+      pluginRefs += (text.match(/plugin|skill/gi) || []).length;
+    }
+
+    return { files: found, mcpServers, hooks, pluginRefs };
+  }
+
+  function scanCodexConfig(root) {
+    const candidates = [
+      path.join(root, ".codex", "config.toml"),
+      path.join(os.homedir(), ".codex", "config.toml"),
+      path.join(root, "AGENTS.md"),
+    ];
+    const found = [];
+    let mcpServers = 0;
+
+    for (const filePath of candidates) {
+      if (!fs.existsSync(filePath)) continue;
+      const text = readIfText(filePath);
+      if (!text) continue;
+      found.push(filePath.startsWith(root) ? normalizeRel(path.relative(root, filePath)) : filePath);
+      mcpServers += (text.match(/\[mcp|mcp_servers|mcp-server|server\]/gi) || []).length;
+    }
+    return { files: found, mcpServers };
+  }
+
+  function commandExists(command) {
+    const pathEntries = (process.env.PATH || "").split(path.delimiter).filter(Boolean);
+    const names = process.platform === "win32" ? [command, `${command}.cmd`, `${command}.exe`, `${command}.ps1`] : [command];
+    return pathEntries.some((entry) => names.some((name) => fs.existsSync(path.join(entry, name))));
+  }
+
+  function pathExistsAny(paths) {
+    return paths.some((candidate) => fs.existsSync(candidate));
+  }
+
+  function detectOptimizationStack(root, claudeConfig, codexConfig) {
+    const projectClaudePlugin = fs.existsSync(path.join(root, ".claude-plugin")) || fs.existsSync(path.join(root, ".claude", "settings.json"));
+    const projectMana = fs.existsSync(path.join(root, ".mana-mcp.json")) || fs.existsSync(path.join(os.homedir(), ".mana"));
+    const projectHeadroom = fs.existsSync(path.join(root, ".headroom")) || fs.existsSync(path.join(os.homedir(), ".headroom"));
+    const projectDistill = fs.existsSync(path.join(os.homedir(), ".config", "distill")) || commandExists("distill");
+    const projectRtk = fs.existsSync(path.join(root, ".rtk")) || commandExists("rtk");
+    const packageText = readIfText(path.join(root, "package.json"), 512 * 1024) || "";
+    const readmeText = readIfText(path.join(root, "README.md"), 512 * 1024) || "";
+    const projectText = `${packageText}\n${readmeText}`.toLowerCase();
+    const hasText = (pattern) => pattern.test(projectText);
+
+    const tools = {
+      rtk: { detected: projectRtk, source: projectRtk ? "binary-or-project-config" : "not-detected" },
+      headroom: { detected: projectHeadroom || commandExists("headroom"), source: projectHeadroom ? "local-config" : commandExists("headroom") ? "binary" : "not-detected" },
+      distill: { detected: projectDistill, source: projectDistill ? "binary-or-user-config" : "not-detected" },
+      mana: { detected: projectMana || commandExists("mana"), source: projectMana ? "local-config" : commandExists("mana") ? "binary" : "not-detected" },
+      contextMode: { detected: commandExists("context-mode") || hasText(/context-mode/), source: commandExists("context-mode") ? "binary" : hasText(/context-mode/) ? "project-reference" : "not-detected" },
+      leanCtx: { detected: commandExists("lean-ctx") || hasText(/lean-ctx|lean ctx/), source: commandExists("lean-ctx") ? "binary" : hasText(/lean-ctx|lean ctx/) ? "project-reference" : "not-detected" },
+      repomix: { detected: commandExists("repomix") || hasText(/repomix/), source: commandExists("repomix") ? "binary" : hasText(/repomix/) ? "project-reference" : "not-detected" },
+      codegraph: { detected: commandExists("codegraph") || hasText(/codegraph|codebase-memory-mcp|jcodemunch|sigmap/), source: commandExists("codegraph") ? "binary" : hasText(/codegraph|codebase-memory-mcp|jcodemunch|sigmap/) ? "project-reference" : "not-detected" },
+      tokf: { detected: commandExists("tokf") || hasText(/tokf/), source: commandExists("tokf") ? "binary" : hasText(/tokf/) ? "project-reference" : "not-detected" },
+    };
+
+    return {
+      tools,
+      claudeHooks: claudeConfig.hooks,
+      claudeMcpServers: claudeConfig.mcpServers,
+      codexMcpServers: codexConfig.mcpServers,
+      claudePluginDetected: projectClaudePlugin,
+      mcpServerTotal: claudeConfig.mcpServers + codexConfig.mcpServers,
+      detectedTools: Object.entries(tools).filter(([, value]) => value.detected).map(([name]) => name),
+    };
+  }
+
+  function detectAgentReadiness(root, claudeConfig, codexConfig, realUsage) {
+    const claudeHome = process.env.PRISMO_CLAUDE_HOME || path.join(os.homedir(), ".claude");
+    const codexHome = process.env.PRISMO_CODEX_HOME || path.join(os.homedir(), ".codex");
+    const cursorPaths = [
+      path.join(root, ".cursor"),
+      path.join(root, ".cursorrules"),
+      path.join(os.homedir(), ".cursor"),
+      path.join(os.homedir(), ".config", "Cursor"),
+    ];
+    const usageSources = new Set(realUsage && realUsage.sources ? realUsage.sources : []);
+
+    const claudeSessionFiles = getClaudeSessionFiles(root);
+    const codexSessionFiles = getCodexSessionFiles();
+
+    return {
+      claudeCode: {
+        detected: claudeConfig.files.length > 0 || fs.existsSync(claudeHome) || claudeSessionFiles.length > 0,
+        configFiles: claudeConfig.files,
+        localLogsFound: claudeSessionFiles.length > 0 || usageSources.has("claude-code"),
+        mcpServers: claudeConfig.mcpServers,
+        hooks: claudeConfig.hooks,
+        exactProxyTracking: "limited-for-subscription-mode",
+        recommendedMode: "local-log-and-repo-scan",
+      },
+      codex: {
+        detected: codexConfig.files.length > 0 || fs.existsSync(codexHome) || codexSessionFiles.length > 0,
+        configFiles: codexConfig.files,
+        localLogsFound: codexSessionFiles.length > 0 || usageSources.has("codex"),
+        mcpServers: codexConfig.mcpServers,
+        exactProxyTracking: "available-when-using-api-key-base-url-mode",
+        recommendedMode: "prismo-proxy-for-api-mode-or-local-log-watch",
+      },
+      cursor: {
+        detected: pathExistsAny(cursorPaths),
+        configFiles: cursorPaths.filter((candidate) => fs.existsSync(candidate)),
+        localLogsFound: false,
+        exactProxyTracking: "available-only-if-configured-for-openai-compatible-base-url",
+        recommendedMode: "repo-scan-and-prismo-proxy-when-supported",
+      },
+      localUsageLogsAvailable: Boolean((realUsage && realUsage.sessions.length) || claudeSessionFiles.length || codexSessionFiles.length),
+      exactProxyTrackingAvailable: true,
+      notes: [
+        "Exact tracking is available when a tool sends OpenAI/Anthropic API traffic through Prismo.",
+        "Subscription coding-agent sessions usually require local-log visibility unless the tool supports a custom base URL.",
+      ],
+    };
+  }
+
+  function detectToolOutputRisk({ exposedLargeFiles, exposedHighRiskDirs, highRiskDirs }) {
+    const noisyDirs = highRiskDirs.filter((dir) => ["coverage", "test-results", "playwright-report", "logs", "dist", "build", ".next"].some((name) => dir.path.split("/").includes(name)));
+    const exposedNoisyDirs = exposedHighRiskDirs.filter((dir) => noisyDirs.some((candidate) => candidate.path === dir.path));
+    const noisyFiles = exposedLargeFiles.filter((file) => ["log", "json", "minified", "lock/generated"].includes(file.kind) || /\.(log|json|ndjson|out|trace|har)$/i.test(file.path));
+    const estimatedExposureTokens = estimateTokens(noisyFiles.reduce((sum, file) => sum + file.size, 0));
+    let level = "Low";
+    if (exposedNoisyDirs.length >= 3 || noisyFiles.length >= 3 || estimatedExposureTokens >= 250000) level = "High";
+    else if (exposedNoisyDirs.length || noisyFiles.length || estimatedExposureTokens >= 50000) level = "Medium";
+
+    return {
+      level,
+      exposedNoisyDirectories: exposedNoisyDirs.map((dir) => dir.path),
+      noisyDirectoriesDetected: noisyDirs.map((dir) => ({ path: dir.path, exposed: dir.exposed })),
+      exposedNoisyFiles: noisyFiles.map((file) => ({
+        path: file.path,
+        kind: file.kind,
+        sizeBytes: file.size,
+        estimatedTokensIfRead: estimateTokens(file.size),
+      })),
+      estimatedExposureTokens,
+      summary:
+        level === "High"
+          ? "Large logs, test reports, build output, or generated files are exposed to coding-agent reads."
+          : level === "Medium"
+            ? "Some noisy tool-output artifacts are present and may enter context during broad exploration."
+            : "No major exposed tool-output artifacts detected.",
+    };
+  }
+
+  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: {
+        available: true,
+        description: "Available for apps and coding tools that send OpenAI or Anthropic API traffic through the Prismo base URL.",
+      },
+      codingAgentBaseUrlMode: {
+        codex: codexConfig.files.length ? "possible-if-using-api-key-mode" : "not-detected",
+        claudeCode: "limited-for-subscription-sessions",
+        cursor: "possible-if-configured-for-openai-compatible-provider",
+      },
+      localEstimateTracking: {
+        available: true,
+        logsFound: Boolean(realUsage && realUsage.sessions.length),
+        description: "Available for subscription coding tools when local Codex/Claude Code logs exist; accuracy depends on token fields exposed by those tools.",
+      },
+      unsupported: [
+        "Exact billing for hidden subscription sessions without provider traffic, API keys, or local token fields.",
+        "Prompt interception or tool rewriting is not enabled by PrismoDev Scan.",
+      ],
+    };
+  }
+
+  function checkUrlReachable(url, timeoutMs = 650) {
+    return new Promise((resolve) => {
+      let parsed;
+      try {
+        parsed = new URL(url);
+      } catch {
+        resolve({ url, reachable: false, error: "invalid-url" });
+        return;
+      }
+      const client = parsed.protocol === "https:" ? https : http;
+      const request = client.request(
+        {
+          method: "GET",
+          hostname: parsed.hostname,
+          port: parsed.port,
+          path: parsed.pathname === "/" ? "/health" : parsed.pathname,
+          timeout: timeoutMs,
+        },
+        (response) => {
+          response.resume();
+          resolve({ url, reachable: response.statusCode >= 200 && response.statusCode < 500, statusCode: response.statusCode });
+        }
+      );
+      request.on("timeout", () => {
+        request.destroy();
+        resolve({ url, reachable: false, error: "timeout" });
+      });
+      request.on("error", (error) => {
+        resolve({ url, reachable: false, error: error.code || error.message });
+      });
+      request.end();
+    });
+  }
+
+  return {
+    buildProxyTrackingReadiness,
+    checkUrlReachable,
+    detectAgentReadiness,
+    detectOperationalNoise,
+    detectOptimizationStack,
+    detectToolOutputRisk,
+    scanClaudeConfig,
+    scanCodexConfig,
+  };
+};