gitnexus 1.6.5-rc.7 → 1.6.5-rc.8

package/dist/core/group/extractors/http-patterns/python.js

@@ -5,6 +5,7 @@ import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-s
  *   - FastAPI `@app.get("/path")` provider decorators
  *   - `requests.get/post/...("url")` consumer calls
  *   - Generic `requests.request("METHOD", "url")` consumer calls
+ *   - `httpx.AsyncClient` instances calling `.get/.post/...("url")`
  */
 const FASTAPI_VERBS = {
     get: 'GET',
@@ -65,11 +66,142 @@ const REQUESTS_GENERIC_PATTERNS = compilePatterns({
         },
     ],
 });
+// ─── Consumer: httpx.AsyncClient assignments ────────────────────────
+// NOTE: This targeted detector only tracks explicit `httpx.AsyncClient(...)`
+// construction. Direct imports (`from httpx import AsyncClient`) and module
+// aliases (`import httpx as hx`) and annotated assignments (`client: httpx.AsyncClient = ...`)
+// are intentionally left for a follow-up. Module-scope clients are only matched
+// at module scope; calls inside functions require a function/class-local tracked
+// client to avoid false positives from same-name local variables.
+const HTTPX_ASYNC_CLIENT_ASSIGN_PATTERNS = compilePatterns({
+    name: 'python-httpx-async-client-assign',
+    language: Python,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (assignment
+          left: (_) @client
+          right: (call
+            function: (attribute
+              object: (identifier) @module (#eq? @module "httpx")
+              attribute: (identifier) @client_class (#eq? @client_class "AsyncClient"))))
+      `,
+        },
+    ],
+});
+// ─── Consumer: async with httpx.AsyncClient() as client ──────────────
+const HTTPX_ASYNC_CLIENT_WITH_ALIAS_PATTERNS = compilePatterns({
+    name: 'python-httpx-async-client-with-alias',
+    language: Python,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (as_pattern
+          (call
+            function: (attribute
+              object: (identifier) @module (#eq? @module "httpx")
+              attribute: (identifier) @client_class (#eq? @client_class "AsyncClient")))
+          (as_pattern_target (identifier) @client))
+      `,
+        },
+    ],
+});
+function getScopeKey(node, preferClass = false) {
+    if (preferClass) {
+        let current = node;
+        while (current) {
+            if (current.type === 'class_definition') {
+                return `class:${current.startIndex}:${current.endIndex}`;
+            }
+            current = current.parent;
+        }
+    }
+    let current = node;
+    while (current) {
+        if (current.type === 'function_definition') {
+            return `function:${current.startIndex}:${current.endIndex}`;
+        }
+        current = current.parent;
+    }
+    return 'module';
+}
+function trackedClientScopeKey(clientNode) {
+    return getScopeKey(clientNode.parent, clientNode.text.includes('.'));
+}
+function callScopeKeys(clientNode) {
+    const keys = new Set();
+    const preferClass = clientNode.text.includes('.');
+    const nearestScope = getScopeKey(clientNode.parent, preferClass);
+    keys.add(nearestScope);
+    return [...keys];
+}
+function collectHttpxAsyncClients(tree) {
+    const clients = new Map();
+    const addClient = (clientNode) => {
+        if (!clientNode)
+            return;
+        const scopeKey = trackedClientScopeKey(clientNode);
+        const clientText = clientNode.text;
+        const scopes = clients.get(clientText) ?? new Set();
+        scopes.add(scopeKey);
+        clients.set(clientText, scopes);
+    };
+    for (const match of runCompiledPatterns(HTTPX_ASYNC_CLIENT_ASSIGN_PATTERNS, tree)) {
+        addClient(match.captures.client);
+    }
+    for (const match of runCompiledPatterns(HTTPX_ASYNC_CLIENT_WITH_ALIAS_PATTERNS, tree)) {
+        addClient(match.captures.client);
+    }
+    return clients;
+}
+function hasTrackedHttpxAsyncClient(clients, clientNode) {
+    const scopes = clients.get(clientNode.text);
+    if (!scopes)
+        return false;
+    return callScopeKeys(clientNode).some((scopeKey) => scopes.has(scopeKey));
+}
+// ─── Consumer: httpx AsyncClient .get/.post/...("url") ──────────────
+const HTTPX_ASYNC_CLIENT_VERB_PATTERNS = compilePatterns({
+    name: 'python-httpx-async-client-verb',
+    language: Python,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (call
+          function: (attribute
+            object: (_) @client
+            attribute: (identifier) @method (#match? @method "^(get|post|put|delete|patch)$"))
+          arguments: (argument_list . (string) @path))
+      `,
+        },
+    ],
+});
+// ─── Consumer: httpx AsyncClient .request("METHOD", "url") ─────────
+const HTTPX_ASYNC_CLIENT_GENERIC_PATTERNS = compilePatterns({
+    name: 'python-httpx-async-client-generic',
+    language: Python,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (call
+          function: (attribute
+            object: (_) @client
+            attribute: (identifier) @method (#eq? @method "request"))
+          arguments: (argument_list . (string) @http_method (string) @path))
+      `,
+        },
+    ],
+});
 export const PYTHON_HTTP_PLUGIN = {
     name: 'python-http',
     language: Python,
     scan(tree) {
         const out = [];
+        const httpxAsyncClients = collectHttpxAsyncClients(tree);
         // Providers: FastAPI
         for (const match of runCompiledPatterns(FASTAPI_PATTERNS, tree)) {
             const methodNode = match.captures.method;
@@ -128,6 +260,49 @@ export const PYTHON_HTTP_PLUGIN = {
                 confidence: 0.7,
             });
         }
+        // Consumers: httpx.AsyncClient.<verb>("url")
+        for (const match of runCompiledPatterns(HTTPX_ASYNC_CLIENT_VERB_PATTERNS, tree)) {
+            const clientNode = match.captures.client;
+            const methodNode = match.captures.method;
+            const pathNode = match.captures.path;
+            if (!clientNode || !methodNode || !pathNode)
+                continue;
+            if (!hasTrackedHttpxAsyncClient(httpxAsyncClients, clientNode))
+                continue;
+            const path = unquoteLiteral(pathNode.text);
+            if (path === null)
+                continue;
+            out.push({
+                role: 'consumer',
+                framework: 'python-httpx',
+                method: methodNode.text.toUpperCase(),
+                path,
+                name: null,
+                confidence: 0.7,
+            });
+        }
+        // Consumers: httpx.AsyncClient.request("METHOD", "url")
+        for (const match of runCompiledPatterns(HTTPX_ASYNC_CLIENT_GENERIC_PATTERNS, tree)) {
+            const clientNode = match.captures.client;
+            const methodNode = match.captures.http_method;
+            const pathNode = match.captures.path;
+            if (!clientNode || !methodNode || !pathNode)
+                continue;
+            if (!hasTrackedHttpxAsyncClient(httpxAsyncClients, clientNode))
+                continue;
+            const methodRaw = unquoteLiteral(methodNode.text);
+            const path = unquoteLiteral(pathNode.text);
+            if (methodRaw === null || path === null)
+                continue;
+            out.push({
+                role: 'consumer',
+                framework: 'python-httpx',
+                method: methodRaw.toUpperCase(),
+                path,
+                name: null,
+                confidence: 0.7,
+            });
+        }
         return out;
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.5-rc.7",
+  "version": "1.6.5-rc.8",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",