devctl 1.0.0__py3-none-any.whl

devctl/generators/fastapi.py

@@ -0,0 +1,67 @@
+"""
+Generators for FastAPI projects.
+Includes boilerplate generation with Uvicorn and Pydantic.
+"""
+
+import os
+import subprocess
+
+import typer
+
+
+def generate_fastapi_boilerplate(project_name: str) -> bool:
+    """
+    Generates a new FastAPI project.
+    """
+    typer.secho(f"Generating FastAPI project '{project_name}'...", fg=typer.colors.CYAN)
+    safe_name = project_name.lower().replace("_", "-")
+    project_path = os.path.join(os.getcwd(), safe_name)
+
+    try:
+        os.makedirs(project_path, exist_ok=True)
+
+        # 1. Create main.py
+        main_py = """from fastapi import FastAPI
+
+app = FastAPI(title="devctl FastAPI project")
+
+@app.get("/")
+def read_root():
+    return {"Hello": "from devctl FastAPI!"}
+
+@app.get("/items/{item_id}")
+def read_item(item_id: int, q: str = None):
+    return {"item_id": item_id, "q": q}
+"""
+        with open(os.path.join(project_path, "main.py"), "w") as f:
+            f.write(main_py)
+
+        # 2. Create requirements.txt
+        requirements = """fastapi
+uvicorn[standard]
+pydantic
+"""
+        with open(os.path.join(project_path, "requirements.txt"), "w") as f:
+            f.write(requirements)
+
+        # 3. Create virtual environment
+        typer.secho("Creating virtual environment...", fg=typer.colors.CYAN)
+        subprocess.run(["python3", "-m", "venv", ".venv"], cwd=project_path, check=True)
+
+        # 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")
+        subprocess.run(
+            [pip_path, "install", "-r", "requirements.txt"],
+            cwd=project_path,
+            check=True,
+            stdout=subprocess.DEVNULL,
+        )
+
+        typer.secho(f"FastAPI project '{safe_name}' successfully generated!", fg=typer.colors.GREEN)
+        return True
+
+    except Exception as e:
+        typer.secho(f"Error: FastAPI initialization failed: {e}", fg=typer.colors.RED)
+        return False

devctl/generators/go_fiber.py

@@ -0,0 +1,61 @@
+"""
+Generators for Go (Fiber) projects.
+Includes boilerplate generation with Fiber framework.
+"""
+
+import os
+import subprocess
+
+import typer
+
+
+def generate_go_boilerplate(project_name: str) -> bool:
+    """
+    Generates a new Go + Fiber project.
+    """
+    typer.secho(f"Generating Go project '{project_name}'...", fg=typer.colors.CYAN)
+    project_path = os.path.join(os.getcwd(), project_name)
+
+    try:
+        os.makedirs(project_path, exist_ok=True)
+
+        # 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)
+
+        # 2. Install Fiber
+        typer.secho("Installing Fiber framework...", fg=typer.colors.CYAN)
+        subprocess.run(
+            ["go", "get", "github.com/gofiber/fiber/v2"],
+            cwd=project_path,
+            check=True,
+            stdout=subprocess.DEVNULL,
+        )
+
+        # 3. Create main.go
+        main_go = """package main
+
+import (
+    "log"
+    "github.com/gofiber/fiber/v2"
+)
+
+func main() {
+    app := fiber.New()
+
+    app.Get("/", func(c *fiber.Ctx) error {
+        return c.SendString("Hello from devctl Go/Fiber!")
+    })
+
+    log.Fatal(app.Listen(":3000"))
+}
+"""
+        with open(os.path.join(project_path, "main.go"), "w") as f:
+            f.write(main_go)
+
+        typer.secho(f"Go project '{project_name}' successfully generated!", fg=typer.colors.GREEN)
+        return True
+
+    except Exception as e:
+        typer.secho(f"Error: Go initialization failed: {e}", fg=typer.colors.RED)
+        return False

devctl/generators/nestjs.py

@@ -0,0 +1,49 @@
+"""
+Generators for NestJS projects.
+Includes boilerplate generation via Nest CLI.
+"""
+
+import subprocess
+
+import typer
+
+
+def generate_nest_boilerplate(project_name: str) -> bool:
+    """
+    Generates a new NestJS project using the Nest CLI via npx.
+    """
+    typer.secho(f"🔄 Generating NestJS project '{project_name}'...", fg=typer.colors.CYAN)
+    safe_name = project_name.lower().replace("_", "-")
+
+    try:
+        # Use npx to run Nest CLI without requiring global installation
+        # --package-manager npm: ensures npm is used
+        # --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)
+        subprocess.run(
+            [
+                "npx",
+                "-p",
+                "@nestjs/cli",
+                "nest",
+                "new",
+                safe_name,
+                "--package-manager",
+                "npm",
+                "--skip-git",
+            ],
+            check=True,
+        )
+
+        typer.secho(
+            f"✅ NestJS project '{safe_name}' successfully generated!", fg=typer.colors.GREEN
+        )
+        return True
+
+    except subprocess.CalledProcessError as e:
+        typer.secho(f"❌ Nest CLI process failed with code: {e.returncode}", fg=typer.colors.RED)
+        return False
+    except FileNotFoundError:
+        typer.secho("❌ Error: 'npx' or 'npm' not found in path.", fg=typer.colors.RED)
+        return False

devctl/generators/nextjs.py

@@ -0,0 +1,53 @@
+"""
+Generators for NextJS projects.
+Includes boilerplate generation via create-next-app.
+"""
+
+import subprocess
+
+import typer
+
+
+def generate_nextjs_boilerplate(project_name: str) -> bool:
+    """
+    Generates a new NextJS project using create-next-app via npx.
+    """
+    typer.secho(f"🔄 Generating NextJS project '{project_name}'...", fg=typer.colors.CYAN)
+    safe_name = project_name.lower().replace("_", "-")
+
+    try:
+        typer.secho("Scaffolding NextJS project (this may take a minute)...", fg=typer.colors.CYAN)
+        # --ts: TypeScript
+        # --eslint: ESLint
+        # --tailwind: Tailwind CSS
+        # --src-dir: Use src/ directory
+        # --app: Use App Router
+        # --import-alias: alias for imports
+        subprocess.run(
+            [
+                "npx",
+                "create-next-app@latest",
+                safe_name,
+                "--ts",
+                "--eslint",
+                "--tailwind",
+                "--src-dir",
+                "--app",
+                "--import-alias",
+                "@/*",
+                "--use-npm",
+            ],
+            check=True,
+        )
+
+        typer.secho(
+            f"✅ NextJS project '{safe_name}' successfully generated!", fg=typer.colors.GREEN
+        )
+        return True
+
+    except subprocess.CalledProcessError as e:
+        typer.secho(f"❌ NextJS creation failed with code: {e.returncode}", fg=typer.colors.RED)
+        return False
+    except Exception as e:
+        typer.secho(f"❌ NextJS initialization failed: {e}", fg=typer.colors.RED)
+        return False

devctl/generators/nodejs.py

@@ -0,0 +1,109 @@
+"""
+Generators for NodeJS (Express) projects.
+Includes boilerplate generation with TypeScript and Express.
+"""
+
+import json
+import os
+import subprocess
+
+import typer
+
+
+def generate_nodejs_boilerplate(project_name: str) -> bool:
+    """
+    Generates a new NodeJS + Express + TypeScript project.
+    """
+    typer.secho(f"🔄 Generating NodeJS/Express project '{project_name}'...", fg=typer.colors.CYAN)
+    safe_name = project_name.lower().replace("_", "-")
+    project_path = os.path.join(os.getcwd(), safe_name)
+
+    try:
+        os.makedirs(project_path, exist_ok=True)
+
+        # 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
+        )
+
+        # 2. Install dependencies
+        typer.secho(
+            "Installing dependencies (express, typescript, ts-node, nodemon)...",
+            fg=typer.colors.CYAN,
+        )
+        subprocess.run(
+            ["npm", "install", "express", "dotenv"],
+            cwd=project_path,
+            check=True,
+            stdout=subprocess.DEVNULL,
+        )
+        subprocess.run(
+            [
+                "npm",
+                "install",
+                "-D",
+                "typescript",
+                "@types/node",
+                "@types/express",
+                "ts-node",
+                "nodemon",
+                "rimraf",
+            ],
+            cwd=project_path,
+            check=True,
+            stdout=subprocess.DEVNULL,
+        )
+
+        # 3. Initialize TypeScript
+        typer.secho("Configuring TypeScript...", fg=typer.colors.CYAN)
+        subprocess.run(
+            ["npx", "tsc", "--init"], cwd=project_path, check=True, stdout=subprocess.DEVNULL
+        )
+
+        # 4. Create folder structure
+        os.makedirs(os.path.join(project_path, "src"), exist_ok=True)
+
+        # 5. Create basic index.ts
+        index_ts = """import express, { Request, Response } from 'express';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const app = express();
+const port = process.env.PORT || 3000;
+
+app.use(express.json());
+
+app.get('/', (req: Request, res: Response) => {
+  res.send('Hello from devctl NodeJS/Express!');
+});
+
+app.listen(port, () => {
+  console.log(`[server]: Server is running at http://localhost:${port}`);
+});
+"""
+        with open(os.path.join(project_path, "src", "index.ts"), "w") as f:
+            f.write(index_ts)
+
+        # 6. Update package.json scripts
+        with open(os.path.join(project_path, "package.json"), "r") as f:
+            pkg = json.load(f)
+
+        pkg["scripts"] = {
+            "start": "node dist/index.js",
+            "build": "rimraf dist && tsc",
+            "dev": "nodemon src/index.ts",
+        }
+
+        with open(os.path.join(project_path, "package.json"), "w") as f:
+            json.dump(pkg, f, indent=2)
+
+        typer.secho(
+            f"NodeJS/Express project '{safe_name}' successfully generated!", fg=typer.colors.GREEN
+        )
+        return True
+
+    except Exception as e:
+        typer.secho(f"Error: NodeJS/Express initialization failed: {e}", fg=typer.colors.RED)
+        return False

devctl/generators/react.py

@@ -0,0 +1,43 @@
+"""
+Generators for ReactJS projects via Vite.
+Includes boilerplate generation and basic configuration.
+"""
+
+import os
+import subprocess
+
+import typer
+
+
+def generate_react_boilerplate(project_name: str) -> bool:
+    """
+    Generates a new React + TypeScript project via Vite.
+    """
+    typer.secho(f"Generating ReactJS frontend '{project_name}' via Vite...", fg=typer.colors.CYAN)
+    safe_name = project_name.lower().replace("_", "-")
+
+    try:
+        typer.secho("Scaffolding React project...", fg=typer.colors.CYAN)
+        subprocess.run(
+            ["npm", "create", "vite@latest", safe_name, "--", "--template", "react-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)
+
+        typer.secho(
+            f"ReactJS frontend '{safe_name}' successfully generated!", fg=typer.colors.GREEN
+        )
+        return True
+
+    except subprocess.CalledProcessError as e:
+        typer.secho(
+            f"Error: React/Vite process failed with code: {e.returncode}", fg=typer.colors.RED
+        )
+        return False
+    except Exception as e:
+        typer.secho(f"Error: React/Vite initialization failed: {e}", fg=typer.colors.RED)
+        return False

devctl/generators/scaffold_angular.py

@@ -0,0 +1,163 @@
+"""
+Angular resource scaffolding generator.
+Handles the creation of features including models, services, and components.
+"""
+
+import os
+
+import typer
+from jinja2 import Environment, FileSystemLoader
+
+from devctl.orchestrator.scanner import detect_environment
+
+# Dictionary mapping CLI types to TypeScript types
+TS_TYPE_MAP = {
+    "string": "string",
+    "int": "number",
+    "integer": "number",
+    "double": "number",
+    "float": "number",
+    "boolean": "boolean",
+    "date": "string",  # In JSON, dates are typically transmitted as ISO strings
+}
+
+
+def parse_ts_fields(fields_str: str):
+    """Transforms terminal fields into TypeScript types."""
+    if not fields_str:
+        return []
+    parsed = []
+    for raw in [f.strip() for f in fields_str.split(",") if f.strip()]:
+        if ":" not in raw:
+            continue
+        name, field_type = raw.split(":", 1)
+        ts_type = TS_TYPE_MAP.get(field_type.lower().strip(), "string")
+        parsed.append({"name": name.strip(), "ts_type": ts_type})
+    return parsed
+
+
+def generate_angular_resource(resource_name: str, fields_str: str, root_path: str = "."):
+    """
+    Orchestrates the creation of a complete Angular feature.
+    """
+    env_state = detect_environment(root_path)
+
+    if not env_state["has_angular"]:
+        typer.secho("Error: No Angular project detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    angular_root = env_state["angular_path"]
+    resource_lower = resource_name.lower()
+    entity_name = resource_name.capitalize()
+
+    # Feature target directory: src/app/features/resource_name
+    feature_dir = os.path.join(angular_root, "src", "app", "features", resource_lower)
+
+    # Components to generate
+    components = [
+        # Models
+        {
+            "dir": "models",
+            "suffix": "-request.model",
+            "ext": ".ts",
+            "template": "models/request.model.ts.j2",
+        },
+        {
+            "dir": "models",
+            "suffix": "-response.model",
+            "ext": ".ts",
+            "template": "models/response.model.ts.j2",
+        },
+        # Service
+        {
+            "dir": "services",
+            "suffix": ".service",
+            "ext": ".ts",
+            "template": "services/service.ts.j2",
+        },
+        # Routes (at feature root)
+        {"dir": "", "suffix": ".routes", "ext": ".ts", "template": "routes.ts.j2"},
+        # List Component
+        {
+            "dir": f"pages/{resource_lower}-list",
+            "suffix": "-list.component",
+            "ext": ".ts",
+            "template": "pages/list/list.component.ts.j2",
+        },
+        {
+            "dir": f"pages/{resource_lower}-list",
+            "suffix": "-list.component",
+            "ext": ".html",
+            "template": "pages/list/list.component.html.j2",
+        },
+        {
+            "dir": f"pages/{resource_lower}-list",
+            "suffix": "-list.component",
+            "ext": ".scss",
+            "template": "pages/list/list.component.scss.j2",
+        },
+        # Form Component
+        {
+            "dir": f"pages/{resource_lower}-form",
+            "suffix": "-form.component",
+            "ext": ".ts",
+            "template": "pages/form/form.component.ts.j2",
+        },
+        {
+            "dir": f"pages/{resource_lower}-form",
+            "suffix": "-form.component",
+            "ext": ".html",
+            "template": "pages/form/form.component.html.j2",
+        },
+        {
+            "dir": f"pages/{resource_lower}-form",
+            "suffix": "-form.component",
+            "ext": ".scss",
+            "template": "pages/form/form.component.scss.j2",
+        },
+    ]
+
+    templates_dir = os.path.join(os.path.dirname(__file__), "..", "templates", "angular", "feature")
+    env = Environment(loader=FileSystemLoader(templates_dir))
+
+    typer.secho(f"Generating Angular 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"{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:
+            # Tip: if no .scss.j2 template exists, create an empty file automatically
+            if comp["ext"] == ".scss":
+                with open(os.path.join(target_dir, target_file_name), "w") as f:
+                    f.write("")
+                typer.echo(f"  - Created (empty): {comp['dir']}/{target_file_name}")
+            else:
+                typer.secho(
+                    f"Warning: Failed to generate {comp['template']}: {e}",
+                    fg=typer.colors.YELLOW,
+                )
+
+    typer.secho(f"{entity_name} feature successfully generated!", fg=typer.colors.GREEN)

devctl/generators/scaffold_django.py

@@ -0,0 +1,79 @@
+"""
+Django resource scaffolding generator.
+Handles the creation of models, serializers, and views.
+"""
+
+import os
+
+import typer
+
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_django_resource(resource_name: str, fields_str: str, root_path: str = "."):
+    """
+    Scaffolds a Django resource.
+    """
+    env_state = detect_environment(root_path)
+
+    if not env_state["has_django"]:
+        typer.secho("❌ Error: No Django project detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    django_root = env_state["django_path"]
+    resource_name.lower()
+    entity_name = resource_name.capitalize()
+
+    # Structure: core/models.py, core/serializers.py, core/views.py
+    # For simplicity, we inject into the 'core' app created during init
+    core_dir = os.path.join(django_root, "core")
+    if not os.path.exists(core_dir):
+        os.makedirs(core_dir, exist_ok=True)
+
+    typer.secho(f"⚙️  Generating Django resource '{entity_name}'...", fg=typer.colors.CYAN)
+
+    # 1. Append Model
+    model_snippet = f"""
+class {entity_name}(models.Model):
+    # Fields: {fields_str}
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        return f"{entity_name} {{self.id}}"
+"""
+    with open(os.path.join(core_dir, "models.py"), "a") as f:
+        f.write(model_snippet)
+
+    # 2. Append Serializer
+    serializer_path = os.path.join(core_dir, "serializers.py")
+    if not os.path.exists(serializer_path):
+        with open(serializer_path, "w") as f:
+            f.write("from rest_framework import serializers\nfrom .models import *\n")
+
+    serializer_snippet = f"""
+class {entity_name}Serializer(serializers.ModelSerializer):
+    class Meta:
+        model = {entity_name}
+        fields = '__all__'
+"""
+    with open(serializer_path, "a") as f:
+        f.write(serializer_snippet)
+
+    # 3. Append View
+    view_snippet = f"""
+from rest_framework import viewsets
+from .models import {entity_name}
+from .serializers import {entity_name}Serializer
+
+class {entity_name}ViewSet(viewsets.ModelViewSet):
+    queryset = {entity_name}.objects.all()
+    serializer_class = {entity_name}Serializer
+"""
+    with open(os.path.join(core_dir, "views.py"), "a") as f:
+        f.write(view_snippet)
+
+    typer.secho(f"✅ {entity_name} Django feature successfully generated!", fg=typer.colors.GREEN)
+    typer.echo("  - Updated: core/models.py")
+    typer.echo("  - Updated: core/serializers.py")
+    typer.echo("  - Updated: core/views.py")