devctl 1.0.0__py3-none-any.whl

devctl/__init__.py

@@ -0,0 +1,3 @@
+"""
+devctl: CLI tool to orchestrate Spring Boot and Frontend projects.
+"""

devctl/commands/__init__.py

@@ -0,0 +1,3 @@
+"""
+CLI command modules for devctl.
+"""

devctl/commands/add.py

@@ -0,0 +1,166 @@
+"""
+CLI command group for adding new resources to existing projects.
+Supports Spring Boot, Angular, Vue.js, NestJS, NodeJS, React, NextJS, FastAPI,
+Django, Svelte, and Go scaffolding.
+"""
+
+import os
+
+import typer
+
+from devctl.generators.scaffold_angular import generate_angular_resource
+from devctl.generators.scaffold_django import generate_django_resource
+from devctl.generators.scaffold_fastapi import generate_fastapi_resource
+from devctl.generators.scaffold_go import generate_go_resource
+from devctl.generators.scaffold_nestjs import generate_nest_resource
+from devctl.generators.scaffold_nextjs import generate_nextjs_resource
+from devctl.generators.scaffold_nodejs import generate_nodejs_resource
+from devctl.generators.scaffold_react import generate_react_resource
+from devctl.generators.scaffold_spring import generate_spring_resource
+from devctl.generators.scaffold_svelte import generate_svelte_resource
+from devctl.generators.scaffold_vue import generate_vue_resource
+from devctl.orchestrator.scanner import detect_environment
+from devctl.utils.dependencies import check_tool
+
+app = typer.Typer(help="Adds resources to the current project (Scaffolding).")
+
+
+@app.command()
+def resource(
+    name: str = typer.Argument(..., help="The name of the resource (e.g., Client, Product)"),
+    fields: str = typer.Option(
+        "", "--fields", "-f", help="Fields in the format 'name:type, age:int'"
+    ),
+):
+    """
+    Scans the current folder and generates a suitable business architecture.
+    """
+    typer.secho("Analyzing current context...", fg=typer.colors.CYAN)
+    env_state = detect_environment(".")
+
+    original_dir = os.getcwd()
+    project_detected = False
+
+    # Check for Spring Boot project
+    if env_state["has_spring"]:
+        check_tool("java", "generating Spring Boot resources")
+        project_detected = True
+        typer.secho(
+            "Spring Boot project detected. Launching Java generator...", fg=typer.colors.GREEN
+        )
+        os.chdir(env_state["spring_path"])
+        try:
+            generate_spring_resource(name, fields)
+        except Exception as e:
+            typer.secho(f"Error: Spring generation failed: {e}", fg=typer.colors.RED)
+        finally:
+            os.chdir(original_dir)
+
+    # Check for Angular project
+    if env_state["has_angular"]:
+        check_tool("npm", "generating Angular resources")
+        project_detected = True
+        typer.secho(
+            "Angular project detected. Launching TypeScript generator...", fg=typer.colors.CYAN
+        )
+        try:
+            generate_angular_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: Angular generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for Vue.js project
+    if env_state.get("has_vue"):
+        check_tool("npm", "generating Vue.js resources")
+        project_detected = True
+        typer.secho("Vue.js project detected. Launching Vue generator...", fg=typer.colors.GREEN)
+        try:
+            generate_vue_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: Vue generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for NestJS project
+    if env_state.get("has_nest"):
+        project_detected = True
+        typer.secho("NestJS project detected. Launching Nest generator...", fg=typer.colors.CYAN)
+        try:
+            generate_nest_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: Nest generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for React project
+    if env_state.get("has_react"):
+        project_detected = True
+        typer.secho("React project detected. Launching React generator...", fg=typer.colors.BLUE)
+        try:
+            generate_react_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: React generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for NextJS project
+    if env_state.get("has_nextjs"):
+        project_detected = True
+        typer.secho(
+            "NextJS project detected. Launching NextJS generator...", fg=typer.colors.YELLOW
+        )
+        try:
+            generate_nextjs_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: NextJS generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for FastAPI project
+    if env_state.get("has_fastapi"):
+        project_detected = True
+        typer.secho(
+            "FastAPI project detected. Launching FastAPI generator...", fg=typer.colors.CYAN
+        )
+        try:
+            generate_fastapi_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: FastAPI generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for Django project
+    if env_state.get("has_django"):
+        project_detected = True
+        typer.secho("Django project detected. Launching Django generator...", fg=typer.colors.GREEN)
+        try:
+            generate_django_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: Django generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for Svelte project
+    if env_state.get("has_svelte"):
+        project_detected = True
+        typer.secho("Svelte project detected. Launching Svelte generator...", fg=typer.colors.RED)
+        try:
+            generate_svelte_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: Svelte generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for Go project
+    if env_state.get("has_go"):
+        project_detected = True
+        typer.secho("Go project detected. Launching Go generator...", fg=typer.colors.CYAN)
+        try:
+            generate_go_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: Go generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for NodeJS project
+    if os.path.exists("package.json") and not project_detected:
+        # Heuristic for generic nodejs project if not already caught by others
+        project_detected = True
+        typer.secho("NodeJS project detected. Launching NodeJS generator...", fg=typer.colors.GREEN)
+        try:
+            generate_nodejs_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: NodeJS generation failed: {e}", fg=typer.colors.RED)
+
+    # Error message only if NO project detected
+    if not project_detected:
+        typer.secho(
+            "Error: Unable to determine project type. "
+            "Please run from within a supported project directory "
+            "(Spring, Angular, React, NextJS, FastAPI, Django, Svelte, Go, or Vue.js).",
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(code=1)

devctl/commands/deploy.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+
+import typer
+
+from devctl.generators.docker_scaffold import (
+    DockerScaffoldError,
+    scaffold_docker_assets,
+)
+
+app = typer.Typer(help="Deployment and orchestration commands.")
+
+PATH_ARGUMENT = typer.Argument(
+    Path("."),
+    help="Repository or project directory to scan for services.",
+)
+
+FORCE_OPTION = typer.Option(
+    False,
+    "--force",
+    help="Overwrite generated Docker files that already exist.",
+)
+
+@app.command()
+def deploy(
+    path: Path = PATH_ARGUMENT,
+    force: bool = FORCE_OPTION,
+):
+    """
+    Generate a global docker-compose-prod.yml by scanning subdirectories.
+    """
+    typer.secho(f"Preparing deployment for {path.resolve()}...", fg=typer.colors.CYAN, bold=True)
+
+    try:
+        result = scaffold_docker_assets(
+            path,
+            force=force,
+        )
+    except DockerScaffoldError as exc:
+        typer.secho(f"Error: {exc}", fg=typer.colors.RED)
+        raise typer.Exit(code=1) from exc
+
+    typer.secho(
+        f"Deployment scaffolding complete for {result.root_path}",
+        fg=typer.colors.CYAN,
+        bold=True,
+    )
+
+    typer.echo("\nDetected services:")
+    for service in result.services:
+        typer.echo(f"  - {service.kind}: {service.service_name} ({service.relative_context})")
+
+    typer.echo("\nFiles:")
+    for operation in result.operations:
+        if "docker-compose-prod.yml" in str(operation.path):
+            relative_path = operation.path.relative_to(result.root_path)
+            typer.echo(f"  - {operation.action}: {relative_path}")
+
+    typer.secho(
+        f"\nSummary: {result.created_count} created, {result.skipped_count} skipped.",
+        fg=typer.colors.GREEN,
+    )

devctl/commands/docker.py

@@ -0,0 +1,65 @@
+"""
+CLI command group for Docker-related operations.
+Includes scaffolding Dockerfiles for detected services.
+"""
+
+from pathlib import Path
+
+import typer
+
+from devctl.generators.docker_scaffold import (
+    DockerScaffoldError,
+    scaffold_docker_assets,
+)
+
+PATH_ARGUMENT = typer.Argument(
+    Path("."),
+    help="Repository or project directory to scan for Dockerizable services.",
+)
+FORCE_OPTION = typer.Option(
+    False,
+    "--force",
+    help="Overwrite generated Docker files that already exist.",
+)
+DRY_RUN_OPTION = typer.Option(
+    False,
+    "--dry-run",
+    help="Show what would be generated without writing files.",
+)
+
+
+def dockerize(
+    path: Path = PATH_ARGUMENT,
+    force: bool = FORCE_OPTION,
+    dry_run: bool = DRY_RUN_OPTION,
+):
+    """
+    Scaffold Dockerfiles for Spring Boot, Angular, and Vue/Vite projects.
+    """
+    try:
+        result = scaffold_docker_assets(
+            path,
+            force=force,
+            dry_run=dry_run,
+        )
+    except DockerScaffoldError as exc:
+        typer.secho(f"Error: {exc}", fg=typer.colors.RED)
+        raise typer.Exit(code=1) from exc
+
+    mode = "Dry run" if dry_run else "Docker scaffolding"
+    typer.secho(f"{mode} complete for {result.root_path}", fg=typer.colors.CYAN, bold=True)
+
+    typer.echo("\nDetected services:")
+    for service in result.services:
+        typer.echo(f"  - {service.kind}: {service.service_name} ({service.relative_context})")
+
+    typer.echo("\nFiles:")
+    for operation in result.operations:
+        relative_path = operation.path.relative_to(result.root_path)
+        typer.echo(f"  - {operation.action}: {relative_path}")
+
+    typer.secho(
+        f"\nSummary: {result.created_count} created, "
+        f"{result.skipped_count} skipped, {result.planned_count} planned.",
+        fg=typer.colors.GREEN,
+    )

devctl/commands/init.py

@@ -0,0 +1,193 @@
+"""
+CLI command group for initializing new projects.
+Supports Spring Boot, Angular, Vue.js, NestJS, NodeJS, React, NextJS, FastAPI,
+Django, Svelte, and Go.
+"""
+
+import typer
+
+# Angular generator
+from devctl.generators.angular import generate_angular_boilerplate
+from devctl.generators.django import generate_django_boilerplate
+from devctl.generators.fastapi import generate_fastapi_boilerplate
+from devctl.generators.go_fiber import generate_go_boilerplate
+from devctl.generators.nestjs import generate_nest_boilerplate
+from devctl.generators.nextjs import generate_nextjs_boilerplate
+from devctl.generators.nodejs import generate_nodejs_boilerplate
+from devctl.generators.react import generate_react_boilerplate
+
+# Spring generator
+from devctl.generators.spring import download_spring_boilerplate
+from devctl.generators.svelte import generate_svelte_boilerplate
+from devctl.generators.vue import generate_vue_boilerplate
+from devctl.orchestrator.config_builder import generate_config
+from devctl.utils.dependencies import check_tool
+
+# Local Typer application for "init" command group
+app = typer.Typer(help="Initializes a new project based on the chosen framework.")
+
+
+@app.command("spring")
+def init_spring(
+    name: str,
+    db: str = typer.Option("postgres", help="Database type (postgres, mysql, or mongodb)"),
+    port: int = typer.Option(None, help="Local port (optional)"),
+):
+    """
+    Initializes a new Spring Boot backend project with its database.
+    """
+    check_tool("java", "initializing a Spring Boot project")
+
+    # Strict input validation
+    if db not in ["postgres", "mysql", "mongodb"]:
+        typer.secho(f"Error: Database '{db}' is not supported.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    typer.secho(f"Initializing Spring Boot project: '{name}'...", fg=typer.colors.CYAN)
+
+    success_download = download_spring_boilerplate(name, db_type=db)
+
+    if success_download:
+        generate_config(name, db_type=db, custom_port=port)
+        typer.secho("\nSpring project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("angular")
+def init_angular(name: str):
+    """
+    Initializes a new Angular frontend project.
+    """
+    check_tool("npm", "initializing an Angular project")
+    check_tool("ng", "initializing an Angular project")
+
+    typer.secho(f"Initializing Angular project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_angular_boilerplate(name)
+
+    if success:
+        typer.secho("\nAngular project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("vue")
+def init_vue(name: str):
+    """
+    Initializes a new Vue.js frontend project (Vite + TS).
+    """
+    check_tool("npm", "initializing a Vue.js project")
+
+    typer.secho(f"Initializing Vue.js project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_vue_boilerplate(name)
+
+    if success:
+        typer.secho("\nVue.js project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("nest")
+def init_nest(name: str):
+    """
+    Initializes a new NestJS backend project.
+    """
+    check_tool("npm", "initializing a NestJS project")
+
+    typer.secho(f"Initializing NestJS project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_nest_boilerplate(name)
+
+    if success:
+        typer.secho("\nNestJS project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("nodejs")
+def init_nodejs(name: str):
+    """
+    Initializes a new NodeJS/Express backend project.
+    """
+    check_tool("npm", "initializing a NodeJS project")
+
+    typer.secho(f"Initializing NodeJS project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_nodejs_boilerplate(name)
+
+    if success:
+        typer.secho("\nNodeJS project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("react")
+def init_react(name: str):
+    """
+    Initializes a new ReactJS frontend project (Vite + TS).
+    """
+    check_tool("npm", "initializing a ReactJS project")
+
+    typer.secho(f"Initializing ReactJS project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_react_boilerplate(name)
+
+    if success:
+        typer.secho("\nReactJS project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("nextjs")
+def init_nextjs(name: str):
+    """
+    Initializes a new NextJS frontend project.
+    """
+    check_tool("npm", "initializing a NextJS project")
+
+    typer.secho(f"Initializing NextJS project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_nextjs_boilerplate(name)
+
+    if success:
+        typer.secho("\nNextJS project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("fastapi")
+def init_fastapi(name: str):
+    """
+    Initializes a new FastAPI backend project.
+    """
+    check_tool("python3", "initializing a FastAPI project")
+
+    typer.secho(f"Initializing FastAPI project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_fastapi_boilerplate(name)
+
+    if success:
+        typer.secho("\nFastAPI project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("django")
+def init_django(name: str):
+    """
+    Initializes a new Django backend project.
+    """
+    check_tool("python3", "initializing a Django project")
+
+    typer.secho(f"Initializing Django project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_django_boilerplate(name)
+
+    if success:
+        typer.secho("\nDjango project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("svelte")
+def init_svelte(name: str):
+    """
+    Initializes a new SvelteKit frontend project.
+    """
+    check_tool("npm", "initializing a Svelte project")
+
+    typer.secho(f"Initializing Svelte project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_svelte_boilerplate(name)
+
+    if success:
+        typer.secho("\nSvelte project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("go")
+def init_go(name: str):
+    """
+    Initializes a new Go/Fiber backend project.
+    """
+    check_tool("go", "initializing a Go project")
+
+    typer.secho(f"Initializing Go project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_go_boilerplate(name)
+
+    if success:
+        typer.secho("\nGo project ready!", fg=typer.colors.GREEN)

devctl/commands/run.py

@@ -0,0 +1,67 @@
+"""
+CLI command group for running the local development environment.
+Automatically detects and launches backend, frontend, and database services.
+"""
+
+from pathlib import Path
+
+import typer
+
+from devctl.generators.docker_scaffold import discover_docker_projects
+from devctl.orchestrator.runner import launch_dev_environment
+from devctl.utils.dependencies import check_tool
+
+app = typer.Typer(help="Local execution and development commands.")
+
+
+@app.callback(invoke_without_command=True)
+def run_env(ctx: typer.Context):
+    """
+    Scans the current tree and automatically launches Spring, Angular, Vue, and Databases.
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    typer.secho("Analyzing the current directory tree...", fg=typer.colors.CYAN)
+
+    projects = discover_docker_projects(".")
+
+    # Check for docker-compose-db.yml files
+    docker_composes = []
+    for p in Path(".").rglob("docker-compose-db.yml"):
+        if "node_modules" not in str(p) and "target" not in str(p) and ".git" not in str(p):
+            docker_composes.append(p.parent)
+
+    any(p.kind == "spring" for p in projects)
+    any(p.kind == "angular" for p in projects)
+    any(p.kind == "vue" for p in projects)
+    has_docker = len(docker_composes) > 0
+
+    # Check dependencies based on detection
+    if has_docker:
+        check_tool("docker", "running the database environment")
+
+    # Group counts
+    counts = {}
+    for p in projects:
+        counts[p.kind] = counts.get(p.kind, 0) + 1
+
+    # Visual summary of detection for the user
+    def get_status(condition: bool):
+        return (
+            typer.style("FOUND", fg=typer.colors.GREEN)
+            if condition
+            else typer.style("MISSING", fg=typer.colors.RED)
+        )
+
+    typer.echo(f"  - Docker Compose DB ({len(docker_composes)}) : {get_status(has_docker)}")
+
+    for kind in sorted(counts.keys()):
+        typer.echo(f"  - {kind.capitalize()} ({counts[kind]}) : {get_status(True)}")
+
+    if not projects and not docker_composes:
+        typer.secho("\nError: No valid development environment detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    # Transfer control to the system orchestration layer
+    launch_dev_environment(projects, docker_composes)

devctl/generators/__init__.py

@@ -0,0 +1,3 @@
+"""
+Code and asset generators for various frameworks and tools.
+"""

devctl/generators/angular.py

@@ -0,0 +1,112 @@
+"""
+Generators for Angular projects.
+Includes boilerplate generation and environment configuration.
+"""
+
+import json
+import os
+import subprocess
+
+import typer
+from jinja2 import Environment, FileSystemLoader
+
+
+def setup_angular_environments(project_path: str):
+    """
+    Generates environments and proxy for an Angular project.
+    """
+    typer.secho("Configuring Proxy and Environments...", fg=typer.colors.CYAN)
+
+    # 1. Target paths
+    src_dir = os.path.join(project_path, "src")
+    env_dir = os.path.join(src_dir, "environments")
+    os.makedirs(env_dir, exist_ok=True)
+
+    # 2. Template rendering via Jinja2
+    templates_dir = os.path.join(os.path.dirname(__file__), "..", "templates", "angular", "config")
+    env = Environment(loader=FileSystemLoader(templates_dir))
+
+    files_to_generate = {
+        "proxy.conf.json.j2": os.path.join(project_path, "src", "proxy.conf.json"),
+        "environment.ts.j2": os.path.join(env_dir, "environment.ts"),
+        "environment.development.ts.j2": os.path.join(env_dir, "environment.development.ts"),
+    }
+
+    for tpl_name, target_path in files_to_generate.items():
+        try:
+            template = env.get_template(tpl_name)
+            content = template.render()
+            with open(target_path, "w", encoding="utf-8") as f:
+                f.write(content)
+        except Exception as e:
+            typer.secho(f"Warning: Failed to generate {tpl_name}: {e}", fg=typer.colors.YELLOW)
+
+    # 3. Modify angular.json to enable the proxy
+    angular_json_path = os.path.join(project_path, "angular.json")
+    if os.path.exists(angular_json_path):
+        with open(angular_json_path, "r", encoding="utf-8") as f:
+            angular_config = json.load(f)
+
+        try:
+            # Find the default project name (usually the same name as the folder)
+            project_name = list(angular_config["projects"].keys())[0]
+
+            # Injection of proxyConfig into the "serve" architect
+            serve_target = angular_config["projects"][project_name]["architect"]["serve"]
+
+            # Ensure "options" exists
+            if "options" not in serve_target:
+                serve_target["options"] = {}
+
+            serve_target["options"]["proxyConfig"] = "src/proxy.conf.json"
+
+            with open(angular_json_path, "w", encoding="utf-8") as f:
+                json.dump(angular_config, f, indent=2)
+
+            typer.echo("  - angular.json updated with proxyConfig.")
+        except Exception as e:
+            typer.secho(
+                f"Warning: Unable to modify angular.json automatically: {e}",
+                fg=typer.colors.YELLOW,
+            )
+
+
+def generate_angular_boilerplate(project_name: str) -> bool:
+    """
+    Generates an Angular project via the native CLI (@angular/cli) and configures it.
+    """
+    typer.secho(f"Generating Angular frontend '{project_name}'...", fg=typer.colors.CYAN)
+
+    safe_name = project_name.lower().replace("_", "-")
+
+    try:
+        subprocess.run(["ng", "version"], capture_output=True, check=True)
+    except FileNotFoundError:
+        typer.secho(
+            "Error: Angular CLI ('ng') not found on your system.",
+            fg=typer.colors.RED,
+        )
+        return False
+    except subprocess.CalledProcessError:
+        typer.secho("Error: Angular CLI is installed but not responding.", fg=typer.colors.RED)
+        return False
+
+    try:
+        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)
+
+        # Post-installation configuration
+        project_full_path = os.path.join(os.getcwd(), safe_name)
+        setup_angular_environments(project_full_path)
+
+        typer.secho(
+            f"Frontend '{safe_name}' successfully generated and configured!",
+            fg=typer.colors.GREEN,
+        )
+        return True
+
+    except subprocess.CalledProcessError as e:
+        typer.secho(f"Error: Angular process failed with code: {e.returncode}", fg=typer.colors.RED)
+        return False