stackforge-cli 0.1.0__py3-none-any.whl

stackforge/engines/dotnet/__init__.py

@@ -0,0 +1,8 @@
+from .scaffolder import scaffold_folders
+from .csproj_generator import generate_csproj
+from .program_generator import generate_configure_services, generate_program_cs
+from .docker_generator import generate_dockerfile, generate_docker_compose
+from .config_generator import generate_env, generate_appsettings, generate_appsettings_development
+from .git_generator import generate_gitignore, git_init
+from .api_generator import generate_api_structure
+from .layers_generator import generate_domain_layer, generate_application_layer, generate_infrastructure_layer, generate_persistence_layer

stackforge/engines/dotnet/api_generator.py

@@ -0,0 +1,312 @@
+from pathlib import Path
+
+
+def generate_api_structure(base: Path, project: str):
+    # Folders
+    folders = [
+        "API/Configurations/Swagger",
+        "API/Controllers/Main",
+        "API/Helpers",
+        "API/Interface",
+        "API/Options",
+        "API/Properties",
+        "API/Services",
+        "API/Swagger",
+        "API/DTOs",
+    ]
+
+    for folder in folders:
+        (base / folder).mkdir(parents=True, exist_ok=True)
+
+    _generate_base_controller(base, project)
+    _generate_jwt_options(base, project)
+    _generate_ijwt_service(base, project)
+    _generate_jwt_service(base, project)
+    _generate_enum_schema_filter(base, project)
+    _generate_api_roles(base, project)
+    _generate_launch_settings(base)
+    _generate_login_dto(base, project)
+    _generate_account_controller(base, project)
+
+    print("  [+] API/ structure and files")
+
+
+def _generate_base_controller(base: Path, project: str):
+    content = f"""using Microsoft.AspNetCore.Mvc;
+using System.Security.Claims;
+
+namespace {project}.API.Controllers
+{{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class BaseApiController : ControllerBase
+    {{
+        protected Guid GetUserId() => Guid.Parse(User?.FindFirst(ClaimTypes.NameIdentifier)?.Value!);
+
+        protected string GetCurrentEmail() => User?.FindFirstValue(ClaimTypes.Email)!;
+
+        protected Guid? GetOrganizationId()
+        {{
+            var claim = User?.FindFirst("OrganizationId");
+
+            if (claim == null || !Guid.TryParse(claim.Value, out var orgId))
+                return null;
+
+            return orgId;
+        }}
+    }}
+}}
+"""
+    (base / "API/Controllers/BaseApiController.cs").write_text(content)
+
+
+def _generate_jwt_options(base: Path, project: str):
+    content = f"""namespace {project}.API.Options
+{{
+    public class JwtOptions
+    {{
+        public string Issuer {{ get; set; }} = string.Empty;
+        public string Audience {{ get; set; }} = string.Empty;
+        public string SecretKey {{ get; set; }} = string.Empty;
+        public int ExpiryMinutes {{ get; set; }}
+    }}
+}}
+"""
+    (base / "API/Options/JwtOptions.cs").write_text(content)
+
+
+def _generate_ijwt_service(base: Path, project: str):
+    content = f"""namespace {project}.API.Interface
+{{
+    public interface IJwtService
+    {{
+        string GenerateToken(Guid userId, string email);
+    }}
+}}
+"""
+    (base / "API/Interface/IJwtService.cs").write_text(content)
+
+
+def _generate_jwt_service(base: Path, project: str):
+    content = f"""using {project}.API.Interface;
+using {project}.API.Options;
+using Microsoft.Extensions.Options;
+using Microsoft.IdentityModel.Tokens;
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
+
+namespace {project}.API.Services
+{{
+    public class JwtService : IJwtService
+    {{
+        private readonly JwtOptions _options;
+
+        public JwtService(IOptions<JwtOptions> options)
+        {{
+            _options = options.Value;
+        }}
+
+        public string GenerateToken(Guid userId, string email)
+        {{
+            var claims = new[]
+            {{
+                new Claim(ClaimTypes.NameIdentifier, userId.ToString()),
+                new Claim(ClaimTypes.Email, email),
+            }};
+
+            var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_options.SecretKey));
+            var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
+
+            var token = new JwtSecurityToken(
+                issuer: _options.Issuer,
+                audience: _options.Audience,
+                claims: claims,
+                expires: DateTime.UtcNow.AddMinutes(_options.ExpiryMinutes),
+                signingCredentials: creds);
+
+            return new JwtSecurityTokenHandler().WriteToken(token);
+        }}
+    }}
+}}
+"""
+    (base / "API/Services/JwtService.cs").write_text(content)
+
+
+def _generate_enum_schema_filter(base: Path, project: str):
+    content = f"""using Microsoft.OpenApi.Any;
+using Microsoft.OpenApi.Models;
+using Swashbuckle.AspNetCore.SwaggerGen;
+using System.Runtime.Serialization;
+
+namespace {project}.API.Swagger
+{{
+    public class EnumMemberSchemaFilter : ISchemaFilter
+    {{
+        public void Apply(OpenApiSchema schema, SchemaFilterContext context)
+        {{
+            if (!context.Type.IsEnum) return;
+
+            schema.Enum.Clear();
+            foreach (var member in Enum.GetNames(context.Type))
+            {{
+                var field = context.Type.GetField(member);
+                var attr = field?.GetCustomAttributes(typeof(EnumMemberAttribute), false)
+                                 .OfType<EnumMemberAttribute>()
+                                 .FirstOrDefault();
+                schema.Enum.Add(new OpenApiString(attr?.Value ?? member));
+            }}
+        }}
+    }}
+}}
+"""
+    (base / "API/Swagger/EnumMemberSchemaFilter.cs").write_text(content)
+
+
+def _generate_api_roles(base: Path, project: str):
+    content = f"""namespace {project}.API.Configurations.Swagger
+{{
+    public static class ApiRoles
+    {{
+        public const string SuperAdmin = "SuperAdmin";
+        public const string Admin = "Admin";
+        public const string User = "User";
+    }}
+}}
+"""
+    (base / "API/Configurations/Swagger/ApiRoles.cs").write_text(content)
+
+
+def _generate_launch_settings(base: Path):
+    content = """{
+  "$schema": "https://json.schemastore.org/launchsettings.json",
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "dotnetRunMessages": true,
+      "applicationUrl": "http://localhost:5000"
+    },
+    "https": {
+      "commandName": "Project",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "dotnetRunMessages": true,
+      "applicationUrl": "https://localhost:7013;http://localhost:5282"
+    },
+    "Container (Dockerfile)": {
+      "commandName": "Docker",
+      "launchUrl": "{Scheme}://{ServiceHost}:{ServicePort}",
+      "environmentVariables": {
+        "ASPNETCORE_HTTPS_PORTS": "8081",
+        "ASPNETCORE_HTTP_PORTS": "8080"
+      },
+      "publishAllPorts": true,
+      "useSSL": true
+    }
+  }
+}
+"""
+    (base / "API/Properties/launchSettings.json").write_text(content)
+
+def _generate_login_dto(base: Path, project: str):
+    content = f"""namespace {project}.API.DTOs
+{{
+    public class LoginRequest
+    {{
+        public string Email {{ get; set; }} = string.Empty;
+        public string Password {{ get; set; }} = string.Empty;
+    }}
+
+    public class LoginResponse
+    {{
+        public string Token {{ get; set; }} = string.Empty;
+        public string Email {{ get; set; }} = string.Empty;
+        public string FullName {{ get; set; }} = string.Empty;
+    }}
+
+    public class CurrentUserResponse
+    {{
+        public Guid Id {{ get; set; }}
+        public string Email {{ get; set; }} = string.Empty;
+        public string FullName {{ get; set; }} = string.Empty;
+        public IList<string> Roles {{ get; set; }} = new List<string>();
+    }}
+}}
+"""
+    (base / "API/DTOs/AccountDTOs.cs").write_text(content)
+
+
+def _generate_account_controller(base: Path, project: str):
+    content = f"""using {project}.API.Controllers;
+using {project}.API.DTOs;
+using {project}.API.Interface;
+using {project}.Domain.Entities.Identity;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+
+namespace {project}.API.Controllers.Main
+{{
+    public class AccountController : BaseApiController
+    {{
+        private readonly UserManager<User> _userManager;
+        private readonly SignInManager<User> _signInManager;
+        private readonly IJwtService _jwtService;
+
+        public AccountController(
+            UserManager<User> userManager,
+            SignInManager<User> signInManager,
+            IJwtService jwtService)
+        {{
+            _userManager = userManager;
+            _signInManager = signInManager;
+            _jwtService = jwtService;
+        }}
+
+        [HttpPost("login")]
+        public async Task<IActionResult> Login([FromBody] LoginRequest request)
+        {{
+            var user = await _userManager.FindByEmailAsync(request.Email);
+            if (user == null)
+                return Unauthorized("Invalid credentials.");
+
+            var result = await _signInManager.CheckPasswordSignInAsync(user, request.Password, false);
+            if (!result.Succeeded)
+                return Unauthorized("Invalid credentials.");
+
+            var token = _jwtService.GenerateToken(user.Id, user.Email!);
+
+            return Ok(new LoginResponse
+            {{
+                Token = token,
+                Email = user.Email!,
+                FullName = $"{{user.FirstName}} {{user.LastName}}"
+            }});
+        }}
+
+        [Authorize]
+        [HttpGet("me")]
+        public async Task<IActionResult> Me()
+        {{
+            var user = await _userManager.FindByIdAsync(GetUserId().ToString());
+            if (user == null)
+                return NotFound("User not found.");
+
+            var roles = await _userManager.GetRolesAsync(user);
+
+            return Ok(new CurrentUserResponse
+            {{
+                Id = user.Id,
+                Email = user.Email!,
+                FullName = $"{{user.FirstName}} {{user.LastName}}",
+                Roles = roles
+            }});
+        }}
+    }}
+}}
+"""
+    (base / "API/Controllers/Main/AccountController.cs").write_text(content)

stackforge/engines/dotnet/config_generator.py

@@ -0,0 +1,76 @@
+from pathlib import Path
+
+
+def generate_env(base: Path, project: str):
+    project_lower = project.lower()
+
+    content = f"""ASPNETCORE_ENVIRONMENT=Development
+DB_HOST=db
+DB_PORT=5432
+DB_NAME={project_lower}_db
+DB_USER=postgres
+DB_PASSWORD=postgres
+JWT_ISSUER=https://localhost:5000
+JWT_AUDIENCE=https://localhost:5000
+JWT_SECRET_KEY=your-super-secret-key-change-this-in-production
+JWT_EXPIRY_MINUTES=60
+"""
+
+    file_path = base / ".env"
+    file_path.write_text(content)
+    print("  [+] .env")
+
+
+def generate_appsettings(base: Path, project: str):
+    project_lower = project.lower()
+
+    content = f"""{{
+  "ConnectionStrings": {{
+    "DefaultConnection": "Host=db;Port=5432;Database={project_lower}_db;Username=postgres;Password=postgres"
+  }},
+  "Jwt": {{
+    "Issuer": "https://localhost:5000",
+    "Audience": "https://localhost:5000",
+    "SecretKey": "your-super-secret-key-change-this-in-production",
+    "ExpiryMinutes": 60
+  }},
+  "Logging": {{
+    "LogLevel": {{
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }}
+  }},
+  "AllowedHosts": "*"
+}}
+"""
+
+    file_path = base / "API" / "appsettings.json"
+    file_path.write_text(content)
+    print("  [+] API/appsettings.json")
+
+
+def generate_appsettings_development(base: Path, project: str):
+    project_lower = project.lower()
+
+    content = f"""{{
+  "ConnectionStrings": {{
+    "DefaultConnection": "Host=localhost;Port=5432;Database={project_lower}_db;Username=postgres;Password=postgres"
+  }},
+  "Jwt": {{
+    "Issuer": "https://localhost:5000",
+    "Audience": "https://localhost:5000",
+    "SecretKey": "your-super-secret-key-change-this-in-production",
+    "ExpiryMinutes": 60
+  }},
+  "Logging": {{
+    "LogLevel": {{
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }}
+  }}
+}}
+"""
+
+    file_path = base / "API" / "appsettings.Development.json"
+    file_path.write_text(content)
+    print("  [+] API/appsettings.Development.json")

stackforge/engines/dotnet/csproj_generator.py

@@ -0,0 +1,82 @@
+from pathlib import Path
+
+
+LAYER_CONFIGS = {
+    "Domain": {
+        "sdk": "Microsoft.NET.Sdk",
+        "references": [],
+        "packages": [
+            ("Microsoft.AspNetCore.Identity.EntityFrameworkCore", "10.0.4"),
+        ],
+    },
+    "Application": {
+        "sdk": "Microsoft.NET.Sdk",
+        "references": ["Domain"],
+        "packages": [
+            ("MediatR", "14.1.0"),
+            ("FluentValidation", "11.9.0"),
+            ("FluentValidation.DependencyInjectionExtensions", "11.9.0"),
+            ("AutoMapper", "16.1.1"),
+            ("Microsoft.Extensions.DependencyInjection.Abstractions", "10.0.4"),
+        ]
+    },
+    "Infrastructure": {
+        "sdk": "Microsoft.NET.Sdk",
+        "references": ["Application"],
+        "packages": [],
+    },
+    "Persistence": {
+        "sdk": "Microsoft.NET.Sdk",
+        "references": ["Application"],
+        "packages": [
+            ("Microsoft.EntityFrameworkCore", "10.0.4"),
+            ("Npgsql.EntityFrameworkCore.PostgreSQL", "10.0.2"),
+            ("Microsoft.EntityFrameworkCore.Tools", "10.0.4"),
+        ],
+    },
+    "API": {
+        "sdk": "Microsoft.NET.Sdk.Web",
+        "references": ["Application", "Infrastructure", "Persistence"],
+        "packages": [
+            ("Swashbuckle.AspNetCore", "6.5.0"),
+            ("Microsoft.AspNetCore.Authentication.JwtBearer", "10.0.4"),
+        ],
+    },
+}
+
+
+def generate_csproj(layer: str, base: Path):
+    config = LAYER_CONFIGS[layer]
+    sdk = config["sdk"]
+
+    project_refs = ""
+    for ref in config["references"]:
+        project_refs += f'\n        <ProjectReference Include="..\\{ref}\\{ref}.csproj" />'
+
+    package_refs = ""
+    for name, version in config["packages"]:
+        package_refs += f'\n        <PackageReference Include="{name}" Version="{version}" />'
+
+    item_group = ""
+    if project_refs:
+        item_group += f"""
+    <ItemGroup>{project_refs}
+    </ItemGroup>"""
+    if package_refs:
+        item_group += f"""
+    <ItemGroup>{package_refs}
+    </ItemGroup>"""
+
+    content = f"""<Project Sdk="{sdk}">
+
+    <PropertyGroup>
+        <TargetFramework>net10.0</TargetFramework>
+        <Nullable>enable</Nullable>
+        <ImplicitUsings>enable</ImplicitUsings>
+    </PropertyGroup>
+{item_group}
+</Project>"""
+
+    csproj_path = base / layer / f"{layer}.csproj"
+    csproj_path.write_text(content.strip())
+    print(f"  [+] {layer}/{layer}.csproj")

stackforge/engines/dotnet/docker_generator.py

@@ -0,0 +1,63 @@
+from pathlib import Path
+
+
+def generate_dockerfile(base: Path):
+    content = """FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
+WORKDIR /app
+
+COPY . .
+
+RUN dotnet publish API/API.csproj -c Release -o out
+
+ENTRYPOINT ["dotnet", "out/API.dll"]
+"""
+
+    file_path = base / "Dockerfile"
+    file_path.write_text(content)
+    print("  [+] Dockerfile")
+
+
+def generate_docker_compose(base: Path, project: str):
+    project_lower = project.lower()
+
+    content = f"""services:
+  api:
+    build: .
+    container_name: {project_lower}_api
+    ports:
+      - "5000:8080"
+    environment:
+      - ASPNETCORE_ENVIRONMENT=Development
+      - ConnectionStrings__DefaultConnection=Host=db;Port=5432;Database={project_lower}_db;Username=postgres;Password=postgres
+      - Jwt__Issuer=http://localhost:5000
+      - Jwt__Audience=http://localhost:5000
+      - Jwt__SecretKey=your-super-secret-key-change-this-in-production
+      - Jwt__ExpiryMinutes=60
+    depends_on:
+      db:
+        condition: service_healthy
+
+  db:
+    image: postgres:latest
+    container_name: {project_lower}_db
+    environment:
+      POSTGRES_DB: {project_lower}_db
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+    ports:
+      - "5432:5432"
+    volumes:
+      - {project_lower}_pgdata:/var/lib/postgresql
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+volumes:
+  {project_lower}_pgdata:
+"""
+
+    file_path = base / "docker-compose.yml"
+    file_path.write_text(content)
+    print("  [+] docker-compose.yml")

stackforge/engines/dotnet/git_generator.py

@@ -0,0 +1,67 @@
+import subprocess
+from pathlib import Path
+
+def generate_sln(base: Path, project: str):
+    layers = ["API", "Application", "Domain", "Infrastructure", "Persistence"]
+    
+    project_entries = ""
+    for layer in layers:
+        guid = str(__import__('uuid').uuid4()).upper()
+        project_entries += f"""Project("{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}") = "{layer}", "{layer}\\{layer}.csproj", "{{{guid}}}"
+EndProject
+"""
+
+    content = f"""
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+{project_entries}"""
+
+    file_path = base / f"{project}.sln"
+    file_path.write_text(content)
+    print(f"  [+] {project}.sln")
+
+    
+def generate_gitignore(base: Path):
+    content = """# Build results
+bin/
+obj/
+out/
+
+# Environment
+.env
+
+# VS / Rider
+.vs/
+.idea/
+*.user
+
+# Logs
+*.log
+"""
+
+    file_path = base / ".gitignore"
+    file_path.write_text(content)
+    print("  [+] .gitignore")
+
+
+def git_init(base: Path, project: str):
+    try:
+        subprocess.run(["git", "init"], cwd=base, check=True, capture_output=True)
+        print("  [+] git init")
+
+        subprocess.run(["git", "add", "."], cwd=base, check=True, capture_output=True)
+        print("  [+] git add .")
+
+        subprocess.run(
+            ["git", "commit", "-m", f"initial: scaffold {project} with stackforge"],
+            cwd=base,
+            check=True,
+            capture_output=True
+        )
+        print("  [+] initial commit")
+
+    except subprocess.CalledProcessError as e:
+        print(f"  [!] Git error: {e}")
+    except FileNotFoundError:
+        print("  [!] Git not found. Make sure Git is installed and in your PATH.")
+