devctl 1.0.0__py3-none-any.whl

devctl/generators/scaffold_fastapi.py

@@ -0,0 +1,83 @@
+"""
+FastAPI resource scaffolding generator.
+Handles the creation of routers, schemas, and models.
+"""
+
+import os
+
+import typer
+
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_fastapi_resource(resource_name: str, fields_str: str, root_path: str = "."):
+    """
+    Scaffolds a FastAPI resource.
+    """
+    env_state = detect_environment(root_path)
+
+    if not env_state["has_fastapi"]:
+        typer.secho("❌ Error: No FastAPI project detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    fastapi_root = env_state["fastapi_path"]
+    resource_lower = resource_name.lower()
+    entity_name = resource_name.capitalize()
+
+    # Create directories
+    routers_dir = os.path.join(fastapi_root, "routers")
+    schemas_dir = os.path.join(fastapi_root, "schemas")
+    models_dir = os.path.join(fastapi_root, "models")
+
+    for d in [routers_dir, schemas_dir, models_dir]:
+        os.makedirs(d, exist_ok=True)
+        # Ensure __init__.py exists
+        with open(os.path.join(d, "__init__.py"), "a"):
+            pass
+
+    typer.secho(f"⚙️  Generating FastAPI resource '{entity_name}'...", fg=typer.colors.CYAN)
+
+    # 1. Generate Schema (Pydantic)
+    schema_content = f"""from pydantic import BaseModel
+from typing import Optional
+
+class {entity_name}Base(BaseModel):
+    # Fields: {fields_str}
+    pass
+
+class {entity_name}Create({entity_name}Base):
+    pass
+
+class {entity_name}({entity_name}Base):
+    id: int
+
+    class Config:
+        orm_mode = True
+"""
+    with open(os.path.join(schemas_dir, f"{resource_lower}.py"), "w") as f:
+        f.write(schema_content)
+
+    # 2. Generate Router
+    router_content = f"""from fastapi import APIRouter, HTTPException
+from typing import List
+from schemas import {resource_lower} as schemas
+
+router = APIRouter(
+    prefix="/{resource_lower}s",
+    tags=["{resource_lower}s"]
+)
+
+@router.get("/", response_model=List[schemas.{entity_name}])
+def read_{resource_lower}s():
+    return []
+
+@router.post("/", response_model=schemas.{entity_name})
+def create_{resource_lower}(item: schemas.{entity_name}Create):
+    return {{"id": 1, **item.dict()}}
+"""
+    with open(os.path.join(routers_dir, f"{resource_lower}.py"), "w") as f:
+        f.write(router_content)
+
+    typer.secho(f"{entity_name} FastAPI feature successfully generated!", fg=typer.colors.GREEN)
+    typer.echo(f"  - Created: schemas/{resource_lower}.py")
+    typer.echo(f"  - Created: routers/{resource_lower}.py")

devctl/generators/scaffold_go.py

@@ -0,0 +1,67 @@
+"""
+Go (Fiber) resource scaffolding generator.
+Handles the creation of handlers and models.
+"""
+
+import os
+
+import typer
+
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_go_resource(resource_name: str, fields_str: str, root_path: str = "."):
+    """
+    Scaffolds a Go resource.
+    """
+    env_state = detect_environment(root_path)
+
+    if not env_state["has_go"]:
+        typer.secho("❌ Error: No Go project detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    go_root = env_state["go_path"]
+    resource_lower = resource_name.lower()
+    entity_name = resource_name.capitalize()
+
+    # Structure: handlers/resource.go, models/resource.go
+    handlers_dir = os.path.join(go_root, "handlers")
+    models_dir = os.path.join(go_root, "models")
+
+    os.makedirs(handlers_dir, exist_ok=True)
+    os.makedirs(models_dir, exist_ok=True)
+
+    typer.secho(f"⚙️  Generating Go resource '{entity_name}'...", fg=typer.colors.CYAN)
+
+    # 1. Generate Model
+    model_content = f"""package models
+
+type {entity_name} struct {{
+    ID uint `json:"id"`
+    // Fields: {fields_str}
+}}
+"""
+    with open(os.path.join(models_dir, f"{resource_lower}.go"), "w") as f:
+        f.write(model_content)
+
+    # 2. Generate Handler
+    handler_content = f"""package handlers
+
+import (
+    "github.com/gofiber/fiber/v2"
+)
+
+func Get{entity_name}s(c *fiber.Ctx) error {{
+    return c.JSON(fiber.Map{{"message": "Get all {resource_lower}s"}})
+}}
+
+func Create{entity_name}(c *fiber.Ctx) error {{
+    return c.Status(201).JSON(fiber.Map{{"message": "{entity_name} created"}})
+}}
+"""
+    with open(os.path.join(handlers_dir, f"{resource_lower}.go"), "w") as f:
+        f.write(handler_content)
+
+    typer.secho(f"✅ {entity_name} Go feature successfully generated!", fg=typer.colors.GREEN)
+    typer.echo(f"  - Created: models/{resource_lower}.go")
+    typer.echo(f"  - Created: handlers/{resource_lower}.go")

devctl/generators/scaffold_nestjs.py

@@ -0,0 +1,52 @@
+"""
+NestJS resource scaffolding generator.
+Handles the creation of modules, controllers, and services using Nest CLI.
+"""
+
+import subprocess
+
+import typer
+
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_nest_resource(resource_name: str, fields_str: str, root_path: str = "."):
+    """
+    Scaffolds a NestJS resource using the Nest CLI.
+    """
+    env_state = detect_environment(root_path)
+
+    if not env_state["has_nest"]:
+        typer.secho("❌ Error: No NestJS project detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    nest_root = env_state["nest_path"]
+    resource_lower = resource_name.lower()
+
+    typer.secho(f"⚙️  Generating NestJS resource '{resource_name}'...", fg=typer.colors.CYAN)
+
+    try:
+        # Use npx to run Nest CLI
+        # 'g res' is shorthand for 'generate resource'
+        # --no-spec skips test files for a cleaner scaffold
+        subprocess.run(
+            ["npx", "@nestjs/cli", "g", "resource", resource_lower, "--no-spec"],
+            cwd=nest_root,
+            check=True,
+        )
+
+        typer.secho(
+            f"✅ {resource_name} NestJS resource successfully generated!", fg=typer.colors.GREEN
+        )
+        typer.echo(
+            f"💡 Note: Fields [{fields_str}] were provided but manual DTO update "
+            "is recommended for NestJS."
+        )
+
+    except subprocess.CalledProcessError as e:
+        typer.secho(
+            f"❌ Nest CLI resource generation failed with code: {e.returncode}",
+            fg=typer.colors.RED,
+        )
+    except Exception as e:
+        typer.secho(f"⚠️  An unexpected error occurred: {e}", fg=typer.colors.YELLOW)

devctl/generators/scaffold_nextjs.py

@@ -0,0 +1,73 @@
+"""
+NextJS resource scaffolding generator.
+Handles the creation of pages and components in the App Router.
+"""
+
+import os
+
+import typer
+
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_nextjs_resource(resource_name: str, _fields_str: str, root_path: str = "."):
+    """
+    Scaffolds a NextJS resource (Page, Component).
+    """
+    env_state = detect_environment(root_path)
+
+    if not env_state["has_nextjs"]:
+        typer.secho("❌ Error: No NextJS project detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    nextjs_root = env_state["nextjs_path"]
+    resource_lower = resource_name.lower()
+    entity_name = resource_name.capitalize()
+
+    # Structure: src/app/resource-name/page.tsx
+    app_dir = os.path.join(nextjs_root, "src", "app", resource_lower)
+    components_dir = os.path.join(nextjs_root, "src", "components")
+
+    os.makedirs(app_dir, exist_ok=True)
+    os.makedirs(components_dir, exist_ok=True)
+
+    typer.secho(f"⚙️  Generating NextJS resource '{entity_name}'...", fg=typer.colors.CYAN)
+
+    # 1. Generate Page (tsx)
+    page_content = f"""import React from 'react';
+import {{ {entity_name}List }} from '@/components/{entity_name}List';
+
+export default function {entity_name}Page() {{
+  return (
+    <main className="p-8">
+      <h1 className="text-2xl font-bold mb-4">{entity_name} Management</h1>
+      <{entity_name}List />
+    </main>
+  );
+}}
+"""
+    with open(os.path.join(app_dir, "page.tsx"), "w") as f:
+        f.write(page_content)
+
+    # 2. Generate Component
+    component_content = f"""import React from 'react';
+
+export const {entity_name}List: React.FC = () => {{
+  return (
+    <div className="border p-4 rounded shadow">
+      <h2 className="text-xl font-semibold mb-2">{entity_name} List</h2>
+      <p>This component was generated by devctl.</p>
+      <ul className="list-disc pl-5 mt-4">
+        <li>Item 1</li>
+        <li>Item 2</li>
+      </ul>
+    </div>
+  );
+}};
+"""
+    with open(os.path.join(components_dir, f"{entity_name}List.tsx"), "w") as f:
+        f.write(component_content)
+
+    typer.secho(f"✅ {entity_name} NextJS feature successfully generated!", fg=typer.colors.GREEN)
+    typer.echo(f"  - Created: src/app/{resource_lower}/page.tsx")
+    typer.echo(f"  - Created: src/components/{entity_name}List.tsx")

devctl/generators/scaffold_nodejs.py

@@ -0,0 +1,81 @@
+"""
+NodeJS/Express resource scaffolding generator.
+Handles the creation of routes and controllers.
+"""
+
+import os
+
+import typer
+
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_nodejs_resource(resource_name: str, _fields_str: str, root_path: str = "."):
+    """
+    Scaffolds a NodeJS/Express resource.
+    """
+    # Using basic manual file writing for simplicity and speed
+    # In a more advanced version, we could use Jinja2 templates
+
+    resource_lower = resource_name.lower()
+    entity_name = resource_name.capitalize()
+
+    src_dir = os.path.join(root_path, "src")
+    if not os.path.exists(src_dir):
+        # Try to find nodejs path from scanner
+        detect_environment(root_path)
+        # We need to add has_nodejs to scanner or just check if src exists in root
+        src_dir = os.path.join(root_path, "src")
+
+    routes_dir = os.path.join(src_dir, "routes")
+    controllers_dir = os.path.join(src_dir, "controllers")
+
+    os.makedirs(routes_dir, exist_ok=True)
+    os.makedirs(controllers_dir, exist_ok=True)
+
+    typer.secho(f"⚙️  Generating NodeJS/Express resource '{entity_name}'...", fg=typer.colors.CYAN)
+
+    # 1. Generate Controller
+    controller_content = f"""import {{ Request, Response }} from 'express';
+
+export const get{entity_name}s = (req: Request, res: Response) => {{
+  res.json({{ message: 'Get all {resource_lower}s' }});
+}};
+
+export const get{entity_name}ById = (req: Request, res: Response) => {{
+  const {{ id }} = req.params;
+  res.json({{ message: `Get {resource_lower} with id ${{id}}` }});
+}};
+
+export const create{entity_name} = (req: Request, res: Response) => {{
+  const data = req.body;
+  res.status(201).json({{
+    message: '{entity_name} created',
+    data
+  }});
+}};
+"""
+    controller_path = os.path.join(controllers_dir, f"{resource_lower}.controller.ts")
+    with open(controller_path, "w") as f:
+        f.write(controller_content)
+
+    # 2. Generate Route
+    route_content = f"""import {{ Router }} from 'express';
+import * as {resource_lower}Controller from '../controllers/{resource_lower}.controller';
+
+const router = Router();
+
+router.get('/', {resource_lower}Controller.get{entity_name}s);
+router.get('/:id', {resource_lower}Controller.get{entity_name}ById);
+router.post('/', {resource_lower}Controller.create{entity_name});
+
+export default router;
+"""
+    route_path = os.path.join(routes_dir, f"{resource_lower}.routes.ts")
+    with open(route_path, "w") as f:
+        f.write(route_content)
+
+    typer.secho(f"✅ {entity_name} NodeJS resource successfully generated!", fg=typer.colors.GREEN)
+    typer.echo(f"  - Created: controllers/{resource_lower}.controller.ts")
+    typer.echo(f"  - Created: routes/{resource_lower}.routes.ts")
+    typer.echo("💡 Don't forget to register the route in your main app file.")

devctl/generators/scaffold_react.py

@@ -0,0 +1,80 @@
+"""
+ReactJS resource scaffolding generator.
+Handles the creation of components, hooks, and services.
+"""
+
+import os
+
+import typer
+
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_react_resource(resource_name: str, fields_str: str, root_path: str = "."):
+    """
+    Scaffolds a React resource (Component, Service).
+    """
+    env_state = detect_environment(root_path)
+
+    if not env_state["has_react"]:
+        typer.secho("❌ Error: No ReactJS project detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    react_root = env_state["react_path"]
+    resource_lower = resource_name.lower()
+    entity_name = resource_name.capitalize()
+
+    # Structure: src/components/ResourceName/...
+    components_dir = os.path.join(react_root, "src", "components", entity_name)
+    services_dir = os.path.join(react_root, "src", "services")
+
+    os.makedirs(components_dir, exist_ok=True)
+    os.makedirs(services_dir, exist_ok=True)
+
+    typer.secho(f"⚙️  Generating ReactJS resource '{entity_name}'...", fg=typer.colors.CYAN)
+
+    # 1. Generate Component (tsx)
+    component_content = f"""import React from 'react';
+
+export const {entity_name}List: React.FC = () => {{
+  return (
+    <div>
+      <h1>{entity_name} List</h1>
+      <p>Manage your {resource_lower}s here.</p>
+    </div>
+  );
+}};
+
+export const {entity_name}Form: React.FC = () => {{
+  return (
+    <form>
+      <h1>Create {entity_name}</h1>
+      {fields_str}
+    </form>
+  );
+}};
+"""
+    with open(os.path.join(components_dir, f"{entity_name}.tsx"), "w") as f:
+        f.write(component_content)
+
+    # 2. Generate Service
+    service_content = f"""export const fetch{entity_name}s = async () => {{
+  const response = await fetch('/api/{resource_lower}s');
+  return response.json();
+}};
+
+export const create{entity_name} = async (data: any) => {{
+  const response = await fetch('/api/{resource_lower}s', {{
+    method: 'POST',
+    body: JSON.stringify(data),
+    headers: {{ 'Content-Type': 'application/json' }}
+  }});
+  return response.json();
+}};
+"""
+    with open(os.path.join(services_dir, f"{resource_lower}.service.ts"), "w") as f:
+        f.write(service_content)
+
+    typer.secho(f"✅ {entity_name} React feature successfully generated!", fg=typer.colors.GREEN)
+    typer.echo(f"  - Created: src/components/{entity_name}/{entity_name}.tsx")
+    typer.echo(f"  - Created: src/services/{resource_lower}.service.ts")

devctl/generators/scaffold_spring.py

@@ -0,0 +1,166 @@
+"""
+Spring Boot resource scaffolding generator.
+Handles the creation of MVC components, DTOs, Mappers, and Security configuration.
+"""
+
+import os
+
+import typer
+from jinja2 import Environment, FileSystemLoader
+
+# Dictionary mapping CLI types to Java types
+JAVA_TYPE_MAP = {
+    "string": "String",
+    "int": "Integer",
+    "integer": "Integer",
+    "double": "Double",
+    "float": "Float",
+    "boolean": "Boolean",
+    "date": "LocalDate",
+}
+
+
+def parse_fields(fields_str: str):
+    """
+    Transforms terminal field strings into injectable data.
+    Example: "name:string, age:int" -> [{"name": "name", "java_type": "String"}, ...]
+    """
+    if not fields_str:
+        return []
+
+    parsed_fields = []
+    raw_fields = [f.strip() for f in fields_str.split(",") if f.strip()]
+
+    for raw in raw_fields:
+        if ":" not in raw:
+            continue
+        name, field_type = raw.split(":", 1)
+        java_type = JAVA_TYPE_MAP.get(field_type.lower().strip(), "String")
+        parsed_fields.append({"name": name.strip(), "java_type": java_type})
+    return parsed_fields
+
+
+def find_spring_base_package_and_path():
+    """
+    Searches for the directory containing the @SpringBootApplication class.
+    This is the most reliable way to find the base package without parsing pom.xml.
+    """
+    java_src_dir = os.path.join(os.getcwd(), "src", "main", "java")
+
+    if not os.path.exists(java_src_dir):
+        return None, None
+
+    for root, _dirs, files in os.walk(java_src_dir):
+        for file in files:
+            if file.endswith("Application.java"):
+                rel_path = os.path.relpath(root, java_src_dir)
+                base_package = rel_path.replace(os.sep, ".")
+                return base_package, root
+
+    return None, None
+
+
+def generate_spring_resource(resource_name: str, fields_str: str):
+    """
+    Orchestrates the creation of MVC + DTOs + Mapper architecture.
+    """
+    base_package, base_path = find_spring_base_package_and_path()
+
+    if not base_package:
+        typer.secho(
+            "Error: Unable to find a valid Spring Boot project here.",
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(code=1)
+
+    entity_name = resource_name.capitalize()
+
+    # Detailed configuration for sub-folders (DTOs, Mappers)
+    components = [
+        {"dir": "entity", "suffix": "Entity", "template": "Entity.java.j2"},
+        {"dir": "repository", "suffix": "Repository", "template": "Repository.java.j2"},
+        {"dir": "service", "suffix": "Service", "template": "Service.java.j2"},
+        {"dir": "service/impl", "suffix": "ServiceImpl", "template": "ServiceImpl.java.j2"},
+        {"dir": "controller", "suffix": "Controller", "template": "Controller.java.j2"},
+        {"dir": "dto/request", "suffix": "Request", "template": "dto/Request.java.j2"},
+        {"dir": "dto/response", "suffix": "Response", "template": "dto/Response.java.j2"},
+        {"dir": "mapper", "suffix": "Mapper", "template": "mapper/Mapper.java.j2"},
+    ]
+
+    templates_dir = os.path.join(os.path.dirname(__file__), "..", "templates", "spring")
+    env = Environment(loader=FileSystemLoader(templates_dir))
+
+    typer.secho(
+        f"Generating Spring resource '{entity_name}' (with MapStruct & DTOs)...",
+        fg=typer.colors.CYAN,
+    )
+
+    for comp in components:
+        class_name = f"{entity_name}{comp['suffix']}"
+        target_file_name = f"{class_name}.java"
+
+        # Create sub-folder if it doesn't exist (e.g., src/.../dto/request)
+        # os.path.normpath handles OS-specific slashes
+        target_dir = os.path.join(base_path, os.path.normpath(comp["dir"]))
+        os.makedirs(target_dir, exist_ok=True)
+
+        # Data passed to the Jinja2 template
+        context = {
+            "base_package": base_package,
+            "class_name": class_name,
+            "entity_name": entity_name,
+            "table_name": f"{resource_name.lower()}s",
+            "fields": parse_fields(fields_str),
+        }
+
+        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)
+
+        typer.echo(f"  - Created: {comp['dir']}/{target_file_name}")
+
+    typer.secho(f"{entity_name} architecture successfully generated!", fg=typer.colors.GREEN)
+
+
+def generate_spring_security(_root_path: str = "."):
+    """
+    Dynamically generates the JWT security base.
+    """
+    # Reuse the dynamic detection function
+    base_package, base_path = find_spring_base_package_and_path()
+
+    if not base_package:
+        typer.secho(
+            "Error: Unable to locate Java package for security.",
+            fg=typer.colors.RED,
+        )
+        return
+
+    # Create config folder in the right place
+    target_dir = os.path.join(base_path, "config")
+    os.makedirs(target_dir, exist_ok=True)
+
+    # Setup Jinja2
+    templates_dir = os.path.join(os.path.dirname(__file__), "..", "templates", "spring", "config")
+    env = Environment(loader=FileSystemLoader(templates_dir))
+
+    security_files = [
+        "JwtService.java",
+        "JwtAuthenticationFilter.java",
+        "SecurityConfig.java",
+        "ApplicationConfig.java",
+    ]
+
+    typer.secho(f"Injecting JWT security into {base_package}.config...", fg=typer.colors.CYAN)
+
+    for filename in security_files:
+        template = env.get_template(f"{filename}.j2")
+        content = template.render(base_package=base_package)
+
+        with open(os.path.join(target_dir, filename), "w", encoding="utf-8") as f:
+            f.write(content)
+        typer.echo(f"  - Created: config/{filename}")
+
+    typer.secho("Security initialized successfully!", fg=typer.colors.GREEN)

devctl/generators/scaffold_svelte.py

@@ -0,0 +1,73 @@
+"""
+Svelte resource scaffolding generator.
+Handles the creation of components and routes.
+"""
+
+import os
+
+import typer
+
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_svelte_resource(resource_name: str, _fields_str: str, root_path: str = "."):
+    """
+    Scaffolds a Svelte resource (Route, Component).
+    """
+    env_state = detect_environment(root_path)
+
+    if not env_state["has_svelte"]:
+        typer.secho("❌ Error: No Svelte project detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    svelte_root = env_state["svelte_path"]
+    resource_lower = resource_name.lower()
+    entity_name = resource_name.capitalize()
+
+    # Structure: src/routes/resource-name/+page.svelte
+    routes_dir = os.path.join(svelte_root, "src", "routes", resource_lower)
+    components_dir = os.path.join(svelte_root, "src", "lib", "components")
+
+    os.makedirs(routes_dir, exist_ok=True)
+    os.makedirs(components_dir, exist_ok=True)
+
+    typer.secho(f"⚙️  Generating Svelte resource '{entity_name}'...", fg=typer.colors.CYAN)
+
+    # 1. Generate +page.svelte
+    page_content = f"""<script lang="ts">
+  import {entity_name}List from '$lib/components/{entity_name}List.svelte';
+</script>
+
+<h1>{entity_name} Management</h1>
+
+<{entity_name}List />
+"""
+    with open(os.path.join(routes_dir, "+page.svelte"), "w") as f:
+        f.write(page_content)
+
+    # 2. Generate Component
+    component_content = f"""<script lang="ts">
+  export let items = [];
+</script>
+
+<div class="list">
+  <h2>{entity_name} List</h2>
+  <p>Generated by devctl</p>
+  <ul>
+    <li>Sample Item</li>
+  </ul>
+</div>
+
+<style>
+  .list {{
+    padding: 1rem;
+    border: 1px solid #ccc;
+  }}
+</style>
+"""
+    with open(os.path.join(components_dir, f"{entity_name}List.svelte"), "w") as f:
+        f.write(component_content)
+
+    typer.secho(f"✅ {entity_name} Svelte feature successfully generated!", fg=typer.colors.GREEN)
+    typer.echo(f"  - Created: src/routes/{resource_lower}/+page.svelte")
+    typer.echo(f"  - Created: src/lib/components/{entity_name}List.svelte")