sscli 0.1.0__tar.gz

sscli-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: sscli
+Version: 0.1.0
+Summary: Seed & Source CLI
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer[all]
+Requires-Dist: rich
+Requires-Dist: questionary
+Requires-Dist: requests
+Requires-Dist: pathlib
+Requires-Dist: python-dotenv
+
+# Seed & Source CLI
+Unified interface for Stack Foundry templates.

sscli-0.1.0/README.md

@@ -0,0 +1,2 @@
+# Seed & Source CLI
+Unified interface for Stack Foundry templates.

sscli-0.1.0/foundry/alpha_expiration.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""
+Alpha Package Expiration Check (Refactored)
+"""
+
+import sys
+from .alpha import AlphaInfo, ExpirationStatus, AlphaExpirationManager
+
+
+def get_expiration_manager() -> AlphaExpirationManager:
+    """Factory function to get the global expiration manager."""
+    return AlphaExpirationManager()
+
+
+def main():
+    """Debug/test CLI for expiration checks."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Alpha Package Expiration Check")
+    parser.add_argument(
+        "--status", action="store_true", help="Show alpha status (if available)"
+    )
+    parser.add_argument(
+        "--check", type=str, help="Check if action is permitted (e.g., 'generate')"
+    )
+
+    args = parser.parse_args()
+    manager = AlphaExpirationManager()
+
+    if args.status:
+        manager.show_status()
+    elif args.check:
+        allowed = manager.check_before_action(args.check)
+        sys.exit(0 if allowed else 1)
+    else:
+        if manager.is_alpha():
+            manager.show_status()
+        else:
+            from rich.console import Console
+
+            Console().print("[dim]Not running in alpha mode[/dim]")
+
+
+if __name__ == "__main__":
+    main()
+

sscli-0.1.0/foundry/animated_experience.py

@@ -0,0 +1,190 @@
+from foundry.constants import console
+from foundry.actions.documentation import run_view_docs
+from foundry.actions.explore import run_explore
+from foundry.actions.generator import run_generator
+from foundry.actions.validation import run_smoke_tests
+from foundry.interactive_utils import manage_config_menu, pause
+from foundry.utils import is_internal_dev
+
+import questionary
+
+from typing import cast, List
+from foundry.animations.base import Animation
+
+# Animation Imports - moved inside function to avoid unbound variables
+# try:
+#     from foundry.animations import (AnimationSequence,
+#                                     InteractiveAnimationEngine)
+#     from foundry.animations.scenes import (LogoDisperseAnimation,
+#                                            LogoRevealAnimation,
+#                                            LogoStaticAnimation,
+#                                            TranquilityAnimation)
+
+#     HAS_ANIMATIONS = True
+# except Exception:
+#     HAS_ANIMATIONS = False
+
+
+def run_animated_experience():
+    """Plays the full robust animation sequence and handles user choice loop."""
+    # Import animations here to avoid unbound variables
+    try:
+        from foundry.animations import (AnimationSequence,
+                                        InteractiveAnimationEngine)
+        from foundry.animations.scenes import (LogoDisperseAnimation,
+                                               LogoRevealAnimation,
+                                               LogoStaticAnimation,
+                                               TranquilityAnimation,
+                                               ForgeAnimation)
+    except Exception:
+        console.print("[bold red]Animation system not fully loaded.[/]")
+        return
+
+    # Internal Mode selection for Developers
+    if is_internal_dev():
+        mode = questionary.select(
+            "Select Your Experience:",
+            choices=[
+                "Seed & Source (Client Side)",
+                "Foundry Ops (Internal Side)",
+                "Exit",
+            ],
+            style=questionary.Style([("highlighted", "fg:#00ffff bold")]),
+        ).ask()
+
+        if mode == "Exit" or mode is None:
+            console.print("[yellow]Goodbye![/yellow]")
+            return
+
+        if mode == "Foundry Ops (Internal Side)":
+            run_internal_animated_experience()
+            return
+
+    engine = InteractiveAnimationEngine(fps=60, console=console)
+
+    # 1. Play Intro Sequence once
+    try:
+        intro = AnimationSequence(
+            cast(List[Animation], [
+                LogoRevealAnimation(duration=1.2),
+                LogoStaticAnimation(duration=1.0),
+                LogoDisperseAnimation(duration=2.0),
+            ])
+        )
+        engine.play(intro)
+    except KeyboardInterrupt:
+        console.print("[yellow]Goodbye![/yellow]")
+        return
+    except Exception as e:
+        console.print(f"[red]Error during intro: {e}[/]")
+
+    # 2. Main Menu Loop
+    while True:
+        try:
+            # Play Tranquility with menu until a choice is made
+            choice = engine.play(TranquilityAnimation())
+
+            if not choice or choice == "Exit":
+                console.print("[yellow]Goodbye![/yellow]")
+                break
+
+            # Dispatch the choice
+            if choice == "Explore Templates":
+                run_explore()
+                pause()
+            elif choice == "Generate Project":
+                run_generator(interactive=True)
+                pause()
+            elif choice == "Manage Config":
+                manage_config_menu()
+            elif choice == "System Validation":
+                run_smoke_tests()
+                pause()
+            elif choice == "View Docs":
+                run_view_docs(interactive=True)
+                pause()
+
+        except KeyboardInterrupt:
+            console.print("[yellow]Goodbye![/yellow]")
+            break
+        except Exception as e:
+            console.print(f"[red]Error during menu: {e}[/]")
+            break
+
+
+def run_internal_animated_experience():
+    """Plays the internal development animation sequence with industrial theme."""
+    # Import animations here to avoid unbound variables
+    try:
+        from foundry.animations import (AnimationSequence,
+                                        InteractiveAnimationEngine)
+        from foundry.animations.scenes import (LogoDisperseAnimation,
+                                               LogoRevealAnimation,
+                                               LogoStaticAnimation,
+                                               ForgeAnimation)
+    except Exception:
+        console.print("[bold red]Animation system not fully loaded.[/]")
+        return
+
+    engine = InteractiveAnimationEngine(fps=60, console=console)
+
+    # 1. Play Intro Sequence once (industrial theme)
+    try:
+        intro = AnimationSequence(
+            [
+                LogoRevealAnimation(duration=1.2),
+                LogoStaticAnimation(duration=1.0),
+                LogoDisperseAnimation(duration=2.0),
+            ]
+        )
+        engine.play(intro)
+    except KeyboardInterrupt:
+        console.print("[yellow]Goodbye![/yellow]")
+        return
+    except Exception as e:
+        console.print(f"[red]Error during intro: {e}[/]")
+
+    # 2. Main Menu Loop with Forge theme
+    while True:
+        try:
+            # Play Forge animation with industrial menu
+            choice = engine.play(ForgeAnimation())
+
+            if not choice or choice == "Back to Main":
+                console.print("[yellow]Goodbye![/yellow]")
+                break
+
+            # Dispatch the choice for internal ops
+            try:
+                from foundry.ops.manager import InternalManager
+                from foundry.ops.runner import run_verification_script
+                manager = InternalManager()
+
+                if choice == "Verify Builds":
+                    manager.verify_builds()
+                    pause()
+                elif choice == "Hygiene Check":
+                    run_verification_script(manager.root_dir, "verify_hygiene", "Code Hygiene (File Lengths)")
+                    pause()
+                elif choice == "Full Suite":
+                    manager.verify_full_suite()
+                    pause()
+                elif choice == "Clean Reports":
+                    manager.clean_reports()
+                    pause()
+                elif choice == "View Docs":
+                    run_view_docs(interactive=True)
+                    pause()
+                elif choice == "Back to Main":
+                    break
+
+            except ImportError:
+                console.print("[red]Ops manager not available in this build.[/]")
+                break
+
+        except KeyboardInterrupt:
+            console.print("[yellow]Goodbye![/yellow]")
+            break
+        except Exception as e:
+            console.print(f"[red]Error during menu: {e}[/]")
+            break

sscli-0.1.0/foundry/auth.py

@@ -0,0 +1,120 @@
+import os
+import json
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import requests
+from foundry.constants import console, API_BASE_URL
+
+# Configuration
+# The base URL is managed in foundry/constants.py (configurable via environment variables)
+LICENSE_SERVER = API_BASE_URL
+CREDENTIALS_FILE = Path.home() / ".config" / "sscli" / "credentials.json"
+
+
+def get_access_token() -> Optional[str]:
+    """Retrieve the stored access token if it exists."""
+    if not CREDENTIALS_FILE.exists():
+        return None
+    try:
+        with open(CREDENTIALS_FILE, "r") as f:
+            data = json.load(f)
+            return data.get("access_token")
+    except Exception:
+        return None
+
+
+def save_credentials(data: Dict[str, Any]) -> None:
+    """Save user credentials to the home directory."""
+    CREDENTIALS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    with open(CREDENTIALS_FILE, "w") as f:
+        json.dump(data, f, indent=2)
+
+
+def login_flow() -> None:
+    """Execute the GitHub Device Flow via the License Server."""
+    console.print("Initiating login with GitHub...")
+
+    try:
+        response = requests.post(f"{LICENSE_SERVER}/auth/device/code")
+        response.raise_for_status()
+    except Exception as e:
+        console.print(f"Error connecting to License Server at {LICENSE_SERVER}: {e}")
+        return
+
+    data = response.json()
+    device_code = data["device_code"]
+    user_code = data["user_code"]
+    verification_uri = data["verification_uri"]
+    interval = data.get("interval", 5)
+
+    console.print(f"\n1. Go to: {verification_uri}")
+    console.print(f"2. Enter code: {user_code}\n")
+    console.print("Waiting for authorization...")
+
+    while True:
+        try:
+            token_resp = requests.get(
+                f"{LICENSE_SERVER}/auth/device/token",
+                params={"device_code": device_code},
+            )
+
+            if token_resp.status_code == 200:
+                credentials = token_resp.json()
+                save_credentials(credentials)
+                console.print(
+                    f"\nSuccessfully logged in as {credentials.get('email', 'User')}!"
+                )
+                console.print(
+                    f"License Tier: {credentials.get('tier', 'free').upper()}"
+                )
+                break
+
+            if token_resp.status_code == 428:  # Pending
+                time.sleep(interval)
+                continue
+
+            # If we get here, something went wrong
+            console.print(
+                f"Login failed: {token_resp.json().get('detail', 'Unknown error')}"
+            )
+            break
+
+        except Exception as e:
+            console.print(f"Polling error: {e}")
+            break
+
+
+def get_current_license_info() -> Dict[str, Any]:
+    """Read the current license/tier info from local storage.
+
+    Returns a dict with at least `tier` and `authorized` keys when no
+    credentials are present or when reading fails.
+    """
+    if not CREDENTIALS_FILE.exists():
+        return {"tier": "free", "authorized": False}
+    try:
+        with open(CREDENTIALS_FILE, "r") as f:
+            data = json.load(f)
+            if isinstance(data, dict):
+                return data
+            # If stored data is malformed, return a sensible default
+            return {"tier": "free", "authorized": False}
+    except Exception:
+        return {"tier": "free", "authorized": False}
+
+
+def logout() -> None:
+    """Clear local stored credentials (logout).
+
+    Removes the `credentials.json` file if present and reports status to the console.
+    """
+    try:
+        if CREDENTIALS_FILE.exists():
+            CREDENTIALS_FILE.unlink()
+            console.print("[green]Logged out:[/] removed local credentials.")
+        else:
+            console.print("[yellow]No credentials found to remove.[/yellow]")
+    except Exception as e:
+        console.print(f"[red]Error clearing credentials:[/] {e}")

sscli-0.1.0/foundry/cli.py

@@ -0,0 +1,117 @@
+from typing import Optional
+from foundry.constants import console
+import typer
+from foundry.actions.documentation import run_view_docs
+from foundry.actions.explore import run_explore
+from foundry.actions.generator import run_generator
+from foundry.actions.health import run_health_check
+from foundry.actions.setup import run_setup
+from foundry.actions.validation import run_smoke_tests
+from foundry.actions.verify import run_verification
+from foundry.auth import get_current_license_info
+from foundry.ops.cli import ops_app
+from foundry.telemetry import log_event
+from foundry.commands.auth import auth_app, run_whoami
+from foundry.commands.interactive import interactive_app
+
+app = typer.Typer(help="Stack Foundry CLI Tool")
+
+# Add sub-apps from separate modules
+app.add_typer(auth_app, name="auth")
+app.add_typer(interactive_app, name="interactive")
+app.add_typer(ops_app, name="ops", help="Internal operations and maintenance.")
+
+
+@app.command("whoami")
+def whoami():
+    run_whoami()
+
+
+
+@app.command("explore")
+def explore():
+    """List available templates."""
+    log_event("COMMAND", "explore")
+    run_explore()
+
+
+@app.command("new")
+def new(
+    template: str = typer.Option(..., help="Name of the template to use"),
+    name: str = typer.Option(..., help="Name of the application"),
+    target: Optional[str] = typer.Option(
+        None, help="Target directory (defaults to name)"
+    ),
+    no_lint: bool = typer.Option(False, "--no-lint", help="Disable default linters"),
+    secrets: str = typer.Option(
+        "Dotenv (Standard .env files)", help="Secrets management strategy"
+    ),
+):
+    """Generate a new project from a template."""
+    log_event("COMMAND", f"new --template {template} --name {name}")
+    run_generator(
+        template_name=template,
+        app_name=name,
+        target_dir_name=target,
+        use_linters=not no_lint,
+        interactive=False,
+        secrets_strategy=secrets,
+    )
+
+
+@app.command("setup")
+def setup(
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable detailed logging"
+    ),
+    force: bool = typer.Option(
+        False, "--force", help="Force setup even if already configured"
+    ),
+    skip_deps: bool = typer.Option(
+        False, "--skip-deps", help="Skip dependency installation"
+    ),
+    env: str = typer.Option("dev", "--env", help="Environment to setup (default: dev)"),
+    strategy: Optional[str] = typer.Option(
+        None, "--strategy", help="Setup strategy (docker, etc)"
+    ),
+):
+    """Run setup for templates."""
+    log_event("COMMAND", f"setup --env {env}")
+    run_setup(
+        verbose=verbose, force=force, skip_deps=skip_deps, env=env, strategy=strategy
+    )
+
+
+@app.command("validate")
+def validate():
+    """Run smoke tests."""
+    log_event("COMMAND", "validate")
+    run_smoke_tests()
+
+
+@app.command("health")
+def health():
+    """Check configuration and health of templates."""
+    log_event("COMMAND", "health")
+    run_health_check()
+
+
+@app.command("verify")
+def verify(
+    skip_docker: bool = typer.Option(
+        False, "--skip-docker", help="Skip Docker builds (faster, less thorough)"
+    ),
+    no_reports: bool = typer.Option(
+        False, "--no-reports", help="Skip generating CSV/MD reports"
+    ),
+):
+    """Verify template integrity and buildability."""
+    log_event("COMMAND", "verify")
+    run_verification(include_docker=not skip_docker, output_reports=not no_reports)
+
+
+@app.command("docs")
+def docs():
+    """List available documentation."""
+    log_event("COMMAND", "docs")
+    run_view_docs(interactive=False)

sscli-0.1.0/foundry/constants.py

@@ -0,0 +1,128 @@
+from pathlib import Path
+import os
+
+from rich.console import Console
+
+TEMPLATES_DIR = Path(__file__).resolve().parent.parent.parent
+
+# Configurable base URLs - can be overridden via environment variables
+# For Render Free Tier, you can set LICENSE_SERVER_URL directly
+SEED_SOURCE_DOMAIN = os.getenv("SEED_SOURCE_DOMAIN", "seedandsource.dev")
+# DEFAULT_API_URL updated for current Alpha deployment on Render
+DEFAULT_API_URL = "https://license-server-53oj.onrender.com/api/v1"
+API_BASE_URL = os.getenv("LICENSE_SERVER_URL", DEFAULT_API_URL)
+FORMS_BASE_URL = os.getenv("FORMS_BASE_URL", f"https://forms.{SEED_SOURCE_DOMAIN}")
+PRICING_URL = os.getenv("PRICING_URL", f"https://{SEED_SOURCE_DOMAIN}/pricing")
+SALES_EMAIL = f"sales@{SEED_SOURCE_DOMAIN}"
+ALPHA_SUPPORT_EMAIL = f"alpha-support@{SEED_SOURCE_DOMAIN}"
+ALPHA_FEEDBACK_FORM = f"{FORMS_BASE_URL}/alpha"
+
+# Metadata-based template registry for PyPI distribution
+# This allows the CLI to know about templates without them being on disk
+TEMPLATE_REGISTRY = {
+    "python-saas": {
+        "name": "Python SaaS Boilerplate",
+        "description": "Hexagonal Architecture (FastAPI + SQLAlchemy)",
+        "tier": "free",
+        "repo": "https://github.com/seed-source/python-saas.git",
+    },
+    "rails-api": {
+        "name": "Rails API Suite",
+        "description": "JSON API with Devise, RSpec, and Docker",
+        "tier": "free",
+        "repo": "https://github.com/seed-source/rails-api.git",
+    },
+    "react-client": {
+        "name": "React Vite Client",
+        "description": "Modern frontend with Tailwind and React Query",
+        "tier": "free",
+        "repo": "https://github.com/seed-source/react-client.git",
+    },
+    "rails-ui-kit": {
+        "name": "Rails UI Kit",
+        "description": "Full-stack Rails with ViewComponent and Tailwind",
+        "tier": "alpha",
+        "repo": "https://github.com/seed-source/rails-ui-kit-private.git",
+    },
+    "data-pipeline": {
+        "name": "Data Pipeline (dbt)",
+        "description": "Modern data stack with dbt and Python",
+        "tier": "alpha",
+        "repo": "https://github.com/seed-source/data-pipeline-private.git",
+    },
+    "mobile-android": {
+        "name": "Mobile Android",
+        "description": "Kotlin-based Android application",
+        "tier": "alpha",
+        "repo": "https://github.com/seed-source/mobile-android-private.git",
+    },
+    "mobile-ios": {
+        "name": "Mobile iOS",
+        "description": "SwiftUI-based iOS application",
+        "tier": "alpha",
+        "repo": "https://github.com/seed-source/mobile-ios-private.git",
+    },
+    "terraform-infra": {
+        "name": "Terraform Infrastructure",
+        "description": "Multi-cloud IaC modules",
+        "tier": "alpha",
+        "repo": "https://github.com/seed-source/terraform-infra-private.git",
+    },
+    "wiring": {
+        "name": "Docker Wiring",
+        "description": "Orchestration for multi-service stacks",
+        "tier": "free",
+        "repo": "https://github.com/seed-source/wiring.git",
+    },
+}
+
+TIER_HIERARCHY = {"free": 0, "alpha": 1, "pro": 2, "enterprise": 3}
+
+console = Console()
+
+FOUNDRY_BANNER = """
+[bold cyan]
+╔════════════════════════════════════════════════════════════════════════╗
+║                                                                        ║
+║         ███████╗████████╗ █████╗  ██████╗██╗  ██╗                    ║
+║         ██╔════╝╚══██╔══╝██╔══██╗██╔════╝██║ ██╔╝                    ║
+║         ███████╗   ██║   ███████║██║     █████╔╝                     ║
+║         ╚════██║   ██║   ██╔══██║██║     ██╔═██╗                     ║
+║         ███████║   ██║   ██║  ██║╚██████╗██║  ██╗                    ║
+║         ╚══════╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝                    ║
+║                                                                        ║
+║    ███████╗ ██████╗ ██╗   ██╗███╗   ██╗██████╗ ██████╗ ██╗   ██╗    ║
+║    ██╔════╝██╔═══██╗██║   ██║████╗  ██║██╔══██╗██╔══██╗╚██╗ ██╔╝    ║
+║    █████╗  ██║   ██║██║   ██║██╔██╗ ██║██║  ██║██████╔╝ ╚████╔╝     ║
+║    ██╔══╝  ██║   ██║██║   ██║██║╚██╗██║██║  ██║██╔══██╗  ╚██╔╝      ║
+║    ██║     ╚██████╔╝╚██████╔╝██║ ╚████║██████╔╝██║  ██║   ██║       ║
+║    ╚═╝      ╚═════╝  ╚═════╝ ╚═╝  ╚═══╝╚═════╝ ╚═╝  ╚═╝   ╚═╝       ║
+║                                                                        ║
+╟────────────────────────────────────────────────────────────────────────╢
+║                                                                        ║
+║    ⬢  Template Management & Deployment System                         ║
+║                                                                        ║
+║    ├─ 📦  9 Production-Ready Templates                                ║
+║    ├─ 🏗️   Hexagonal Architecture Patterns                            ║
+║    ├─ 🐳  Docker-First Deployment                                     ║
+║    ├─ 🔧  Automated Configuration & Setup                             ║
+║    └─ ✅  Built-in Validation & Smoke Tests                           ║
+║                                                                        ║
+╟────────────────────────────────────────────────────────────────────────╢
+║                                                                        ║
+║  STATUS: [green]●[/green] OPERATIONAL  │  PATTERN: PORTS & ADAPTERS  │  YEAR: 2026      ║
+║                                                                        ║
+╚════════════════════════════════════════════════════════════════════════╝
+[/bold cyan]
+[dim]                The Foundry Overseer - Stack Management CLI[/dim]
+"""
+
+# Menu configuration
+ANIMATED_MENU_ITEMS = [
+    "Explore Templates",
+    "Generate Project",
+    "Manage Config",
+    "System Validation",
+    "View Docs",
+    "Exit",
+]

sscli-0.1.0/foundry/interactive.py

@@ -0,0 +1,151 @@
+import questionary
+from foundry.actions.documentation import run_view_docs
+from foundry.actions.explore import run_explore
+from foundry.actions.generator import run_generator
+from foundry.actions.validation import run_smoke_tests
+from foundry.alpha_expiration import get_expiration_manager
+from foundry.alpha.view import show_warning_message
+from foundry.auth import get_current_license_info, login_flow
+from foundry.constants import FOUNDRY_BANNER, console
+from foundry.utils import is_internal_dev
+from foundry.interactive_utils import manage_config_menu, pause, internal_ops_menu
+
+
+# Animation Imports - Standard Menu only needs to know if they exist for banner display
+try:
+    from foundry.animations import InteractiveAnimationEngine
+    HAS_ANIMATIONS = True
+except Exception:
+    HAS_ANIMATIONS = False
+
+
+def run_animated_experience():
+    """Proxy to the actual animated experience implementation."""
+    from foundry.animated_experience import run_animated_experience as _run
+    _run()
+
+
+def interactive_menu():
+    if HAS_ANIMATIONS:
+        try:
+            # No intro sequence for standard menu - jumping straight to banner
+            console.print(FOUNDRY_BANNER)
+        except Exception:
+            console.print(FOUNDRY_BANNER)
+    else:
+        console.print(FOUNDRY_BANNER)
+
+    # Check authentication status
+    auth_info = get_current_license_info()
+    if auth_info.get("tier") == "free":
+        console.print("\n[bold yellow]🔐 Authentication Required[/bold yellow]")
+        console.print("You need to authenticate to access PRO and ALPHA features.\n")
+
+        auth_choice = questionary.select(
+            "Would you like to authenticate now?",
+            choices=[
+                "Login with GitHub (Recommended)",
+                "Continue as Free User",
+                "Exit",
+            ],
+        ).ask()
+
+        if auth_choice == "Exit" or auth_choice is None:
+            console.print("[yellow]Goodbye![/yellow]")
+            return
+        elif auth_choice == "Login with GitHub (Recommended)":
+            try:
+                login_flow()
+                # Refresh auth info after login
+                auth_info = get_current_license_info()
+                console.print("\n[green]✓ Authentication successful![/green]\n")
+            except Exception as e:
+                console.print(f"\n[red]✗ Authentication failed:[/red] {e}\n")
+                console.print("Continuing as free user...\n")
+
+    # Internal Mode selection for Developers
+    if is_internal_dev():
+        mode = questionary.select(
+            "Select Your Experience:",
+            choices=[
+                "Seed & Source (Client Side)",
+                "Foundry Ops (Internal Side)",
+                "Exit",
+            ],
+            style=questionary.Style([("highlighted", "fg:#00ffff bold")]),
+        ).ask()
+
+        if mode == "Exit" or mode is None:
+            console.print("[yellow]Goodbye![/yellow]")
+            return
+
+        if mode == "Foundry Ops (Internal Side)":
+            internal_ops_menu()
+            return
+
+    # Check for alpha package expiration
+    alpha_mgr = get_expiration_manager()
+    if alpha_mgr.is_alpha():
+        alpha_mgr.show_status()
+        if alpha_mgr.is_near_expiration():
+            show_warning_message(alpha_mgr.alpha_info)
+
+    while True:
+        # Build menu choices based on auth status
+        base_choices = [
+            "Explore Templates",
+            "Generate New Project",
+            "Manage Stack Configuration",
+            "Run System Validation (Smoke Tests)",
+            "View Documentation",
+        ]
+
+        # Add auth option if not authenticated
+        if auth_info.get("tier") == "free":
+            base_choices.insert(0, "🔐 Login to Unlock PRO Features")
+        else:
+            base_choices.insert(0, f"👤 Account ({auth_info.get('tier', 'free').upper()})")
+
+        base_choices.append("Exit")
+
+        choice = questionary.select(
+            "What would you like to do?",
+            choices=base_choices,
+        ).ask()
+
+        if choice == "🔐 Login to Unlock PRO Features":
+            try:
+                login_flow()
+                # Refresh auth info after login
+                auth_info = get_current_license_info()
+                console.print("\n[green]✓ Authentication successful![/green]\n")
+            except Exception as e:
+                console.print(f"\n[red]✗ Authentication failed:[/red] {e}\n")
+        elif choice == f"👤 Account ({auth_info.get('tier', 'free').upper()})":
+            # Show account info
+            console.print(f"\n[bold]Account Information:[/bold]")
+            console.print(f"Email: {auth_info.get('email', 'Not available')}")
+            console.print(f"Tier: {auth_info.get('tier', 'free').upper()}")
+            console.print(f"Expires: {auth_info.get('expires', 'N/A')}")
+            console.print(f"User ID: {auth_info.get('user_id', 'N/A')}\n")
+            pause()
+        elif choice == "Explore Templates":
+            run_explore()
+            pause()
+        elif choice == "Generate New Project":
+            # Check expiration before generation
+            if not alpha_mgr.check_before_action("Generate New Project"):
+                continue
+            run_generator(interactive=True)
+            pause()
+        elif choice == "Manage Stack Configuration":
+            manage_config_menu()
+        elif choice == "Run System Validation (Smoke Tests)":
+            run_smoke_tests()
+            pause()
+        elif choice == "View Documentation":
+            run_view_docs(interactive=True)
+            pause()
+        else:
+            console.print("[yellow]Goodbye![/yellow]")
+            break

sscli-0.1.0/foundry/interactive_utils.py

@@ -0,0 +1,81 @@
+import questionary
+from foundry.constants import console
+from foundry.actions.health import run_health_check
+from foundry.actions.setup import run_setup
+
+
+def manage_config_menu():
+    while True:
+        action = questionary.select(
+            "Configuration Management:",
+            choices=[
+                "View Validation Status",
+                "Run Template Setup (Full Suite)",
+                "Back",
+            ],
+        ).ask()
+
+        if action == "Back":
+            break
+
+        if action == "View Validation Status":
+            run_health_check()
+            pause()
+
+        if action == "Run Template Setup (Full Suite)":
+            run_setup()
+            pause()
+
+
+def pause():
+    input("\nPress Enter to return...")
+
+
+def internal_ops_menu():
+    """Menu for internal development and ops tasks."""
+    try:
+        from foundry.ops.manager import InternalManager
+    except ImportError:
+        console.print("[red]Ops manager not available in this build.[/]")
+        return
+
+    # Show auth status for internal devs too
+    from foundry.auth import get_current_license_info
+    auth_info = get_current_license_info()
+    if auth_info.get("tier") != "free":
+        console.print(f"[green]✓ Authenticated as {auth_info.get('tier', 'user').upper()}[/green]")
+    else:
+        console.print("[yellow]⚠️  Not authenticated - limited access[/yellow]")
+
+    manager = InternalManager()
+
+    while True:
+        choice = questionary.select(
+            "Foundry Ops - Internal Development:",
+            choices=[
+                "Verify All Builds (Docker)",
+                "Run Hygiene Checks (Repo Health)",
+                "Full Verification Suite",
+                "Clean Verification Reports",
+                "Back to Main",
+            ],
+            style=questionary.Style([("highlighted", "fg:#ff00ff bold")]),
+        ).ask()
+
+        if not choice or choice == "Back to Main":
+            break
+
+        if choice == "Verify All Builds (Docker)":
+            manager.verify_builds()
+            pause()
+        elif choice == "Run Hygiene Checks (Repo Health)":
+            manager.run_verification_script(
+                "verify_hygiene", "Code Hygiene (File Lengths)"
+            )
+            pause()
+        elif choice == "Full Verification Suite":
+            manager.verify_full_suite()
+            pause()
+        elif choice == "Clean Verification Reports":
+            manager.clean_reports()
+            pause()

sscli-0.1.0/foundry/manage.py

@@ -0,0 +1,9 @@
+import os
+from dotenv import load_dotenv
+from foundry.cli import app
+
+# Load environment variables from .env file if it exists
+load_dotenv()
+
+if __name__ == "__main__":
+    app()

sscli-0.1.0/foundry/telemetry.py

@@ -0,0 +1,23 @@
+import datetime
+from pathlib import Path
+from foundry.constants import ALPHA_FEEDBACK_FORM
+
+LOG_FILE = Path(".session.log")
+
+
+def log_event(event_type: str, details: str = ""):
+    """Log an event to the local session log."""
+    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    log_entry = f"[{timestamp}] {event_type.upper()}: {details}\n"
+
+    try:
+        with open(LOG_FILE, "a", encoding="utf-8") as f:
+            f.write(log_entry)
+    except Exception:
+        # Fallback to silent failure to not break the CLI experience
+        pass
+
+
+def get_feedback_link() -> str:
+    """Returns the feedback form link."""
+    return ALPHA_FEEDBACK_FORM

sscli-0.1.0/foundry/utils.py

@@ -0,0 +1,66 @@
+from pathlib import Path
+import os
+from typing import Any, Dict, List
+
+from foundry.constants import TEMPLATE_REGISTRY, TEMPLATES_DIR
+
+
+def is_valid_template(path: Path) -> bool:
+    """Check if a local directory is a valid template."""
+    if not path.is_dir() or path.name.startswith("."):
+        return False
+
+    # Check if it's in our registry
+    if path.name in TEMPLATE_REGISTRY:
+        return True
+
+    # Check for legacy project markers (fallback)
+    markers = [
+        "Dockerfile",
+        "package.json",
+        "main.tf",
+        "pyproject.toml",
+        "Gemfile",
+        "build.gradle.kts",
+        "StackApp",
+    ]
+
+    return any((path / marker).exists() for marker in markers)
+
+
+def is_internal_dev() -> bool:
+    """
+    Check if the CLI is running in the internal development mono-repo context.
+    Looks for markers like .github, ops/, and scripts/ at the root.
+    Can be explicitly disabled with FOUNDRY_INTERNAL_DEV=0
+    """
+    if os.getenv("FOUNDRY_INTERNAL_DEV") == "0":
+        return False
+
+    internal_markers = [".github", "ops", "scripts", "wiring"]
+    return all((TEMPLATES_DIR / marker).exists() for marker in internal_markers)
+
+
+def get_templates() -> List[Path]:
+    """
+    Get list of templates.
+    In development mode, returns local directories.
+    In PyPI mode, returns virtual paths based on registry.
+    """
+    # 1. Try local scanning (Development/Monorepo mode)
+    if TEMPLATES_DIR.exists():
+        local_templates = [d for d in TEMPLATES_DIR.iterdir() if is_valid_template(d)]
+        if local_templates:
+            return sorted(local_templates, key=lambda x: x.name)
+
+    # 2. Fallback to Registry (PyPI mode)
+    # We return dummy Path objects where the name corresponds to the registry key
+    return [Path(name) for name in TEMPLATE_REGISTRY.keys()]
+
+
+def get_template_info(template_name: str) -> Dict[str, Any]:
+    """Get metadata for a specific template."""
+    return TEMPLATE_REGISTRY.get(
+        template_name,
+        {"name": template_name, "description": "Custom Template", "tier": "free"},
+    )

sscli-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sscli"
+version = "0.1.0"
+description = "Seed & Source CLI"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "typer[all]",
+    "rich",
+    "questionary",
+    "requests",
+    "pathlib",
+    "python-dotenv"
+]
+
+[project.scripts]
+stack-cli = "foundry.manage:app"
+
+[tool.setuptools]
+packages = ["foundry"]
+
+[tool.setuptools.package-data]
+"*" = ["*.md", "*.json"]
+
+[tool.setuptools.exclude-package-data]
+"*" = ["venv*", ".env*", "*.log", ".pytest_cache*", "tests*"]

sscli-0.1.0/setup.cfg

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

sscli-0.1.0/sscli.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: sscli
+Version: 0.1.0
+Summary: Seed & Source CLI
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer[all]
+Requires-Dist: rich
+Requires-Dist: questionary
+Requires-Dist: requests
+Requires-Dist: pathlib
+Requires-Dist: python-dotenv
+
+# Seed & Source CLI
+Unified interface for Stack Foundry templates.

sscli-0.1.0/sscli.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+foundry/__init__.py
+foundry/alpha_expiration.py
+foundry/animated_experience.py
+foundry/auth.py
+foundry/cli.py
+foundry/constants.py
+foundry/interactive.py
+foundry/interactive_utils.py
+foundry/manage.py
+foundry/telemetry.py
+foundry/utils.py
+sscli.egg-info/PKG-INFO
+sscli.egg-info/SOURCES.txt
+sscli.egg-info/dependency_links.txt
+sscli.egg-info/entry_points.txt
+sscli.egg-info/requires.txt
+sscli.egg-info/top_level.txt

sscli-0.1.0/sscli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sscli-0.1.0/sscli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+stack-cli = foundry.manage:app

sscli-0.1.0/sscli.egg-info/requires.txt

@@ -0,0 +1,6 @@
+typer[all]
+rich
+questionary
+requests
+pathlib
+python-dotenv

sscli-0.1.0/sscli.egg-info/top_level.txt

@@ -0,0 +1 @@
+foundry