contextl 1.2.5 → 1.2.7

package/README.md

@@ -84,7 +84,7 @@ Finds unused files and dead code by analyzing the dependency graph for files wit
 
 Takes the exact dependency graph built by the intelligence engine and physically writes it to disk as a directory of interconnected Markdown files. Automatically injects file metadata, JSDoc/Docstring explanations, and uses standard `[[wikilinks]]` to map out dependencies. Open the generated folder as an Obsidian vault for a stunning 3D interactive graph of your architecture!
 
----
+
 
 ## How the ranking works
 

package/package.json

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

package/python/query_engine.py

@@ -60,6 +60,7 @@ class RankedFile:
         )
 
 
+
 def _tokenize(text: str) -> list[str]:
     """Lowercase, split on non-alphanumeric, remove stop words."""
     tokens = re.findall(r"[a-z0-9]+", text.lower())
@@ -106,25 +107,64 @@ def _keyword_score(query_terms: list[str], file_path: str, idf_weights: dict[str
     return score, matched
 
 
-def _content_score(query_terms: list[str], file_content: str, idf_weights: dict[str, float]) -> tuple[float, list[str]]:
+def _content_score(query_terms: list[str], file_path: str, file_content: str, idf_weights: dict[str, float]) -> tuple[float, list[str]]:
     """
     Score how often query terms appear in the file's source code.
     Uses TF-IDF weighting, capped to avoid huge files dominating.
+    Includes language-specific heuristics for Java and other OOP languages.
     """
-    content_tokens = set(re.findall(r"[a-z0-9]+", file_content))
+    is_oop = file_path.endswith(".java") or file_path.endswith(".ts") or file_path.endswith(".tsx")
+    content_tokens = set(re.findall(r"[a-z0-9]+", file_content.lower()))
+    
+    # 1. CamelCase Splitting
+    if is_oop:
+        camel_tokens = []
+        for word in re.findall(r"[a-zA-Z]+", file_content):
+            if any(c.isupper() for c in word):
+                sub = re.sub(r"([A-Z])", r" \1", word).lower()
+                camel_tokens.extend(re.findall(r"[a-z0-9]+", sub))
+        content_tokens.update([t for t in camel_tokens if len(t) > 1])
+
+    # 2. Extract Class Declarations & Annotations
+    declared_classes = set()
+    if is_oop or file_path.endswith(".py"):
+        decls = re.findall(r"\b(?:class|interface|enum)\s+([a-zA-Z0-9_]+)", file_content)
+        for d in decls:
+            declared_classes.add(d.lower())
+            
+    annotations = set()
+    if is_oop or file_path.endswith(".py"):
+        anns = re.findall(r"@([a-zA-Z0-9_]+)", file_content)
+        for a in anns:
+            annotations.add(a.lower())
+
     matched = [t for t in query_terms if t in content_tokens]
 
     if not query_terms:
         return 0.0, []
 
-    score = sum(idf_weights.get(t, 1.0) for t in matched)
+    score = 0.0
+    for t in matched:
+        base_weight = idf_weights.get(t, 1.0)
+        multiplier = 1.0
+        
+        # 3. Apply Multipliers
+        if t in declared_classes:
+            multiplier = 10.0
+        elif t in annotations:
+            multiplier = 5.0
+            
+        score += (base_weight * multiplier)
+
     max_score = sum(idf_weights.get(t, 1.0) for t in query_terms)
     if max_score > 0:
-        score = score / max_score
+        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)
+        final_score = base_normalized + bonus
     else:
-        score = 0.0
+        final_score = 0.0
 
-    return score, matched
+    return final_score, matched
 
 
 def _apply_neighbor_bonus(
@@ -179,6 +219,7 @@ def query(
         return []
 
     # --- Pre-computation: Global TF-IDF ---
+    import pathlib
     total_files = len(repo_graph.nodes)
     document_frequency = {term: 0 for term in query_terms}
     
@@ -186,9 +227,18 @@ def query(
     for path, node in repo_graph.nodes.items():
         abs_path = node.path if hasattr(node, "absolute_path") else str(__import__("pathlib").Path(repo_graph.root) / path)
         try:
-            content = open(abs_path, encoding="utf-8").read().lower()
+            content = open(abs_path, encoding="utf-8").read()
             file_contents[path] = content
-            content_tokens = set(re.findall(r"[a-z0-9]+", content))
+            content_tokens = set(re.findall(r"[a-z0-9]+", content.lower()))
+            
+            if path.endswith(".java") or path.endswith(".ts") or path.endswith(".tsx"):
+                camel_tokens = []
+                for word in re.findall(r"[a-zA-Z]+", content):
+                    if any(c.isupper() for c in word):
+                        sub = re.sub(r"([A-Z])", r" \1", word).lower()
+                        camel_tokens.extend(re.findall(r"[a-z0-9]+", sub))
+                content_tokens.update([t for t in camel_tokens if len(t) > 1])
+                
             path_tokens = set(_path_tokens(path))
             combined_tokens = content_tokens.union(path_tokens)
             for term in query_terms:
@@ -209,7 +259,7 @@ def query(
 
     for path, node in repo_graph.nodes.items():
         kscore, kterms = _keyword_score(query_terms, path, idf_weights)
-        cscore, cterms = _content_score(query_terms, file_contents.get(path, ""), idf_weights)
+        cscore, cterms = _content_score(query_terms, path, file_contents.get(path, ""), idf_weights)
 
         keyword_scores[path] = kscore
         content_scores[path] = cscore