269 lines
9.1 KiB
Plaintext
269 lines
9.1 KiB
Plaintext
"""{{CLI_NAME}} - {{CLI_DESCRIPTION}}
|
|
|
|
Complex multi-command Fire CLI with multiple command groups.
|
|
"""
|
|
import fire
|
|
from rich.console import Console
|
|
from rich.table import Table
|
|
from pathlib import Path
|
|
from typing import Optional, List
|
|
import json
|
|
|
|
console = Console()
|
|
|
|
|
|
class {{CLASS_NAME}}:
|
|
"""{{CLI_DESCRIPTION}}"""
|
|
|
|
def __init__(self):
|
|
self.version = "{{VERSION}}"
|
|
self.config_file = Path.home() / ".{{CLI_NAME_LOWER}}" / "config.json"
|
|
|
|
class Project:
|
|
"""Project management commands"""
|
|
|
|
def create(self, name: str, template: str = 'default', path: Optional[str] = None):
|
|
"""Create a new project
|
|
|
|
Args:
|
|
name: Project name
|
|
template: Project template (default: default)
|
|
path: Project path (default: current directory)
|
|
"""
|
|
project_path = Path(path) if path else Path.cwd() / name
|
|
console.print(f"[green]✓[/green] Creating project: {name}")
|
|
console.print(f"[dim]Template: {template}[/dim]")
|
|
console.print(f"[dim]Path: {project_path}[/dim]")
|
|
|
|
def delete(self, name: str, confirm: bool = False):
|
|
"""Delete a project
|
|
|
|
Args:
|
|
name: Project name
|
|
confirm: Confirm deletion
|
|
"""
|
|
if not confirm:
|
|
console.print("[yellow]Use --confirm to delete project[/yellow]")
|
|
return
|
|
|
|
console.print(f"[red]Deleting project: {name}[/red]")
|
|
|
|
def list(self):
|
|
"""List all projects"""
|
|
projects = [
|
|
{"name": "project-a", "status": "active", "version": "1.0.0"},
|
|
{"name": "project-b", "status": "archived", "version": "2.1.0"},
|
|
]
|
|
|
|
table = Table(title="Projects")
|
|
table.add_column("Name", style="cyan")
|
|
table.add_column("Status", style="green")
|
|
table.add_column("Version", style="yellow")
|
|
|
|
for proj in projects:
|
|
table.add_row(proj['name'], proj['status'], proj['version'])
|
|
|
|
console.print(table)
|
|
return projects
|
|
|
|
class Build:
|
|
"""Build management commands"""
|
|
|
|
def start(self, target: str, parallel: bool = False, workers: int = 4):
|
|
"""Start build process
|
|
|
|
Args:
|
|
target: Build target
|
|
parallel: Enable parallel builds
|
|
workers: Number of parallel workers
|
|
"""
|
|
console.print(f"[cyan]Building target: {target}[/cyan]")
|
|
if parallel:
|
|
console.print(f"[dim]Parallel mode with {workers} workers[/dim]")
|
|
|
|
def clean(self, deep: bool = False):
|
|
"""Clean build artifacts
|
|
|
|
Args:
|
|
deep: Perform deep clean (includes cache)
|
|
"""
|
|
console.print("[yellow]Cleaning build artifacts...[/yellow]")
|
|
if deep:
|
|
console.print("[dim]Deep clean: removing cache[/dim]")
|
|
|
|
def status(self):
|
|
"""Show build status"""
|
|
console.print("[bold]Build Status:[/bold]")
|
|
console.print(" Last build: [green]Success[/green]")
|
|
console.print(" Artifacts: 42 files")
|
|
|
|
class Deploy:
|
|
"""Deployment commands"""
|
|
|
|
def start(
|
|
self,
|
|
environment: str,
|
|
service: Optional[str] = None,
|
|
force: bool = False,
|
|
mode: str = 'safe'
|
|
):
|
|
"""Deploy to environment
|
|
|
|
Args:
|
|
environment: Target environment (dev, staging, prod)
|
|
service: Specific service to deploy (default: all)
|
|
force: Force deployment
|
|
mode: Deployment mode (fast, safe, rollback)
|
|
"""
|
|
console.print(f"[cyan]Deploying to {environment}[/cyan]")
|
|
if service:
|
|
console.print(f"[dim]Service: {service}[/dim]")
|
|
console.print(f"[dim]Mode: {mode}[/dim]")
|
|
if force:
|
|
console.print("[yellow]⚠ Force mode enabled[/yellow]")
|
|
|
|
def rollback(self, environment: str, version: Optional[str] = None):
|
|
"""Rollback deployment
|
|
|
|
Args:
|
|
environment: Target environment
|
|
version: Version to rollback to (default: previous)
|
|
"""
|
|
target = version or "previous"
|
|
console.print(f"[yellow]Rolling back {environment} to {target}[/yellow]")
|
|
|
|
def status(self, environment: str):
|
|
"""Show deployment status
|
|
|
|
Args:
|
|
environment: Target environment
|
|
"""
|
|
console.print(f"[bold]Deployment Status: {environment}[/bold]")
|
|
console.print(" Status: [green]Active[/green]")
|
|
console.print(" Version: 1.2.3")
|
|
console.print(" Last deployed: 2 hours ago")
|
|
|
|
def history(self, environment: str, limit: int = 10):
|
|
"""Show deployment history
|
|
|
|
Args:
|
|
environment: Target environment
|
|
limit: Number of records to show
|
|
"""
|
|
console.print(f"[bold]Deployment History: {environment}[/bold]")
|
|
for i in range(limit):
|
|
console.print(f" {i+1}. Version 1.{i}.0 - 2 days ago")
|
|
|
|
class Database:
|
|
"""Database management commands"""
|
|
|
|
def migrate(self, direction: str = 'up', steps: Optional[int] = None):
|
|
"""Run database migrations
|
|
|
|
Args:
|
|
direction: Migration direction (up, down)
|
|
steps: Number of migrations to run (default: all)
|
|
"""
|
|
console.print(f"[cyan]Running migrations {direction}[/cyan]")
|
|
if steps:
|
|
console.print(f"[dim]Steps: {steps}[/dim]")
|
|
|
|
def seed(self, dataset: str = 'default'):
|
|
"""Seed database
|
|
|
|
Args:
|
|
dataset: Dataset to use (default, test, production)
|
|
"""
|
|
console.print(f"[green]Seeding database with {dataset} dataset[/green]")
|
|
|
|
def reset(self, confirm: bool = False):
|
|
"""Reset database
|
|
|
|
Args:
|
|
confirm: Confirm reset operation
|
|
"""
|
|
if not confirm:
|
|
console.print("[yellow]Use --confirm to reset database[/yellow]")
|
|
return
|
|
|
|
console.print("[red]Resetting database...[/red]")
|
|
|
|
def backup(self, output: Optional[str] = None):
|
|
"""Backup database
|
|
|
|
Args:
|
|
output: Output file path (default: auto-generated)
|
|
"""
|
|
filename = output or f"backup-{self._timestamp()}.sql"
|
|
console.print(f"[cyan]Creating backup: {filename}[/cyan]")
|
|
|
|
@staticmethod
|
|
def _timestamp():
|
|
from datetime import datetime
|
|
return datetime.now().strftime("%Y%m%d-%H%M%S")
|
|
|
|
class Config:
|
|
"""Configuration commands"""
|
|
|
|
def __init__(self, parent):
|
|
self.parent = parent
|
|
|
|
def get(self, key: str):
|
|
"""Get configuration value"""
|
|
console.print(f"[blue]{key}[/blue]: value")
|
|
|
|
def set(self, key: str, value: str):
|
|
"""Set configuration value"""
|
|
console.print(f"[green]✓[/green] Set {key} = {value}")
|
|
|
|
def list(self):
|
|
"""List all configuration"""
|
|
console.print("[bold]Configuration:[/bold]")
|
|
console.print(" api_key: abc123")
|
|
console.print(" endpoint: https://api.example.com")
|
|
|
|
def __init__(self):
|
|
self.version = "{{VERSION}}"
|
|
self.config_file = Path.home() / ".{{CLI_NAME_LOWER}}" / "config.json"
|
|
self.project = self.Project()
|
|
self.build = self.Build()
|
|
self.deploy = self.Deploy()
|
|
self.database = self.Database()
|
|
self.config = self.Config(self)
|
|
|
|
def version_info(self):
|
|
"""Display version information"""
|
|
console.print(f"[bold]{{CLI_NAME}}[/bold] version {self.version}")
|
|
return {"version": self.version}
|
|
|
|
def info(self):
|
|
"""Display CLI information"""
|
|
console.print(f"[bold]{{CLI_NAME}}[/bold] v{self.version}")
|
|
console.print(f"Config: {self.config_file}")
|
|
console.print("\n[bold]Available Commands:[/bold]")
|
|
console.print(" project - Project management")
|
|
console.print(" build - Build management")
|
|
console.print(" deploy - Deployment commands")
|
|
console.print(" database - Database operations")
|
|
console.print(" config - Configuration management")
|
|
|
|
|
|
def main():
|
|
fire.Fire({{CLASS_NAME}})
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|
|
|
|
|
|
# Usage examples:
|
|
# python {{CLI_NAME_LOWER}}.py project create my-app --template=react
|
|
# python {{CLI_NAME_LOWER}}.py project list
|
|
# python {{CLI_NAME_LOWER}}.py build start production --parallel
|
|
# python {{CLI_NAME_LOWER}}.py build clean --deep
|
|
# python {{CLI_NAME_LOWER}}.py deploy start staging --service=api
|
|
# python {{CLI_NAME_LOWER}}.py deploy rollback production --version=1.2.0
|
|
# python {{CLI_NAME_LOWER}}.py database migrate --direction=up
|
|
# python {{CLI_NAME_LOWER}}.py database backup
|
|
# python {{CLI_NAME_LOWER}}.py config get api_key
|