adop-cli 0.1.3__py3-none-any.whl

ado_pipeline/config.py

@@ -0,0 +1,225 @@
+"""Configuration management for Azure DevOps Pipeline CLI."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+CONFIG_DIR = Path.home() / ".azure-pipeline-cli"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+PIPELINES_FILE = CONFIG_DIR / "pipelines.json"
+
+
+@dataclass
+class PipelineParamConfig:
+    """Pipeline parameter configuration."""
+
+    name: str
+    param_type: str = "string"  # string, boolean, choice
+    default: Any = None
+    choices: list[str] | None = None
+    description: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dict, excluding None values."""
+        result = {"name": self.name, "type": self.param_type}
+        if self.default is not None:
+            result["default"] = self.default
+        if self.choices:
+            result["choices"] = self.choices
+        if self.description:
+            result["description"] = self.description
+        return result
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> PipelineParamConfig:
+        """Create from dict."""
+        return cls(
+            name=data["name"],
+            param_type=data.get("type", "string"),
+            default=data.get("default"),
+            choices=data.get("choices"),
+            description=data.get("description", ""),
+        )
+
+
+@dataclass
+class PipelineConfig:
+    """Pipeline configuration."""
+
+    alias: str
+    name: str
+    description: str = ""
+    parameters: list[PipelineParamConfig] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dict."""
+        result: dict[str, Any] = {"name": self.name}
+        if self.description:
+            result["description"] = self.description
+        if self.parameters:
+            result["parameters"] = [p.to_dict() for p in self.parameters]
+        return result
+
+    @classmethod
+    def from_dict(cls, alias: str, data: dict[str, Any]) -> PipelineConfig:
+        """Create from dict."""
+        params = []
+        for p in data.get("parameters", []):
+            params.append(PipelineParamConfig.from_dict(p))
+        return cls(
+            alias=alias,
+            name=data["name"],
+            description=data.get("description", ""),
+            parameters=params,
+        )
+
+
+@dataclass
+class Config:
+    """Configuration for Azure DevOps Pipeline CLI."""
+
+    organization: str = ""
+    project: str = ""
+    repository: str = ""
+    pat: str = ""
+
+    @classmethod
+    def load(cls) -> Config:
+        """Load config from file, or return defaults if not found."""
+        if not CONFIG_FILE.exists():
+            return cls()
+
+        try:
+            with CONFIG_FILE.open() as f:
+                data = json.load(f)
+        except (json.JSONDecodeError, OSError):
+            return cls()
+
+        return cls(
+            organization=data.get("organization", ""),
+            project=data.get("project", ""),
+            repository=data.get("repository", ""),
+            pat=data.get("pat", ""),
+        )
+
+    def save(self) -> None:
+        """Save config to file with restricted permissions."""
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        with CONFIG_FILE.open("w") as f:
+            json.dump(asdict(self), f, indent=2)
+        # Restrict file permissions to owner only (contains PAT)
+        CONFIG_FILE.chmod(0o600)
+
+    def is_configured(self) -> bool:
+        """Check if required fields are configured."""
+        return bool(self.pat and self.organization and self.project)
+
+    def get_missing_fields(self) -> list[str]:
+        """Get list of missing required fields."""
+        missing = []
+        if not self.organization:
+            missing.append("organization")
+        if not self.project:
+            missing.append("project")
+        if not self.pat:
+            missing.append("PAT")
+        return missing
+
+
+@dataclass
+class PipelinesConfig:
+    """Pipeline definitions configuration."""
+
+    pipelines: dict[str, PipelineConfig] = field(default_factory=dict)
+
+    @classmethod
+    def load(cls) -> PipelinesConfig:
+        """Load pipelines from file."""
+        if not PIPELINES_FILE.exists():
+            return cls()
+
+        try:
+            with PIPELINES_FILE.open() as f:
+                data = json.load(f)
+        except (json.JSONDecodeError, OSError):
+            return cls()
+
+        pipelines = {}
+        for alias, pipeline_data in data.get("pipelines", {}).items():
+            try:
+                pipelines[alias] = PipelineConfig.from_dict(alias, pipeline_data)
+            except (KeyError, TypeError):
+                continue
+
+        return cls(pipelines=pipelines)
+
+    def save(self) -> None:
+        """Save pipelines to file."""
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+        data = {
+            "pipelines": {
+                alias: p.to_dict() for alias, p in self.pipelines.items()
+            }
+        }
+
+        with PIPELINES_FILE.open("w") as f:
+            json.dump(data, f, indent=2)
+
+    def add(self, pipeline: PipelineConfig) -> None:
+        """Add or update a pipeline."""
+        self.pipelines[pipeline.alias] = pipeline
+        self.save()
+
+    def remove(self, alias: str) -> bool:
+        """Remove a pipeline. Returns True if removed."""
+        if alias in self.pipelines:
+            del self.pipelines[alias]
+            self.save()
+            return True
+        return False
+
+    def get(self, alias: str) -> PipelineConfig | None:
+        """Get a pipeline by alias."""
+        return self.pipelines.get(alias)
+
+    def list_all(self) -> list[PipelineConfig]:
+        """List all pipelines."""
+        return list(self.pipelines.values())
+
+
+def init_config(
+    organization: str,
+    project: str,
+    pat: str,
+    repository: str = "",
+) -> Config:
+    """Initialize config with required fields."""
+    config = Config(
+        organization=organization,
+        project=project,
+        repository=repository,
+        pat=pat,
+    )
+    config.save()
+    return config
+
+
+def get_config() -> Config:
+    """Get current config, raising error if not configured."""
+    config = Config.load()
+    if not config.is_configured():
+        missing = config.get_missing_fields()
+        raise ConfigError(
+            f"Configuration incomplete. Missing: {', '.join(missing)}. "
+            "Run 'ado-pipeline config init' to set up."
+        )
+    return config
+
+
+class ConfigError(Exception):
+    """Configuration error."""

ado_pipeline/favorites.py

@@ -0,0 +1,109 @@
+"""Favorites management for quick pipeline access."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+FAVORITES_FILE = Path.home() / ".azure-pipeline-cli" / "favorites.json"
+
+
+@dataclass
+class Favorite:
+    """A saved favorite pipeline configuration."""
+
+    name: str
+    pipeline_alias: str
+    branch: str | None = None
+    deploy: bool | None = None
+    output_format: str | None = None
+    release_notes: str | None = None
+    environment: str | None = None
+    fail_if_no_changes: bool | None = None
+    fail_on_push_error: bool | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dict, excluding None values."""
+        return {k: v for k, v in asdict(self).items() if v is not None}
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Favorite:
+        """Create from dict."""
+        return cls(
+            name=data["name"],
+            pipeline_alias=data["pipeline_alias"],
+            branch=data.get("branch"),
+            deploy=data.get("deploy"),
+            output_format=data.get("output_format"),
+            release_notes=data.get("release_notes"),
+            environment=data.get("environment"),
+            fail_if_no_changes=data.get("fail_if_no_changes"),
+            fail_on_push_error=data.get("fail_on_push_error"),
+        )
+
+
+@dataclass
+class FavoritesStore:
+    """Store for favorite pipeline configurations."""
+
+    favorites: dict[str, Favorite] = field(default_factory=dict)
+
+    @classmethod
+    def load(cls) -> FavoritesStore:
+        """Load favorites from file."""
+        if not FAVORITES_FILE.exists():
+            return cls()
+
+        try:
+            with FAVORITES_FILE.open() as f:
+                data = json.load(f)
+        except (json.JSONDecodeError, OSError):
+            # Return empty store if file is corrupted or unreadable
+            return cls()
+
+        favorites = {}
+        for name, fav_data in data.get("favorites", {}).items():
+            try:
+                fav_data["name"] = name
+                favorites[name] = Favorite.from_dict(fav_data)
+            except (KeyError, TypeError):
+                # Skip invalid favorites
+                continue
+
+        return cls(favorites=favorites)
+
+    def save(self) -> None:
+        """Save favorites to file."""
+        FAVORITES_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+        data = {
+            "favorites": {
+                name: fav.to_dict() for name, fav in self.favorites.items()
+            }
+        }
+
+        with FAVORITES_FILE.open("w") as f:
+            json.dump(data, f, indent=2)
+
+    def add(self, favorite: Favorite) -> None:
+        """Add or update a favorite."""
+        self.favorites[favorite.name] = favorite
+        self.save()
+
+    def remove(self, name: str) -> bool:
+        """Remove a favorite. Returns True if removed."""
+        if name in self.favorites:
+            del self.favorites[name]
+            self.save()
+            return True
+        return False
+
+    def get(self, name: str) -> Favorite | None:
+        """Get a favorite by name."""
+        return self.favorites.get(name)
+
+    def list_all(self) -> list[Favorite]:
+        """List all favorites."""
+        return list(self.favorites.values())

ado_pipeline/pipelines.py

@@ -0,0 +1,154 @@
+"""Pipeline definitions and registry."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from .config import PipelineConfig, PipelineParamConfig, PipelinesConfig
+
+
+class PipelineNotFoundError(Exception):
+    """Pipeline not found error."""
+
+
+@dataclass
+class PipelineParam:
+    """Pipeline parameter definition."""
+
+    name: str
+    param_type: str  # string, boolean, choice
+    default: Any
+    choices: list[str] | None = None
+    description: str = ""
+
+    def validate(self, value: Any) -> Any:
+        """Validate and convert value to appropriate type."""
+        if self.param_type == "boolean":
+            if isinstance(value, bool):
+                return value
+            if isinstance(value, str):
+                return value.lower() in ("true", "yes", "1")
+            return bool(value)
+
+        if self.param_type == "choice" and self.choices:
+            if value not in self.choices:
+                raise ValueError(
+                    f"Invalid value '{value}' for {self.name}. "
+                    f"Must be one of: {', '.join(self.choices)}"
+                )
+            return value
+
+        return str(value) if value is not None else self.default
+
+    @classmethod
+    def from_config(cls, config: PipelineParamConfig) -> PipelineParam:
+        """Create from PipelineParamConfig."""
+        return cls(
+            name=config.name,
+            param_type=config.param_type,
+            default=config.default,
+            choices=config.choices,
+            description=config.description,
+        )
+
+
+@dataclass
+class Pipeline:
+    """Pipeline definition."""
+
+    alias: str
+    name: str
+    parameters: list[PipelineParam] = field(default_factory=list)
+    description: str = ""
+
+    def get_param(self, name: str) -> PipelineParam | None:
+        """Get parameter by name."""
+        return next((p for p in self.parameters if p.name == name), None)
+
+    def build_parameters(self, **kwargs: Any) -> dict[str, Any]:
+        """Build parameters dict with defaults and overrides."""
+        result = {}
+        for param in self.parameters:
+            if param.name in kwargs:
+                result[param.name] = param.validate(kwargs[param.name])
+            elif param.default is not None:
+                result[param.name] = param.default
+        return result
+
+    @classmethod
+    def from_config(cls, config: PipelineConfig) -> Pipeline:
+        """Create from PipelineConfig."""
+        params = [PipelineParam.from_config(p) for p in config.parameters]
+        return cls(
+            alias=config.alias,
+            name=config.name,
+            parameters=params,
+            description=config.description,
+        )
+
+
+def _calculate_similarity(s1: str, s2: str) -> float:
+    """Calculate similarity ratio between two strings (0.0 to 1.0)."""
+    if not s1 or not s2:
+        return 0.0
+    s1_lower, s2_lower = s1.lower(), s2.lower()
+    # Check substring match first
+    if s1_lower in s2_lower or s2_lower in s1_lower:
+        return 0.8
+    # Count matching characters in order
+    matches = 0
+    j = 0
+    for char in s1_lower:
+        while j < len(s2_lower):
+            if s2_lower[j] == char:
+                matches += 1
+                j += 1
+                break
+            j += 1
+    return matches / max(len(s1), len(s2))
+
+
+def find_similar_pipelines(alias: str, threshold: float = 0.4) -> list[str]:
+    """Find pipelines similar to the given alias."""
+    pipelines_config = PipelinesConfig.load()
+    similarities = []
+    for name in pipelines_config.pipelines:
+        score = _calculate_similarity(alias, name)
+        if score >= threshold:
+            similarities.append((name, score))
+    similarities.sort(key=lambda x: x[1], reverse=True)
+    return [name for name, _ in similarities[:3]]
+
+
+def get_pipeline(alias: str) -> Pipeline:
+    """Get pipeline by alias."""
+    pipelines_config = PipelinesConfig.load()
+    config = pipelines_config.get(alias)
+
+    if config is None:
+        similar = find_similar_pipelines(alias)
+        if similar:
+            raise PipelineNotFoundError(
+                f"Pipeline '{alias}' not found. Did you mean: {', '.join(similar)}?"
+            )
+        if not pipelines_config.pipelines:
+            raise PipelineNotFoundError(
+                f"Pipeline '{alias}' not found. No pipelines configured. "
+                "Run 'ado-pipeline pipeline add' or 'ado-pipeline pipeline import' to add pipelines."
+            )
+        raise PipelineNotFoundError(f"Pipeline '{alias}' not found")
+
+    return Pipeline.from_config(config)
+
+
+def list_pipelines() -> list[Pipeline]:
+    """List all available pipelines."""
+    pipelines_config = PipelinesConfig.load()
+    return [Pipeline.from_config(c) for c in pipelines_config.list_all()]
+
+
+def get_all_aliases() -> list[str]:
+    """Get all pipeline aliases for completion."""
+    pipelines_config = PipelinesConfig.load()
+    return list(pipelines_config.pipelines.keys())

ado_pipeline/plan.py

@@ -0,0 +1,164 @@
+"""Execution plan generation and display."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import quote
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+
+from .config import Config
+from .pipelines import Pipeline
+
+
+@dataclass
+class ExecutionPlan:
+    """Execution plan for a pipeline run."""
+
+    pipeline: Pipeline
+    branch: str
+    parameters: dict[str, Any]
+    config: Config
+
+    @property
+    def api_url(self) -> str:
+        """Generate API URL for pipeline run."""
+        org = self.config.organization
+        project = quote(self.config.project, safe="")
+        return (
+            f"https://dev.azure.com/{org}/{project}/"
+            f"_apis/pipelines/{{id}}/runs?api-version=7.1"
+        )
+
+    @property
+    def request_body(self) -> dict[str, Any]:
+        """Generate request body for API call."""
+        body: dict[str, Any] = {
+            "resources": {
+                "repositories": {
+                    "self": {"refName": f"refs/heads/{self.branch}"}
+                }
+            }
+        }
+
+        # Filter out empty strings - Azure DevOps doesn't accept them
+        filtered_params = {
+            k: v for k, v in self.parameters.items()
+            if v != ""
+        }
+
+        if filtered_params:
+            body["templateParameters"] = filtered_params
+
+        return body
+
+    def display(self, console: Console | None = None) -> None:
+        """Pretty-print the execution plan."""
+        if console is None:
+            console = Console()
+
+        # Header panel
+        console.print()
+        console.print(
+            Panel(
+                "[bold cyan]Azure DevOps Pipeline Trigger - PLAN[/bold cyan]",
+                expand=False,
+            )
+        )
+        console.print()
+
+        # Pipeline info table
+        info_table = Table(show_header=False, box=None, padding=(0, 2))
+        info_table.add_column("Key", style="bold")
+        info_table.add_column("Value")
+
+        info_table.add_row("Pipeline:", self.pipeline.name)
+        info_table.add_row("Alias:", self.pipeline.alias)
+        info_table.add_row("Branch:", self.branch)
+        info_table.add_row("Organization:", self.config.organization)
+        info_table.add_row("Project:", self.config.project)
+
+        console.print(info_table)
+        console.print()
+
+        # Parameters section
+        console.print("[bold]Parameters:[/bold]", end="")
+        if not self.parameters:
+            console.print(" [dim](none)[/dim]")
+        else:
+            console.print()
+            for key, value in self.parameters.items():
+                display_value = json.dumps(value) if isinstance(value, bool) else value
+                display_value = display_value if display_value != "" else '""'
+                console.print(f"  [dim]*[/dim] {key}: {display_value}")
+        console.print()
+
+        # API endpoint
+        console.print("[bold]API Endpoint:[/bold]")
+        console.print(f"  POST {self.api_url}")
+        console.print()
+
+        # Request body
+        console.print("[bold]Request Body:[/bold]")
+        body_json = json.dumps(self.request_body, indent=2)
+        syntax = Syntax(body_json, "json", theme="monokai", line_numbers=False)
+        console.print(syntax)
+        console.print()
+
+        # Footer warning
+        console.print("[dim]" + "-" * 60 + "[/dim]")
+        console.print(
+            "[yellow bold]!![/yellow bold] "
+            "[yellow]This is a PLAN. No API call was made.[/yellow]"
+        )
+        console.print(
+            "[dim]Run with 'apply' to trigger the pipeline.[/dim]"
+        )
+        console.print()
+
+
+class GitError(Exception):
+    """Git command error."""
+
+
+def get_current_branch() -> str:
+    """Get current git branch name."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return result.stdout.strip()
+    except FileNotFoundError:
+        raise GitError("Git is not installed or not in PATH")
+    except subprocess.CalledProcessError:
+        raise GitError("Not a git repository. Use --branch to specify.")
+
+
+def create_plan(
+    pipeline: Pipeline,
+    branch: str | None = None,
+    config: Config | None = None,
+    **kwargs: Any,
+) -> ExecutionPlan:
+    """Create an execution plan for a pipeline run."""
+    if config is None:
+        config = Config.load()
+
+    if branch is None:
+        branch = get_current_branch()
+
+    return ExecutionPlan(
+        pipeline=pipeline,
+        branch=branch,
+        parameters=pipeline.build_parameters(**kwargs),
+        config=config,
+    )