contextl 1.2.8 → 1.2.10

package/package.json

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

@@ -134,12 +134,26 @@ def _resolve_alias(import_path: str, alias_map: dict[str, str]) -> str | None:
 def _resolve_relative(import_path: str, source_file: str) -> str:
     """
     Resolve a relative import path against the source file's directory.
-    Example: source="frontend/app/page.tsx", import="../lib/api" → "frontend/lib/api"
+    Returns a repo-relative path string (NOT absolute).
+
+    Example: source="apps/web/src/routes.tsx", import="./App.tsx"
+             → "apps/web/src/App.tsx"
     """
-    source_dir = Path(source_file).parent
-    resolved = (source_dir / import_path).resolve()
-    # Make it relative again (we'll strip the absolute prefix below)
-    return str(resolved)
+    # Use pure PurePosixPath arithmetic — never call .resolve() which
+    # anchors to the OS cwd and produces a wrong absolute path.
+    from pathlib import PurePosixPath
+    source_dir = PurePosixPath(source_file).parent
+    # Normalise away any .. and . components without touching the filesystem
+    resolved = (source_dir / import_path)
+    # PurePosixPath doesn't have .resolve(), so manually normalise ".."
+    parts = []
+    for part in resolved.parts:
+        if part == "..":
+            if parts:
+                parts.pop()
+        elif part != ".":
+            parts.append(part)
+    return str(PurePosixPath(*parts)) if parts else "."
 
 
 def _find_file_in_repo(
@@ -210,41 +224,95 @@ def _find_file_in_repo(
     return None
 
 
-def _detect_alias_map(scan_result: ScanResult) -> dict[str, str]:
+def _load_tsconfig_paths(tsconfig_path: Path) -> dict:
     """
-    Auto-detect the @/ alias by finding tsconfig.json or next.config files
-    and inferring the project root. Falls back to a heuristic.
-    
-    Returns a map like {"@/": "frontend/"} or {"@/": ""}
+    Load compilerOptions.paths from a tsconfig.json, following `extends` chains.
+    Returns merged paths dict (child overrides parent).
     """
-    root = Path(scan_result.root)
-    alias_map = {}
-
-    # Look for tsconfig.json to find paths config
-    for tsconfig in root.rglob("tsconfig.json"):
+    import json
+    visited = set()
+    merged_paths = {}
+
+    def _load(path: Path):
+        if path in visited:
+            return
+        visited.add(path)
         try:
-            import json
-            # naive regex to strip comments from tsconfig before parsing
-            text = tsconfig.read_text()
-            text = re.sub(r'//.*?\n|/\*.*?\*/', '', text, flags=re.S)
+            text = path.read_text(encoding="utf-8")
+            pattern = r'(".*?(?<!\\)")|(/\*.*?\*/|//[^\r\n]*)'
+            text = re.sub(pattern, lambda m: m.group(1) if m.group(1) else '', text, flags=re.S)
             data = json.loads(text)
-            paths = data.get("compilerOptions", {}).get("paths", {})
-
-            for alias, targets in paths.items():
-                if not targets:
-                    continue
-                # "@/*": ["./src/*"] → strip trailing /* from both
-                clean_alias = alias.rstrip("/*").rstrip("*")
-                clean_target = targets[0].rstrip("/*").rstrip("*").lstrip("./")
-
-                tsconfig_dir = tsconfig.parent.relative_to(root)
-                prefix = str(tsconfig_dir / clean_target).lstrip("./")
-                alias_map[clean_alias + "/"] = prefix + "/" if prefix else ""
         except Exception:
+            return
+
+        # Follow extends first (parent paths are base, child overrides)
+        extends = data.get("extends")
+        if extends:
+            parent = (path.parent / extends).resolve()
+            # handle both with and without .json
+            if not parent.suffix:
+                parent = parent.with_suffix(".json")
+            _load(parent)
+
+        # Then apply this tsconfig's own paths (child wins)
+        paths = data.get("compilerOptions", {}).get("paths", {})
+        for alias, targets in paths.items():
+            if targets:
+                merged_paths[alias] = targets[0]
+
+    _load(tsconfig_path)
+    return merged_paths
+
+
+def _detect_alias_map(scan_result: ScanResult) -> dict[str, str]:
+    """
+    Auto-detect TypeScript path aliases by reading every tsconfig.json in the repo.
+    Each tsconfig's aliases are scoped relative to its own directory so that
+    multiple packages with conflicting @/* aliases don't clobber each other.
+
+    Returns a flat map:  alias_prefix -> resolved_repo_relative_prefix
+    e.g. {
+        '@/'            : 'packages/ui/src/',
+        '@components/'  : 'apps/web/src/components/',
+        '@core/'        : 'apps/web/src/core/',
+    }
+    """
+    root = Path(scan_result.root)
+    alias_map: dict[str, str] = {}
+
+    # Walk all tsconfig.json files (skip node_modules / build dirs)
+    ignore = {"node_modules", "dist", "build", ".next", "coverage", "out"}
+    tsconfigs = []
+    for tc in root.rglob("tsconfig.json"):
+        if any(p in ignore for p in tc.parts):
             continue
+        tsconfigs.append(tc)
+
+    for tsconfig in tsconfigs:
+        tsconfig_dir = tsconfig.parent
+        paths = _load_tsconfig_paths(tsconfig)
+
+        for alias, target in paths.items():
+            # Normalise: strip trailing /* or *
+            clean_alias = alias.rstrip("/*").rstrip("*")
+            clean_target = target.rstrip("/*").rstrip("*").lstrip("./")
+
+            # Resolve target relative to the tsconfig's own directory
+            resolved = (tsconfig_dir / clean_target).resolve()
+            try:
+                repo_rel = str(resolved.relative_to(root))
+            except ValueError:
+                continue  # outside repo — skip
+
+            alias_key = clean_alias + "/"
+            target_val = repo_rel.replace("\\", "/") + "/"
+
+            # Only add if not already defined (first match / most specific wins)
+            if alias_key not in alias_map:
+                alias_map[alias_key] = target_val
 
     if not alias_map:
-        # Heuristic fallback: if all files share a common top-level dir, use that
+        # Heuristic fallback: single top-level source dir
         top_dirs = {Path(f.path).parts[0] for f in scan_result.files if Path(f.path).parts}
         if len(top_dirs) == 1:
             top = list(top_dirs)[0]

package/python/mcp_server.py

@@ -71,19 +71,12 @@ async def list_tools() -> list[types.Tool]:
                     "query": {
                         "type": "string",
                         "description": (
-                            "SYSTEM INSTRUCTION: You are a translation layer designed to convert human requests into highly optimized queries for the contextl codebase search engine. "
-                            "The contextl engine is NOT a semantic AI; it is an advanced, dependency-aware fuzzy keyword searcher. It relies on exact token matching and import-graph ranking.\n\n"
-                            "Your goal is to extract the core technical keywords from the user's request and discard all conversational filler or vague concepts.\n\n"
-                            "Rules for generating the query string:\n"
-                            "1. Remove Conversational Filler: Drop words like 'where is', 'how does', 'find the', 'show me'.\n"
-                            "2. Translate Concepts to Code: If the user asks for a concept, translate it into the exact keywords, classes, or library syntax a developer would type. (e.g., 'routing' -> 'createRouter Route routeTree', 'entry point' -> 'main bootstrap init').\n"
-                            "3. Include Known Framework Terms: Append standard terminology of the framework.\n"
-                            "4. Target File Types/Structures: Use terms like 'config', 'yaml', 'json' if looking for configurations.\n"
-                            "5. Keep it space-separated: Output a single string of space-separated keywords without punctuation.\n\n"
-                            "Examples:\n"
-                            "- 'Where are the main react components and routing defined?' -> 'createRouter Route routeTree components layout'\n"
-                            "- 'Find the application entry point and main method.' -> 'public static void main bootstrap init ApplicationContext configuration'\n"
-                            "- 'How is the user authentication handled?' -> 'login auth authenticate jwt token session passport'"
+                            "SYSTEM INSTRUCTION: The contextl search engine is highly optimized for both raw conversational queries AND exact keyword searches. "
+                            "It uses dynamic structural multipliers to instantly rank classes for short/conversational queries, and switches to BM25 frequency math for longer keyword queries.\n\n"
+                            "STRATEGY INSTRUCTION:\n"
+                            "1. INITIAL SEARCHES: Pass the user's raw natural-language query directly. Do NOT convert it to keywords. The engine is smart enough to drop stop-words and find the primary class anchors. Example: 'where is the auth logic?' -> 'where is the auth logic?'\n"
+                            "2. TARGETED DEBUG SEARCHES: If the initial search fails, or if you are deep into debugging and need to cross-reference very specific variables across the codebase, then convert the query into highly optimized, space-separated keywords. Example: 'auth failure bug' -> 'login jwt AuthController retry_count token'\n"
+                            "Never append generic filler words to targeted searches."
                         ),
                     },
                     "top_n": {

package/python/query_engine.py

@@ -161,6 +161,13 @@ def _content_score(query_terms: list[str], file_path: str, file_content: str, id
                 for part in re.findall(r"[a-z0-9]+", sub):
                     if len(part) > 3:
                         java_methods.add(part)
+                        
+    py_defs = set()
+    if file_path.endswith(".py"):
+        defs = re.findall(r"\b(?:def|async def)\s+([a-zA-Z0-9_]+)\s*\(", file_content)
+        for d in defs:
+            if d.lower() not in {"main", "init", "get", "set"}:
+                py_defs.add(d.lower())
             
     if is_ts:
         exports = re.findall(r"\bexport\s+(?:const|let|var|class|interface|function|default)\s+([a-zA-Z0-9_]+)", file_content)
@@ -213,7 +220,7 @@ def _content_score(query_terms: list[str], file_path: str, file_content: str, id
             multiplier = 8.0
         elif t in declared_classes:
             multiplier = class_mult
-        elif t in java_methods:
+        elif t in java_methods or t in py_defs:
             multiplier = 4.0
         elif t in annotations:
             multiplier = ann_mult
@@ -340,9 +347,10 @@ def query(
         if df == 0:
             idf_weights[term] = 0.0
         else:
-            idf_weights[term] = math.log(total_files / (1 + df)) if total_files > 0 else 1.0
+            idf_weights[term] = max(0.1, math.log(total_files / (1 + df))) if total_files > 0 else 1.0
 
     # --- Pass 1: keyword + content scores per file ---
+    base_scores: dict[str, float] = {}
     keyword_scores: dict[str, float] = {}
     content_scores: dict[str, float] = {}
     matched_terms: dict[str, list[str]] = {}
@@ -355,14 +363,15 @@ def query(
         keyword_scores[path] = kscore
         content_scores[path] = cscore
         matched_terms[path] = list(set(kterms + cterms))
-
-    # --- Pass 2: combine into base score ---
-    base_scores: dict[str, float] = {}
-    for path in repo_graph.nodes:
-        base_scores[path] = (
-            keyword_scores.get(path, 0.0) * 0.5 +
-            content_scores.get(path, 0.0) * 0.5
-        )
+        
+        # Base combination: 50/50 keyword vs content
+        combined = (kscore * 0.5) + (cscore * 0.5)
+        
+        # Tiebreaker: Slightly penalize deep paths so src/x.py wins over build/npm/python/x.py
+        depth_penalty = 0.0001 * path.count("/")
+        combined -= depth_penalty
+        
+        base_scores[path] = combined
 
     # --- Pass 3: neighbor bonus ---
     boosted_scores = _apply_neighbor_bonus(base_scores, repo_graph)

package/python/scanner.py

@@ -7,24 +7,23 @@ Filters by supported extensions for the MVP (Next.js / React / TypeScript).
 """
 
 import os
+import pathlib
 from pathlib import Path
 from dataclasses import dataclass, field
 
 
 SUPPORTED_EXTENSIONS = {".tsx", ".ts", ".jsx", ".js", ".py", ".java"}
 
-IGNORED_DIRS = {
-    "node_modules",
-    ".git",
-    ".next",
-    "dist",
-    "build",
-    ".cache",
-    "__pycache__",
-    ".turbo",
-    "coverage",
+ignore_dirs = {
+    ".git", "node_modules", "__pycache__", "venv", ".venv",
+    "env", ".env", ".next", ".nuxt", "out", "build", "dist",
+    "coverage", ".nyc_output", ".pytest_cache", "npm", "pypi"
 }
 
+def _should_ignore(path: str) -> bool:
+    parts = pathlib.Path(path).parts
+    return any(part in ignore_dirs for part in parts)
+
 
 @dataclass
 class ScannedFile:
@@ -87,7 +86,7 @@ def scan_repo(repo_path: str) -> ScanResult:
 
     for dirpath, dirnames, filenames in os.walk(root):
         # Prune ignored directories in-place so os.walk skips them
-        dirnames[:] = [d for d in dirnames if d not in IGNORED_DIRS]
+        dirnames[:] = [d for d in dirnames if d not in ignore_dirs]
 
         for filename in filenames:
             filepath = Path(dirpath) / filename