contextl 1.2.32 → 1.2.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "contextl",
-  "version": "1.2.32",
+  "version": "1.2.34",
   "description": "contextl — finds the most relevant files in your codebase for any change request. MCP server for AI coding agents.",
   "keywords": [
     "mcp",

package/python/import_parser.py

@@ -836,27 +836,7 @@ def parse_imports(scan_result: ScanResult) -> ParseResult:
         if scanned_file.extension == ".py" and not _TS_AVAILABLE:
             pass  # regex already handles this above
         elif scanned_file.extension == ".py" and _TS_AVAILABLE:
-            # tree-sitter gives us just the module name; add symbol-level candidates
-            # to match the legacy behaviour that resolves "scanner.ScannedFile" → scanner.py
-            extra: list[str] = []
-            for match in PYTHON_FROM_IMPORT_PATTERN.finditer(source_code):
-                base = match.group(1)
-                symbols_str = match.group(2) or match.group(3)
-                if symbols_str:
-                    symbols_str = symbols_str.replace('(', '').replace(')', '').replace('\\', '').strip()
-                    for sym in symbols_str.split(','):
-                        sym = sym.split(' as ')[0].strip()
-                        if sym and sym != '*':
-                            if base.endswith("."):
-                                extra.append(f"{base}{sym}")
-                            else:
-                                extra.append(f"{base}.{sym}")
-            # Merge without duplicates
-            seen = set(raw_imports)
-            for e in extra:
-                if e not in seen:
-                    raw_imports.append(e)
-                    seen.add(e)
+            pass # tree-sitter gives us just the module name; add symbol-level candidates (legacy removed)
 
         for raw in raw_imports:
             if _is_external(raw, scanned_file.extension, alias_map):
@@ -980,6 +960,7 @@ def _skeleton_python(root: "Node", source_bytes: bytes) -> dict:
         name = ""
         bases: list[str] = []
         methods: list[dict] = []
+        nested_classes: list[dict] = []
         props: list[dict] = []
 
         for child in node.children:
@@ -1001,9 +982,16 @@ def _skeleton_python(root: "Node", source_bytes: bytes) -> dict:
                                 if sub.type == "function_definition":
                                     fn_node = sub
                                     break
-                        methods.append(visit_function(fn_node, is_method=True))
+                                elif sub.type == "class_definition":
+                                    nested_classes.append(visit_class(sub))
+                                    fn_node = None
+                                    break
+                        if fn_node is not None:
+                            methods.append(visit_function(fn_node, is_method=True))
+                    elif stmt.type == "class_definition":
+                        nested_classes.append(visit_class(stmt))
 
-        entry: dict = {"name": name, "bases": bases, "methods": methods, "properties": props}
+        entry: dict = {"name": name, "bases": bases, "methods": methods, "nested_classes": nested_classes, "properties": props}
         return entry
 
     def visit_function(node: "Node", is_method: bool = False) -> dict:
@@ -1197,16 +1185,57 @@ def _skeleton_ts_js(root: "Node") -> dict:
             "is_exported": is_exported,
         }
 
+    def visit_enum(node: "Node") -> dict:
+        name = ""
+        properties: list[dict] = []
+        for child in node.children:
+            if child.type == "identifier":
+                name = _node_text(child)
+            elif child.type == "enum_body":
+                for member in child.children:
+                    if member.type == "property_identifier":
+                        properties.append({
+                            "name": _node_text(member),
+                            "type": "",
+                            "visibility": "public",
+                        })
+                    elif member.type == "enum_assignment":
+                        member_name = ""
+                        member_val = ""
+                        for sub in member.children:
+                            if sub.type == "property_identifier":
+                                member_name = _node_text(sub)
+                            elif sub.type not in ("=",):
+                                member_val = _node_text(sub)
+                        if member_name:
+                            properties.append({
+                                "name": member_name,
+                                "type": member_val,
+                                "visibility": "public",
+                            })
+        return {
+            "name": name,
+            "extends": "",
+            "implements": [],
+            "methods": [],
+            "properties": properties,
+        }
+
     def visit(node: "Node"):
         if node.type == "class_declaration":
             c = visit_class(node)
             classes.append(c)
             return
-        if node.type in ("function_declaration", "function"):
+        if node.type in ("function_declaration", "function", "generator_function_declaration", "generator_function"):
             f = visit_function(node)
             if f["name"]:
                 functions.append(f)
             return
+        if node.type == "enum_declaration":
+            c = visit_enum(node)
+            if c["name"]:
+                classes.append(c)
+            return
         if node.type == "export_statement":
             # Track what is exported
             for child in node.children:
@@ -1217,13 +1246,37 @@ def _skeleton_ts_js(root: "Node") -> dict:
                     if c["name"]:
                         exports.append(c["name"])
                     return
-                if child.type in ("function_declaration", "function"):
+                if child.type in ("function_declaration", "function", "generator_function_declaration", "generator_function"):
                     f = visit_function(child)
                     if f["name"]:
                         f["is_exported"] = True
                         functions.append(f)
                         exports.append(f["name"])
                     return
+                if child.type == "enum_declaration":
+                    c = visit_enum(child)
+                    if c["name"]:
+                        classes.append(c)
+                        exports.append(c["name"])
+                    return
+                if child.type == "lexical_declaration":
+                    for sub in child.children:
+                        if sub.type == "variable_declarator":
+                            for sub2 in sub.children:
+                                if sub2.type == "identifier":
+                                    name = _node_text(sub2)
+                                    exports.append(name)
+                                    is_callable = any(c.type in ("arrow_function", "function", "generator_function") for c in sub.children)
+                                    if is_callable:
+                                        functions.append({
+                                            "name": name,
+                                            "params": "",
+                                            "return_type": "",
+                                            "is_async": False,
+                                            "is_exported": True,
+                                        })
+                                    break
+                    return
                 if child.type == "export_clause":
                     for spec in child.children:
                         if spec.type == "export_specifier":

package/python/standalone.py

@@ -18,7 +18,7 @@ ENTRY_POINT_MARKERS = {
     "route.ts", "route.js",
     "globals.css", "global.css", "tailwind.css",
     "index.ts", "index.js", "index.tsx", "index.jsx",
-    "main.ts", "main.js", "main.py",
+    "main.ts", "main.js", "main.py", "main.go", "main.rs", "main.c", "main.cpp", "main.cc", "main.java",
     "app.ts", "app.js", "app.tsx", "app.jsx", "app.py",
     "mcp_server.py", "server.ts", "server.js", "server.py",
     "__main__.py", "__init__.py", "setup.py", "conftest.py",