contextl 1.2.24 → 1.2.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "contextl",
-  "version": "1.2.24",
+  "version": "1.2.26",
   "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

@@ -19,6 +19,18 @@ import sys
 from pathlib import Path, PurePosixPath
 from dataclasses import dataclass, field
 
+PYTHON_STDLIB_AND_COMMON_PACKAGES = {
+    "os", "sys", "re", "math", "json", "datetime", "typing", "collections",
+    "itertools", "functools", "pathlib", "logging", "argparse", "subprocess",
+    "unittest", "pytest", "numpy", "pandas", "requests", "urllib", "asyncio",
+    "time", "random", "hashlib", "base64", "csv", "xml", "html", "http",
+    "concurrent", "multiprocessing", "threading", "sqlite3", "flask", "django",
+    "fastapi", "sqlalchemy", "pydantic", "dataclasses", "uuid", "socket",
+    "struct", "tempfile", "shutil", "glob", "copy", "warnings", "traceback",
+    "contextlib", "io", "sysconfig", "importlib", "pkgutil", "runpy",
+    "celery", "redis", "psycopg2", "boto3", "jinja2", "pytest_mock",
+}
+
 from scanner import ScannedFile, ScanResult
 
 
@@ -142,7 +154,7 @@ def _ts_imports_js_ts(root: "Node") -> list[str]:
                     return child.text.decode("utf-8", errors="replace")
             # Fallback: strip quotes manually
             raw = node.text.decode("utf-8", errors="replace")
-            return raw.strip("'\"`")
+            return raw.strip('"\'`')
         return None
 
     def visit(node: "Node"):
@@ -883,6 +895,10 @@ def parse_imports(scan_result: ScanResult) -> ParseResult:
             else:
                 if scanned_file.extension == ".rs" and locals().get("is_likely_external", False):
                     continue
+                if scanned_file.extension == ".py":
+                    base_pkg = raw.split(".")[0]
+                    if base_pkg in PYTHON_STDLIB_AND_COMMON_PACKAGES:
+                        continue
                 result.unresolved.append((scanned_file.path, raw))
 
     return result
@@ -1495,11 +1511,18 @@ def extract_skeleton(file_path: str) -> dict:
     try:
         path = Path(file_path)
         ext = path.suffix.lower()
+        
+        lang_map = {
+            ".py": "python", ".ts": "typescript", ".tsx": "tsx",
+            ".js": "javascript", ".jsx": "jsx", ".java": "java",
+            ".rs": "rust", ".go": "go", ".cpp": "cpp",
+        }
+        derived_language = lang_map.get(ext, ext.lstrip("."))
 
         if not _TS_AVAILABLE:
             return {
                 "file": str(path),
-                "language": ext.lstrip("."),
+                "language": derived_language,
                 "error": "tree-sitter not installed — run: pip install tree-sitter tree-sitter-python tree-sitter-typescript ...",
                 "classes": [],
                 "functions": [],
@@ -1511,7 +1534,7 @@ def extract_skeleton(file_path: str) -> dict:
         if parser is None:
             return {
                 "file": str(path),
-                "language": ext.lstrip("."),
+                "language": derived_language,
                 "error": f"Unsupported file type: {ext}",
                 "classes": [],
                 "functions": [],
@@ -1526,7 +1549,7 @@ def extract_skeleton(file_path: str) -> dict:
         if handler is None:
             return {
                 "file": str(path),
-                "language": ext.lstrip("."),
+                "language": derived_language,
                 "error": f"No skeleton handler for {ext}",
                 "classes": [],
                 "functions": [],
@@ -1534,12 +1557,6 @@ def extract_skeleton(file_path: str) -> dict:
                 "docstrings": {},
             }
 
-        lang_map = {
-            ".py": "python", ".ts": "typescript", ".tsx": "tsx",
-            ".js": "javascript", ".jsx": "jsx", ".java": "java",
-            ".rs": "rust", ".go": "go", ".cpp": "cpp",
-        }
-
         if ext == ".py":
             body = handler(tree.root_node, source_bytes)
         else:
@@ -1547,14 +1564,22 @@ def extract_skeleton(file_path: str) -> dict:
 
         return {
             "file": str(path),
-            "language": lang_map.get(ext, ext.lstrip(".")),
+            "language": derived_language,
             **body,
         }
 
     except Exception as e:
+        # Fallback if path is not yet defined
+        lang = "unknown"
+        if 'derived_language' in locals():
+            lang = derived_language
+        elif 'file_path' in locals():
+            ext = Path(file_path).suffix.lower()
+            lang = lang_map.get(ext, ext.lstrip(".")) if 'lang_map' in locals() else ext.lstrip(".")
+
         return {
             "file": str(file_path),
-            "language": "unknown",
+            "language": lang,
             "error": str(e),
             "classes": [],
             "functions": [],

package/python/query_engine.py

@@ -96,7 +96,7 @@ def _keyword_score(query_terms: list[str], file_path: str, idf_weights: dict[str
     for term in query_terms:
         # Exact match on filename
         if term in filename_toks:
-            score += 2.0 * idf_weights.get(term, 1.0)   # Massive signal
+            score += 4.0 * idf_weights.get(term, 1.0)   # Massive signal
             matched.append(term)
         # Substring or abbreviation match on filename
         elif len(term) >= 2 and any(
@@ -104,11 +104,11 @@ def _keyword_score(query_terms: list[str], file_path: str, idf_weights: dict[str
             all(c in iter(ft) for c in term)
             for ft in filename_toks
         ):
-            score += 1.5 * idf_weights.get(term, 1.0)
+            score += 3.0 * idf_weights.get(term, 1.0)
             matched.append(term)
         # Exact match on path
         elif term in path_toks:
-            score += 0.8 * idf_weights.get(term, 1.0)   # Strong signal
+            score += 2.0 * idf_weights.get(term, 1.0)   # Strong signal
             if term not in matched:
                 matched.append(term)
         # Substring or abbreviation match on path
@@ -117,14 +117,16 @@ def _keyword_score(query_terms: list[str], file_path: str, idf_weights: dict[str
             all(c in iter(pt) for c in term)
             for pt in path_toks
         ):
-            score += 0.4 * idf_weights.get(term, 1.0)
+            score += 1.5 * idf_weights.get(term, 1.0)
             if term not in matched:
                 matched.append(term)
 
     # Normalize by max possible score (sum of all IDFs)
     max_score = sum(idf_weights.get(t, 1.0) for t in query_terms)
     if max_score > 0:
-        score = min(1.0, score / max_score) # Cap at 1.0 since we have massive multipliers
+        base_normalized = min(1.0, sum(idf_weights.get(t, 1.0) for t in matched) / max_score)
+        bonus = score - sum(idf_weights.get(t, 1.0) for t in matched)
+        score = base_normalized + max(0, bonus)
 
     return score, matched
 
@@ -362,8 +364,9 @@ def query(
         content_scores[path] = cscore
         matched_terms[path] = list(set(kterms + cterms))
         
-        # Base combination: 50/50 keyword vs content
-        combined = (kscore * 0.5) + (cscore * 0.5)
+        # Base combination: heavily weight filename/path matches (70%) over content matches (30%)
+        # This prevents transitive consumers of a file from out-ranking the file itself
+        combined = (kscore * 0.7) + (cscore * 0.3)
         
         # Tiebreaker: Slightly penalize deep paths so src/x.py wins over build/npm/python/x.py
         depth_penalty = 0.0001 * path.count("/")