@ngocsangairvds/vsaf 3.1.27 → 3.2.1

package/tools/vds-scripts/vds_cli/src/vds_cli/env.py

@@ -0,0 +1,41 @@
+"""Environment management using pydantic-settings.
+
+Based on pydantic-settings v2.12.0+ API
+Context7: /pydantic/pydantic-settings
+Key Features: env_file, env_file_encoding, case_sensitive
+"""
+
+from pathlib import Path
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class VDSSettings(BaseSettings):
+    """VDS environment settings loaded from ~/.vds/.env file."""
+
+    model_config = SettingsConfigDict(
+        env_file=Path.home() / ".vds" / ".env",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    vds_username: str | None = None
+    vds_password: str | None = None
+    bitbucket_access_token: str | None = None
+    internal_confluence_token: str | None = None
+    external_confluence_token: str | None = None
+
+
+def load_environment() -> VDSSettings:
+    """Load environment variables from ~/.vds/.env.
+
+    Returns:
+        VDSSettings: Loaded settings instance
+
+    Example:
+        >>> settings = load_environment()
+        >>> if settings.vds_username:
+        ...     print("Credentials loaded")
+    """
+    return VDSSettings()

package/tools/vds-scripts/vds_cli/src/vds_cli/google_sheets_orchestrator/__init__.py

@@ -0,0 +1,3 @@
+from .google_sheets_orchestrator import app as app
+
+__all__ = ["app"]

package/tools/vds-scripts/vds_cli/src/vds_cli/google_sheets_orchestrator/google_sheets_orchestrator.py

@@ -0,0 +1,198 @@
+from pathlib import Path
+
+import gspread
+import structlog
+import typer
+from google.oauth2.service_account import Credentials
+from rich.console import Console
+from vds_cli_common.paths import get_vds_config_root
+
+console = Console()
+app = typer.Typer(help="Google Sheets orchestrator operations.")
+logger = structlog.get_logger(__name__)
+
+GOOGLE_SHEETS_SCOPE = [
+    "https://spreadsheets.google.com/feeds",
+    "https://www.googleapis.com/auth/drive",
+]
+
+
+def _build_client(auth_method: str, credentials_path: Path | None):
+    method = auth_method.strip().lower()
+    if method == "service_account":
+        resolved_path = credentials_path or (get_vds_config_root() / "google_credentials.json")
+        if not resolved_path.exists():
+            console.print(
+                "[bold red]Error:[/bold red] Service account credentials file not found "
+                f"at {resolved_path}"
+            )
+            raise typer.Exit(code=1) from None
+
+        creds = ServiceAccountCredentials.from_json_keyfile_name(
+            str(resolved_path),
+            GOOGLE_SHEETS_SCOPE,
+        )
+        client = gspread.service_account(credentials=creds)
+        console.print(
+            "[bold green]Authenticated using service account: [/bold green]"
+            f"{resolved_path}"
+        )
+        return client
+
+    if method == "oauth":
+        resolved_path = credentials_path or (get_vds_config_root() / "gspread_oauth.json")
+        resolved_path.parent.mkdir(parents=True, exist_ok=True)
+        client = gspread.oauth(
+            scopes=GOOGLE_SHEETS_SCOPE,
+            credentials_filename=resolved_path,
+            authorized_user_filename=resolved_path.with_name("authorized_user.json"),
+        )
+        console.print(
+            "[bold green]Authenticated using OAuth: [/bold green]"
+            f"{resolved_path}"
+        )
+        return client
+
+    if method == "none":
+        # gspread still needs a client object even when opening public sheets.
+        console.print("[bold green]Attempting to read as a public sheet.[/bold green]")
+        return gspread.service_account()
+
+    console.print(
+        "[bold red]Error:[/bold red] Invalid authentication method: "
+        f"{auth_method}. Choose 'service_account', 'oauth', or 'none'."
+    )
+    raise typer.Exit(code=1) from None
+
+
+@app.command()
+def read(
+    spreadsheet_url: str = typer.Option(
+        ...,
+        "--spreadsheet-url",
+        "-u",
+        help="URL of the Google Spreadsheet.",
+    ),
+    sheet_name: str = typer.Option(
+        "Sheet1",
+        "--sheet-name",
+        "-n",
+        help="Name of the worksheet to read.",
+    ),
+    auth_method: str = typer.Option(
+        "service_account",
+        "--auth-method",
+        "-a",
+        help="Authentication method: 'service_account', 'oauth', or 'none' (for public sheets).",
+    ),
+    credentials_path: Path | None = typer.Option(
+        None,
+        "--credentials-path",
+        "-c",
+        help="Path to the Google credentials file (e.g., service_account.json).",
+    ),
+):
+    """Read data from a specified Google Sheet and print it to the console."""
+    client = _build_client(auth_method, credentials_path)
+    try:
+        spreadsheet = client.open_by_url(spreadsheet_url)
+        worksheet = spreadsheet.worksheet(sheet_name)
+        data = worksheet.get_all_values()
+
+        if data:
+            console.print(
+                "[bold green]Successfully read data from "
+                f"'{sheet_name}' in '{spreadsheet.title}':[/bold green]"
+            )
+            for row_idx, row in enumerate(data, start=1):
+                logger.info(f"Row {row_idx}", row=row)
+        else:
+            console.print(
+                f"[bold yellow]No data found in sheet '{sheet_name}' in "
+                f"'{spreadsheet.title}'.[/bold yellow]"
+            )
+
+    except gspread.exceptions.SpreadsheetNotFound:
+        console.print(
+            "[bold red]Error:[/bold red] Spreadsheet not found at URL: "
+            f"{spreadsheet_url}"
+        )
+        logger.error("Spreadsheet not found", url=spreadsheet_url)
+        raise typer.Exit(code=1) from None
+    except gspread.exceptions.WorksheetNotFound:
+        console.print(
+            "[bold red]Error:[/bold red] Worksheet "
+            f"'{sheet_name}' not found in the spreadsheet."
+        )
+        logger.error("Worksheet not found", sheet_name=sheet_name, url=spreadsheet_url)
+        console.print("[bold yellow]Available worksheets:[/bold yellow]")
+        try:
+            spreadsheet = client.open_by_url(spreadsheet_url)
+            for worksheet in spreadsheet.worksheets():
+                console.print(f"- {worksheet.title}")
+        except Exception as exc:  # noqa: BLE001
+            logger.exception("Failed to list worksheets")
+            console.print(f"[bold red]Could not list worksheets: {exc}[/bold red]")
+        raise typer.Exit(code=1) from None
+    except gspread.exceptions.APIError as exc:
+        console.print(f"[bold red]Error:[/bold red] Google Sheets API error: {exc}")
+        logger.error("Google Sheets API error", error=str(exc), auth_method=auth_method)
+        console.print(
+            "[bold yellow]Please check your credentials and spreadsheet permissions.[/bold yellow]"
+        )
+        if (
+            "Request had insufficient authentication scopes." in str(exc)
+            and auth_method == "service_account"
+        ):
+            console.print(
+                "[bold yellow]Ensure your service account has editor access to the spreadsheet "
+                "and Google Drive API is enabled.[/bold yellow]"
+            )
+        if "Requested entity was not found" in str(exc) and auth_method == "none":
+            console.print(
+                "[bold yellow]The spreadsheet might not be publicly accessible. Try "
+                "'oauth' or 'service_account' authentication.[/bold yellow]"
+            )
+        raise typer.Exit(code=1) from None
+    except Exception as exc:  # noqa: BLE001
+        logger.exception("An unexpected error occurred")
+        console.print(f"[bold red]An unexpected error occurred:[/bold red] {exc}")
+        raise typer.Exit(code=1) from None
+
+
+@app.command(name="list-worksheets")
+def list_worksheets(
+    spreadsheet_url: str = typer.Option(
+        ...,
+        "--spreadsheet-url",
+        "-u",
+        help="URL of the Google Spreadsheet.",
+    ),
+    auth_method: str = typer.Option(
+        "service_account",
+        "--auth-method",
+        "-a",
+        help="Authentication method: 'service_account', 'oauth', or 'none' (for public sheets).",
+    ),
+    credentials_path: Path | None = typer.Option(
+        None,
+        "--credentials-path",
+        "-c",
+        help="Path to the Google credentials file (e.g., service_account.json).",
+    ),
+):
+    """List all worksheets in a specified Google Spreadsheet."""
+    client = _build_client(auth_method, credentials_path)
+    try:
+        spreadsheet = client.open_by_url(spreadsheet_url)
+        console.print(f"[bold green]Worksheets in '{spreadsheet.title}':[/bold green]")
+        for worksheet in spreadsheet.worksheets():
+            console.print(f"- {worksheet.title}")
+    except Exception as exc:  # noqa: BLE001
+        logger.exception("Failed to list worksheets")
+        console.print(f"[bold red]An error occurred while listing worksheets:[/bold red] {exc}")
+        raise typer.Exit(code=1) from None
+
+
+if __name__ == "__main__":
+    app()

package/tools/vds-scripts/vds_cli/src/vds_cli/router.py

@@ -0,0 +1,93 @@
+"""Command routing to Python orchestrators.
+
+Routes commands to appropriate orchestrators via uv run.
+"""
+
+import os
+import subprocess
+from pathlib import Path
+
+ORCHESTRATORS = {
+    "jira": {
+        "module": "vds_jira_orchestrator.cli",
+        "path": "jira_orchestrator",
+        "entry": "vds-jira-cli",
+    },
+    "confluence": {
+        "module": "confluence_orchestrator.cli",
+        "path": "confluence_orchestrator",
+        "entry": "vds-confluence-cli",
+    },
+    "bitbucket": {
+        "module": "vds_bitbucket_orchestrator.cli",
+        "path": "bitbucket_orchestrator",
+        "entry": "vds-bitbucket-cli",
+    },
+    "git": {
+        "module": "vds_git_orchestrator.cli",
+        "path": "git_orchestrator",
+        "entry": "vds-git-orchestrator",
+    },
+    "pdf": {
+        "module": "vds_pdf_orchestrator.cli",
+        "path": "pdf_orchestrator",
+        "entry": "vds-pdf",
+    },
+}
+
+
+def run_orchestrator(service: str, args: list[str], script_dir: Path) -> int:
+    """Run orchestrator via uv.
+
+    Args:
+        service: Service name (jira, confluence, bitbucket, git)
+        args: Command arguments to pass to orchestrator
+        script_dir: Base directory containing orchestrators
+
+    Returns:
+        int: Exit code from orchestrator (0 for success)
+
+    Raises:
+        ValueError: If service is not recognized
+
+    Example:
+        >>> exit_code = run_orchestrator("jira", ["search", "project = NTTC"], Path("/path/to/scripts"))
+        >>> if exit_code == 0:
+        ...     print("Success")
+    """
+    if service not in ORCHESTRATORS:
+        raise ValueError(f"Unknown service: {service}. Available: {list(ORCHESTRATORS.keys())}")
+
+    config = ORCHESTRATORS[service]
+    project_dir = script_dir / config["path"]
+
+    if not project_dir.exists():
+        raise FileNotFoundError(f"Orchestrator directory not found: {project_dir}")
+
+    # Use uv to run the orchestrator
+    entry = config.get("entry")
+    if entry:
+        cmd = ["uv", "run", "--project", str(project_dir), entry] + args
+    else:
+        cmd = [
+            "uv",
+            "run",
+            "--project",
+            str(project_dir),
+            "python",
+            "-m",
+            config["module"],
+        ] + args
+
+    env = os.environ.copy()
+    env.pop("VIRTUAL_ENV", None)
+    orchestrator_src = project_dir / "src"
+    existing_path = env.get("PYTHONPATH", "")
+    if orchestrator_src.exists():
+        env["PYTHONPATH"] = (
+            f"{orchestrator_src}{os.pathsep}{existing_path}"
+            if existing_path
+            else str(orchestrator_src)
+        )
+    result = subprocess.run(cmd, check=False, env=env)
+    return result.returncode