scc-cli 1.5.3__py3-none-any.whl

scc_cli/commands/launch/workspace.py

@@ -0,0 +1,339 @@
+"""
+Workspace validation and preparation functions.
+
+This module handles workspace-related operations for the launch command:
+- Path validation and resolution
+- Worktree creation and mounting
+- Dependency installation
+- Team-workspace association resolution
+"""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import typer
+from rich.status import Status
+
+from ... import config, deps, git
+from ... import platform as platform_module
+from ...cli_common import console
+from ...confirm import Confirm
+from ...core.constants import WORKTREE_BRANCH_PREFIX
+from ...core.errors import NotAGitRepoError, WorkspaceNotFoundError
+from ...core.exit_codes import EXIT_CANCELLED
+from ...core.workspace import ResolverResult
+from ...output_mode import print_human
+from ...panels import create_info_panel, create_success_panel, create_warning_panel
+from ...theme import Indicators, Spinners
+from ...ui.gate import is_interactive_allowed
+
+if TYPE_CHECKING:
+    pass
+
+
+@dataclass
+class LaunchContext:
+    """Display-focused launch context wrapping ResolverResult.
+
+    This dataclass is used for rendering the launch panel and JSON output.
+    It combines resolver results with session-specific information.
+    """
+
+    resolver_result: ResolverResult
+    team: str | None
+    branch: str | None
+    session_name: str | None
+    mode: str  # "new" or "resume"
+
+    @property
+    def workspace_root(self) -> Path:
+        """Workspace root (WR)."""
+        return self.resolver_result.workspace_root
+
+    @property
+    def entry_dir(self) -> Path:
+        """Entry directory (ED)."""
+        return self.resolver_result.entry_dir
+
+    @property
+    def mount_root(self) -> Path:
+        """Mount root (MR)."""
+        return self.resolver_result.mount_root
+
+    @property
+    def container_workdir(self) -> str:
+        """Container working directory (CW)."""
+        return self.resolver_result.container_workdir
+
+    @property
+    def entry_dir_relative(self) -> str:
+        """Entry dir path relative to workspace root."""
+        try:
+            return str(self.entry_dir.relative_to(self.workspace_root))
+        except ValueError:
+            return str(self.entry_dir)
+
+    @property
+    def is_mount_expanded(self) -> bool:
+        """Whether mount was expanded for worktree support."""
+        return self.resolver_result.is_mount_expanded
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for JSON output."""
+        return {
+            "workspace_root": str(self.workspace_root),
+            "entry_dir": str(self.entry_dir),
+            "entry_dir_relative": self.entry_dir_relative,
+            "mount_root": str(self.mount_root),
+            "container_workdir": self.container_workdir,
+            "is_mount_expanded": self.is_mount_expanded,
+            "team": self.team,
+            "branch": self.branch,
+            "session_name": self.session_name,
+            "mode": self.mode,
+            "reason": self.resolver_result.reason,
+        }
+
+
+def validate_and_resolve_workspace(
+    workspace: str | None,
+    *,
+    no_interactive: bool = False,
+    allow_suspicious: bool = False,
+    json_mode: bool = False,
+) -> Path | None:
+    """
+    Validate workspace path and handle platform-specific warnings.
+
+    Args:
+        workspace: Workspace path string.
+        no_interactive: If True, fail fast instead of prompting.
+        allow_suspicious: If True, allow suspicious workspaces in non-interactive mode.
+        json_mode: If True, output is JSON (suppress Rich panels).
+
+    Raises:
+        WorkspaceNotFoundError: If workspace path doesn't exist.
+        UsageError: If workspace is suspicious in non-interactive mode without --allow-suspicious-workspace.
+        typer.Exit: If user declines to continue after warnings.
+    """
+    from ...core.errors import UsageError
+    from ...services.workspace.suspicious import get_suspicious_reason, is_suspicious_directory
+
+    if workspace is None:
+        return None
+
+    workspace_path = Path(workspace).expanduser().resolve()
+
+    if not workspace_path.exists():
+        raise WorkspaceNotFoundError(path=str(workspace_path))
+
+    # Check for suspicious workspace (home, /tmp, system directories)
+    if is_suspicious_directory(workspace_path):
+        reason = get_suspicious_reason(workspace_path) or "Suspicious directory"
+
+        # If --allow-suspicious-workspace is set, skip confirmation entirely
+        if allow_suspicious:
+            print_human(
+                f"[yellow]Warning:[/yellow] {reason}",
+                file=sys.stderr,
+                highlight=False,
+            )
+        elif is_interactive_allowed(json_mode=json_mode, no_interactive_flag=no_interactive):
+            # Interactive mode: warn but allow user to continue
+            console.print()
+            console.print(
+                create_warning_panel(
+                    "Suspicious Workspace",
+                    reason,
+                    "Consider using a project-specific directory instead.",
+                )
+            )
+            console.print()
+            if not Confirm.ask("[cyan]Continue anyway?[/cyan]", default=True):
+                console.print("[dim]Cancelled.[/dim]")
+                raise typer.Exit(EXIT_CANCELLED)
+        else:
+            # Non-interactive mode without flag: block
+            raise UsageError(
+                user_message=f"Refusing to start in suspicious directory: {workspace_path}\n  → {reason}",
+                suggested_action=(
+                    "Either:\n"
+                    f"  • Run: scc start --allow-suspicious-workspace {workspace_path}\n"
+                    "  • Run: scc start --interactive (to choose a different workspace)\n"
+                    "  • Run from a project directory inside a git repository"
+                ),
+            )
+
+    # WSL2 performance warning
+    if platform_module.is_wsl2():
+        is_optimal, warning = platform_module.check_path_performance(workspace_path)
+        if not is_optimal and warning:
+            print_human(
+                "[yellow]Warning:[/yellow] Workspace is on the Windows filesystem."
+                " Performance may be slow.",
+                file=sys.stderr,
+                highlight=False,
+            )
+            if is_interactive_allowed(no_interactive_flag=no_interactive):
+                console.print()
+                console.print(
+                    create_warning_panel(
+                        "Performance Warning",
+                        "Your workspace is on the Windows filesystem.",
+                        "For better performance, move to ~/projects inside WSL.",
+                    )
+                )
+                console.print()
+                if not Confirm.ask("[cyan]Continue anyway?[/cyan]", default=True):
+                    console.print("[dim]Cancelled.[/dim]")
+                    raise typer.Exit(EXIT_CANCELLED)
+
+    return workspace_path
+
+
+def prepare_workspace(
+    workspace_path: Path | None,
+    worktree_name: str | None,
+    install_deps: bool,
+) -> Path | None:
+    """
+    Prepare workspace: create worktree, install deps, check git safety.
+
+    Returns:
+        The (possibly updated) workspace path after worktree creation.
+    """
+    if workspace_path is None:
+        return None
+
+    # Handle worktree creation
+    if worktree_name:
+        workspace_path = git.create_worktree(workspace_path, worktree_name)
+        console.print(
+            create_success_panel(
+                "Worktree Created",
+                {
+                    "Path": str(workspace_path),
+                    "Branch": f"{WORKTREE_BRANCH_PREFIX}{worktree_name}",
+                },
+            )
+        )
+
+    # Install dependencies if requested
+    if install_deps:
+        with Status(
+            "[cyan]Installing dependencies...[/cyan]", console=console, spinner=Spinners.SETUP
+        ):
+            success = deps.auto_install_dependencies(workspace_path)
+        if success:
+            console.print(f"[green]{Indicators.get('PASS')} Dependencies installed[/green]")
+        else:
+            console.print("[yellow]⚠ Could not detect package manager or install failed[/yellow]")
+
+    # Check git safety (handles protected branch warnings)
+    if workspace_path.exists():
+        if not git.check_branch_safety(workspace_path, console):
+            console.print("[dim]Cancelled.[/dim]")
+            raise typer.Exit(EXIT_CANCELLED)
+
+    return workspace_path
+
+
+def resolve_workspace_team(
+    workspace_path: Path | None,
+    team: str | None,
+    cfg: dict[str, Any],
+    *,
+    json_mode: bool = False,
+    standalone: bool = False,
+    no_interactive: bool = False,
+) -> str | None:
+    """Resolve team selection with proper priority.
+
+    Resolution priority:
+    1. Explicit --team flag (if provided)
+    2. selected_profile (explicit user choice via `scc team switch`)
+    3. Workspace-pinned team (auto-saved from previous session)
+
+    In interactive mode, prompts user when pinned team differs from selected profile.
+    In non-interactive mode, prefers selected_profile (explicit user action).
+    """
+    if standalone or workspace_path is None:
+        return team
+
+    if team:
+        return team
+
+    pinned_team = config.get_workspace_team_from_config(cfg, workspace_path)
+    selected_profile: str | None = cfg.get("selected_profile")
+
+    if pinned_team and selected_profile and pinned_team != selected_profile:
+        if is_interactive_allowed(json_mode=json_mode, no_interactive_flag=no_interactive):
+            # Default to selected_profile (explicit user choice) for consistency
+            # with non-interactive mode behavior
+            message = (
+                f"[yellow]Note:[/yellow] This workspace was last used with team "
+                f"'[cyan]{pinned_team}[/cyan]', but your current profile is "
+                f"'[cyan]{selected_profile}[/cyan]'.\n"
+                f"Use workspace's previous team '{pinned_team}' instead?"
+            )
+            if Confirm.ask(message, default=False):
+                return pinned_team
+            return selected_profile
+
+        # Non-interactive: prefer selected_profile (explicit user choice via `scc team switch`)
+        # over workspace pinning (auto-saved from previous session)
+        if not json_mode:
+            print_human(
+                "[yellow]Notice:[/yellow] "
+                f"Workspace was last used with team '{pinned_team}', "
+                f"but current profile is '{selected_profile}'. Using '{selected_profile}'.",
+                file=sys.stderr,
+                highlight=False,
+            )
+        return selected_profile
+
+    if pinned_team:
+        return pinned_team
+
+    return selected_profile
+
+
+def resolve_mount_and_branch(
+    workspace_path: Path | None,
+    *,
+    json_mode: bool = False,
+) -> tuple[Path | None, str | None]:
+    """
+    Resolve mount path for worktrees and get current branch.
+
+    For worktrees, expands mount scope to include main repo.
+    Returns (mount_path, current_branch).
+    """
+    if workspace_path is None:
+        return None, None
+
+    # Get current branch
+    current_branch = None
+    try:
+        current_branch = git.get_current_branch(workspace_path)
+    except (NotAGitRepoError, OSError):
+        pass
+
+    # Handle worktree mounting
+    mount_path, is_expanded = git.get_workspace_mount_path(workspace_path)
+    if is_expanded and not json_mode:
+        console.print()
+        console.print(
+            create_info_panel(
+                "Worktree Detected",
+                f"Mounting parent directory for worktree support:\n{mount_path}",
+                "Both worktree and main repo will be accessible",
+            )
+        )
+        console.print()
+
+    return mount_path, current_branch

scc_cli/commands/org/__init__.py

@@ -0,0 +1,49 @@
+"""
+Org package - organization configuration management commands.
+
+This package contains the decomposed org functionality:
+- app.py: Typer app definitions and command wiring
+- validate_cmd.py: Schema and semantic validation
+- update_cmd.py: Organization and team config refresh
+- schema_cmd.py: Print bundled schema
+- status_cmd.py: Current organization status
+- import_cmd.py: Import organization config from URL
+- init_cmd.py: Generate config skeleton from templates
+- _builders.py: Pure builder functions
+
+Public API re-exports for backward compatibility.
+"""
+
+# Re-export pure builders for testing
+from ._builders import (
+    build_import_preview_data,
+    build_status_data,
+    build_update_data,
+    build_validation_data,
+    check_semantic_errors,
+)
+from .app import org_app
+from .import_cmd import org_import_cmd
+from .init_cmd import org_init_cmd
+from .schema_cmd import org_schema_cmd
+from .status_cmd import org_status_cmd
+from .update_cmd import org_update_cmd
+from .validate_cmd import org_validate_cmd
+
+__all__ = [
+    # Typer app
+    "org_app",
+    # Commands
+    "org_validate_cmd",
+    "org_update_cmd",
+    "org_schema_cmd",
+    "org_status_cmd",
+    "org_import_cmd",
+    "org_init_cmd",
+    # Pure builders
+    "build_validation_data",
+    "check_semantic_errors",
+    "build_import_preview_data",
+    "build_status_data",
+    "build_update_data",
+]

scc_cli/commands/org/_builders.py

@@ -0,0 +1,264 @@
+"""Pure builder functions for org commands.
+
+These functions build data structures for JSON output and display.
+They have no side effects and are ideal for unit testing.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    pass
+
+
+def build_validation_data(
+    source: str,
+    schema_errors: list[str],
+    semantic_errors: list[str],
+    schema_version: str,
+) -> dict[str, Any]:
+    """Build validation result data for JSON output.
+
+    Args:
+        source: Path or URL of validated config
+        schema_errors: List of JSON schema validation errors
+        semantic_errors: List of semantic validation errors
+        schema_version: Schema version used for validation
+
+    Returns:
+        Dictionary with validation results
+    """
+    is_valid = len(schema_errors) == 0 and len(semantic_errors) == 0
+    return {
+        "source": source,
+        "schema_version": schema_version,
+        "valid": is_valid,
+        "schema_errors": schema_errors,
+        "semantic_errors": semantic_errors,
+    }
+
+
+def check_semantic_errors(config: dict[str, Any]) -> list[str]:
+    """Check for semantic errors beyond JSON schema validation.
+
+    Args:
+        config: Parsed organization config
+
+    Returns:
+        List of semantic error messages
+    """
+    errors: list[str] = []
+    org = config.get("organization", {})
+
+    # Profiles are at TOP LEVEL of config as a DICT (not under "organization")
+    # Dict keys are unique, so no duplicate name checking needed
+    profiles = config.get("profiles", {})
+    profile_names: list[str] = list(profiles.keys())
+
+    # Check if default_profile references existing profile
+    default_profile = org.get("default_profile")
+    if default_profile and default_profile not in profile_names:
+        errors.append(f"default_profile '{default_profile}' references non-existent profile")
+
+    return errors
+
+
+def build_import_preview_data(
+    source: str,
+    resolved_url: str,
+    config: dict[str, Any],
+    validation_errors: list[str],
+) -> dict[str, Any]:
+    """Build import preview data for display and JSON output.
+
+    Pure function that assembles preview information for an organization config
+    before it is imported.
+
+    Args:
+        source: Original source string (URL or shorthand like github:org/repo)
+        resolved_url: Resolved URL after shorthand expansion
+        config: Parsed organization config dict
+        validation_errors: List of validation error messages
+
+    Returns:
+        Dictionary with preview information including org details and validation status
+    """
+    org_data = config.get("organization", {})
+    profiles_dict = config.get("profiles", {})
+
+    return {
+        "source": source,
+        "resolved_url": resolved_url,
+        "organization": {
+            "name": org_data.get("name", ""),
+            "id": org_data.get("id", ""),
+            "contact": org_data.get("contact", ""),
+        },
+        "valid": len(validation_errors) == 0,
+        "validation_errors": validation_errors,
+        "available_profiles": list(profiles_dict.keys()),
+        "schema_version": config.get("schema_version", ""),
+        "min_cli_version": config.get("min_cli_version", ""),
+    }
+
+
+def build_status_data(
+    user_config: dict[str, Any],
+    org_config: dict[str, Any] | None,
+    cache_meta: dict[str, Any] | None,
+) -> dict[str, Any]:
+    """Build status data for JSON output and display.
+
+    Pure function that assembles status information from various sources.
+
+    Args:
+        user_config: User configuration dict
+        org_config: Cached organization config (may be None)
+        cache_meta: Cache metadata dict (may be None)
+
+    Returns:
+        Dictionary with complete status information
+    """
+    # Import here to avoid circular imports at module level
+    from ...remote import is_cache_valid
+    from ...validate import check_version_compatibility
+
+    # Determine mode
+    is_standalone = user_config.get("standalone", False) or not user_config.get(
+        "organization_source"
+    )
+
+    if is_standalone:
+        return {
+            "mode": "standalone",
+            "organization": None,
+            "cache": None,
+            "version_compatibility": None,
+            "selected_profile": None,
+            "available_profiles": [],
+        }
+
+    # Organization connected mode
+    org_source = user_config.get("organization_source", {})
+    source_url = org_source.get("url", "")
+
+    # Organization info
+    org_info: dict[str, Any] | None = None
+    available_profiles: list[str] = []
+    if org_config:
+        org_data = org_config.get("organization", {})
+        org_info = {
+            "name": org_data.get("name", "unknown"),
+            "id": org_data.get("id", ""),
+            "contact": org_data.get("contact", ""),
+            "source_url": source_url,
+        }
+        # Extract available profiles
+        profiles_dict = org_config.get("profiles", {})
+        available_profiles = list(profiles_dict.keys())
+    else:
+        org_info = {
+            "name": None,
+            "source_url": source_url,
+        }
+
+    # Cache status
+    cache_info: dict[str, Any] | None = None
+    if cache_meta:
+        org_cache = cache_meta.get("org_config", {})
+        cache_info = {
+            "fetched_at": org_cache.get("fetched_at"),
+            "expires_at": org_cache.get("expires_at"),
+            "etag": org_cache.get("etag"),
+            "valid": is_cache_valid(cache_meta),
+        }
+
+    # Version compatibility
+    version_compat: dict[str, Any] | None = None
+    if org_config:
+        compat = check_version_compatibility(org_config)
+        version_compat = {
+            "compatible": compat.compatible,
+            "blocking_error": compat.blocking_error,
+            "warnings": compat.warnings,
+            "schema_version": compat.schema_version,
+            "min_cli_version": compat.min_cli_version,
+            "current_cli_version": compat.current_cli_version,
+        }
+
+    return {
+        "mode": "organization",
+        "organization": org_info,
+        "cache": cache_info,
+        "version_compatibility": version_compat,
+        "selected_profile": user_config.get("selected_profile"),
+        "available_profiles": available_profiles,
+    }
+
+
+def build_update_data(
+    org_config: dict[str, Any] | None,
+    team_results: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Build update result data for JSON output.
+
+    Pure function that assembles update result information.
+
+    Args:
+        org_config: Updated organization config (may be None on failure)
+        team_results: List of team update results (optional)
+
+    Returns:
+        Dictionary with update results including org and team info
+    """
+    result: dict[str, Any] = {
+        "org_updated": org_config is not None,
+    }
+
+    if org_config:
+        org_data = org_config.get("organization", {})
+        result["organization"] = {
+            "name": org_data.get("name", ""),
+            "id": org_data.get("id", ""),
+        }
+        result["schema_version"] = org_config.get("schema_version", "")
+
+    if team_results is not None:
+        result["teams_updated"] = team_results
+        result["teams_success_count"] = sum(1 for t in team_results if t.get("success"))
+        result["teams_failed_count"] = sum(1 for t in team_results if not t.get("success"))
+
+    return result
+
+
+def _parse_config_source(source_dict: dict[str, Any]) -> Any:
+    """Parse a config_source dict into the appropriate ConfigSource type.
+
+    Handles discriminated union parsing for github, git, url sources.
+
+    Args:
+        source_dict: Raw config_source dict from org config
+
+    Returns:
+        ConfigSource object (ConfigSourceGitHub, ConfigSourceGit, or ConfigSourceURL)
+    """
+    # Import here to avoid circular imports
+    from ...marketplace.schema import (
+        ConfigSourceGit,
+        ConfigSourceGitHub,
+        ConfigSourceURL,
+    )
+
+    if "github" in source_dict:
+        github_data = source_dict["github"]
+        # Add source discriminator for Pydantic model
+        return ConfigSourceGitHub(source="github", **github_data)
+    elif "git" in source_dict:
+        git_data = source_dict["git"]
+        return ConfigSourceGit(source="git", **git_data)
+    elif "url" in source_dict:
+        url_data = source_dict["url"]
+        return ConfigSourceURL(source="url", **url_data)
+    else:
+        raise ValueError(f"Unknown config_source type: {list(source_dict.keys())}")

scc_cli/commands/org/app.py

@@ -0,0 +1,41 @@
+"""
+Org package - Typer app definitions and command wiring.
+
+This module contains the Typer app definitions and wires commands from:
+- validate_cmd.py: Schema and semantic validation
+- update_cmd.py: Organization and team config refresh
+- schema_cmd.py: Print bundled schema
+- status_cmd.py: Current organization status
+- import_cmd.py: Import organization config from URL
+- init_cmd.py: Generate config skeleton from templates
+"""
+
+from __future__ import annotations
+
+import typer
+
+from .import_cmd import org_import_cmd
+from .init_cmd import org_init_cmd
+from .schema_cmd import org_schema_cmd
+from .status_cmd import org_status_cmd
+from .update_cmd import org_update_cmd
+from .validate_cmd import org_validate_cmd
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Org App
+# ─────────────────────────────────────────────────────────────────────────────
+
+org_app = typer.Typer(
+    name="org",
+    help="Organization configuration management and validation.",
+    no_args_is_help=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+
+# Wire org commands
+org_app.command("validate")(org_validate_cmd)
+org_app.command("update")(org_update_cmd)
+org_app.command("schema")(org_schema_cmd)
+org_app.command("status")(org_status_cmd)
+org_app.command("import")(org_import_cmd)
+org_app.command("init")(org_init_cmd)