modwire-cli 1.0.0__tar.gz → 1.0.1__tar.gz

{modwire_cli-1.0.0 → modwire_cli-1.0.1}/.gitignore

@@ -1,12 +1,7 @@
 .venv/
-.dev/
 .pytest_cache/
 .ruff_cache/
-.coverage
-htmlcov/
-build/
-dist/
-*.egg-info/
-src/modwire_cli/_version.py
 __pycache__/
 *.py[cod]
+dist/
+src/modwire_cli/_version.py

modwire_cli-1.0.1/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: modwire-cli
+Version: 1.0.1
+Summary: Command-line interface for the Modwire ecosystem.
+Project-URL: Homepage, https://github.com/modwire/modwire-cli
+Project-URL: Repository, https://github.com/modwire/modwire-cli
+Project-URL: Issues, https://github.com/modwire/modwire-cli/issues
+Author: Tomasz Szpak
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,modwire
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development
+Requires-Python: >=3.12
+Requires-Dist: modwire-architecture<7,>=6
+Requires-Dist: modwire-extraction<3,>=2
+Requires-Dist: pydantic-yaml>=1.7
+Requires-Dist: rich>=13
+Requires-Dist: wireup>=2.12.0
+Provides-Extra: dev
+Requires-Dist: build>=1.3; extra == 'dev'
+Requires-Dist: pytest>=9; extra == 'dev'
+Requires-Dist: ruff>=0.14; extra == 'dev'
+Requires-Dist: twine>=6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# modwire-cli
+
+The command-line interface for the Modwire ecosystem.
+
+## Install
+
+```sh
+pip install modwire-cli
+```
+
+## Usage
+
+```sh
+modwire --language python
+```
+
+By default, Modwire reads its configuration from `.modwire/architecture.yaml`
+and analyses the current directory. Override either path when needed:
+
+```sh
+modwire --language typescript --dot-dir path/to/.modwire --architecture-root path/to/source
+```
+
+To check this repository's architecture:
+
+```sh
+uv run modwire --language python
+```
+
+## Development
+
+```sh
+uv sync --all-groups
+uv run pytest
+uv run ruff check .
+uv build
+```

modwire_cli-1.0.1/README.md

@@ -0,0 +1,37 @@
+# modwire-cli
+
+The command-line interface for the Modwire ecosystem.
+
+## Install
+
+```sh
+pip install modwire-cli
+```
+
+## Usage
+
+```sh
+modwire --language python
+```
+
+By default, Modwire reads its configuration from `.modwire/architecture.yaml`
+and analyses the current directory. Override either path when needed:
+
+```sh
+modwire --language typescript --dot-dir path/to/.modwire --architecture-root path/to/source
+```
+
+To check this repository's architecture:
+
+```sh
+uv run modwire --language python
+```
+
+## Development
+
+```sh
+uv sync --all-groups
+uv run pytest
+uv run ruff check .
+uv build
+```

modwire_cli-1.0.1/pyproject.toml

@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling>=1.28", "hatch-vcs>=0.5"]
+build-backend = "hatchling.build"
+
+[project]
+name = "modwire-cli"
+dynamic = ["version"]
+description = "Command-line interface for the Modwire ecosystem."
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+authors = [{ name = "Tomasz Szpak" }]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development",
+]
+keywords = ["cli", "modwire"]
+dependencies = [
+    "modwire-architecture>=6,<7",
+    "modwire-extraction>=2,<3",
+    "pydantic-yaml>=1.7",
+    "rich>=13",
+    "wireup>=2.12.0",
+]
+
+[project.scripts]
+modwire = "modwire_cli.__main__:main"
+
+[project.optional-dependencies]
+dev = [
+    "build>=1.3",
+    "pytest>=9",
+    "ruff>=0.14",
+    "twine>=6",
+]
+
+[project.urls]
+Homepage = "https://github.com/modwire/modwire-cli"
+Repository = "https://github.com/modwire/modwire-cli"
+Issues = "https://github.com/modwire/modwire-cli/issues"
+
+[dependency-groups]
+dev = [
+    "build>=1.3",
+    "pytest>=9",
+    "ruff>=0.14",
+    "twine>=6",
+]
+
+[tool.hatch.version]
+source = "vcs"
+tag-pattern = '^v(?P<version>\d+\.\d+\.\d+)$'
+fallback-version = "0.0.0"
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/modwire_cli/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/modwire_cli"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src", "tests", "README.md", "LICENSE", "pyproject.toml"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = ["-ra", "--strict-config", "--strict-markers"]
+filterwarnings = ["error"]
+
+[tool.ruff]
+line-length = 120
+extend-exclude = ["**/_version.py"]
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]

modwire_cli-1.0.1/src/modwire_cli/__init__.py

@@ -0,0 +1,3 @@
+from ._version import __version__
+
+__all__ = ["__version__"]

modwire_cli-1.0.1/src/modwire_cli/__main__.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+from rich.console import Console
+from wireup import create_sync_container, instance
+
+import modwire_cli
+
+from .facade import FitnessFacade
+
+
+def main() -> int:
+    return run(sys.argv[1:])
+
+
+def run(argv: Sequence[str]) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--dot-dir", type=Path, default=Path(".modwire"))
+    parser.add_argument("--architecture-root", type=Path, default=Path("."))
+    parser.add_argument("--language", required=True)
+    arguments = parser.parse_args(argv)
+
+    container = create_sync_container(
+        injectables=[modwire_cli, instance(Console(), as_type=Console)]
+    )
+    try:
+        facade = container.get(FitnessFacade)
+        return facade.reports(
+            dot_dir=arguments.dot_dir,
+            architecture_root=arguments.architecture_root,
+            language=arguments.language,
+        )
+    finally:
+        container.close()

{modwire_cli-1.0.0 → modwire_cli-1.0.1}/src/modwire_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.0'
-__version_tuple__ = version_tuple = (1, 0, 0)
+__version__ = version = '1.0.1'
+__version_tuple__ = version_tuple = (1, 0, 1)
 
-__commit_id__ = commit_id = 'ge8788a19e'
+__commit_id__ = commit_id = None

modwire_cli-1.0.1/src/modwire_cli/config.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from modwire_architecture import ArchitectureConfig
+from pydantic_yaml import parse_yaml_file_as
+from wireup import injectable
+
+
+@injectable
+@dataclass(frozen=True)
+class ConfigService:
+    def load(self, dot_dir: Path) -> ArchitectureConfig:
+        return parse_yaml_file_as(ArchitectureConfig, dot_dir / "architecture.yaml")

modwire_cli-1.0.1/src/modwire_cli/extraction.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from modwire_extraction import ModwireExtraction, QueryableCodeMap
+from wireup import injectable
+
+
+@injectable
+@dataclass(frozen=True)
+class ExtractionService:
+    def load(self, architecture_root: Path, language: str) -> QueryableCodeMap:
+        return ModwireExtraction(architecture_root).generate_queryable_map(language)

modwire_cli-1.0.1/src/modwire_cli/facade.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from modwire_architecture import Modwire
+from wireup import injectable
+
+from .config import ConfigService
+from .extraction import ExtractionService
+from .pipeline.runner import ReportPipelineRunner
+
+
+@injectable
+@dataclass(frozen=True)
+class FitnessFacade:
+    config_service: ConfigService
+    extraction_service: ExtractionService
+    pipeline_runner: ReportPipelineRunner
+
+    def reports(
+        self,
+        dot_dir: Path,
+        architecture_root: Path,
+        language: str,
+    ) -> int:
+        config = self.config_service.load(dot_dir)
+        code_map = self.extraction_service.load(architecture_root, language)
+        reports = Modwire().architecture(config).report(code_map)
+        return self.pipeline_runner.run(reports)

modwire_cli-1.0.1/src/modwire_cli/pipeline/context.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from typing import cast
+
+from modwire_architecture.shared.report.base import ReportNode
+from rich.console import Console
+
+
+@dataclass(frozen=True)
+class ReportPipelineContext:
+    reports: tuple[ReportNode, ...]
+    console: Console
+    failed: bool = False
+
+    def has_report(self, report_type: type[ReportNode]) -> bool:
+        return any(type(report) is report_type for report in self.reports)
+
+    def report[ReportType: ReportNode](self, report_type: type[ReportType]) -> ReportType:
+        for report in self.reports:
+            if type(report) is report_type:
+                return cast(ReportType, report)
+        raise LookupError(f"Missing report: {report_type.__name__}")
+
+    def fail(self) -> ReportPipelineContext:
+        return replace(self, failed=True)

modwire_cli-1.0.1/src/modwire_cli/pipeline/runner.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from collections.abc import Hashable, Mapping
+from dataclasses import dataclass
+
+from modwire_architecture.shared.report.base import ReportNode
+from rich.console import Console
+from wireup import injectable
+
+from .context import ReportPipelineContext
+from .step import ReportPipelineStep
+
+
+@injectable
+@dataclass(frozen=True)
+class ReportPipelineRunner:
+    steps: Mapping[Hashable, ReportPipelineStep]
+    console: Console
+
+    def run(self, reports: tuple[ReportNode, ...]) -> int:
+        context = ReportPipelineContext(reports=reports, console=self.console)
+        result = self.process(context)
+        return int(result.failed)
+
+    def process(self, context: ReportPipelineContext) -> ReportPipelineContext:
+        for _, step in sorted(
+            self.steps.items(),
+            key=lambda item: int(str(item[0]).partition("-")[0]),
+        ):
+            if step.should_process(context):
+                context = step.process(context)
+        return context

modwire_cli-1.0.1/src/modwire_cli/pipeline/step.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from .context import ReportPipelineContext
+
+
+class ReportPipelineStep(ABC):
+    @abstractmethod
+    def should_process(self, context: ReportPipelineContext) -> bool: ...
+
+    @abstractmethod
+    def process(self, context: ReportPipelineContext) -> ReportPipelineContext: ...

modwire_cli-1.0.1/src/modwire_cli/pipeline/steps/callables_insight.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from modwire_architecture.architecture.insights.reporters.callables import CallablesReport
+from wireup import injectable
+
+from ..context import ReportPipelineContext
+from ..step import ReportPipelineStep
+
+
+@injectable(as_type=ReportPipelineStep, qualifier="80-callables")
+class CallablesInsight(ReportPipelineStep):
+    def should_process(self, context: ReportPipelineContext) -> bool:
+        return context.has_report(CallablesReport) and bool(context.report(CallablesReport).entries)
+
+    def process(self, context: ReportPipelineContext) -> ReportPipelineContext:
+        report = context.report(CallablesReport)
+        context.console.print("[blue]Callable graph:[/blue]")
+        for entry in report.entries:
+            context.console.print(entry.source_callable, markup=False)
+            for call in entry.calls:
+                context.console.print(f"  calls: {call}", markup=False)
+            for caller in entry.callers:
+                context.console.print(f"  called by: {caller}", markup=False)
+        return context

modwire_cli-1.0.1/src/modwire_cli/pipeline/steps/clusters_insight.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from modwire_architecture.architecture.insights.reporters.clusters import ClustersReport
+from wireup import injectable
+
+from ..context import ReportPipelineContext
+from ..step import ReportPipelineStep
+
+
+@injectable(as_type=ReportPipelineStep, qualifier="50-clusters")
+class ClustersInsight(ReportPipelineStep):
+    def should_process(self, context: ReportPipelineContext) -> bool:
+        return context.has_report(ClustersReport) and bool(context.report(ClustersReport).clusters)
+
+    def process(self, context: ReportPipelineContext) -> ReportPipelineContext:
+        report = context.report(ClustersReport)
+        context.console.print("[blue]Dependency clusters:[/blue]")
+        for cluster in report.clusters:
+            context.console.print(
+                (
+                    f"{cluster.name} (pressure: {cluster.pressure_score}, "
+                    f"incoming: {cluster.incoming_count}, outgoing: {cluster.outgoing_count})"
+                ),
+                markup=False,
+            )
+            for source_id in cluster.top_files:
+                context.console.print(f"  - {source_id}", markup=False)
+        return context

modwire_cli-1.0.1/src/modwire_cli/pipeline/steps/coherence_insight.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from modwire_architecture.architecture.insights.reporters.coherence import CoherenceReport
+from wireup import injectable
+
+from ..context import ReportPipelineContext
+from ..step import ReportPipelineStep
+
+
+@injectable(as_type=ReportPipelineStep, qualifier="70-coherence")
+class CoherenceInsight(ReportPipelineStep):
+    def should_process(self, context: ReportPipelineContext) -> bool:
+        if not context.has_report(CoherenceReport):
+            return False
+        report = context.report(CoherenceReport)
+        return bool(report.roots or report.leaves or report.isolated or report.external_dependencies)
+
+    def process(self, context: ReportPipelineContext) -> ReportPipelineContext:
+        report = context.report(CoherenceReport)
+        context.console.print("[blue]Dependency coherence:[/blue]")
+        self._print_section(context, "Roots", report.roots)
+        self._print_section(context, "Leaves", report.leaves)
+        self._print_section(context, "Isolated", report.isolated)
+        self._print_section(context, "External dependencies", report.external_dependencies)
+        return context
+
+    def _print_section(
+        self,
+        context: ReportPipelineContext,
+        title: str,
+        entries: tuple[str, ...],
+    ) -> None:
+        if not entries:
+            return
+        context.console.print(title)
+        for entry in entries:
+            context.console.print(f"  - {entry}", markup=False)

modwire_cli-1.0.1/src/modwire_cli/pipeline/steps/flow_violations.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from modwire_architecture.architecture.boundaries.collector import FlowReport
+from wireup import injectable
+
+from ..context import ReportPipelineContext
+from ..step import ReportPipelineStep
+
+
+@injectable(as_type=ReportPipelineStep, qualifier="30-flow-violations")
+class FlowViolations(ReportPipelineStep):
+    def should_process(self, context: ReportPipelineContext) -> bool:
+        return bool(context.report(FlowReport).violations)
+
+    def process(self, context: ReportPipelineContext) -> ReportPipelineContext:
+        report = context.report(FlowReport)
+        context.console.print("[red]Flow violations:[/red]")
+        for violation in report.violations:
+            context.console.print(
+                f"  - [{violation.rule_name}] {violation.message}",
+                markup=False,
+            )
+            context.console.print(f"    {' -> '.join(violation.path)}", markup=False)
+        return context.fail()

modwire_cli-1.0.1/src/modwire_cli/pipeline/steps/hotspots_insight.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from modwire_architecture.architecture.insights.reporters.hotspots import HotspotsReport
+from wireup import injectable
+
+from ..context import ReportPipelineContext
+from ..step import ReportPipelineStep
+
+
+@injectable(as_type=ReportPipelineStep, qualifier="60-hotspots")
+class HotspotsInsight(ReportPipelineStep):
+    def should_process(self, context: ReportPipelineContext) -> bool:
+        return context.has_report(HotspotsReport) and bool(context.report(HotspotsReport).hotspots)
+
+    def process(self, context: ReportPipelineContext) -> ReportPipelineContext:
+        report = context.report(HotspotsReport)
+        context.console.print("[blue]Dependency hotspots:[/blue]")
+        for hotspot in report.hotspots:
+            context.console.print(
+                (
+                    f"  - {hotspot.source_id} (pressure: {hotspot.pressure_score}, "
+                    f"incoming: {hotspot.incoming_count}, outgoing: {hotspot.outgoing_count})"
+                ),
+                markup=False,
+            )
+        return context

modwire_cli-1.0.1/src/modwire_cli/pipeline/steps/map_tree.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from modwire_architecture.architecture.map.collector import ArchitectureGroup, MapReport
+from rich.tree import Tree
+from wireup import injectable
+
+from ..context import ReportPipelineContext
+from ..step import ReportPipelineStep
+
+
+@injectable(as_type=ReportPipelineStep, qualifier="10-map")
+class MapTree(ReportPipelineStep):
+    def should_process(self, context: ReportPipelineContext) -> bool:
+        return True
+
+    def process(self, context: ReportPipelineContext) -> ReportPipelineContext:
+        report = context.report(MapReport)
+        tree = Tree("Architecture Map")
+        self._add_groups(tree, "Modules", report.modules)
+        self._add_groups(tree, "Layers", report.layers)
+        context.console.print(tree)
+        return context
+
+    def _add_groups(
+        self,
+        tree: Tree,
+        title: str,
+        groups: tuple[ArchitectureGroup, ...],
+    ) -> None:
+        branch = tree.add(title)
+        for group in groups:
+            group_branch = branch.add(group.name)
+            for source_id in group.source_ids:
+                group_branch.add(source_id)

modwire_cli-1.0.1/src/modwire_cli/pipeline/steps/shape_violations.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from modwire_architecture.architecture.shape.collector import ShapeReport
+from wireup import injectable
+
+from ..context import ReportPipelineContext
+from ..step import ReportPipelineStep
+
+
+@injectable(as_type=ReportPipelineStep, qualifier="40-shape-violations")
+class ShapeViolations(ReportPipelineStep):
+    def should_process(self, context: ReportPipelineContext) -> bool:
+        return bool(context.report(ShapeReport).violations)
+
+    def process(self, context: ReportPipelineContext) -> ReportPipelineContext:
+        report = context.report(ShapeReport)
+        context.console.print("[red]Shape violations:[/red]")
+        for violation in report.violations:
+            symbol = f" {violation.symbol_kind} {violation.symbol_name}" if violation.symbol_kind else ""
+            context.console.print(
+                (
+                    f"  - [{violation.rule_name}] {violation.source_id}{symbol}: "
+                    f"{violation.actual} exceeds {violation.limit}"
+                ),
+                markup=False,
+            )
+        return context.fail()

modwire_cli-1.0.1/src/modwire_cli/pipeline/steps/success.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from wireup import injectable
+
+from ..context import ReportPipelineContext
+from ..step import ReportPipelineStep
+
+
+@injectable(as_type=ReportPipelineStep, qualifier="100-success")
+class Success(ReportPipelineStep):
+    def should_process(self, context: ReportPipelineContext) -> bool:
+        return not context.failed
+
+    def process(self, context: ReportPipelineContext) -> ReportPipelineContext:
+        context.console.print("[green]Architecture checks passed.[/green]")
+        return context

modwire_cli-1.0.1/src/modwire_cli/pipeline/steps/unknown_files_warning.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from modwire_architecture.architecture.map.collector import MapReport
+from wireup import injectable
+
+from ..context import ReportPipelineContext
+from ..step import ReportPipelineStep
+
+
+@injectable(as_type=ReportPipelineStep, qualifier="20-unknown-files")
+class UnknownFilesWarning(ReportPipelineStep):
+    def should_process(self, context: ReportPipelineContext) -> bool:
+        return bool(context.report(MapReport).unknown_files)
+
+    def process(self, context: ReportPipelineContext) -> ReportPipelineContext:
+        report = context.report(MapReport)
+        context.console.print("[yellow]Warning:[/yellow] Files not included in the architecture map:")
+        for source_id in report.unknown_files:
+            context.console.print(f"  - {source_id}", markup=False)
+        return context