cloudcost-cli 0.1.0__py3-none-any.whl

backend/app/comments.py

@@ -0,0 +1,94 @@
+from decimal import Decimal, InvalidOperation
+from typing import Any
+
+
+CLOUDCOST_COMMENT_MARKER = "<!-- cloudcost-ai:infracost -->"
+
+
+def to_decimal(value: Any) -> Decimal | None:
+    if value is None or value == "":
+        return None
+    try:
+        return Decimal(str(value))
+    except (InvalidOperation, ValueError):
+        return None
+
+
+def format_money(value: Any, signed: bool = False) -> str:
+    amount = to_decimal(value)
+    if amount is None:
+        return "unknown"
+
+    sign = ""
+    if signed and amount > 0:
+        sign = "+"
+    quantized = amount.quantize(Decimal("0.01"))
+    return f"{sign}${quantized:,.2f}"
+
+
+def format_infracost_comment(
+    *,
+    plan_path: str,
+    diff_total_monthly_cost: Any,
+    total_monthly_cost: Any,
+    past_total_monthly_cost: Any,
+    pr_title: str,
+) -> str:
+    diff = to_decimal(diff_total_monthly_cost)
+    if diff is None:
+        verdict = "Infracost returned a result, but the monthly delta was not available."
+    elif diff > 0:
+        verdict = f"This pull request increases estimated monthly infrastructure cost by {format_money(diff, signed=True)}."
+    elif diff < 0:
+        verdict = f"This pull request reduces estimated monthly infrastructure cost by {format_money(diff, signed=True)}."
+    else:
+        verdict = "This pull request has no estimated monthly infrastructure cost change."
+
+    return "\n".join(
+        [
+            CLOUDCOST_COMMENT_MARKER,
+            "## CloudCost AI estimate",
+            "",
+            verdict,
+            "",
+            "| Metric | Estimate |",
+            "| --- | ---: |",
+            f"| Previous monthly cost | {format_money(past_total_monthly_cost)} |",
+            f"| Proposed monthly cost | {format_money(total_monthly_cost)} |",
+            f"| Diff total monthly cost | {format_money(diff_total_monthly_cost, signed=True)} |",
+            "",
+            f"Terraform plan JSON: `{plan_path}`",
+            f"Pull request: `{pr_title}`",
+            "",
+            "This comment was generated from Terraform plan JSON via the Infracost Plan JSON API.",
+        ]
+    )
+
+
+def format_no_plan_comment(pr_title: str) -> str:
+    return "\n".join(
+        [
+            CLOUDCOST_COMMENT_MARKER,
+            "## CloudCost AI estimate",
+            "",
+            "No Terraform plan JSON file was found in this pull request.",
+            "",
+            "Add a generated plan file such as `plan.json`, `tfplan.json`, or `terraform-plan.json` to let CloudCost AI calculate the monthly infrastructure cost delta.",
+            "",
+            f"Pull request: `{pr_title}`",
+        ]
+    )
+
+
+def format_error_comment(pr_title: str, message: str) -> str:
+    return "\n".join(
+        [
+            CLOUDCOST_COMMENT_MARKER,
+            "## CloudCost AI estimate",
+            "",
+            "CloudCost AI could not complete the cost estimate for this pull request.",
+            "",
+            f"Reason: `{message}`",
+            f"Pull request: `{pr_title}`",
+        ]
+    )

backend/app/config.py

@@ -0,0 +1,191 @@
+from functools import lru_cache
+import json
+from pathlib import Path
+from shutil import which
+from typing import Any
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", extra="ignore")
+
+    app_name: str = "CloudCost AI"
+    environment: str = "local"
+    public_base_url: str = "http://localhost:8000"
+    database_url: str | None = None
+    app_database_url: str | None = None
+
+    auth_secret: str | None = None
+    auth_session_cookie: str = "cloudcost_session"
+    auth_session_days: int = 14
+    auth_cookie_secure: bool = False
+    auth_otp_ttl_minutes: int = 10
+    auth_otp_max_attempts: int = 5
+    auth_dev_otp_log_path: str = "logs/auth-otp.log"
+
+    smtp_host: str | None = None
+    smtp_port: int = 587
+    smtp_username: str | None = None
+    smtp_password: str | None = None
+    smtp_from_email: str | None = None
+    smtp_use_tls: bool = True
+    resend_api_key: str | None = None
+    from_email: str | None = None
+    waitlist_confirmation_enabled: bool = True
+
+    github_api_url: str = "https://api.github.com"
+    github_api_version: str = "2026-03-10"
+    github_app_id: str | None = None
+    github_client_id: str | None = None
+    github_private_key: str | None = None
+    github_private_key_path: str | None = None
+    github_webhook_secret: str | None = None
+    github_manifest_config_path: str = "data/github-app-manifest.json"
+    comment_when_no_plan: bool = True
+
+    infracost_api_key: str | None = None
+    infracost_api_url: str = "https://pricing.api.infracost.io/breakdown"
+    infracost_ci_platform: str = "cloudcost-ai"
+    infracost_mode: str = "cli"
+    infracost_pricing_mode: str = "self_hosted"
+    infracost_cli_path: str = "infracost"
+    infracost_pricing_api_endpoint: str | None = None
+    infracost_timeout_seconds: int = 120
+
+    litellm_base_url: str = "http://127.0.0.1:4000"
+    litellm_master_key: str | None = None
+
+    usage_ingest_token: str | None = None
+    waitlist_path: str = "data/waitlist.jsonl"
+    usage_events_path: str = "data/usage-events.jsonl"
+
+    terraform_plan_names: str = Field(
+        default="plan.json,tfplan.json,terraform-plan.json,infracost-plan.json"
+    )
+    terraform_plan_suffixes: str = Field(default=".tfplan.json,.plan.json")
+
+    @property
+    def github_jwt_issuer(self) -> str:
+        manifest = self.load_github_manifest_config()
+        issuer = (
+            self.github_client_id
+            or self.github_app_id
+            or manifest.get("client_id")
+            or manifest.get("id")
+        )
+        if not issuer:
+            raise RuntimeError("Set GITHUB_CLIENT_ID or GITHUB_APP_ID for GitHub App auth.")
+        return str(issuer)
+
+    def load_github_manifest_config(self) -> dict[str, Any]:
+        path = Path(self.github_manifest_config_path)
+        if not path.exists():
+            return {}
+        try:
+            payload = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            return {}
+        return payload if isinstance(payload, dict) else {}
+
+    @property
+    def github_app_configured(self) -> bool:
+        manifest = self.load_github_manifest_config()
+        has_id = bool(
+            self.github_app_id
+            or self.github_client_id
+            or manifest.get("id")
+            or manifest.get("client_id")
+        )
+        has_key = bool(
+            self.github_private_key
+            or self.github_private_key_path
+            or manifest.get("private_key_path")
+            or manifest.get("pem")
+        )
+        has_secret = bool(self.github_webhook_secret or manifest.get("webhook_secret"))
+        return has_id and has_key and has_secret
+
+    @property
+    def backend_database_url(self) -> str | None:
+        return self.app_database_url or self.database_url
+
+    @property
+    def plan_names(self) -> set[str]:
+        return {item.strip().lower() for item in self.terraform_plan_names.split(",") if item.strip()}
+
+    @property
+    def plan_suffixes(self) -> tuple[str, ...]:
+        return tuple(
+            item.strip().lower() for item in self.terraform_plan_suffixes.split(",") if item.strip()
+        )
+
+    def load_github_private_key(self) -> str:
+        manifest = self.load_github_manifest_config()
+        if self.github_private_key:
+            return self.github_private_key.replace("\\n", "\n")
+        if self.github_private_key_path:
+            return Path(self.github_private_key_path).read_text(encoding="utf-8")
+        if manifest.get("private_key_path"):
+            return Path(str(manifest["private_key_path"])).read_text(encoding="utf-8")
+        if manifest.get("pem"):
+            return str(manifest["pem"]).replace("\\n", "\n")
+        raise RuntimeError("Set GITHUB_PRIVATE_KEY or GITHUB_PRIVATE_KEY_PATH.")
+
+    def require_github_webhook_secret(self) -> str:
+        manifest = self.load_github_manifest_config()
+        if not self.github_webhook_secret:
+            if manifest.get("webhook_secret"):
+                return str(manifest["webhook_secret"])
+            raise RuntimeError("Set GITHUB_WEBHOOK_SECRET.")
+        return self.github_webhook_secret
+
+    def require_manifest_state_secret(self) -> str:
+        secret = (
+            self.auth_secret
+            or self.litellm_master_key
+            or self.usage_ingest_token
+            or self.github_webhook_secret
+        )
+        if not secret:
+            raise RuntimeError("Set LITELLM_MASTER_KEY, USAGE_INGEST_TOKEN, or AUTH_SECRET.")
+        return secret
+
+    def require_infracost_api_key(self) -> str:
+        if not self.infracost_api_key:
+            raise RuntimeError("Set INFRACOST_API_KEY.")
+        return self.infracost_api_key
+
+    @property
+    def infracost_configured(self) -> bool:
+        mode = self.infracost_mode.lower()
+        if mode == "api":
+            return bool(self.infracost_api_key)
+        if mode == "cli":
+            if not self.infracost_cli_path:
+                return False
+            cli_path = Path(self.infracost_cli_path)
+            has_cli = cli_path.exists() or which(self.infracost_cli_path) is not None
+            if not has_cli:
+                return False
+            if self.infracost_pricing_mode.lower() == "cloudcost":
+                return bool(self.infracost_api_key and self.infracost_pricing_api_endpoint)
+            return bool(self.infracost_pricing_api_endpoint)
+        return False
+
+    def require_litellm_master_key(self) -> str:
+        if not self.litellm_master_key:
+            raise RuntimeError("Set LITELLM_MASTER_KEY.")
+        return self.litellm_master_key
+
+    def require_auth_secret(self) -> str:
+        secret = self.auth_secret or self.litellm_master_key or self.github_webhook_secret
+        if not secret:
+            raise RuntimeError("Set AUTH_SECRET or LITELLM_MASTER_KEY.")
+        return secret
+
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()