cl-preset 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

cl_preset/cli.py

@@ -10,17 +10,25 @@ from rich.console import Console
 from rich.panel import Panel
 
 from cl_preset.git_strategy import GitStrategyManager
+from cl_preset.interactive import InteractiveCLI
 from cl_preset.manager import PresetManager
 from cl_preset.models import PresetMetadata, PresetScope, PresetType
 
 console = Console()
 
 
-@click.group()
+@click.group(invoke_without_command=True)
 @click.version_option(version="0.1.0", prog_name="cl-preset")
-def main() -> None:
-    """cl-preset: Manage Claude Code configuration presets and strategies."""
-    pass
+@click.pass_context
+def main(ctx: click.Context) -> None:
+    """cl-preset: Manage Claude Code configuration presets and strategies.
+
+    Running without a command starts the interactive strategy selector.
+    """
+    # If no subcommand is provided, run interactive mode
+    if ctx.invoked_subcommand is None:
+        interactive = InteractiveCLI()
+        interactive.run()
 
 
 @main.command()
@@ -29,22 +37,22 @@ def main() -> None:
 @click.option("--version", "-v", default="1.0.0", help="Version (default: 1.0.0)")
 @click.option("--description", "-d", required=True, help="Description of the preset")
 @click.option("--author", "-a", default="", help="Author name")
-@click.option("--type", "-t",
-              type=click.Choice(["agent", "skill", "command", "strategy"]),
-              default="strategy",
-              help="Type of preset (default: strategy)")
-@click.option("--scope", "-s",
-              type=click.Choice(["global", "user", "project"]),
-              default="user",
-              help="Installation scope (default: user)")
+@click.option(
+    "--type",
+    "-t",
+    type=click.Choice(["agent", "skill", "command", "strategy"]),
+    default="strategy",
+    help="Type of preset (default: strategy)",
+)
+@click.option(
+    "--scope",
+    "-s",
+    type=click.Choice(["global", "user", "project"]),
+    default="user",
+    help="Installation scope (default: user)",
+)
 def install(
-    source_path: Path,
-    name: str,
-    version: str,
-    description: str,
-    author: str,
-    type: str,
-    scope: str
+    source_path: Path, name: str, version: str, description: str, author: str, type: str, scope: str
 ) -> None:
     """Install a preset from a source directory.
 
@@ -60,13 +68,11 @@ def install(
         version=version,
         description=description,
         author=author,
-        preset_type=PresetType(type)
+        preset_type=PresetType(type),
     )
 
     preset = manager.create_from_directory(
-        source_path=source_path,
-        metadata=metadata,
-        scope=PresetScope(scope)
+        source_path=source_path, metadata=metadata, scope=PresetScope(scope)
     )
 
     manager.install(preset)
@@ -74,9 +80,9 @@ def install(
 
 @main.command()
 @click.argument("name")
-@click.option("--scope", "-s",
-              type=click.Choice(["global", "user", "project"]),
-              help="Filter by scope")
+@click.option(
+    "--scope", "-s", type=click.Choice(["global", "user", "project"]), help="Filter by scope"
+)
 def uninstall(name: str, scope: str | None) -> None:
     """Uninstall a preset by name.
 
@@ -91,9 +97,9 @@ def uninstall(name: str, scope: str | None) -> None:
 
 
 @main.command()
-@click.option("--scope", "-s",
-              type=click.Choice(["global", "user", "project"]),
-              help="Filter by scope")
+@click.option(
+    "--scope", "-s", type=click.Choice(["global", "user", "project"]), help="Filter by scope"
+)
 @click.option("--json", "json_output", is_flag=True, help="Output as JSON")
 def list_cmd(scope: str | None, json_output: bool) -> None:
     """List installed presets.
@@ -114,9 +120,13 @@ def list_cmd(scope: str | None, json_output: bool) -> None:
 
 @main.command()
 @click.argument("name")
-@click.option("--output", "-o", type=click.Path(path_type=Path),
-              default=None,
-              help="Output path for preset metadata")
+@click.option(
+    "--output",
+    "-o",
+    type=click.Path(path_type=Path),
+    default=None,
+    help="Output path for preset metadata",
+)
 def init(name: str, output: Path | None) -> None:
     """Initialize a new preset scaffold.
 
@@ -177,14 +187,16 @@ Add your name here
         "author": "",
         "license": "MIT",
         "preset_type": "strategy",
-        "tags": []
+        "tags": [],
     }
     output.write_text(json.dumps(metadata, indent=2))
 
     console.print(f"[green]Created preset scaffold at {preset_dir}[/green]")
     console.print(f"[cyan]Metadata written to {output}[/cyan]")
     console.print("\nEdit the metadata and preset files, then install with:")
-    console.print(f"  cl-preset install {preset_dir} --name {name} --description 'Your description'")
+    console.print(
+        f"  cl-preset install {preset_dir} --name {name} --description 'Your description'"
+    )
 
 
 @main.command()
@@ -236,6 +248,7 @@ def info(name: str) -> None:
 # Git Strategy Commands
 # ============================================================================
 
+
 @click.group()
 def git() -> None:
     """Git strategy management commands."""
@@ -274,7 +287,8 @@ def git_info(name: str) -> None:
 
     # Handle strategy_type being either a string or enum (due to use_enum_values=True)
     strategy_type = (
-        strategy.strategy_type if isinstance(strategy.strategy_type, str)
+        strategy.strategy_type
+        if isinstance(strategy.strategy_type, str)
         else strategy.strategy_type.value
     )
 
@@ -327,8 +341,13 @@ def git_info(name: str) -> None:
 
 @git.command("export")
 @click.argument("name")
-@click.option("--output", "-o", type=click.Path(path_type=Path), default=None,
-              help="Output path (default: ./<name>.yaml)")
+@click.option(
+    "--output",
+    "-o",
+    type=click.Path(path_type=Path),
+    default=None,
+    help="Output path (default: ./<name>.yaml)",
+)
 def git_export(name: str, output: Path | None) -> None:
     """Export a git strategy to YAML file.
 
@@ -395,13 +414,12 @@ def git_apply(name: str, dry_run: bool) -> None:
         # Check if we're in a git repository
         try:
             result = subprocess.run(
-                ["git", "rev-parse", "--git-dir"],
-                capture_output=True,
-                text=True,
-                cwd=Path.cwd()
+                ["git", "rev-parse", "--git-dir"], capture_output=True, text=True, cwd=Path.cwd()
             )
             if result.returncode != 0:
-                console.print("[red]Not in a git repository. Initialize one first with 'git init'[/red]")
+                console.print(
+                    "[red]Not in a git repository. Initialize one first with 'git init'[/red]"
+                )
                 raise click.Abort()
 
             # Create .moai/config/sections directory

cl_preset/interactive.py

@@ -0,0 +1,347 @@
+"""
+Interactive CLI module for cl-preset package.
+
+Provides beautiful interactive prompts for strategy selection and installation.
+"""
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import questionary
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from cl_preset.git_strategy import GitStrategyManager
+from cl_preset.manager import PresetManager
+from cl_preset.models import PresetMetadata, PresetScope, PresetType
+
+if TYPE_CHECKING:
+    pass
+
+
+class InteractiveCLI:
+    """Interactive CLI for strategy selection and installation."""
+
+    def __init__(self) -> None:
+        """Initialize the interactive CLI."""
+        self.console = Console()
+        self.preset_manager = PresetManager()
+        self.git_manager = GitStrategyManager()
+
+    def show_welcome(self) -> None:
+        """Show welcome message with styled panel."""
+        welcome_text = Text()
+        welcome_text.append("Welcome to ", style="white")
+        welcome_text.append("cl-preset", style="bold cyan")
+        welcome_text.append("! ", style="white")
+        welcome_text.append("Interactive Strategy Management", style="dim")
+
+        panel = Panel(
+            welcome_text,
+            border_style="cyan",
+            padding=(1, 2),
+        )
+        self.console.print(panel)
+        self.console.print()
+
+    def get_available_strategies(self) -> list[dict]:
+        """
+        Get all available strategies (presets and git strategies).
+
+        Returns:
+            List of strategy dictionaries with name, type, and description
+        """
+        strategies = []
+
+        # Add built-in presets from examples directory
+        examples_path = Path(__file__).parent.parent.parent / "examples" / "presets"
+        if examples_path.exists():
+            for preset_dir in examples_path.iterdir():
+                if preset_dir.is_dir():
+                    readme_path = preset_dir / "README.md"
+                    description = ""
+                    if readme_path.exists():
+                        description = readme_path.read_text()
+                        # Extract first line after title
+                        for line in description.split("\n")[1:10]:
+                            line = line.strip()
+                            if line and not line.startswith("#"):
+                                description = line
+                                break
+
+                    strategies.append(
+                        {
+                            "name": preset_dir.name,
+                            "type": "preset",
+                            "description": description or f"Preset from {preset_dir.name}",
+                            "path": preset_dir,
+                        }
+                    )
+
+        # Add git strategies
+        git_strategies = self.git_manager.list_strategies(include_builtin=True)
+        for strategy in git_strategies:
+            strategies.append(
+                {
+                    "name": strategy["name"],
+                    "type": "git-strategy",
+                    "description": strategy["description"],
+                    "source": strategy.get("source", "builtin"),
+                }
+            )
+
+        return strategies
+
+    def select_strategy(self) -> dict | None:
+        """
+        Show interactive strategy selection prompt.
+
+        Returns:
+            Selected strategy dictionary or None if cancelled
+        """
+        strategies = self.get_available_strategies()
+
+        if not strategies:
+            self.console.print("[yellow]No strategies available.[/yellow]")
+            return None
+
+        # Format choices for questionary
+        choices = []
+        for strategy in strategies:
+            type_label = "[Preset]" if strategy["type"] == "preset" else "[Git]"
+            choice = questionary.Choice(
+                title=f"{type_label} {strategy['name']}",
+                value=strategy["name"],
+                description=strategy["description"][:70] + "..."
+                if len(strategy["description"]) > 70
+                else strategy["description"],
+            )
+            choices.append(choice)
+
+        # Add cancel option
+        choices.append(questionary.Separator())
+        choices.append(questionary.Choice(title="Cancel", value="cancel"))
+
+        selected_name = questionary.select(
+            "Select a strategy to install:",
+            choices=choices,
+            qmark=">",
+            pointer=">",
+        ).ask()
+
+        if selected_name == "cancel" or selected_name is None:
+            return None
+
+        # Find the selected strategy
+        for strategy in strategies:
+            if strategy["name"] == selected_name:
+                return strategy
+
+        return None
+
+    def select_scope(self) -> PresetScope | None:
+        """
+        Show interactive scope selection prompt.
+
+        Returns:
+            Selected PresetScope or None if cancelled
+        """
+        scope_choices = [
+            questionary.Choice(
+                title="global   (System-wide installation)",
+                value="global",
+                description="Install for all users on the system",
+            ),
+            questionary.Choice(
+                title="user     (User-level installation)",
+                value="user",
+                description="Install for current user only (recommended)",
+            ),
+            questionary.Choice(
+                title="project  (Project-specific installation)",
+                value="project",
+                description="Install for current project only",
+            ),
+            questionary.Choice(title="Cancel", value="cancel"),
+        ]
+
+        selected_scope = questionary.select(
+            "Select installation scope:",
+            choices=scope_choices,
+            qmark=">",
+            pointer=">",
+            default="user",
+        ).ask()
+
+        if selected_scope == "cancel" or selected_scope is None:
+            return None
+
+        return PresetScope(selected_scope)
+
+    def install_preset(self, strategy: dict, scope: PresetScope) -> bool:
+        """
+        Install a preset strategy.
+
+        Args:
+            strategy: Strategy dictionary
+            scope: Installation scope
+
+        Returns:
+            True if successful, False otherwise
+        """
+        from cl_preset.manager import Preset
+
+        if "path" not in strategy:
+            self.console.print("[red]Strategy path not found.[/red]")
+            return False
+
+        source_path = strategy["path"]
+
+        # Try to read preset metadata
+        metadata_path = source_path / "preset.json"
+        if metadata_path.exists():
+            import json
+
+            metadata_data = json.loads(metadata_path.read_text())
+            metadata = PresetMetadata(**metadata_data)
+        else:
+            # Create metadata from directory name
+            metadata = PresetMetadata(
+                name=strategy["name"],
+                version="1.0.0",
+                description=strategy["description"],
+                preset_type=PresetType.STRATEGY,
+            )
+
+        preset = Preset(
+            config={
+                "metadata": metadata,
+                "source_path": source_path,
+                "scope": scope,
+            }
+        )
+
+        return self.preset_manager.install(preset)
+
+    def apply_git_strategy(self, strategy: dict, scope: PresetScope) -> bool:
+        """
+        Apply a git strategy.
+
+        Args:
+            strategy: Strategy dictionary
+            scope: Installation scope (for git strategies, affects where config is written)
+
+        Returns:
+            True if successful, False otherwise
+        """
+        import subprocess
+
+        name = strategy["name"]
+        git_strategy = self.git_manager.get_strategy(name)
+
+        if git_strategy is None:
+            self.console.print(f"[red]Strategy '{name}' not found.[/red]")
+            return False
+
+        self.console.print(f"[cyan]Applying git strategy: {git_strategy.name}[/cyan]")
+        self.console.print(f"[dim]{git_strategy.description}[/dim]")
+        self.console.print()
+
+        # Check if we're in a git repository
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--git-dir"],
+                capture_output=True,
+                text=True,
+                cwd=Path.cwd(),
+            )
+            if result.returncode != 0:
+                self.console.print(
+                    "[red]Not in a git repository. Initialize one first with 'git init'[/red]"
+                )
+                return False
+
+        except Exception as e:
+            self.console.print(f"[red]Error checking git repository: {e}[/red]")
+            return False
+
+        # Create .moai/config/sections directory
+        config_dir = Path.cwd() / ".moai" / "config" / "sections"
+        config_dir.mkdir(parents=True, exist_ok=True)
+
+        # Export strategy config
+        strategy_file = config_dir / "git-strategy.yaml"
+        success = self.git_manager.export_strategy_yaml(name, strategy_file)
+
+        if success:
+            self.console.print()
+            self.console.print(
+                Panel(
+                    f"[green]Strategy configuration written to {strategy_file}[/green]\n\n"
+                    f"Main branch: [cyan]{git_strategy.main_branch}[/cyan]\n"
+                    f"Feature pattern: [cyan]{git_strategy.branch_patterns.feature}[/cyan]",
+                    title="Git Strategy Applied",
+                    border_style="green",
+                )
+            )
+            return True
+
+        return False
+
+    def run(self) -> None:
+        """Run the interactive CLI flow."""
+        self.show_welcome()
+
+        # Step 1: Select strategy
+        strategy = self.select_strategy()
+        if strategy is None:
+            self.console.print("[dim]Cancelled.[/dim]")
+            return
+
+        self.console.print()
+
+        # Step 2: Select scope
+        scope = self.select_scope()
+        if scope is None:
+            self.console.print("[dim]Cancelled.[/dim]")
+            return
+
+        self.console.print()
+
+        # Step 3: Install/Apply
+        strategy_type = strategy.get("type", "")
+        strategy_name = strategy["name"]
+
+        if strategy_type == "preset":
+            self.console.print(f"[cyan]Installing {strategy_name} to {scope.value} scope...[/cyan]")
+            success = self.install_preset(strategy, scope)
+        else:  # git-strategy
+            self.console.print(
+                f"[cyan]Applying git strategy {strategy_name} to {scope.value} scope...[/cyan]"
+            )
+            success = self.apply_git_strategy(strategy, scope)
+
+        self.console.print()
+
+        # Step 4: Show result
+        if success:
+            self.console.print(
+                Panel(
+                    "[bold green]Strategy installed successfully![/bold green]\n\n"
+                    f"Type: [cyan]{strategy_type}[/cyan]\n"
+                    f"Name: [cyan]{strategy_name}[/cyan]\n"
+                    f"Scope: [cyan]{scope.value}[/cyan]",
+                    title="Success",
+                    border_style="green",
+                )
+            )
+        else:
+            self.console.print(
+                Panel(
+                    "[bold red]Installation failed.[/bold red]\n\n"
+                    "Please check the error messages above and try again.",
+                    title="Error",
+                    border_style="red",
+                )
+            )

{cl_preset-0.1.0.dist-info → cl_preset-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cl-preset
-Version: 0.1.0
+Version: 0.2.0
 Summary: A package for managing Claude Code configuration presets and strategies
 Project-URL: Homepage, https://github.com/yarang/cl-preset
 Project-URL: Documentation, https://github.com/yarang/cl-preset#readme
@@ -13,6 +13,7 @@ Requires-Python: >=3.10
 Requires-Dist: click>=8.1.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: questionary>=2.0.0
 Requires-Dist: rich>=13.0.0
 Provides-Extra: dev
 Requires-Dist: mypy>=1.0.0; extra == 'dev'
@@ -52,6 +53,26 @@ uv pip install cl-preset
 
 ## Quick Start
 
+### Interactive Mode (Recommended)
+
+The easiest way to get started is the interactive mode:
+
+```bash
+cl-preset
+```
+
+This will launch an interactive selector that guides you through:
+1. **Welcome Screen** - Beautiful introduction to cl-preset
+2. **Strategy Selection** - Browse and select from available strategies (presets and git strategies)
+3. **Scope Selection** - Choose installation scope (global, user, or project)
+4. **Installation** - Automatic installation with progress feedback
+
+Available strategies include:
+- **web-development-strategy** - Preset for web development with FastAPI and React
+- **dual-repo-git-strategy** - Dev/Release repository separation workflow
+- **github-flow-git-strategy** - Simple branch-based workflow
+- **git-flow-git-strategy** - Feature/release/hotfix branching model
+
 ### Create a New Preset
 
 ```bash

{cl_preset-0.1.0.dist-info → cl_preset-0.2.0.dist-info}/RECORD

@@ -1,12 +1,13 @@
 cl_preset/__init__.py,sha256=rGIQS-1vuBzwnPj7NtC2N8hRIoMHUmSEMbWfnhjHjKQ,462
-cl_preset/cli.py,sha256=XldMCDe1-HEeX1IQQZU0J-2ECABpWLbq5yWXd-eIswY,15762
+cl_preset/cli.py,sha256=f-WqvlfomDQbAaCmSfWLMtfs9KP-jm9E66NZEJC80OM,16003
 cl_preset/git_strategy.py,sha256=FuiNUMaTwAyNA5nS8EvLhAntldJOBgRMO5FrUUgJ1K4,17375
+cl_preset/interactive.py,sha256=O20q7GLjNvtY-4voRsqHIBM_b484IYuxOu8InzviWh8,11509
 cl_preset/manager.py,sha256=OojhbTxXZ0cPt44PPZE1NqSBAXsGssB6ZuYyfoKwPa4,6192
 cl_preset/models.py,sha256=UWx68lb0ac3VFCRpj3zOqc7qGwJpbX2EZcw_OYHBKWg,2241
 cl_preset/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cl_preset/templates/git_strategy_template.yaml,sha256=2oF97WOHq2crSRoaLzWodBvzANmQ-9FPzM-A0jui2iw,1328
-cl_preset-0.1.0.dist-info/METADATA,sha256=Oon9IbfPw1sIDSGnLyYMVFv4-3Zi6wiwdcFTMDtIn38,8939
-cl_preset-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-cl_preset-0.1.0.dist-info/entry_points.txt,sha256=JAW_u5lrqylE516FDGO5audUKuCsxGYypQ7d6cA_9uY,49
-cl_preset-0.1.0.dist-info/licenses/LICENSE,sha256=5b1_XulzMGBmVHcNKAHMo0Mqfqm5xJix4O5AErotK0o,1069
-cl_preset-0.1.0.dist-info/RECORD,,
+cl_preset-0.2.0.dist-info/METADATA,sha256=ohb0hWBIjOvk0zXFQkBr7Uf8QCnl11u8AEzTuQwwEAo,9782
+cl_preset-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+cl_preset-0.2.0.dist-info/entry_points.txt,sha256=JAW_u5lrqylE516FDGO5audUKuCsxGYypQ7d6cA_9uY,49
+cl_preset-0.2.0.dist-info/licenses/LICENSE,sha256=5b1_XulzMGBmVHcNKAHMo0Mqfqm5xJix4O5AErotK0o,1069
+cl_preset-0.2.0.dist-info/RECORD,,