stackforge-cli 0.1.0__tar.gz

stackforge_cli-0.1.0/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: stackforge-cli
+Version: 0.1.0
+Summary: A CLI scaffolder for .NET Clean Architecture projects
+License: MIT
+Keywords: scaffolder,dotnet,clean-architecture,cli
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# StackForge
+
+A CLI scaffolder for .NET Clean Architecture (CQRS) projects.
+
+## Installation
+
+```bash
+pip install stackforge
+```
+
+## Usage
+
+```bash
+stackforge
+```
+
+Then follow the prompts to scaffold a new project.
+
+## What it generates
+
+- .NET 10 Clean Architecture structure (API, Application, Domain, Infrastructure, Persistence)
+- JWT authentication with ASP.NET Identity
+- Swagger UI with Bearer token support
+- PostgreSQL with EF Core
+- Docker + docker-compose with healthchecks
+- Role and user seeders (SuperAdmin out of the box)
+- Git initialization with initial commit
+
+## Quickstart after scaffolding
+
+1. Open the project in VS Code or Visual Studio
+2. Run: `docker-compose up --build`
+3. Visit: `http://localhost:5000/swagger`

stackforge_cli-0.1.0/README.md

@@ -0,0 +1,33 @@
+# StackForge
+
+A CLI scaffolder for .NET Clean Architecture (CQRS) projects.
+
+## Installation
+
+```bash
+pip install stackforge
+```
+
+## Usage
+
+```bash
+stackforge
+```
+
+Then follow the prompts to scaffold a new project.
+
+## What it generates
+
+- .NET 10 Clean Architecture structure (API, Application, Domain, Infrastructure, Persistence)
+- JWT authentication with ASP.NET Identity
+- Swagger UI with Bearer token support
+- PostgreSQL with EF Core
+- Docker + docker-compose with healthchecks
+- Role and user seeders (SuperAdmin out of the box)
+- Git initialization with initial commit
+
+## Quickstart after scaffolding
+
+1. Open the project in VS Code or Visual Studio
+2. Run: `docker-compose up --build`
+3. Visit: `http://localhost:5000/swagger`

stackforge_cli-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "stackforge-cli"
+version = "0.1.0"
+description = "A CLI scaffolder for .NET Clean Architecture projects"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+keywords = ["scaffolder", "dotnet", "clean-architecture", "cli"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+]
+
+[project.scripts]
+stackforge = "stackforge.scaffold:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

stackforge_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

stackforge_cli-0.1.0/src/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_cli-0.1.0/src/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_cli-0.1.0/src/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_cli-0.1.0/src/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_cli-0.1.0/src/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")