srclawyer 0.4.1 → 0.6.0

package/dist/engine/scanEngine.js

@@ -4,10 +4,13 @@ import { discoverProjects } from "./discoverProjects.js";
 import { discoverFiles } from "./discoverFiles.js";
 import { detectUnsupportedStack } from "./languageDetection.js";
 import { parseSource } from "./astUtils.js";
+import { parsePythonSource } from "./pythonAstUtils.js";
 import { runSdkRules } from "../rules/sdkRules.js";
 import { runFrameworkRules } from "../rules/frameworkRules.js";
 import { runWebApiRules } from "../rules/webApiRules.js";
 import { runTypedRequestBodyRules } from "../rules/typedRequestBodyRules.js";
+import { runPythonSdkRules } from "../rules/pythonSdkRules.js";
+import { runPythonFrameworkRules } from "../rules/pythonFrameworkRules.js";
 import { findZodCandidates } from "../rules/zodPreFilter.js";
 import { buildTsProject } from "./tsProject.js";
 import { runHtmlInputRules, extractInlineScripts } from "../rules/htmlRules.js";
@@ -34,9 +37,11 @@ function makeLazyTsProject(files) {
         return handle;
     };
 }
-function runCodeRules(filePath, source, root, getTsProject, zodCandidates) {
+function runCodeRules(filePath, source, root, getTsProject, zodCandidates, oversizedZodFiles) {
     const ast = parseSource(source, filePath);
-    zodCandidates.push(...findZodCandidates(source, filePath, root));
+    const zodResult = findZodCandidates(source, filePath, root);
+    zodCandidates.push(...zodResult.candidates);
+    oversizedZodFiles.push(...zodResult.oversizedFiles);
     if (!ast)
         return [];
     return [
@@ -46,6 +51,12 @@ function runCodeRules(filePath, source, root, getTsProject, zodCandidates) {
         ...runTypedRequestBodyRules(ast, filePath, source, root, getTsProject),
     ];
 }
+async function runPythonCodeRules(filePath, source, root) {
+    const tree = await parsePythonSource(source);
+    if (!tree)
+        return [];
+    return [...runPythonSdkRules(tree, filePath, source, root), ...runPythonFrameworkRules(tree, filePath, source, root)];
+}
 /**
  * Pure, local, offline — no network access anywhere in this function or anything it calls. Zod
  * schemas and confidence scoring can no longer be fully resolved here (see pendingZodCandidates and
@@ -59,10 +70,12 @@ export async function scan(root) {
     const [projects, unsupportedStackWarning] = await Promise.all([discoverProjects(root), detectUnsupportedStack(root)]);
     const findings = [];
     const pendingZodCandidates = [];
+    const oversizedZodFiles = [];
     let filesScanned = 0;
     const projectRootList = [...new Set(projects.map((p) => p.root))];
     const fileSets = await Promise.all(projectRootList.map((projectRoot) => discoverFiles(projectRoot)));
     const allCodeFiles = new Set();
+    const allPythonFiles = new Set();
     const allHtmlFiles = new Set();
     const allSchemaFiles = new Set();
     const rootForFile = new Map();
@@ -74,6 +87,7 @@ export async function scan(root) {
             allCodeFiles.add(f);
             rootForFile.set(f, projectRoot);
         });
+        set.pythonFiles.forEach((f) => allPythonFiles.add(f));
         set.htmlFiles.forEach((f) => allHtmlFiles.add(f));
         set.schemaFiles.forEach((f) => allSchemaFiles.add(f));
     });
@@ -90,7 +104,18 @@ export async function scan(root) {
             continue;
         }
         const getTsProject = tsProjectByRoot.get(rootForFile.get(filePath) ?? "") ?? noTsProject;
-        findings.push(...runCodeRules(filePath, source, root, getTsProject, pendingZodCandidates));
+        findings.push(...runCodeRules(filePath, source, root, getTsProject, pendingZodCandidates, oversizedZodFiles));
+    }
+    for (const filePath of allPythonFiles) {
+        filesScanned += 1;
+        let source;
+        try {
+            source = readFileSync(filePath, "utf8");
+        }
+        catch {
+            continue;
+        }
+        findings.push(...(await runPythonCodeRules(filePath, source, root)));
     }
     for (const filePath of allHtmlFiles) {
         filesScanned += 1;
@@ -103,7 +128,7 @@ export async function scan(root) {
         }
         findings.push(...runHtmlInputRules(html, filePath, root));
         for (const script of extractInlineScripts(html)) {
-            findings.push(...runCodeRules(filePath, script.code, root, noTsProject, pendingZodCandidates));
+            findings.push(...runCodeRules(filePath, script.code, root, noTsProject, pendingZodCandidates, oversizedZodFiles));
         }
     }
     for (const filePath of allSchemaFiles) {
@@ -126,5 +151,17 @@ export async function scan(root) {
         }
     }
     const ambiguousCount = findings.filter((f) => f.requiresReview).length;
-    return { projects, findings, ambiguousCount, filesScanned, unsupportedStackWarning, pendingZodCandidates };
+    const maxZodFragmentBytes = pendingZodCandidates.length
+        ? Math.max(...pendingZodCandidates.map((c) => Buffer.byteLength(c.codeFragment, "utf8")))
+        : 0;
+    return {
+        projects,
+        findings,
+        ambiguousCount,
+        filesScanned,
+        unsupportedStackWarning,
+        pendingZodCandidates,
+        oversizedZodFiles,
+        maxZodFragmentBytes,
+    };
 }

package/dist/engine/types.d.ts

@@ -68,4 +68,13 @@ export interface ScanResult {
         codeFragment: string;
         fragmentLineToSourceLine: number[];
     }>;
+    /** Relative paths of files whose extracted Zod fragment was too large to send safely and was
+     *  dropped before ever reaching pendingZodCandidates -- surfaced in resolveProtectedLogic()'s
+     *  warning so a schema going unchecked is never silent, just like a failed network call is. */
+    oversizedZodFiles: string[];
+    /** The largest pendingZodCandidates fragment's byte size this scan, or 0 if none. Logged by the
+     *  caller so real-world fragment sizes keep being observed against MAX_FRAGMENT_BYTES
+     *  (zodPreFilter.ts) and the batching cap (protectedLogicClient.ts) -- both are provisional,
+     *  unvalidated against the Worker's real limit until its plan upgrade is confirmed. */
+    maxZodFragmentBytes: number;
 }

package/dist/grammars/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Max Brunsfeld
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/llm/resolveProviderForTier.d.ts

@@ -1,3 +1,3 @@
-import type { SrcLawyerConfig } from "../config/config.js";
+import { type SrcLawyerConfig } from "../config/config.js";
 import type { ProviderResolution } from "./types.js";
 export declare function resolveProviderForTier(config: SrcLawyerConfig): ProviderResolution;

package/dist/llm/resolveProviderForTier.js

@@ -1,3 +1,4 @@
+import { CONFIG_FILENAME } from "../config/config.js";
 import { AnthropicProvider } from "./anthropicProvider.js";
 export function resolveProviderForTier(config) {
     const tier = config.tier ?? "free";
@@ -9,7 +10,7 @@ export function resolveProviderForTier(config) {
         if (!envVar) {
             return {
                 provider: null,
-                error: 'Tier is "byok" but no API key environment variable is configured in .privacypolicy.yml. Run "srclawyer init" to set one.',
+                error: `Tier is "byok" but no API key environment variable is configured in ${CONFIG_FILENAME}. Run "srclawyer init" to set one.`,
             };
         }
         const apiKey = process.env[envVar];
@@ -27,5 +28,5 @@ export function resolveProviderForTier(config) {
             error: 'Tier is "managed" but SrcLawyer\'s managed backend is not available yet. Use "byok" with your own Anthropic API key, or "free".',
         };
     }
-    return { provider: null, error: `Unknown tier "${tier}" in .privacypolicy.yml.` };
+    return { provider: null, error: `Unknown tier "${tier}" in ${CONFIG_FILENAME}.` };
 }

package/dist/policy/generatePolicy.d.ts

@@ -1,3 +1,3 @@
 import type { ScanResult } from "../engine/types.js";
-import type { SrcLawyerConfig } from "../config/config.js";
-export declare function generatePolicyMarkdown(result: ScanResult, config: SrcLawyerConfig | null, llmError?: string | null): string;
+import { type SrcLawyerConfig } from "../config/config.js";
+export declare function generatePolicyMarkdown(result: ScanResult, config: SrcLawyerConfig | null, llmError?: string | null, protectedLogicWarning?: string | null): string;

package/dist/policy/generatePolicy.js

@@ -1,3 +1,4 @@
+import { CONFIG_FILENAME } from "../config/config.js";
 import { DATA_CATEGORY_LABELS } from "./dataCategoryLabels.js";
 import { MANDATORY_DISCLAIMER } from "./disclaimer.js";
 function locationRef(finding) {
@@ -88,7 +89,7 @@ function renderContextSection(config) {
         return [
             "## Scope",
             "",
-            "No `.privacypolicy.yml` configuration was found, so this policy was generated without jurisdiction, target-market, or industry context. Run `srclawyer init` and re-run `srclawyer scan` to include that context.",
+            `No \`${CONFIG_FILENAME}\` configuration was found, so this policy was generated without jurisdiction, target-market, or industry context. Run \`srclawyer init\` and re-run \`srclawyer scan\` to include that context.`,
         ].join("\n");
     }
     const lines = ["## Scope", ""];
@@ -101,6 +102,12 @@ function renderContextSection(config) {
 function renderUnsupportedStackWarning(warning) {
     return ["> **WARNING: INCOMPLETE SCAN — DO NOT PUBLISH WITHOUT MANUAL REVIEW**", ">", `> ${warning}`].join("\n");
 }
+// Mirrors renderUnsupportedStackWarning's own reasoning exactly: this policy FILE gets committed and
+// shared on its own, without the CLI output that already shows this warning -- a reader of the file
+// alone has no other way to know confidence grading or Zod-schema detection didn't run for this scan.
+function renderProtectedLogicWarning(warning) {
+    return ["> **WARNING: PROTECTED-LOGIC SERVICE UNAVAILABLE — POLICY MAY BE INCOMPLETE**", ">", `> ${warning}`].join("\n");
+}
 function outcomeOf(finding) {
     if (!finding.requiresReview)
         return "confident";
@@ -110,7 +117,7 @@ function outcomeOf(finding) {
         return "declined";
     return "unresolved";
 }
-export function generatePolicyMarkdown(result, config, llmError) {
+export function generatePolicyMarkdown(result, config, llmError, protectedLogicWarning) {
     const confidentFindings = result.findings.filter((f) => {
         const outcome = outcomeOf(f);
         return outcome === "confident" || outcome === "resolved";
@@ -121,6 +128,9 @@ export function generatePolicyMarkdown(result, config, llmError) {
     if (result.unsupportedStackWarning) {
         parts.push(renderUnsupportedStackWarning(result.unsupportedStackWarning), "");
     }
+    if (protectedLogicWarning) {
+        parts.push(renderProtectedLogicWarning(protectedLogicWarning), "");
+    }
     if (llmError) {
         parts.push(renderLlmErrorWarning(llmError), "");
     }
@@ -129,6 +139,9 @@ export function generatePolicyMarkdown(result, config, llmError) {
     if (categorySections.length > 0) {
         parts.push(categorySections.join("\n\n"));
     }
+    else if (result.unsupportedStackWarning) {
+        parts.push("**Not analyzed:** this codebase's primary language/framework isn't supported yet (see the warning above). This is not a clean-scan result — nothing below should be read as \"no data collection found.\"");
+    }
     else {
         parts.push("No data-collection patterns were confidently identified in this codebase.");
     }

package/dist/policy/legalNotices.d.ts

@@ -0,0 +1,5 @@
+export declare const PRIVACY_POLICY_URL = "https://github.com/SrcLawyer/srclawyer#legal";
+export declare const TERMS_URL = "https://github.com/SrcLawyer/srclawyer#legal";
+export declare const NETWORK_CALLS_NOTICE: string;
+export declare const SCAN_DISCLAIMER_REMINDER = "Reminder: this is automated analysis, not legal advice \u2014 review the generated policy before publishing it.";
+export declare function byokNetworkNotice(apiKeyEnvVar: string | null): string;

package/dist/policy/legalNotices.js

@@ -0,0 +1,29 @@
+// No dedicated privacy-policy/terms site exists yet -- these point at the real, resolvable README
+// "Legal" section that covers the same ground today (not a placeholder or a dead `.invalid` link), and
+// should be repointed to a real site once one exists. Kept as named constants precisely so there's one
+// place to update when that happens -- a one-line change, not a hunt through every call site.
+//
+// Deliberately NOT labeled "Privacy policy:" / "Terms:" below: that would claim those documents exist
+// at this URL, when the Legal section itself says plainly that they don't yet -- this points at a
+// notice and disclaimer, not a substitute for either.
+export const PRIVACY_POLICY_URL = "https://github.com/SrcLawyer/srclawyer#legal";
+export const TERMS_URL = "https://github.com/SrcLawyer/srclawyer#legal";
+// Verbatim from README.md's own "Network calls" section (minus markdown backticks, since this prints
+// to a terminal) -- one wording for this claim, not a second paraphrase that can drift from the first.
+export const NETWORK_CALLS_NOTICE = [
+    "Heads up: SrcLawyer makes network calls.",
+    "",
+    "Detection itself is fully local and offline — no code leaves your machine for pattern matching.",
+    "Once detection completes, scan makes one batched network call to grade the confidence of what it",
+    "found (field names and derived yes/no signals only, never source code), and, for scans that use Zod",
+    "schemas as request validators, one additional call sending a small redacted code fragment. This runs",
+    "on every scan regardless of tier.",
+    "",
+    `Legal notice and disclaimer: ${PRIVACY_POLICY_URL}`,
+    "(A dedicated privacy policy and terms of service are coming; this points to what exists today.)",
+].join("\n");
+export const SCAN_DISCLAIMER_REMINDER = "Reminder: this is automated analysis, not legal advice — review the generated policy before publishing it.";
+export function byokNetworkNotice(apiKeyEnvVar) {
+    const keySource = apiKeyEnvVar ? `env var ${apiKeyEnvVar}` : "your configured key";
+    return `BYOK is configured: redacted code snippets for ambiguous findings will be sent to Anthropic under your own API key (${keySource}), for AI-assisted classification only.`;
+}

package/dist/report/formatText.js

@@ -38,7 +38,7 @@ export function formatText(result) {
     }
     else if (result.ambiguousCount > 0) {
         lines.push("");
-        lines.push(`${result.ambiguousCount} item(s) require deeper analysis before they can be included in a policy. Run "srclawyer scan" with a "byok"/"managed" tier configured to attempt AI-assisted resolution, or resolve manually.`);
+        lines.push(`${result.ambiguousCount} item(s) require deeper analysis before they can be included in a policy. Run "srclawyer scan" with the "byok" tier configured (bring your own Anthropic key) to attempt AI-assisted resolution, or resolve manually. A "managed" tier is planned but not yet available.`);
     }
     return lines.join("\n");
 }

package/dist/rules/dataCategoryLexicon.js

@@ -1,9 +1,15 @@
 const LEXICON = [
     { pattern: /email/i, category: "email" },
-    // Checked before the generic "name" pattern below: bank_name/account_holder_name end in
-    // "name" and would otherwise be classified as just "name", losing the payment-specific signal.
     { pattern: /bank[ _-]?name|routing[ _-]?number|account[ _-]?holder|iban|swift[ _-]?code/i, category: "payment_info" },
-    { pattern: /(full)?name$|firstname|lastname|surname/i, category: "name" },
+    // Anchored to the whole field name, not a bare "...name$" suffix match: the old pattern matched
+    // ANY field ending in "name" -- hostname, filename, directoryName, className, teamName, etc. -- none
+    // of which are a person's name. This matches only "name" itself and the known person-name
+    // decompositions (first/last/middle/maiden/nick/display/legal name, username), each allowing an
+    // optional separator (first_name, firstName, first-name). A compound this doesn't recognize falls
+    // through with no category match, landing in the same "could not confidently classify — needs
+    // review" path as any other unclassified field -- not the safe list, not a new discard path, just
+    // the existing honest-ambiguity treatment.
+    { pattern: /^(full|first|middle|last|sur|maiden|nick|display|legal)[\s_-]*name$|^name$|^user[\s_-]*name$/i, category: "name" },
     { pattern: /phone|mobile|telephone/i, category: "phone" },
     { pattern: /address|street|city|zip ?code|postal ?code/i, category: "physical_address" },
     { pattern: /card ?number|creditcard|cvv|cvc|cardholder/i, category: "payment_info" },

package/dist/rules/frameworkRules.js

@@ -18,6 +18,54 @@ function fieldsFromObjectPattern(pattern) {
     }
     return names;
 }
+function isRequestBodyMemberExpression(node) {
+    return (node.type === "MemberExpression" &&
+        !node.computed &&
+        node.object.type === "Identifier" &&
+        REQUEST_OBJECT_NAMES.test(node.object.name) &&
+        node.property.type === "Identifier" &&
+        REQUEST_BODY_PROPS.test(node.property.name));
+}
+function isAwaitedRequestJsonCall(node) {
+    return (node.type === "AwaitExpression" &&
+        node.argument.type === "CallExpression" &&
+        node.argument.callee.type === "MemberExpression" &&
+        node.argument.callee.object.type === "Identifier" &&
+        REQUEST_OBJECT_NAMES.test(node.argument.callee.object.name) &&
+        node.argument.callee.property.type === "Identifier" &&
+        node.argument.callee.property.name === "json");
+}
+/**
+ * Same-function alias tracking: `const body = req.body` (or `req.query`/`req.params`, or
+ * `await req.json()`) followed by `body.email` / `body['email']` / `const { email } = body` in the
+ * same function body. Deliberately one mechanical hop, scoped to the nearest enclosing function (or
+ * module/program scope for top-level code) via Babel's own `getFunctionParent()` -- not general
+ * dataflow: no cross-function tracking, no chained reassignment, no closures capturing an outer
+ * function's alias. Mirrors pythonFrameworkRules.ts's same-function alias tracking exactly, for the
+ * same reason: `const body = req.body; body.email` was structurally invisible before this, just like
+ * `data = request.get_json(); data['email']` was on the Python side.
+ */
+function collectRequestAliases(ast) {
+    const aliasesByScope = new Map();
+    traverse(ast, {
+        VariableDeclarator(path) {
+            const id = path.node.id;
+            const init = path.node.init;
+            if (!init || id.type !== "Identifier")
+                return;
+            if (!isRequestBodyMemberExpression(init) && !isAwaitedRequestJsonCall(init))
+                return;
+            const scope = path.getFunctionParent()?.node ?? ast.program;
+            const aliases = aliasesByScope.get(scope) ?? new Set();
+            aliases.add(id.name);
+            aliasesByScope.set(scope, aliases);
+        },
+    });
+    return aliasesByScope;
+}
+function enclosingScope(path, ast) {
+    return path.getFunctionParent()?.node ?? ast.program;
+}
 export function runFrameworkRules(ast, filePath, source, root) {
     const findings = [];
     const lines = source.split("\n");
@@ -53,24 +101,38 @@ export function runFrameworkRules(ast, filePath, source, root) {
             confidenceFactors: { lexiconCategory, ambiguousName, runtimeVerified: true, siblingConfidentCount },
         });
     }
+    const aliasesByScope = collectRequestAliases(ast);
+    const isAliasReference = (path, name) => !!aliasesByScope.get(enclosingScope(path, ast))?.has(name);
     traverse(ast, {
         MemberExpression(path) {
-            const { object, property } = path.node;
-            if (object.type !== "Identifier" || !REQUEST_OBJECT_NAMES.test(object.name))
+            const { object, property, computed } = path.node;
+            if (object.type !== "Identifier")
                 return;
-            if (property.type !== "Identifier" || !REQUEST_BODY_PROPS.test(property.name))
+            if (REQUEST_OBJECT_NAMES.test(object.name) && !computed && property.type === "Identifier" && REQUEST_BODY_PROPS.test(property.name)) {
+                const parent = path.parent;
+                if (parent.type === "MemberExpression" && parent.property.type === "Identifier") {
+                    emit(parent.property.name, parent.loc?.start.line ?? path.node.loc?.start.line ?? 1, parent);
+                    return;
+                }
+                if (parent.type === "VariableDeclarator" && parent.id.type === "ObjectPattern") {
+                    const line = parent.loc?.start.line ?? 1;
+                    const siblingFieldNames = fieldsFromObjectPattern(parent.id);
+                    for (const fieldName of siblingFieldNames) {
+                        emit(fieldName, line, parent, siblingFieldNames);
+                    }
+                }
                 return;
-            const parent = path.parent;
-            if (parent.type === "MemberExpression" && parent.property.type === "Identifier") {
-                emit(parent.property.name, parent.loc?.start.line ?? path.node.loc?.start.line ?? 1, parent);
+            }
+            // Alias reference: `body.email` or `body['email']`, where `body` was assigned from
+            // req.body/.query/.params or await req.json() earlier in the same function.
+            if (!isAliasReference(path, object.name))
                 return;
+            const line = path.node.loc?.start.line ?? 1;
+            if (!computed && property.type === "Identifier") {
+                emit(property.name, line, path.node);
             }
-            if (parent.type === "VariableDeclarator" && parent.id.type === "ObjectPattern") {
-                const line = parent.loc?.start.line ?? 1;
-                const siblingFieldNames = fieldsFromObjectPattern(parent.id);
-                for (const fieldName of siblingFieldNames) {
-                    emit(fieldName, line, parent, siblingFieldNames);
-                }
+            else if (computed && property.type === "StringLiteral") {
+                emit(property.value, line, path.node);
             }
         },
         AwaitExpression(path) {
@@ -93,6 +155,21 @@ export function runFrameworkRules(ast, filePath, source, root) {
                 }
             }
         },
+        VariableDeclarator(path) {
+            // Alias destructure: `const { email } = body`, where `body` was assigned from
+            // req.body/.query/.params or await req.json() earlier in the same function.
+            const init = path.node.init;
+            const id = path.node.id;
+            if (!init || init.type !== "Identifier" || id.type !== "ObjectPattern")
+                return;
+            if (!isAliasReference(path, init.name))
+                return;
+            const line = path.node.loc?.start.line ?? 1;
+            const siblingFieldNames = fieldsFromObjectPattern(id);
+            for (const fieldName of siblingFieldNames) {
+                emit(fieldName, line, path.node, siblingFieldNames);
+            }
+        },
     });
     return findings;
 }

package/dist/rules/pythonFrameworkRules.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from "web-tree-sitter";
+import type { Finding } from "../engine/types.js";
+export declare function runPythonFrameworkRules(tree: Tree, filePath: string, source: string, root: string): Finding[];

package/dist/rules/pythonFrameworkRules.js

@@ -0,0 +1,136 @@
+import { relative } from "node:path";
+import { classifyFieldName, isAmbiguousFieldName } from "./dataCategoryLexicon.js";
+import { isSafeFieldName } from "./safeFieldNames.js";
+import { redactSecrets } from "../engine/secretRedaction.js";
+import { countConfidentSiblings } from "./confidenceFactors.js";
+/**
+ * Flask's incoming-request accessors: request.form / request.json / request.args. Anchored to the
+ * literal name "request" rather than a configurable-name regex (unlike Express's req/request, which
+ * is a per-handler parameter that can be named anything) -- Flask's `request` is always the direct,
+ * module-level import from `flask`, used by that exact name in effectively all real code.
+ */
+const REQUEST_ATTR = /^request\.(form|json|args)$/;
+const REQUEST_GET_CALL = /^request\.(form|json|args)\.get$/;
+const REQUEST_GET_JSON_CALL = /^request\.get_json$/;
+function stringLiteralContent(node) {
+    if (!node || node.type !== "string")
+        return null;
+    return node.descendantsOfType("string_content")[0]?.text ?? null;
+}
+/** True for the RHS of `x = <this>`: request.form / .json / .args, or a request.get_json() call. */
+function isRequestDataSource(node) {
+    if (node.type === "attribute")
+        return REQUEST_ATTR.test(node.text);
+    if (node.type === "call") {
+        const fn = node.childForFieldName("function");
+        return !!fn && REQUEST_GET_JSON_CALL.test(fn.text);
+    }
+    return false;
+}
+/**
+ * The nearest enclosing function_definition's node id, or -1 for module-level code. Scoped by `.id`
+ * rather than the Node object itself -- web-tree-sitter doesn't guarantee the same underlying syntax
+ * node comes back as the same JS object identity across separate traversal calls (same `.id`, new
+ * wrapper), so using Node references as Map keys silently never matches.
+ */
+function enclosingScopeId(node) {
+    let current = node.parent;
+    while (current) {
+        if (current.type === "function_definition")
+            return current.id;
+        current = current.parent;
+    }
+    return -1;
+}
+/**
+ * Same-function alias tracking: `data = request.get_json()` (or `= request.form` / `.json` / `.args`)
+ * followed by `data['x']` / `data.get('x')` in the same function body. Deliberately one mechanical hop,
+ * scoped to the nearest enclosing function (or module level), not general dataflow -- no cross-function
+ * tracking, no chained reassignment, no branch/conditional awareness, no closures capturing an outer
+ * function's alias. This is exactly the gap the microblog golden-corpus entry documented: real signup
+ * PII read via request.get_json() into a local variable rather than a direct request.json[...] subscript.
+ */
+function collectRequestAliases(tree) {
+    const aliasesByScope = new Map();
+    for (const node of tree.rootNode.descendantsOfType("assignment")) {
+        const left = node.childForFieldName("left");
+        const right = node.childForFieldName("right");
+        if (!left || left.type !== "identifier" || !right || !isRequestDataSource(right))
+            continue;
+        const scope = enclosingScopeId(node);
+        const aliases = aliasesByScope.get(scope) ?? new Set();
+        aliases.add(left.text);
+        aliasesByScope.set(scope, aliases);
+    }
+    return aliasesByScope;
+}
+function collectFieldAccesses(tree) {
+    const accesses = [];
+    const aliasesByScope = collectRequestAliases(tree);
+    const isAliasReference = (node) => !!node && node.type === "identifier" && !!aliasesByScope.get(enclosingScopeId(node))?.has(node.text);
+    for (const node of tree.rootNode.descendantsOfType("subscript")) {
+        const value = node.childForFieldName("value");
+        if (!value)
+            continue;
+        const isDirect = REQUEST_ATTR.test(value.text) || (value.type === "call" && isRequestDataSource(value));
+        if (!isDirect && !isAliasReference(value))
+            continue;
+        const key = stringLiteralContent(node.childForFieldName("subscript"));
+        if (key)
+            accesses.push({ fieldName: key, line: node.startPosition.row + 1 });
+    }
+    for (const node of tree.rootNode.descendantsOfType("call")) {
+        const fn = node.childForFieldName("function");
+        if (!fn)
+            continue;
+        const isDirectGet = REQUEST_GET_CALL.test(fn.text);
+        const isAliasGet = fn.type === "attribute" &&
+            fn.childForFieldName("attribute")?.text === "get" &&
+            isAliasReference(fn.childForFieldName("object"));
+        if (!isDirectGet && !isAliasGet)
+            continue;
+        const args = node.childForFieldName("arguments")?.namedChildren ?? [];
+        const key = stringLiteralContent(args[0] ?? null);
+        if (key)
+            accesses.push({ fieldName: key, line: node.startPosition.row + 1 });
+    }
+    return accesses;
+}
+export function runPythonFrameworkRules(tree, filePath, source, root) {
+    const lines = source.split("\n");
+    const relPath = relative(root, filePath);
+    const accesses = collectFieldAccesses(tree);
+    const allFieldNames = accesses.map((a) => a.fieldName);
+    const findings = [];
+    const emitted = new Set();
+    for (const { fieldName, line } of accesses) {
+        if (isSafeFieldName(fieldName))
+            continue;
+        const dedupeKey = `${fieldName}:${line}`;
+        if (emitted.has(dedupeKey))
+            continue;
+        emitted.add(dedupeKey);
+        const lexiconCategory = classifyFieldName(fieldName);
+        const ambiguousName = isAmbiguousFieldName(fieldName);
+        const siblingConfidentCount = countConfidentSiblings(allFieldNames, fieldName);
+        const evidenceLine = lines[line - 1] ?? "";
+        // Provisional confidence, patched by the batched protected-logic scoring call -- same pattern as
+        // frameworkRules.ts's JS equivalent; the scoring endpoint doesn't care which language a
+        // confidenceFactors-bearing finding came from.
+        findings.push({
+            id: `field:${relPath}:${line}:${fieldName}`,
+            dataCategories: lexiconCategory ? [lexiconCategory] : ["generic_pii"],
+            processor: null,
+            description: lexiconCategory
+                ? `Request field "${fieldName}" collected, classified as ${lexiconCategory}.`
+                : `Request field "${fieldName}" collected; could not confidently classify — needs review.`,
+            confidence: "low",
+            source: "framework-rule",
+            location: { file: relPath, line, column: 0 },
+            evidence: redactSecrets(evidenceLine.trim()).slice(0, 200),
+            requiresReview: true,
+            confidenceFactors: { lexiconCategory, ambiguousName, runtimeVerified: true, siblingConfidentCount },
+        });
+    }
+    return findings;
+}

package/dist/rules/pythonSdkRules.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from "web-tree-sitter";
+import type { Finding } from "../engine/types.js";
+export declare function runPythonSdkRules(tree: Tree, filePath: string, source: string, root: string): Finding[];