devctl 1.0.0__tar.gz → 1.1.0__tar.gz

{devctl-1.0.0 → devctl-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devctl
-Version: 1.0.0
+Version: 1.1.0
 Summary: Local development orchestrator for Spring Boot, Angular, and Vue.js
 Author: Youssef Fellah
 License: MIT License
@@ -45,10 +45,11 @@ Dynamic: license-file
 orchestrate the development lifecycle for modern full-stack architectures. It
 provides a unified workflow for managing backends (Spring Boot, NestJS, Go,
 FastAPI), frontends (Angular, Vue, React, NextJS, Svelte), and their
-containerization.
+containerization across Linux, macOS, and Windows.
 
 ## Core Features
 
+-   **Cross-Platform Architecture**: Out-of-the-box support for Windows, Linux, and macOS utilizing a robust platform abstraction layer.
 -   **Multi-Stack Orchestration**: Launch databases, multiple microservices, and
     frontend dev servers with a single command. Includes real-time, prefixed log
     streaming.

{devctl-1.0.0 → devctl-1.1.0}/README.md

@@ -4,10 +4,11 @@
 orchestrate the development lifecycle for modern full-stack architectures. It
 provides a unified workflow for managing backends (Spring Boot, NestJS, Go,
 FastAPI), frontends (Angular, Vue, React, NextJS, Svelte), and their
-containerization.
+containerization across Linux, macOS, and Windows.
 
 ## Core Features
 
+-   **Cross-Platform Architecture**: Out-of-the-box support for Windows, Linux, and macOS utilizing a robust platform abstraction layer.
 -   **Multi-Stack Orchestration**: Launch databases, multiple microservices, and
     frontend dev servers with a single command. Includes real-time, prefixed log
     streaming.

{devctl-1.0.0 → devctl-1.1.0}/devctl/generators/angular.py

@@ -79,8 +79,15 @@ def generate_angular_boilerplate(project_name: str) -> bool:
 
     safe_name = project_name.lower().replace("_", "-")
 
+    from devctl.utils import get_platform
+    platform = get_platform()
     try:
-        subprocess.run(["ng", "version"], capture_output=True, check=True)
+        subprocess.run(
+            ["ng", "version"],
+            capture_output=True,
+            check=True,
+            shell=platform.shell_required,
+        )
     except FileNotFoundError:
         typer.secho(
             "Error: Angular CLI ('ng') not found on your system.",
@@ -95,7 +102,7 @@ def generate_angular_boilerplate(project_name: str) -> bool:
         command = ["ng", "new", safe_name, "--routing=true", "--style=scss", "--skip-git=true"]
 
         typer.secho("Downloading npm packages... (This may take 1-2 minutes)", fg=typer.colors.CYAN)
-        subprocess.run(command, check=True)
+        subprocess.run(command, check=True, shell=platform.shell_required)
 
         # Post-installation configuration
         project_full_path = os.path.join(os.getcwd(), safe_name)

{devctl-1.0.0 → devctl-1.1.0}/devctl/generators/django.py

@@ -28,28 +28,56 @@ django-cors-headers
         with open(os.path.join(project_path, "requirements.txt"), "w") as f:
             f.write(requirements)
 
+        import sys
+        python_exe = "python" if sys.platform == "win32" else "python3"
+
         # 2. Create virtual environment
         typer.secho("Creating virtual environment...", fg=typer.colors.CYAN)
-        subprocess.run(["python3", "-m", "venv", ".venv"], cwd=project_path, check=True)
+        subprocess.run(
+            [python_exe, "-m", "venv", ".venv"],
+            cwd=project_path,
+            check=True,
+            shell=(sys.platform == "win32"),
+        )
 
         # 3. Install Django
         typer.secho("Installing Django and DRF...", fg=typer.colors.CYAN)
-        pip_path = os.path.join(".venv", "bin", "pip")
+        if sys.platform == "win32":
+            pip_path = os.path.join(".venv", "Scripts", "pip.exe")
+        else:
+            pip_path = os.path.join(".venv", "bin", "pip")
         subprocess.run(
             [pip_path, "install", "django", "djangorestframework"],
             cwd=project_path,
             check=True,
             stdout=subprocess.DEVNULL,
+            shell=(sys.platform == "win32"),
         )
 
         # 4. Start Project
         typer.secho("Scaffolding Django project structure...", fg=typer.colors.CYAN)
-        django_admin = os.path.join(".venv", "bin", "django-admin")
-        subprocess.run([django_admin, "startproject", safe_name, "."], cwd=project_path, check=True)
+        if sys.platform == "win32":
+            django_admin = os.path.join(".venv", "Scripts", "django-admin.exe")
+        else:
+            django_admin = os.path.join(".venv", "bin", "django-admin")
+        subprocess.run(
+            [django_admin, "startproject", safe_name, "."],
+            cwd=project_path,
+            check=True,
+            shell=(sys.platform == "win32"),
+        )
 
         # 5. Create core app
-        python_path = os.path.join(".venv", "bin", "python")
-        subprocess.run([python_path, "manage.py", "startapp", "core"], cwd=project_path, check=True)
+        if sys.platform == "win32":
+            python_path = os.path.join(".venv", "Scripts", "python.exe")
+        else:
+            python_path = os.path.join(".venv", "bin", "python")
+        subprocess.run(
+            [python_path, "manage.py", "startapp", "core"],
+            cwd=project_path,
+            check=True,
+            shell=(sys.platform == "win32"),
+        )
 
         typer.secho(
             f"Django project '{project_name}' successfully generated!", fg=typer.colors.GREEN

{devctl-1.0.0 → devctl-1.1.0}/devctl/generators/fastapi.py

@@ -44,19 +44,30 @@ pydantic
         with open(os.path.join(project_path, "requirements.txt"), "w") as f:
             f.write(requirements)
 
+        import sys
+        python_exe = "python" if sys.platform == "win32" else "python3"
+
         # 3. Create virtual environment
         typer.secho("Creating virtual environment...", fg=typer.colors.CYAN)
-        subprocess.run(["python3", "-m", "venv", ".venv"], cwd=project_path, check=True)
+        subprocess.run(
+            [python_exe, "-m", "venv", ".venv"],
+            cwd=project_path,
+            check=True,
+            shell=(sys.platform == "win32"),
+        )
 
         # 4. Install dependencies
         typer.secho("Installing dependencies (fastapi, uvicorn)...", fg=typer.colors.CYAN)
-        # Note: on Linux it's .venv/bin/pip
-        pip_path = os.path.join(".venv", "bin", "pip")
+        if sys.platform == "win32":
+            pip_path = os.path.join(".venv", "Scripts", "pip.exe")
+        else:
+            pip_path = os.path.join(".venv", "bin", "pip")
         subprocess.run(
             [pip_path, "install", "-r", "requirements.txt"],
             cwd=project_path,
             check=True,
             stdout=subprocess.DEVNULL,
+            shell=(sys.platform == "win32"),
         )
 
         typer.secho(f"FastAPI project '{safe_name}' successfully generated!", fg=typer.colors.GREEN)

{devctl-1.0.0 → devctl-1.1.0}/devctl/generators/go_fiber.py

@@ -19,9 +19,16 @@ def generate_go_boilerplate(project_name: str) -> bool:
     try:
         os.makedirs(project_path, exist_ok=True)
 
+        from devctl.utils import get_platform
+        platform = get_platform()
         # 1. Go mod init
         typer.secho("Initializing Go module...", fg=typer.colors.CYAN)
-        subprocess.run(["go", "mod", "init", project_name], cwd=project_path, check=True)
+        subprocess.run(
+            ["go", "mod", "init", project_name],
+            cwd=project_path,
+            check=True,
+            shell=platform.shell_required,
+        )
 
         # 2. Install Fiber
         typer.secho("Installing Fiber framework...", fg=typer.colors.CYAN)
@@ -30,6 +37,7 @@ def generate_go_boilerplate(project_name: str) -> bool:
             cwd=project_path,
             check=True,
             stdout=subprocess.DEVNULL,
+            shell=platform.shell_required,
         )
 
         # 3. Create main.go

{devctl-1.0.0 → devctl-1.1.0}/devctl/generators/nestjs.py

@@ -21,6 +21,8 @@ def generate_nest_boilerplate(project_name: str) -> bool:
         # --strict: enables strict mode
         # --skip-git: devctl might be in a git repo already
         typer.secho("Scaffolding NestJS project (this may take a minute)...", fg=typer.colors.CYAN)
+        from devctl.utils import get_platform
+        platform = get_platform()
         subprocess.run(
             [
                 "npx",
@@ -34,6 +36,7 @@ def generate_nest_boilerplate(project_name: str) -> bool:
                 "--skip-git",
             ],
             check=True,
+            shell=platform.shell_required,
         )
 
         typer.secho(

{devctl-1.0.0 → devctl-1.1.0}/devctl/generators/nextjs.py

@@ -23,6 +23,8 @@ def generate_nextjs_boilerplate(project_name: str) -> bool:
         # --src-dir: Use src/ directory
         # --app: Use App Router
         # --import-alias: alias for imports
+        from devctl.utils import get_platform
+        platform = get_platform()
         subprocess.run(
             [
                 "npx",
@@ -38,6 +40,7 @@ def generate_nextjs_boilerplate(project_name: str) -> bool:
                 "--use-npm",
             ],
             check=True,
+            shell=platform.shell_required,
         )
 
         typer.secho(

{devctl-1.0.0 → devctl-1.1.0}/devctl/generators/nodejs.py

@@ -21,10 +21,16 @@ def generate_nodejs_boilerplate(project_name: str) -> bool:
     try:
         os.makedirs(project_path, exist_ok=True)
 
+        from devctl.utils import get_platform
+        platform = get_platform()
         # 1. Initialize package.json
         typer.secho("Initializing package.json...", fg=typer.colors.CYAN)
         subprocess.run(
-            ["npm", "init", "-y"], cwd=project_path, check=True, stdout=subprocess.DEVNULL
+            ["npm", "init", "-y"],
+            cwd=project_path,
+            check=True,
+            stdout=subprocess.DEVNULL,
+            shell=platform.shell_required,
         )
 
         # 2. Install dependencies
@@ -37,6 +43,7 @@ def generate_nodejs_boilerplate(project_name: str) -> bool:
             cwd=project_path,
             check=True,
             stdout=subprocess.DEVNULL,
+            shell=platform.shell_required,
         )
         subprocess.run(
             [
@@ -53,12 +60,17 @@ def generate_nodejs_boilerplate(project_name: str) -> bool:
             cwd=project_path,
             check=True,
             stdout=subprocess.DEVNULL,
+            shell=platform.shell_required,
         )
 
         # 3. Initialize TypeScript
         typer.secho("Configuring TypeScript...", fg=typer.colors.CYAN)
         subprocess.run(
-            ["npx", "tsc", "--init"], cwd=project_path, check=True, stdout=subprocess.DEVNULL
+            ["npx", "tsc", "--init"],
+            cwd=project_path,
+            check=True,
+            stdout=subprocess.DEVNULL,
+            shell=platform.shell_required,
         )
 
         # 4. Create folder structure

{devctl-1.0.0 → devctl-1.1.0}/devctl/generators/react.py

@@ -17,16 +17,24 @@ def generate_react_boilerplate(project_name: str) -> bool:
     safe_name = project_name.lower().replace("_", "-")
 
     try:
+        from devctl.utils import get_platform
+        platform = get_platform()
         typer.secho("Scaffolding React project...", fg=typer.colors.CYAN)
         subprocess.run(
             ["npm", "create", "vite@latest", safe_name, "--", "--template", "react-ts"],
             check=True,
+            shell=platform.shell_required,
         )
 
         project_full_path = os.path.join(os.getcwd(), safe_name)
 
         typer.secho("Installing npm dependencies...", fg=typer.colors.CYAN)
-        subprocess.run(["npm", "install"], cwd=project_full_path, check=True)
+        subprocess.run(
+            ["npm", "install"],
+            cwd=project_full_path,
+            check=True,
+            shell=platform.shell_required,
+        )
 
         typer.secho(
             f"ReactJS frontend '{safe_name}' successfully generated!", fg=typer.colors.GREEN

{devctl-1.0.0 → devctl-1.1.0}/devctl/generators/scaffold_nestjs.py

@@ -25,6 +25,8 @@ def generate_nest_resource(resource_name: str, fields_str: str, root_path: str =
 
     typer.secho(f"⚙️  Generating NestJS resource '{resource_name}'...", fg=typer.colors.CYAN)
 
+    from devctl.utils import get_platform
+    platform = get_platform()
     try:
         # Use npx to run Nest CLI
         # 'g res' is shorthand for 'generate resource'
@@ -33,6 +35,7 @@ def generate_nest_resource(resource_name: str, fields_str: str, root_path: str =
             ["npx", "@nestjs/cli", "g", "resource", resource_lower, "--no-spec"],
             cwd=nest_root,
             check=True,
+            shell=platform.shell_required,
         )
 
         typer.secho(

{devctl-1.0.0 → devctl-1.1.0}/devctl/generators/svelte.py

@@ -18,6 +18,8 @@ def generate_svelte_boilerplate(project_name: str) -> bool:
 
     try:
         typer.secho("Scaffolding SvelteKit project...", fg=typer.colors.CYAN)
+        from devctl.utils import get_platform
+        platform = get_platform()
         # Using a non-interactive way to scaffold svelte
         # We'll use the 'skeleton' template with TypeScript
         subprocess.run(
@@ -34,12 +36,18 @@ def generate_svelte_boilerplate(project_name: str) -> bool:
                 "--no-git",
             ],
             check=True,
+            shell=platform.shell_required,
         )
 
         project_full_path = os.path.join(os.getcwd(), safe_name)
 
         typer.secho("Installing npm dependencies...", fg=typer.colors.CYAN)
-        subprocess.run(["npm", "install"], cwd=project_full_path, check=True)
+        subprocess.run(
+            ["npm", "install"],
+            cwd=project_full_path,
+            check=True,
+            shell=platform.shell_required,
+        )
 
         typer.secho(f"Svelte project '{safe_name}' successfully generated!", fg=typer.colors.GREEN)
         return True

{devctl-1.0.0 → devctl-1.1.0}/devctl/generators/vue.py

@@ -37,6 +37,8 @@ def setup_vue_router(project_path: str):
     """
     typer.secho("Installing and configuring vue-router...", fg=typer.colors.CYAN)
 
+    from devctl.utils import get_platform
+    platform = get_platform()
     try:
         # 1. NPM package installation
         subprocess.run(
@@ -44,6 +46,7 @@ def setup_vue_router(project_path: str):
             cwd=project_path,
             check=True,
             stdout=subprocess.DEVNULL,
+            shell=platform.shell_required,
         )
 
         # 2. Router directory creation
@@ -79,16 +82,25 @@ def generate_vue_boilerplate(project_name: str) -> bool:
     typer.secho(f"Generating Vue.js frontend '{project_name}' via Vite...", fg=typer.colors.CYAN)
     safe_name = project_name.lower().replace("_", "-")
 
+    from devctl.utils import get_platform
+    platform = get_platform()
     try:
         typer.secho("Scaffolding Vite project...", fg=typer.colors.CYAN)
         subprocess.run(
-            ["npm", "create", "vite@latest", safe_name, "--", "--template", "vue-ts"], check=True
+            ["npm", "create", "vite@latest", safe_name, "--", "--template", "vue-ts"],
+            check=True,
+            shell=platform.shell_required,
         )
 
         project_full_path = os.path.join(os.getcwd(), safe_name)
 
         typer.secho("Installing npm dependencies...", fg=typer.colors.CYAN)
-        subprocess.run(["npm", "install"], cwd=project_full_path, check=True)
+        subprocess.run(
+            ["npm", "install"],
+            cwd=project_full_path,
+            check=True,
+            shell=platform.shell_required,
+        )
 
         # --- CALL OUR TWO CONFIGURATORS ---
         setup_vue_proxy(project_full_path)

{devctl-1.0.0 → devctl-1.1.0}/devctl/orchestrator/runner.py

@@ -17,6 +17,7 @@ from rich.console import Console
 from rich.markup import escape
 
 from devctl.generators.docker_scaffold import DockerProject
+from devctl.utils import get_platform
 from devctl.utils.env_loader import get_project_env
 
 console = Console()
@@ -56,6 +57,7 @@ def _launch_process(p: DockerProject, cmd: List[str], color: str, label: str):
     # Load environment variables including .env if present
     env = get_project_env(p.path)
 
+    platform = get_platform()
     proc = subprocess.Popen(
         cmd,
         cwd=str(p.path),
@@ -63,6 +65,7 @@ def _launch_process(p: DockerProject, cmd: List[str], color: str, label: str):
         stderr=subprocess.STDOUT,
         bufsize=1,
         env=env,
+        shell=platform.shell_required,
     )
     active_processes.append((p.name, proc))
 
@@ -82,7 +85,11 @@ def launch_dev_environment(projects: List[DockerProject], docker_composes: List[
         cleanup_and_exit(docker_composes)
 
     signal.signal(signal.SIGINT, signal_handler)
-    signal.signal(signal.SIGTERM, signal_handler)
+    if sys.platform != "win32":
+        signal.signal(signal.SIGTERM, signal_handler)
+    else:
+        if hasattr(signal, "SIGBREAK"):
+            signal.signal(signal.SIGBREAK, signal_handler)
 
     try:
         # 1. Start Databases
@@ -105,10 +112,11 @@ def launch_dev_environment(projects: List[DockerProject], docker_composes: List[
             typer.echo("Waiting 5s for databases to initialize...")
             time.sleep(5)
 
+        platform = get_platform()
         # 2. Start Projects
         for p in projects:
             if p.kind == "spring":
-                _launch_process(p, ["./mvnw", "spring-boot:run"], "green", "Spring Boot")
+                _launch_process(p, [platform.mvnw_cmd, "spring-boot:run"], "green", "Spring Boot")
 
             elif p.kind == "angular":
                 _launch_process(p, ["npx", "ng", "serve"], "cyan", "Angular")
@@ -132,17 +140,17 @@ def launch_dev_environment(projects: List[DockerProject], docker_composes: List[
                 _launch_process(p, ["npm", "run", "dev"], "green", "NodeJS")
 
             elif p.kind == "fastapi":
-                venv_python = os.path.join(str(p.path), ".venv", "bin", "python3")
+                venv_python = platform.get_venv_python(p.path)
                 if not os.path.exists(venv_python):
-                    venv_python = "python3"
+                    venv_python = platform.python_exe
                 _launch_process(
                     p, [venv_python, "-m", "uvicorn", "main:app", "--reload"], "cyan", "FastAPI"
                 )
 
             elif p.kind == "django":
-                venv_python = os.path.join(str(p.path), ".venv", "bin", "python3")
+                venv_python = platform.get_venv_python(p.path)
                 if not os.path.exists(venv_python):
-                    venv_python = "python3"
+                    venv_python = platform.python_exe
                 _launch_process(p, [venv_python, "manage.py", "runserver"], "green", "Django")
 
             elif p.kind == "go":
@@ -193,14 +201,10 @@ def launch_dev_environment(projects: List[DockerProject], docker_composes: List[
 
 def cleanup_and_exit(docker_composes: List[Path]):
     """Stops all active processes and docker containers."""
+    platform = get_platform()
     for name, proc in active_processes:
         typer.echo(f"Closing {name}...")
-        proc.terminate()
-        try:
-            proc.wait(timeout=5)
-        except subprocess.TimeoutExpired:
-            typer.echo(f"Force killing {name}...")
-            proc.kill()
+        platform.kill_process_tree(proc)
 
     for compose_path in docker_composes:
         typer.echo(f"Stopping Docker Compose DB in {compose_path}...")

devctl-1.1.0/devctl/utils/__init__.py

@@ -0,0 +1,5 @@
+"""
+General utility functions and helpers.
+"""
+
+from devctl.utils.platform import get_platform as get_platform

{devctl-1.0.0 → devctl-1.1.0}/devctl/utils/dependencies.py

@@ -13,7 +13,17 @@ def check_tool(tool_name: str, required_for: str = "this operation"):
     Check if a tool is available in the system PATH.
     If not, print a friendly error message and exit.
     """
-    if shutil.which(tool_name) is None:
+    from devctl.utils import get_platform
+    platform = get_platform()
+
+    actual_tool = tool_name
+    if tool_name == "python3" and platform.python_exe == "python":
+        actual_tool = "python"
+
+    if shutil.which(actual_tool) is None:
+        if tool_name == "python3" and shutil.which("python") is not None:
+            return
+
         typer.secho(
             f"\nError: '{tool_name}' is not installed or not in your PATH.",
             fg=typer.colors.RED,

devctl-1.1.0/devctl/utils/platform.py

@@ -0,0 +1,120 @@
+"""
+Platform abstraction layer to handle OS-specific command execution, paths, and process management.
+"""
+
+import os
+import subprocess
+import sys
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+
+class BasePlatform(ABC):
+    @property
+    @abstractmethod
+    def python_exe(self) -> str:
+        """Global python executable name."""
+        pass
+
+    @property
+    @abstractmethod
+    def mvnw_cmd(self) -> str:
+        """Maven wrapper command/script name."""
+        pass
+
+    @property
+    @abstractmethod
+    def shell_required(self) -> bool:
+        """Indicates if shell execution is required for subprocess commands."""
+        pass
+
+    @abstractmethod
+    def get_venv_python(self, project_path: Path) -> str:
+        """Returns the path to the python executable in the virtual environment."""
+        pass
+
+    @abstractmethod
+    def get_venv_pip(self, project_path: Path) -> str:
+        """Returns the path to the pip executable in the virtual environment."""
+        pass
+
+    @abstractmethod
+    def get_venv_django_admin(self, project_path: Path) -> str:
+        """Returns the path to the django-admin executable in the virtual environment."""
+        pass
+
+    @abstractmethod
+    def kill_process_tree(self, proc: subprocess.Popen) -> None:
+        """Terminates the process and all its descendants."""
+        pass
+
+
+class WindowsPlatform(BasePlatform):
+    @property
+    def python_exe(self) -> str:
+        return "python"
+
+    @property
+    def mvnw_cmd(self) -> str:
+        return "mvnw.cmd"
+
+    @property
+    def shell_required(self) -> bool:
+        return True
+
+    def get_venv_python(self, project_path: Path) -> str:
+        return os.path.join(str(project_path), ".venv", "Scripts", "python.exe")
+
+    def get_venv_pip(self, project_path: Path) -> str:
+        return os.path.join(str(project_path), ".venv", "Scripts", "pip.exe")
+
+    def get_venv_django_admin(self, project_path: Path) -> str:
+        return os.path.join(str(project_path), ".venv", "Scripts", "django-admin.exe")
+
+    def kill_process_tree(self, proc: subprocess.Popen) -> None:
+        try:
+            subprocess.run(
+                ["taskkill", "/F", "/T", "/PID", str(proc.pid)],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                check=False,
+            )
+        except Exception:
+            pass
+
+
+class UnixPlatform(BasePlatform):
+    @property
+    def python_exe(self) -> str:
+        return "python3"
+
+    @property
+    def mvnw_cmd(self) -> str:
+        return "./mvnw"
+
+    @property
+    def shell_required(self) -> bool:
+        return False
+
+    def get_venv_python(self, project_path: Path) -> str:
+        return os.path.join(str(project_path), ".venv", "bin", "python3")
+
+    def get_venv_pip(self, project_path: Path) -> str:
+        return os.path.join(str(project_path), ".venv", "bin", "pip")
+
+    def get_venv_django_admin(self, project_path: Path) -> str:
+        return os.path.join(str(project_path), ".venv", "bin", "django-admin")
+
+    def kill_process_tree(self, proc: subprocess.Popen) -> None:
+        proc.terminate()
+        try:
+            proc.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+
+
+def get_platform() -> BasePlatform:
+    """Factory function to return the correct Platform implementation."""
+    if sys.platform == "win32":
+        return WindowsPlatform()
+    return UnixPlatform()

{devctl-1.0.0 → devctl-1.1.0}/devctl.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devctl
-Version: 1.0.0
+Version: 1.1.0
 Summary: Local development orchestrator for Spring Boot, Angular, and Vue.js
 Author: Youssef Fellah
 License: MIT License
@@ -45,10 +45,11 @@ Dynamic: license-file
 orchestrate the development lifecycle for modern full-stack architectures. It
 provides a unified workflow for managing backends (Spring Boot, NestJS, Go,
 FastAPI), frontends (Angular, Vue, React, NextJS, Svelte), and their
-containerization.
+containerization across Linux, macOS, and Windows.
 
 ## Core Features
 
+-   **Cross-Platform Architecture**: Out-of-the-box support for Windows, Linux, and macOS utilizing a robust platform abstraction layer.
 -   **Multi-Stack Orchestration**: Launch databases, multiple microservices, and
     frontend dev servers with a single command. Includes real-time, prefixed log
     streaming.

{devctl-1.0.0 → devctl-1.1.0}/devctl.egg-info/SOURCES.txt

@@ -93,6 +93,7 @@ devctl/templates/vue/feature/service.ts.j2
 devctl/utils/__init__.py
 devctl/utils/dependencies.py
 devctl/utils/env_loader.py
+devctl/utils/platform.py
 test/test_add.py
 test/test_commands.py
 test/test_deploy.py
@@ -107,6 +108,7 @@ test/test_mongodb.py
 test/test_nestjs.py
 test/test_nextjs.py
 test/test_nodejs.py
+test/test_platform.py
 test/test_pom_patcher.py
 test/test_react.py
 test/test_runner.py

{devctl-1.0.0 → devctl-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devctl"
-version = "1.0.0"
+version = "1.1.0"
 description = "Local development orchestrator for Spring Boot, Angular, and Vue.js"
 readme = "README.md"
 license = {file = "LICENSE"}

devctl-1.1.0/test/test_platform.py

@@ -0,0 +1,72 @@
+import os
+import subprocess
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+from devctl.utils.platform import (
+    UnixPlatform,
+    WindowsPlatform,
+    get_platform,
+)
+
+
+def test_get_platform():
+    """Ensure get_platform returns the correct implementation based on sys.platform."""
+    with patch("sys.platform", "win32"):
+        p = get_platform()
+        assert isinstance(p, WindowsPlatform)
+
+    with patch("sys.platform", "linux"):
+        p = get_platform()
+        assert isinstance(p, UnixPlatform)
+
+
+def test_windows_platform():
+    """Ensure WindowsPlatform returns the correct values and calls taskkill."""
+    p = WindowsPlatform()
+    assert p.python_exe == "python"
+    assert p.mvnw_cmd == "mvnw.cmd"
+    assert p.shell_required is True
+
+    path = Path("proj")
+    assert p.get_venv_python(path) == os.path.join(
+        "proj", ".venv", "Scripts", "python.exe"
+    )
+    assert p.get_venv_pip(path) == os.path.join(
+        "proj", ".venv", "Scripts", "pip.exe"
+    )
+    assert p.get_venv_django_admin(path) == os.path.join(
+        "proj", ".venv", "Scripts", "django-admin.exe"
+    )
+
+    # Test kill_process_tree
+    mock_proc = MagicMock()
+    mock_proc.pid = 1234
+    with patch("subprocess.run") as mock_run:
+        p.kill_process_tree(mock_proc)
+        mock_run.assert_called_once_with(
+            ["taskkill", "/F", "/T", "/PID", "1234"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
+
+
+def test_unix_platform():
+    """Ensure UnixPlatform returns the correct values and terminates/kills process."""
+    p = UnixPlatform()
+    assert p.python_exe == "python3"
+    assert p.mvnw_cmd == "./mvnw"
+    assert p.shell_required is False
+
+    path = Path("proj")
+    assert p.get_venv_python(path) == os.path.join("proj", ".venv", "bin", "python3")
+    assert p.get_venv_pip(path) == os.path.join("proj", ".venv", "bin", "pip")
+    assert p.get_venv_django_admin(path) == os.path.join("proj", ".venv", "bin", "django-admin")
+
+    # Test kill_process_tree with normal termination
+    mock_proc = MagicMock()
+    p.kill_process_tree(mock_proc)
+    mock_proc.terminate.assert_called_once()
+    mock_proc.wait.assert_called_once_with(timeout=5)
+    mock_proc.kill.assert_not_called()

devctl-1.0.0/devctl/utils/__init__.py

@@ -1,3 +0,0 @@
-"""
-General utility functions and helpers.
-"""