sscli 2.0.2__tar.gz → 2.1.0__tar.gz

{sscli-2.0.2 → sscli-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sscli
-Version: 2.0.2
+Version: 2.1.0
 Summary: Seed & Source CLI - Multi-tenant SaaS scaffolding with Seed & Source Core
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

sscli-2.1.0/foundry/actions/development.py

@@ -0,0 +1,397 @@
+"""
+Development tools for sscli - status, build, and swap functionality
+Internal development only - not available in production installs
+"""
+import subprocess
+import questionary
+import json
+from pathlib import Path
+from foundry.constants import console
+from foundry.utils import is_internal_dev
+from rich.panel import Panel
+from rich.table import Table
+import sys
+import os
+import importlib.util
+# Detect venv location
+def get_venv_path():
+    """Detect Python virtual environment."""
+    # First priority: VIRTUAL_ENV environment variable (most reliable)
+    if os.environ.get('VIRTUAL_ENV'):
+        venv = Path(os.environ['VIRTUAL_ENV'])
+        if (venv / 'bin' / 'pip').exists() or (venv / 'bin' / 'python').exists():
+            return venv
+    
+    # Second priority: Try to find venv near the script
+    stack_cli_root = get_stack_cli_root()
+    for venv_candidate in ['venv', '.venv', 'env']:
+        venv_path = stack_cli_root / venv_candidate
+        if (venv_path / 'bin' / 'python').exists():
+            return venv_path
+    
+    # Third priority: try using sys.prefix (venv's location when activated)
+    if hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix:
+        # We're in a virtual environment
+        return Path(sys.prefix)
+    
+    return None
+
+def get_stack_cli_root():
+    """Get the stack-cli root directory."""
+    # First, try FOUNDRY_ROOT environment variable
+    if os.environ.get('FOUNDRY_ROOT'):
+        foundry_root = Path(os.environ['FOUNDRY_ROOT'])
+        stack_cli_path = foundry_root / 'tooling' / 'stack-cli'
+        if stack_cli_path.exists():
+            return stack_cli_path
+    
+    # Try to find by looking for pyproject.toml with sscli package
+    current_file = Path(__file__).resolve()
+    
+    # Go up from foundry/actions/development.py -> stack-cli root
+    candidate = current_file.parent.parent.parent
+    if (candidate / 'pyproject.toml').exists():
+        with open(candidate / 'pyproject.toml') as f:
+            content = f.read()
+            if 'name = "sscli"' in content:
+                return candidate
+    
+    # Fallback: use sys.prefix for installed package case
+    return Path(sys.prefix)
+
+def get_local_version():
+    """Get version from local pyproject.toml."""
+    stack_cli_root = get_stack_cli_root()
+    pyproject = stack_cli_root / 'pyproject.toml'
+    
+    if pyproject.exists():
+        with open(pyproject) as f:
+            for line in f:
+                if line.startswith('version'):
+                    return line.split('=')[1].strip().strip('"')
+    return "unknown"
+
+def get_pip_version():
+    """Get installed pip package version."""
+    try:
+        return get_package_version('sscli')
+    except:
+        return ""
+
+def is_using_local():
+    """Check if currently using local build."""
+    stack_cli_root = get_stack_cli_root()
+    return str(stack_cli_root) in sys.executable
+
+def run_build(clean=False):
+    """Build distribution packages using setuptools."""
+    stack_cli_root = get_stack_cli_root()
+    
+    console.print("[bold cyan]→[/bold cyan] [bold]Building packages...[/bold]")
+    console.print("")
+    
+    # Clean if requested
+    if clean:
+        dist_dir = stack_cli_root / 'dist'
+        build_dir = stack_cli_root / 'build'
+        
+        if dist_dir.exists():
+            console.print("[yellow]Removing dist/[/yellow]")
+            import shutil
+            shutil.rmtree(dist_dir)
+        
+        if build_dir.exists():
+            console.print("[yellow]Removing build/[/yellow]")
+            import shutil
+            shutil.rmtree(build_dir)
+    
+    # Create dist directory
+    dist_dir = stack_cli_root / 'dist'
+    dist_dir.mkdir(exist_ok=True)
+    
+    # Run wheel build
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "wheel", ".", "--no-deps", "-w", str(dist_dir)],
+            cwd=str(stack_cli_root),
+            capture_output=True,
+            text=True
+        )
+        
+        if result.returncode != 0:
+            console.print(f"[red]Build failed:[/red]")
+            console.print(result.stderr)
+            return False
+        
+        # Build sdist using tarball
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "download", ".", "--no-deps", "--no-binary", ":all:", "-d", str(dist_dir)],
+            cwd=str(stack_cli_root),
+            capture_output=True,
+            text=True
+        )
+        
+        # Show build artifacts
+        if dist_dir.exists():
+            console.print("")
+            artifacts = sorted(list(dist_dir.glob('*')))
+            if artifacts:
+                console.print("[bold]✓[/bold] Build complete")
+                console.print("[bold cyan]→[/bold cyan] Build artifacts:")
+                console.print("")
+                for artifact in artifacts:
+                    size_kb = artifact.stat().st_size / 1024
+                    console.print(f"  [cyan]{artifact.name}[/cyan] ({size_kb:.0f}K)")
+                console.print("")
+                console.print("[bold cyan]Next steps:[/bold cyan]")
+                console.print("  • Install locally:  [yellow]pip install --force-reinstall ./dist/sscli-*.whl[/yellow]")
+                console.print("  • Or use swap:      [yellow]sscli swap[/yellow]")
+                return True
+    except Exception as e:
+        console.print(f"[red]✗ Build failed: {e}[/red]")
+        return False
+    
+    return False
+
+def show_status(verbose=False):
+    """Show development environment status."""
+    stack_cli_root = get_stack_cli_root()
+    venv_path = get_venv_path()
+    local_version = get_local_version()
+    pip_version = get_pip_version()
+    using_local = is_using_local()
+    
+    # Header
+    console.print("")
+    header_panel = Panel(
+        "[bold]sscli Development Status[/bold]",
+        border_style="blue",
+        padding=(0, 2)
+    )
+    console.print(header_panel)
+    console.print("")
+    
+    # Create version table
+    version_table = Table(show_header=False, show_lines=False, padding=(0, 2))
+    version_table.add_column()
+    version_table.add_column()
+    
+    version_table.add_row("  [bold]Local build:[/bold]", f"[yellow]v{local_version}[/yellow] in [dim]{stack_cli_root}[/dim]")
+    version_table.add_row("  [bold]Pip package:[/bold]", f"[yellow]{pip_version if pip_version else '(not installed)'}[/yellow]")
+    
+    console.print(version_table)
+    console.print("")
+    
+    # Installation status
+    current_status = "[yellow]LOCAL BUILD (development)[/yellow]" if using_local else f"[yellow]PIP PACKAGE (v{pip_version})[/yellow]" if pip_version else "[yellow]UNKNOWN[/yellow]"
+    
+    status_table = Table(show_header=False, show_lines=False, padding=(0, 2))
+    status_table.add_column()
+    status_table.add_column()
+    status_table.add_row("  [bold]Currently using:[/bold]", current_status)
+    
+    console.print(status_table)
+    console.print("")
+    
+    # Environment info
+    env_table = Table(show_header=False, show_lines=False, padding=(0, 2))
+    env_table.add_column()
+    env_table.add_column()
+    env_table.add_row("  [bold]Python:[/bold]", f"{sys.version.split()[0]}")
+    env_table.add_row("  [bold]Venv:[/bold]", str(venv_path) if venv_path else "[yellow](not detected)[/yellow]")
+    
+    if verbose and venv_path:
+        req_file = stack_cli_root / 'requirements.txt'
+        if req_file.exists():
+            with open(req_file) as f:
+                deps = [line.strip() for line in f if line.strip() and not line.startswith('#')]
+                env_table.add_row("  [bold]Dependencies:[/bold]", f"{len(deps)} packages")
+    
+    console.print(env_table)
+    console.print("")
+    
+    # Quick actions
+    console.print("  [bold cyan]Quick Actions:[/bold cyan]")
+    console.print("    • Show status verbose:  [yellow]sscli status --verbose[/yellow]")
+    console.print("    • Build packages:       [yellow]sscli build[/yellow]")
+    console.print("    • Switch installation:  [yellow]sscli swap[/yellow]")
+    console.print("")
+    
+    return True
+
+def run_swap(target=None):
+    """Swap between local and pip versions."""
+    stack_cli_root = get_stack_cli_root()
+    venv_path = get_venv_path()
+    pip_version = get_pip_version()
+    using_local = is_using_local()
+    
+    if not venv_path:
+        console.print("[red]✗ Virtual environment not found[/red]")
+        return False
+    
+    venv_bin = venv_path / 'bin'
+    
+    # If no target specified, ask interactively
+    if target is None:
+        console.print("")
+        console.print("[bold]Package Swap Utility[/bold]")
+        console.print("")
+        
+        status = "[yellow]LOCAL BUILD[/yellow]" if using_local else f"[yellow]PIP PACKAGE (v{pip_version})[/yellow]" if pip_version else "[yellow]UNKNOWN[/yellow]"
+        console.print(f"  Currently: {status}")
+        console.print("")
+        
+        available = []
+        if not using_local:
+            available.append(("1", "Local build", "local", "v" + get_local_version()))
+        if pip_version:
+            available.append(("2", "Pip package", "pip", "v" + pip_version))
+        if not available:
+            available.append(("1", "Local build", "local", "v" + get_local_version()))
+        
+        console.print("  [bold]Available versions:[/bold]")
+        for num, label, val, ver in available:
+            console.print(f"    {num}) {label}: {ver}")
+        console.print("")
+        
+        choice = questionary.select(
+            "Switch to which installation?",
+            choices=[f"{label} ({ver})" for _, label, _, ver in available] + ["Cancel"]
+        ).ask()
+        
+        if choice and choice != "Cancel":
+            target = available[[f"{label} ({ver})" for _, label, _, ver in available].index(choice)][2]
+        else:
+            return True  # User cancelled
+    
+    console.print("")
+    console.print(f"[bold cyan]→[/bold cyan] [bold]Switching to {target}...[/bold]")
+    
+    try:
+        if target == "local":
+            # Install from local dist
+            dist_dir = stack_cli_root / 'dist'
+            wheels = list(dist_dir.glob('sscli-*.whl'))
+            
+            if not wheels:
+                console.print("[red]✗ No wheel found in dist/. Run 'sscli build' first[/red]")
+                return False
+            
+            wheel = wheels[0]
+            console.print(f"  Installing from [cyan]{wheel.name}[/cyan]...")
+            
+            result = subprocess.run(
+                [str(venv_bin / 'pip'), 'install', '--force-reinstall', str(wheel)],
+                capture_output=True,
+                text=True
+            )
+            
+            if result.returncode != 0:
+                console.print("[red]✗ Installation failed[/red]")
+                if "--force-reinstall" in result.stderr:
+                    console.print(result.stderr)
+                return False
+            
+            console.print("[green]✓ Switched to local build[/green]")
+            return True
+        
+        elif target == "pip":
+            if not pip_version:
+                console.print("[red]✗ sscli not available on PyPI. Build and install locally[/red]")
+                return False
+            
+            console.print(f"  Installing sscli=={pip_version} from PyPI...")
+            
+            result = subprocess.run(
+                [str(venv_bin / 'pip'), 'install', '--force-reinstall', f'sscli=={pip_version}'],
+                capture_output=True,
+                text=True
+            )
+            
+            if result.returncode != 0:
+                console.print("[red]✗ Installation failed[/red]")
+                return False
+            
+            console.print("[green]✓ Switched to pip package[/green]")
+            return True
+    
+    except Exception as e:
+        console.print(f"[red]✗ Swap failed: {e}[/red]")
+        return False
+    
+    return False
+
+def dev_tools_menu():
+    """Interactive menu for development tools."""
+    # Check if running in development context
+    if not is_internal_dev():
+        console.print("[yellow]⚠️  Development tools are only available in development mode.[/yellow]")
+        return
+    
+    console.clear()
+    
+    console.print("[bold cyan]Development Tools[/bold cyan]")
+    console.print("[dim]Utilities for local development and testing[/dim]")
+    console.print("")
+    
+    while True:
+        choices = [
+            questionary.Choice("📊 Show Development Status", value="status"),
+            questionary.Choice("🔨 Build Distribution Package", value="build"),
+            questionary.Choice("🔄 Switch Build Source (Local ↔ Pip)", value="swap"),
+            questionary.Choice("← Back to Main Menu", value="back"),
+        ]
+        
+        selection = questionary.select(
+            "Select a development tool:",
+            choices=choices,
+        ).ask()
+        
+        if selection is None or selection == "back":
+            return
+        
+        console.clear()
+        console.print("")
+        
+        if selection == "status":
+            show_verbose = questionary.confirm(
+                "Show detailed dependency information?",
+                default=False
+            ).ask()
+            show_status(verbose=show_verbose)
+            
+        elif selection == "build":
+            clean = questionary.confirm(
+                "Clean build artifacts before building?",
+                default=False
+            ).ask()
+            if run_build(clean=clean):
+                console.print("[green]✓[/green] Build successful")
+            else:
+                console.print("[red]✗[/red] Build failed")
+        
+        elif selection == "swap":
+            # Show current status first
+            show_status(verbose=False)
+            console.print("")
+            
+            swap_choice = questionary.select(
+                "Choose action:",
+                choices=[
+                    questionary.Choice("🔄 Toggle (interactive)", value="toggle"),
+                    questionary.Choice("📦 Switch to Local Build", value="local"),
+                    questionary.Choice("🐍 Switch to Pip Package", value="pip"),
+                    questionary.Choice("❌ Cancel", value="cancel"),
+                ],
+            ).ask()
+            
+            if swap_choice and swap_choice != "cancel":
+                if run_swap(target=None if swap_choice == "toggle" else swap_choice):
+                    console.print("[green]✓[/green] Swap successful")
+                else:
+                    console.print("[red]✗[/red] Swap failed")
+        
+        console.print("")
+        input("[dim]Press Enter to continue...[/dim]")
+        console.clear()

sscli-2.1.0/foundry/actions/explore.py

@@ -0,0 +1,139 @@
+from foundry.constants import console, TIER_HIERARCHY, QUESTIONARY_STYLE, TEMPLATE_REGISTRY
+from foundry.utils import get_templates, get_template_info
+from foundry.auth import get_current_license_info
+from rich.panel import Panel
+from rich.tree import Tree
+import questionary
+import re
+
+
+def _get_template_tech(name):
+    """Get technology stack for a template by name."""
+    # Map template names to tech descriptions
+    tech_map = {
+        "python-saas": "Python (FastAPI/SQLAlchemy)",
+        "rails-api": "Ruby on Rails",
+        "react-client": "React/Vite",
+        "rails-ui-kit": "Rails + ViewComponent",
+        "static-landing": "Astro (Static Site)",
+        "mobile-android": "Android (Kotlin/Compose)",
+        "mobile-ios": "iOS (Swift/SwiftUI)",
+        "data-pipeline": "Data Stack (dbt + Python)",
+        "terraform-infra": "Terraform (Multi-cloud)",
+        "wiring": "Docker Orchestration",
+    }
+    return tech_map.get(name, "Multi-tech Stack")
+
+
+def _strip_markup(text):
+    """Remove Rich markup tags from text."""
+    return re.sub(r'\[/?[^\]]+\]', '', text)
+
+
+def _render_templates_tree(buckets):
+    """Render a tree view with all categories expanded showing available templates."""
+    tree = Tree("[bold green]Seed & Source Inventory[/bold green]")
+
+    for category, items in buckets.items():
+        if not items:
+            continue
+
+        count = len(items)
+        cat_node = tree.add(f"[bold yellow]▼ {category} ({count})[/bold yellow]")
+        
+        for item in items:
+            node = cat_node.add(f"[bold cyan]{item['name']}[/bold cyan]")
+            # Show tier badge in tree
+            if item['tier'] != "free":
+                tier_display = f"(🔐 {item['tier'].upper()})" if item['locked'] else f"(✅ {item['tier'].upper()})"
+                node.add(f"[yellow]{tier_display}[/yellow]")
+            # Show tech
+            tech = _get_template_tech(item['name'])
+            node.add(f"[dim]{tech}[/dim]")
+
+    console.print(Panel(tree, title="Available Templates", border_style="green"))
+
+
+def run_explore():
+    """Interactive template explorer with expanded tree and selectable templates."""
+    # Get user info for tier checking
+    user_info = get_current_license_info()
+    user_tier = user_info.get("tier", "free")
+    user_rank = TIER_HIERARCHY.get(user_tier, 0)
+
+    # Group templates by category
+    buckets = {
+        "Backend Services": [],
+        "Frontend & UI": [],
+        "Mobile App": [],
+        "Data Engineering": [],
+        "Infrastructure": [],
+        "Other": [],
+    }
+
+    templates = get_templates()
+
+    for tmpl in templates:
+        name = tmpl.name
+        # Fetch metadata to get the tier
+        info = get_template_info(name)
+        tmpl_tier = info.get("tier", "free").lower()
+        tmpl_rank = TIER_HIERARCHY.get(tmpl_tier, 0)
+
+        # Check if locked
+        locked = tmpl_rank > user_rank
+        
+        # Simple menu label (no markup for questionary)
+        menu_label = name
+        if locked:
+            menu_label = f"{name} 🔐"
+        elif tmpl_tier != "free":
+            menu_label = f"{name} ✅"
+        
+        # Store template data for processing
+        tmpl_data = {
+            "name": name,
+            "menu_label": menu_label,
+            "tier": tmpl_tier,
+            "locked": locked,
+        }
+
+        if name in ["python-saas", "rails-api"]:
+            buckets["Backend Services"].append(tmpl_data)
+        elif name in ["react-client", "rails-ui-kit", "static-landing"]:
+            buckets["Frontend & UI"].append(tmpl_data)
+        elif name.startswith("mobile-"):
+            buckets["Mobile App"].append(tmpl_data)
+        elif name == "data-pipeline":
+            buckets["Data Engineering"].append(tmpl_data)
+        elif name == "terraform-infra":
+            buckets["Infrastructure"].append(tmpl_data)
+        else:
+            buckets["Other"].append(tmpl_data)
+
+    # Remove empty categories
+    buckets = {k: v for k, v in buckets.items() if v}
+
+    # Display the tree with all categories expanded
+    console.clear()
+    _render_templates_tree(buckets)
+    
+    # Build flat list of templates for selection (without Rich markup for questionary)
+    template_choices = []
+    for category, items in buckets.items():
+        for item in items:
+            template_choices.append((item['name'], item['menu_label']))
+    
+    # Add back button
+    template_choices.append(("back", "← Back to Main Menu"))
+
+    # Show template selection menu
+    selected = questionary.select(
+        "Select a template to view details:",
+        choices=[questionary.Choice(label, value=name) for name, label in template_choices],
+        style=questionary.Style(QUESTIONARY_STYLE)
+    ).ask()
+
+    if selected is None or selected == "back":
+        return
+

{sscli-2.0.2 → sscli-2.1.0}/foundry/cli.py

@@ -1,13 +1,13 @@
 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.actions.development import dev_tools_menu, show_status, run_build, run_swap
 from foundry.auth import get_current_license_info, logout
 from foundry.telemetry import log_event
 from foundry.commands.auth import auth_app, run_whoami
@@ -16,7 +16,7 @@ from foundry.utils import is_internal_dev
 
 app = typer.Typer(
     help="Seed & Source CLI Tool",
-    no_args_is_help=True,
+    no_args_is_help=False,
     add_completion=True,
 )
 
@@ -30,6 +30,14 @@ if is_internal_dev():
     app.add_typer(ops_app, name="ops", help="Internal operations and maintenance.")
 
 
+@app.callback(invoke_without_command=True)
+def default_action(ctx: typer.Context):
+    """Default action: show interactive menu if no command is provided."""
+    if ctx.invoked_subcommand is None:
+        from foundry.interactive import interactive_menu
+        interactive_menu()
+
+
 @app.command("whoami")
 def whoami():
     run_whoami()
@@ -135,9 +143,46 @@ def verify(
     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)
+# Only expose dev tools in internal development mode
+if is_internal_dev():
+    @app.command("dev")
+    def dev():
+        """Access development tools (status, build, swap)."""
+        log_event("COMMAND", "dev")
+        dev_tools_menu()
+
+    @app.command("status")
+    def status(
+        verbose: bool = typer.Option(
+            False, "--verbose", "-v", help="Show detailed dependency information"
+        ),
+    ):
+        """Show development environment status (local build vs pip package)."""
+        log_event("COMMAND", "status")
+        show_status(verbose=verbose)
+
+    @app.command("build")
+    def build(
+        clean: bool = typer.Option(
+            False, "--clean", help="Clean build artifacts before building"
+        ),
+    ):
+        """Build distribution packages (wheel and sdist)."""
+        log_event("COMMAND", "build")
+        if run_build(clean=clean):
+            console.print("[green]✓[/green] Build successful")
+        else:
+            console.print("[red]✗[/red] Build failed")
+            raise typer.Exit(code=1)
+
+    @app.command("swap")
+    def swap(
+        target: Optional[str] = typer.Option(
+            None, help="Target: 'local' or 'pip' (interactive if not specified)"
+        ),
+    ):
+        """Switch between local and pip package installations."""
+        log_event("COMMAND", "swap")
+        if not run_swap(target=target):
+            console.print("[red]✗[/red] Swap failed")
+            raise typer.Exit(code=1)

{sscli-2.0.2 → sscli-2.1.0}/foundry/interactive.py

@@ -1,10 +1,10 @@
 import questionary
 from questionary import Choice
-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.actions.account_info import account_info_menu
+from foundry.actions.development import dev_tools_menu
 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
@@ -95,9 +95,12 @@ def interactive_menu():
             Choice("✨ Generate New Project", value="generate"),
             Choice("⚙️  Manage Stack Configuration", value="config"),
             Choice("🔍 Run System Validation (Smoke Tests)", value="validation"),
-            Choice("📚 View Documentation", value="docs"),
         ]
 
+        # Add development tools only in internal dev mode
+        if is_internal_dev():
+            base_choices.append(Choice("🛠️  Development Tools", value="dev_tools"))
+
         # Add ADMIN-ONLY features if user is admin
         if auth_info.get("tier") == "admin":
             base_choices.append(Choice("🔑 Client Template Access Manager", value="client_access"))
@@ -125,8 +128,8 @@ def interactive_menu():
             choice = "Manage Stack Configuration"
         elif choice == "validation":
             choice = "Run System Validation (Smoke Tests)"
-        elif choice == "docs":
-            choice = "View Documentation"
+        elif choice == "dev_tools":
+            choice = "Development Tools"
         elif choice == "client_access":
             choice = "🔑 Client Template Access Manager"
         elif choice == "login":
@@ -165,9 +168,8 @@ def interactive_menu():
         elif choice == "Run System Validation (Smoke Tests)":
             run_smoke_tests()
             pause()
-        elif choice == "View Documentation":
-            run_view_docs(interactive=True)
-            pause()
+        elif choice == "Development Tools":
+            dev_tools_menu()
         elif choice == "🔑 Client Template Access Manager":
             from foundry.client_access_manager import client_access_admin_menu
             client_access_admin_menu()

{sscli-2.0.2 → sscli-2.1.0}/pyproject.toml

@@ -1,12 +1,10 @@
 [build-system]
-requires = [
-    "setuptools>=61.0",
-]
+requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "sscli"
-version = "2.0.2"
+version = "2.1.0"
 description = "Seed & Source CLI - Multi-tenant SaaS scaffolding with Seed & Source Core"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -18,28 +16,17 @@ dependencies = [
     "pathlib",
     "python-dotenv",
     "pydantic>=2.0.0",
-    "httpx>=0.27.0",
+    "httpx>=0.27.0"
 ]
 
 [project.scripts]
 sscli = "foundry.manage:app"
 
-[tool.setuptools.packages.find]
-include = [
-    "foundry*",
-]
+[tool.setuptools]
+packages = { find = { include = ["foundry*"] } }
 
 [tool.setuptools.package-data]
-"*" = [
-    "*.md",
-    "*.json",
-]
+"*" = ["*.md", "*.json"]
 
 [tool.setuptools.exclude-package-data]
-"*" = [
-    "venv*",
-    ".env*",
-    "*.log",
-    ".pytest_cache*",
-    "tests*",
-]
+"*" = ["venv*", ".env*", "*.log", ".pytest_cache*", "tests*"]

{sscli-2.0.2 → sscli-2.1.0}/sscli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sscli
-Version: 2.0.2
+Version: 2.1.0
 Summary: Seed & Source CLI - Multi-tenant SaaS scaffolding with Seed & Source Core
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

{sscli-2.0.2 → sscli-2.1.0}/sscli.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ foundry/telemetry.py
 foundry/utils.py
 foundry/actions/__init__.py
 foundry/actions/account_info.py
+foundry/actions/development.py
 foundry/actions/documentation.py
 foundry/actions/explore.py
 foundry/actions/features.py

sscli-2.0.2/foundry/actions/explore.py

@@ -1,145 +0,0 @@
-from foundry.constants import console, TIER_HIERARCHY
-from foundry.utils import get_templates, get_template_info
-from foundry.auth import get_current_license_info
-from rich.panel import Panel
-from rich.tree import Tree
-import questionary
-
-
-def _get_template_tech(tmpl):
-    """Get technology stack for a template."""
-    if (tmpl / "pyproject.toml").exists():
-        return "Python (FastAPI/NiceGUI)"
-    elif (tmpl / "Gemfile").exists():
-        return "Ruby on Rails"
-    elif (tmpl / "package.json").exists():
-        return "React/Vite"
-    elif (tmpl / "build.gradle.kts").exists():
-        return "Android (Kotlin/Compose)"
-    elif (tmpl / "StackApp").exists():
-        return "iOS (Swift/SwiftUI)"
-    elif (tmpl / "main.tf").exists():
-        return "Terraform"
-    elif (tmpl / "astro.config.mjs").exists():
-        return "Astro (Static Site)"
-    return "Unknown"
-
-
-def _render_interactive_tree(buckets, expansion_state):
-    """Render an interactive tree view with collapsible categories."""
-    tree = Tree("[bold green]Seed & Source Inventory[/bold green]")
-
-    for category, items in buckets.items():
-        if not items:
-            continue
-
-        count = len(items)
-        is_expanded = expansion_state.get(category, True)
-        toggle_icon = "▼" if is_expanded else "►"
-        
-        cat_node = tree.add(f"[bold yellow]{toggle_icon} {category} ({count})[/bold yellow]")
-        
-        if is_expanded:
-            for item in items:
-                node = cat_node.add(f"[bold cyan]{item['display']}[/bold cyan]")
-                tmpl = item['path']
-                tech = _get_template_tech(tmpl)
-                node.add(f"[dim]{tech}[/dim]")
-        else:
-            cat_node.add("[dim]Click to expand...[/dim]")
-
-    console.print(Panel(tree, title="Available Templates", border_style="green"))
-
-
-def run_explore():
-    """Interactive template explorer with interactive collapsible sections using tree view design."""
-    # Get user info for tier checking
-    user_info = get_current_license_info()
-    user_tier = user_info.get("tier", "free")
-    user_rank = TIER_HIERARCHY.get(user_tier, 0)
-
-    # Group templates by category
-    buckets = {
-        "Backend Services": [],
-        "Frontend & UI": [],
-        "Mobile App": [],
-        "Data Engineering": [],
-        "Infrastructure": [],
-        "Other": [],
-    }
-
-    templates = get_templates()
-
-    for tmpl in templates:
-        name = tmpl.name
-        # Fetch metadata to get the tier
-        info = get_template_info(name)
-        tmpl_tier = info.get("tier", "free").lower()
-        tmpl_rank = TIER_HIERARCHY.get(tmpl_tier, 0)
-
-        # Format display name with access status badge
-        tmpl_display_name = name
-        if tmpl_rank > user_rank:
-            tmpl_display_name = f"[dim]{name} [red](🔐 {tmpl_tier.upper()})[/dim]"
-        elif tmpl_tier != "free":
-            tmpl_display_name = f"{name} [green](✅ {tmpl_tier.upper()})[/green]"
-        
-        # Store template data for processing
-        tmpl_data = {"name": name, "display": tmpl_display_name, "path": tmpl}
-
-        if name in ["python-saas", "rails-api"]:
-            buckets["Backend Services"].append(tmpl_data)
-        elif name in ["react-client", "rails-ui-kit", "static-landing"]:
-            buckets["Frontend & UI"].append(tmpl_data)
-        elif name.startswith("mobile-"):
-            buckets["Mobile App"].append(tmpl_data)
-        elif name == "data-pipeline":
-            buckets["Data Engineering"].append(tmpl_data)
-        elif name == "terraform-infra":
-            buckets["Infrastructure"].append(tmpl_data)
-        else:
-            buckets["Other"].append(tmpl_data)
-
-    # Remove empty categories
-    buckets = {k: v for k, v in buckets.items() if v}
-    
-    # Track expansion state for each category (all start expanded)
-    expansion_state = {category: True for category in buckets.keys()}
-
-    # Interactive menu loop
-    while True:
-        # Display the interactive tree
-        console.clear()
-        _render_interactive_tree(buckets, expansion_state)
-        
-        # Build menu choices for toggling categories
-        choices = []
-        for category in buckets.keys():
-            is_expanded = expansion_state.get(category, True)
-            icon = "▼" if is_expanded else "►"
-            count = len(buckets[category])
-            action = "Collapse" if is_expanded else "Expand"
-            choices.append(f"{icon} {action} {category} ({count})")
-        
-        choices.append("🔄 Expand All")
-        choices.append("🔒 Collapse All")
-        choices.append("Exit")
-
-        selection = questionary.select(
-            "[bold]Toggle Categories[/bold]",
-            choices=choices,
-        ).ask()
-
-        if selection is None or selection == "Exit":
-            break
-        elif selection == "🔄 Expand All":
-            expansion_state = {k: True for k in expansion_state.keys()}
-        elif selection == "🔒 Collapse All":
-            expansion_state = {k: False for k in expansion_state.keys()}
-        else:
-            # Extract category name from choice
-            for category in buckets.keys():
-                if category in selection:
-                    expansion_state[category] = not expansion_state[category]
-                    break
-                input("[dim]Press Enter to continue...[/dim]")