@orangepro/orangepro-mcp 0.2.42 → 0.2.44

package/dist/local/analyze/treeSitter/engine.js

@@ -8,6 +8,8 @@ import { createRequire } from "node:module";
 import { Parser, Language } from "web-tree-sitter";
 import { MAX_SYMBOLS_PER_FILE } from "../symbols.js";
 import { TS_LANG_CONFIGS } from "./languages.js";
+import { slugify } from "../../util/ids.js";
+import { shortHash } from "../../util/hash.js";
 const require = createRequire(import.meta.url);
 let initPromise = null;
 const loaded = new Map();
@@ -212,6 +214,39 @@ function symbolName(node, cfg) {
 function nodeLines(node) {
     return { start_line: node.startPosition.row + 1, end_line: node.endPosition.row + 1 };
 }
+/**
+ * Nearest lexical Python class for a function. A function boundary reached first
+ * means this is a nested local function, not a class method.
+ */
+function pythonOwnerClass(node) {
+    const owners = [];
+    let parent = node.parent;
+    while (parent) {
+        if (parent.type === "function_definition" || parent.type === "lambda")
+            return undefined;
+        if (parent.type === "class_definition") {
+            const name = parent.childForFieldName("name")?.text;
+            if (name)
+                owners.unshift(name);
+        }
+        parent = parent.parent;
+    }
+    return owners.length > 0 ? owners.join(".") : undefined;
+}
+function hasPythonFunctionAncestor(node) {
+    let parent = node.parent;
+    while (parent) {
+        if (parent.type === "function_definition" || parent.type === "lambda")
+            return true;
+        parent = parent.parent;
+    }
+    return false;
+}
+function pythonQualifiedFunctionName(node) {
+    const name = functionName(node, "python");
+    const owner = pythonOwnerClass(node);
+    return name && owner ? `${owner}.${name}` : name;
+}
 /**
  * Extract class/function/method symbol metadata (names + a trivial-accessor flag —
  * never source bodies) from a tree-sitter-supported language. Sync; returns [] when
@@ -249,16 +284,22 @@ export function extractTreeSitterSymbols(content, language) {
             kind = "method";
         else if (cfg.functionTypes.has(node.type))
             kind = "function";
-        if (kind && shouldEmitSymbol(node, language)) {
+        const pythonOwner = language === "python" && node.type === "function_definition" ? pythonOwnerClass(node) : undefined;
+        if (pythonOwner && kind === "function")
+            kind = "method";
+        const localPythonDeclaration = language === "python" && (node.type === "function_definition" || node.type === "class_definition") && hasPythonFunctionAncestor(node);
+        if (kind && !localPythonDeclaration && shouldEmitSymbol(node, language)) {
             const name = symbolName(node, cfg);
             if (name && !RESERVED_SYMBOL_NAMES.has(name)) {
                 // Go methods mint receiver-qualified names (`Recv.M`, mirroring TS/JS
                 // `Class.method` + member_of) so same-named methods on different receivers
                 // stay distinct symbols; an underivable receiver falls back to the bare name.
-                const recv = kind === "method" && language === "go" ? goReceiverBaseName(node) : undefined;
+                const recv = kind === "method" && language === "go" ? goReceiverBaseName(node) : language === "python" ? pythonOwner : undefined;
+                const pythonClassOwner = kind === "class" && language === "python" ? pythonOwnerClass(node) : undefined;
+                const emittedName = pythonClassOwner ? `${pythonClassOwner}.${name}` : name;
                 add(kind === "method"
                     ? { name: recv ? `${recv}.${name}` : name, ...(recv ? { member_of: recv } : {}), symbol_kind: kind, trivial_accessor: isTrivialAccessorBody(node, language), ...nodeLines(node) }
-                    : { name, symbol_kind: kind, ...nodeLines(node) });
+                    : { name: emittedName, symbol_kind: kind, ...nodeLines(node) });
             }
         }
         for (let i = 0; i < node.childCount; i++) {
@@ -464,6 +505,21 @@ function kotlinTopLevelSymbols(root) {
     }
     return [...out].sort();
 }
+function underPythonTypeCheckingGuard(node) {
+    let parent = node.parent;
+    while (parent) {
+        if (parent.type === "if_statement") {
+            const condition = parent.childForFieldName("condition");
+            const text = condition?.text.trim() ?? "";
+            if (text === "TYPE_CHECKING" || /^[A-Za-z_]\w*\.TYPE_CHECKING$/.test(text))
+                return true;
+        }
+        if (parent.type === "function_definition" || parent.type === "class_definition")
+            break;
+        parent = parent.parent;
+    }
+    return false;
+}
 function extractImports(root, language) {
     const imports = [];
     const add = (binding) => {
@@ -472,6 +528,9 @@ function extractImports(root, language) {
         imports.push(binding);
     };
     const walk = (node) => {
+        if (language === "python" && (node.type === "import_statement" || node.type === "import_from_statement") && underPythonTypeCheckingGuard(node)) {
+            return;
+        }
         if (language === "java" && node.type === "import_declaration") {
             const spec = namedChildren(node).find((n) => n.type.endsWith("identifier"))?.text;
             if (spec && !spec.endsWith(".*"))
@@ -1430,6 +1489,360 @@ function extractJavaProofCalls(root, imports) {
     }
     return out;
 }
+const FASTAPI_HTTP_METHODS = new Set(["get", "post", "put", "patch", "delete", "options", "head", "trace"]);
+function pythonStaticString(node) {
+    if (!node || node.type !== "string")
+        return null;
+    const contents = node.descendantsOfType("string_content").filter((n) => Boolean(n));
+    if (contents.length !== 1)
+        return null;
+    return contents[0]?.text ?? null;
+}
+function pythonDottedName(node) {
+    if (!node)
+        return null;
+    if (node.type === "identifier" || node.type === "dotted_name")
+        return node.text;
+    if (node.type !== "attribute")
+        return null;
+    const object = pythonDottedName(node.childForFieldName("object"));
+    const attribute = node.childForFieldName("attribute")?.text;
+    return object && attribute ? `${object}.${attribute}` : null;
+}
+function pythonCallArguments(call) {
+    const args = call.childForFieldName("arguments");
+    return args ? namedChildren(args).filter((n) => n.type !== "comment") : [];
+}
+function pythonKeywordArgument(call, name) {
+    for (const arg of pythonCallArguments(call)) {
+        if (arg.type !== "keyword_argument" || arg.childForFieldName("name")?.text !== name)
+            continue;
+        return arg.childForFieldName("value") ?? namedChildren(arg)[1] ?? null;
+    }
+    return null;
+}
+function pythonPositionalArguments(call) {
+    return pythonCallArguments(call).filter((n) => n.type !== "keyword_argument" && n.type !== "list_splat" && n.type !== "dictionary_splat");
+}
+function pythonStaticHttpMethods(node, fallback = ["GET"]) {
+    if (!node)
+        return fallback;
+    if (!new Set(["list", "tuple", "set"]).has(node.type))
+        return null;
+    const elements = namedChildren(node).filter((child) => child.type !== "comment");
+    if (elements.length === 0)
+        return null;
+    const methods = elements.map((element) => pythonStaticString(element));
+    if (methods.some((method) => method === null))
+        return null;
+    const normalized = methods.map((method) => method.toLowerCase());
+    return normalized.every((method) => FASTAPI_HTTP_METHODS.has(method)) ? normalized.map((method) => method.toUpperCase()) : null;
+}
+function normalizePythonRoutePath(...parts) {
+    const joined = parts.map((p) => p.trim().replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
+    return joined ? `/${joined}` : "/";
+}
+function pythonImportedFromFastapi(imports, local, imported) {
+    return imports.some((b) => b.local === local && b.module === "fastapi" && b.kind === "named" && b.imported === imported);
+}
+function pythonCallIsFastapiConstructor(call, imports, imported) {
+    const parts = callParts(call, "python");
+    if (!parts)
+        return false;
+    if (!parts.qualifier)
+        return pythonImportedFromFastapi(imports, parts.callee, imported);
+    if (parts.callee !== imported)
+        return false;
+    const root = parts.qualifier.split(".")[0] ?? "";
+    return imports.some((b) => b.local === root && b.kind === "module" && b.module === "fastapi");
+}
+function pythonBindingTargetNames(target) {
+    if (!target)
+        return [];
+    if (target.type === "identifier")
+        return [target.text];
+    if (!new Set(["pattern_list", "tuple_pattern", "list_pattern", "tuple", "list"]).has(target.type))
+        return [];
+    return namedChildren(target).flatMap((child) => pythonBindingTargetNames(child));
+}
+function pythonFastapiReceivers(root, imports) {
+    const mutationCount = new Map();
+    const candidates = new Map();
+    const mutations = [];
+    for (const type of ["assignment", "annotated_assignment", "augmented_assignment", "delete_statement"]) {
+        mutations.push(...root.descendantsOfType(type).filter((node) => Boolean(node)));
+    }
+    mutations.sort((a, b) => a.startIndex - b.startIndex);
+    for (const assignment of mutations) {
+        if (!pythonDirectModuleExecution(assignment))
+            continue;
+        const left = assignment.childForFieldName("left");
+        const targets = assignment.type === "delete_statement"
+            ? namedChildren(assignment).flatMap((child) => pythonBindingTargetNames(child))
+            : pythonBindingTargetNames(left);
+        for (const target of targets)
+            mutationCount.set(target, (mutationCount.get(target) ?? 0) + 1);
+        const right = assignment.childForFieldName("right");
+        if (left?.type !== "identifier")
+            continue;
+        const kind = right?.type === "call" && pythonCallIsFastapiConstructor(right, imports, "APIRouter")
+            ? "router"
+            : right?.type === "call" && pythonCallIsFastapiConstructor(right, imports, "FastAPI")
+                ? "app"
+                : null;
+        if (!kind || right?.type !== "call")
+            continue;
+        const prefixNode = kind === "router" ? pythonKeywordArgument(right, "prefix") : null;
+        const staticPrefix = pythonStaticString(prefixNode);
+        candidates.set(left.text, {
+            kind,
+            prefix: staticPrefix ?? "",
+            prefixResolved: !prefixNode || staticPrefix !== null,
+            boundAt: assignment.startIndex
+        });
+    }
+    const out = new Map();
+    for (const [name, receiver] of candidates)
+        if (mutationCount.get(name) === 1)
+            out.set(name, receiver);
+    return out;
+}
+const PYTHON_NONDETERMINISTIC_SCOPES = new Set([
+    "function_definition", "class_definition", "if_statement", "for_statement", "while_statement",
+    "try_statement", "with_statement", "match_statement", "lambda", "list_comprehension",
+    "dictionary_comprehension", "set_comprehension", "generator_expression"
+]);
+function pythonDirectModuleExecution(node) {
+    let parent = node.parent;
+    while (parent) {
+        if (PYTHON_NONDETERMINISTIC_SCOPES.has(parent.type))
+            return false;
+        if (parent.type === "module")
+            return true;
+        parent = parent.parent;
+    }
+    return false;
+}
+function pythonRouterIncludePrefixes(root, receivers) {
+    const out = new Map();
+    for (const call of root.descendantsOfType("call")) {
+        if (!call || !pythonDirectModuleExecution(call))
+            continue;
+        const parts = callParts(call, "python");
+        const app = parts?.qualifier?.split(".")[0];
+        if (!parts || parts.callee !== "include_router" || !app || receivers.get(app)?.kind !== "app")
+            continue;
+        const router = pythonDottedName(pythonPositionalArguments(call)[0] ?? null);
+        if (!router || !receivers.has(router) || receivers.get(app).boundAt >= call.startIndex || receivers.get(router).boundAt >= call.startIndex)
+            continue;
+        const includePrefix = pythonStaticString(pythonKeywordArgument(call, "prefix"));
+        if (includePrefix === null && pythonKeywordArgument(call, "prefix"))
+            continue;
+        let prefixes = out.get(router);
+        if (!prefixes)
+            out.set(router, (prefixes = new Set()));
+        prefixes.add(includePrefix ?? "");
+    }
+    return out;
+}
+function makePythonBehaviorContract(input) {
+    const identityInput = `${input.method}|${input.path}|${input.file}|${input.handler ?? ""}`;
+    return {
+        id: `endpoint:${slugify(`${input.method}-${input.path}-${input.file}-${input.handler ?? ""}`)}-${shortHash(identityInput)}`,
+        title: `${input.method} ${input.path}`,
+        kind: "http_endpoint",
+        framework: "fastapi",
+        method: input.method,
+        path: input.path,
+        file: input.file,
+        handler: input.handler,
+        route_prefix_status: input.prefixStatus,
+        ...(input.prefix ? { route_prefix: input.prefix } : {}),
+        source: "framework"
+    };
+}
+function dedupePythonContracts(contracts) {
+    const seen = new Set();
+    return contracts.filter((contract) => {
+        const key = `${contract.method}|${contract.path}|${contract.handler ?? ""}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function pythonDirectModuleHandlers(root) {
+    const counts = new Map();
+    for (const fn of root.descendantsOfType("function_definition")) {
+        if (!fn || hasPythonFunctionAncestor(fn))
+            continue;
+        const declaration = fn.parent?.type === "decorated_definition" ? fn.parent : fn;
+        if (declaration.parent?.type !== "module")
+            continue;
+        const name = pythonQualifiedFunctionName(fn);
+        if (name)
+            counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+    for (const type of ["assignment", "annotated_assignment", "augmented_assignment", "delete_statement"]) {
+        for (const mutation of root.descendantsOfType(type)) {
+            if (!mutation || !pythonDirectModuleExecution(mutation))
+                continue;
+            const left = mutation.childForFieldName("left");
+            const targets = mutation.type === "delete_statement"
+                ? namedChildren(mutation).flatMap((child) => pythonBindingTargetNames(child))
+                : pythonBindingTargetNames(left);
+            for (const target of targets)
+                if (counts.has(target))
+                    counts.set(target, counts.get(target) + 1);
+        }
+    }
+    return new Set([...counts].filter(([, count]) => count === 1).map(([name]) => name));
+}
+function extractPythonBehaviorContracts(root, imports, file) {
+    const receivers = pythonFastapiReceivers(root, imports);
+    if (receivers.size === 0)
+        return [];
+    const directHandlers = pythonDirectModuleHandlers(root);
+    const includes = pythonRouterIncludePrefixes(root, receivers);
+    const out = [];
+    const add = (receiverName, method, routePath, registrationAt, handler) => {
+        const receiver = receivers.get(receiverName);
+        if (!receiver || receiver.boundAt >= registrationAt)
+            return;
+        const includePrefixes = receiver.kind === "app" ? new Set([""]) : includes.get(receiverName);
+        const prefixes = includePrefixes && includePrefixes.size > 0 ? [...includePrefixes] : [""];
+        const status = receiver.prefixResolved && (receiver.kind === "app" || Boolean(includePrefixes?.size)) ? "resolved" : "unresolved";
+        for (const includePrefix of prefixes) {
+            const prefix = normalizePythonRoutePath(includePrefix, receiver.prefix);
+            const normalizedPrefix = prefix === "/" ? "" : prefix;
+            out.push(makePythonBehaviorContract({
+                file,
+                method: method.toUpperCase(),
+                path: normalizePythonRoutePath(normalizedPrefix, routePath),
+                handler,
+                prefixStatus: status,
+                prefix: normalizedPrefix
+            }));
+        }
+    };
+    for (const fn of root.descendantsOfType("function_definition")) {
+        if (!fn || hasPythonFunctionAncestor(fn))
+            continue;
+        const handler = pythonQualifiedFunctionName(fn);
+        const decorated = fn.parent?.type === "decorated_definition" ? fn.parent : null;
+        if (!handler || !directHandlers.has(handler) || !decorated || decorated.parent?.type !== "module")
+            continue;
+        for (const decorator of namedChildren(decorated).filter((n) => n.type === "decorator")) {
+            const call = namedChildren(decorator).find((n) => n.type === "call");
+            const parts = call ? callParts(call, "python") : null;
+            const receiver = parts?.qualifier?.split(".")[0];
+            const route = call ? pythonStaticString(pythonPositionalArguments(call)[0] ?? null) : null;
+            if (!call || !parts || !receiver || route === null)
+                continue;
+            if (FASTAPI_HTTP_METHODS.has(parts.callee)) {
+                add(receiver, parts.callee, route, call.startIndex, handler);
+            }
+            else if (parts.callee === "api_route") {
+                const methods = pythonStaticHttpMethods(pythonKeywordArgument(call, "methods"));
+                if (!methods)
+                    continue;
+                for (const method of methods)
+                    add(receiver, method, route, call.startIndex, handler);
+            }
+        }
+    }
+    for (const call of root.descendantsOfType("call")) {
+        if (!call || !pythonDirectModuleExecution(call))
+            continue;
+        const parts = callParts(call, "python");
+        const receiver = parts?.qualifier?.split(".")[0];
+        if (!parts || parts.callee !== "add_api_route" || !receiver || !receivers.has(receiver))
+            continue;
+        const positional = pythonPositionalArguments(call);
+        const route = pythonStaticString(positional[0] ?? null);
+        const handler = pythonDottedName(positional[1] ?? null);
+        if (route === null || !handler || !directHandlers.has(handler))
+            continue;
+        const methods = pythonStaticHttpMethods(pythonKeywordArgument(call, "methods"));
+        if (!methods)
+            continue;
+        for (const method of methods)
+            add(receiver, method, route, call.startIndex, handler);
+    }
+    return dedupePythonContracts(out);
+}
+function isFastapiDependsCall(call, imports) {
+    const parts = callParts(call, "python");
+    if (!parts)
+        return false;
+    if (!parts.qualifier) {
+        return pythonImportedFromFastapi(imports, parts.callee, "Depends") || pythonImportedFromFastapi(imports, parts.callee, "Security");
+    }
+    if (parts.callee !== "Depends" && parts.callee !== "Security")
+        return false;
+    const root = parts.qualifier.split(".")[0] ?? "";
+    return imports.some((b) => b.local === root && b.kind === "module" && b.module === "fastapi");
+}
+function extractPythonDependencies(root, imports, acceptedHandlers) {
+    const out = [];
+    const seen = new Set();
+    const receivers = pythonFastapiReceivers(root, imports);
+    const directHandlers = pythonDirectModuleHandlers(root);
+    const addFromNode = (handler, node) => {
+        if (!node)
+            return;
+        const calls = [...(node.type === "call" ? [node] : []), ...node.descendantsOfType("call").filter((n) => Boolean(n))];
+        for (const call of calls) {
+            if (!isFastapiDependsCall(call, imports))
+                continue;
+            const dependency = pythonDottedName(pythonPositionalArguments(call)[0] ?? null);
+            if (!dependency)
+                continue;
+            const key = `${handler}|${dependency}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({ handler, dependency });
+        }
+    };
+    for (const fn of root.descendantsOfType("function_definition")) {
+        if (!fn || hasPythonFunctionAncestor(fn))
+            continue;
+        const handler = pythonQualifiedFunctionName(fn);
+        const params = fn.childForFieldName("parameters");
+        const declaration = fn.parent?.type === "decorated_definition" ? fn.parent : fn;
+        if (!handler || !params || !directHandlers.has(handler) || declaration.parent?.type !== "module" || !acceptedHandlers.has(handler))
+            continue;
+        addFromNode(handler, params);
+        const decorated = fn.parent?.type === "decorated_definition" ? fn.parent : null;
+        for (const decorator of decorated ? namedChildren(decorated).filter((n) => n.type === "decorator") : []) {
+            const routeCall = namedChildren(decorator).find((n) => n.type === "call");
+            const parts = routeCall ? callParts(routeCall, "python") : null;
+            const receiver = parts?.qualifier?.split(".")[0];
+            if (!routeCall || !parts || !receiver || !receivers.has(receiver) || receivers.get(receiver).boundAt >= routeCall.startIndex)
+                continue;
+            if (!FASTAPI_HTTP_METHODS.has(parts.callee) && (parts.callee !== "api_route" || !pythonStaticHttpMethods(pythonKeywordArgument(routeCall, "methods"))))
+                continue;
+            addFromNode(handler, pythonKeywordArgument(routeCall, "dependencies"));
+        }
+    }
+    for (const call of root.descendantsOfType("call")) {
+        if (!call || !pythonDirectModuleExecution(call))
+            continue;
+        const parts = callParts(call, "python");
+        const receiver = parts?.qualifier?.split(".")[0];
+        if (!parts || parts.callee !== "add_api_route" || !receiver || !receivers.has(receiver) || receivers.get(receiver).boundAt >= call.startIndex)
+            continue;
+        const positional = pythonPositionalArguments(call);
+        const route = pythonStaticString(positional[0] ?? null);
+        const handler = pythonDottedName(positional[1] ?? null);
+        const methods = pythonStaticHttpMethods(pythonKeywordArgument(call, "methods"));
+        if (route !== null && handler && methods && directHandlers.has(handler) && acceptedHandlers.has(handler)) {
+            addFromNode(handler, pythonKeywordArgument(call, "dependencies"));
+        }
+    }
+    return out;
+}
 function directPythonAssertCall(assertion) {
     const subject = namedChildren(assertion)[0];
     if (!subject)
@@ -1443,19 +1856,195 @@ function singlePythonComparisonCall(comparison) {
     const calls = namedChildren(comparison).filter((child) => child.type === "call");
     return calls.length === 1 ? calls[0] ?? null : null;
 }
+function pythonDirectAssignment(stmt) {
+    const assignment = stmt.type === "assignment" || stmt.type === "annotated_assignment"
+        ? stmt
+        : namedChildren(stmt).find((child) => child.type === "assignment" || child.type === "annotated_assignment");
+    if (!assignment)
+        return null;
+    const target = assignment.childForFieldName("left");
+    const value = assignment.childForFieldName("right");
+    return target && value ? { target, value } : null;
+}
+function pythonSingleCall(node) {
+    const calls = [...(node.type === "call" ? [node] : []), ...node.descendantsOfType("call").filter((call) => Boolean(call))];
+    const unique = [...new Map(calls.map((call) => [`${call.startIndex}:${call.endIndex}`, call])).values()];
+    return unique.length === 1 ? unique[0] ?? null : null;
+}
+function pythonExactCall(node) {
+    if (!node)
+        return null;
+    if (node.type === "call")
+        return node;
+    if (node.type === "await" || node.type === "parenthesized_expression") {
+        const children = namedChildren(node);
+        return children.length === 1 ? pythonExactCall(children[0] ?? null) : null;
+    }
+    return null;
+}
+function pythonDirectAssertedResult(assertion, results) {
+    const subject = namedChildren(assertion)[0];
+    if (subject?.type !== "comparison_operator")
+        return null;
+    const operands = namedChildren(subject);
+    if (operands.length !== 2)
+        return null;
+    const candidates = operands.filter((operand) => operand.type === "identifier" && results.has(operand.text));
+    if (candidates.length !== 1)
+        return null;
+    const name = candidates[0].text;
+    const occurrences = subject.descendantsOfType("identifier")
+        .filter((identifier) => Boolean(identifier))
+        .filter((identifier) => identifier.text === name);
+    return occurrences.length === 1 ? name : null;
+}
+function pythonLexicalNodes(root) {
+    const out = [];
+    const visit = (node) => {
+        for (const child of namedChildren(node)) {
+            if (child.type === "function_definition" || child.type === "class_definition" || child.type === "lambda")
+                continue;
+            out.push(child);
+            visit(child);
+        }
+    };
+    visit(root);
+    return out;
+}
+function pythonBindingNames(node) {
+    if (node.type === "assignment" || node.type === "annotated_assignment" || node.type === "augmented_assignment" || node.type === "named_expression") {
+        const target = node.childForFieldName("left") ?? node.childForFieldName("name");
+        if (target?.type === "attribute") {
+            const dotted = pythonDottedName(target);
+            return dotted ? [dotted.split(".")[0] ?? dotted] : [];
+        }
+        return target ? pythonBindingTargetNames(target) : [];
+    }
+    if (node.type === "for_statement") {
+        const target = node.childForFieldName("left");
+        return target ? pythonBindingTargetNames(target) : [];
+    }
+    if (node.type === "delete_statement") {
+        return namedChildren(node).flatMap((target) => {
+            if (target.type === "attribute") {
+                const dotted = pythonDottedName(target);
+                return dotted ? [dotted.split(".")[0] ?? dotted] : [];
+            }
+            return pythonBindingTargetNames(target);
+        });
+    }
+    return [];
+}
+function pythonAssignedInstanceProofCalls(block) {
+    const testFunction = block.parent;
+    const decorated = testFunction?.parent?.type === "decorated_definition" ? testFunction.parent : testFunction;
+    const parameterNames = testFunction?.childForFieldName("parameters")?.descendantsOfType("identifier").map((node) => node?.text).filter(Boolean) ?? [];
+    if (parameterNames.some((name) => name !== "self" && name !== "cls"))
+        return [];
+    if (/\b(?:monkeypatch|mocker|patch|Mock|MagicMock|AsyncMock|create_autospec)\b/.test(decorated?.text ?? ""))
+        return [];
+    const lexicalNodes = pythonLexicalNodes(block);
+    const assignments = lexicalNodes.filter((node) => node.type === "assignment" || node.type === "annotated_assignment");
+    const assertions = lexicalNodes.filter((node) => node.type === "assert_statement");
+    if (assertions.length !== 1)
+        return [];
+    const mutationCounts = new Map();
+    for (const node of lexicalNodes) {
+        for (const name of pythonBindingNames(node))
+            mutationCounts.set(name, (mutationCounts.get(name) ?? 0) + 1);
+    }
+    const instances = new Map();
+    const orderedAssignments = assignments.map(pythonDirectAssignment).filter((assignment) => Boolean(assignment));
+    for (const { target, value } of orderedAssignments) {
+        if (target.type !== "identifier" || mutationCounts.get(target.text) !== 1)
+            continue;
+        const constructor = pythonSingleCall(value);
+        const parts = constructor ? callParts(constructor, "python") : null;
+        if (!parts || parts.qualifier || !/^[A-Za-z_]\w*$/.test(parts.callee))
+            continue;
+        if ((mutationCounts.get(parts.callee) ?? 0) > 0)
+            continue;
+        instances.set(target.text, { className: parts.callee, assignedAt: target.startIndex });
+    }
+    for (const { target, value } of orderedAssignments) {
+        if (target.type === "identifier" && value.type === "identifier" && instances.has(value.text))
+            return [];
+    }
+    const trackedNames = new Set([
+        ...instances.keys(),
+        ...[...instances.values()].map((instance) => instance.className)
+    ]);
+    for (const callNode of lexicalNodes.filter((node) => node.type === "call")) {
+        const call = callParts(callNode, "python");
+        const receiver = call?.qualifier?.split(".")[0] ?? "";
+        if (instances.has(receiver))
+            continue;
+        const args = callNode.childForFieldName("arguments");
+        const argumentNames = args
+            ? [
+                ...(args.type === "identifier" ? [args] : []),
+                ...args.descendantsOfType("identifier").filter((identifier) => Boolean(identifier))
+            ].map((identifier) => identifier.text)
+            : [];
+        if (argumentNames.some((name) => trackedNames.has(name)))
+            return [];
+    }
+    const results = new Map();
+    const instanceCalls = lexicalNodes.filter((node) => node.type === "call").filter((callNode) => {
+        const call = callParts(callNode, "python");
+        const receiver = call?.qualifier?.split(".")[0] ?? "";
+        return instances.has(receiver);
+    });
+    if (instanceCalls.length !== 1)
+        return [];
+    for (const { target, value } of orderedAssignments) {
+        if (target.type !== "identifier" || mutationCounts.get(target.text) !== 1)
+            continue;
+        const callNode = pythonExactCall(value);
+        const call = callNode ? callParts(callNode, "python") : null;
+        const receiver = call?.qualifier?.split(".")[0] ?? "";
+        const instance = instances.get(receiver);
+        if (call && instance && instance.assignedAt < value.startIndex) {
+            results.set(target.text, { call, instanceClass: instance.className });
+        }
+    }
+    const out = [];
+    for (const stmt of assertions) {
+        const direct = directPythonAssertCall(stmt);
+        const directReceiver = direct?.qualifier?.split(".")[0] ?? "";
+        const directInstance = instances.get(directReceiver);
+        if (direct && directInstance && directInstance.assignedAt < stmt.startIndex) {
+            out.push({ assertion: stmt, call: direct, instanceClass: directInstance.className });
+        }
+        const subject = namedChildren(stmt)[0];
+        const assertionCalls = subject
+            ? [...(subject.type === "call" ? [subject] : []), ...subject.descendantsOfType("call").filter((call) => Boolean(call))]
+            : [];
+        if (assertionCalls.length > 0)
+            continue;
+        const observed = pythonDirectAssertedResult(stmt, results);
+        const result = observed ? results.get(observed) : undefined;
+        if (result)
+            out.push({ assertion: stmt, ...result });
+    }
+    return out;
+}
 function extractPythonProofCalls(root) {
     const out = [];
     const seen = new Set();
-    const add = (testName, shadowed, call) => {
+    const add = (testName, shadowed, call, instanceClass) => {
         if (!call)
             return;
-        const key = `${testName}|${call.qualifier ?? ""}|${call.callee}`;
+        const key = `${testName}|${instanceClass ?? ""}|${call.qualifier ?? ""}|${call.callee}`;
         if (seen.has(key))
             return;
         seen.add(key);
-        out.push({ caller: testName, testName, ...call, shadowed: [...shadowed], assertion: "pytest_assert" });
+        out.push({ caller: testName, testName, ...call, shadowed: [...shadowed], assertion: "pytest_assert", ...(instanceClass ? { instanceClass } : {}) });
     };
     const processBlock = (block, testName, shadowed) => {
+        for (const associated of pythonAssignedInstanceProofCalls(block)) {
+            add(testName, shadowed, associated.call, associated.instanceClass);
+        }
         for (const stmt of blockStatements(block)) {
             if (stmt.type === "assert_statement")
                 add(testName, shadowed, directPythonAssertCall(stmt));
@@ -1490,7 +2079,7 @@ function extractPythonProofCalls(root) {
     walk(root, false, null);
     return out;
 }
-export function extractTreeSitterStructure(content, language) {
+export function extractTreeSitterStructure(content, language, relPath = "") {
     const parser = parserFor(language);
     if (!parser)
         return { imports: [], calls: [] };
@@ -1530,6 +2119,9 @@ export function extractTreeSitterStructure(content, language) {
                             callerReceivers.set(name, { receiverVar: rv, receiverType: recv });
                     }
                 }
+                if (name && language === "python" && node.type === "function_definition") {
+                    name = pythonQualifiedFunctionName(node) ?? name;
+                }
                 if (name) {
                     nextCaller = name;
                     nextShadowed = localBindings(node, language);
@@ -1546,6 +2138,10 @@ export function extractTreeSitterStructure(content, language) {
     };
     visit(root, null, new Set(), false);
     const imports = extractImports(root, language);
+    const pythonBehaviorContracts = language === "python" ? extractPythonBehaviorContracts(root, imports, relPath) : undefined;
+    const pythonDependencies = language === "python"
+        ? extractPythonDependencies(root, imports, new Set((pythonBehaviorContracts ?? []).map((contract) => contract.handler).filter((handler) => Boolean(handler))))
+        : undefined;
     const result = {
         ...(language === "java" ? { packageName: javaPackage(root), javaClasses: javaClassInfos(root), javaProofCalls: extractJavaProofCalls(root, imports) } : {}),
         ...(language === "go" ? { packageName: goPackage(root), goCtorResults: extractGoCtorResults(root) } : {}),
@@ -1555,7 +2151,7 @@ export function extractTreeSitterStructure(content, language) {
         imports,
         calls,
         ...(language === "go" ? { goProofCalls: extractGoProofCalls(root, imports) } : {}),
-        ...(language === "python" ? { pythonProofCalls: extractPythonProofCalls(root) } : {})
+        ...(language === "python" ? { pythonProofCalls: extractPythonProofCalls(root), pythonBehaviorContracts, pythonDependencies } : {})
     };
     tree.delete();
     return result;