gitnexus 1.6.5-rc.7 → 1.6.5-rc.9

package/dist/core/embeddings/http-client.js

@@ -30,8 +30,11 @@ const readConfig = () => {
     const rawDims = process.env.GITNEXUS_EMBEDDING_DIMS;
     let dimensions;
     if (rawDims !== undefined) {
+        if (!/^\d+$/.test(rawDims)) {
+            throw new Error(`GITNEXUS_EMBEDDING_DIMS must be a positive integer, got "${rawDims}"`);
+        }
         const parsed = parseInt(rawDims, 10);
-        if (Number.isNaN(parsed) || parsed <= 0) {
+        if (parsed <= 0) {
             throw new Error(`GITNEXUS_EMBEDDING_DIMS must be a positive integer, got "${rawDims}"`);
         }
         dimensions = parsed;
@@ -73,9 +76,22 @@ const safeUrl = (url) => {
  * @param model - Model name for the request body
  * @param apiKey - Bearer token (only used in Authorization header)
  * @param batchIndex - Logical batch number (for error context)
- * @param attempt - Current retry attempt (internal)
+ * @param dimensions - Optional output-vector size. When provided, sent as
+ *   the `dimensions` field in the request body. Endpoints that implement
+ *   Matryoshka truncation (OpenAI text-embedding-3-*, Cohere embed-v3,
+ *   Voyage) return a truncated vector at that size; endpoints that do not
+ *   recognise the field may ignore it or return 400. Leave
+ *   `GITNEXUS_EMBEDDING_DIMS` unset for strict backends that reject
+ *   unknown fields.
  */
-const httpEmbedBatch = async (url, batch, model, apiKey, batchIndex = 0) => {
+const httpEmbedBatch = async (url, batch, model, apiKey, batchIndex = 0, dimensions) => {
+    const requestBody = {
+        input: batch,
+        model,
+    };
+    if (dimensions !== undefined) {
+        requestBody.dimensions = dimensions;
+    }
     let resp;
     try {
         resp = await resilientFetch(url, {
@@ -85,7 +101,7 @@ const httpEmbedBatch = async (url, batch, model, apiKey, batchIndex = 0) => {
                 'Content-Type': 'application/json',
                 Authorization: `Bearer ${apiKey}`,
             },
-            body: JSON.stringify({ input: batch, model }),
+            body: JSON.stringify(requestBody),
         }, {
             breakerKey: HTTP_BREAKER_KEY,
             retry: { maxAttempts: HTTP_MAX_RETRIES + 1, baseDelayMs: HTTP_RETRY_BACKOFF_MS },
@@ -130,7 +146,7 @@ export const httpEmbed = async (texts) => {
     for (let i = 0; i < texts.length; i += HTTP_BATCH_SIZE) {
         const batch = texts.slice(i, i + HTTP_BATCH_SIZE);
         const batchIndex = Math.floor(i / HTTP_BATCH_SIZE);
-        const items = await httpEmbedBatch(url, batch, config.model, config.apiKey, batchIndex);
+        const items = await httpEmbedBatch(url, batch, config.model, config.apiKey, batchIndex, config.dimensions);
         if (items.length !== batch.length) {
             throw new Error(`Embedding endpoint returned ${items.length} vectors for ${batch.length} texts ` +
                 `(${safeUrl(url)}, batch ${batchIndex})`);
@@ -164,7 +180,7 @@ export const httpEmbedQuery = async (text) => {
     if (!config)
         throw new Error('HTTP embedding not configured');
     const url = `${config.baseUrl}/embeddings`;
-    const items = await httpEmbedBatch(url, [text], config.model, config.apiKey);
+    const items = await httpEmbedBatch(url, [text], config.model, config.apiKey, 0, config.dimensions);
     if (!items.length) {
         throw new Error(`Embedding endpoint returned empty response (${safeUrl(url)})`);
     }

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.9",
   "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",