metripy 0.3.0__tar.gz → 0.3.2__tar.gz

{metripy-0.3.0 → metripy-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metripy
-Version: 0.3.0
+Version: 0.3.2
 Summary: A Python tool to generate multi project, multi language code metric reports
 Author-email: Yannick Zimmermann <yannick.zimmermann@proton.me>
 License: MIT
@@ -26,6 +26,7 @@ Requires-Dist: packaging==25.0
 Requires-Dist: toml==0.10.2
 Requires-Dist: tree-sitter==0.21.3
 Requires-Dist: tree-sitter-languages==1.10.2
+Requires-Dist: PyYAML==6.0.3
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov==7.0.0; extra == "dev"

{metripy-0.3.0 → metripy-0.3.2}/metripy/Application/Application.py

@@ -2,14 +2,13 @@ import json
 
 from metripy.Application.Analyzer import Analyzer
 from metripy.Application.Config.Parser import Parser
+from metripy.Application.Info import Info
 from metripy.Component.Debug.Debugger import Debugger
 from metripy.Component.File.Finder import Finder
 from metripy.Component.Output.CliOutput import CliOutput
 from metripy.Report.ReporterFactory import ReporterFactory
 from metripy.Report.ReporterInterface import ReporterInterface
 
-from metripy.Application.Info import Info
-
 
 class Application:
     def run(self, argv) -> None:
@@ -61,7 +60,7 @@ class Application:
             )
             for report_config in project_config.reports:
                 reporter: ReporterInterface = ReporterFactory.create(
-                    report_config, output
+                    report_config, output, project_config.name
                 )
                 reporter.generate(project_metrics)
             output.writeln(

{metripy-0.3.0 → metripy-0.3.2}/metripy/Application/Config/Config.py

@@ -17,7 +17,6 @@ class Config:
         }
 
     def set(self, param: str, value: any) -> None:
-        print(f"Setting {param} to {value}")
         if param == "quiet":
             self.quiet = value
         elif param == "version":
@@ -27,7 +26,7 @@ class Config:
         elif param == "debug":
             self.debug = value
         elif param.startswith("configs."):
-            self._set_project_value(param[len("configs."):], value)
+            self._set_project_value(param[len("configs.") :], value)
         else:
             # ignore unknown parameters
             return
@@ -35,7 +34,9 @@ class Config:
     def _set_project_value(self, param: str, value: any) -> None:
         keys = param.split(".")
         project_name = keys[0]
-        project_config = next((pc for pc in self.project_configs if pc.name == project_name), None)
+        project_config = next(
+            (pc for pc in self.project_configs if pc.name == project_name), None
+        )
         if not project_config:
             project_config = ProjectConfig(project_name)
             self.project_configs.append(project_config)

{metripy-0.3.0 → metripy-0.3.2}/metripy/Application/Config/File/ConfigFileReaderFactory.py

@@ -5,6 +5,7 @@ from metripy.Application.Config.File.ConfigFileReaderInterface import (
     ConfigFileReaderInterface,
 )
 from metripy.Application.Config.File.JsonConfigFileReader import JsonConfigFileReader
+from metripy.Application.Config.File.YamlConfigFileReader import YamlConfigFileReader
 
 
 class ConfigFileReaderFactory:
@@ -17,7 +18,7 @@ class ConfigFileReaderFactory:
         if extension == ".json":
             return JsonConfigFileReader(filename)
         elif extension == ".yaml" or extension == ".yml":
-            raise NotImplementedError("YAML support is not implemented yet")
+            return YamlConfigFileReader(filename)
         elif extension == ".xml":
             raise NotImplementedError("XML support is not implemented yet")
         else:

metripy-0.3.0/metripy/Application/Config/File/JsonConfigFileReader.py → metripy-0.3.2/metripy/Application/Config/File/ConfigFileReaderInterface.py

@@ -1,45 +1,39 @@
-import json
 import os
+from abc import ABC, abstractmethod
 
 from metripy.Application.Config.Config import Config
-from metripy.Application.Config.File.ConfigFileReaderInterface import (
-    ConfigFileReaderInterface,
-)
 from metripy.Application.Config.GitConfig import GitConfig
 from metripy.Application.Config.ProjectConfig import ProjectConfig
 from metripy.Application.Config.ReportConfig import ReportConfig
 
 
-class JsonConfigFileReader(ConfigFileReaderInterface):
+class ConfigFileReaderInterface(ABC):
     def __init__(self, filename: str):
         self.filename = filename
 
+    @abstractmethod
     def read(self, config: Config) -> None:
-        with open(self.filename, "r") as file:
-            json_data = json.load(file)
-
-        self.parse_json(json_data, config)
+        pass
 
     def resolve_path(self, path: str) -> str:
         return os.path.join(os.path.dirname(self.filename), path)
 
-    def parse_json(self, json_data: dict, config: Config) -> None:
-
+    def parse_data(self, data: dict, config: Config) -> None:
         # configs
-        if configs := json_data.get("configs"):
+        if configs := data.get("configs"):
             for project_name, project_config in configs.items():
                 project_config = self.parse_config_json(project_name, project_config)
                 config.project_configs.append(project_config)
 
-    def parse_config_json(self, project_name: str, json_data: dict) -> ProjectConfig:
+    def parse_config_json(self, project_name: str, data: dict) -> ProjectConfig:
         project_config = ProjectConfig(project_name)
 
         # extensions
-        if base_path := json_data.get("base_path"):
+        if base_path := data.get("base_path"):
             project_config.base_path = base_path
 
         # includes
-        if includes := json_data.get("includes"):
+        if includes := data.get("includes"):
             files = []
             # with config file, includes are relative to the config file
             for include in includes:
@@ -49,39 +43,39 @@ class JsonConfigFileReader(ConfigFileReaderInterface):
             project_config.includes = files
 
         # extensions
-        if extensions := json_data.get("extensions"):
+        if extensions := data.get("extensions"):
             project_config.extensions = extensions
 
         # excludes
-        if excludes := json_data.get("excludes"):
+        if excludes := data.get("excludes"):
             project_config.excludes = excludes
 
         # reports
-        if reports := json_data.get("reports"):
+        if reports := data.get("reports"):
             for report_type, path in reports.items():
                 path = self.resolve_path(path)
                 project_config.reports.append(ReportConfig(report_type, path))
 
         # git
-        if git := json_data.get("git"):
+        if git := data.get("git"):
             project_config.git = GitConfig()
             project_config.git.repo = project_config.base_path
             project_config.git.branch = git.get("branch", project_config.git.branch)
 
         # composer
-        if composer := json_data.get("composer"):
+        if composer := data.get("composer"):
             project_config.composer = composer
 
         # pip
-        if pip := json_data.get("pip"):
+        if pip := data.get("pip"):
             project_config.pip = pip
 
         # npm
-        if npm := json_data.get("npm"):
+        if npm := data.get("npm"):
             project_config.npm = npm
 
         # trends
-        if history_path := json_data.get("trends"):
+        if history_path := data.get("trends"):
             project_config.history_path = self.resolve_path(history_path)
 
         return project_config

metripy-0.3.2/metripy/Application/Config/File/JsonConfigFileReader.py

@@ -0,0 +1,17 @@
+import json
+
+from metripy.Application.Config.Config import Config
+from metripy.Application.Config.File.ConfigFileReaderInterface import (
+    ConfigFileReaderInterface,
+)
+
+
+class JsonConfigFileReader(ConfigFileReaderInterface):
+    def __init__(self, filename: str):
+        super().__init__(filename)
+
+    def read(self, config: Config) -> None:
+        with open(self.filename, "r") as file:
+            json_data = json.load(file)
+
+        self.parse_data(json_data, config)

metripy-0.3.2/metripy/Application/Config/File/YamlConfigFileReader.py

@@ -0,0 +1,17 @@
+import yaml
+
+from metripy.Application.Config.Config import Config
+from metripy.Application.Config.File.ConfigFileReaderInterface import (
+    ConfigFileReaderInterface,
+)
+
+
+class YamlConfigFileReader(ConfigFileReaderInterface):
+    def __init__(self, filename: str):
+        super().__init__(filename)
+
+    def read(self, config: Config) -> None:
+        with open(self.filename, "r") as file:
+            yaml_data = yaml.safe_load(file)
+
+        self.parse_data(yaml_data, config)

{metripy-0.3.0 → metripy-0.3.2}/metripy/Application/Config/Parser.py

@@ -9,7 +9,6 @@ from metripy.Application.Config.File.ConfigFileReaderFactory import (
 class Parser:
     def parse(self, argv: list[str]) -> Config:
         config = Config()
-        print(argv)
 
         if argv[0].endswith("metripy.py") or argv[0].endswith("metripy"):
             argv.pop(0)
@@ -18,7 +17,6 @@ class Parser:
         key = 0
         while key < len(argv):
             arg = argv[key]
-            print(f"Key: {key} Arg: '{arg}'")
             if matches := re.search(r"^--config=(.+)$", arg):
                 fileReader = ConfigFileReaderFactory.createFromFileName(
                     matches.group(1)

{metripy-0.3.0 → metripy-0.3.2}/metripy/Application/Config/ProjectConfig.py

@@ -41,7 +41,6 @@ class ProjectConfig:
         if len(keys) == 0:
             return
         primary_key = keys[0]
-        print(f"Setting primary {primary_key} to {value}")
         # single value
         if primary_key == "base_path":
             self.base_path = value
@@ -84,7 +83,9 @@ class ProjectConfig:
             if value != "":
                 self.reports.append(ReportConfig(report_type, report_path))
             else:
-                report_config = next((rc for rc in self.reports if rc.type == report_type), None)
+                report_config = next(
+                    (rc for rc in self.reports if rc.type == report_type), None
+                )
                 if not report_config:
                     return
-                self.reports.remove(report_config)
+                self.reports.remove(report_config)

{metripy-0.3.0 → metripy-0.3.2}/metripy/Application/Info.py

@@ -1,5 +1,6 @@
 import toml
 
+
 class Info:
     def __init__(self):
         data = self._get_data()
@@ -11,14 +12,19 @@ class Info:
             data = toml.load(file)
         return data
 
+    def get_version(self) -> str:
+        return self.version
+
     def get_version_info(self) -> str:
         return f"""
-Metripy {self.version}
+Metripy {self.get_version()}
 {self.url}
 """
 
     def get_help(self) -> str:
-        return self.get_version_info() + f"""
+        return (
+            self.get_version_info()
+            + """
 Usage: metripy [options]
 Options:
  --config=<file>    Use a custom config file
@@ -27,3 +33,4 @@ Options:
  --debug              Enable debug mode
  --quiet              Disable output
 """
+        )

{metripy-0.3.0 → metripy-0.3.2}/metripy/LangAnalyzer/Python/PythonAnalyzer.py

@@ -122,7 +122,7 @@ class PythonAnalyzer(AbstractLangAnalyzer):
                 continue
             # if MI is 0, we want to take another look, radon does not like boring functions
 
-            lines = code_lines[function_node.lineno:function_node.line_end]
+            lines = code_lines[function_node.lineno : function_node.line_end]
             function_metrics = (
                 self.fallback_halstead_analyzer.calculate_halstead_metrics(
                     "\n".join(lines)

{metripy-0.3.0 → metripy-0.3.2}/metripy/Metric/Code/Segmentor.py

@@ -40,3 +40,5 @@ class Segmentor:
             return "ok"
         elif method_size <= 50:
             return "warning"
+        else:
+            return "critical"

metripy-0.3.2/metripy/Report/Html/DependencyPageRenderer.py

@@ -0,0 +1,21 @@
+from metripy.Dependency.Dependency import Dependency
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Html.PageRenderer import PageRenderer
+
+
+class DependencyPageRenderer(PageRenderer):
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        super().__init__(template_dir, output_dir, project_name)
+
+    def render(self, metrics: ProjectMetrics):
+        dependencies = metrics.dependencies if metrics.dependencies is not None else []
+        license_by_type = Dependency.get_lisence_distribution(dependencies)
+
+        self.render_template(
+            "dependencies.html",
+            {
+                "has_dependencies_data": bool(metrics.dependencies),
+                "dependencies": [d.to_dict() for d in dependencies],
+                "license_distribution": license_by_type,
+            },
+        )

metripy-0.3.2/metripy/Report/Html/FilesPageRenderer.py

@@ -0,0 +1,28 @@
+import json
+
+from metripy.Metric.FileTree.FileTreeParser import FileTreeParser
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Html.PageRenderer import PageRenderer
+
+
+class FilesPageRenderer(PageRenderer):
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        super().__init__(template_dir, output_dir, project_name)
+
+    def render(self, metrics: ProjectMetrics):
+        file_names = []
+        file_details = {}
+        for file_metrics in metrics.file_metrics:
+            file_name = file_metrics.full_name
+            file_details[file_name] = file_metrics.to_dict()
+            file_names.append(file_name)
+
+        filetree = FileTreeParser.parse(file_names, shorten=True)
+
+        self.render_template(
+            "files.html",
+            {
+                "filetree": json.dumps(filetree.to_dict()),
+                "file_details": json.dumps(file_details),
+            },
+        )

metripy-0.3.2/metripy/Report/Html/GitAnalysisPageRenderer.py

@@ -0,0 +1,55 @@
+import json
+
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Html.PageRenderer import PageRenderer
+
+
+class GitAnalysisPageRenderer(PageRenderer):
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        super().__init__(template_dir, output_dir, project_name)
+
+    def _render_empty_template(self):
+        self.render_template(
+            "git_analysis.html",
+            {
+                "has_git_analysis_data": False,
+                "git_analysis": {},
+                "git_analysis_json": "{}",
+                "git_stats_data": "{}",
+                "git_churn_data": "{}",
+                "git_silos_data": [],
+                "git_contributors": [],
+                "git_hotspots_data": [],
+            },
+        )
+
+    def render(self, metrics: ProjectMetrics):
+        if not metrics.git_metrics:
+            self._render_empty_template()
+            return
+
+        self.render_template(
+            "git_analysis.html",
+            {
+                "has_git_analysis_data": bool(metrics.git_metrics),
+                "git_analysis": metrics.git_metrics.to_dict(),
+                "git_analysis_json": json.dumps(
+                    metrics.git_metrics.get_contributors_dict(), indent=4
+                ),
+                "git_stats_data": json.dumps(
+                    metrics.git_metrics.get_commit_stats_per_month(), indent=4
+                ),  # git commit graph
+                "git_churn_data": json.dumps(
+                    metrics.git_metrics.get_churn_per_month(), indent=4
+                ),  # git chrun graph
+                "git_silos_data": metrics.git_metrics.get_silos_list()[
+                    :10
+                ],  # silos list
+                "git_contributors": metrics.git_metrics.get_contributors_list()[
+                    :10
+                ],  # contributors list
+                "git_hotspots_data": metrics.git_metrics.get_hotspots_list()[
+                    :10
+                ],  # hotspots list
+            },
+        )

metripy-0.3.2/metripy/Report/Html/IndexPageRenderer.py

@@ -0,0 +1,40 @@
+import json
+
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Html.PageRenderer import PageRenderer
+
+
+class IndexPageRenderer(PageRenderer):
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        super().__init__(template_dir, output_dir, project_name)
+
+    def render(self, metrics: ProjectMetrics):
+        git_stats_data = {}
+        if metrics.git_metrics:
+            git_stats_data = metrics.git_metrics.get_commit_stats_per_month()
+
+        self.render_template(
+            "index.html",
+            {
+                "git_stats_data": json.dumps(git_stats_data, indent=4),
+                "total_code_metrics": metrics.total_code_metrics.to_dict(),
+                "has_total_code_metrics_trend": metrics.total_code_metrics.trend
+                is not None,
+                "total_code_metrics_trend": (
+                    metrics.total_code_metrics.trend.to_dict()
+                    if metrics.total_code_metrics.trend
+                    else None
+                ),
+                "segmentation_data": json.dumps(
+                    metrics.total_code_metrics.to_dict_segmentation(), indent=4
+                ),
+                "segmentation_data_trend": (
+                    json.dumps(
+                        metrics.total_code_metrics.trend.to_dict_segmentation(),
+                        indent=4,
+                    )
+                    if metrics.total_code_metrics.trend
+                    else None
+                ),
+            },
+        )

metripy-0.3.2/metripy/Report/Html/PageRenderer.py

@@ -0,0 +1,43 @@
+import os
+from datetime import datetime
+
+from py_template_engine import TemplateEngine
+
+from metripy.Application.Info import Info
+
+
+class PageRenderer:
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        self.template_dir = template_dir
+        self.output_dir = output_dir
+
+        self.global_template_args = {
+            "project_name": project_name,
+            "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "date": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "author": "Metripy",
+            "version": Info().get_version(),
+        }
+
+    @staticmethod
+    def _stringify_values(obj):
+        if isinstance(obj, dict):
+            return {
+                key: PageRenderer._stringify_values(value) for key, value in obj.items()
+            }
+        elif isinstance(obj, list):
+            return [PageRenderer._stringify_values(item) for item in obj]
+        else:
+            return str(obj)
+
+    def render_template(self, template_name: str, data: dict):
+        data = self._stringify_values(
+            {
+                **self.global_template_args,
+                **data,
+            }
+        )
+        engine = TemplateEngine(os.path.join(self.template_dir, template_name))
+        content = engine.render(**data)
+        with open(os.path.join(self.output_dir, template_name), "w") as file:
+            file.write(content)

metripy-0.3.2/metripy/Report/Html/PageRendererFactory.py

@@ -0,0 +1,37 @@
+from metripy.Report.Html.DependencyPageRenderer import DependencyPageRenderer
+from metripy.Report.Html.FilesPageRenderer import FilesPageRenderer
+from metripy.Report.Html.GitAnalysisPageRenderer import GitAnalysisPageRenderer
+from metripy.Report.Html.IndexPageRenderer import IndexPageRenderer
+from metripy.Report.Html.TopOffendersPageRenderer import TopOffendersPageRenderer
+from metripy.Report.Html.TrendsPageRenderer import TrendsPageRenderer
+
+
+class PageRendererFactory:
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        self.template_dir = template_dir
+        self.output_dir = output_dir
+        self.project_name = project_name
+
+    def create_index_page_renderer(self) -> IndexPageRenderer:
+        return IndexPageRenderer(self.template_dir, self.output_dir, self.project_name)
+
+    def create_files_page_renderer(self) -> FilesPageRenderer:
+        return FilesPageRenderer(self.template_dir, self.output_dir, self.project_name)
+
+    def create_top_offenders_page_renderer(self) -> TopOffendersPageRenderer:
+        return TopOffendersPageRenderer(
+            self.template_dir, self.output_dir, self.project_name
+        )
+
+    def create_git_analysis_page_renderer(self) -> GitAnalysisPageRenderer:
+        return GitAnalysisPageRenderer(
+            self.template_dir, self.output_dir, self.project_name
+        )
+
+    def create_dependency_page_renderer(self) -> DependencyPageRenderer:
+        return DependencyPageRenderer(
+            self.template_dir, self.output_dir, self.project_name
+        )
+
+    def create_trends_page_renderer(self) -> TrendsPageRenderer:
+        return TrendsPageRenderer(self.template_dir, self.output_dir, self.project_name)

metripy-0.3.2/metripy/Report/Html/Reporter.py

@@ -0,0 +1,124 @@
+import os
+import shutil
+from datetime import datetime
+
+
+from metripy.Application.Config.ReportConfig import ReportConfig
+from metripy.Component.Output.CliOutput import CliOutput
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Html.PageRendererFactory import PageRendererFactory
+from metripy.Report.ReporterInterface import ReporterInterface
+
+
+class Reporter(ReporterInterface):
+    def __init__(
+        self, config: ReportConfig, output: CliOutput, project_name: str = "foobar"
+    ):
+        self.config: ReportConfig = config
+        self.output = output
+        self.template_dir = os.path.join(os.getcwd(), "templates/html_report")
+        self.project_name = project_name
+
+        self.page_renderer_factory = PageRendererFactory(
+            self.template_dir, self.config.path, self.project_name
+        )
+
+        self.global_template_args = {
+            "project_name": project_name,
+            "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        }
+
+    def generate(self, metrics: ProjectMetrics):
+
+        self.output.writeln("<info>Generating HTML report...</info>")
+
+        # copy sources
+        if not os.path.exists(os.path.join(self.config.path, "js")):
+            os.makedirs(os.path.join(self.config.path, "js"))
+        if not os.path.exists(os.path.join(self.config.path, "css")):
+            os.makedirs(os.path.join(self.config.path, "css"))
+        if not os.path.exists(os.path.join(self.config.path, "images")):
+            os.makedirs(os.path.join(self.config.path, "images"))
+        if not os.path.exists(os.path.join(self.config.path, "fonts")):
+            os.makedirs(os.path.join(self.config.path, "fonts"))
+        if not os.path.exists(os.path.join(self.config.path, "data")):
+            os.makedirs(os.path.join(self.config.path, "data"))
+
+        # shutil.copy(os.path.join(self.template_dir, "favicon.ico"), os.path.join(self.config.path, "favicon.ico"))
+
+        shutil.copytree(
+            os.path.join(self.template_dir, "js"),
+            os.path.join(self.config.path, "js"),
+            dirs_exist_ok=True,
+        )
+        shutil.copytree(
+            os.path.join(self.template_dir, "css"),
+            os.path.join(self.config.path, "css"),
+            dirs_exist_ok=True,
+        )
+        shutil.copytree(
+            os.path.join(self.template_dir, "images"),
+            os.path.join(self.config.path, "images"),
+            dirs_exist_ok=True,
+        )
+        # shutil.copytree(os.path.join(self.template_dir, "fonts"), os.path.join(self.config.path, "fonts"), dirs_exist_ok=True)
+
+        # copy logo, lies 2 down from the templates directory
+        shutil.copy(
+            os.path.join(self.template_dir, "../..", "logo.svg"),
+            os.path.join(self.config.path, "images", "logo.svg"),
+        )
+
+        # Render main pages
+        self.render_index_page(metrics)
+        self.render_files_page(metrics)
+        self.render_top_offenders_page(metrics)
+        self.render_git_analysis_page(metrics)
+        self.render_dependencies_page(metrics)
+        self.render_trends_page(metrics)
+
+        self.output.writeln(
+            f"<success>HTML report generated in {self.config.path} directory</success>"
+        )
+        self.output.writeln(
+            f"<success>Open HTML report: {self.config.path}/index.html</success>"
+        )
+
+    def render_index_page(self, metrics: ProjectMetrics):
+        self.output.writeln("<info>Rendering index page</info>")
+        self.page_renderer_factory.create_index_page_renderer().render(metrics)
+        self.output.writeln("<success>Done rendering index page</success>")
+
+    def render_files_page(self, metrics: ProjectMetrics):
+        """Render the files page with file details and analysis"""
+        self.output.writeln("<info>Rendering files page</info>")
+        self.page_renderer_factory.create_files_page_renderer().render(metrics)
+        self.output.writeln("<success>Files page generated successfully</success>")
+
+    def render_top_offenders_page(self, metrics: ProjectMetrics):
+        self.output.writeln("<info>Rendering top offenders page</info>")
+        self.page_renderer_factory.create_top_offenders_page_renderer().render(metrics)
+        self.output.writeln(
+            "<success>Top offenders page generated successfully</success>"
+        )
+
+    def render_git_analysis_page(self, metrics: ProjectMetrics):
+        """Render the git analysis page with comprehensive git data"""
+        self.output.writeln("<info>Rendering git analysis page</info>")
+        self.page_renderer_factory.create_git_analysis_page_renderer().render(metrics)
+        self.output.writeln(
+            "<success>Git analysis page generated successfully</success>"
+        )
+
+    def render_dependencies_page(self, metrics: ProjectMetrics):
+        """Render the dependencies page with dependency details and stats"""
+        self.output.writeln("<info>Rendering dependencies page</info>")
+        self.page_renderer_factory.create_dependency_page_renderer().render(metrics)
+        self.output.writeln(
+            "<success>Dependencies page generated successfully</success>"
+        )
+
+    def render_trends_page(self, metrics: ProjectMetrics):
+        self.output.writeln("<info>Rendering trends page</info>")
+        self.page_renderer_factory.create_trends_page_renderer().render(metrics)
+        self.output.writeln("<success>Trends page generated successfully</success>")