launchprep 0.0.1 → 0.1.0

package/src/checks.mjs

@@ -0,0 +1,209 @@
+// Tier-1 checks: deterministic, no LLM, no network. Each returns findings with
+// a file:line so the user can go straight to it.
+import { AUTHZ_CHECKS } from './checks-authz.mjs';
+import { AI_CHECKS } from './checks-ai.mjs';
+import { DEPLOY_CHECKS } from './checks-deploy.mjs';
+import { AUTH_CHECKS } from './checks-auth.mjs';
+import { FRAMEWORK_CHECKS } from './checks-frameworks.mjs';
+import { BATCH2_CHECKS } from './checks-batch2.mjs';
+import { BATCH3_CHECKS } from './checks-batch3.mjs';
+import { BATCH4_CHECKS } from './checks-batch4.mjs';
+
+const finding = (id, title, severity, file, line, detail, fix) =>
+  ({ id, title, severity, file, line, detail, fix });
+
+const lineOf = (text, index) => text.slice(0, index).split('\n').length;
+
+const BASE_CHECKS = [
+
+{ id:'SEC-002', run(repo){
+    const gi = repo.read('.gitignore');
+    if (gi === null) return [];
+    if (/^\s*\.env/m.test(gi)) return [];
+    return [finding('SEC-002','.env is not in .gitignore','high','.gitignore',1,
+      'Nothing stops a future commit from publishing your secrets.',
+      'Add a line containing  .env*  to .gitignore')];
+  }},
+
+{ id:'SEC-004', run(repo){
+    // Many NEXT_PUBLIC_* keys are public BY DESIGN. Stripe's publishable key and
+    // Supabase's anon key belong in the browser; flagging them as CRITICAL is the
+    // fastest way to lose a user's trust in every other finding.
+    const PUBLIC_BY_DESIGN = /(PUBLISHABLE|ANON_KEY|PUBLIC_KEY|SITE_KEY|VAPID|POSTHOG|SENTRY_DSN|MEASUREMENT_ID|^(GA|GTM)_|TURNSTILE|RECAPTCHA_SITE|HCAPTCHA|MAPBOX|GOOGLE_MAPS|ALGOLIA_SEARCH|AMPLITUDE|MIXPANEL_TOKEN)/;
+    // names that are settings, not credentials
+    const NOT_A_CREDENTIAL = /(ENABLE|DISABLE|REQUIRE|ALLOW|SHOW|USE)_/;
+    // unambiguous: these must never be public
+    const DEFINITELY_SECRET = /(SECRET|SERVICE_ROLE|PRIVATE_KEY|_SK_|OPENAI|ANTHROPIC|CLAUDE|GROQ|SENDGRID|RESEND|TWILIO|AWS_SECRET|DATABASE_URL|CONNECTION_STRING)/;
+
+    const out=[];
+    for (const f of repo.files){
+      if (!f.text || !/\.(ts|tsx|js|jsx|mjs|env)$/.test(f.path)) continue;
+      if (/\.(example|sample|template)$/i.test(f.path)) continue;
+      const re=/\b(NEXT_PUBLIC_|VITE_|REACT_APP_|PUBLIC_)([A-Z0-9_]*(KEY|SECRET|TOKEN|PASSWORD)[A-Z0-9_]*)/g;
+      let m;
+      while ((m=re.exec(f.text))){
+        const full = m[1]+m[2];
+        if (PUBLIC_BY_DESIGN.test(m[2]) || NOT_A_CREDENTIAL.test(m[2])) continue;
+
+        const certain = DEFINITELY_SECRET.test(m[2]);
+        out.push(finding('SEC-004',
+          certain ? 'Server secret exposed to the browser' : 'Possible secret exposed to the browser',
+          certain ? 'critical' : 'medium',
+          f.path, lineOf(f.text,m.index),
+          certain
+            ? `${full} — the ${m[1]} prefix ships this value to every visitor's browser, and this is a credential that must stay on your server.`
+            : `${full} — the ${m[1]} prefix makes this readable by anyone who opens your site. If it is a provider's publishable key that is fine; if it grants write access it is not.`,
+          certain
+            ? 'Remove the public prefix, read it only on the server, and rotate the key.'
+            : 'Confirm this key is meant to be public. If it is not, drop the prefix and rotate it.'));
+      }
+    }
+    return out;
+  }},
+
+{ id:'SEC-003', run(repo){
+    const out=[];
+    const PATTERNS=[
+      [/\bsk-ant-[A-Za-z0-9_-]{20,}/g,'Anthropic API key'],
+      [/\bsk-[A-Za-z0-9]{32,}/g,'OpenAI API key'],
+      [/\bAKIA[0-9A-Z]{16}\b/g,'AWS access key'],
+      [/\bghp_[A-Za-z0-9]{30,}/g,'GitHub token'],
+      [/\bxox[baprs]-[A-Za-z0-9-]{10,}/g,'Slack token'],
+    ];
+    for (const f of repo.files){
+      // placeholder/sample env files are meant to be committed - never a secret finding
+      if (!f.text || /\.(md|lock)$/.test(f.path)) continue;
+      if (/\.(example|sample|template|dist)$/i.test(f.path) ||
+          /\.env\.(example|sample|template)/i.test(f.path)) continue;
+      for (const [re,label] of PATTERNS){
+        let m; re.lastIndex=0;
+        while ((m=re.exec(f.text))){
+          out.push(finding('SEC-003',`Hardcoded ${label}`,'critical',
+            f.path, lineOf(f.text,m.index),
+            `A live ${label} is written directly into this file.`,
+            'Move it to an environment variable and rotate the key — it must be treated as leaked.'));
+        }
+      }
+    }
+    return out;
+  }},
+
+{ id:'AUTH-001', run(repo,profile){
+    if (!profile.has_accounts) return [];
+    const out=[];
+    for (const f of repo.files){
+      if (!f.text || !/\.(ts|tsx|js|jsx)$/.test(f.path)) continue;
+      const re=/(localStorage|sessionStorage)\.setItem\(\s*['"`][^'"`]*(token|jwt|auth|session)/gi;
+      let m;
+      while ((m=re.exec(f.text))){
+        out.push(finding('AUTH-001','Session token stored in browser storage','high',
+          f.path, lineOf(f.text,m.index),
+          'Anything in localStorage is readable by any script on the page, so one XSS steals the login.',
+          'Store the session in an httpOnly, Secure, SameSite cookie instead.'));
+      }
+    }
+    return out;
+  }},
+
+{ id:'AI-003', run(repo,profile){
+    if (!profile.calls_llm) return [];
+    const out=[];
+    for (const f of repo.files){
+      if (!f.text || !/\.(ts|tsx|js|mjs|py)$/.test(f.path)) continue;
+      const re=/\.messages\.create\s*\(|\.chat\.completions\.create\s*\(/g;
+      let m;
+      while ((m=re.exec(f.text))){
+        const window_=f.text.slice(m.index, m.index+600);
+        if (/max_tokens|maxTokens|max_output_tokens/.test(window_)) continue;
+        out.push(finding('AI-003','AI call with no token ceiling','high',
+          f.path, lineOf(f.text,m.index),
+          'Without max_tokens a single request can generate — and bill — without limit.',
+          'Set max_tokens on every completion call.'));
+      }
+    }
+    return out;
+  }},
+
+{ id:'DEP-010', run(repo){
+    if (!repo.exists('package.json')) return [];
+    const has = ['package-lock.json','pnpm-lock.yaml','yarn.lock','bun.lockb'].some(l=>repo.exists(l));
+    return has ? [] : [finding('DEP-010','No lockfile committed','medium','package.json',1,
+      'Without a lockfile your production build can install different versions than you tested.',
+      'Commit the lockfile your package manager generates.')];
+  }},
+
+{ id:'API-002', run(repo,profile){
+    if (!profile.is_public) return [];
+    const out=[];
+    for (const f of repo.files){
+      if (!f.text || !/\.(ts|js|mjs)$/.test(f.path)) continue;
+      const re=/catch\s*\(\s*(\w+)\s*\)\s*\{[^}]{0,200}?(?:json|send)\s*\(\s*\{[^}]{0,120}?\1(?:\.message|\.stack)?/gs;
+      let m;
+      while ((m=re.exec(f.text))){
+        out.push(finding('API-002','Internal error details returned to the client','high',
+          f.path, lineOf(f.text,m.index),
+          'Raw error objects leak file paths, query fragments and library versions to anyone who can trigger them.',
+          'Log the real error server-side; return a generic message and a reference id.'));
+      }
+    }
+    return out;
+  }},
+
+{ id:'UP-002', run(repo,profile){
+    if (!profile.has_file_uploads) return [];
+    const hasLimit = repo.grep(/limits\s*:\s*\{[^}]*fileSize|maxFileSize|MAX_FILE_SIZE/).length;
+    if (hasLimit) return [];
+    const site = repo.grep(/multer\s*\(|formidable\s*\(|\.upload\s*\(/)[0];
+    return site ? [finding('UP-002','File uploads have no size limit','high',
+      site.path, 1,
+      'One user can upload a file large enough to fill your disk or exhaust memory.',
+      'Set an explicit maximum file size on the upload handler.')] : [];
+  }},
+];
+
+// AI checks supersede the earlier inline AI-003
+const BASE = BASE_CHECKS.filter(c => c.id !== 'AI-003');
+// the fuller AUTH_CHECKS version supersedes the early inline SEC-001
+const B2 = BASE.filter(c => c.id !== 'SEC-001');
+export const CHECKS = [...B2, ...AUTHZ_CHECKS, ...AI_CHECKS, ...DEPLOY_CHECKS, ...AUTH_CHECKS, ...FRAMEWORK_CHECKS, ...BATCH2_CHECKS, ...BATCH3_CHECKS, ...BATCH4_CHECKS];
+
+// Test and fixture files are not deployed. A "vulnerability" in a spec file is
+// noise, and noise is what makes people stop reading findings.
+const IS_TEST = /(^|\/)(tests?|__tests__|__mocks__|spec|e2e|fixtures?|examples?)\/|\.(test|spec)\.[jt]sx?$|\.stories\.[jt]sx?$/;
+
+function withoutTests(repo){
+  const files = repo.files.filter(f => !IS_TEST.test(f.path));
+  return { ...repo, files,
+    has:  (re) => files.some(f => re.test(f.path)),
+    find: (re) => files.filter(f => re.test(f.path)),
+    grep: (re, pathRe = /\.(ts|tsx|js|jsx|mjs|cjs|py|rb|sql|prisma)$/) =>
+      files.filter(f => f.text && pathRe.test(f.path) && re.test(f.text)),
+  };
+}
+
+// Some facts live at the repo root and nowhere else - the lockfile, the CI
+// config, .gitignore. In a monorepo every workspace correctly lacks them, so a
+// check that looks for one from inside apps/web fires on every package and is
+// wrong every time. Those declare scope:'root' and run once, against the root.
+export function runRootChecks(repo, profile, applicableIds){
+  repo = withoutTests(repo);
+  const out=[];
+  for (const c of CHECKS){
+    if (c.scope !== 'root') continue;
+    if (applicableIds && !applicableIds.has(c.id)) continue;
+    try { out.push(...c.run(repo, profile)); } catch {}
+  }
+  return out;
+}
+
+export function runChecks(repo, profile, applicableIds){
+  repo = withoutTests(repo);
+  const out=[];
+  for (const c of CHECKS){
+    if (c.scope === 'root') continue;          // runRootChecks owns these
+    if (applicableIds && !applicableIds.has(c.id)) continue;
+    try { out.push(...c.run(repo, profile)); } catch {}
+  }
+  const rank={critical:0,high:1,medium:2,low:3};
+  return out.sort((a,b)=>rank[a.severity]-rank[b.severity]);
+}

package/src/detect.mjs

@@ -0,0 +1,304 @@
+// Profile detection. Every fact carries evidence and a confidence level.
+// LOW confidence never produces a `fail` — the gate turns it into a question.
+import { readPackageJson, allDeps, stripComments, isWorkspaceRoot } from './fs-scan.mjs';
+
+const fact = (value, confidence, evidence = []) => ({ value, confidence, evidence });
+const dep  = (deps, ...names) => names.find(n => deps[n] !== undefined);
+
+// ---------- stack ----------
+function detectFramework(repo, deps) {
+  // ---- python ----
+  if (repo.exists('manage.py') || repo.has(/(^|\/)manage\.py$/))
+    return fact('django', 'high', ['manage.py']);
+  if (repo.grep(/^\s*(DJANGO_SETTINGS_MODULE|INSTALLED_APPS)\s*=/m, /\.py$/).length ||
+      repo.grep(/^\s*[Dd]jango[><=~]/m, /requirements.*\.txt$|Pipfile$|pyproject\.toml$/).length)
+    return fact('django', 'high', ['django settings']);
+  if (repo.grep(/from fastapi|FastAPI\s*\(/, /\.py$/).length)
+    return fact('fastapi', 'high', ['FastAPI import']);
+  if (repo.grep(/from flask import|Flask\s*\(__name__/, /\.py$/).length)
+    return fact('flask', 'high', ['Flask import']);
+
+  // ---- ruby ----
+  const gemfile = repo.read('Gemfile') || repo.find(/(^|\/)Gemfile$/)[0]?.text || '';
+  if (/gem\s+['"]rails['"]/.test(gemfile) || repo.exists('config/application.rb') ||
+      repo.has(/config\/application\.rb$/))
+    return fact('rails', 'high', ['rails in Gemfile']);
+  if (/gem\s+['"]sinatra['"]/.test(gemfile)) return fact('sinatra', 'high', ['sinatra gem']);
+
+  // ---- php ----
+  const composer = repo.read('composer.json') || '';
+  if (repo.exists('artisan') || /laravel\/framework/.test(composer))
+    return fact('laravel', 'high', ['artisan / laravel framework']);
+  if (/symfony\//.test(composer)) return fact('symfony', 'high', ['symfony packages']);
+
+  // ---- javascript ----
+  const byDep = [
+    ['next','next'], ['remix','@remix-run/react'], ['nuxt','nuxt'],
+    ['sveltekit','@sveltejs/kit'], ['nest','@nestjs/core'],
+    ['express','express'], ['fastify','fastify'], ['react-native','react-native'],
+  ];
+  for (const [name, d] of byDep) if (deps[d]) return fact(name, 'high', [`dependency ${d}`]);
+
+  // ---- mobile ----
+  if (repo.exists('pubspec.yaml'))      return fact('flutter', 'high', ['pubspec.yaml']);
+  if (repo.has(/Package\.swift$|\.xcodeproj/)) return fact('swiftui', 'high', ['xcode project']);
+  return fact('other', 'low', []);
+}
+
+// `root` is the whole repo when profiling one package of a monorepo: the app
+// package imports the db package, so its schema lives somewhere else entirely.
+function detectDatabase(repo, deps, root) {
+  if (deps['@supabase/supabase-js'] || repo.exists('supabase/config.toml') ||
+      root?.exists('supabase/config.toml'))
+    return fact('supabase', 'high', ['@supabase/supabase-js']);
+
+  const prisma = repo.find(/schema\.prisma$/)[0] || root?.find(/schema\.prisma$/)[0];
+  if (prisma?.text) {
+    const m = prisma.text.match(/provider\s*=\s*"(\w+)"/);
+    if (m) return fact(m[1] === 'postgresql' ? 'postgres' : m[1], 'high', ['prisma schema provider']);
+  }
+  // ORM present but schema elsewhere - still tells us a database exists
+  if (deps['@prisma/client'] || deps['prisma'])
+    return fact('postgres', 'low', ['prisma client, schema not in this package']);
+  if (deps['drizzle-orm']) {
+    const d = (root || repo).grep(/pgTable\s*\(/) .length ? 'postgres'
+            : (root || repo).grep(/mysqlTable\s*\(/).length ? 'mysql'
+            : (root || repo).grep(/sqliteTable\s*\(/).length ? 'sqlite' : 'postgres';
+    return fact(d, 'high', ['drizzle schema']);
+  }
+  if (deps['mongoose']) return fact('mongodb','high',['mongoose']);
+  if (deps['typeorm'] || deps['sequelize']) return fact('postgres','low',['orm present']);
+  if (deps['sqlalchemy'] || deps['SQLAlchemy'] || deps['psycopg2'] || deps['psycopg2-binary'])
+    return fact('postgres','high',['python postgres driver']);
+
+  // django settings.py -> DATABASES ENGINE
+  const dj = repo.grep(/ENGINE['"]?\s*:\s*['"]django\.db\.backends\.(\w+)/, /\.py$/)[0]
+          || root?.grep(/ENGINE['"]?\s*:\s*['"]django\.db\.backends\.(\w+)/, /\.py$/)[0];
+  if (dj) {
+    const m = dj.text.match(/django\.db\.backends\.(\w+)/);
+    const map = { postgresql: 'postgres', postgresql_psycopg2: 'postgres', mysql: 'mysql', sqlite3: 'sqlite', oracle: 'other' };
+    if (m) return fact(map[m[1]] || m[1], 'high', ['django DATABASES engine']);
+  }
+  // rails config/database.yml -> adapter
+  const ry = repo.read('config/database.yml') || root?.read('config/database.yml');
+  if (ry) {
+    const m = ry.match(/adapter:\s*(\w+)/);
+    const map = { postgresql: 'postgres', postgres: 'postgres', mysql2: 'mysql', sqlite3: 'sqlite' };
+    if (m) return fact(map[m[1]] || m[1], 'high', ['rails database.yml adapter']);
+  }
+  // requirements.txt / Gemfile drivers
+  if (repo.grep(/^\s*psycopg2|^\s*asyncpg/m, /requirements.*\.txt$|Pipfile$/).length)
+    return fact('postgres','high',['python postgres driver']);
+  const gem = repo.read('Gemfile') || '';
+  if (/gem\s+['"]pg['"]/.test(gem))     return fact('postgres','high',['pg gem']);
+  if (/gem\s+['"]mysql2['"]/.test(gem)) return fact('mysql','high',['mysql2 gem']);
+  if (dep(deps,'pg','postgres','@neondatabase/serverless')) return fact('postgres','high',['pg driver']);
+  if (dep(deps,'mysql2','mysql'))     return fact('mysql','high',['mysql driver']);
+  if (dep(deps,'mongodb','mongoose')) return fact('mongodb','high',['mongo driver']);
+  if (dep(deps,'better-sqlite3','sqlite3')) return fact('sqlite','high',['sqlite driver']);
+  if (dep(deps,'firebase','firebase-admin')) return fact('firebase','high',['firebase sdk']);
+  return fact('none','low',[]);
+}
+
+function detectAuth(repo, deps) {
+  if (dep(deps,'@clerk/nextjs','@clerk/clerk-react')) return fact('clerk','high',['clerk sdk']);
+  if (dep(deps,'@auth0/nextjs-auth0'))                return fact('auth0','high',['auth0 sdk']);
+  if (dep(deps,'next-auth','@auth/core'))             return fact('nextauth','high',['next-auth']);
+  if (deps['@supabase/supabase-js'] && repo.grep(/auth\.(signIn|signUp|getUser|getSession)/).length)
+    return fact('supabase-auth','high',['supabase auth calls']);
+  const gemf = repo.read('Gemfile') || '';
+  if (/gem\s+['"]devise['"]/.test(gemf)) return fact('devise','high',['devise gem']);
+  if (/has_secure_password/.test((repo.grep(/has_secure_password/, /\.rb$/)[0]||{}).text || ''))
+    return fact('custom','high',['has_secure_password']);
+  if (repo.grep(/django\.contrib\.auth/, /\.py$/).length)
+    return fact('django-auth','high',['django.contrib.auth']);
+  if (dep(deps,'bcrypt','bcryptjs','argon2') ||
+      repo.grep(/(?:from|require\()\s*['"](?:bcrypt|bcryptjs|argon2)/).length)
+    return fact('custom','high',['password hashing import']);
+  return fact('none','low',[]);
+}
+
+function detectHost(repo, deps) {
+  if (repo.exists('vercel.json') || deps['@vercel/analytics']) return fact('vercel','high',['vercel.json']);
+  if (repo.exists('netlify.toml'))  return fact('netlify','high',['netlify.toml']);
+  if (repo.exists('wrangler.toml')) return fact('cloudflare','high',['wrangler.toml']);
+  if (repo.exists('fly.toml'))      return fact('fly','high',['fly.toml']);
+  if (repo.exists('railway.json'))  return fact('railway','high',['railway.json']);
+  if (repo.exists('render.yaml'))   return fact('render','high',['render.yaml']);
+  if (repo.has(/^Dockerfile$|docker-compose\.ya?ml$/)) return fact('vps','low',['Dockerfile — host inferred']);
+  return fact(null,'low',[]);
+}
+
+// ---------- capability facts ----------
+const LLM_DEPS = {
+  '@anthropic-ai/sdk':'anthropic', 'openai':'openai', 'groq-sdk':'groq',
+  '@google/generative-ai':'google', '@mistralai/mistralai':'mistral', 'ollama':'other',
+  'ai':'other', '@ai-sdk/anthropic':'anthropic', '@ai-sdk/openai':'openai',
+};
+function detectLlm(repo, deps) {
+  const providers = [...new Set(Object.entries(LLM_DEPS).filter(([d]) => deps[d]).map(([,p]) => p))];
+  const hits = repo.grep(/api\.(openai|anthropic)\.com|generativelanguage\.googleapis|api\.groq\.com/);
+  if (!providers.length && !hits.length) return { calls_llm: fact(false,'high',[]), providers: fact([], 'high', []) };
+  const ev = providers.length ? [`sdk: ${providers.join(', ')}`] : [`direct call in ${hits[0].path}`];
+  return { calls_llm: fact(true,'high',ev), providers: fact(providers,'high',ev) };
+}
+
+function detectTenancy(repo, hasAccounts) {
+  const RE = /\b(tenant_id|org_id|organization_id|workspace_id|team_id|account_id)\b/;
+  const schema = repo.grep(RE, /\.(sql|prisma)$/);
+  const code   = repo.grep(RE);
+  if (schema.length >= 2 || (schema.length && code.length >= 3))
+    return fact('multi-tenant-shared-db','high',[`tenant key in ${schema.length} schema file(s)`]);
+  if (schema.length || code.length >= 3)
+    return fact('multi-tenant-shared-db','low',['tenant key present but sparse']);
+  if (!hasAccounts) return fact('none','high',['no accounts']);
+  return fact('single-user','low',['accounts present, no tenant key found']);
+}
+
+const PII    = /\b(email|phone|first_?name|last_?name|address|date_?of_?birth|dob|postal|zip_?code)\b/i;
+const FIN    = /\b(card_?number|iban|invoice|amount_cents|stripe_customer|tax_id|vat)\b/i;
+const HEALTH = /\b(diagnosis|patient|medical_record|prescription|icd_?10)\b/i;
+const CHILD  = /\b(parental_consent|guardian|is_minor|age_gate)\b/i;
+// only count matches inside actual schema declarations, with comments removed
+function schemaHits(repo, re) {
+  const files = repo.files.filter(f => f.text && /\.(sql|prisma|ts|py|rb)$/.test(f.path));
+  const hits = [];
+  for (const f of files) {
+    const body = stripComments(f.text);
+    const looksLikeSchema =
+      /pgTable\s*\(|mysqlTable\s*\(|sqliteTable\s*\(|CREATE TABLE|^model\s+\w+\s*\{|class\s+\w+\(.*Model\)/mi.test(body)
+      || /(^|\/)(schema|models?|migrations?|entities)(\/|\.)/i.test(f.path);
+    if (!looksLikeSchema) continue;
+    const m = body.match(new RegExp(re.source, 'gi'));
+    if (m) hits.push({ path: f.path, terms: [...new Set(m.map(x => x.toLowerCase()))] });
+  }
+  return hits;
+}
+function detectSensitivity(repo) {
+  const terms = (hits) => [...new Set(hits.flatMap(h => h.terms))];
+  // high-consequence classifications require corroboration: 2+ distinct terms
+  const health = schemaHits(repo, HEALTH), child = schemaHits(repo, CHILD);
+  if (terms(health).length >= 2) return fact('health','high',[`clinical fields: ${terms(health).join(', ')}`]);
+  if (terms(child).length  >= 2) return fact('children','high',[`minor/guardian fields: ${terms(child).join(', ')}`]);
+  const fin = schemaHits(repo, FIN), pii = schemaHits(repo, PII);
+  if (terms(fin).length >= 1) return fact('financial','high',[`financial fields: ${terms(fin).slice(0,4).join(', ')}`]);
+  if (terms(pii).length >= 2) return fact('pii','high',[`personal fields: ${terms(pii).slice(0,4).join(', ')}`]);
+  if (terms(pii).length === 1) return fact('pii','low',[`single personal field: ${terms(pii)[0]}`]);
+  return fact('none','low',[]);
+}
+
+function detectUploads(repo, deps) {
+  if (dep(deps,'multer','formidable','busboy','uploadthing','@aws-sdk/client-s3','@uploadcare/upload-client'))
+    return fact(true,'high',['upload library']);
+  if (repo.grep(/storage\.from\([^)]*\)\.upload|multipart\/form-data|new FormData\(\)/).length)
+    return fact(true,'high',['upload call site']);
+  return fact(false,'low',[]);
+}
+
+function detectAccounts(repo, deps, auth) {
+  if (auth.value && auth.value !== 'none') return fact(true,'high',[`auth: ${auth.value}`]);
+  if (repo.grep(/(?:CREATE TABLE\s+(?:IF NOT EXISTS\s+)?["`]?(?:public\.)?(?:users|accounts)|^model\s+(?:User|Account)\b)/mi,
+                /\.(sql|prisma)$/).length) return fact(true,'high',['users table in schema']);
+  if (repo.has(/(login|signin|sign-in|register|signup)/i)) return fact(true,'low',['auth route naming']);
+  return fact(false,'low',[]);
+}
+
+function looksLikeLibrary(repo, framework, deps) {
+  // an app has an entrypoint users reach; a library only has exports
+  const pkg = readPackageJson(repo);
+  const hasAppRoutes =
+    repo.has(/^(src\/)?(app|pages|routes|views)\//) ||
+    repo.has(/^(src\/)?(server|api)\//) ||
+    repo.grep(/createServer\(|app\.listen\(|export const (GET|POST|PUT|DELETE)\b/).length > 0;
+  const isFrameworkApp = ['next','remix','nuxt','sveltekit','express','fastify','nest','django','fastapi','rails','flutter','swiftui','react-native'].includes(framework.value);
+  const exportsOnly = !!(pkg && (pkg.main || pkg.module || pkg.exports || pkg.types) && !pkg.bin);
+  if (isFrameworkApp || hasAppRoutes) return false;
+  if (exportsOnly) return true;
+  // config-only packages (eslint/prettier/tsconfig/tailwind presets)
+  if (pkg && Object.keys(deps).length <= 3 && repo.files.length < 30) return true;
+  return false;
+}
+
+function detectSurface(repo, framework, deps) {
+  const f = framework.value;
+  if (looksLikeLibrary(repo, framework, deps))
+    return fact('library','high',['exports only, no app entrypoint']);
+  if (['swiftui'].includes(f))                 return fact('mobile-ios','high',['xcode project']);
+  if (['flutter','react-native'].includes(f))  return fact('mobile-android','low',['cross-platform mobile']);
+  if (['django','rails','laravel','symfony','flask'].includes(f))
+    return fact('web-app','high',[`${f} application`]);
+  if (['express','fastify','nest','fastapi','sinatra'].includes(f)) return fact('api-only','low',['server framework, no UI framework']);
+  if (['next','remix','nuxt','sveltekit'].includes(f)) {
+    const dynamic = repo.has(/\/(api|actions)\//) || repo.grep(/'use server'/).length;
+    return fact(dynamic ? 'web-app' : 'web-site','low',[dynamic?'server routes present':'no server routes found']);
+  }
+  const pkg = readPackageJson(repo);
+  if (pkg?.bin) return fact('cli','high',['package.json bin']);
+  return fact('web-app','low',[]);
+}
+
+function detectStage(repo, host) {
+  const signals = [];
+  if (host.value) signals.push(`host config (${host.value})`);
+  if (repo.has(/^\.github\/workflows\//)) signals.push('CI workflows');
+  if (repo.exists('.env.production') || repo.exists('.env.prod')) signals.push('production env file');
+  if (signals.length >= 2) return fact('production','low',signals);
+  if (signals.length === 1) return fact('pre-launch','low',signals);
+  return fact('prototype','low',['no deploy signals']);
+}
+
+// ---------- entry ----------
+export function detectProfile(repo, opts = {}) {
+  const root = opts.root || null;
+  const pkg  = readPackageJson(repo);
+  const deps = allDeps(repo);          // monorepo-aware: unions every workspace manifest
+
+  const framework = detectFramework(repo, deps);
+  const database  = detectDatabase(repo, deps, root);
+  const auth      = detectAuth(repo, deps);
+  const host      = detectHost(repo, deps);
+  const llm       = detectLlm(repo, deps);
+  const accounts  = detectAccounts(repo, deps, auth);
+
+  const f = {
+    surface:          detectSurface(repo, framework, deps),
+    has_accounts:     accounts,
+    calls_llm:        llm.calls_llm,
+    llm_providers:    llm.providers,
+    is_public:        host.value ? fact(true,'low',['deployed to a public host']) : fact(false,'low',[]),
+    data_sensitivity: (() => { const l = detectSensitivity(repo);
+                               return (l.value === 'none' && root) ? detectSensitivity(root) : l; })(),
+    has_file_uploads: detectUploads(repo, deps),
+    tenancy:          (() => { const l = detectTenancy(repo, accounts.value);
+                               return (['none','single-user'].includes(l.value) && root)
+                                 ? detectTenancy(root, accounts.value) : l; })(),
+    stage:            detectStage(repo, host),
+    // cheap extras that gate real rules
+    has_migrations:   repo.has(/migrations?\//) ? fact(true,'high',['migrations dir']) : fact(false,'low',[]),
+    has_ci:           repo.has(/^\.github\/workflows\//) ? fact(true,'high',['github workflows']) : fact(false,'high',[]),
+    sends_email:      dep(deps,'resend','@sendgrid/mail','nodemailer','postmark','@aws-sdk/client-ses')
+                        ? fact(true,'high',['email sdk']) : fact(false,'low',[]),
+    handles_payments: dep(deps,'stripe','@stripe/stripe-js') ? fact('stripe','high',['stripe sdk'])
+                      : dep(deps,'@paddle/paddle-js') ? fact('paddle','high',['paddle sdk'])
+                      : fact('none','low',[]),
+    has_admin_panel:  repo.has(/\/admin\//i) ? fact(true,'low',['admin route']) : fact(false,'low',[]),
+    stack: {
+      framework: framework.value, database: database.value,
+      auth: auth.value, host: host.value,
+    },
+    _stack_evidence: { framework, database, auth, host },
+  };
+  return f;
+}
+
+// flatten to the shape gate.py expects
+export function toGateProfile(f) {
+  const v = (x) => (x && typeof x === 'object' && 'value' in x) ? x.value : x;
+  const out = {};
+  for (const [k, val] of Object.entries(f)) {
+    if (k.startsWith('_') || k === 'stack') continue;
+    out[k] = v(val);
+  }
+  out.stack = f.stack;
+  return out;
+}