stackforge-cli 0.1.1__tar.gz → 0.1.3__tar.gz

stackforge_cli-0.1.3/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: stackforge-cli
+Version: 0.1.3
+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
+Requires-Dist: colorama>=0.4.6
+
+# StackForge
+
+A CLI scaffolder for .NET Clean Architecture (CQRS) projects.
+
+## Installation
+
+```bash
+pip install stackforge-cli
+```
+
+## Usage
+
+```bash
+stackforge
+```
+
+Then follow the prompts to scaffold a new project.
+
+## Version and updates
+
+Check the version you have installed:
+
+```bash
+stackforge --version
+```
+
+Update to the latest release:
+
+```bash
+pip install --upgrade stackforge-cli
+```
+
+When you run `stackforge`, it checks PyPI for a newer version and prints an upgrade notice if one is available (network required; fails silently if offline).
+
+## 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 on `main` with `staging` and `development` branches
+- GitHub Actions workflow to create `staging` and `development` on first push to `main`
+
+## 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`
+
+## Git workflow
+
+Each scaffolded project is initialized with three local branches:
+
+| Branch        | Purpose                          |
+|---------------|----------------------------------|
+| `main`        | Production / default branch      |
+| `staging`     | Pre-production environment       |
+| `development` | Active development environment   |
+
+A GitHub Actions workflow (`.github/workflows/sync-branches.yml`) is also included as a fallback: if you only push `main` first, it creates remote `staging` and `development` on GitHub automatically.
+
+### Example: push to GitHub
+
+From your scaffolded project directory (e.g. `~/stackforge/MyApi`):
+
+```bash
+# 1. Create a new repo on GitHub (empty, no README), then add the remote
+git remote add origin https://github.com/<your-user>/MyApi.git
+
+# 2. Push all branches in one go
+git push -u origin --all
+```
+
+That publishes `main`, `staging`, and `development` in a single command and sets upstream tracking for each.
+
+### Day-to-day branching
+
+```bash
+# Work on a feature
+git checkout development
+git checkout -b feature/my-feature
+# ... commit changes ...
+git push -u origin feature/my-feature
+
+# Merge into development when ready (via PR or locally)
+git checkout development
+git merge feature/my-feature
+git push origin development
+```
+
+Promote changes up the chain (`development` → `staging` → `main`) using pull requests or merges as your team prefers.

stackforge_cli-0.1.3/README.md

@@ -0,0 +1,93 @@
+# StackForge
+
+A CLI scaffolder for .NET Clean Architecture (CQRS) projects.
+
+## Installation
+
+```bash
+pip install stackforge-cli
+```
+
+## Usage
+
+```bash
+stackforge
+```
+
+Then follow the prompts to scaffold a new project.
+
+## Version and updates
+
+Check the version you have installed:
+
+```bash
+stackforge --version
+```
+
+Update to the latest release:
+
+```bash
+pip install --upgrade stackforge-cli
+```
+
+When you run `stackforge`, it checks PyPI for a newer version and prints an upgrade notice if one is available (network required; fails silently if offline).
+
+## 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 on `main` with `staging` and `development` branches
+- GitHub Actions workflow to create `staging` and `development` on first push to `main`
+
+## 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`
+
+## Git workflow
+
+Each scaffolded project is initialized with three local branches:
+
+| Branch        | Purpose                          |
+|---------------|----------------------------------|
+| `main`        | Production / default branch      |
+| `staging`     | Pre-production environment       |
+| `development` | Active development environment   |
+
+A GitHub Actions workflow (`.github/workflows/sync-branches.yml`) is also included as a fallback: if you only push `main` first, it creates remote `staging` and `development` on GitHub automatically.
+
+### Example: push to GitHub
+
+From your scaffolded project directory (e.g. `~/stackforge/MyApi`):
+
+```bash
+# 1. Create a new repo on GitHub (empty, no README), then add the remote
+git remote add origin https://github.com/<your-user>/MyApi.git
+
+# 2. Push all branches in one go
+git push -u origin --all
+```
+
+That publishes `main`, `staging`, and `development` in a single command and sets upstream tracking for each.
+
+### Day-to-day branching
+
+```bash
+# Work on a feature
+git checkout development
+git checkout -b feature/my-feature
+# ... commit changes ...
+git push -u origin feature/my-feature
+
+# Merge into development when ready (via PR or locally)
+git checkout development
+git merge feature/my-feature
+git push origin development
+```
+
+Promote changes up the chain (`development` → `staging` → `main`) using pull requests or merges as your team prefers.

{stackforge_cli-0.1.1 → stackforge_cli-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "stackforge-cli"
-version = "0.1.1"
+version = "0.1.3"
 description = "A CLI scaffolder for .NET Clean Architecture projects"
 readme = "README.md"
 requires-python = ">=3.10"

{stackforge_cli-0.1.1 → stackforge_cli-0.1.3}/src/stackforge/engines/dotnet/__init__.py

@@ -3,6 +3,6 @@ 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 .git_generator import generate_gitignore, generate_github_workflow, 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.1 → stackforge_cli-0.1.3}/src/stackforge/engines/dotnet/api_generator.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+from stackforge import ui
 
 
 def generate_api_structure(base: Path, project: str):
@@ -28,7 +29,7 @@ def generate_api_structure(base: Path, project: str):
     _generate_login_dto(base, project)
     _generate_account_controller(base, project)
 
-    print("  [+] API/ structure and files")
+    ui.file_created("API/ structure and files")
 
 
 def _generate_base_controller(base: Path, project: str):

{stackforge_cli-0.1.1 → stackforge_cli-0.1.3}/src/stackforge/engines/dotnet/config_generator.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+from stackforge import ui
 
 
 def generate_env(base: Path, project: str):
@@ -18,7 +19,7 @@ JWT_EXPIRY_MINUTES=60
 
     file_path = base / ".env"
     file_path.write_text(content)
-    print("  [+] .env")
+    ui.file_created(".env")
 
 
 def generate_appsettings(base: Path, project: str):
@@ -46,7 +47,7 @@ def generate_appsettings(base: Path, project: str):
 
     file_path = base / "API" / "appsettings.json"
     file_path.write_text(content)
-    print("  [+] API/appsettings.json")
+    ui.file_created("API/appsettings.json")
 
 
 def generate_appsettings_development(base: Path, project: str):
@@ -73,4 +74,4 @@ def generate_appsettings_development(base: Path, project: str):
 
     file_path = base / "API" / "appsettings.Development.json"
     file_path.write_text(content)
-    print("  [+] API/appsettings.Development.json")
+    ui.file_created("API/appsettings.Development.json")

{stackforge_cli-0.1.1 → stackforge_cli-0.1.3}/src/stackforge/engines/dotnet/csproj_generator.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+from stackforge import ui
 
 
 LAYER_CONFIGS = {
@@ -79,4 +80,4 @@ def generate_csproj(layer: str, base: Path):
 
     csproj_path = base / layer / f"{layer}.csproj"
     csproj_path.write_text(content.strip())
-    print(f"  [+] {layer}/{layer}.csproj")
+    ui.file_created(f"{layer}/{layer}.csproj")

{stackforge_cli-0.1.1 → stackforge_cli-0.1.3}/src/stackforge/engines/dotnet/docker_generator.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+from stackforge import ui
 
 
 def generate_dockerfile(base: Path):
@@ -14,7 +15,7 @@ ENTRYPOINT ["dotnet", "out/API.dll"]
 
     file_path = base / "Dockerfile"
     file_path.write_text(content)
-    print("  [+] Dockerfile")
+    ui.file_created("Dockerfile")
 
 
 def generate_docker_compose(base: Path, project: str):
@@ -60,4 +61,4 @@ volumes:
 
     file_path = base / "docker-compose.yml"
     file_path.write_text(content)
-    print("  [+] docker-compose.yml")
+    ui.file_created("docker-compose.yml")

stackforge_cli-0.1.3/src/stackforge/engines/dotnet/git_generator.py

@@ -0,0 +1,111 @@
+import subprocess
+from pathlib import Path
+from stackforge import ui
+
+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)
+    ui.file_created(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)
+    ui.file_created(".gitignore")
+
+
+def generate_github_workflow(base: Path):
+    workflow_dir = base / ".github" / "workflows"
+    workflow_dir.mkdir(parents=True, exist_ok=True)
+
+    content = """name: Sync Environment Branches
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: write
+
+jobs:
+  sync-branches:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Create staging branch if missing
+        run: |
+          if ! git ls-remote --exit-code origin refs/heads/staging; then
+            git push origin HEAD:refs/heads/staging
+          fi
+
+      - name: Create development branch if missing
+        run: |
+          if ! git ls-remote --exit-code origin refs/heads/development; then
+            git push origin HEAD:refs/heads/development
+          fi
+"""
+    file_path = workflow_dir / "sync-branches.yml"
+    file_path.write_text(content.lstrip())
+    ui.file_created(".github/workflows/sync-branches.yml")
+
+
+def git_init(base: Path, project: str):
+    try:
+        subprocess.run(["git", "init", "-b", "main"], cwd=base, check=True, capture_output=True)
+        ui.file_created("git init (main)")
+
+        subprocess.run(["git", "add", "."], cwd=base, check=True, capture_output=True)
+        ui.file_created("git add .")
+
+        subprocess.run(
+            ["git", "commit", "-m", f"initial: scaffold {project} with stackforge"],
+            cwd=base,
+            check=True,
+            capture_output=True
+        )
+        ui.file_created("initial commit")
+
+        subprocess.run(["git", "branch", "staging"], cwd=base, check=True, capture_output=True)
+        subprocess.run(["git", "branch", "development"], cwd=base, check=True, capture_output=True)
+        ui.file_created("branches: main, staging, development")
+
+    except subprocess.CalledProcessError as e:
+        ui.error(f"Git error: {e}")
+    except FileNotFoundError:
+        ui.error("Git not found. Make sure Git is installed and in your PATH.")
+

{stackforge_cli-0.1.1 → stackforge_cli-0.1.3}/src/stackforge/engines/dotnet/layers_generator.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+from stackforge import ui
 
 
 def generate_application_layer(base: Path, project: str):
@@ -27,7 +28,7 @@ def generate_application_layer(base: Path, project: str):
     _gen_paged_response(base, project)
     _gen_iso_datetime(base, project)
 
-    print("  [+] Application/ structure and files")
+    ui.file_created("Application/ structure and files")
 
 
 def generate_domain_layer(base: Path, project: str):
@@ -47,7 +48,7 @@ def generate_domain_layer(base: Path, project: str):
     _gen_user_role(base, project)
     _gen_global_usings(base, project)
 
-    print("  [+] Domain/ structure and files")
+    ui.file_created("Domain/ structure and files")
 
 
 def generate_infrastructure_layer(base: Path, project: str):
@@ -60,7 +61,7 @@ def generate_infrastructure_layer(base: Path, project: str):
     for folder in folders:
         (base / folder).mkdir(parents=True, exist_ok=True)
 
-    print("  [+] Infrastructure/ structure and files")
+    ui.file_created("Infrastructure/ structure and files")
 
 
 def generate_persistence_layer(base: Path, project: str):
@@ -78,7 +79,7 @@ def generate_persistence_layer(base: Path, project: str):
     _gen_user_seeder(base, project)
     _gen_user_role_configuration(base, project)
 
-    print("  [+] Persistence/ structure and files")
+    ui.file_created("Persistence/ structure and files")
 
 
 # ── Application files ──────────────────────────────────────────────────────────

{stackforge_cli-0.1.1 → stackforge_cli-0.1.3}/src/stackforge/engines/dotnet/program_generator.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+from stackforge import ui
 
 
 def generate_configure_services(layer: str, base: Path, project: str):
@@ -67,7 +68,7 @@ namespace {project}.Persistence
 
     file_path = base / layer / "ConfigureServices.cs"
     file_path.write_text(templates[layer])
-    print(f"  [+] {layer}/ConfigureServices.cs")
+    ui.file_created(f"{layer}/ConfigureServices.cs")
 
 
 def generate_program_cs(base: Path, project: str):
@@ -191,4 +192,4 @@ app.Run();
 
     file_path = base / "API" / "Program.cs"
     file_path.write_text(content)
-    print("  [+] API/Program.cs")
+    ui.file_created("API/Program.cs")

{stackforge_cli-0.1.1 → stackforge_cli-0.1.3}/src/stackforge/engines/dotnet/scaffolder.py

@@ -1,9 +1,10 @@
 from pathlib import Path
+from stackforge import ui
 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 .git_generator import generate_gitignore, generate_github_workflow, generate_sln, git_init
 from .api_generator import generate_api_structure
 from .layers_generator import (
     generate_application_layer,
@@ -21,51 +22,53 @@ def scaffold_folders(base: Path, project: str):
         "Persistence"
     ]
 
-    print(f"\nScaffolding folders for project '{project}'...")
+    ui.section(f"Scaffolding '{project}'")
 
+    ui.step("Creating folders")
     for layer in layers:
         folder = base / layer
         folder.mkdir(parents=True, exist_ok=True)
-        print(f"    [+] {layer}")
+        ui.file_created(layer)
 
-    print("\nFolder structure created.")
-
-    print("\nGenerating .csproj files...")
+    ui.section("Generating .csproj files")
     for layer in layers:
         generate_csproj(layer, base)
 
-    print("\nGenerating service registrations...")
+    ui.section("Generating service registrations")
     for layer in ["Application", "Infrastructure", "Persistence"]:
         generate_configure_services(layer, base, project)
 
-    print("\nGenerating Program.cs...")
+    ui.section("Generating Program.cs")
     generate_program_cs(base, project)
 
-    print("\nGenerating Docker files...")
+    ui.section("Generating Docker files")
     generate_dockerfile(base)
     generate_docker_compose(base, project)
 
-    print("\nGenerating config files...")
+    ui.section("Generating config files")
     generate_env(base, project)
     generate_appsettings(base, project)
     generate_appsettings_development(base, project)
 
-    print("\nGenerating API layer...")
+    ui.section("Generating API layer")
     generate_api_structure(base, project)
 
-    print("\nGenerating layer files...")
+    ui.section("Generating 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...")
+    ui.section("Generating solution file")
     generate_sln(base, project)
 
-    print("\nGenerating .gitignore...")
+    ui.section("Generating .gitignore")
     generate_gitignore(base)
 
-    print("\nInitializing Git repository...")
+    ui.section("Generating GitHub workflow")
+    generate_github_workflow(base)
+
+    ui.section("Initializing Git repository")
     git_init(base, project)
 
-    print("\nDone.")
+    ui.done()

stackforge_cli-0.1.3/src/stackforge/project_name.py

@@ -0,0 +1,34 @@
+import re
+
+_CAMEL_PARTS = re.compile(r"[A-Z]?[a-z]+|[A-Z]+(?=[A-Z][a-z]|\b)|\d+")
+
+
+def is_valid_project_name(name: str) -> bool:
+    if not name or not name[0].isalpha():
+        return False
+    if not re.fullmatch(r"[A-Za-z0-9_-]+", name):
+        return False
+    if name.startswith(("-", "_")) or name.endswith(("-", "_")):
+        return False
+    if "__" in name or "--" in name:
+        return False
+    return True
+
+
+def _title_part(part: str) -> str:
+    if not part:
+        return ""
+    if part.isdigit():
+        return part
+    return part[0].upper() + part[1:]
+
+
+def to_pascal_case(name: str) -> str:
+    if "_" in name:
+        parts = name.split("_")
+    elif "-" in name:
+        parts = name.split("-")
+    else:
+        parts = _CAMEL_PARTS.findall(name) or [name]
+
+    return "".join(_title_part(part) for part in parts if part)

stackforge_cli-0.1.3/src/stackforge/scaffold.py

@@ -0,0 +1,90 @@
+from pathlib import Path
+from stackforge.engines.dotnet.scaffolder import scaffold_folders
+from stackforge.version import get_installed_version, notify_if_update_available
+from stackforge.project_name import is_valid_project_name, to_pascal_case
+from stackforge import ui
+import sys
+
+
+FRAMEWORK_CHOICES = frozenset({"dotnet", "django", "fastapi", "flask", "exit"})
+
+
+def select_framework() -> str:
+    ui.info("\n  Select a framework:\n")
+    ui.menu_item("dotnet", ".NET Clean Architecture (CQRS)")
+    ui.menu_item("django", "Django                          [coming soon]", style=ui.Fore.YELLOW)
+    ui.menu_item("fastapi", "FastAPI                         [coming soon]", style=ui.Fore.YELLOW)
+    ui.menu_item("flask", "Flask                           [coming soon]", style=ui.Fore.YELLOW)
+    ui.menu_item("exit", "Exit", style=ui.Fore.RED)
+
+    choice = ui.prompt("\n  Framework [dotnet]:").lower() or "dotnet"
+    if choice not in FRAMEWORK_CHOICES:
+        ui.error(f"Unknown framework '{choice}'.")
+        ui.step("Options: dotnet, django, fastapi, flask, exit\n")
+        return ""
+    return choice
+
+
+def main():
+    if "--version" in sys.argv or "-V" in sys.argv:
+        print(get_installed_version())
+        return
+
+    notify_if_update_available()
+    ui.banner(".NET Clean Architecture Scaffolder", get_installed_version())
+    print()
+
+    while True:
+        framework = select_framework()
+
+        if not framework:
+            continue
+
+        if framework == "exit":
+            ui.warn("\n  Exiting...")
+            break
+
+        if framework != "dotnet":
+            ui.warn("\n  This framework is under development. Stay tuned!\n")
+            continue
+
+        raw_name = ui.prompt(
+            "\n  Enter project name (PascalCase, camelCase, snake_case, or kebab-case):"
+        )
+
+        if not raw_name:
+            ui.error("Project name cannot be empty.\n")
+            continue
+
+        if not is_valid_project_name(raw_name):
+            ui.error("Invalid project name. Use letters, numbers, hyphens, or underscores.")
+            ui.step("Examples: MyApi, myApi, my_api, my-api\n")
+            continue
+
+        project_name = to_pascal_case(raw_name)
+        if project_name != raw_name:
+            ui.info(f"  Normalized to: {project_name}")
+
+        base_path = Path.home() / "stackforge" / project_name
+
+        if base_path.exists():
+            ui.error(f"\n  Project '{project_name}' already exists in the stackforge workspace.")
+            ui.step(f"Path: {base_path}")
+            ui.step("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)
+
+        ui.section("Project ready")
+        ui.success(f"Created '{project_name}'")
+        ui.success(f"Location: {base_path}")
+        ui.info("\n  Next steps:")
+        ui.step("Open the project in Visual Studio or VS Code")
+        ui.step("Run: docker-compose up --build")
+        ui.step("Visit: http://localhost:5000/swagger")
+        ui.muted("\n  Press Ctrl+C to exit or continue to scaffold another project.\n")
+
+
+if __name__ == "__main__":
+    main()

stackforge_cli-0.1.3/src/stackforge/ui.py

@@ -0,0 +1,72 @@
+from colorama import Fore, Style, init
+
+init(autoreset=True)
+
+__all__ = [
+    "BANNER", "banner", "section", "step", "file_created", "success",
+    "warn", "error", "info", "prompt", "menu_item", "done", "muted",
+    "Fore", "Style",
+]
+
+BANNER = r"""
+  _____ _             _    ______
+ / ____| |           | |  |  ____|
+| (___ | |_ __ _  ___| | _| |__ ___  _ __ __ _  ___
+ \___ \| __/ _` |/ __| |/ /  __/ _ \| '__/ _` |/ _ \
+ ____) | || (_| | (__|   <| | | (_) | | | (_| |  __/
+|_____/ \__\__,_|\___|_|\_\_|  \___/|_|  \__, |\___|
+                                           __/ |
+                                          |___/"""
+
+
+def banner(subtitle: str, version: str = "") -> None:
+    print(f"{Style.BRIGHT}{Fore.CYAN}{BANNER}{Style.RESET_ALL}")
+    print(f"  {Style.BRIGHT}{Fore.WHITE}{subtitle}{Style.RESET_ALL}", end="")
+    if version:
+        print(f"  {Fore.LIGHTBLACK_EX}v{version}{Style.RESET_ALL}")
+    else:
+        print()
+
+
+def section(title: str) -> None:
+    print(f"\n  {Style.BRIGHT}{Fore.CYAN}> {title}{Style.RESET_ALL}")
+
+
+def step(label: str) -> None:
+    print(f"  {Fore.BLUE}|{Style.RESET_ALL} {label}")
+
+
+def file_created(path: str) -> None:
+    print(f"    {Fore.GREEN}+{Style.RESET_ALL} {Fore.LIGHTWHITE_EX}{path}{Style.RESET_ALL}")
+
+
+def success(message: str) -> None:
+    print(f"  {Fore.GREEN}+{Style.RESET_ALL} {message}")
+
+
+def warn(message: str) -> None:
+    print(f"  {Fore.YELLOW}!{Style.RESET_ALL}  {message}")
+
+
+def error(message: str) -> None:
+    print(f"  {Fore.RED}x{Style.RESET_ALL}  {message}")
+
+
+def info(message: str) -> None:
+    print(f"  {Fore.CYAN}{message}{Style.RESET_ALL}")
+
+
+def prompt(label: str) -> str:
+    return input(f"  {Style.BRIGHT}{Fore.CYAN}{label}{Style.RESET_ALL} ").strip()
+
+
+def menu_item(key: str, label: str, *, style: str = Fore.GREEN) -> None:
+    print(f"    {style}{key:<10}{Style.RESET_ALL} {label}")
+
+
+def done() -> None:
+    print(f"\n  {Style.BRIGHT}{Fore.GREEN}+ Scaffold complete.{Style.RESET_ALL}")
+
+
+def muted(message: str) -> None:
+    print(f"  {Fore.LIGHTBLACK_EX}{message}{Style.RESET_ALL}")

stackforge_cli-0.1.3/src/stackforge/version.py

@@ -0,0 +1,48 @@
+import json
+import urllib.error
+import urllib.request
+from importlib.metadata import PackageNotFoundError, version
+
+PACKAGE_NAME = "stackforge-cli"
+PYPI_JSON_URL = f"https://pypi.org/pypi/{PACKAGE_NAME}/json"
+
+
+def get_installed_version() -> str:
+    try:
+        return version(PACKAGE_NAME)
+    except PackageNotFoundError:
+        return "0.0.0-dev"
+
+
+def _version_tuple(value: str) -> tuple[int, ...]:
+    parts: list[int] = []
+    for segment in value.split("."):
+        digits = "".join(c for c in segment if c.isdigit())
+        if digits:
+            parts.append(int(digits))
+    return tuple(parts)
+
+
+def fetch_latest_version(timeout: float = 2.0) -> str | None:
+    request = urllib.request.Request(
+        PYPI_JSON_URL,
+        headers={"Accept": "application/json"},
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            payload = json.load(response)
+        return payload["info"]["version"]
+    except (urllib.error.URLError, TimeoutError, KeyError, json.JSONDecodeError):
+        return None
+
+
+def notify_if_update_available() -> None:
+    from stackforge import ui
+
+    installed = get_installed_version()
+    latest = fetch_latest_version()
+    if not latest or _version_tuple(latest) <= _version_tuple(installed):
+        return
+
+    ui.warn(f"StackForge {latest} is available (you have {installed}).")
+    ui.step(f"Update: pip install --upgrade {PACKAGE_NAME}\n")

stackforge_cli-0.1.3/src/stackforge_cli.egg-info/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: stackforge-cli
+Version: 0.1.3
+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
+Requires-Dist: colorama>=0.4.6
+
+# StackForge
+
+A CLI scaffolder for .NET Clean Architecture (CQRS) projects.
+
+## Installation
+
+```bash
+pip install stackforge-cli
+```
+
+## Usage
+
+```bash
+stackforge
+```
+
+Then follow the prompts to scaffold a new project.
+
+## Version and updates
+
+Check the version you have installed:
+
+```bash
+stackforge --version
+```
+
+Update to the latest release:
+
+```bash
+pip install --upgrade stackforge-cli
+```
+
+When you run `stackforge`, it checks PyPI for a newer version and prints an upgrade notice if one is available (network required; fails silently if offline).
+
+## 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 on `main` with `staging` and `development` branches
+- GitHub Actions workflow to create `staging` and `development` on first push to `main`
+
+## 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`
+
+## Git workflow
+
+Each scaffolded project is initialized with three local branches:
+
+| Branch        | Purpose                          |
+|---------------|----------------------------------|
+| `main`        | Production / default branch      |
+| `staging`     | Pre-production environment       |
+| `development` | Active development environment   |
+
+A GitHub Actions workflow (`.github/workflows/sync-branches.yml`) is also included as a fallback: if you only push `main` first, it creates remote `staging` and `development` on GitHub automatically.
+
+### Example: push to GitHub
+
+From your scaffolded project directory (e.g. `~/stackforge/MyApi`):
+
+```bash
+# 1. Create a new repo on GitHub (empty, no README), then add the remote
+git remote add origin https://github.com/<your-user>/MyApi.git
+
+# 2. Push all branches in one go
+git push -u origin --all
+```
+
+That publishes `main`, `staging`, and `development` in a single command and sets upstream tracking for each.
+
+### Day-to-day branching
+
+```bash
+# Work on a feature
+git checkout development
+git checkout -b feature/my-feature
+# ... commit changes ...
+git push -u origin feature/my-feature
+
+# Merge into development when ready (via PR or locally)
+git checkout development
+git merge feature/my-feature
+git push origin development
+```
+
+Promote changes up the chain (`development` → `staging` → `main`) using pull requests or merges as your team prefers.

{stackforge_cli-0.1.1 → stackforge_cli-0.1.3}/src/stackforge_cli.egg-info/SOURCES.txt

@@ -1,7 +1,10 @@
 README.md
 pyproject.toml
 src/stackforge/__init__.py
+src/stackforge/project_name.py
 src/stackforge/scaffold.py
+src/stackforge/ui.py
+src/stackforge/version.py
 src/stackforge/engines/dotnet/__init__.py
 src/stackforge/engines/dotnet/api_generator.py
 src/stackforge/engines/dotnet/config_generator.py

stackforge_cli-0.1.1/PKG-INFO

@@ -1,47 +0,0 @@
-Metadata-Version: 2.4
-Name: stackforge-cli
-Version: 0.1.1
-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
-Requires-Dist: colorama>=0.4.6
-
-# 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.1/README.md

@@ -1,33 +0,0 @@
-# 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.1/src/stackforge/engines/dotnet/git_generator.py

@@ -1,67 +0,0 @@
-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.")
-

stackforge_cli-0.1.1/src/stackforge/scaffold.py

@@ -1,83 +0,0 @@
-from pathlib import Path
-from stackforge.engines.dotnet.scaffolder import scaffold_folders
-from colorama import init, Fore, Style
-import re
-
-init(autoreset=True)
-
-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(f"  {Fore.CYAN}Select a framework:{Style.RESET_ALL}\n")
-    print(f"    {Fore.GREEN}1.{Style.RESET_ALL} .NET Clean Architecture (CQRS)")
-    print(f"    {Fore.YELLOW}2.{Style.RESET_ALL} Django                          [coming soon]")
-    print(f"    {Fore.YELLOW}3.{Style.RESET_ALL} FastAPI                         [coming soon]")
-    print(f"    {Fore.YELLOW}4.{Style.RESET_ALL} Flask                           [coming soon]")
-    print(f"    {Fore.RED}5.{Style.RESET_ALL} exit")
-
-    choice = input(f"\n  {Fore.CYAN}Choice [n]:{Style.RESET_ALL} ").strip() or "1"
-    return choice
-
-
-def main():
-    print(Fore.CYAN + r"""
-  _____ _             _    ______
- / ____| |           | |  |  ____|
-| (___ | |_ __ _  ___| | _| |__ ___  _ __ __ _  ___
- \___ \| __/ _` |/ __| |/ /  __/ _ \| '__/ _` |/ _ \
- ____) | || (_| | (__|   <| | | (_) | | | (_| |  __/
-|_____/ \__\__,_|\___|_|\_\_|  \___/|_|  \__, |\___|
-                                           __/ |
-                                          |___/
-""" + Style.RESET_ALL + f"  {Fore.WHITE}.NET Clean Architecture Scaffolder{Style.RESET_ALL}\n")
-
-    while True:
-        framework = select_framework()
-
-        if framework == "5":
-            print(f"\n  {Fore.YELLOW}Exiting...{Style.RESET_ALL}")
-            break
-
-        if framework != "1":
-            print(f"\n  {Fore.YELLOW}[!] This framework is under development. Stay tuned!{Style.RESET_ALL}\n")
-            continue
-
-        project_name = input(f"\n  {Fore.CYAN}Enter project name (PascalCase, no spaces):{Style.RESET_ALL} ").strip()
-
-        if not project_name:
-            print(f"  {Fore.RED}[!] Project name cannot be empty.{Style.RESET_ALL}\n")
-            continue
-
-        if not is_valid_project_name(project_name):
-            print(f"  {Fore.RED}[!] Project name must start with a letter and contain only letters and numbers.")
-            print(f"      Example: RaiderXpress, MyApi, StackForge{Style.RESET_ALL}\n")
-            continue
-
-        base_path = Path.home() / "stackforge" / project_name
-
-        if base_path.exists():
-            print(f"\n  {Fore.RED}[!] Project '{project_name}' already exists in the stackforge workspace.")
-            print(f"      Path: {base_path}{Style.RESET_ALL}")
-            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"""
-  {Fore.GREEN}✔ Project '{project_name}' created successfully!
-  ✔ Location: {base_path}{Style.RESET_ALL}
-
-  {Fore.CYAN}Next steps:{Style.RESET_ALL}
-    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.1/src/stackforge_cli.egg-info/PKG-INFO

@@ -1,47 +0,0 @@
-Metadata-Version: 2.4
-Name: stackforge-cli
-Version: 0.1.1
-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
-Requires-Dist: colorama>=0.4.6
-
-# 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`