🐛 Fix named args

Author: savannahostrowski

src/core/extractors.ts

@@ -399,26 +399,28 @@ export function importExtractor(node: Node): ImportInfo | null {
   const namedImports: ImportedName[] = []
 
   if (node.type === "import_statement") {
+    let modulePath = ""
     // Handle aliased imports: "import fastapi as f"
     for (const aliased of findNodesByType(node, "aliased_import")) {
       const nameNode = aliased.childForFieldName("name")
       const aliasNode = aliased.childForFieldName("alias")
       if (nameNode) {
+        if (!modulePath) modulePath = nameNode.text // preserve full dotted path
         const alias = aliasNode?.text ?? null
         names.push(alias ?? nameNode.text)
         namedImports.push({ name: nameNode.text, alias })
       }
     }
-    // Non-aliased: "import fastapi"
+    // Non-aliased: "import fastapi" or "import fastapi.routing"
     const nameNodes = findNodesByType(node, "dotted_name")
     for (const nameNode of nameNodes) {
       if (!hasAncestor(nameNode, "aliased_import")) {
+        if (!modulePath) modulePath = nameNode.text // preserve full dotted path
         const firstName = nameNode.text.split(".")[0]
         names.push(firstName)
         namedImports.push({ name: firstName, alias: null })
       }
     }
-    const modulePath = namedImports[0]?.name ?? ""
     return {
       modulePath,
       names,
@@ -465,7 +467,7 @@ export function importExtractor(node: Node): ImportInfo | null {
  *   app.get("/users", response_model=List[User])  → position 0 = string node "/users"
  *   app.get(path="/users", response_model=List[User]) → keyword "path" = string node "/users"
  */
-function resolveArgNode(
+export function resolveArgNode(
   args: Node[],
   position: number,
   keywordName: string,

src/test/core/extractors.test.ts

@@ -649,6 +649,20 @@ router = f.APIRouter(prefix="/items")
       assert.strictEqual(result.isRelative, false)
     })
 
+    test("preserves full dotted modulePath for import fastapi.routing", () => {
+      const code = "import fastapi.routing"
+      const tree = parse(code)
+      const imports = findNodesByType(tree.rootNode, "import_statement")
+      const result = importExtractor(imports[0])
+
+      assert.ok(result)
+      assert.strictEqual(result.modulePath, "fastapi.routing")
+      assert.deepStrictEqual(result.names, ["fastapi"])
+      assert.deepStrictEqual(result.namedImports, [
+        { name: "fastapi", alias: null },
+      ])
+    })
+
     test("extracts aliased module import (import fastapi as f)", () => {
       const code = "import fastapi as f"
       const tree = parse(code)

src/test/providers/testCodeLensProvider.test.ts

@@ -287,6 +287,22 @@ def test_something():
       assert.strictEqual(lenses.length, 0)
     })
 
+    test("creates CodeLens for url= keyword argument", async () => {
+      const app = createMockApp([createRoute("GET", "/users")])
+      provider.setApps([app])
+
+      const doc = await vscode.workspace.openTextDocument({
+        content: `
+def test_get_users():
+    response = client.get(url="/users")
+`,
+        language: "python",
+      })
+      const lenses = provider.provideCodeLenses(doc)
+      assert.strictEqual(lenses.length, 1)
+      assert.ok(lenses[0].command?.title.includes("/users"))
+    })
+
     test("ignores calls with no arguments", async () => {
       const app = createMockApp([createRoute("GET", "/users")])
       provider.setApps([app])

src/vscode/testCodeLensProvider.ts

@@ -14,7 +14,11 @@ import {
   Uri,
 } from "vscode"
 import type { Node } from "web-tree-sitter"
-import { extractPathFromNode, findNodesByType } from "../core/extractors"
+import {
+  extractPathFromNode,
+  findNodesByType,
+  resolveArgNode,
+} from "../core/extractors"
 import { ROUTE_METHODS } from "../core/internal"
 import type { Parser } from "../core/parser"
 import {
@@ -134,7 +138,11 @@ export class TestCodeLensProvider implements CodeLensProvider {
         continue
       }
 
-      const pathArg = args[0]
+      const pathArg = resolveArgNode(args, 0, "url")
+
+      if (!pathArg) {
+        continue
+      }
       // extractPathFromNode always returns a non-empty string for valid AST nodes
       const path = extractPathFromNode(pathArg)