opsmith-cli 0.3.1b0__tar.gz → 0.4.0b0__tar.gz

opsmith_cli-0.4.0b0/CONVENTIONS.md

@@ -0,0 +1,35 @@
+# Engineering Conventions
+
+## Conventions
+> When writing code follow these conventions
+
+- Write simple verbose code over terse, compact, dense code
+- Use types everywhere possible.
+- Add logs where applicable so that debugging becomes easy
+- Add docstring to functions that describe its use
+- Add try/except blocks sparingly, only where it is essential
+- Use pytest to write tests
+- Add docstring to each test case that describes its flow clearly
+- Tests should mock out external calls and command calls
+- Do not assert on logs in tests as that is not a best practice
+
+## Project Structure
+
+- `opsmith/` - Source code for this CLI tool
+  - `cloud_providers/` - Cloud provider implementations (e.g., AWS, GCP).
+  - `deployment_strategies/` - Application deployment strategies (e.g., monolithic).
+  - `infra_provisioners/` - Wrappers for infrastructure tools (e.g., Terraform, Ansible).
+  - `templates/` - Infrastructure-as-code templates (e.g., Terraform modules, Ansible Playbooks).
+  - `tests/` - Tests for all the components
+  - `agent.py` - AI agent logic.
+  - `exceptions.py` - Custom exceptions used by Opsmith
+  - `git_repo.py` - Connector for a git repo
+  - `main.py` - CLI command definitions (Typer).
+  - `models.py` - List of available LLMs
+  - `prompts.py` - Prompts used to interact with the LLM
+  - `repo_map.py` - Generates a ,ap of the files in the repository
+  - `service_detector.py` - Logic to detect services in a repository.
+  - `settings.py` - Configurations for Opsmith 
+  - `types.py` - Core Pydantic data models for configuration and state.
+  - `utils.py` - Shared utility functions.
+

{opsmith_cli-0.3.1b0 → opsmith_cli-0.4.0b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opsmith-cli
-Version: 0.3.1b0
+Version: 0.4.0b0
 Summary: Opsmith is an AI devops engineer in your terminal
 License-Expression: GPL-3.0-only
 License-File: LICENSE.txt

{opsmith_cli-0.3.1b0 → opsmith_cli-0.4.0b0}/opsmith/agent.py

@@ -45,9 +45,9 @@ def build_agent(model_config: Type[BaseAiModel], instrument: bool = False) -> Ag
     )
 
     @agent.tool(retries=5)
-    def read_file_content(ctx: RunContext[AgentDeps], filenames: List[str]) -> List[str]:
+    def read_repo_files(ctx: RunContext[AgentDeps], filenames: List[str]) -> List[str]:
         """
-        Reads and returns the content of specified files from the repository.
+        Reads and returns the content of specified files from the repo.
         Use this to understand file structures, dependencies, or specific configurations.
         Provide the relative file paths from the repository root.
 
@@ -59,9 +59,9 @@ def build_agent(model_config: Type[BaseAiModel], instrument: bool = False) -> Ag
             A list of strings, where each string is the content of the corresponding file.
             The order of contents in the list matches the order of filenames in the input.
         """
-        if is_duplicate_tool_call(ctx, "read_file_content"):
+        if is_duplicate_tool_call(ctx, "read_repo_files"):
             raise ModelRetry(
-                "The tool 'read_file_content' has already been called with the exact same list of "
+                "The tool 'read_repo_files' has already been called with the exact same list of "
                 "files in this conversation."
             )
 

{opsmith_cli-0.3.1b0 → opsmith_cli-0.4.0b0}/opsmith/cloud_providers/aws.py

@@ -1,7 +1,9 @@
+import shutil
 from typing import Literal, Type
 
 import boto3
 import botocore.session
+import inquirer
 from botocore.exceptions import ClientError, NoCredentialsError
 from pydantic import Field
 
@@ -13,11 +15,13 @@ from opsmith.cloud_providers.base import (
     MachineType,
     MachineTypeList,
 )
+from opsmith.utils import WaitingSpinner
 
 
 class AWSCloudDetail(BaseCloudProviderDetail):
     name: Literal["AWS"] = Field(default="AWS", description="Provider name, 'AWS'")
     account_id: str = Field(..., description="AWS Account ID.")
+    ssm_plugin: str = Field(..., description="Path to session-manager-plugin executable.")
 
 
 class AWSProvider(BaseCloudProvider):
@@ -38,33 +42,35 @@ class AWSProvider(BaseCloudProvider):
         """The cloud provider detail model."""
         return AWSCloudDetail
 
-    def get_regions(self) -> list[tuple[str, str]]:
+    @staticmethod
+    def get_regions() -> list[tuple[str, str]]:
         """
         Retrieves a list of available AWS regions with their display names.
         """
-        # Get available region codes from EC2
-        ec2_client = boto3.client("ec2", region_name="us-east-1")
-        response = ec2_client.describe_regions()
-        available_region_codes = {region["RegionName"] for region in response["Regions"]}
-
-        # Get region descriptions from botocore's packaged data
-        session = botocore.session.get_session()
-        # The first partition is 'aws' which contains all standard regions
-        region_data = session.get_data("endpoints")["partitions"][0]["regions"]
-
-        regions = []
-        for code in available_region_codes:
-            data = region_data[code]
-            description = data.get("description", code.replace("-", " ").title())
-            regions.append((f"{description} ({code})", code))
-
-        return sorted(regions, key=lambda x: x[1])
-
-    def get_instance_types(self, region: str) -> MachineTypeList:
+        with WaitingSpinner(text="Fetching available regions from AWS Cloud Provider..."):
+            # Get available region codes from EC2
+            ec2_client = boto3.client("ec2", region_name="us-east-1")
+            response = ec2_client.describe_regions()
+            available_region_codes = {region["RegionName"] for region in response["Regions"]}
+
+            # Get region descriptions from botocore's packaged data
+            session = botocore.session.get_session()
+            # The first partition is 'aws' which contains all standard regions
+            region_data = session.get_data("endpoints")["partitions"][0]["regions"]
+
+            regions = []
+            for code in available_region_codes:
+                data = region_data[code]
+                description = data.get("description", code.replace("-", " ").title())
+                regions.append((f"{description} ({code})", code))
+
+            return sorted(regions, key=lambda x: x[1])
+
+    def get_instance_types(self) -> MachineTypeList:
         """
         Retrieves a list of available instance types for the given region using heuristics.
         """
-        ec2_client = boto3.client("ec2", region_name=region)
+        ec2_client = boto3.client("ec2", region_name=self.provider_detail.region)
 
         # Prioritize newer generation, general-purpose and compute-optimized instance families
         instance_families = [
@@ -129,6 +135,16 @@ class AWSProvider(BaseCloudProvider):
         Retrieves structured AWS account details.
         """
         try:
+            ssm_plugin_path = shutil.which("session-manager-plugin")
+            if not ssm_plugin_path:
+                raise CloudCredentialsError(
+                    message=(
+                        "'session-manager-plugin' not found. Please install the AWS Session Manager"
+                        " plugin."
+                    ),
+                    help_url="https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html",
+                )
+
             sts_client = boto3.client("sts")
             identity = sts_client.get_caller_identity()
             account_id = identity.get("Account")
@@ -140,7 +156,23 @@ class AWSProvider(BaseCloudProvider):
                     ),
                     help_url="https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html",
                 )
-            return AWSCloudDetail(account_id=account_id)
+
+            regions = AWSProvider.get_regions()
+            questions = [
+                inquirer.List(
+                    "region",
+                    message="Select an AWS region",
+                    choices=regions,
+                ),
+            ]
+            answers = inquirer.prompt(questions)
+            if not answers or not answers.get("region"):
+                raise ValueError("AWS region selection is required. Aborting.")
+            selected_region = answers["region"]
+
+            return AWSCloudDetail(
+                account_id=account_id, ssm_plugin=ssm_plugin_path, region=selected_region
+            )
         except (NoCredentialsError, ClientError) as e:
             raise CloudCredentialsError(
                 message=f"AWS credentials error: {e}",

{opsmith_cli-0.3.1b0 → opsmith_cli-0.4.0b0}/opsmith/cloud_providers/base.py

@@ -57,6 +57,7 @@ class MachineTypeList(BaseModel):
 
 class BaseCloudProviderDetail(BaseModel):
     name: str = Field(..., description="Provider name")
+    region: str = Field(..., description="The cloud provider region for this environment.")
 
 
 class CloudProviderRegistry:
@@ -160,7 +161,7 @@ class BaseCloudProvider(abc.ABC):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def get_instance_types(self, region: str) -> "MachineTypeList":
+    def get_instance_types(self) -> "MachineTypeList":
         """
         Retrieves a list of available instance types for the given region.
         """
@@ -172,11 +173,4 @@ class BaseCloudProvider(abc.ABC):
         Subclasses should implement specific authentication and setup.
         """
         self.provider_detail = TypeAdapter(self.get_detail_model()).validate_python(provider_detail)
-
-    @abc.abstractmethod
-    def get_regions(self) -> List[Tuple[str, str]]:
-        """
-        Retrieves a list of available regions for the cloud provider.
-        Returns a list of tuples, where each tuple contains the display name and the region code.
-        """
-        raise NotImplementedError
+        self.provider_detail_dump = self.provider_detail.model_dump(mode="json", exclude={"name"})

{opsmith_cli-0.3.1b0 → opsmith_cli-0.4.0b0}/opsmith/cloud_providers/gcp.py

@@ -15,6 +15,7 @@ from opsmith.cloud_providers.base import (
     MachineType,
     MachineTypeList,
 )
+from opsmith.utils import WaitingSpinner
 
 GCP_REGION_DESCRIPTIONS = {
     "africa-south1": "Johannesburg, South Africa",
@@ -62,6 +63,7 @@ GCP_REGION_DESCRIPTIONS = {
 class GCPCloudDetail(BaseCloudProviderDetail):
     name: Literal["GCP"] = Field(default="GCP", description="Provider name, 'GCP'")
     project_id: str = Field(..., description="GCP Project ID.")
+    zone: str = Field(..., description="The GCP zone for this environment.")
 
 
 class GCPProvider(BaseCloudProvider):
@@ -101,37 +103,47 @@ class GCPProvider(BaseCloudProvider):
             self._credentials, _ = google.auth.default()
         return self._credentials
 
-    def get_regions(self) -> list[tuple[str, str]]:
+    @staticmethod
+    def get_regions(project_id: str, credentials: Credentials) -> list[tuple[str, str]]:
         """
         Retrieves a list of available GCP regions using the GCP API.
         """
-        client = compute_v1.RegionsClient(credentials=self.get_credentials())
-        project_id = self.provider_detail.project_id
-
-        request = compute_v1.ListRegionsRequest(project=project_id)
-        pager = client.list(request=request)
+        with WaitingSpinner(text="Fetching available regions from GCP Cloud Provider..."):
+            client = compute_v1.RegionsClient(credentials=credentials)
+
+            request = compute_v1.ListRegionsRequest(project=project_id)
+            pager = client.list(request=request)
+
+            regions = []
+            for region in pager:
+                code = region.name
+                name = (
+                    GCP_REGION_DESCRIPTIONS.get(code)
+                    or region.description
+                    or code.replace("-", " ").title()
+                )
+                regions.append((f"{name} ({code})", code))
 
-        regions = []
-        for region in pager:
-            code = region.name
-            name = (
-                GCP_REGION_DESCRIPTIONS.get(code)
-                or region.description
-                or code.replace("-", " ").title()
-            )
-            regions.append((f"{name} ({code})", code))
+            return sorted(regions, key=lambda x: x[1])
 
-        return sorted(regions, key=lambda x: x[1])
+    @staticmethod
+    def get_zones(project_id: str, region_name: str, credentials: Credentials) -> list[str]:
+        """
+        Retrieves a list of available GCP zones for a given region.
+        """
+        client = compute_v1.RegionsClient(credentials=credentials)
+        request = compute_v1.GetRegionRequest(project=project_id, region=region_name)
+        region_details = client.get(request=request)
+        zones = [zone.split("/")[-1] for zone in region_details.zones]
+        return sorted(zones)
 
-    def get_instance_types(self, region: str) -> MachineTypeList:
+    def get_instance_types(self) -> MachineTypeList:
         """
-        Retrieves a list of available instance types for the given region using the GCP API.
+        Retrieves a list of available instance types for the given zone using the GCP API.
         """
         client = compute_v1.MachineTypesClient(credentials=self.get_credentials())
         project_id = self.provider_detail.project_id
-
-        # We need a zone to list machine types. We'll pick a zone in the region, assuming standard naming.
-        zone = f"{region}-a"
+        zone = self.provider_detail.zone
 
         request = compute_v1.ListMachineTypesRequest(project=project_id, zone=zone)
         pager = client.list(request=request)
@@ -183,7 +195,31 @@ class GCPProvider(BaseCloudProvider):
                 raise ValueError("GCP project selection is required. Aborting.")
 
             selected_project_id = answers["project_id"]
-            return GCPCloudDetail(project_id=selected_project_id)
+
+            regions = cls.get_regions(selected_project_id, credentials)
+            region_questions = [
+                inquirer.List(
+                    "region",
+                    message="Select a GCP region",
+                    choices=regions,
+                ),
+            ]
+            answers = inquirer.prompt(region_questions)
+            if not answers or not answers.get("region"):
+                raise ValueError("GCP region selection is required. Aborting.")
+
+            selected_region = answers["region"]
+
+            zones = cls.get_zones(selected_project_id, selected_region, credentials)
+            if not zones:
+                raise ValueError(f"No zones found for region '{selected_region}'.")
+
+            # For now, just use the first zone.
+            selected_zone = zones[0]
+
+            return GCPCloudDetail(
+                project_id=selected_project_id, region=selected_region, zone=selected_zone
+            )
 
         except DefaultCredentialsError as e:
             raise CloudCredentialsError(

{opsmith_cli-0.3.1b0 → opsmith_cli-0.4.0b0}/opsmith/deployment_strategies/base.py

@@ -9,16 +9,20 @@ from importlib.metadata import entry_points
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple, Type
 
-import yaml
 from pydantic_ai import Agent
 from rich import print
 
 from opsmith.agent import AgentDeps
-from opsmith.cloud_providers.base import BaseCloudProvider
+from opsmith.cloud_providers.base import BaseCloudProvider, MachineType
 from opsmith.infra_provisioners.ansible_provisioner import AnsibleProvisioner
 from opsmith.infra_provisioners.terraform_provisioner import TerraformProvisioner
 from opsmith.settings import settings
-from opsmith.types import DeploymentConfig, DeploymentEnvironment, ServiceTypeEnum
+from opsmith.types import (
+    DeploymentConfig,
+    DeploymentEnvironment,
+    ServiceTypeEnum,
+    VirtualMachineState,
+)
 from opsmith.utils import slugify
 
 
@@ -111,7 +115,7 @@ class BaseDeploymentStrategy(abc.ABC):
         """Sets up a container registry for the given region."""
         app_name = deployment_config.app_name_slug
         # Registry name should probably be unique per region for the app
-        registry_name = slugify(f"{app_name}-{environment.region}")
+        registry_name = slugify(f"{app_name}-{environment.cloud_provider_detail.region}")
 
         cloud_provider_instance = environment.cloud_provider_instance
         provider_name = cloud_provider_instance.name()
@@ -120,7 +124,7 @@ class BaseDeploymentStrategy(abc.ABC):
             self.deployments_path
             / "environments"
             / "global"
-            / f"{cloud_provider_instance.name()}-{environment.region}"
+            / f"{cloud_provider_instance.name()}-{environment.cloud_provider_detail.region}"
             / "container_registry"
         )
         tf = TerraformProvisioner(working_dir=registry_infra_path)
@@ -128,7 +132,7 @@ class BaseDeploymentStrategy(abc.ABC):
         variables = {
             "app_name": app_name,
             "registry_name": registry_name,
-            "region": environment.region,
+            "force_delete": "true",
         }
         env_vars = cloud_provider_instance.provider_detail.model_dump(mode="json")
 
@@ -201,17 +205,16 @@ class BaseDeploymentStrategy(abc.ABC):
 
             ansible_runner = AnsibleProvisioner(working_dir=build_infra_path)
 
-            provider_name = environment.cloud_provider["name"].lower()
+            provider_name = environment.cloud_provider_detail.name.lower()
 
             extra_vars = {
                 "docker_path": str(self.agent_deps.src_dir),
-                "dockerfile_name": str(dockerfile_path_abs),
+                "dockerfile_path": str(dockerfile_path_abs),
                 "image_name_slug": image_name_slug,
                 "image_tag_name": "latest",
-                "region": environment.region,
                 "registry_url": registry_url,
             }
-
+            extra_vars.update(environment.cloud_provider_instance.provider_detail_dump)
             ansible_runner.copy_template("docker_build_push", provider_name)
             outputs = ansible_runner.run_playbook("main.yml", extra_vars)
 
@@ -303,9 +306,9 @@ class BaseDeploymentStrategy(abc.ABC):
         self,
         deployment_config: DeploymentConfig,
         environment: DeploymentEnvironment,
-        instance_type: str,
+        machine_type: MachineType,
         cloud_provider: BaseCloudProvider,
-    ) -> Tuple[str, str]:
+    ) -> VirtualMachineState:
         """Creates a new virtual machine for the deployment."""
         provider_name = cloud_provider.name().lower()
         infra_path = self.deployments_path / "environments" / environment.name / "virtual_machine"
@@ -313,63 +316,61 @@ class BaseDeploymentStrategy(abc.ABC):
 
         variables = {
             "app_name": deployment_config.app_name_slug,
-            "instance_type": instance_type,
-            "region": environment.region,
+            "environment": environment.name,
+            "instance_type": machine_type.name,
+            "instance_arch": machine_type.architecture.value,
             "ssh_pub_key": self._get_ssh_public_key(),
         }
-        env_vars = cloud_provider.provider_detail.model_dump(mode="json")
+        env_vars = cloud_provider.provider_detail_dump
 
-        try:
-            tf.copy_template("virtual_machine", provider_name)
+        tf.copy_template("virtual_machine", provider_name)
 
-            tf.init_and_apply(variables, env_vars=env_vars)
+        tf.init_and_apply(variables, env_vars=env_vars)
 
-            outputs = tf.get_output()
-            print("[bold green]Monolithic infrastructure provisioned successfully.[/bold green]")
-            if outputs:
-                print("[bold green]Outputs:[/bold green]")
-                print(yaml.dump(outputs))
+        outputs = tf.get_output()
+        print("[bold green]Monolithic infrastructure provisioned successfully.[/bold green]")
 
-            instance_public_ip = outputs.get("instance_public_ip")
-            if not instance_public_ip:
-                print(
-                    "[bold red]Could not find 'instance_public_ip' in Terraform outputs.[/bold red]"
-                )
-                raise ValueError("Could not find 'instance_public_ip' in Terraform outputs.")
+        virtual_machine_state = VirtualMachineState(
+            ram_gb=machine_type.ram_gb,
+            cpu=machine_type.cpu,
+            instance_type=machine_type.name,
+            architecture=machine_type.architecture,
+            **outputs,
+        )
 
-            ansible_user = outputs.get("ansible_user")
-            if not ansible_user:
-                print("[bold red]Could not find 'ansible_user' in Terraform outputs.[/bold red]")
-                raise ValueError("Could not find 'ansible_user' in Terraform outputs.")
+        print("[bold blue]Waiting 15 seconds for instance to become ready...[/bold blue]")
+        time.sleep(15)
 
-            print("[bold blue]Waiting 15 seconds for instance to become ready...[/bold blue]")
-            time.sleep(15)
+        print("\n[bold blue]Setting up Docker on the newly created VM[/bold blue]")
 
-            print("\n[bold blue]Setting up Docker on the newly created VM[/bold blue]")
+        setup_docker_path = (
+            self.deployments_path / "environments" / environment.name / "virtual_machine_setup"
+        )
+        ansible_runner = AnsibleProvisioner(working_dir=setup_docker_path)
+        ansible_runner.copy_template("virtual_machine_setup", provider_name)
 
-            setup_docker_path = (
-                self.deployments_path / "environments" / environment.name / "docker_setup"
-            )
-            ansible_runner = AnsibleProvisioner(working_dir=setup_docker_path)
-            ansible_runner.copy_template("docker_setup", provider_name)
-            ansible_runner.run_playbook(
-                "main.yml",
-                extra_vars={},
-                inventory=instance_public_ip,
-                user=ansible_user,
-            )
-            print("[bold green]Docker setup complete.[/bold green]")
+        extra_vars = {
+            "environment_name": environment.name,
+            "app_name": deployment_config.app_name_slug,
+            **cloud_provider.provider_detail_dump,
+            **virtual_machine_state.model_dump(mode="json"),
+        }
+        # extra_vars.update(virtual_machine_state.model_dump(mode="json"))
+        # extra_vars.update(cloud_provider.provider_detail_dump)
 
-            return instance_public_ip, ansible_user
-        except (FileNotFoundError, subprocess.CalledProcessError) as e:
-            print(f"[bold red]Failed to set up monolithic infrastructure: {e}[/bold red]")
-            raise
+        ansible_runner.run_playbook(
+            "main.yml",
+            extra_vars=extra_vars,
+        )
+        print("[bold green]Docker setup complete.[/bold green]")
+
+        return virtual_machine_state
 
     def _fetch_remote_deployment_files(
         self,
+        deployment_config: DeploymentConfig,
         environment: DeploymentEnvironment,
-        instance_public_ip: str,
-        ansible_user: str,
+        virtual_machine: VirtualMachineState,
         remote_files: List[str],
     ) -> List[str]:
         print("\n[bold blue]Fetching current deployment files from server...[/bold blue]")
@@ -378,17 +379,20 @@ class BaseDeploymentStrategy(abc.ABC):
         )
 
         ansible_runner = AnsibleProvisioner(working_dir=fetch_files_path)
-        # We use 'common' as provider, since fetching is cloud-agnostic
-        ansible_runner.copy_template("fetch_remote_files", "common")
+        ansible_runner.copy_template(
+            "fetch_remote_files", environment.cloud_provider_instance.name()
+        )
         extra_vars = {
+            "app_name": deployment_config.app_name_slug,
+            "environment_name": environment.name,
             "remote_files": remote_files,
+            **virtual_machine.model_dump(mode="json"),
+            **environment.cloud_provider_instance.provider_detail_dump,
         }
 
         outputs = ansible_runner.run_playbook(
             "main.yml",
             extra_vars=extra_vars,
-            inventory=instance_public_ip,
-            user=ansible_user,
         )
 
         fetched_files_b64 = outputs.get("fetched_files", "")
@@ -430,8 +434,8 @@ class BaseDeploymentStrategy(abc.ABC):
 
         extra_vars = {
             "bucket_name": bucket_name,
-            "region": environment.region,
         }
+        extra_vars.update(environment.cloud_provider_instance.provider_detail_dump)
         ansible_runner.run_playbook("main.yml", extra_vars=extra_vars, inventory="localhost")
         print(f"[bold green]Bucket '{bucket_name}' emptied successfully.[/bold green]")