stackforge-cli 0.1.0__py3-none-any.whl

stackforge/engines/dotnet/program_generator.py

@@ -0,0 +1,194 @@
+from pathlib import Path
+
+
+def generate_configure_services(layer: str, base: Path, project: str):
+    templates = {
+        "Application": f"""using FluentValidation;
+using MediatR;
+using Microsoft.Extensions.DependencyInjection;
+using System.Reflection;
+
+namespace {project}.Application
+{{
+    public static class ConfigureServices
+    {{
+        public static IServiceCollection AddApplicationServices(this IServiceCollection services)
+        {{
+            services.AddMediatR(cfg =>
+                cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()));
+
+            services.AddAutoMapper(cfg => cfg.AddMaps(Assembly.GetExecutingAssembly()));
+
+            services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());
+
+            return services;
+        }}
+    }}
+}}
+""",
+        "Infrastructure": f"""using Microsoft.Extensions.DependencyInjection;
+
+namespace {project}.Infrastructure
+{{
+    public static class ConfigureServices
+    {{
+        public static IServiceCollection AddInfrastructureServices(this IServiceCollection services)
+        {{
+            // Register infrastructure services here
+
+            return services;
+        }}
+    }}
+}}
+""",
+        "Persistence": f"""using {project}.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace {project}.Persistence
+{{
+    public static class ConfigureServices
+    {{
+        public static IServiceCollection AddPersistenceServices(this IServiceCollection services, IConfiguration configuration)
+        {{
+            services.AddDbContext<DataContext>(options =>
+                options.UseNpgsql(configuration.GetConnectionString("DefaultConnection")));
+
+            return services;
+        }}
+    }}
+}}
+""",
+    }
+
+    if layer not in templates:
+        return
+
+    file_path = base / layer / "ConfigureServices.cs"
+    file_path.write_text(templates[layer])
+    print(f"  [+] {layer}/ConfigureServices.cs")
+
+
+def generate_program_cs(base: Path, project: str):
+    content = f"""using {project}.Application;
+using {project}.Infrastructure;
+using {project}.Persistence;
+using {project}.API.Interface;
+using {project}.API.Options;
+using {project}.API.Services;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.IdentityModel.Tokens;
+using {project}.Domain.Entities.Identity;
+using System.Text;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Layer services
+builder.Services.AddApplicationServices();
+builder.Services.AddInfrastructureServices();
+builder.Services.AddPersistenceServices(builder.Configuration);
+
+// Identity
+builder.Services.AddIdentity<User, Role>(options =>
+{{
+    options.Password.RequireDigit = true;
+    options.Password.RequireLowercase = true;
+    options.Password.RequireUppercase = true;
+    options.Password.RequireNonAlphanumeric = true;
+    options.Password.RequiredLength = 8;
+}})
+.AddEntityFrameworkStores<DataContext>()
+.AddDefaultTokenProviders();
+
+// JWT
+builder.Services.Configure<JwtOptions>(builder.Configuration.GetSection("Jwt"));
+var jwtOptions = new {project}.API.Options.JwtOptions();
+builder.Configuration.GetSection("Jwt").Bind(jwtOptions);
+builder.Services.AddScoped<IJwtService, JwtService>();
+
+builder.Services.AddAuthentication(options =>
+{{
+    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
+    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
+}})
+.AddJwtBearer(options =>
+{{
+    options.TokenValidationParameters = new TokenValidationParameters
+    {{
+        ValidateIssuer = true,
+        ValidateAudience = true,
+        ValidateLifetime = true,
+        ValidateIssuerSigningKey = true,
+        ValidIssuer = jwtOptions.Issuer,
+        ValidAudience = jwtOptions.Audience,
+        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtOptions.SecretKey))
+    }};
+}});
+
+// Controllers
+builder.Services.AddControllers();
+
+// Swagger
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGen(c =>
+{{
+    c.AddSecurityDefinition("Bearer", new Microsoft.OpenApi.Models.OpenApiSecurityScheme
+    {{
+        Name = "Authorization",
+        Type = Microsoft.OpenApi.Models.SecuritySchemeType.Http,
+        Scheme = "bearer",
+        BearerFormat = "JWT",
+        In = Microsoft.OpenApi.Models.ParameterLocation.Header,
+        Description = "Enter your JWT token only (no 'Bearer' prefix needed)"
+    }});
+    c.AddSecurityRequirement(new Microsoft.OpenApi.Models.OpenApiSecurityRequirement
+    {{
+        {{
+            new Microsoft.OpenApi.Models.OpenApiSecurityScheme
+            {{
+                Reference = new Microsoft.OpenApi.Models.OpenApiReference
+                {{
+                    Type = Microsoft.OpenApi.Models.ReferenceType.SecurityScheme,
+                    Id = "Bearer"
+                }}
+            }},
+            Array.Empty<string>()
+        }}
+    }});
+}});
+
+var app = builder.Build();
+
+if (app.Environment.IsDevelopment())
+{{
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}}
+
+if (!app.Environment.IsDevelopment())
+{{
+    app.UseHttpsRedirection();
+}}
+app.UseAuthentication();
+app.UseAuthorization();
+app.MapControllers();
+
+using (var scope = app.Services.CreateScope())
+{{
+    var db = scope.ServiceProvider.GetRequiredService<DataContext>();
+    db.Database.EnsureCreated();
+
+    var roleManager = scope.ServiceProvider.GetRequiredService<RoleManager<Role>>();
+    var userManager = scope.ServiceProvider.GetRequiredService<UserManager<User>>();
+    await {project}.Persistence.Seeders.RoleSeeder.SeedAsync(roleManager);
+    await {project}.Persistence.Seeders.UserSeeder.SeedAsync(userManager);
+}}
+
+app.Run();
+"""
+
+    file_path = base / "API" / "Program.cs"
+    file_path.write_text(content)
+    print("  [+] API/Program.cs")

stackforge/engines/dotnet/scaffolder.py

@@ -0,0 +1,71 @@
+from pathlib import Path
+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, generate_sln, git_init
+from .api_generator import generate_api_structure
+from .layers_generator import (
+    generate_application_layer,
+    generate_domain_layer,
+    generate_infrastructure_layer,
+    generate_persistence_layer,
+)
+
+def scaffold_folders(base: Path, project: str):
+    layers = [
+        "API",
+        "Application",
+        "Domain",
+        "Infrastructure",
+        "Persistence"
+    ]
+
+    print(f"\nScaffolding folders for project '{project}'...")
+
+    for layer in layers:
+        folder = base / layer
+        folder.mkdir(parents=True, exist_ok=True)
+        print(f"    [+] {layer}")
+
+    print("\nFolder structure created.")
+
+    print("\nGenerating .csproj files...")
+    for layer in layers:
+        generate_csproj(layer, base)
+
+    print("\nGenerating service registrations...")
+    for layer in ["Application", "Infrastructure", "Persistence"]:
+        generate_configure_services(layer, base, project)
+
+    print("\nGenerating Program.cs...")
+    generate_program_cs(base, project)
+
+    print("\nGenerating Docker files...")
+    generate_dockerfile(base)
+    generate_docker_compose(base, project)
+
+    print("\nGenerating config files...")
+    generate_env(base, project)
+    generate_appsettings(base, project)
+    generate_appsettings_development(base, project)
+
+    print("\nGenerating API layer...")
+    generate_api_structure(base, project)
+
+    print("\nGenerating layer files...")
+    generate_application_layer(base, project)
+    generate_domain_layer(base, project)
+    generate_infrastructure_layer(base, project)
+    generate_persistence_layer(base, project)
+
+    print("\nGenerating solution file...")
+    generate_sln(base, project)
+
+    print("\nGenerating .gitignore...")
+    generate_gitignore(base)
+
+    print("\nInitializing Git repository...")
+    git_init(base, project)
+
+    print("\nDone.")

stackforge/scaffold.py

@@ -0,0 +1,82 @@
+from pathlib import Path
+from stackforge.engines.dotnet.scaffolder import scaffold_folders
+import re
+
+
+def is_valid_project_name(name: str) -> bool:
+    return bool(re.match(r'^[A-Za-z][A-Za-z0-9]*$', name))
+
+
+def select_framework() -> str:
+    print("  Select a framework:\n")
+    print("    1. .NET Clean Architecture (CQRS)")
+    print("    2. Django                          [coming soon]")
+    print("    3. FastAPI                         [coming soon]")
+    print("    4. Flask                           [coming soon]")
+    print("    5. exit")
+
+    choice = input("\n  Choice [n]: ").strip() or "1"
+    return choice
+
+
+def main():
+    print(r"""
+  _____ _             _    ______
+ / ____| |           | |  |  ____|
+| (___ | |_ __ _  ___| | _| |__ ___  _ __ __ _  ___
+ \___ \| __/ _` |/ __| |/ /  __/ _ \| '__/ _` |/ _ \
+ ____) | || (_| | (__|   <| | | (_) | | | (_| |  __/
+|_____/ \__\__,_|\___|_|\_\_|  \___/|_|  \__, |\___|
+                                           __/ |
+                                          |___/
+  .NET Clean Architecture Scaffolder
+    """)
+
+    while True:
+        framework = select_framework()
+
+        if framework == "5":
+            print("\n  Exiting...")
+            break
+
+        if framework != "1":
+            print("\n  [!] This framework is under development. Stay tuned!\n")
+            continue
+
+        project_name = input("\n  Enter project name (PascalCase, no spaces): ").strip()
+
+        if not project_name:
+            print("  [!] Project name cannot be empty.\n")
+            continue
+
+        if not is_valid_project_name(project_name):
+            print("  [!] Project name must start with a letter and contain only letters and numbers.")
+            print("      Example: RaiderXpress, MyApi, StackForge\n")
+            continue
+
+        base_path = Path.home() / "stackforge" / project_name
+
+        if base_path.exists():
+            print(f"\n  [!] Project '{project_name}' already exists in the stackforge workspace.")
+            print(f"      Path: {base_path}")
+            print("      Choose a different project name or delete the existing one.\n")
+            continue
+
+        base_path.mkdir(parents=True, exist_ok=True)
+        scaffold_folders(base_path, project_name)
+
+        print(f"""
+  ✔ Project '{project_name}' created successfully!
+  ✔ Location: {base_path}
+
+  Next steps:
+    1. Open the project in Visual Studio or VS Code
+    2. Run: docker-compose up --build
+    3. Visit: http://localhost:5000/swagger
+
+  Press Ctrl+C to exit or continue to scaffold another project.
+        """)
+
+
+if __name__ == "__main__":
+    main()

stackforge_cli-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,16 @@
+stackforge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stackforge/scaffold.py,sha256=0RfIzXY_b7-NzhRq6fT-5jT-wJ-IbXvDniUs8yxLLUs,2697
+stackforge/engines/dotnet/__init__.py,sha256=bxCYj7mEmcLZZ06vgUPe8l9_PAp_dTDYLbaVK7sotQM,592
+stackforge/engines/dotnet/api_generator.py,sha256=06dPkqhqadIV2xNrlrMzNNvf9n2iG2zro8lzZ6jk-uw,9783
+stackforge/engines/dotnet/config_generator.py,sha256=cEKpUJ9t6gRNk9TnWQ1LXrxUk1WYLxDw_DH8T-X7gvA,2030
+stackforge/engines/dotnet/csproj_generator.py,sha256=aGoqkJLIVggTxM_tlyMH_RESI4Qy0BY6Pdo3OJLF7ao,2483
+stackforge/engines/dotnet/docker_generator.py,sha256=V4r2UKcMAR92-3yJBXjVfo1u-_HOtw9Zf2mrAp7bjDM,1624
+stackforge/engines/dotnet/git_generator.py,sha256=_fRnGnMLitw5GPxt1yKVCwCDequpMF-XZe-qYzSn6Gs,1718
+stackforge/engines/dotnet/layers_generator.py,sha256=EM5agcRcZAL_9s980sEP1iECuE518O-L6NndFtH3U2o,18132
+stackforge/engines/dotnet/program_generator.py,sha256=bCjTI8-aY9kLOOVZASF9U8HIEkVgOhtAndkV0Sq8V10,6037
+stackforge/engines/dotnet/scaffolder.py,sha256=Tco9MnM-qEBkTps472inZ62rTAcnecwpUBvAofE56gY,2289
+stackforge_cli-0.1.0.dist-info/METADATA,sha256=qXkOAIe6WnQao8vOhYBiCUsrroKQdX_KjhJzY9DUHM8,1215
+stackforge_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+stackforge_cli-0.1.0.dist-info/entry_points.txt,sha256=r6YqYMrqMdXBiKTqSNdbEjwuzhCSksAlAmdhnqIOvJE,56
+stackforge_cli-0.1.0.dist-info/top_level.txt,sha256=rLeEUKSWLyFKeW9uVuvTDIxq05hOic0cG7Xy3XlSYI8,11
+stackforge_cli-0.1.0.dist-info/RECORD,,

stackforge_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

stackforge_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+stackforge = stackforge.scaffold:main

stackforge_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+stackforge