codehere 1.0.1 → 1.0.2

package/dist/infrastructure/security/trust-scorer.js

@@ -1,724 +0,0 @@
-/**
- * Shared trust scoring engine — used by CLI, MCP server, and hook handler.
- *
- * Three scanning passes:
- *   Pass 1 (comments+regex stripped): Secrets & API keys — string literals visible, comments/regex stripped
- *   Pass 2 (fully stripped):          Structural patterns — eval, execSync, innerHTML, etc.
- *                                     Stripped to avoid false positives from pattern definitions
- *   Pass 3 (instruction scan):        Hook-layer patterns on fully stripped code
- *
- * All passes run locally, zero API calls.
- */
-/**
- * Extract the child_process bindings actually imported in a file, so the
- * exec() command-injection pattern can tell a real `cp.exec(cmd)` from a
- * `regex.exec(str)` that happens to live in a file which also uses
- * child_process (e.g. our own artifacts-extractor: spawns git AND runs a
- * regex loop). namespaceAliases = the `cp` in `import * as cp` / `const cp =
- * require(...)`; namedExec = whether `exec`/`execSync` was imported by name so
- * a bare `exec(cmd)` is callable.
- */
-export function childProcessBindings(src) {
-    const namespaceAliases = new Set();
-    let namedExec = false;
-    for (const m of src.matchAll(/import\s+(?:\*\s+as\s+)?(\w+)\s+from\s+['"](?:node:)?child_process['"]/g)) {
-        namespaceAliases.add(m[1]);
-    }
-    for (const m of src.matchAll(/(?:const|let|var|import)\s+(\w+)\s*=\s*require\(\s*['"](?:node:)?child_process['"]/g)) {
-        namespaceAliases.add(m[1]);
-    }
-    for (const m of src.matchAll(/(?:import|const|let|var)\s*\{([^}]*)\}\s*(?:from\s*|=\s*require\(\s*)['"](?:node:)?child_process['"]/g)) {
-        if (/\b(?:exec|execSync)\b/.test(m[1]))
-            namedExec = true;
-    }
-    return { namespaceAliases, namedExec };
-}
-export const CODE_PATTERNS = [
-    // Secrets (scan with strings visible — must see inside string literals)
-    {
-        regex: /(?:password|passwd|pass|pwd|secret|api_?key|auth_?token)\s*[:=]\s*['"`][^'"`\s]{4,}['"`]/gi,
-        severity: 'high',
-        category: 'Secrets',
-        description: 'Hardcoded credential',
-        cwe: 'CWE-798',
-        scanRaw: true,
-    },
-    {
-        regex: /(?:password|passwd|secret|api.?key|auth.?token)[^\n]*\|\|\s*['"`][^'"`\s]{3,}['"`]/gi,
-        severity: 'high',
-        category: 'Secrets',
-        description: 'Hardcoded fallback credential (env var || literal)',
-        cwe: 'CWE-798',
-        scanRaw: true,
-    },
-    {
-        // Provider key formats a dev actually hardcodes. Anthropic (sk-ant-) FIRST:
-        // it carries hyphens, so the generic sk-[alnum]{32,} branch never matched —
-        // and codehere is an Anthropic-SDK product, so it's the most likely leak.
-        // A dogfood sweep (cycle 9) then caught more misses: Stripe (sk_live_ has an
-        // underscore, not a hyphen), AWS access keys (only the .aws/credentials FILE
-        // read was flagged, never a hardcoded AKIA…), and GitHub fine-grained PATs
-        // (github_pat_, distinct from the classic ghp_).
-        // /g so a file with multiple DISTINCT hardcoded keys reports each one — a
-        // trust scan should surface every secret in one pass, not just the first
-        // (the engine's exec-loop breaks after match #1 unless the regex is global).
-        regex: /sk-ant-[a-zA-Z0-9_-]{20,}|sk-[a-zA-Z0-9]{32,}|(?:sk|rk)_(?:live|test)_[a-zA-Z0-9]{20,}|AKIA[0-9A-Z]{16}|github_pat_[A-Za-z0-9_]{22,}|xoxb-[a-zA-Z0-9-]+|ghp_[a-zA-Z0-9]{36,}/gi,
-        severity: 'critical',
-        category: 'Secrets',
-        description: 'Hardcoded API key / secret (Anthropic, OpenAI, Stripe, AWS, GitHub, Slack)',
-        cwe: 'CWE-798',
-        scanRaw: true,
-    },
-    {
-        // A hardcoded PRIVATE KEY block in source is among the worst possible leaks,
-        // and trust was blind to it (cycle 10 dogfood) — the existing key rule only
-        // flags READING a .pem/.ssh file, not an inline -----BEGIN … PRIVATE KEY-----.
-        regex: /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY(?: BLOCK)?-----/gi,
-        severity: 'critical',
-        category: 'Secrets',
-        description: 'Hardcoded private key (PEM block)',
-        cwe: 'CWE-798',
-        scanRaw: true,
-    },
-    // SQL Injection (scan with strings visible — SQL lives inside string literals)
-    // Per-quote-type to allow inner quotes: "SELECT...WHERE name='" + user
-    {
-        regex: /"[^"]*SELECT[^"]*FROM[^"]*WHERE[^"]*"\s*\+/gi,
-        severity: 'critical',
-        category: 'SQL Injection',
-        description: 'SQL query built with string concatenation (double-quoted)',
-        cwe: 'CWE-89',
-        scanRaw: true,
-    },
-    {
-        regex: /'[^']*SELECT[^']*FROM[^']*WHERE[^']*'\s*\+/gi,
-        severity: 'critical',
-        category: 'SQL Injection',
-        description: 'SQL query built with string concatenation (single-quoted)',
-        cwe: 'CWE-89',
-        scanRaw: true,
-    },
-    // Require a SQL keyword inside the interpolated string — otherwise this
-    // matches any `query("prompt with ${x}")` (handleQuery, graphql.query, etc.)
-    {
-        regex: /query\s*\(\s*['"`][^'"`]*\b(?:SELECT|INSERT|UPDATE|DELETE|WHERE|FROM)\b[^'"`]*\$\{|execute\s*\([`'"]\s*SELECT.*\$\{/gi,
-        severity: 'critical',
-        category: 'SQL Injection',
-        description: 'String interpolation in SQL query',
-        cwe: 'CWE-89',
-        scanRaw: true,
-    },
-    {
-        regex: /pool\.query\s*\([^,)]*\+[^,)]*\)/g,
-        severity: 'high',
-        category: 'SQL Injection',
-        description: 'String concatenation in SQL query call',
-        cwe: 'CWE-89',
-    },
-    // SQL built in a template literal — catches the case the `query(...)` pattern above misses:
-    // the query is assigned to a variable first (`const q = `SELECT...${x}``) then passed to query(q).
-    // Anchored on real SQL shape (SELECT…FROM / INSERT…INTO / UPDATE…SET / DELETE…FROM) to stay low-noise.
-    {
-        regex: /`[^`]*\b(?:SELECT\b[^`]*\bFROM|INSERT\b[^`]*\bINTO|UPDATE\b[^`]*\bSET|DELETE\b[^`]*\bFROM)\b[^`]*\$\{/gi,
-        severity: 'critical',
-        category: 'SQL Injection',
-        description: 'SQL query built in a template literal with interpolation',
-        cwe: 'CWE-89',
-        scanRaw: true,
-    },
-    // Command injection with user input (scan with strings visible)
-    // Catches require('child_process').execSync(req.body.cmd) — child_process is in a string
-    // but the method call and req. reference are in plain code
-    {
-        regex: /\.exec(?:Sync)?\s*\(\s*req\./gi,
-        severity: 'critical',
-        category: 'Command Injection',
-        description: 'exec/execSync called directly with request input',
-        cwe: 'CWE-78',
-        scanRaw: true,
-    },
-    // Injection (scan fully stripped — structural, must not trigger on pattern defs or comments)
-    {
-        regex: /\beval\s*\(/g,
-        severity: 'critical',
-        category: 'Code Injection',
-        description: 'eval() allows arbitrary code execution',
-        cwe: 'CWE-95',
-    },
-    {
-        regex: /new\s+Function\s*\(/g,
-        severity: 'critical',
-        category: 'Code Injection',
-        description: 'Function() constructor execution',
-        cwe: 'CWE-95',
-    },
-    {
-        regex: /child_process\.exec(?:Sync)?\s*\(\s*[^,)'"]*(?:req\.|body\.|params\.|query\.)/g,
-        severity: 'critical',
-        category: 'Command Injection',
-        description: 'execSync/exec with user-controlled input',
-        cwe: 'CWE-78',
-    },
-    {
-        regex: /child_process\.exec\s*\(\s*[^,)]*\+/g,
-        severity: 'critical',
-        category: 'Command Injection',
-        description: 'Command injection via string concat',
-        cwe: 'CWE-78',
-    },
-    // Destructured exec/execSync with string concat containing user input
-    {
-        regex: /\bexec(?:Sync)?\s*\([^)]*\+\s*req\./g,
-        severity: 'critical',
-        category: 'Command Injection',
-        description: 'exec() with string concatenation of user input',
-        cwe: 'CWE-78',
-        scanRaw: true,
-    },
-    {
-        regex: /\.innerHTML\s*=\s*[^=]/g,
-        severity: 'high',
-        category: 'XSS',
-        description: 'innerHTML assignment (potential XSS)',
-        cwe: 'CWE-79',
-    },
-    {
-        regex: /document\.write\s*\(/g,
-        severity: 'high',
-        category: 'XSS',
-        description: 'document.write can lead to XSS',
-        cwe: 'CWE-79',
-    },
-    // Insecure deserialization
-    {
-        regex: /JSON\.parse\s*\([^)]*req\.|JSON\.parse\s*\([^)]*input/gi,
-        severity: 'medium',
-        category: 'Insecure Input',
-        description: 'JSON.parse on unvalidated user input',
-        cwe: 'CWE-502',
-    },
-    {
-        regex: /yaml\.load\s*\([^)]*\)/g,
-        severity: 'high',
-        category: 'Insecure Deserialization',
-        description: 'yaml.load without safeLoad',
-        cwe: 'CWE-502',
-    },
-    {
-        regex: /pickle\.loads\s*\(/g,
-        severity: 'critical',
-        category: 'Insecure Deserialization',
-        description: 'pickle.loads on arbitrary data',
-        cwe: 'CWE-502',
-    },
-    // Auth issues
-    {
-        regex: /jwt\.verify\s*\([^,)]+,\s*[^,)]+,\s*\{\s*algorithms\s*:\s*\[\s*['"`]none['"`]/i,
-        severity: 'critical',
-        category: 'Auth Bypass',
-        description: 'JWT algorithm:none vulnerability',
-        cwe: 'CWE-347',
-    },
-    {
-        regex: /password\s*===?\s*['"`]|password\s*==\s*req\./gi,
-        severity: 'high',
-        category: 'Auth Bypass',
-        description: 'Plaintext password comparison',
-        cwe: 'CWE-256',
-    },
-    // Weak crypto
-    {
-        regex: /Math\.random\s*\(\s*\).*(?:token|key|secret|password|nonce|salt)/gi,
-        severity: 'high',
-        category: 'Weak Crypto',
-        description: 'Math.random() for security-sensitive value',
-        cwe: 'CWE-338',
-    },
-    {
-        regex: /createCipheriv\s*\([^,]*['"`](?:des|rc4|md5)[^'"]*['"`]/gi,
-        severity: 'high',
-        category: 'Weak Crypto',
-        description: 'Weak/deprecated cipher algorithm',
-        cwe: 'CWE-327',
-    },
-    // Path traversal
-    {
-        regex: /readFile\s*\([^)]*req\.|readFileSync\s*\([^)]*user/gi,
-        severity: 'high',
-        category: 'Path Traversal',
-        description: 'File read with user-controlled path',
-        cwe: 'CWE-22',
-    },
-    {
-        regex: /__dirname\s*\+\s*['"`/]*\s*\+?\s*req\.(params|query|body)/gi,
-        severity: 'high',
-        category: 'Path Traversal',
-        description: 'Path built from user input without sanitization',
-        cwe: 'CWE-22',
-    },
-    {
-        regex: /sendFile\s*\([^)]*req\.(params|query|body)/gi,
-        severity: 'high',
-        category: 'Path Traversal',
-        description: 'sendFile with user-controlled path',
-        cwe: 'CWE-22',
-    },
-    // Open redirect
-    {
-        regex: /res\.redirect\s*\([^)]*req\.(query|body|params)/gi,
-        severity: 'medium',
-        category: 'Open Redirect',
-        description: 'Redirect to user-controlled URL',
-        cwe: 'CWE-601',
-    },
-    // Server-side XSS (template injection in response)
-    {
-        regex: /res\.send\s*\(\s*`[^`]*\$\{[^}]*req\.(query|body|params)/gi,
-        severity: 'high',
-        category: 'XSS',
-        description: 'User input interpolated directly into response HTML',
-        cwe: 'CWE-79',
-        scanRaw: true,
-    },
-    {
-        regex: /res\.send\s*\([^)]*\+\s*req\.(query|body|params)/gi,
-        severity: 'high',
-        category: 'XSS',
-        description: 'User input concatenated into response',
-        cwe: 'CWE-79',
-        scanRaw: true,
-    },
-    // Command injection via variable indirection (exec with non-literal arg).
-    // Gated: only fires if file references child_process — otherwise regex.exec(str)
-    // lights up every bundled highlight.js / parser in the ecosystem.
-    // requiresContext must match an actual import, not the literal string
-    // child_process (which this scanner file itself contains as pattern data).
-    {
-        // Capture an optional receiver (group 1) so matchFilter can check it:
-        //   cp.exec(cmd)  → receiver "cp"   |  exec(cmd) → no receiver  |  g.exec(s) → "g"
-        regex: /(?:\b(\w+)\s*\.\s*)?\bexec(?:Sync)?\s*\(\s*(?!['"`])(\w+)\s*[,)]/g,
-        severity: 'high',
-        category: 'Command Injection',
-        description: 'exec() called with variable argument — verify input is not user-controlled',
-        cwe: 'CWE-78',
-        requiresContext: /(?:from|require\()\s*['"](?:node:)?child_process['"]/,
-        // Only a real child_process call counts: a method call on the imported
-        // child_process binding, or a bare exec() when exec was named-imported.
-        // A method call on anything else (a RegExp, a parser, …) is not.
-        matchFilter: (m, src) => {
-            const receiver = m[1];
-            const b = childProcessBindings(src);
-            return receiver === undefined ? b.namedExec : b.namespaceAliases.has(receiver);
-        },
-    },
-    // SSRF
-    {
-        regex: /fetch\s*\(\s*req\.(body|query|params)/gi,
-        severity: 'high',
-        category: 'SSRF',
-        description: 'Server-side request to user-controlled URL',
-        cwe: 'CWE-918',
-    },
-    {
-        regex: /axios\s*\.\s*(?:get|post|put|delete)\s*\(\s*req\.(body|query|params)/gi,
-        severity: 'high',
-        category: 'SSRF',
-        description: 'HTTP request to user-controlled URL',
-        cwe: 'CWE-918',
-    },
-    // Weak crypto (MD5, SHA1 for passwords)
-    {
-        regex: /createHash\s*\(\s*['"`]md5['"`]\s*\)/gi,
-        severity: 'high',
-        category: 'Weak Crypto',
-        description: 'MD5 hash is cryptographically broken — use bcrypt/argon2 for passwords',
-        cwe: 'CWE-328',
-        scanRaw: true,
-    },
-    {
-        regex: /createHash\s*\(\s*['"`]sha1['"`]\s*\)/gi,
-        severity: 'medium',
-        category: 'Weak Crypto',
-        description: 'SHA1 is deprecated for security use — use SHA-256+ or bcrypt',
-        cwe: 'CWE-328',
-        scanRaw: true,
-    },
-    // JWT algorithm:none (both sign and verify — scan raw to catch string content)
-    {
-        regex: /jwt\.(?:sign|verify)\s*\([^)]*algorithm\s*:\s*['"`]none['"`]/gi,
-        severity: 'critical',
-        category: 'Auth Bypass',
-        description: 'JWT with algorithm "none" disables signature verification',
-        cwe: 'CWE-347',
-        scanRaw: true,
-    },
-    // Secret-file read / exfiltration. Code that touches a private key, cloud
-    // credential, or system password file is almost always exfil or theft.
-    // dogfood 2026-05-27 Phase F: reading ~/.ssh/id_rsa was a false-negative on a
-    // product that claims a trust score on every file. scanRaw — the path lives
-    // inside a string literal. Tight path set keeps false positives near zero.
-    {
-        regex: /(?:\.ssh\/id_(?:rsa|dsa|ecdsa|ed25519)|(?:^|[^\w])id_(?:rsa|ed25519)\b|\.aws\/credentials|\.config\/gcloud\/|\.kube\/config|\.docker\/config\.json|\/etc\/shadow|\.npmrc\b|\.pem['"`])/gi,
-        severity: 'critical',
-        category: 'Secret Exfiltration',
-        description: 'Reads a private key or credential file — likely secret exfiltration',
-        cwe: 'CWE-522',
-        scanRaw: true,
-    },
-    // Destructive shell command. `rm -rf` in agent-written code is worth flagging
-    // even when it looks scoped — a stray variable or trailing slash turns it into
-    // a filesystem wipe. dogfood 2026-05-27 Phase F named this a false-negative.
-    // The runtime PreToolUse hook also blocks the worst forms at execution time;
-    // this is the static signal on the file itself. scanRaw — the command is a
-    // string literal.
-    {
-        regex: /rm\s+-[a-z]*r[a-z]*f|rm\s+-[a-z]*f[a-z]*r/gi,
-        severity: 'high',
-        category: 'Destructive Operation',
-        description: 'Recursive force-delete (rm -rf) — verify the target can never be empty or a parent path',
-        cwe: 'CWE-78',
-        scanRaw: true,
-    },
-    {
-        // rm -rf targeting root, a home glob, or a variable/concatenation → wipe risk.
-        regex: /rm\s+-[a-z]*[rf][a-z]*\s+(?:\/(?:\s|$|["'`])|~|\$\{?\w|["'`][^"'`]*["'`]\s*\+|\.\.)/gi,
-        severity: 'critical',
-        category: 'Destructive Operation',
-        description: 'rm -rf targeting root, home, or a dynamic path — can wipe unintended files',
-        cwe: 'CWE-78',
-        scanRaw: true,
-    },
-];
-export function measureComplexity(code) {
-    const lines = code.split('\n').length;
-    const functionMatches = code.match(/\b(function\s+\w+|=>\s*\{|\basync\s+function|\bclass\s+\w+)/g);
-    const functions = functionMatches?.length ?? 0;
-    const branchKeywords = code.match(/\b(if|else\s+if|while|for|switch|case|catch|\?\s*:)/g);
-    const cyclomaticEstimate = (branchKeywords?.length ?? 0) + 1;
-    let depth = 0, maxDepth = 0;
-    for (const char of code) {
-        if (char === '{') {
-            depth++;
-            maxDepth = Math.max(maxDepth, depth);
-        }
-        if (char === '}')
-            depth = Math.max(0, depth - 1);
-    }
-    const todos = (code.match(/\/\/\s*(TODO|FIXME|HACK|XXX)/gi) ?? []).length;
-    return { lines, functions, nestingDepth: maxDepth, cyclomaticEstimate, todos };
-}
-// ── Scoring ───────────────────────────────────────────────────────────────────
-const SEVERITY_PENALTY = {
-    critical: 25,
-    high: 12,
-    medium: 5,
-    low: 2,
-};
-/**
- * Returns true if the character at position `pos` follows an expression-start
- * context (i.e., `/` here opens a regex literal, not a division operator).
- */
-function isRegexStart(code, pos) {
-    let j = pos - 1;
-    while (j >= 0 && (code[j] === ' ' || code[j] === '\t'))
-        j--;
-    if (j < 0)
-        return true;
-    const prev = code[j];
-    return ('=([{,;!&|?:~^%+->'.includes(prev) ||
-        /\b(return|typeof|instanceof|in|new|delete|void|throw|case)\s*$/.test(code.slice(0, pos).trimEnd()));
-}
-/**
- * Strip ONLY comments and regex literals — string literals remain visible.
- * Used for pass 1 (raw pattern scanning): we need to see inside string literals to find
- * hardcoded secrets and SQL injection, but comments/regex literals that contain
- * example patterns would otherwise cause false positives.
- */
-function stripCommentsAndRegex(code) {
-    const out = [];
-    let i = 0;
-    const len = code.length;
-    while (i < len) {
-        const ch = code[i];
-        const next = code[i + 1];
-        // Single-line comment: // ...
-        if (ch === '/' && next === '/') {
-            const start = i;
-            while (i < len && code[i] !== '\n')
-                i++;
-            out.push(' '.repeat(i - start));
-            continue;
-        }
-        // Block comment: /* ... */
-        if (ch === '/' && next === '*') {
-            const start = i;
-            i += 2;
-            while (i < len && !(code[i - 1] === '*' && code[i] === '/'))
-                i++;
-            i++;
-            out.push(' '.repeat(i - start));
-            continue;
-        }
-        // Regex literal: /.../ — strip to avoid pattern-def false positives
-        if (ch === '/' && next !== '/' && next !== '*' && isRegexStart(code, i)) {
-            const start = i;
-            i++;
-            while (i < len && code[i] !== '/' && code[i] !== '\n') {
-                if (code[i] === '\\')
-                    i++;
-                if (code[i] === '[') {
-                    i++;
-                    while (i < len && code[i] !== ']') {
-                        if (code[i] === '\\')
-                            i++;
-                        i++;
-                    }
-                }
-                i++;
-            }
-            i++;
-            while (i < len && 'gimsuy'.includes(code[i]))
-                i++;
-            out.push(' '.repeat(i - start));
-            continue;
-        }
-        // String literals — pass through (needed to detect secrets/SQL inside them)
-        out.push(ch);
-        i++;
-    }
-    return out.join('');
-}
-/**
- * Fully strip all string literals, regex literals, and comments.
- * Used for pass 2 (structural pattern scanning) to avoid false positives
- * from pattern definitions, example code in strings, etc.
- */
-function stripLiterals(code) {
-    const out = [];
-    let i = 0;
-    const len = code.length;
-    while (i < len) {
-        const ch = code[i];
-        const next = code[i + 1];
-        if (ch === '/' && next === '/') {
-            const start = i;
-            while (i < len && code[i] !== '\n')
-                i++;
-            out.push(' '.repeat(i - start));
-            continue;
-        }
-        if (ch === '/' && next === '*') {
-            const start = i;
-            i += 2;
-            while (i < len && !(code[i - 1] === '*' && code[i] === '/'))
-                i++;
-            i++;
-            out.push(' '.repeat(i - start));
-            continue;
-        }
-        if (ch === '/' && next !== '/' && next !== '*' && isRegexStart(code, i)) {
-            const start = i;
-            i++;
-            while (i < len && code[i] !== '/' && code[i] !== '\n') {
-                if (code[i] === '\\')
-                    i++;
-                if (code[i] === '[') {
-                    i++;
-                    while (i < len && code[i] !== ']') {
-                        if (code[i] === '\\')
-                            i++;
-                        i++;
-                    }
-                }
-                i++;
-            }
-            i++;
-            while (i < len && 'gimsuy'.includes(code[i]))
-                i++;
-            out.push(' '.repeat(i - start));
-            continue;
-        }
-        if (ch === '`') {
-            const start = i;
-            i++;
-            while (i < len && code[i] !== '`') {
-                if (code[i] === '\\')
-                    i++;
-                i++;
-            }
-            i++;
-            out.push(' '.repeat(i - start));
-            continue;
-        }
-        if (ch === '"') {
-            const start = i;
-            i++;
-            while (i < len && code[i] !== '"' && code[i] !== '\n') {
-                if (code[i] === '\\')
-                    i++;
-                i++;
-            }
-            i++;
-            out.push(' '.repeat(i - start));
-            continue;
-        }
-        if (ch === "'") {
-            const start = i;
-            i++;
-            while (i < len && code[i] !== "'" && code[i] !== '\n') {
-                if (code[i] === '\\')
-                    i++;
-                i++;
-            }
-            i++;
-            out.push(' '.repeat(i - start));
-            continue;
-        }
-        out.push(ch);
-        i++;
-    }
-    return out.join('');
-}
-/**
- * Public-by-design credential patterns — not secrets, should not flag.
- * Firebase web API keys: Google documents these as safe to expose (security is via Firebase Rules).
- * Stripe publishable keys: meant to be used in client code (pk_test_, pk_live_).
- * Supabase anon keys: public by design when used with row-level security.
- */
-const PUBLIC_KEY_SIGNATURES = [
-    /AIzaSy[A-Za-z0-9_-]{33}/, // Firebase / Google Cloud web API key
-    /pk_(?:test|live)_[A-Za-z0-9]{20,}/, // Stripe publishable key
-];
-function isKnownPublicKey(matched) {
-    if (!matched)
-        return false;
-    return PUBLIC_KEY_SIGNATURES.some((re) => re.test(matched));
-}
-export function scoreFile(filepath, code) {
-    const allFindings = [];
-    // Pass 1: Comments+regex stripped but strings visible — catches secrets/SQL inside literals
-    const rawForSecrets = stripCommentsAndRegex(code);
-    for (const pattern of CODE_PATTERNS.filter((p) => p.scanRaw)) {
-        let match;
-        const re = new RegExp(pattern.regex.source, pattern.regex.flags);
-        while ((match = re.exec(rawForSecrets)) !== null) {
-            const matched = match[0].substring(0, 80);
-            // Skip known public-by-design keys (Firebase, Stripe publishable, etc.)
-            if (pattern.category === 'Secrets' && isKnownPublicKey(matched)) {
-                if (!re.global)
-                    break;
-                continue;
-            }
-            const line = code.substring(0, match.index).split('\n').length;
-            allFindings.push({
-                severity: pattern.severity,
-                category: pattern.category,
-                description: pattern.description,
-                line,
-                cwe: pattern.cwe,
-                matched,
-            });
-            if (!re.global)
-                break;
-        }
-    }
-    // Pass 2: Fully stripped code — structural patterns (no false positives from literals)
-    const scannable = stripLiterals(code);
-    // Context gate test: use comment-stripped source so `// require('child_process')`
-    // in a comment doesn't count as real usage. Strings still visible so actual
-    // imports like `from 'child_process'` still match.
-    const contextTarget = rawForSecrets;
-    for (const pattern of CODE_PATTERNS.filter((p) => !p.scanRaw)) {
-        // Context gate: skip pattern if the file doesn't have the required context
-        // (e.g., .exec(var) only fires if the file uses child_process).
-        if (pattern.requiresContext && !pattern.requiresContext.test(contextTarget)) {
-            continue;
-        }
-        let match;
-        const re = new RegExp(pattern.regex.source, pattern.regex.flags);
-        while ((match = re.exec(scannable)) !== null) {
-            if (pattern.matchFilter && !pattern.matchFilter(match, contextTarget)) {
-                if (!re.global)
-                    break;
-                continue;
-            }
-            const line = code.substring(0, match.index).split('\n').length;
-            allFindings.push({
-                severity: pattern.severity,
-                category: pattern.category,
-                description: pattern.description,
-                line,
-                cwe: pattern.cwe,
-            });
-            if (!re.global)
-                break;
-        }
-    }
-    // Pass 3 (removed): hook-layer instruction patterns are designed for runtime
-    // tool_input JSON, not source code. Firing them on source lit up every docstring
-    // containing phrases like "act as a flag". The hook handler still uses scanPayload
-    // directly; source scanning stays with Pass 1 + Pass 2 only.
-    const complexity = measureComplexity(code);
-    let penalty = 0;
-    for (const f of allFindings)
-        penalty += SEVERITY_PENALTY[f.severity] ?? 2;
-    if (complexity.cyclomaticEstimate > 20)
-        penalty += 5;
-    if (complexity.cyclomaticEstimate > 50)
-        penalty += 10;
-    if (complexity.nestingDepth > 6)
-        penalty += 5;
-    if (complexity.todos > 5)
-        penalty += 3;
-    const score = Math.max(0, Math.min(100, 100 - penalty));
-    const critical = allFindings.filter((f) => f.severity === 'critical').length;
-    const high = allFindings.filter((f) => f.severity === 'high').length;
-    // Honesty floor (It-0 finding): a file with a CRITICAL finding cannot read as
-    // a passing grade — eval(userInput) + a hardcoded key scoring "B 75/100" is
-    // the optimistic-average lie. A critical caps the grade at F; a high (no
-    // critical) caps it at C. The numeric score still shows the gradient below.
-    let grade = score >= 90 ? 'A' : score >= 75 ? 'B' : score >= 60 ? 'C' : score >= 40 ? 'D' : 'F';
-    if (critical > 0)
-        grade = 'F';
-    else if (high > 0 && (grade === 'A' || grade === 'B'))
-        grade = 'C';
-    const summary = critical > 0
-        ? `${critical} critical issue${critical > 1 ? 's' : ''} require immediate attention`
-        : high > 0
-            ? `${high} high-severity issue${high > 1 ? 's' : ''} should be addressed before merge`
-            : allFindings.length === 0
-                ? 'No issues found — clean scan'
-                : `${allFindings.length} minor issue${allFindings.length > 1 ? 's' : ''} found`;
-    return { filepath, score, grade, findings: allFindings, complexity, summary };
-}
-export function gradeFromScore(score) {
-    return score >= 90 ? 'A' : score >= 75 ? 'B' : score >= 60 ? 'C' : score >= 40 ? 'D' : 'F';
-}
-/**
- * S8 · the ONE project-level aggregation. `trust`, `trust --badge`, and
- * `report` all derive the headline score + grade from here — each command
- * used to re-implement this reduce-and-cap block (the same drift that
- * historically hit the file-collection rules), and the badge could disagree
- * with the report for the same target. Same inputs → same number,
- * structurally.
- */
-export function aggregateTrust(results) {
-    const count = (sev) => results.reduce((s, r) => s + r.findings.filter((f) => f.severity === sev).length, 0);
-    const criticalCount = count('critical');
-    const highCount = count('high');
-    const mediumCount = count('medium');
-    const lowCount = count('low');
-    const totalFindings = results.reduce((s, r) => s + r.findings.length, 0);
-    const overallScore = results.length > 0 ? Math.round(results.reduce((s, r) => s + r.score, 0) / results.length) : 100;
-    // Honesty floor (It-0): a scan with any CRITICAL finding can't read as a
-    // passing grade — eval()/hardcoded-key scoring "B" is the optimistic-average
-    // lie. Critical → F; high (no critical) → no better than C. Score still
-    // shows the gradient.
-    let grade = overallScore >= 90 ? 'A' : overallScore >= 75 ? 'B' : overallScore >= 60 ? 'C' : overallScore >= 40 ? 'D' : 'F';
-    if (criticalCount > 0)
-        grade = 'F';
-    else if (highCount > 0 && (grade === 'A' || grade === 'B'))
-        grade = 'C';
-    return { overallScore, grade, criticalCount, highCount, mediumCount, lowCount, totalFindings };
-}
-//# sourceMappingURL=trust-scorer.js.map