codeframe-ai 0.9.0__py3-none-any.whl

codeframe/cli/env_commands.py

@@ -0,0 +1,409 @@
+"""CLI environment validation commands.
+
+This module provides commands for:
+- Checking environment health
+- Running comprehensive diagnostics
+- Installing missing tools
+- Auto-installing all missing tools
+
+Usage:
+    codeframe env check           # Quick validation
+    codeframe env doctor          # Comprehensive diagnostics
+    codeframe env install-missing pytest  # Install specific tool
+    codeframe env auto-install --yes      # Install all missing
+"""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from codeframe.core.environment import (
+    EnvironmentValidator,
+    ToolStatus,
+)
+from codeframe.core.installer import ToolInstaller
+
+
+console = Console()
+
+env_app = typer.Typer(
+    name="env",
+    help="Environment validation and tool management",
+    no_args_is_help=True,
+)
+
+
+@env_app.command()
+def check(
+    project: Optional[str] = typer.Option(
+        None, "--project", "-p", help="Project directory to validate"
+    ),
+):
+    """Quick environment validation.
+
+    Checks if required tools are installed and shows health score.
+
+    Examples:
+
+        codeframe env check
+
+        codeframe env check --project ./my-project
+    """
+    # Determine project path
+    if project:
+        project_path = Path(project)
+        if not project_path.exists():
+            console.print(f"[red]Error:[/red] Project path not found: {project}")
+            raise typer.Exit(1)
+    else:
+        project_path = Path.cwd()
+
+    # Run validation
+    validator = EnvironmentValidator()
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+        transient=True,
+    ) as progress:
+        progress.add_task("Checking environment...", total=None)
+        result = validator.validate_environment(project_path)
+
+    # Display results
+    health_pct = int(result.health_score * 100)
+
+    if result.is_healthy:
+        health_color = "green"
+        health_status = "Healthy"
+    elif result.health_score >= 0.5:
+        health_color = "yellow"
+        health_status = "Partial"
+    else:
+        health_color = "red"
+        health_status = "Unhealthy"
+
+    console.print()
+    console.print(f"[bold]Project Type:[/bold] {result.project_type}")
+    console.print(f"[bold]Health Score:[/bold] [{health_color}]{health_pct}%[/{health_color}] ({health_status})")
+    console.print()
+
+    # Show tool summary
+    available_count = sum(1 for t in result.detected_tools.values() if t.is_available)
+    total_count = len(result.detected_tools)
+    console.print(f"[bold]Tools:[/bold] {available_count}/{total_count} available")
+
+    if result.missing_tools:
+        console.print(f"[bold]Missing (required):[/bold] [red]{', '.join(result.missing_tools)}[/red]")
+
+    if result.optional_missing:
+        console.print(f"[bold]Missing (optional):[/bold] [yellow]{', '.join(result.optional_missing)}[/yellow]")
+
+    console.print()
+
+    # Show quick recommendations
+    if result.recommendations:
+        console.print("[bold]Quick fix:[/bold]")
+        for rec in result.recommendations[:3]:  # Show top 3
+            console.print(f"  • {rec}")
+        console.print()
+        console.print("[dim]Run 'codeframe env doctor' for full diagnostics[/dim]")
+
+    if not result.is_healthy:
+        raise typer.Exit(1)
+
+
+@env_app.command()
+def doctor(
+    project: Optional[str] = typer.Option(
+        None, "--project", "-p", help="Project directory to analyze"
+    ),
+):
+    """Comprehensive environment health analysis.
+
+    Provides detailed diagnostics including version compatibility,
+    recommendations, and potential conflicts.
+
+    Examples:
+
+        codeframe env doctor
+
+        codeframe env doctor --project ./my-project
+    """
+    # Determine project path
+    if project:
+        project_path = Path(project)
+        if not project_path.exists():
+            console.print(f"[red]Error:[/red] Project path not found: {project}")
+            raise typer.Exit(1)
+    else:
+        project_path = Path.cwd()
+
+    # Run validation
+    validator = EnvironmentValidator()
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+        transient=True,
+    ) as progress:
+        progress.add_task("Running comprehensive diagnostics...", total=None)
+        result = validator.validate_environment(project_path)
+
+    # Display header
+    health_pct = int(result.health_score * 100)
+    console.print()
+    console.print(Panel(
+        f"[bold]Environment Health Report[/bold]\n"
+        f"Project: {project_path.name}\n"
+        f"Type: {result.project_type}\n"
+        f"Score: {health_pct}%",
+        title="CodeFRAME Doctor",
+    ))
+
+    # Tools table
+    table = Table(title="Detected Tools")
+    table.add_column("Tool", style="cyan")
+    table.add_column("Status", style="green")
+    table.add_column("Version")
+    table.add_column("Path", style="dim")
+
+    for name, info in sorted(result.detected_tools.items()):
+        if info.status == ToolStatus.AVAILABLE:
+            status = "[green]Available[/green]"
+        elif info.status == ToolStatus.NOT_FOUND:
+            status = "[red]Not Found[/red]"
+        elif info.status == ToolStatus.VERSION_INCOMPATIBLE:
+            status = "[yellow]Incompatible[/yellow]"
+        else:
+            status = "[dim]Error[/dim]"
+
+        table.add_row(
+            name,
+            status,
+            info.version or "-",
+            info.path or "-",
+        )
+
+    console.print()
+    console.print(table)
+
+    # Warnings
+    if result.warnings:
+        console.print()
+        console.print("[bold yellow]Warnings:[/bold yellow]")
+        for warning in result.warnings:
+            console.print(f"  [yellow]⚠[/yellow] {warning}")
+
+    # Conflicts
+    if result.conflicts:
+        console.print()
+        console.print("[bold red]Conflicts:[/bold red]")
+        for conflict in result.conflicts:
+            console.print(f"  [red]✗[/red] {conflict}")
+
+    # Recommendations
+    if result.recommendations:
+        console.print()
+        console.print("[bold]Recommendations:[/bold]")
+        for rec in result.recommendations:
+            console.print(f"  • {rec}")
+
+    # Stale worktree check
+    try:
+        from codeframe.core.worktrees import WorktreeRegistry
+        stale = WorktreeRegistry().list_stale(project_path)
+        if stale:
+            console.print()
+            console.print("[bold yellow]Stale Worktrees:[/bold yellow]")
+            for entry in stale:
+                console.print(
+                    f"  [yellow]⚠[/yellow] task [cyan]{entry['task_id']}[/cyan] "
+                    f"(pid {entry.get('pid', '?')} no longer running)"
+                )
+            console.print()
+            console.print(
+                "[dim]To clean up, run:[/dim] codeframe work batch run --all-ready "
+                "[dim](auto-cleans on next run)[/dim]"
+            )
+            console.print(
+                "[dim]Or remove manually:[/dim] rm -rf .codeframe/worktrees/"
+            )
+    except Exception:
+        pass  # Worktree registry is optional; never fail doctor over it
+
+    console.print()
+
+    if not result.is_healthy:
+        console.print("[bold]To fix issues, run:[/bold]")
+        console.print("  codeframe env auto-install --yes")
+        console.print()
+        raise typer.Exit(1)
+
+
+@env_app.command("install-missing")
+def install_missing(
+    tool: str = typer.Argument(..., help="Name of the tool to install"),
+    yes: bool = typer.Option(
+        False, "--yes", "-y", help="Skip confirmation prompt"
+    ),
+):
+    """Install a specific missing tool.
+
+    Attempts to install the specified tool using the appropriate
+    package manager (pip, npm, cargo, or system).
+
+    Examples:
+
+        codeframe env install-missing pytest
+
+        codeframe env install-missing eslint --yes
+    """
+    installer = ToolInstaller()
+
+    # Check if we can install this tool
+    if not installer.can_install(tool):
+        console.print(f"[red]Error:[/red] Cannot install '{tool}' - no installer available")
+        console.print()
+        console.print("This tool may need manual installation.")
+        console.print(f"Try: [dim]{installer.get_install_command(tool) or f'Install {tool} manually'}[/dim]")
+        raise typer.Exit(1)
+
+    # Show install command
+    install_cmd = installer.get_install_command(tool)
+    console.print(f"[bold]Tool:[/bold] {tool}")
+    console.print(f"[bold]Command:[/bold] {install_cmd}")
+    console.print()
+
+    # Confirm if needed
+    if not yes:
+        confirmed = typer.confirm("Proceed with installation?")
+        if not confirmed:
+            console.print("[yellow]Installation cancelled[/yellow]")
+            raise typer.Exit(0)
+
+    # Install
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+        transient=True,
+    ) as progress:
+        progress.add_task(f"Installing {tool}...", total=None)
+        result = installer.install_tool(tool, confirm=False)
+
+    # Report result
+    if result.success:
+        console.print(f"[green]✓[/green] {result.message}")
+    else:
+        console.print(f"[red]✗[/red] {result.message}")
+        if result.error_output:
+            console.print()
+            console.print("[dim]Error output:[/dim]")
+            console.print(result.error_output[:500])  # Truncate long errors
+        raise typer.Exit(1)
+
+
+@env_app.command("auto-install")
+def auto_install(
+    project: Optional[str] = typer.Option(
+        None, "--project", "-p", help="Project directory"
+    ),
+    yes: bool = typer.Option(
+        False, "--yes", "-y", help="Skip confirmation prompt"
+    ),
+):
+    """Automatically install all missing required tools.
+
+    Detects missing tools for the project and installs them
+    using the appropriate package managers.
+
+    Examples:
+
+        codeframe env auto-install
+
+        codeframe env auto-install --yes
+
+        codeframe env auto-install --project ./my-project --yes
+    """
+    # Determine project path
+    if project:
+        project_path = Path(project)
+        if not project_path.exists():
+            console.print(f"[red]Error:[/red] Project path not found: {project}")
+            raise typer.Exit(1)
+    else:
+        project_path = Path.cwd()
+
+    # Get missing tools
+    validator = EnvironmentValidator()
+    validation_result = validator.validate_environment(project_path)
+
+    if not validation_result.missing_tools:
+        console.print("[green]✓[/green] All required tools are already installed!")
+        console.print()
+        console.print("[dim]Nothing to install.[/dim]")
+        return
+
+    # Show what will be installed
+    console.print("[bold]Missing tools to install:[/bold]")
+    for tool in validation_result.missing_tools:
+        console.print(f"  • {tool}")
+    console.print()
+
+    # Confirm if needed
+    if not yes:
+        confirmed = typer.confirm(f"Install {len(validation_result.missing_tools)} tool(s)?")
+        if not confirmed:
+            console.print("[yellow]Installation cancelled[/yellow]")
+            raise typer.Exit(0)
+
+    # Install each tool
+    installer = ToolInstaller()
+    results = []
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Installing tools...", total=len(validation_result.missing_tools))
+
+        for tool in validation_result.missing_tools:
+            progress.update(task, description=f"Installing {tool}...")
+
+            if installer.can_install(tool):
+                result = installer.install_tool(tool, confirm=False)
+                results.append(result)
+            else:
+                results.append(None)
+
+            progress.advance(task)
+
+    console.print()
+
+    # Report results
+    success_count = sum(1 for r in results if r and r.success)
+    fail_count = len(results) - success_count
+
+    console.print("[bold]Results:[/bold]")
+    for i, tool in enumerate(validation_result.missing_tools):
+        result = results[i]
+        if result is None:
+            console.print(f"  [yellow]⚠[/yellow] {tool}: No installer available")
+        elif result.success:
+            console.print(f"  [green]✓[/green] {tool}: Installed")
+        else:
+            console.print(f"  [red]✗[/red] {tool}: {result.message}")
+
+    console.print()
+    console.print(f"[bold]Summary:[/bold] {success_count} installed, {fail_count} failed")
+
+    if fail_count > 0:
+        raise typer.Exit(1)

codeframe/cli/helpers.py

@@ -0,0 +1,56 @@
+"""Shared CLI helper utilities.
+
+This module provides common utilities used across CLI command modules:
+- require_auth: Authentication check for API client
+- format_date: Safe date string formatting
+- console: Shared Rich Console instance
+
+Usage:
+    from codeframe.cli.helpers import require_auth, format_date, console
+"""
+
+import typer
+from rich.console import Console
+
+from codeframe.cli.api_client import APIClient
+
+# Shared console instance for all CLI modules
+console = Console()
+
+
+def require_auth(client: APIClient) -> None:
+    """Check if client is authenticated, exit with error if not.
+
+    Args:
+        client: APIClient instance to check for authentication
+
+    Raises:
+        typer.Exit: If client is not authenticated (exit code 1)
+    """
+    if not client.token:
+        console.print("[yellow]Not logged in.[/yellow]")
+        console.print("Please log in: codeframe auth login")
+        raise typer.Exit(1)
+
+
+def format_date(date_str: str | None, length: int = 10) -> str:
+    """Safely extract date portion from an ISO datetime string.
+
+    Args:
+        date_str: ISO datetime string (e.g., "2024-01-15T10:30:00Z") or None
+        length: Number of characters to extract (default 10 for YYYY-MM-DD)
+
+    Returns:
+        Truncated date string or empty string if input is falsy or too short
+
+    Examples:
+        >>> format_date("2024-01-15T10:30:00Z")
+        '2024-01-15'
+        >>> format_date(None)
+        ''
+        >>> format_date("short")
+        ''
+    """
+    if not date_str or len(date_str) < length:
+        return ""
+    return date_str[:length]

codeframe/cli/hooks_commands.py

@@ -0,0 +1,208 @@
+"""CLI workspace lifecycle hooks management.
+
+Usage:
+    codeframe hooks show              # Display configured hooks
+    codeframe hooks run <hook_name>   # Manually trigger a hook
+    codeframe hooks set <name> <cmd>  # Set a hook command
+    codeframe hooks clear <name>      # Remove a hook
+"""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+hooks_app = typer.Typer(
+    name="hooks",
+    help="Workspace lifecycle hooks management",
+    no_args_is_help=True,
+)
+
+VALID_HOOK_NAMES = [
+    "after_init",
+    "before_task",
+    "after_task_success",
+    "after_task_failure",
+    "before_remove",
+]
+
+
+@hooks_app.command("show")
+def hooks_show(
+    workspace_path: Optional[Path] = typer.Option(
+        None, "--workspace", "-w",
+        help="Workspace path (defaults to current directory)",
+    ),
+) -> None:
+    """Display configured hooks from .codeframe/config.yaml."""
+    from codeframe.core.config import load_environment_config
+
+    from codeframe.core.workspace import get_workspace
+    path = workspace_path or Path.cwd()
+    try:
+        ws = get_workspace(path)
+        path = ws.repo_path
+    except (FileNotFoundError, ValueError):
+        pass  # Workspace not initialized; fall back to raw path
+    config = load_environment_config(path)
+
+    if not config:
+        console.print("[yellow]No workspace configuration found.[/yellow]")
+        console.print("Run 'codeframe init .' first.")
+        raise typer.Exit(1)
+
+    table = Table(title="Workspace Hooks")
+    table.add_column("Hook Point", style="cyan")
+    table.add_column("Command", style="dim")
+    table.add_column("Status")
+
+    for hook_name in VALID_HOOK_NAMES:
+        command = getattr(config.hooks, hook_name, None)
+        if command:
+            table.add_row(hook_name, command, "[green]configured[/green]")
+        else:
+            table.add_row(hook_name, "-", "[dim]not set[/dim]")
+
+    table.add_row("", "", "")
+    table.add_row("hook_timeout", f"{config.hooks.hook_timeout}s", "[dim]default[/dim]")
+
+    console.print(table)
+
+
+@hooks_app.command("run")
+def hooks_run(
+    hook_name: str = typer.Argument(..., help="Hook name to execute"),
+    task_id: str = typer.Option("", "--task-id", help="Task ID for template rendering"),
+    task_title: str = typer.Option("", "--task-title", help="Task title for template rendering"),
+    workspace_path: Optional[Path] = typer.Option(
+        None, "--workspace", "-w",
+        help="Workspace path (defaults to current directory)",
+    ),
+) -> None:
+    """Manually trigger a named hook."""
+    from codeframe.core.config import load_environment_config
+    from codeframe.core.hooks import HookContext, execute_hook
+
+    if hook_name not in VALID_HOOK_NAMES:
+        console.print(f"[red]Error:[/red] Invalid hook name '{hook_name}'")
+        console.print(f"Valid hooks: {', '.join(VALID_HOOK_NAMES)}")
+        raise typer.Exit(1)
+
+    from codeframe.core.workspace import get_workspace
+    path = workspace_path or Path.cwd()
+    try:
+        ws = get_workspace(path)
+        path = ws.repo_path
+    except (FileNotFoundError, ValueError):
+        pass  # Workspace not initialized; fall back to raw path
+    config = load_environment_config(path)
+
+    if not config:
+        console.print("[yellow]No workspace configuration found.[/yellow]")
+        raise typer.Exit(1)
+
+    ctx = HookContext(
+        task_id=task_id,
+        task_title=task_title,
+        task_status="manual",
+        workspace_path=str(path),
+    )
+
+    result = execute_hook(hook_name, config, path, ctx, abort_on_failure=False)
+
+    if result is None:
+        console.print(f"[yellow]Hook '{hook_name}' is not configured.[/yellow]")
+        return
+
+    if result.success:
+        console.print(f"[green]Hook '{hook_name}' succeeded[/green] ({result.duration_ms}ms)")
+    else:
+        console.print(f"[red]Hook '{hook_name}' failed[/red] ({result.duration_ms}ms)")
+        if result.timed_out:
+            console.print("  [yellow]Timed out[/yellow]")
+
+    if result.stdout.strip():
+        console.print(f"  stdout: {result.stdout.strip()[:500]}")
+    if result.stderr.strip():
+        console.print(f"  stderr: {result.stderr.strip()[:500]}")
+
+    if not result.success:
+        raise typer.Exit(1)
+
+
+@hooks_app.command("set")
+def hooks_set(
+    hook_name: str = typer.Argument(..., help="Hook name to configure"),
+    command: str = typer.Argument(..., help="Shell command template"),
+    workspace_path: Optional[Path] = typer.Option(
+        None, "--workspace", "-w",
+        help="Workspace path (defaults to current directory)",
+    ),
+) -> None:
+    """Set or update a hook command."""
+    from codeframe.core.config import (
+        load_environment_config,
+        save_environment_config,
+        get_default_environment_config,
+    )
+
+    if hook_name not in VALID_HOOK_NAMES:
+        console.print(f"[red]Error:[/red] Invalid hook name '{hook_name}'")
+        console.print(f"Valid hooks: {', '.join(VALID_HOOK_NAMES)}")
+        raise typer.Exit(1)
+
+    from codeframe.core.workspace import get_workspace
+    path = workspace_path or Path.cwd()
+    try:
+        ws = get_workspace(path)
+        path = ws.repo_path
+    except (FileNotFoundError, ValueError):
+        pass  # Workspace not initialized; fall back to raw path
+    config = load_environment_config(path) or get_default_environment_config()
+
+    setattr(config.hooks, hook_name, command)
+    save_environment_config(path, config)
+
+    console.print(f"[green]Hook '{hook_name}' set to:[/green] {command}")
+
+
+@hooks_app.command("clear")
+def hooks_clear(
+    hook_name: str = typer.Argument(..., help="Hook name to clear"),
+    workspace_path: Optional[Path] = typer.Option(
+        None, "--workspace", "-w",
+        help="Workspace path (defaults to current directory)",
+    ),
+) -> None:
+    """Remove a hook."""
+    from codeframe.core.config import (
+        load_environment_config,
+        save_environment_config,
+    )
+
+    if hook_name not in VALID_HOOK_NAMES:
+        console.print(f"[red]Error:[/red] Invalid hook name '{hook_name}'")
+        console.print(f"Valid hooks: {', '.join(VALID_HOOK_NAMES)}")
+        raise typer.Exit(1)
+
+    from codeframe.core.workspace import get_workspace
+    path = workspace_path or Path.cwd()
+    try:
+        ws = get_workspace(path)
+        path = ws.repo_path
+    except (FileNotFoundError, ValueError):
+        pass  # Workspace not initialized; fall back to raw path
+    config = load_environment_config(path)
+
+    if not config:
+        console.print("[yellow]No workspace configuration found.[/yellow]")
+        raise typer.Exit(1)
+
+    setattr(config.hooks, hook_name, None)
+    save_environment_config(path, config)
+
+    console.print(f"[green]Hook '{hook_name}' cleared.[/green]")