local-dev-composer 0.1.0__tar.gz

local_dev_composer-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: local-dev-composer
+Version: 0.1.0
+Summary: Orchestrate local microservice environments on Windows without Docker or WSL
+Author: Sergii Bugera
+Project-URL: Homepage, https://github.com/sbugera/local-dev-composer
+Project-URL: Repository, https://github.com/sbugera/local-dev-composer
+Project-URL: Issues, https://github.com/sbugera/local-dev-composer/issues
+Keywords: microservices,local-development,developer-tools,process-manager,windows,devtools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: rich>=13.0.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: psutil>=5.9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+
+# local-dev-composer (ldc)
+
+Orchestrate local microservice environments on **Windows 11** without Docker, Podman, or WSL.
+
+- Start a full service graph with one command
+- Per-service environment isolation (same variable, different values per service)
+- Dependency ordering — services start leaf-first, stop dependents-first
+- Prerequisite checks with actionable fix hints (Java version, PATH commands, env vars, ports, folders)
+- Live Rich terminal dashboard
+- Groups — declare the minimum set of services per development scenario
+- Survives restarts — reconciles live PIDs from `.ldc/state.json`
+
+## Quick start
+
+```bash
+git clone https://github.com/sbugera/local-dev-composer.git
+cd local-dev-composer
+pip install -e .
+
+cp composer.example.yml composer.yml
+# edit composer.yml for your project
+
+ldc doctor                     # check everything, get a numbered fix list
+ldc clone                      # clone all repos
+ldc check --fix                # verify and fix prerequisites
+ldc install                    # run install commands
+ldc up --group gateway-dev     # start minimum services for your task
+```
+
+## Daily use
+
+```bash
+ldc up --group gateway-dev     # start what you need
+ldc status                     # service table with PIDs and health
+ldc logs gateway -f            # follow a service log
+ldc down                       # stop everything
+```
+
+## Documentation
+
+| topic | description |
+|-------|-------------|
+| [Installation](docs/installation.md) | Setup, direct-script mode |
+| [Configuration](docs/configuration.md) | Full `composer.yml` schema reference |
+| [Commands](docs/commands.md) | All CLI commands with options |
+| [Groups](docs/groups.md) | Named service sets, smart selection |
+| [Environment](docs/environment.md) | Per-service env isolation, `.env` files |
+| [Prerequisites](docs/prerequisites.md) | Runtime/command/folder/port checks |
+| [Health Checks](docs/health-checks.md) | HTTP, TCP, command, process types |
+| [State & Logs](docs/state-and-logs.md) | `.ldc/state.json`, log files, clearing state |
+| [Architecture](docs/architecture.md) | Hexagonal design, layers, extending ldc |
+| [Testing](docs/testing.md) | Running tests, writing new ones |
+
+## Requirements
+
+- Python 3.9+
+- Git for Windows
+- Windows 11
+- No Docker, no WSL

local_dev_composer-0.1.0/README.md

@@ -0,0 +1,59 @@
+# local-dev-composer (ldc)
+
+Orchestrate local microservice environments on **Windows 11** without Docker, Podman, or WSL.
+
+- Start a full service graph with one command
+- Per-service environment isolation (same variable, different values per service)
+- Dependency ordering — services start leaf-first, stop dependents-first
+- Prerequisite checks with actionable fix hints (Java version, PATH commands, env vars, ports, folders)
+- Live Rich terminal dashboard
+- Groups — declare the minimum set of services per development scenario
+- Survives restarts — reconciles live PIDs from `.ldc/state.json`
+
+## Quick start
+
+```bash
+git clone https://github.com/sbugera/local-dev-composer.git
+cd local-dev-composer
+pip install -e .
+
+cp composer.example.yml composer.yml
+# edit composer.yml for your project
+
+ldc doctor                     # check everything, get a numbered fix list
+ldc clone                      # clone all repos
+ldc check --fix                # verify and fix prerequisites
+ldc install                    # run install commands
+ldc up --group gateway-dev     # start minimum services for your task
+```
+
+## Daily use
+
+```bash
+ldc up --group gateway-dev     # start what you need
+ldc status                     # service table with PIDs and health
+ldc logs gateway -f            # follow a service log
+ldc down                       # stop everything
+```
+
+## Documentation
+
+| topic | description |
+|-------|-------------|
+| [Installation](docs/installation.md) | Setup, direct-script mode |
+| [Configuration](docs/configuration.md) | Full `composer.yml` schema reference |
+| [Commands](docs/commands.md) | All CLI commands with options |
+| [Groups](docs/groups.md) | Named service sets, smart selection |
+| [Environment](docs/environment.md) | Per-service env isolation, `.env` files |
+| [Prerequisites](docs/prerequisites.md) | Runtime/command/folder/port checks |
+| [Health Checks](docs/health-checks.md) | HTTP, TCP, command, process types |
+| [State & Logs](docs/state-and-logs.md) | `.ldc/state.json`, log files, clearing state |
+| [Architecture](docs/architecture.md) | Hexagonal design, layers, extending ldc |
+| [Testing](docs/testing.md) | Running tests, writing new ones |
+
+## Requirements
+
+- Python 3.9+
+- Git for Windows
+- Windows 11
+- No Docker, no WSL

local_dev_composer-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "local-dev-composer"
+version = "0.1.0"
+description = "Orchestrate local microservice environments on Windows without Docker or WSL"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [
+    {name = "Sergii Bugera"},
+]
+keywords = [
+    "microservices", "local-development", "developer-tools",
+    "process-manager", "windows", "devtools",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: System :: Systems Administration",
+]
+dependencies = [
+    "rich>=13.0.0",
+    "pyyaml>=6.0",
+    "psutil>=5.9.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/sbugera/local-dev-composer"
+Repository = "https://github.com/sbugera/local-dev-composer"
+Issues = "https://github.com/sbugera/local-dev-composer/issues"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+]
+
+[project.scripts]
+ldc = "ldc.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+addopts = "--import-mode=importlib"
+
+[tool.coverage.run]
+source = ["src/ldc"]

local_dev_composer-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

local_dev_composer-0.1.0/src/ldc/__init__.py

@@ -0,0 +1,3 @@
+"""local-dev-composer (ldc) — orchestrate local microservice environments."""
+
+__version__ = "0.1.0"

local_dev_composer-0.1.0/src/ldc/__main__.py

@@ -0,0 +1,5 @@
+"""Enables  python -m ldc  invocation."""
+from ldc.cli import main
+
+if __name__ == "__main__":
+    main()

local_dev_composer-0.1.0/src/ldc/adapters/config/yaml_reader.py

@@ -0,0 +1,172 @@
+"""
+Adapter: reads a composer.yml file and produces a WorkspaceConfig.
+
+YAML schema is deliberately flat and human-friendly; this adapter maps it
+to the rich domain model.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+
+from ldc.domain.exceptions import ConfigValidationError
+from ldc.domain.models import (
+    Group,
+    HealthCheckConfig,
+    HealthCheckType,
+    InstallConfig,
+    Prerequisites,
+    Runtime,
+    Service,
+    StartConfig,
+    WorkspaceConfig,
+)
+from ldc.ports.config_reader import IConfigReader
+
+
+class YamlConfigReader(IConfigReader):
+
+    def read(self, path: Path) -> WorkspaceConfig:
+        if not path.exists():
+            raise ConfigValidationError(f"Config file not found: {path}")
+
+        with path.open("r", encoding="utf-8") as fh:
+            raw = yaml.safe_load(fh)
+
+        if not isinstance(raw, dict):
+            raise ConfigValidationError("composer.yml must be a YAML mapping")
+
+        workspace_raw = raw.get("workspace", {})
+        root = workspace_raw.get("root", "./services")
+        log_dir = workspace_raw.get("log_dir", "./logs")
+
+        services_raw: Dict[str, Any] = raw.get("services", {})
+        groups_raw: Dict[str, Any] = raw.get("groups", {})
+
+        services = {
+            name: self._parse_service(name, svc_raw)
+            for name, svc_raw in services_raw.items()
+        }
+
+        groups = {
+            name: self._parse_group(name, grp_raw)
+            for name, grp_raw in groups_raw.items()
+        }
+
+        return WorkspaceConfig(
+            root=root,
+            log_dir=log_dir,
+            services=services,
+            groups=groups,
+        )
+
+    # ------------------------------------------------------------------
+    # Private helpers
+    # ------------------------------------------------------------------
+
+    def _parse_service(self, name: str, raw: Dict[str, Any]) -> Service:
+        runtime_str = raw.get("runtime", "custom")
+        try:
+            runtime = Runtime(runtime_str.lower())
+        except ValueError:
+            raise ConfigValidationError(
+                f"Service '{name}': unknown runtime '{runtime_str}'. "
+                f"Valid values: {[r.value for r in Runtime]}"
+            )
+
+        return Service(
+            name=name,
+            runtime=runtime,
+            depends_on=raw.get("depends_on", []),
+            repo=raw.get("repo"),
+            branch=raw.get("branch", "main"),
+            dir=raw.get("dir"),
+            env=raw.get("env", {}),
+            env_files=self._parse_env_files(raw),
+            requires=self._parse_prerequisites(raw.get("requires")),
+            install=self._parse_install(raw.get("install")),
+            start=self._parse_start(raw.get("start")),
+            health_check=self._parse_health_check(name, raw.get("health_check")),
+            labels=raw.get("labels", {}),
+            description=raw.get("description", ""),
+        )
+
+    def _parse_env_files(self, raw: Dict[str, Any]) -> list:
+        if "env_files" in raw:
+            value = raw["env_files"]
+            return [value] if isinstance(value, str) else list(value)
+        if "env_file" in raw:
+            value = raw["env_file"]
+            return [value] if value else []
+        return []
+
+    def _parse_prerequisites(self, raw: Optional[Dict]) -> Optional[Prerequisites]:
+        if not raw:
+            return None
+        return Prerequisites(
+            java=raw.get("java"),
+            python=raw.get("python"),
+            node=raw.get("node"),
+            dotnet=raw.get("dotnet"),
+            commands=raw.get("commands", []),
+            env_vars=raw.get("env_vars", []),
+            folders=raw.get("folders", []),
+            files=raw.get("files", []),
+            ports_free=raw.get("ports_free", []),
+        )
+
+    def _parse_install(self, raw: Optional[Any]) -> Optional[InstallConfig]:
+        if not raw:
+            return None
+        if isinstance(raw, str):
+            return InstallConfig(command=raw)
+        return InstallConfig(
+            command=raw["command"],
+            working_dir=raw.get("working_dir", "."),
+        )
+
+    def _parse_start(self, raw: Optional[Any]) -> Optional[StartConfig]:
+        if not raw:
+            return None
+        if isinstance(raw, str):
+            return StartConfig(command=raw)
+        return StartConfig(
+            command=raw["command"],
+            args=raw.get("args", []),
+            working_dir=raw.get("working_dir", "."),
+        )
+
+    def _parse_health_check(
+        self, service_name: str, raw: Optional[Dict]
+    ) -> Optional[HealthCheckConfig]:
+        if not raw:
+            return None
+
+        type_str = raw.get("type", "process")
+        try:
+            hc_type = HealthCheckType(type_str.lower())
+        except ValueError:
+            raise ConfigValidationError(
+                f"Service '{service_name}': unknown health_check type '{type_str}'"
+            )
+
+        return HealthCheckConfig(
+            type=hc_type,
+            url=raw.get("url"),
+            host=raw.get("host", "localhost"),
+            port=raw.get("port"),
+            command=raw.get("command"),
+            expected_output=raw.get("expected_output"),
+            interval_seconds=raw.get("interval", 5),
+            timeout_seconds=raw.get("timeout", 60),
+            retries=raw.get("retries", 12),
+        )
+
+    def _parse_group(self, name: str, raw: Dict[str, Any]) -> Group:
+        return Group(
+            name=name,
+            description=raw.get("description", ""),
+            services=raw.get("services", []),
+        )

local_dev_composer-0.1.0/src/ldc/adapters/git/subprocess_client.py

@@ -0,0 +1,64 @@
+"""
+Adapter: git operations via the system git binary (via subprocess).
+Works on Windows with Git for Windows / GitBash.
+"""
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from ldc.ports.git_client import IGitClient
+
+
+class SubprocessGitClient(IGitClient):
+
+    def clone(self, repo_url: str, dest: Path, branch: str = "main") -> None:
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        self._run(
+            ["git", "clone", "--branch", branch, "--depth", "1", repo_url, dest.name],
+            cwd=str(dest.parent),
+        )
+
+    def pull(self, repo_dir: Path, branch: str = "main") -> None:
+        self._run(["git", "fetch", "origin"], cwd=str(repo_dir))
+        self._run(
+            ["git", "checkout", branch], cwd=str(repo_dir)
+        )
+        self._run(
+            ["git", "pull", "origin", branch, "--ff-only"],
+            cwd=str(repo_dir),
+        )
+
+    def is_cloned(self, dest: Path) -> bool:
+        git_dir = dest / ".git"
+        return git_dir.exists()
+
+    def current_branch(self, repo_dir: Path) -> str:
+        result = self._run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=str(repo_dir),
+            capture=True,
+        )
+        return result.stdout.strip()
+
+    # ------------------------------------------------------------------
+
+    def _run(
+        self,
+        cmd: list,
+        cwd: str,
+        capture: bool = False,
+    ) -> subprocess.CompletedProcess:
+        result = subprocess.run(
+            cmd,
+            cwd=cwd,
+            capture_output=capture,
+            text=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            stderr = result.stderr.strip() if capture else ""
+            raise RuntimeError(
+                f"git command failed (exit {result.returncode}): {' '.join(cmd)}\n{stderr}"
+            )
+        return result

local_dev_composer-0.1.0/src/ldc/adapters/health/command_checker.py

@@ -0,0 +1,41 @@
+"""Adapter: health check via arbitrary command exit code / output."""
+from __future__ import annotations
+
+import subprocess
+import time
+
+from ldc.domain.models import HealthCheckConfig, HealthCheckType
+from ldc.ports.health_checker import IHealthChecker
+
+
+class CommandHealthChecker(IHealthChecker):
+
+    def supports(self, config: HealthCheckConfig) -> bool:
+        return config.type == HealthCheckType.COMMAND
+
+    def check(self, config: HealthCheckConfig) -> bool:
+        if not config.command:
+            return False
+        try:
+            result = subprocess.run(
+                config.command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode != 0:
+                return False
+            if config.expected_output:
+                return config.expected_output in (result.stdout + result.stderr)
+            return True
+        except Exception:
+            return False
+
+    def wait_healthy(self, config: HealthCheckConfig) -> bool:
+        deadline = time.monotonic() + config.timeout_seconds
+        while time.monotonic() < deadline:
+            if self.check(config):
+                return True
+            time.sleep(config.interval_seconds)
+        return False

local_dev_composer-0.1.0/src/ldc/adapters/health/composite_checker.py

@@ -0,0 +1,39 @@
+"""
+Adapter: dispatches health checks to the appropriate concrete checker
+based on HealthCheckConfig.type.
+"""
+from __future__ import annotations
+
+import time
+from typing import List
+
+from ldc.domain.models import HealthCheckConfig
+from ldc.ports.health_checker import IHealthChecker
+
+
+class CompositeHealthChecker(IHealthChecker):
+    """Routes to the first registered checker that supports the config type."""
+
+    def __init__(self, checkers: List[IHealthChecker]) -> None:
+        self._checkers = checkers
+
+    def supports(self, config: HealthCheckConfig) -> bool:
+        return any(c.supports(config) for c in self._checkers)
+
+    def check(self, config: HealthCheckConfig) -> bool:
+        checker = self._find(config)
+        if checker is None:
+            return False
+        return checker.check(config)
+
+    def wait_healthy(self, config: HealthCheckConfig) -> bool:
+        checker = self._find(config)
+        if checker is None:
+            return False
+        return checker.wait_healthy(config)
+
+    def _find(self, config: HealthCheckConfig) -> "IHealthChecker | None":
+        for c in self._checkers:
+            if c.supports(config):
+                return c
+        return None

local_dev_composer-0.1.0/src/ldc/adapters/health/http_checker.py

@@ -0,0 +1,31 @@
+"""Adapter: HTTP/HTTPS health check."""
+from __future__ import annotations
+
+import time
+import urllib.request
+import urllib.error
+
+from ldc.domain.models import HealthCheckConfig, HealthCheckType
+from ldc.ports.health_checker import IHealthChecker
+
+
+class HttpHealthChecker(IHealthChecker):
+
+    def supports(self, config: HealthCheckConfig) -> bool:
+        return config.type == HealthCheckType.HTTP
+
+    def check(self, config: HealthCheckConfig) -> bool:
+        try:
+            req = urllib.request.Request(config.url)
+            with urllib.request.urlopen(req, timeout=5) as resp:
+                return 200 <= resp.status < 400
+        except Exception:
+            return False
+
+    def wait_healthy(self, config: HealthCheckConfig) -> bool:
+        deadline = time.monotonic() + config.timeout_seconds
+        while time.monotonic() < deadline:
+            if self.check(config):
+                return True
+            time.sleep(config.interval_seconds)
+        return False

local_dev_composer-0.1.0/src/ldc/adapters/health/process_checker.py

@@ -0,0 +1,28 @@
+"""Adapter: health check that simply verifies the process is alive."""
+from __future__ import annotations
+
+import time
+
+import psutil
+
+from ldc.domain.models import HealthCheckConfig, HealthCheckType
+from ldc.ports.health_checker import IHealthChecker
+
+
+class ProcessHealthChecker(IHealthChecker):
+
+    def __init__(self, pid_provider) -> None:
+        # pid_provider: callable(service_name) -> Optional[int]
+        self._pid_provider = pid_provider
+
+    def supports(self, config: HealthCheckConfig) -> bool:
+        return config.type == HealthCheckType.PROCESS
+
+    def check(self, config: HealthCheckConfig) -> bool:
+        # For PROCESS type we just need any live process — the caller supplies PID
+        # via the provider; config carries no PID directly.
+        # This checker is used as a fallback by the orchestrator passing PID explicitly.
+        return True  # orchestrator checks is_alive() directly for PROCESS type
+
+    def wait_healthy(self, config: HealthCheckConfig) -> bool:
+        return True

local_dev_composer-0.1.0/src/ldc/adapters/health/tcp_checker.py

@@ -0,0 +1,33 @@
+"""Adapter: TCP port health check."""
+from __future__ import annotations
+
+import socket
+import time
+
+from ldc.domain.models import HealthCheckConfig, HealthCheckType
+from ldc.ports.health_checker import IHealthChecker
+
+
+class TcpHealthChecker(IHealthChecker):
+
+    def supports(self, config: HealthCheckConfig) -> bool:
+        return config.type == HealthCheckType.TCP
+
+    def check(self, config: HealthCheckConfig) -> bool:
+        host = config.host or "localhost"
+        port = config.port
+        if not port:
+            return False
+        try:
+            with socket.create_connection((host, port), timeout=3):
+                return True
+        except (OSError, socket.timeout):
+            return False
+
+    def wait_healthy(self, config: HealthCheckConfig) -> bool:
+        deadline = time.monotonic() + config.timeout_seconds
+        while time.monotonic() < deadline:
+            if self.check(config):
+                return True
+            time.sleep(config.interval_seconds)
+        return False