contextl 1.2.19 → 1.2.21

package/README.md

@@ -90,9 +90,11 @@ Walks the dependency graph upstream from any file to find every direct and trans
 Lists every source file `contextl` can see — useful for the agent to orient itself before doing anything else.
 
 ### `find_dead_files`
-*"Which files are never imported by anything?"*
+Find files in the repository that are never imported by any other file (in-degree of 0 in the dependency graph). 
 
-Finds unused files and dead code by analyzing the dependency graph for files with an in-degree of 0. Automatically filters out standard entry points (like `page.tsx` or `index.ts`) and test files.
+*Note: The engine automatically detects and excludes standard entry points (e.g. `src/index.ts`, `main.py`, `app.tsx`) and test files from these results, as they are intentionally not imported by other files.*
+
+**Arguments:**
 
 ```json
 {

package/package.json

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

package/python/graph_builder.py

@@ -163,6 +163,15 @@ def build_graph(scan_result, parse_result: ParseResult) -> RepoGraph:
     # Compute PageRank (importance score)
     try:
         pagerank = nx.pagerank(G, alpha=0.85)
+        
+        # Penalize cycle-locked nodes to prevent inflation
+        sccs = [scc for scc in nx.strongly_connected_components(G) if len(scc) > 1]
+        for scc in sccs:
+            for node in scc:
+                # If a node only has incoming edges from within its own cycle, dampen it
+                predecessors = set(G.predecessors(node))
+                if predecessors.issubset(scc):
+                    pagerank[node] *= 0.1
     except nx.PowerIterationFailedConvergence:
         pagerank = {n: 1.0 / len(G.nodes) for n in G.nodes}
 

package/python/impact_analysis.py

@@ -40,14 +40,24 @@ class ImpactReport:
     transitively_affected: list[ImpactedFile] = field(default_factory=list)
     test_files: list[str] = field(default_factory=list)
     total_affected: int = 0
+    cycle_detected: bool = False
+    cycle_members: list[str] = field(default_factory=list)
+    risk_score: float = 0.0
 
     def summary(self) -> str:
         lines = [
             f"Impact analysis for: {self.target}",
             f"Total affected files: {self.total_affected}",
+            f"Risk score: {self.risk_score:.1f}",
             "",
         ]
 
+        if self.cycle_detected:
+            lines.append("⚠️ WARNING: Circular dependency detected ⚠️")
+            lines.append(f"This file is part of a cycle containing {len(self.cycle_members)} files.")
+            lines.append("Members: " + ", ".join(self.cycle_members))
+            lines.append("")
+
         if self.directly_affected:
             lines.append("Directly affected (import this file):")
             for f in self.directly_affected:
@@ -117,6 +127,9 @@ def analyze_impact(
     Raises:
         ValueError: If target_file is not found in the graph.
     """
+    if not target_file:
+        raise ValueError("target_file cannot be empty")
+
     if target_file not in repo_graph.nodes:
         raise ValueError(
             f"File not found in repository graph: {target_file}. "
@@ -170,6 +183,20 @@ def analyze_impact(
 
     report.total_affected = len(report.directly_affected) + len(report.transitively_affected)
 
+    import networkx as nx
+    sccs = [scc for scc in nx.strongly_connected_components(repo_graph.graph) if len(scc) > 1]
+    for scc in sccs:
+        if target_file in scc:
+            report.cycle_detected = True
+            report.cycle_members = list(scc)
+            break
+            
+    target_node = repo_graph.nodes.get(target_file)
+    in_degree = target_node.in_degree if target_node else 0
+    report.risk_score = (in_degree * 0.5) + (len(report.transitively_affected) * 0.2)
+    if report.cycle_detected:
+        report.risk_score += len(report.cycle_members) * 0.8
+
     return report
 
 

package/python/import_parser.py

@@ -563,8 +563,15 @@ def _find_file_in_repo(
         for path in file_index:
             if path.endswith(suffix) or path == py_ext:
                 return path
+                
+        # Fallback for Python cross-language imports (e.g. from tests to .ts/.js core logic)
+        for ext in [".ts", ".tsx", ".js", ".jsx", ".java", ".go", ".rs", ".cpp", ".cc", ".cxx", ".h", ".hpp", ".c"]:
+            alt_suffix = "/" + candidate_str + ext
+            alt_matches = [p for p in file_index if p.endswith(alt_suffix) or p == alt_suffix.lstrip("/")]
+            if len(alt_matches) == 1:
+                return alt_matches[0]
+                
         return None
-
     for ext in [".tsx", ".ts", ".jsx", ".js"]:
         with_ext = candidate_str + ext
         if with_ext in file_index:
@@ -578,13 +585,7 @@ def _find_file_in_repo(
         if mod_path in file_index:
             return mod_path
 
-    if extension == ".py":
-        candidate_suffix = "/" + candidate_str + ".py"
-        matches = [p for p in file_index if p.endswith(candidate_suffix)]
-        if len(matches) == 1:
-            return matches[0]
 
-    return None
 
 
 def _load_tsconfig_paths(tsconfig_path: Path) -> dict:

package/python/mcp_server.py

@@ -58,7 +58,7 @@ from import_parser import extract_skeleton
 @dataclass
 class _CacheEntry:
     repo_path: str          # resolved absolute path
-    mtime_hash: float       # max mtime across all source files at build time
+    mtime_hash: tuple[float, int]       # max mtime across all source files at build time, and total file count
     scan: object            # ScanResult
     repo_graph: object      # RepoGraph
     last_checked_time: float = 0.0
@@ -68,9 +68,10 @@ _cache_lock = threading.Lock()
 _cache: dict[str, _CacheEntry] = {}
 
 
-def _compute_mtime_hash(repo_path: str) -> float:
-    """Walk repo_path and return the maximum file modification time."""
+def _compute_mtime_hash(repo_path: str) -> tuple[float, int]:
+    """Walk repo_path and return (maximum file modification time, file count)."""
     max_mtime = 0.0
+    file_count = 0
     for dirpath, _, filenames in os.walk(repo_path):
         # Skip hidden dirs and common noise dirs
         dirpath_obj = Path(dirpath)
@@ -82,9 +83,10 @@ def _compute_mtime_hash(repo_path: str) -> float:
                 mtime = os.path.getmtime(os.path.join(dirpath, fname))
                 if mtime > max_mtime:
                     max_mtime = mtime
+                file_count += 1
             except OSError:
                 pass
-    return max_mtime
+    return (max_mtime, file_count)
 
 
 def _get_graph(repo_path: str):

package/python/obsidian_export.py

@@ -52,11 +52,15 @@ def _extract_file_context(file_path: str, extension: str, root_dir: str) -> tupl
     return explanation, outline, snippet
 
 
-def export_obsidian_vault(repo_graph: RepoGraph, output_dir: str) -> str:
+def export_obsidian_vault(repo_path: str, output_dir: str) -> str:
     """
     Generates a markdown file for every node in the graph in a hierarchical folder structure, 
     with Obsidian wikilinks connecting them based on imports.
     """
+    scan = scan_repo(repo_path)
+    parse = parse_imports(scan)
+    repo_graph = build_graph(scan, parse)
+
     out_path = Path(output_dir).resolve()
     
     if out_path.exists():

package/python/query_engine.py

@@ -98,7 +98,7 @@ def _keyword_score(query_terms: list[str], file_path: str, idf_weights: dict[str
             score += 2.0 * idf_weights.get(term, 1.0)   # Massive signal
             matched.append(term)
         # Substring match on filename
-        elif len(term) > 3 and any(term in ft for ft in filename_toks):
+        elif len(term) >= 2 and any(term in ft for ft in filename_toks) or any(len(ft) >= 2 and ft in term for ft in filename_toks):
             score += 1.5 * idf_weights.get(term, 1.0)
             matched.append(term)
         # Exact match on path
@@ -107,7 +107,7 @@ def _keyword_score(query_terms: list[str], file_path: str, idf_weights: dict[str
             if term not in matched:
                 matched.append(term)
         # Substring match on path
-        elif len(term) > 3 and any(term in pt for pt in path_toks):
+        elif len(term) >= 2 and any(term in pt for pt in path_toks) or any(len(pt) >= 2 and pt in term for pt in path_toks):
             score += 0.4 * idf_weights.get(term, 1.0)
             if term not in matched:
                 matched.append(term)
@@ -186,7 +186,7 @@ def _content_score(query_terms: list[str], file_path: str, file_content: str, id
         for ct in content_tokens_list:
             if t == ct:
                 count += 1
-            elif len(t) > 3 and t in ct:
+            elif len(t) >= 2 and (t in ct or (len(ct) >= 2 and ct in t)):
                 count += 1
         if count > 0:
             term_counts[t] = count
@@ -322,9 +322,9 @@ def query(
         for term in query_terms:
             if term in combined_tokens:
                 document_frequency[term] += 1
-            elif len(term) > 3:
+            elif len(term) >= 2:
                 for ct in combined_tokens:
-                    if term in ct:
+                    if term in ct or (len(ct) >= 2 and ct in term):
                         document_frequency[term] += 1
                         break
 
@@ -381,6 +381,13 @@ def query(
             matched_terms=matched_terms.get(path, []),
         ))
 
+    # Down-rank test files unless the user specifically searched for tests
+    is_test_query = "test" in query_str.lower() or "spec" in query_str.lower()
+    from impact_analysis import _is_test_file
+    for r in results:
+        if _is_test_file(r.path) and not is_test_query:
+            r.total_score *= 0.5
+
     # Sort by total score descending
     results.sort(key=lambda r: r.total_score, reverse=True)