codegraphcontext 0.6.2__tar.gz → 0.6.3__tar.gz

{codegraphcontext-0.6.2/src/codegraphcontext.egg-info → codegraphcontext-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.6.2
+Version: 0.6.3
 Summary: An MCP server that indexes local code into a graph database to provide context to AI assistants.
 Author-email: Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 License: MIT License

{codegraphcontext-0.6.2 → codegraphcontext-0.6.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.6.2"
+version = "0.6.3"
 description = "An MCP server that indexes local code into a graph database to provide context to AI assistants."
 authors = [{ name = "Shashank Shekhar Singh", email = "shashankshekharsingh1205@gmail.com" }]
 readme = "README.md"

{codegraphcontext-0.6.2 → codegraphcontext-0.6.3}/src/codegraphcontext/cli/cli_helpers.py

@@ -123,6 +123,10 @@ def _print_index_execution_summary(graph_builder: GraphBuilder) -> None:
         f"{summary.get('serialization_seconds', 0.0):.2f}",
     )
     console.print(table)
+    # Always-visible warnings (#1597): these describe an explicitly enabled
+    # feature that did NOT run — they must not depend on the log level.
+    for warning in summary.get("warnings", []):
+        console.print(f"[bold yellow]⚠ {warning}[/bold yellow]")
 
 
 def _initialize_services(

{codegraphcontext-0.6.2 → codegraphcontext-0.6.3}/src/codegraphcontext/cli/config_manager.py

@@ -685,6 +685,21 @@ def set_config_value(key: str, value: str) -> bool:
     save_config(config)
     
     console.print(f"[green]✅ Set {key} = {value}[/green]")
+
+    # Surface a missing embedding backend at the moment of intent, not after
+    # an index run that silently generated nothing (#1597).
+    if key == "ENABLE_VECTOR_RESOLVE" and value.lower() == "true":
+        try:
+            from codegraphcontext.tools.indexing.embeddings import probe_embedding_backend
+            ok, detail = probe_embedding_backend()
+            if not ok:
+                console.print(
+                    f"[bold yellow]⚠ Vector resolve is enabled but cannot run yet: "
+                    f"{detail}. Indexing will proceed without embeddings until "
+                    f"this is installed.[/bold yellow]"
+                )
+        except Exception:
+            pass
     return True
 
 

{codegraphcontext-0.6.2 → codegraphcontext-0.6.3}/src/codegraphcontext/cli/main.py

@@ -1149,6 +1149,96 @@ def export_shortcut(
         context=context,
     )
 
+@app.command("diagram")
+def diagram(
+    path: Optional[str] = typer.Argument(None, help="Repository path to scope the diagram to"),
+    output_format: str = typer.Option("mermaid", "--format", help="Diagram format: mermaid or dot (#1287)"),
+    level: str = typer.Option("file", "--level", help="Granularity: 'file' (file→module imports) or 'call' (function call graph)"),
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Write to a file instead of stdout"),
+    limit: int = typer.Option(300, "--limit", "-l", help="Maximum edges to include (truncation is reported in the diagram)"),
+    context: Optional[str] = typer.Option(None, "--context", "-c", help="Specific context to use"),
+):
+    """
+    Export the context graph as a Mermaid or Graphviz DOT diagram.
+
+    Mermaid output pastes straight into GitHub Markdown / Notion; DOT renders
+    locally with graphviz. The diagram is a generated artifact of the current
+    index — regenerate it after refactors rather than committing it as
+    documentation.
+
+    Example:
+        cgc diagram . > architecture.mmd
+        cgc diagram . --format dot -o graph.dot && dot -Tsvg graph.dot -o graph.svg
+        cgc diagram . --level call --limit 100
+    """
+    output_format = output_format.lower()
+    if output_format not in ("mermaid", "dot"):
+        console.print(f"[red]Unknown --format '{output_format}' (expected mermaid or dot)[/red]")
+        raise typer.Exit(code=2)
+    if level not in ("file", "call"):
+        console.print(f"[red]Unknown --level '{level}' (expected file or call)[/red]")
+        raise typer.Exit(code=2)
+    if output is None:
+        # stdout carries only the diagram; init chatter goes to stderr.
+        import sys as _sys
+        from . import cli_helpers as _cli_helpers
+        _cli_helpers.console.file = _sys.stderr
+
+    _load_credentials()
+    services = _initialize_services(context)
+    if not all(services[:3]):
+        raise typer.Exit(code=1)
+    db_manager, graph_builder, code_finder = services[:3]
+
+    try:
+        repo_path = Path(path).resolve().as_posix() if path else None
+        result = code_finder.export_diagram_edges(level=level, repo_path=repo_path, limit=limit)
+    finally:
+        db_manager.close_driver()
+
+    edges = result["edges"]
+    ids: dict = {}
+
+    def _node_id(name: str) -> str:
+        if name not in ids:
+            ids[name] = f"n{len(ids)}"
+        return ids[name]
+
+    lines = []
+    if output_format == "mermaid":
+        lines.append("graph LR")
+        if result["truncated"]:
+            lines.append(f"    %% truncated: showing {len(edges)} of {result['total_count']} edges (raise --limit)")
+        for src, dst in edges:
+            sid, did = _node_id(src), _node_id(dst)
+            s_label = src.replace('"', "'")
+            d_label = dst.replace('"', "'")
+            lines.append(f'    {sid}["{s_label}"] --> {did}["{d_label}"]')
+        if not edges:
+            lines.append("    %% no edges found for this scope")
+    else:
+        lines.append("digraph cgc {")
+        lines.append("    rankdir=LR;")
+        if result["truncated"]:
+            lines.append(f"    // truncated: showing {len(edges)} of {result['total_count']} edges (raise --limit)")
+        for src, dst in edges:
+            sid, did = _node_id(src), _node_id(dst)
+            lines.append(f'    {sid} -> {did};')
+        for name, nid in ids.items():
+            label = name.replace('"', "'")
+            lines.append(f'    {nid} [label="{label}"];')
+        lines.append("}")
+
+    text = "\n".join(lines) + "\n"
+    if output:
+        Path(output).write_text(text, encoding="utf-8")
+        console.print(f"[green]✅ Wrote {output_format} diagram ({len(edges)} edges) to {output}[/green]")
+        if result["truncated"]:
+            console.print(f"[yellow]⚠ Truncated: {result['total_count']} total edges; raise --limit to include all[/yellow]")
+    else:
+        print(text, end="")
+
+
 @app.command("load", rich_help_panel="Bundle Shortcuts")
 def load_shortcut(
     bundle_name: str = typer.Argument(..., help="Bundle name or path to load"),
@@ -2905,9 +2995,11 @@ def analyze_inheritance_tree(
 def analyze_complexity(
     path: Optional[str] = typer.Argument(None, help="Function name or file path to analyze"),
     threshold: Optional[int] = typer.Option(None, "--threshold", "-t", help="Complexity threshold for warnings (default: from config or 10)"),
-    limit: int = typer.Option(20, "--limit", "-l", help="Maximum results to show"),
+    limit: Optional[int] = typer.Option(None, "--limit", "-l", help="Maximum results to show (default 20 for text; unlimited for json/csv)"),
     file: Optional[str] = typer.Option(None, "--file", "-f", help="Specific file path to scope analysis"),
     context: Optional[str] = typer.Option(None, "--context", "-c", help="Specific context to use"),
+    output_format: str = typer.Option("text", "--format", help="Output format: text, json or csv (#1333)"),
+    fail_on_violations: bool = typer.Option(False, "--fail-on-violations", help="Exit with code 1 when any function exceeds the threshold (CI gate)"),
 ):
     """
     Show cyclomatic complexity for functions.
@@ -2920,7 +3012,19 @@ def analyze_complexity(
         cgc analyze complexity src/main.py        # Most complex functions in file
         cgc analyze complexity main.py            # Most complex functions in file
         cgc analyze complexity --file src/main.py # Alternative file syntax
-    """
+        cgc analyze complexity -t 10 --format json --fail-on-violations  # CI gate
+    """
+    output_format = output_format.lower()
+    if output_format not in ("text", "json", "csv"):
+        console.print(f"[red]Unknown --format '{output_format}' (expected text, json or csv)[/red]")
+        raise typer.Exit(code=2)
+    if output_format in ("json", "csv"):
+        # stdout must carry ONLY the parseable document: the service-init
+        # chatter from cli_helpers prints to stdout, so reroute that console
+        # to stderr before initializing anything (`--format json | jq .`).
+        import sys as _sys
+        from . import cli_helpers as _cli_helpers
+        _cli_helpers.console.file = _sys.stderr
     _load_credentials()
     services = _initialize_services(context)
     if not all(services[:3]):
@@ -2938,6 +3042,47 @@ def analyze_complexity(
         else:
             threshold = 10
 
+    machine_output = output_format in ("json", "csv")
+    # Enforcement and export need the full set: a display page must never
+    # truncate the violation count a CI gate acts on (#1333).
+    effective_limit = limit if limit is not None else (None if (machine_output or fail_on_violations) else 20)
+
+    def _violations_from(results):
+        rows = []
+        for func in results or []:
+            # The synthetic `<module>` frame is the attribution target for
+            # module-level calls, not a function anyone can refactor.
+            if func.get("function_name") == "<module>":
+                continue
+            complexity = func.get("complexity", 0) or 0
+            if complexity > threshold:
+                rows.append({
+                    "function": func.get("function_name", ""),
+                    "file": func.get("path", ""),
+                    "line": func.get("line_number"),
+                    "complexity": complexity,
+                    "exceeds_by": complexity - threshold,
+                })
+        return rows
+
+    def _emit_machine(violations):
+        import csv as _csv
+        import io as _io
+        import json as _json
+        if output_format == "json":
+            print(_json.dumps({
+                "threshold": threshold,
+                "violations_count": len(violations),
+                "violations": violations,
+            }, indent=2))
+        else:
+            buf = _io.StringIO()
+            w = _csv.writer(buf)
+            w.writerow(["function", "file", "line", "complexity", "exceeds_by"])
+            for v in violations:
+                w.writerow([v["function"], v["file"], v["line"], v["complexity"], v["exceeds_by"]])
+            print(buf.getvalue(), end="")
+
     _FILE_EXTENSIONS = ('.py', '.js', '.ts', '.jsx', '.tsx', '.go', '.rs', '.rb',
                         '.java', '.cpp', '.c', '.cs', '.swift', '.kt', '.scala',
                         '.php', '.lua', '.zig', '.ex', '.exs', '.r', '.m', '.sh')
@@ -2970,15 +3115,31 @@ def analyze_complexity(
         console.print(table)
         console.print(f"\n[dim]{len([f for f in results if f.get('complexity', 0) > threshold])} function(s) exceed threshold[/dim]")
 
+    violations = None
     try:
         if path and _is_file_path(path):
             # File path provided as positional argument
-            results = code_finder.find_most_complex_functions_in_file(path, limit)
-            _render_complexity_table(results, f"Most Complex Functions in '{path}' (threshold: {threshold}):")
+            results = code_finder.find_most_complex_functions_in_file(path, effective_limit)
+            violations = _violations_from(results)
+            if machine_output:
+                _emit_machine(violations)
+            else:
+                _render_complexity_table(results, f"Most Complex Functions in '{path}' (threshold: {threshold}):")
         elif path:
             # Specific function name
             result = code_finder.get_cyclomatic_complexity(path, file)
+            single = []
             if result:
+                single = [{
+                    "function_name": path,
+                    "path": result.get("path", ""),
+                    "line_number": result.get("line_number"),
+                    "complexity": result.get("complexity", 0) or 0,
+                }]
+            violations = _violations_from(single)
+            if machine_output:
+                _emit_machine(violations)
+            elif result:
                 console.print(f"\n[bold cyan]Complexity for '{path}':[/bold cyan]")
                 console.print(f"  Cyclomatic Complexity: [yellow]{result.get('complexity', 'N/A')}[/yellow]")
                 console.print(f"  File: [dim]{result.get('path', '')}[/dim]")
@@ -2987,20 +3148,36 @@ def analyze_complexity(
                 console.print(f"[yellow]Function '{path}' not found or has no complexity data[/yellow]")
         elif file:
             # --file option without positional arg
-            results = code_finder.find_most_complex_functions_in_file(file, limit)
-            _render_complexity_table(results, f"Most Complex Functions in '{file}' (threshold: {threshold}):")
+            results = code_finder.find_most_complex_functions_in_file(file, effective_limit)
+            violations = _violations_from(results)
+            if machine_output:
+                _emit_machine(violations)
+            else:
+                _render_complexity_table(results, f"Most Complex Functions in '{file}' (threshold: {threshold}):")
         else:
             # Global - most complex functions
-            results = code_finder.find_most_complex_functions(limit)
-            _render_complexity_table(results, f"Most Complex Functions (threshold: {threshold}):")
+            results = code_finder.find_most_complex_functions(effective_limit)
+            violations = _violations_from(results)
+            if machine_output:
+                _emit_machine(violations)
+            else:
+                _render_complexity_table(results, f"Most Complex Functions (threshold: {threshold}):")
     finally:
         db_manager.close_driver()
 
+    # CI gate (#1333): explicit opt-in keeps exploratory usage exit-0 —
+    # the config default threshold means most codebases have *some*
+    # function above it, and failing every casual invocation would break
+    # innocent `cgc analyze complexity && …` chains.
+    if fail_on_violations and violations:
+        raise typer.Exit(code=1)
+
 @analyze_app.command("dead-code")
 def analyze_dead_code(
     path: Optional[str] = typer.Argument(None, help="Repository path to scope the analysis to"),
     exclude_decorators: Optional[str] = typer.Option(None, "--exclude", "-e", help="Comma-separated decorators to exclude"),
     context: Optional[str] = typer.Option(None, "--context", "-c", help="Specific context to use"),
+    show_all: bool = typer.Option(False, "--show-all", help="Include low-confidence rows (dunders, test hooks, entry-point names) normally hidden (#1332)"),
 ):
     """
     Find potentially unused functions.
@@ -3030,7 +3207,8 @@ def analyze_dead_code(
         # of table rows. The true count comes from total_count below (#1606).
         display_limit = get_tool_result_limit("find_dead_code")
         results = code_finder.find_dead_code(
-            exclude_list, repo_path=repo_path, limit=display_limit
+            exclude_list, repo_path=repo_path, limit=display_limit,
+            include_low_confidence=show_all,
         )
 
         unused_funcs = results.get('potentially_unused_functions', [])
@@ -3042,16 +3220,22 @@ def analyze_dead_code(
         
         table = Table(show_header=True, header_style="bold magenta", box=box.ROUNDED)
         table.add_column("Function", style="cyan")
+        table.add_column("Confidence", justify="center")
         table.add_column("Location", style="dim", overflow="fold")
-        
+
+        _conf_render = {
+            "high": "[red]● high[/red]",
+            "medium": "[yellow]● medium[/yellow]",
+            "low": "[dim]● low[/dim]",
+        }
         for func in unused_funcs:
-            path = func.get('path', '')
+            fpath = func.get('path', '')
             line_str = str(func.get('line_number', ''))
-            location_str = f"{path}:{line_str}" if line_str else path
-
+            location_str = f"{fpath}:{line_str}" if line_str else fpath
             table.add_row(
                 func.get('function_name', ''),
-                location_str
+                _conf_render.get(func.get('confidence', 'high'), func.get('confidence', '')),
+                location_str,
             )
         
         console.print("\n[bold yellow]⚠️  Potentially Unused Functions:[/bold yellow]")
@@ -3063,6 +3247,16 @@ def analyze_dead_code(
             )
         else:
             console.print(f"\n[dim]Total: {total_count} function(s)[/dim]")
+        counts = results.get('confidence_counts') or {}
+        if counts:
+            summary = (
+                f"[red]{counts.get('high', 0)} high[/red], "
+                f"[yellow]{counts.get('medium', 0)} medium[/yellow], "
+                f"[dim]{counts.get('low', 0)} low[/dim] confidence"
+            )
+            if not show_all:
+                summary += " [dim](low-confidence categories are hidden — use --show-all)[/dim]"
+            console.print(summary)
         console.print(f"[dim]Note: {results.get('note', '')}[/dim]")
     finally:
         db_manager.close_driver()

{codegraphcontext-0.6.2 → codegraphcontext-0.6.3}/src/codegraphcontext/core/watcher.py

@@ -324,14 +324,26 @@ class RepositoryEventHandler(FileSystemEventHandler):
             _inherit_enabled = False
 
         if _vector_enabled:
-            try:
-                from codegraphcontext.tools.indexing.embeddings import EmbeddingPipeline
-                embed_pipeline = EmbeddingPipeline(self.graph_builder.driver)
-                embed_pipeline.invalidate_for_file(changed_path_str)
-                embed_pipeline.run(str(self.repo_path))
-                info_logger(f"[EMBED] Incremental embedding complete for {changed_path_str}")
-            except Exception as _e:
-                warning_logger(f"[EMBED] Incremental embedding failed: {_e}")
+            # Probe once per handler: with no backend installed, the old code
+            # re-attempted (and re-failed) the import on every file event and
+            # only said so at a suppressed log level (#1597).
+            if not hasattr(self, "_embed_backend_ok"):
+                from codegraphcontext.tools.indexing.embeddings import probe_embedding_backend
+                self._embed_backend_ok, _detail = probe_embedding_backend()
+                if not self._embed_backend_ok:
+                    error_logger(
+                        f"[EMBED] ENABLE_VECTOR_RESOLVE=true but incremental embeddings "
+                        f"cannot run: {_detail} (reported once; further file events skip this)"
+                    )
+            if self._embed_backend_ok:
+                try:
+                    from codegraphcontext.tools.indexing.embeddings import EmbeddingPipeline
+                    embed_pipeline = EmbeddingPipeline(self.graph_builder.driver)
+                    embed_pipeline.invalidate_for_file(changed_path_str)
+                    embed_pipeline.run(str(self.repo_path))
+                    info_logger(f"[EMBED] Incremental embedding complete for {changed_path_str}")
+                except Exception as _e:
+                    warning_logger(f"[EMBED] Incremental embedding failed: {_e}")
 
         if _inherit_enabled:
             try:

{codegraphcontext-0.6.2 → codegraphcontext-0.6.3}/src/codegraphcontext/tools/code_finder.py

@@ -44,6 +44,41 @@ _ANDROID_ENTRY_POINT_NAMES = (
     "onconfigurationchanged", "onlowmemory", "ontrimmemory",
     "onbindviewholder", "oncreateviewholder", "getitemcount",
 )
+_TEST_HOOK_NAMES = {
+    "setup", "teardown", "setupclass", "teardownclass",
+    "setupmodule", "teardownmodule", "setup_method", "teardown_method",
+}
+
+
+def _classify_dead_code_confidence(row: dict) -> tuple:
+    """(confidence, reason) for a zero-caller symbol (#1332).
+
+    low    — matches a category that is almost always a false positive
+             (dunder, test hook/prefix, entry-point name, override, test file)
+    medium — decorated: decorators frequently register implicit callers
+             (@property, @app.route, @pytest.fixture, …)
+    high   — none of the above; very likely genuinely dead
+    """
+    name = (row.get("function_name") or "")
+    lname = name.lower()
+    path = (row.get("path") or "")
+    if name.startswith("__") and name.endswith("__"):
+        return "low", "dunder — called implicitly by the runtime"
+    if lname in _TEST_HOOK_NAMES or name.startswith(("test_", "_test")):
+        return "low", "test hook/prefix — invoked by the test runner"
+    if lname in {n.lower() for n in _ENTRY_POINT_NAMES}:
+        return "low", "entry-point name — typically called externally"
+    if lname in {n.lower() for n in _ANDROID_ENTRY_POINT_NAMES}:
+        return "low", "framework entry point"
+    if "override" in (row.get("modifiers") or []):
+        return "low", "override — dispatched via its base declaration"
+    if "/tests/" in path or "/test/" in path or path.endswith("conftest.py"):
+        return "low", "test-tree file — commonly runner-invoked"
+    if row.get("decorators"):
+        return "medium", "decorated — decorators often add implicit callers"
+    return "high", "no callers, no excluding signal"
+
+
 _ANDROID_ENTRY_POINT_NAMES_CYPHER = "[" + ", ".join(
     f"'{n}'" for n in _ANDROID_ENTRY_POINT_NAMES
 ) + "]"
@@ -938,7 +973,7 @@ class CodeFinder:
             
             return result.data()
     
-    def find_dead_code(self, exclude_decorated_with: Optional[List[str]] = None, repo_path: Optional[str] = None, graph_name: str = None, limit: Optional[int] = None) -> Dict[str, Any]:
+    def find_dead_code(self, exclude_decorated_with: Optional[List[str]] = None, repo_path: Optional[str] = None, graph_name: str = None, limit: Optional[int] = None, include_low_confidence: bool = False) -> Dict[str, Any]:
         self._active_graph = graph_name
         """Find potentially unused functions (not called by other functions in the project), optionally excluding those with specific decorators.
 
@@ -996,6 +1031,8 @@ class CodeFinder:
                     func.line_number as line_number,
                     func.docstring as docstring,
                     func.context as context,
+                    func.decorators as decorators,
+                    func.modifiers as modifiers,
                     file.name as file_name
                 ORDER BY func.path, func.line_number
             """
@@ -1014,15 +1051,119 @@ class CodeFinder:
             # exclude_decorated_with look inert: excluded rows were backfilled
             # by the next ones in path order and the count came back 50 either
             # way (#1606).
+            for row in rows:
+                confidence, reason = _classify_dead_code_confidence(row)
+                row["confidence"] = confidence
+                row["confidence_reason"] = reason
+
+            if include_low_confidence:
+                # The main query hard-excludes categories that are almost
+                # always false positives (dunders, test hooks, entry-point
+                # names, overrides). --show-all reintroduces them as
+                # low-confidence rows instead of leaving them invisible
+                # (#1332).
+                low_query = f"""
+                    MATCH (func:Function)
+                    WHERE func.is_dependency = false {repo_filter} {func_ignore}
+                      AND func.name <> '<module>'
+                      AND (
+                            toLower(func.name) IN {_ENTRY_POINT_NAMES_CYPHER}
+                            OR (func.lang IN {_JVM_LANGS_CYPHER}
+                                AND toLower(func.name) IN {_ANDROID_ENTRY_POINT_NAMES_CYPHER})
+                            OR (func.modifiers IS NOT NULL AND 'override' IN func.modifiers)
+                            OR (func.name STARTS WITH '__' AND func.name ENDS WITH '__')
+                            OR func.name STARTS WITH '_test'
+                            OR func.name STARTS WITH 'test_'
+                          )
+                      {decorator_filter}
+                    WITH func
+                    OPTIONAL MATCH (caller)-[:CALLS|HEURISTIC_CALLS]->(func)
+                    WHERE (caller.is_dependency IS NULL OR caller.is_dependency = false)
+                      {caller_ignore}
+                    WITH func, count(caller) as caller_count
+                    WHERE caller_count = 0
+                    OPTIONAL MATCH (file:File)-[:CONTAINS]->(func)
+                    RETURN
+                        func.name as function_name,
+                        func.path as path,
+                        func.line_number as line_number,
+                        func.docstring as docstring,
+                        func.context as context,
+                        func.decorators as decorators,
+                        func.modifiers as modifiers,
+                        file.name as file_name
+                    ORDER BY func.path, func.line_number
+                """
+                low_rows = session.run(low_query, **params).data()
+                for row in low_rows:
+                    confidence, reason = _classify_dead_code_confidence(row)
+                    # Everything the main query excluded is low by construction,
+                    # but reuse the classifier so the reason strings match.
+                    row["confidence"] = "low" if confidence == "high" else confidence
+                    row["confidence_reason"] = reason
+                rows = rows + low_rows
+                rows.sort(key=lambda r: (str(r.get("path") or ""), r.get("line_number") or 0))
+
             total_count = len(rows)
+            confidence_counts = {"high": 0, "medium": 0, "low": 0}
+            for row in rows:
+                confidence_counts[row.get("confidence", "high")] += 1
             page = rows[:limit] if limit else rows
 
             return {
                 "potentially_unused_functions": page,
                 "total_count": total_count,
+                "confidence_counts": confidence_counts,
                 "note": "These functions might be unused, but could be entry points, callbacks, or called dynamically"
             }
     
+    def export_diagram_edges(self, level: str = "file", repo_path: Optional[str] = None, limit: Optional[int] = 300) -> Dict[str, Any]:
+        """Edges for a Mermaid/DOT export (#1287).
+
+        level="file": File -[IMPORTS]-> Module dependencies.
+        level="call": Function -[CALLS]-> Function within the repo.
+
+        Returns {"edges": [(src, dst), ...], "total_count": n, "truncated": bool}
+        — the cap is reported, never silent.
+        """
+        repo_path = self._normalize_repo_path_filter(repo_path)
+        with self.driver.session() as session:
+            if level == "call":
+                repo_filter = "AND caller.path STARTS WITH $repo_path" if repo_path else ""
+                query = f"""
+                    MATCH (caller:Function)-[:CALLS]->(callee:Function)
+                    WHERE caller.is_dependency = false AND callee.is_dependency = false
+                      AND caller.name <> '<module>' AND callee.name <> '<module>'
+                      {repo_filter}
+                    RETURN DISTINCT caller.name AS src, callee.name AS dst
+                    ORDER BY src, dst
+                """
+            else:
+                repo_filter = "AND file.path STARTS WITH $repo_path" if repo_path else ""
+                query = f"""
+                    MATCH (file:File)-[:IMPORTS]->(module:Module)
+                    WHERE file.is_dependency = false {repo_filter}
+                    RETURN DISTINCT file.relative_path AS src_rel, file.name AS src_name,
+                                    module.name AS dst
+                    ORDER BY src_rel, dst
+                """
+            params = {"repo_path": repo_path} if repo_path else {}
+            rows = session.run(query, **params).data()
+
+        if level == "call":
+            edges = [(r["src"], r["dst"]) for r in rows if r.get("src") and r.get("dst")]
+        else:
+            edges = [
+                ((r.get("src_rel") or r.get("src_name") or ""), r["dst"])
+                for r in rows
+                if (r.get("src_rel") or r.get("src_name")) and r.get("dst")
+            ]
+        total = len(edges)
+        truncated = limit is not None and total > limit
+        if truncated:
+            edges = edges[:limit]
+        return {"edges": edges, "total_count": total, "truncated": truncated}
+
     def find_all_callers(self, function_name: str, path: Optional[str] = None, repo_path: Optional[str] = None, depth: int = 3) -> List[Dict]:
         """Find all direct and indirect callers of a specific function, returning edges."""
         repo_path = self._normalize_repo_path_filter(repo_path)
@@ -1634,28 +1775,40 @@ class CodeFinder:
                 return result_data[0]
             return None
 
-    def find_most_complex_functions(self, limit: int = 10, repo_path: Optional[str] = None, graph_name: str = None) -> List[Dict]:
+    def find_most_complex_functions(self, limit: Optional[int] = 10, repo_path: Optional[str] = None, graph_name: str = None) -> List[Dict]:
         self._active_graph = graph_name
-        """Find the most complex functions based on cyclomatic complexity."""
+        """Find the most complex functions based on cyclomatic complexity.
+
+        ``limit=None`` returns the full set — CI enforcement must not have its
+        violation count truncated by a display page (#1333).
+        """
         repo_path = self._normalize_repo_path_filter(repo_path)
         with self.driver.session() as session:
             repo_filter = "AND f.path STARTS WITH $repo_path" if repo_path else ""
             path_ignore = cypher_path_not_under_ignore_dirs("f.path")
+            limit_clause = "LIMIT $limit" if limit is not None else ""
+            params = {"repo_path": repo_path}
+            if limit is not None:
+                params["limit"] = limit
             query = f"""
                 MATCH (f:Function)
                 WHERE f.cyclomatic_complexity IS NOT NULL AND f.is_dependency = false {repo_filter} {path_ignore}
                 RETURN f.name as function_name, f.path as path, f.cyclomatic_complexity as complexity, f.line_number as line_number
                 ORDER BY f.cyclomatic_complexity DESC
-                LIMIT $limit
+                {limit_clause}
             """
-            result = session.run(query, limit=limit, repo_path=repo_path)
+            result = session.run(query, **params)
             return result.data()
 
-    def find_most_complex_functions_in_file(self, file_path: str, limit: int = 20, repo_path: Optional[str] = None) -> List[Dict]:
-        """Find the most complex functions in a specific file."""
+    def find_most_complex_functions_in_file(self, file_path: str, limit: Optional[int] = 20, repo_path: Optional[str] = None) -> List[Dict]:
+        """Find the most complex functions in a specific file (limit=None = all)."""
         repo_path = self._normalize_repo_path_filter(repo_path)
         with self.driver.session() as session:
             repo_filter = "AND f.path STARTS WITH $repo_path" if repo_path else ""
+            limit_clause = "LIMIT $limit" if limit is not None else ""
+            params = {"file_path": file_path, "repo_path": repo_path}
+            if limit is not None:
+                params["limit"] = limit
             query = f"""
                 MATCH (f:Function)
                 WHERE f.cyclomatic_complexity IS NOT NULL
@@ -1664,9 +1817,9 @@ class CodeFinder:
                 RETURN f.name as function_name, f.path as path,
                        f.cyclomatic_complexity as complexity, f.line_number as line_number
                 ORDER BY f.cyclomatic_complexity DESC
-                LIMIT $limit
+                {limit_clause}
             """
-            result = session.run(query, file_path=file_path, limit=limit, repo_path=repo_path)
+            result = session.run(query, **params)
             return result.data()
 
     def list_indexed_repositories(self, graph_name: str = None) -> List[Dict]: