metripy 0.2.5__py3-none-any.whl

metripy-0.2.5.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: metripy
+Version: 0.2.5
+Summary: A Python tool to generate multi project, multi language code metric reports
+Author-email: Yannick Zimmermann <yannick.zimmermann@proton.me>
+License: MIT
+Project-URL: Homepage, https://github.com/zimmer-yan/codemetrics
+Project-URL: Repository, https://github.com/zimmer-yan/codemetrics
+Project-URL: Documentation, https://github.com/zimmer-yan/codemetrics#readme
+Project-URL: Bug Tracker, https://github.com/zimmer-yan/codemetrics/issues
+Keywords: code metrics,multi-language,code analysis,git metrics,code visualization,software quality,static analysis,repository insights,developer productivity,codebase health,technical debt,language-agnostic
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lizard==1.18.0
+Requires-Dist: GitPython==3.1.45
+Requires-Dist: py-template-engine>=0.1.0
+Requires-Dist: radon==6.0.1
+Requires-Dist: requests==2.32.5
+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
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov==7.0.0; extra == "dev"
+Requires-Dist: pytest-mock==3.15.1; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=5.0.0; extra == "dev"
+Requires-Dist: mypy>=0.991; extra == "dev"
+Requires-Dist: poethepoet==0.37.0; extra == "dev"
+Dynamic: license-file
+
+# Codemetrics
+A multilanguage, multi project code metrics analysis tool. 
+
+# Languages
+Supported languages
+- Python (with radon)
+- Php (experimental)
+- Typescript (experimental)
+- TBD
+
+# Analysis types
+
+## Code analysis
+Analyses code with cyclomatic complexity, maintainability index, halstead metrics.
+
+## Git analysis
+Analyses git stats of the past months
+
+## Dependeny analysis
+Analyzses composer, npm or pip dependencies
+
+More dependencies TBD
+
+# Report formats
+
+## Html
+Generates an easy to read dashboard
+
+TODO: as this application generates multi project reports, add central dashboard to have project specific insights at first glance
+
+## Csv
+Coming soon...
+
+## Json
+Coming soon...
+
+## Cli
+Coming soon...
+
+# Configuration
+Configuration is for the moment only possible with the `--config=<file>.json` option. More TBD
+
+Sample configuraiton:
+```json
+{
+    "configs": {
+        "funny codemetrics": {
+            "base_path": "./", // base path to look at
+            "includes": [
+                "src/" // paths to include from the base path on
+            ],
+            "excludes": [
+                "__pycache__" // exclude patterns of paths / files
+            ],
+            "extensions": [
+                "py" // file extensions to look at
+            ],
+            "git": { // if git is set, analyzes git history
+                "branch": "main" // git branch to look at
+            },
+            "composer": true, // looks for base_path/composer.json and analyzes dependencies - for php projects
+            "npm": true, // looks for base_path/package.json and analyzes dependencies - for ts/js projects
+            "pip": true,
+            // looks for base_path/requirements.txt or base_path/pyproject.toml and analyzes dependencies - for python projects
+            "reports": {
+                "html": "./build/report/codemetrics", // report should be put into this directory
+                "json-git": "./build/json-report/codemetrics-git.json" // file where to put git json report
+                // more types of reports TBA
+            }
+        },
+        // next project name: { next config... } 
+    }
+}
+```

metripy-0.2.5.dist-info/RECORD

@@ -0,0 +1,66 @@
+metripy-0.2.5.dist-info/licenses/LICENSE,sha256=RQUMdlYUkqBhJgf7iIlzqrlaYz8VGr6KAn60wkv3FzE,1067
+src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/codemetrics.py,sha256=zBlIveTZax-kKi20CFFYLKYrpBw1MPzdFXO8NdKqzso,258
+src/Application/Analyzer.py,sha256=e4UQnLXc25F8rBQiHC441DhTabWmFdMZt0EdEgbcO-0,3909
+src/Application/Application.py,sha256=A4ytSzZGaNvs9MQ4egYbTzikkcNXRR7Oayipwa-9N-8,1915
+src/Application/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/Application/Config/Config.py,sha256=rEO3p57Rf0JCuBlNj16o3i1XoonZYLOdHUvyh09nKXc,345
+src/Application/Config/GitConfig.py,sha256=4y676GYv-FH6QyLxh6IQn64gUG9xOQciMgkXH9pJtb4,220
+src/Application/Config/Parser.py,sha256=gzzpciFtGTOwuoHCOX1GQXecYQT6ndwM0DFDAtSlHrM,882
+src/Application/Config/ProjectConfig.py,sha256=kB5Zl1PdOBYFuTuQkSuc4c2zHl2trNJGu5S-t0SPDbw,916
+src/Application/Config/ReportConfig.py,sha256=Vh3S1n2nyH5YNmt8JrfGRTcmYZuqLMxyFnFF5mmxu_4,259
+src/Application/Config/File/ConfigFileReaderFactory.py,sha256=0WGj8cVD5Bd6KWjA1tthD0iHcFiA9arjMGMzZi1_-lg,897
+src/Application/Config/File/ConfigFileReaderInterface.py,sha256=vJPJdob3zMCYlPT2yNZZnqw_KGbTwWepWfUFiNA-jRs,273
+src/Application/Config/File/JsonConfigFileReader.py,sha256=TEAdCzeGu3I1GD590iMatZZkfvRtyHcy68HcSNK3BQk,2762
+src/Component/Debug/Debugger.py,sha256=puvmjX-AenkXcpHJZuXL2eW0Sq4OEZvDj9diAdyiwZ4,415
+src/Component/File/Finder.py,sha256=nLJqQsnmOkbX9YuuiA0LWfAQEPsfw1hoteZEfAbQtT0,1391
+src/Component/Output/CliOutput.py,sha256=XJ5vJa7jxoukk4fRuj1UVV7GNkkZx-4Jb_Pl7ZYOSFk,1197
+src/Component/Output/ProgressBar.py,sha256=CGt6RfLukbDdfMgVvSkDfOIqEuFBh6LFvmYid2A1IBs,717
+src/Dependency/Dependency.py,sha256=6YSuNPEAbJY5MZ_8ZwMyppnWA_j84dwKx_hzm0eYmYc,1002
+src/Dependency/Composer/Composer.py,sha256=iHNHsGmNOLSOjwUywuzsVqYX2kKPcVA63sUhMYDdzl8,1017
+src/Dependency/Composer/Packegist.py,sha256=frroQwCJjFMonnrs9AueJW3OhTD1IOB-e96tTnZ4YFw,1972
+src/Dependency/Npm/Npm.py,sha256=nwN_LU0B7ukg_E63S3AdnHsGmb521FbUsCBZk9GeyTw,959
+src/Dependency/Npm/NpmOrg.py,sha256=Bp9LUluc_lbqHDHO8O5MNtaIODdN1hYtsmw-XbqjnXM,1543
+src/Dependency/Pip/Pip.py,sha256=MfuUbV86yYKyHngF5Qn2A-6YsQdcf_3gQu_2tKQ9ink,2302
+src/Dependency/Pip/PyPi.py,sha256=cCHU8WEeal9EXPuCfrwWzrj4j6yo2BFpBG4TqGVwEow,1604
+src/Git/GitAnalyzer.py,sha256=DLlQUe3xXRKFG0H7oQjWsbKHGrCyieo3OGwkrF30Rps,3055
+src/LangAnalyzer/AbstractLangAnalyzer.py,sha256=xT12UhRfJ0VeV2yXvNPCXYLIegGG2ps_53pA2ztcCLc,1880
+src/LangAnalyzer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/LangAnalyzer/Generic/HalSteadAnalyzer.py,sha256=z8h3V7mud5NnzQ67I9G3YhTFKHjO6Z-e_ida2d32YZ4,1845
+src/LangAnalyzer/Generic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/LangAnalyzer/Php/PhpAnalyzer.py,sha256=j0qorVWBx5tm5c0U5R1XSaNWgRrrVU9bolMrPE43lZI,7379
+src/LangAnalyzer/Php/PhpBasicAstParser.py,sha256=T717e7hM67HBOZ7mvl7Jr4RkCF-Hq-sUMzk__UTheeU,1874
+src/LangAnalyzer/Php/PhpBasicLocAnalyzer.py,sha256=2Vt3pbU0BEy2p8em3ZW_qOe9eGigtpZzVoEhe11S2O8,6229
+src/LangAnalyzer/Php/PhpHalSteadAnalyzer.py,sha256=l6oOqGIss5XHKvKwqqyw4Nu_3v-pRpdlZFIawVIyRCY,1029
+src/LangAnalyzer/Python/PythonAnalyzer.py,sha256=s6Y_DxZEn20ljKFLwY0kLyrx9zAMG_fstPJIktLXbCo,4995
+src/LangAnalyzer/Typescript/TypescriptAnalyzer.py,sha256=7sdcuniPPBqWvJZEuu4q7MWfpwdPLqyqUOxbSTuBVyM,8039
+src/LangAnalyzer/Typescript/TypescriptAstParser.py,sha256=i0AVU1Sx0hJ62eho0wwsUgIRLDJLeAiW_jk_jO8WEKA,2919
+src/LangAnalyzer/Typescript/TypescriptBasicComplexityAnalyzer.py,sha256=zEmqN3ha94XrpQwqtwX6VReNaYrNOkwWH-8igzdFEkE,3800
+src/LangAnalyzer/Typescript/TypescriptBasicLocAnalyzer.py,sha256=hxNqVGDUBb0Dy4cvQFTqfz5cCJTQ8B4uWu9hBnzSO2Y,2336
+src/LangAnalyzer/Typescript/TypescriptHalSteadAnalyzer.py,sha256=b65kNDQaygoHAyG442-mcstYdaj7tlcCuiWslvIj2t0,1270
+src/Metric/ProjectMetrics.py,sha256=qciYncQqQEJiSlX5byKq61HCeRVHi7U1cUfF7xH2bcQ,2054
+src/Metric/Code/AggregatedMetrics.py,sha256=SDpMFLV-hUXkHKFp3tZuCGySRuNGjW2VNkQq8Eqcl9Q,1551
+src/Metric/Code/FileMetrics.py,sha256=NIRRGgmT6eD-cq3DYgwi9vo-v-Eo_cf64eudMu9n6sA,1134
+src/Metric/Code/ModuleMetrics.py,sha256=x45xQbDy56_gSYuKrSPi0iWQFRbE9CPlYpho8_ZdW8c,1169
+src/Metric/Code/SegmentedMetrics.py,sha256=DqXZsagrz5yicAECXGO8e6xvhY9SivkhJvQKH9TKtaw,1730
+src/Metric/FileTree/FileTree.py,sha256=X5KeQ26lCEcUcYoa8q6ITO0kpgqphLmXWlG-NGeXpX0,467
+src/Metric/FileTree/FileTreeParser.py,sha256=AyyyajqXqvttxvT20g6damgeq9ExUCBBettv90fRRWw,1283
+src/Metric/Git/GitCodeHotspot.py,sha256=zdqmXZu9cELpJ7-KGTW3tbmD2so2R6c0w1gYg2OU1jc,1291
+src/Metric/Git/GitContributor.py,sha256=Sn3Rmds7tr1H6CsR8bJ2cfuwG7tRj0vVadD28dKa6OE,1172
+src/Metric/Git/GitKnowledgeSilo.py,sha256=arla_KR2zyfw9O5QPDhxBrkc-bfQ-pvQuA6GUgv2c44,946
+src/Metric/Git/GitMetrics.py,sha256=5gQi2JHjjafZ3fKgLW0pwa6wTCsEMPXc0m_NND-69WY,5745
+src/Report/ReporterFactory.py,sha256=U5wxEuv-Ihi1y7rbVxa1RHaKlZDhCDZJI08iWzTsS7k,857
+src/Report/ReporterInterface.py,sha256=7xLrpTuLPnQRI8uZaovx7-VkLWK2mRIxBLSpmaIgpec,519
+src/Report/Csv/Reporter.py,sha256=N0VJIayP-gakyqJanuQ9vafbGn7d5JRD1R6vCyAruHg,407
+src/Report/Html/Reporter.py,sha256=89eianUFZlhXPSANMHf0yKuMXYhpKwm5Fj-qklUthd8,8598
+src/Report/Json/AbstractJsonReporter.py,sha256=ely5RMqRrIV-kZsWc_-_4JfVDKyQlG5dAytBJkJioO0,334
+src/Report/Json/GitJsonReporter.py,sha256=c45ubLOXpDfEn-3m5re8vx51uhi-yiQJQ8TVrSY4Lno,834
+src/Report/Json/JsonReporter.py,sha256=aPazuX3R1aOpJUDGLG8WDi-7rL_WAN9J_PJ282ftFug,366
+src/Tree/ClassNode.py,sha256=_Ci6B72b5WeQBkv77J3phLw3DRpqQlgk32a-cLeo7v8,908
+src/Tree/FunctionNode.py,sha256=c2T78uGVkNRF_c2jCVmtfAwNFeY3MgASbUApROAsl3c,1520
+src/Tree/ModuleNode.py,sha256=3vrM6ERdh63AGn4Zp06647Fu7KQ3gKenqmjZ72OLWD4,1222
+metripy-0.2.5.dist-info/METADATA,sha256=NShjMgB285S_kVIJUeem3QiJ-TxWpdbidfxZRC0C7ew,3841
+metripy-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+metripy-0.2.5.dist-info/entry_points.txt,sha256=G3czqTUzqUsBf_-XbSCVQBp6OIWO9pFjaJa2CATzDks,53
+metripy-0.2.5.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+metripy-0.2.5.dist-info/RECORD,,

metripy-0.2.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

metripy-0.2.5.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codemetrics = src.codemetrics:main

metripy-0.2.5.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 CodeMetrics
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

metripy-0.2.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+src

src/Application/Analyzer.py

@@ -0,0 +1,105 @@
+from Application.Config.ProjectConfig import ProjectConfig
+from Component.Debug.Debugger import Debugger
+from Component.Output.CliOutput import CliOutput
+from Component.Output.ProgressBar import ProgressBar
+from Dependency.Composer.Composer import Composer
+from Dependency.Dependency import Dependency
+from Dependency.Npm.Npm import Npm
+from Dependency.Pip.Pip import Pip
+from Git.GitAnalyzer import GitAnalyzer
+from LangAnalyzer.AbstractLangAnalyzer import AbstractLangAnalyzer
+from LangAnalyzer.Php.PhpAnalyzer import PhpAnalyzer
+from LangAnalyzer.Python.PythonAnalyzer import PythonAnalyzer
+from LangAnalyzer.Typescript.TypescriptAnalyzer import TypescriptAnalyzer
+from Metric.Code.FileMetrics import FileMetrics
+from Metric.Git.GitMetrics import GitMetrics
+from Metric.ProjectMetrics import ProjectMetrics
+
+
+class Analyzer:
+    def __init__(self, config: ProjectConfig, output: CliOutput, debugger: Debugger):
+        self.config = config
+        self.output = output
+        self.debugger = debugger
+        self.runners: list[AbstractLangAnalyzer] = [
+            PythonAnalyzer(),
+            PhpAnalyzer(),
+            TypescriptAnalyzer(),
+        ]
+
+    def analyze_git(self) -> GitMetrics:
+        self.output.writeln("<info>Analyzing git history...</info>")
+        metrics = GitAnalyzer(self.config.git).analyze()
+        self.output.writeln("<success>Git history analyzed</success>")
+
+        return metrics
+
+    def analyze_code(self, files: list[str]) -> list[FileMetrics]:
+        file_metrics = []
+
+        # for multi language projects, register runner per language
+        runner_sizes = []
+        for runner in self.runners:
+            runner.set_files(files)
+            if not runner.is_needed():
+                continue
+            runner_sizes.append(len(runner.files))
+
+        self.debugger.debug(len(files))
+        self.output.writeln("<info>Analyzing code...</info>")
+        progress_bar = ProgressBar(self.output, sum(runner_sizes))
+        for runner in self.runners:
+            if not runner.is_needed():
+                continue
+            runner.before_run()
+            runner.run(progress_bar)
+            runner.after_run()
+
+            for metric in runner.get_metrics():
+                file_metrics.append(metric)
+
+        self.output.writeln("")
+        self.output.writeln("<success>Code analyzed</success>")
+
+        return file_metrics
+
+    def analyze_composer(self) -> list[Dependency]:
+        self.output.writeln("<info>Analyzing composer packages...</info>")
+        dependencies = Composer().get_composer_dependencies(self.config.base_path)
+        self.output.writeln("<success>Composer packages analyzed</success>")
+
+        return dependencies
+
+    def analyze_pip(self) -> list[Dependency]:
+        self.output.writeln("<info>Analyzing pip packages...</info>")
+        dependencies = Pip().get_dependencies(self.config.base_path)
+        self.output.writeln("<success>Pip packages analyzed</success>")
+
+        return dependencies
+
+    def analyze_npm(self) -> list[Dependency]:
+        self.output.writeln("<info>Analyzing npm packages...</info>")
+        dependencies = Npm().get_dependencies(self.config.base_path)
+        self.output.writeln("<success>Npm packages analyzed</success>")
+
+        return dependencies
+
+    def run(self, files: list[str]) -> ProjectMetrics:
+        git_stats = None
+        if self.config.git:
+            git_stats = self.analyze_git()
+
+        file_metrics = []
+        if True:
+            file_metrics = self.analyze_code(files)
+
+        # TODO: analyze dependencies: composer, pip, npm, etc etc
+        packages = None
+        if self.config.composer:
+            packages = self.analyze_composer()
+        elif self.config.pip:
+            packages = self.analyze_pip()
+        elif self.config.npm:
+            packages = self.analyze_npm()
+
+        return ProjectMetrics(file_metrics, git_stats, packages)

src/Application/Application.py

@@ -0,0 +1,54 @@
+import json
+
+from Application.Analyzer import Analyzer
+from Application.Config.Parser import Parser
+from Component.Debug.Debugger import Debugger
+from Component.File.Finder import Finder
+from Component.Output.CliOutput import CliOutput
+from Report.ReporterFactory import ReporterFactory
+from Report.ReporterInterface import ReporterInterface
+
+
+class Application:
+    def run(self, argv) -> None:
+        output = CliOutput()
+
+        # issues and debug
+        debugger = Debugger(output).enable()
+
+        config = Parser().parse(argv)
+
+        finder = Finder()
+        files = finder.fetch(config.project_configs)
+
+        for project_config in config.project_configs:
+            debugger.debug(project_config.name)
+            project_files = files[project_config.name]
+            debugger.debug(f"Found {len(project_files)} files")
+            debugger.debug(json.dumps(project_files))
+
+            output.writeln(f"<info>Analying Project {project_config.name}...</info>")
+            project_metrics = Analyzer(project_config, output, debugger).run(
+                project_files
+            )
+            output.writeln(
+                f"<success>Done analying Project {project_config.name}</success>"
+            )
+
+            if not project_config.reports:
+                output.writeln(
+                    f"<success>Skipping reports of {project_config.name}!</success>"
+                )
+                continue
+
+            output.writeln(
+                f"<info>Generating reports for {project_config.name}...</info>"
+            )
+            for report_config in project_config.reports:
+                reporter: ReporterInterface = ReporterFactory.create(
+                    report_config, output
+                )
+                reporter.generate(project_metrics)
+            output.writeln(
+                f"<success>Reports generated for {project_config.name}</success>"
+            )

src/Application/Config/Config.py

@@ -0,0 +1,13 @@
+from Application.Config.ProjectConfig import ProjectConfig
+
+
+class Config:
+    def __init__(self):
+        self.project_configs: list[ProjectConfig] = []
+
+    def to_dict(self) -> dict:
+        return {
+            "project_configs": [
+                project_config.to_dict() for project_config in self.project_configs
+            ],
+        }

src/Application/Config/File/ConfigFileReaderFactory.py

@@ -0,0 +1,22 @@
+import os
+import pathlib
+
+from Application.Config.File.ConfigFileReaderInterface import ConfigFileReaderInterface
+from Application.Config.File.JsonConfigFileReader import JsonConfigFileReader
+
+
+class ConfigFileReaderFactory:
+    @staticmethod
+    def createFromFileName(filename: str) -> ConfigFileReaderInterface:
+        if not os.path.isfile(filename):
+            raise FileNotFoundError(f"File {filename} does not exist")
+
+        extension = pathlib.Path(filename).suffix
+        if extension == ".json":
+            return JsonConfigFileReader(filename)
+        elif extension == ".yaml" or extension == ".yml":
+            raise NotImplementedError("YAML support is not implemented yet")
+        elif extension == ".xml":
+            raise NotImplementedError("XML support is not implemented yet")
+        else:
+            raise NotImplementedError(f"Unsupported file type: {extension}")

src/Application/Config/File/ConfigFileReaderInterface.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+from Application.Config.Config import Config
+
+
+class ConfigFileReaderInterface(ABC):
+
+    @abstractmethod
+    def __init__(self, filename: str):
+        pass
+
+    @abstractmethod
+    def read(self, config: Config) -> None:
+        pass

src/Application/Config/File/JsonConfigFileReader.py

@@ -0,0 +1,81 @@
+import json
+import os
+
+from Application.Config.Config import Config
+from Application.Config.File.ConfigFileReaderInterface import ConfigFileReaderInterface
+from Application.Config.GitConfig import GitConfig
+from Application.Config.ProjectConfig import ProjectConfig
+from Application.Config.ReportConfig import ReportConfig
+
+
+class JsonConfigFileReader(ConfigFileReaderInterface):
+    def __init__(self, filename: str):
+        self.filename = filename
+
+    def read(self, config: Config) -> None:
+        with open(self.filename, "r") as file:
+            json_data = json.load(file)
+
+        self.parse_json(json_data, config)
+
+    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:
+
+        # configs
+        if configs := json_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:
+        project_config = ProjectConfig(project_name)
+
+        # extensions
+        if base_path := json_data.get("base_path"):
+            project_config.base_path = base_path
+
+        # includes
+        if includes := json_data.get("includes"):
+            files = []
+            # with config file, includes are relative to the config file
+            for include in includes:
+                include = self.resolve_path(include)
+                files.append(include)
+
+            project_config.includes = files
+
+        # extensions
+        if extensions := json_data.get("extensions"):
+            project_config.extensions = extensions
+
+        # excludes
+        if excludes := json_data.get("excludes"):
+            project_config.excludes = excludes
+
+        # reports
+        if reports := json_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"):
+            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"):
+            project_config.composer = composer
+
+        # pip
+        if pip := json_data.get("pip"):
+            project_config.pip = pip
+
+        # npm
+        if npm := json_data.get("npm"):
+            project_config.npm = npm
+
+        return project_config

src/Application/Config/GitConfig.py

@@ -0,0 +1,10 @@
+class GitConfig:
+    def __init__(self):
+        self.repo = "./"
+        self.branch = "main"
+
+    def to_dict(self) -> dict:
+        return {
+            "repo": self.repo,
+            "branch": self.branch,
+        }

src/Application/Config/Parser.py

@@ -0,0 +1,30 @@
+import re
+
+from Application.Config.Config import Config
+from Application.Config.File.ConfigFileReaderFactory import ConfigFileReaderFactory
+
+
+class Parser:
+    def parse(self, argv: list[str]) -> Config:
+        config = Config()
+
+        if argv[0] == "codemetrics.py" or argv[0] == "codemetrics":
+            # TODO, fix when path ends with codemetrics.py
+            pass
+        argv.pop(0)
+
+        # check for a config file
+        for key, arg in enumerate(argv):
+            if matches := re.search(r"^--config=(.+)$", arg):
+                fileReader = ConfigFileReaderFactory.createFromFileName(
+                    matches.group(1)
+                )
+                fileReader.read(config)
+                argv.pop(key)
+
+        # TODO: add the following
+        # arguments with options
+        # arguments without options
+        # last argument
+
+        return config

src/Application/Config/ProjectConfig.py

@@ -0,0 +1,27 @@
+from Application.Config.GitConfig import GitConfig
+from Application.Config.ReportConfig import ReportConfig
+
+
+class ProjectConfig:
+    def __init__(self, name: str):
+        self.name: str = name
+        self.base_path: str = "./"
+        self.includes: list[str] = []
+        self.excludes: list[str] = []
+        self.extensions: list[str] = []
+        self.git: GitConfig | None = None
+        self.composer: bool = False
+        self.pip: bool = False
+        self.npm: bool = False
+        self.reports: list[ReportConfig] = []
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "base_path": self.base_path,
+            "includes": self.includes,
+            "excludes": self.excludes,
+            "extensions": self.extensions,
+            "git": self.git.to_dict() if self.git else None,
+            "reports": [report.to_dict() for report in self.reports],
+        }

src/Application/Config/ReportConfig.py

@@ -0,0 +1,10 @@
+class ReportConfig:
+    def __init__(self, report_type: str, path: str) -> None:
+        self.type = report_type
+        self.path = path
+
+    def to_dict(self) -> dict:
+        return {
+            "type": self.type,
+            "path": self.path,
+        }

src/Component/Debug/Debugger.py

@@ -0,0 +1,20 @@
+from typing import Self
+
+from Component.Output.CliOutput import CliOutput
+
+
+class Debugger:
+    def __init__(self, output: CliOutput):
+        self.enabled = False
+        self.output = output
+
+    def enable(self) -> Self:
+        self.enabled = True
+
+        return self
+
+    def debug(self, message: str):
+        if not self.enabled:
+            return
+
+        self.output.writeln(f"<debug>{message}</debug>")

src/Component/File/Finder.py

@@ -0,0 +1,37 @@
+import os
+
+from Application.Config.ProjectConfig import ProjectConfig
+
+
+class Finder:
+    def fetch(self, project_configs: list[ProjectConfig]) -> dict[str, list[str]]:
+        """returns a list of files per project project_name => [files,...]"""
+        project_files = {}
+        for project_config in project_configs:
+            files = []
+
+            paths = [
+                os.path.join(project_config.base_path, inc)
+                for inc in project_config.includes
+            ]
+            for path in paths:
+                if os.path.isdir(path):
+                    self._search(
+                        path, project_config.extensions, project_config.excludes, files
+                    )
+            project_files[project_config.name] = files
+
+        return project_files
+
+    def _search(
+        self, path: str, extensions: list[str], excludes: list[str], results: list[str]
+    ):
+        if not os.path.isdir(path):
+            if path not in excludes and path.endswith(tuple(extensions)):
+                results.append(path)
+
+        for file in os.listdir(path):
+            if os.path.isdir(os.path.join(path, file)) and file not in excludes:
+                self._search(os.path.join(path, file), extensions, excludes, results)
+            elif file not in excludes and file.endswith(tuple(extensions)):
+                results.append(os.path.join(path, file))