devctl 1.0.0__py3-none-any.whl

devctl/orchestrator/runner.py

@@ -0,0 +1,219 @@
+"""
+Local development environment runner.
+Handles parallel process management for multi-tier applications with log prefixing.
+"""
+
+import os
+import signal
+import subprocess
+import sys
+import threading
+import time
+from pathlib import Path
+from typing import List
+
+import typer
+from rich.console import Console
+from rich.markup import escape
+
+from devctl.generators.docker_scaffold import DockerProject
+from devctl.utils.env_loader import get_project_env
+
+console = Console()
+
+# Global list to track processes for cleanup
+active_processes = []
+active_threads = []
+
+
+def is_docker_running():
+    """Checks if the Docker daemon is active on the system."""
+    try:
+        subprocess.run(["docker", "info"], capture_output=True, check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+
+def stream_logs(name: str, process: subprocess.Popen, color: str):
+    """Streams logs from a process with a colored prefix."""
+    try:
+        # Use line-buffered reading
+        for line in iter(process.stdout.readline, b""):
+            if line:
+                decoded_line = line.decode("utf-8", errors="ignore").rstrip()
+                console.print(f"[{color}]{name:>15} |[/{color}] {escape(decoded_line)}")
+    except Exception as e:
+        console.print(f"[red]Error streaming logs for {name}: {escape(str(e))}[/red]")
+
+
+def _launch_process(p: DockerProject, cmd: List[str], color: str, label: str):
+    """Helper to launch a process with log streaming and .env loading."""
+    global active_processes, active_threads
+
+    typer.secho(f"Starting {label}: {p.name}...", fg=getattr(typer.colors, color.upper()))
+
+    # Load environment variables including .env if present
+    env = get_project_env(p.path)
+
+    proc = subprocess.Popen(
+        cmd,
+        cwd=str(p.path),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        bufsize=1,
+        env=env,
+    )
+    active_processes.append((p.name, proc))
+
+    t = threading.Thread(target=stream_logs, args=(p.name, proc, color), daemon=True)
+    t.start()
+    active_threads.append(t)
+
+
+def launch_dev_environment(projects: List[DockerProject], docker_composes: List[Path]):
+    """
+    Launches the necessary processes in parallel with structured startup and log streaming.
+    """
+    global active_processes
+
+    def signal_handler(_sig, _frame):
+        typer.echo("\nShutdown requested. Cleaning up...")
+        cleanup_and_exit(docker_composes)
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    try:
+        # 1. Start Databases
+        if docker_composes:
+            if not is_docker_running():
+                typer.secho("Error: Docker service is not running.", fg=typer.colors.RED)
+                sys.exit(1)
+
+            for compose_path in docker_composes:
+                typer.secho(
+                    f"Starting Docker Compose DB in {compose_path}...",
+                    fg=typer.colors.CYAN,
+                )
+                subprocess.run(
+                    ["docker", "compose", "-f", "docker-compose-db.yml", "up", "-d"],
+                    cwd=str(compose_path),
+                    check=True,
+                )
+
+            typer.echo("Waiting 5s for databases to initialize...")
+            time.sleep(5)
+
+        # 2. Start Projects
+        for p in projects:
+            if p.kind == "spring":
+                _launch_process(p, ["./mvnw", "spring-boot:run"], "green", "Spring Boot")
+
+            elif p.kind == "angular":
+                _launch_process(p, ["npx", "ng", "serve"], "cyan", "Angular")
+
+            elif p.kind == "vue":
+                _launch_process(p, ["npm", "run", "dev"], "magenta", "Vue")
+
+            elif p.kind == "react":
+                _launch_process(p, ["npm", "run", "dev"], "blue", "React")
+
+            elif p.kind == "nextjs":
+                _launch_process(p, ["npm", "run", "dev"], "yellow", "NextJS")
+
+            elif p.kind == "svelte":
+                _launch_process(p, ["npm", "run", "dev"], "red", "Svelte")
+
+            elif p.kind == "nest":
+                _launch_process(p, ["npm", "run", "start:dev"], "magenta", "NestJS")
+
+            elif p.kind == "nodejs":
+                _launch_process(p, ["npm", "run", "dev"], "green", "NodeJS")
+
+            elif p.kind == "fastapi":
+                venv_python = os.path.join(str(p.path), ".venv", "bin", "python3")
+                if not os.path.exists(venv_python):
+                    venv_python = "python3"
+                _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")
+                if not os.path.exists(venv_python):
+                    venv_python = "python3"
+                _launch_process(p, [venv_python, "manage.py", "runserver"], "green", "Django")
+
+            elif p.kind == "go":
+                _launch_process(p, ["go", "run", "."], "cyan", "Go")
+
+        if not active_processes and not docker_composes:
+            typer.secho(
+                "Warning: No projects or databases detected to run.",
+                fg=typer.colors.YELLOW,
+            )
+            return
+
+        typer.secho(
+            "\nDevelopment environment active! Press Ctrl+C to stop everything gracefully.\n",
+            fg=typer.colors.GREEN,
+            bold=True,
+        )
+        # Keep the main thread alive
+        while True:
+            # Monitor process health
+            for name, proc in active_processes:
+                exit_code = proc.poll()
+                if exit_code is not None:
+                    typer.secho(
+                        f"\nError: {name} process terminated unexpectedly "
+                        f"(Exit code: {exit_code}).",
+                        fg=typer.colors.RED,
+                        bold=True,
+                    )
+                    # Trigger shutdown logic
+                    raise KeyboardInterrupt
+
+            time.sleep(1)
+            # Check if any process has died unexpectedly
+            # This is a bit redundant with the monitor above but kept for compatibility
+            for name, proc in active_processes:
+                if proc.poll() is not None:
+                    typer.secho(
+                        f"Warning: Process {name} exited with code {proc.returncode}",
+                        fg=typer.colors.RED,
+                    )
+                    active_processes.remove((name, proc))
+
+    except Exception as e:
+        typer.secho(f"Error: A system error occurred: {e}", fg=typer.colors.RED)
+        cleanup_and_exit(docker_composes)
+
+
+def cleanup_and_exit(docker_composes: List[Path]):
+    """Stops all active processes and docker containers."""
+    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()
+
+    for compose_path in docker_composes:
+        typer.echo(f"Stopping Docker Compose DB in {compose_path}...")
+        try:
+            subprocess.run(
+                ["docker", "compose", "-f", "docker-compose-db.yml", "down", "-v"],
+                cwd=str(compose_path),
+                check=True,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+        except Exception:
+            typer.secho(f"Warning: Docker cleanup failed for {compose_path}", fg=typer.colors.RED)
+
+    typer.secho("Cleanup finished. Environment is clean.", fg=typer.colors.GREEN)
+    sys.exit(0)

devctl/orchestrator/scanner.py

@@ -0,0 +1,155 @@
+"""
+Project scanner and environment detector.
+Identifies Spring Boot, Angular, Vue.js, React, NextJS, NestJS, NodeJS, FastAPI,
+Django, Svelte, Go, and Docker components in a directory tree.
+"""
+
+import json
+import os
+from pathlib import Path
+
+# Directories to ignore during scanning
+IGNORED_DIRECTORIES = {
+    "node_modules",
+    "target",
+    ".git",
+    ".angular",
+    "dist",
+    "build",
+    "venv",
+    ".venv",
+    "__pycache__",
+    ".next",
+    ".svelte-kit",
+}
+
+
+def detect_environment(root_path: str = "."):
+    """
+    Scans the directory tree and its subfolders to identify components.
+    Returns the state and absolute paths of each component.
+    """
+    root = Path(root_path).resolve()
+    env_state = {
+        "has_docker_compose": False,
+        "docker_path": None,
+        "has_spring": False,
+        "spring_path": None,
+        "has_angular": False,
+        "angular_path": None,
+        "has_vue": False,
+        "vue_path": None,
+        "has_react": False,
+        "react_path": None,
+        "has_nextjs": False,
+        "nextjs_path": None,
+        "has_nest": False,
+        "nest_path": None,
+        "has_nodejs": False,
+        "nodejs_path": None,
+        "has_fastapi": False,
+        "fastapi_path": None,
+        "has_django": False,
+        "django_path": None,
+        "has_svelte": False,
+        "svelte_path": None,
+        "has_go": False,
+        "go_path": None,
+        "project_root": str(root),
+    }
+
+    for dirpath, dirnames, filenames in os.walk(root):
+        # In-place modification of dirnames to prune the traversal
+        dirnames[:] = [d for d in dirnames if d not in IGNORED_DIRECTORIES]
+
+        current_path = Path(dirpath)
+        filename_set = set(filenames)
+
+        # 1. Docker Compose detection
+        if "docker-compose-db.yml" in filename_set and not env_state["has_docker_compose"]:
+            env_state["has_docker_compose"] = True
+            env_state["docker_path"] = str(current_path)
+
+        # 2. Spring Boot detection
+        if ("pom.xml" in filename_set or "mvnw" in filename_set) and not env_state["has_spring"]:
+            env_state["has_spring"] = True
+            env_state["spring_path"] = str(current_path)
+
+        # 3. Angular detection
+        if "angular.json" in filename_set and not env_state["has_angular"]:
+            env_state["has_angular"] = True
+            env_state["angular_path"] = str(current_path)
+
+        # 4. Vite-based detection (Vue/React)
+        vue_markers = {"vite.config.ts", "vite.config.js"}
+        if (vue_markers & filename_set) and not any([env_state["has_vue"], env_state["has_react"]]):
+            # Distinguish by package.json
+            pkg_path = current_path / "package.json"
+            if pkg_path.exists():
+                try:
+                    pkg = json.loads(pkg_path.read_text(encoding="utf-8"))
+                    deps = pkg.get("dependencies", {})
+                    dev_deps = pkg.get("devDependencies", {})
+                    all_deps = {**deps, **dev_deps}
+                    if "react" in all_deps:
+                        env_state["has_react"] = True
+                        env_state["react_path"] = str(current_path)
+                    else:
+                        env_state["has_vue"] = True
+                        env_state["vue_path"] = str(current_path)
+                except Exception:
+                    env_state["has_vue"] = True
+                    env_state["vue_path"] = str(current_path)
+            else:
+                env_state["has_vue"] = True
+                env_state["vue_path"] = str(current_path)
+
+        # 5. NestJS detection
+        if "nest-cli.json" in filename_set and not env_state["has_nest"]:
+            env_state["has_nest"] = True
+            env_state["nest_path"] = str(current_path)
+
+        # 6. NextJS detection
+        if any(f.startswith("next.config.") for f in filename_set) and not env_state["has_nextjs"]:
+            env_state["has_nextjs"] = True
+            env_state["nextjs_path"] = str(current_path)
+
+        # 7. Generic NodeJS detection (if not already caught)
+        if "package.json" in filename_set and not any(
+            [
+                env_state["has_angular"],
+                env_state["has_vue"],
+                env_state["has_react"],
+                env_state["has_nest"],
+                env_state["has_nextjs"],
+            ]
+        ):
+            env_state["has_nodejs"] = True
+            env_state["nodejs_path"] = str(current_path)
+
+        # 8. Python detection (FastAPI/Django)
+        if "requirements.txt" in filename_set:
+            req_path = current_path / "requirements.txt"
+            try:
+                req_content = req_path.read_text(encoding="utf-8").lower()
+                if "fastapi" in req_content and not env_state["has_fastapi"]:
+                    env_state["has_fastapi"] = True
+                    env_state["fastapi_path"] = str(current_path)
+                if "django" in req_content and not env_state["has_django"]:
+                    env_state["has_django"] = True
+                    env_state["django_path"] = str(current_path)
+            except (OSError, UnicodeDecodeError):
+                # Ignore unreadable requirements files during environment scanning
+                pass
+
+        # 9. Svelte detection
+        if "svelte.config.js" in filename_set and not env_state["has_svelte"]:
+            env_state["has_svelte"] = True
+            env_state["svelte_path"] = str(current_path)
+
+        # 10. Go detection
+        if "go.mod" in filename_set and not env_state["has_go"]:
+            env_state["has_go"] = True
+            env_state["go_path"] = str(current_path)
+
+    return env_state

devctl/templates/angular/config/environment.development.ts.j2

@@ -0,0 +1,4 @@
+export const environment = {
+  production: false,
+  apiUrl: '/api'
+};

devctl/templates/angular/config/environment.ts.j2

@@ -0,0 +1,5 @@
+export const environment = {
+  production: true,
+  // TODO: Remplacer par l'URL de production de ton backend
+  apiUrl: 'https://api.ton-domaine.com/api'
+};

devctl/templates/angular/config/proxy.conf.json.j2

@@ -0,0 +1,8 @@
+{
+  "/api": {
+    "target": "http://localhost:8080",
+    "secure": false,
+    "changeOrigin": true,
+    "logLevel": "debug"
+  }
+}

devctl/templates/angular/feature/models/request.model.ts.j2

@@ -0,0 +1,5 @@
+export interface {{ entity_name }}Request {
+{% for field in fields %}
+  {{ field.name }}: {{ field.ts_type }};
+{% endfor %}
+}

devctl/templates/angular/feature/models/response.model.ts.j2

@@ -0,0 +1,6 @@
+export interface {{ entity_name }}Response {
+  id: number;
+{% for field in fields %}
+  {{ field.name }}: {{ field.ts_type }};
+{% endfor %}
+}

devctl/templates/angular/feature/pages/form/form.component.html.j2

@@ -0,0 +1,21 @@
+<div class="form-container">
+  <h2>{{ '{{' }} isEditMode ? 'Modifier' : 'Nouveau' {{ '}}' }} {{ entity_name }}</h2>
+
+  <form [formGroup]="form" (ngSubmit)="onSubmit()">
+    {% for field in fields %}
+    <div class="form-group">
+      <label for="{{ field.name }}">{{ field.name | capitalize }}</label>
+      <input
+        id="{{ field.name }}"
+        type="{% if field.ts_type == 'number' %}number{% else %}text{% endif %}"
+        formControlName="{{ field.name }}"
+      />
+    </div>
+    {% endfor %}
+
+    <div class="form-actions">
+      <button type="submit" [disabled]="form.invalid">Enregistrer</button>
+      <a routerLink="/{{ resource_name_lower }}s" class="btn-cancel">Annuler</a>
+    </div>
+  </form>
+</div>

devctl/templates/angular/feature/pages/form/form.component.ts.j2

@@ -0,0 +1,63 @@
+import { Component, inject, OnInit } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ReactiveFormsModule, FormBuilder, FormGroup, Validators } from '@angular/forms';
+import { ActivatedRoute, Router, RouterModule } from '@angular/router';
+import { {{ entity_name }}Service } from '../../services/{{ resource_name_lower }}.service';
+import { {{ entity_name }}Request } from '../../models/{{ resource_name_lower }}-request.model';
+
+@Component({
+  selector: 'app-{{ resource_name_lower }}-form',
+  standalone: true,
+  imports: [CommonModule, ReactiveFormsModule, RouterModule],
+  templateUrl: './{{ resource_name_lower }}-form.component.html',
+  styleUrls: ['./{{ resource_name_lower }}-form.component.scss']
+})
+export class {{ entity_name }}FormComponent implements OnInit {
+  private fb = inject(FormBuilder);
+  private service = inject({{ entity_name }}Service);
+  private router = inject(Router);
+  private route = inject(ActivatedRoute);
+
+  form!: FormGroup;
+  isEditMode = false;
+  currentId?: number;
+
+  ngOnInit(): void {
+    this.initForm();
+    this.checkEditMode();
+  }
+
+  private initForm(): void {
+    this.form = this.fb.group({
+      {% for field in fields %}
+      {{ field.name }}: ['', Validators.required],
+      {% endfor %}
+    });
+  }
+
+  private checkEditMode(): void {
+    const id = this.route.snapshot.paramMap.get('id');
+    if (id) {
+      this.isEditMode = true;
+      this.currentId = +id;
+      this.service.getById(this.currentId).subscribe(data => {
+        this.form.patchValue(data);
+      });
+    }
+  }
+
+  onSubmit(): void {
+    if (this.form.invalid) return;
+
+    const request: {{ entity_name }}Request = this.form.value;
+    const action$ = this.isEditMode && this.currentId
+      ? this.service.update(this.currentId, request)
+      : this.service.create(request);
+
+    action$.subscribe({
+      // Redirige vers la liste après succès
+      next: () => this.router.navigate(['/{{ resource_name_lower }}s']),
+      error: (err) => console.error('Erreur de sauvegarde', err)
+    });
+  }
+}

devctl/templates/angular/feature/pages/list/list.component.html.j2

@@ -0,0 +1,28 @@
+<div class="header-actions">
+  <h2>Liste des {{ entity_name }}s</h2>
+  <a routerLink="new" class="btn-primary">Nouveau {{ entity_name }}</a>
+</div>
+
+<table>
+  <thead>
+    <tr>
+      <th>ID</th>
+      {% for field in fields %}
+      <th>{{ field.name | capitalize }}</th>
+      {% endfor %}
+      <th>Actions</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr *ngFor="let item of items">
+      <td>{{ '{{' }} item.id {{ '}}' }}</td>
+      {% for field in fields %}
+      <td>{{ '{{' }} item.{{ field.name }} {{ '}}' }}</td>
+      {% endfor %}
+      <td>
+        <a [routerLink]="['edit', item.id]" class="btn-edit">Modifier</a>
+        <button (click)="delete(item.id)" class="btn-delete">Supprimer</button>
+      </td>
+    </tr>
+  </tbody>
+</table>

devctl/templates/angular/feature/pages/list/list.component.ts.j2

@@ -0,0 +1,34 @@
+import { Component, inject, OnInit } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { RouterModule } from '@angular/router';
+import { {{ entity_name }}Service } from '../../services/{{ resource_name_lower }}.service';
+import { {{ entity_name }}Response } from '../../models/{{ resource_name_lower }}-response.model';
+
+@Component({
+  selector: 'app-{{ resource_name_lower }}-list',
+  standalone: true,
+  imports: [CommonModule, RouterModule],
+  templateUrl: './{{ resource_name_lower }}-list.component.html',
+  styleUrls: ['./{{ resource_name_lower }}-list.component.scss']
+})
+export class {{ entity_name }}ListComponent implements OnInit {
+  private service = inject({{ entity_name }}Service);
+  items: {{ entity_name }}Response[] = [];
+
+  ngOnInit(): void {
+    this.loadItems();
+  }
+
+  loadItems(): void {
+    this.service.getAll().subscribe({
+      next: (data) => this.items = data,
+      error: (err) => console.error('Erreur lors du chargement', err)
+    });
+  }
+
+  delete(id: number): void {
+    if (confirm('Voulez-vous vraiment supprimer cet élément ?')) {
+      this.service.delete(id).subscribe(() => this.loadItems());
+    }
+  }
+}

devctl/templates/angular/feature/routes.ts.j2

@@ -0,0 +1,9 @@
+import { Routes } from '@angular/router';
+import { {{ entity_name }}ListComponent } from './pages/{{ resource_name_lower }}-list/{{ resource_name_lower }}-list.component';
+import { {{ entity_name }}FormComponent } from './pages/{{ resource_name_lower }}-form/{{ resource_name_lower }}-form.component';
+
+export const {{ uppercase_name }}_ROUTES: Routes = [
+  { path: '', component: {{ entity_name }}ListComponent },
+  { path: 'new', component: {{ entity_name }}FormComponent },
+  { path: 'edit/:id', component: {{ entity_name }}FormComponent }
+];

devctl/templates/angular/feature/services/service.ts.j2

@@ -0,0 +1,34 @@
+import { inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { environment } from '../../../../environments/environment';
+import { {{ entity_name }}Request } from '../models/{{ resource_name_lower }}-request.model';
+import { {{ entity_name }}Response } from '../models/{{ resource_name_lower }}-response.model';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class {{ entity_name }}Service {
+  private http = inject(HttpClient);
+  private apiUrl = `${environment.apiUrl}/{{ table_name }}`; // URL Spring Boot
+
+  getAll(): Observable<{{ entity_name }}Response[]> {
+    return this.http.get<{{ entity_name }}Response[]>(this.apiUrl);
+  }
+
+  getById(id: number): Observable<{{ entity_name }}Response> {
+    return this.http.get<{{ entity_name }}Response>(`${this.apiUrl}/${id}`);
+  }
+
+  create(request: {{ entity_name }}Request): Observable<{{ entity_name }}Response> {
+    return this.http.post<{{ entity_name }}Response>(this.apiUrl, request);
+  }
+
+  update(id: number, request: {{ entity_name }}Request): Observable<{{ entity_name }}Response> {
+    return this.http.put<{{ entity_name }}Response>(`${this.apiUrl}/${id}`, request);
+  }
+
+  delete(id: number): Observable<void> {
+    return this.http.delete<void>(`${this.apiUrl}/${id}`);
+  }
+}

devctl/templates/docker/deploy.yml.j2

@@ -0,0 +1,37 @@
+services:
+{% for service in services %}
+  {{ service.service_name }}:
+    build:
+      context: {{ service.relative_context }}
+      dockerfile: Dockerfile
+    {% if service.kind == 'spring' and service.db %}
+    depends_on:
+      - {{ service.db.service_name }}
+    environment:
+      - SPRING_DATASOURCE_URL=jdbc:{{ service.db.type }}://{{ service.db.service_name }}:{{ service.db.internal_port }}/{{ service.db.name }}
+      - SPRING_DATASOURCE_USERNAME={{ service.db.user }}
+      - SPRING_DATASOURCE_PASSWORD={{ service.db.password }}
+    {% endif %}
+    {% if service.kind == 'angular' or service.kind == 'vue' %}
+    ports:
+      - "80:80"
+    {% endif %}
+
+{% endfor %}
+{% for db in databases %}
+  {{ db.service_name }}:
+    image: {{ db.image }}
+    environment:
+      {% for key, value in db.env.items() %}
+      {{ key }}: {{ value }}
+      {% endfor %}
+    ports:
+      - "{{ db.port }}:{{ db.internal_port }}"
+    volumes:
+      - {{ db.volume_name }}:{{ db.volume_path }}
+
+{% endfor %}
+volumes:
+{% for db in databases %}
+  {{ db.volume_name }}:
+{% endfor %}

devctl/templates/docker/django/Dockerfile.j2

@@ -0,0 +1,21 @@
+# Production Dockerfile for Django
+# Generated by devctl
+
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apk add --no-cache libpq-dev gcc
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 8000
+
+# Using gunicorn for production
+RUN pip install gunicorn
+
+CMD ["gunicorn", "--bind", "0.0.0.0:8000", "core.wsgi:application"]