devctl 1.0.0__py3-none-any.whl

devctl/generators/scaffold_vue.py

@@ -0,0 +1,111 @@
+"""
+Vue.js resource scaffolding generator.
+Handles the creation of features including models, services, and views.
+"""
+
+import os
+
+import typer
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+from devctl.generators.scaffold_angular import parse_ts_fields
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_vue_resource(resource_name: str, fields_str: str, root_path: str = "."):
+    """
+    Orchestrates the creation of a complete Vue 3 feature.
+    """
+    env_state = detect_environment(root_path)
+
+    if not env_state["has_vue"]:
+        typer.secho("Error: No Vue.js project detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    vue_root = env_state["vue_path"]
+    resource_lower = resource_name.lower()
+    entity_name = resource_name.capitalize()
+
+    # Feature target directory: src/features/resource_name
+    feature_dir = os.path.join(vue_root, "src", "features", resource_lower)
+
+    # Subdirectories and files to generate
+    components = [
+        # Models
+        {
+            "dir": "models",
+            "suffix": "Models",
+            "ext": ".ts",
+            "template": "models.ts.j2",
+        },
+        # Service
+        {
+            "dir": "services",
+            "suffix": "Service",
+            "ext": ".ts",
+            "template": "service.ts.j2",
+        },
+        # Routes
+        {
+            "dir": "",
+            "suffix": "Routes",
+            "ext": ".ts",
+            "template": "routes.ts.j2",
+        },
+        # List Component
+        {
+            "dir": "views",
+            "suffix": "List",
+            "ext": ".vue",
+            "template": "List.vue.j2",
+        },
+        # Form Component
+        {
+            "dir": "views",
+            "suffix": "Form",
+            "ext": ".vue",
+            "template": "Form.vue.j2",
+        },
+    ]
+
+    templates_dir = os.path.join(os.path.dirname(__file__), "..", "templates", "vue", "feature")
+    env = Environment(
+        loader=FileSystemLoader(templates_dir),
+        autoescape=select_autoescape(["html", "xml"]),
+    )
+
+    typer.secho(f"Generating Vue.js feature '{entity_name}'...", fg=typer.colors.CYAN)
+
+    # Template data
+    context = {
+        "entity_name": entity_name,
+        "resource_name_lower": resource_lower,
+        "table_name": f"{resource_lower}s",
+        "uppercase_name": resource_name.upper(),
+        "fields": parse_ts_fields(fields_str),
+    }
+
+    for comp in components:
+        # Create target directory
+        target_dir = os.path.join(feature_dir, os.path.normpath(comp["dir"]))
+        os.makedirs(target_dir, exist_ok=True)
+
+        target_file_name = f"{entity_name}{comp['suffix']}{comp['ext']}"
+        # Adjust name for routes to be lowercase e.g. taskRoutes.ts
+        if comp["suffix"] == "Routes":
+            target_file_name = f"{resource_lower}{comp['suffix']}{comp['ext']}"
+
+        try:
+            template = env.get_template(comp["template"])
+            content = template.render(context)
+
+            with open(os.path.join(target_dir, target_file_name), "w", encoding="utf-8") as f:
+                f.write(content)
+
+            display_dir = comp["dir"] if comp["dir"] else "feature root"
+            typer.echo(f"  - Created: {display_dir}/{target_file_name}")
+
+        except Exception as e:
+            typer.secho(f"Warning: Error on {comp['template']}: {e}", fg=typer.colors.YELLOW)
+
+    typer.secho(f"{entity_name} Vue feature successfully generated!", fg=typer.colors.GREEN)

devctl/generators/spring.py

@@ -0,0 +1,221 @@
+"""
+Generators for Spring Boot projects.
+Includes boilerplate downloading via Spring Initializr and POM patching.
+"""
+
+import io
+import os
+import stat
+import xml.etree.ElementTree as ET
+import zipfile
+
+import requests
+import typer
+
+from devctl.generators.scaffold_spring import generate_spring_security
+
+
+def patch_pom_xml(project_path: str):
+    """
+    Surgically adds missing JJWT and MapStruct dependencies to pom.xml,
+    and configures annotation processors for Lombok + MapStruct.
+    """
+    pom_path = os.path.join(project_path, "pom.xml")
+    if not os.path.exists(pom_path):
+        return
+
+    # Register Maven namespace to avoid "ns0" prefixes
+    ns = "http://maven.apache.org/POM/4.0.0"
+    ET.register_namespace("", ns)
+    tree = ET.parse(pom_path)
+    root = tree.getroot()
+    ns_map = {"m": ns}
+
+    # 1. Add Dependencies
+    dependencies = root.find("m:dependencies", ns_map)
+    if dependencies is None:
+        dependencies = ET.SubElement(root, "{%s}dependencies" % ns)
+
+    # JJWT & MapStruct versions
+    jjwt_version = "0.12.5"
+    mapstruct_version = "1.5.5.Final"
+    lombok_version = "1.18.30"
+    lombok_mapstruct_binding_version = "0.2.0"
+
+    extra_deps = [
+        ("io.jsonwebtoken", "jjwt-api", jjwt_version, None),
+        ("io.jsonwebtoken", "jjwt-impl", jjwt_version, "runtime"),
+        ("io.jsonwebtoken", "jjwt-jackson", jjwt_version, "runtime"),
+        ("org.mapstruct", "mapstruct", mapstruct_version, None),
+    ]
+
+    # Helper to find if a dependency already exists
+    def dep_exists(gid, aid):
+        for dep in dependencies.findall("m:dependency", ns_map):
+            g = dep.find("m:groupId", ns_map)
+            a = dep.find("m:artifactId", ns_map)
+            if g is not None and a is not None and g.text == gid and a.text == aid:
+                return True
+        return False
+
+    for gid, aid, ver, scope in extra_deps:
+        if not dep_exists(gid, aid):
+            dep = ET.SubElement(dependencies, "{%s}dependency" % ns)
+            ET.SubElement(dep, "{%s}groupId" % ns).text = gid
+            ET.SubElement(dep, "{%s}artifactId" % ns).text = aid
+            ET.SubElement(dep, "{%s}version" % ns).text = ver
+            if scope:
+                ET.SubElement(dep, "{%s}scope" % ns).text = scope
+
+    # 2. Configure Annotation Processors
+    processors = [
+        ("org.projectlombok", "lombok", lombok_version),
+        ("org.projectlombok", "lombok-mapstruct-binding", lombok_mapstruct_binding_version),
+        ("org.mapstruct", "mapstruct-processor", mapstruct_version),
+    ]
+
+    def update_annotation_paths(parent_element):
+        ap_paths = parent_element.find("m:annotationProcessorPaths", ns_map)
+        if ap_paths is None:
+            ap_paths = ET.SubElement(parent_element, "{%s}annotationProcessorPaths" % ns)
+
+        for gid, aid, ver in processors:
+            # Check if this processor already exists in this block
+            exists = False
+            for path in ap_paths.findall("m:path", ns_map):
+                g = path.find("m:groupId", ns_map)
+                a = path.find("m:artifactId", ns_map)
+                if g is not None and a is not None and g.text == gid and a.text == aid:
+                    # Update version if it exists
+                    v = path.find("m:version", ns_map)
+                    if v is not None:
+                        v.text = ver
+                    else:
+                        ET.SubElement(path, "{%s}version" % ns).text = ver
+                    exists = True
+                    break
+
+            if not exists:
+                path = ET.SubElement(ap_paths, "{%s}path" % ns)
+                ET.SubElement(path, "{%s}groupId" % ns).text = gid
+                ET.SubElement(path, "{%s}artifactId" % ns).text = aid
+                ET.SubElement(path, "{%s}version" % ns).text = ver
+
+    # Find or create maven-compiler-plugin
+    compiler_plugin = None
+    for plugin in root.findall(".//m:plugin", ns_map):
+        aid = plugin.find("m:artifactId", ns_map)
+        if aid is not None and aid.text == "maven-compiler-plugin":
+            compiler_plugin = plugin
+            break
+
+    if compiler_plugin is None:
+        build = root.find("m:build", ns_map)
+        if build is None:
+            build = ET.SubElement(root, "{%s}build" % ns)
+        plugins = build.find("m:plugins", ns_map)
+        if plugins is None:
+            plugins = ET.SubElement(build, "{%s}plugins" % ns)
+
+        compiler_plugin = ET.SubElement(plugins, "{%s}plugin" % ns)
+        ET.SubElement(compiler_plugin, "{%s}groupId" % ns).text = "org.apache.maven.plugins"
+        ET.SubElement(compiler_plugin, "{%s}artifactId" % ns).text = "maven-compiler-plugin"
+        ET.SubElement(compiler_plugin, "{%s}version" % ns).text = "3.11.0"
+
+    # Update global configuration
+    config = compiler_plugin.find("m:configuration", ns_map)
+    if config is None:
+        config = ET.SubElement(compiler_plugin, "{%s}configuration" % ns)
+    update_annotation_paths(config)
+
+    # Update configurations inside executions
+    executions = compiler_plugin.find("m:executions", ns_map)
+    if executions is not None:
+        for execution in executions.findall("m:execution", ns_map):
+            exec_config = execution.find("m:configuration", ns_map)
+            if exec_config is not None:
+                update_annotation_paths(exec_config)
+
+    # Write back to file
+    tree.write(pom_path, encoding="utf-8", xml_declaration=True)
+
+
+def download_spring_boilerplate(project_name: str, db_type: str = "postgres"):
+    """
+    Downloads and extracts a Spring Boot project via the start.spring.io API.
+    Automatically makes the Maven wrapper executable on Unix.
+    """
+    typer.secho(
+        f"Generating Spring Boot backend '{project_name}' (Driver: {db_type})...",
+        fg=typer.colors.CYAN,
+    )
+
+    # Java rule: a package name cannot contain hyphens
+    safe_package_name = project_name.replace("-", "").replace("_", "").lower()
+
+    # Dynamic mapping for the Spring API
+    db_dependency = "postgresql" if db_type == "postgres" else "mysql"
+    official_deps = [
+        "web",
+        "lombok",
+        "data-jpa",
+        "validation",
+        "security",
+        "devtools",
+        "thymeleaf",
+        db_dependency,  # postgresql or mysql
+    ]
+    dependencies = ",".join(official_deps)
+
+    # Spring Initializr API parameters
+    params = {
+        "type": "maven-project",
+        "language": "java",
+        "baseDir": project_name,
+        "groupId": "com.devctl",
+        "artifactId": project_name,
+        "name": project_name,
+        "description": "Spring Boot project generated by devctl",
+        "packageName": f"com.devctl.{safe_package_name}",
+        "packaging": "jar",
+        "javaVersion": "17",
+        "dependencies": dependencies,
+    }
+
+    url = "https://start.spring.io/starter.zip"
+
+    try:
+        response = requests.get(url, params=params)
+
+        if response.status_code != 200:
+            typer.secho(f"Error: API Rejected: {response.text}", fg=typer.colors.RED)
+            return False
+
+        z = zipfile.ZipFile(io.BytesIO(response.content))
+        z.extractall(os.getcwd())
+
+        project_path = os.path.join(os.getcwd(), project_name)
+
+        # Patch the POM to add missing libraries (JJWT, MapStruct)
+        patch_pom_xml(project_path)
+
+        mvnw_path = os.path.join(project_path, "mvnw")
+        if os.path.exists(mvnw_path):
+            # Get current file permissions
+            st = os.stat(mvnw_path)
+            # Add execute permission (stat.S_IEXEC) for the current user
+            os.chmod(mvnw_path, st.st_mode | stat.S_IEXEC)
+
+        os.chdir(project_name)
+        generate_spring_security()
+        os.chdir("..")
+
+        typer.secho(
+            f"Backend successfully generated in folder ./{project_name}!",
+            fg=typer.colors.GREEN,
+        )
+        return True
+
+    except requests.exceptions.RequestException as e:
+        typer.secho(f"Error: Network error contacting API: {e}", fg=typer.colors.RED)
+        return False

devctl/generators/svelte.py

@@ -0,0 +1,52 @@
+"""
+Generators for Svelte projects.
+Includes boilerplate generation via create-svelte.
+"""
+
+import os
+import subprocess
+
+import typer
+
+
+def generate_svelte_boilerplate(project_name: str) -> bool:
+    """
+    Generates a new SvelteKit project using create-svelte via npx.
+    """
+    typer.secho(f"Generating Svelte project '{project_name}'...", fg=typer.colors.CYAN)
+    safe_name = project_name.lower().replace("_", "-")
+
+    try:
+        typer.secho("Scaffolding SvelteKit project...", fg=typer.colors.CYAN)
+        # Using a non-interactive way to scaffold svelte
+        # We'll use the 'skeleton' template with TypeScript
+        subprocess.run(
+            [
+                "npx",
+                "sv",
+                "create",
+                safe_name,
+                "--template",
+                "skeleton",
+                "--types",
+                "typescript",
+                "--no-install",
+                "--no-git",
+            ],
+            check=True,
+        )
+
+        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)
+
+        typer.secho(f"Svelte project '{safe_name}' successfully generated!", fg=typer.colors.GREEN)
+        return True
+
+    except subprocess.CalledProcessError as e:
+        typer.secho(f"Error: Svelte creation failed with code: {e.returncode}", fg=typer.colors.RED)
+        return False
+    except Exception as e:
+        typer.secho(f"Error: Svelte initialization failed: {e}", fg=typer.colors.RED)
+        return False

devctl/generators/vue.py

@@ -0,0 +1,105 @@
+"""
+Generators for Vue.js projects via Vite.
+Includes boilerplate generation, proxy setup, and router configuration.
+"""
+
+import os
+import subprocess
+
+import typer
+from jinja2 import Environment, FileSystemLoader
+
+
+def setup_vue_proxy(project_path: str):
+    """
+    Replaces the default vite.config.ts with our version including the proxy.
+    """
+    typer.secho("Configuring Vite Proxy for Spring Boot...", fg=typer.colors.CYAN)
+
+    templates_dir = os.path.join(os.path.dirname(__file__), "..", "templates", "vue", "config")
+    env = Environment(loader=FileSystemLoader(templates_dir))
+
+    target_path = os.path.join(project_path, "vite.config.ts")
+
+    try:
+        template = env.get_template("vite.config.ts.j2")
+        content = template.render()
+        with open(target_path, "w", encoding="utf-8") as f:
+            f.write(content)
+        typer.echo("  - vite.config.ts updated with /api proxy.")
+    except Exception as e:
+        typer.secho(f"Warning: Error configuring proxy: {e}", fg=typer.colors.YELLOW)
+
+
+def setup_vue_router(project_path: str):
+    """
+    Installs vue-router and configures the base architecture (main.ts, router, App.vue).
+    """
+    typer.secho("Installing and configuring vue-router...", fg=typer.colors.CYAN)
+
+    try:
+        # 1. NPM package installation
+        subprocess.run(
+            ["npm", "install", "vue-router@4"],
+            cwd=project_path,
+            check=True,
+            stdout=subprocess.DEVNULL,
+        )
+
+        # 2. Router directory creation
+        src_dir = os.path.join(project_path, "src")
+        router_dir = os.path.join(src_dir, "router")
+        os.makedirs(router_dir, exist_ok=True)
+
+        # 3. Jinja2 template rendering
+        templates_dir = os.path.join(os.path.dirname(__file__), "..", "templates", "vue", "config")
+        env = Environment(loader=FileSystemLoader(templates_dir))
+
+        files_to_generate = {
+            "router.ts.j2": os.path.join(router_dir, "index.ts"),
+            "main.ts.j2": os.path.join(src_dir, "main.ts"),
+            "App.vue.j2": os.path.join(src_dir, "App.vue"),
+        }
+
+        for tpl_name, target_path in files_to_generate.items():
+            template = env.get_template(tpl_name)
+            content = template.render()
+            with open(target_path, "w", encoding="utf-8") as f:
+                f.write(content)
+
+        typer.echo("  - Navigation architecture ready.")
+    except Exception as e:
+        typer.secho(f"Warning: Error configuring router: {e}", fg=typer.colors.YELLOW)
+
+
+def generate_vue_boilerplate(project_name: str) -> bool:
+    """
+    Generates a Vue 3 + TypeScript project via Vite.
+    """
+    typer.secho(f"Generating Vue.js frontend '{project_name}' via Vite...", fg=typer.colors.CYAN)
+    safe_name = project_name.lower().replace("_", "-")
+
+    try:
+        typer.secho("Scaffolding Vite project...", fg=typer.colors.CYAN)
+        subprocess.run(
+            ["npm", "create", "vite@latest", safe_name, "--", "--template", "vue-ts"], check=True
+        )
+
+        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)
+
+        # --- CALL OUR TWO CONFIGURATORS ---
+        setup_vue_proxy(project_full_path)
+        setup_vue_router(project_full_path)
+        # ----------------------------------------
+
+        typer.secho(f"Vue.js frontend '{safe_name}' successfully generated!", fg=typer.colors.GREEN)
+        return True
+
+    except subprocess.CalledProcessError as e:
+        typer.secho(
+            f"Error: Vue/Vite process failed with code: {e.returncode}", fg=typer.colors.RED
+        )
+        return False

devctl/main.py

@@ -0,0 +1,45 @@
+import typer
+
+# Import command modules
+from devctl.commands import add, deploy, docker, init, run
+
+# Create the main Typer application
+app = typer.Typer(help="devctl: Local orchestrator for your Spring/Angular projects")
+
+# Register sub-commands
+app.add_typer(init.app, name="init", help="Initialize a new project with its codebase.")
+app.add_typer(run.app, name="run", help="Launch the local development environment in parallel.")
+app.add_typer(add.app, name="add", help="Generate code and business resources.")
+
+app.command("dockerize", help="Scaffold Dockerfiles for supported projects.")(docker.dockerize)
+app.command("deploy", help="Generate a global docker-compose-prod.yml for the entire project.")(
+    deploy.deploy
+)
+
+
+@app.callback()
+def callback():
+    """
+    devctl: Local orchestrator for your projects
+    """
+    # This empty callback allows Typer to understand it handles a multi-command menu
+    pass
+
+
+@app.command()
+def ping():
+    """
+    Health check command to verify the CLI is responding.
+    """
+    typer.secho("pong! The devctl CLI is perfectly operational.", fg=typer.colors.GREEN, bold=True)
+
+
+def main():
+    """
+    Entry point called by the operating system (via pyproject.toml)
+    """
+    app()
+
+
+if __name__ == "__main__":
+    main()

devctl/orchestrator/__init__.py

@@ -0,0 +1,3 @@
+"""
+Core orchestration logic for scanning and running the development environment.
+"""

devctl/orchestrator/config_builder.py

@@ -0,0 +1,64 @@
+"""
+Configuration builder for Spring Boot projects.
+Generates docker-compose-db.yml and application.properties with dynamic database settings.
+"""
+
+import os
+
+import typer
+from jinja2 import Environment, FileSystemLoader
+
+
+def generate_config(project_name: str, db_type: str = "postgres", custom_port: int = None):
+    """
+    Generates the initial configuration (Docker and Spring properties) for a new project.
+    """
+    template_dir = os.path.join(os.path.dirname(__file__), "..", "templates", "spring")
+    env = Environment(loader=FileSystemLoader(template_dir))
+
+    # Intelligent default port resolution
+    if custom_port is None:
+        if db_type == "postgres":
+            db_port = 5432
+        elif db_type == "mysql":
+            db_port = 3306
+        elif db_type == "mongodb":
+            db_port = 27017
+        else:
+            db_port = 5432
+    else:
+        db_port = custom_port
+
+    context = {
+        "project_name": project_name,
+        "db_type": db_type,
+        "db_service_name": f"{project_name}-db",
+        "db_name": f"{project_name}_db".replace("-", "_"),
+        "db_user": "admin",
+        "db_password": "password",
+        "db_port": db_port,
+    }
+
+    project_path = os.path.join(os.getcwd(), project_name)
+
+    try:
+        docker_template = env.get_template("docker-compose.yml.j2")
+        with open(os.path.join(project_path, "docker-compose-db.yml"), "w") as f:
+            f.write(docker_template.render(context))
+
+        props_path = os.path.join(
+            project_path, "src", "main", "resources", "application.properties"
+        )
+        if os.path.exists(props_path):
+            props_template = env.get_template("application.properties.j2")
+            with open(props_path, "w") as f:
+                f.write(props_template.render(context))
+
+        typer.secho(
+            f"Dynamic configuration ({db_type} on port {db_port}) generated.",
+            fg=typer.colors.GREEN,
+        )
+        return True
+    except Exception as e:
+        typer.secho(f"Error: Configuration failed: {e}", fg=typer.colors.RED)
+        return False