diagram-to-iac 1.3.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

diagram_to_iac/core/config_loader.py

@@ -16,113 +16,104 @@ logger = logging.getLogger(__name__)
 class ConfigLoader:
     """
     Central configuration management for the diagram-to-iac project.
-    Loads configuration from YAML files and provides environment variable override capability.
+    Loads configuration from central config.yaml file with environment variable override capability.
     """
     
-    def __init__(self, app_config_path: Optional[str] = None, system_config_path: Optional[str] = None):
+    def __init__(self, config_path: Optional[str] = None):
         """
-        Initialize ConfigLoader with optional custom config paths.
+        Initialize ConfigLoader with optional custom config path.
         
         Args:
-            app_config_path: Path to application config file (default: src/diagram_to_iac/config.yaml)
-            system_config_path: Path to system config file (default: config/system.yaml)
+            config_path: Path to central config file (default: src/diagram_to_iac/config.yaml)
         """
         self.logger = logging.getLogger(self.__class__.__name__)
         
-        # Set default paths
-        self.base_path = Path(__file__).parent.parent.parent.parent  # diagram-to-iac root
-        self.app_config_path = Path(app_config_path) if app_config_path else self.base_path / "src" / "diagram_to_iac" / "config.yaml"
-        self.system_config_path = Path(system_config_path) if system_config_path else self.base_path / "config" / "system.yaml"
+        # Set default paths (container-safe)
+        if config_path:
+            self.config_path = Path(config_path)
+        else:
+            # Try multiple locations for central config
+            possible_paths = [
+                Path.cwd() / "src" / "diagram_to_iac" / "config.yaml",  # Development
+                Path(__file__).parent.parent / "config.yaml",  # Package location
+                Path("/workspace/src/diagram_to_iac/config.yaml"),  # Container workspace
+                Path("/workspace/config.yaml"),  # Container root
+            ]
+            self.config_path = None
+            for path in possible_paths:
+                if path.exists():
+                    self.config_path = path
+                    break
+            # Default to package location if none found (will create defaults)
+            if not self.config_path:
+                self.config_path = Path(__file__).parent.parent / "config.yaml"
         
-        # Cache for loaded configs
-        self._app_config = None
-        self._system_config = None
-        self._merged_config = None
+        # Cache for loaded config
+        self._config = None
     
     @lru_cache(maxsize=1)
     def get_config(self) -> Dict[str, Any]:
         """
-        Get the complete merged configuration with environment variable overrides.
+        Get the complete configuration with environment variable overrides.
         
         Returns:
-            Merged configuration dictionary
+            Configuration dictionary
         """
-        if self._merged_config is None:
-            self._merged_config = self._load_and_merge_configs()
-        return self._merged_config
+        if self._config is None:
+            self._config = self._load_config()
+        return self._config
     
-    def _load_and_merge_configs(self) -> Dict[str, Any]:
+    def _load_config(self) -> Dict[str, Any]:
         """
-        Load and merge all configuration sources.
+        Load configuration from central config file.
         
         Returns:
-            Merged configuration dictionary
+            Configuration dictionary with environment overrides applied
         """
-        # Load base configs
-        app_config = self._load_app_config()
-        system_config = self._load_system_config()
-        
-        # Start with system config as base, overlay app config
-        merged = self._deep_merge(system_config, app_config)
+        # Load base config
+        config = self._load_config_file()
         
         # Apply environment variable overrides
-        merged = self._apply_env_overrides(merged)
+        config = self._apply_env_overrides(config)
         
-        self.logger.debug("Configuration loaded and merged successfully")
-        return merged
-    
-    def _load_app_config(self) -> Dict[str, Any]:
-        """Load application configuration from YAML file."""
-        if self._app_config is None:
-            try:
-                if self.app_config_path.exists():
-                    with open(self.app_config_path, 'r') as f:
-                        self._app_config = yaml.safe_load(f) or {}
-                    self.logger.debug(f"Loaded app config from {self.app_config_path}")
-                else:
-                    self.logger.warning(f"App config file not found: {self.app_config_path}")
-                    self._app_config = {}
-            except Exception as e:
-                self.logger.error(f"Failed to load app config: {e}")
-                self._app_config = {}
-        return self._app_config
+        self.logger.debug("Configuration loaded successfully")
+        return config
     
-    def _load_system_config(self) -> Dict[str, Any]:
-        """Load system configuration from YAML file."""
-        if self._system_config is None:
-            try:
-                if self.system_config_path.exists():
-                    with open(self.system_config_path, 'r') as f:
-                        self._system_config = yaml.safe_load(f) or {}
-                    self.logger.debug(f"Loaded system config from {self.system_config_path}")
-                else:
-                    self.logger.warning(f"System config file not found: {self.system_config_path}")
-                    self._system_config = {}
-            except Exception as e:
-                self.logger.error(f"Failed to load system config: {e}")
-                self._system_config = {}
-        return self._system_config
-    
-    def _deep_merge(self, base: Dict[str, Any], overlay: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Deep merge two dictionaries, with overlay taking precedence.
-        
-        Args:
-            base: Base dictionary
-            overlay: Dictionary to overlay on base
-            
-        Returns:
-            Merged dictionary
-        """
-        result = base.copy()
-        
-        for key, value in overlay.items():
-            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
-                result[key] = self._deep_merge(result[key], value)
+    def _load_config_file(self) -> Dict[str, Any]:
+        """Load configuration from central YAML file."""
+        try:
+            if self.config_path.exists():
+                with open(self.config_path, 'r') as f:
+                    config = yaml.safe_load(f) or {}
+                self.logger.debug(f"Loaded config from {self.config_path}")
             else:
-                result[key] = value
-        
-        return result
+                self.logger.warning(f"Config file not found at {self.config_path}, using built-in defaults")
+                config = self._get_default_config()
+        except Exception as e:
+            self.logger.error(f"Failed to load config: {e}")
+            config = self._get_default_config()
+        return config
+    
+    def _get_default_config(self) -> Dict[str, Any]:
+        """Get default configuration when config file is not available."""
+        return {
+            'system': {
+                'workspace_base': '/workspace',
+                'log_level': 'INFO'
+            },
+            'network': {
+                'api_timeout': 10,
+                'shell_timeout': 30,
+                'terraform_timeout': 300,
+                'github_timeout': 15,
+                'git_timeout': 300
+            },
+            'ai': {
+                'default_model': 'gpt-4o-mini',
+                'default_temperature': 0.1,
+                'max_tokens': 1000
+            }
+        }
     
     def _apply_env_overrides(self, config: Dict[str, Any]) -> Dict[str, Any]:
         """
@@ -246,10 +237,8 @@ class ConfigLoader:
             return default
     
     def reload(self) -> None:
-        """Reload configuration from files (clears cache)."""
-        self._app_config = None
-        self._system_config = None
-        self._merged_config = None
+        """Reload configuration from file (clears cache)."""
+        self._config = None
         self.get_config.cache_clear()
         self.logger.debug("Configuration cache cleared, will reload on next access")
 

diagram_to_iac/core/enhanced_memory.py

@@ -4,6 +4,13 @@ import json
 import os
 from pathlib import Path
 
+try:
+    from .config_loader import get_config_value
+except ImportError:
+    # Fallback for tests or standalone usage
+    def get_config_value(path: str, default: Any = None) -> Any:
+        return default
+
 # Abstract base for memory implementations
 class MemoryInterface(ABC):
     """Abstract interface for agent memory systems."""
@@ -94,11 +101,21 @@ class PersistentFileMemory(MemoryInterface):
     
     def __init__(self, file_path: Optional[str] = None):
         if file_path is None:
-            # Default to data/db directory
-            base_dir = Path(__file__).parent.parent.parent.parent
-            data_dir = base_dir / "data" / "db"
-            data_dir.mkdir(parents=True, exist_ok=True)
-            file_path = data_dir / "agent_memory.json"
+            # Get workspace base from config with fallback
+            workspace_base = get_config_value("system.workspace_base", "/workspace")
+            
+            # Default to workspace or /tmp directory for container safety
+            try:
+                # Try workspace first (from config)
+                base_dir = Path(workspace_base) if Path(workspace_base).exists() else Path.cwd()
+                data_dir = base_dir / "data" / "db"
+                data_dir.mkdir(parents=True, exist_ok=True)
+                file_path = data_dir / "agent_memory.json"
+            except (PermissionError, OSError):
+                # Fallback to /tmp for container environments
+                data_dir = Path("/tmp") / "diagram_to_iac" / "data" / "db"
+                data_dir.mkdir(parents=True, exist_ok=True)
+                file_path = data_dir / "agent_memory.json"
         
         self.file_path = Path(file_path)
         self._state: Dict[str, Any] = {}

diagram_to_iac/core/registry.py

@@ -33,6 +33,8 @@ from enum import Enum
 
 from pydantic import BaseModel, Field, field_validator
 
+from .config_loader import get_config_value
+
 
 class RunStatus(str, Enum):
     """Status values for deployment runs."""
@@ -126,9 +128,27 @@ class RunRegistry:
         if registry_path:
             self.registry_path = Path(registry_path)
         else:
-            # Default to data/state/issue_registry.json
-            base_path = Path(__file__).parent.parent.parent.parent
-            self.registry_path = base_path / "data" / "state" / "issue_registry.json"
+            # Get workspace base from config (with fallback)
+            workspace_base = get_config_value("system.workspace_base", "/workspace")
+            
+            # Try multiple locations for registry file
+            possible_paths = [
+                Path.cwd() / "data" / "state" / "issue_registry.json",  # Development
+                Path(workspace_base) / "data" / "state" / "issue_registry.json",  # Container workspace
+                Path("/tmp/diagram_to_iac/data/state/issue_registry.json"),  # Container fallback
+            ]
+            self.registry_path = None
+            for path in possible_paths:
+                try:
+                    path.parent.mkdir(parents=True, exist_ok=True)
+                    self.registry_path = path
+                    break
+                except (PermissionError, OSError):
+                    continue
+            
+            # Final fallback if all locations fail
+            if not self.registry_path:
+                self.registry_path = Path("/tmp/issue_registry.json")
         
         # Ensure the directory exists
         self.registry_path.parent.mkdir(parents=True, exist_ok=True)

diagram_to_iac/core/test_config.py

@@ -0,0 +1,123 @@
+"""
+Configuration loader for diagram-to-iac tests.
+
+This module provides utilities to load test configuration from the main config.yaml file,
+making test repository URLs and other test settings configurable and centralized.
+"""
+
+import os
+import yaml
+from pathlib import Path
+from typing import Dict, Any
+
+
+def load_test_config() -> Dict[str, Any]:
+    """
+    Load test configuration from the main config.yaml file.
+    
+    Returns:
+        Dict containing test configuration settings
+    """
+    # Find the config file relative to this module
+    # The config.yaml is at src/diagram_to_iac/config.yaml
+    # This file is at src/diagram_to_iac/core/test_config.py
+    # So we need to go up one directory
+    current_dir = Path(__file__).parent
+    config_path = current_dir.parent / "config.yaml"
+    
+    if not config_path.exists():
+        raise FileNotFoundError(f"Config file not found at {config_path}")
+    
+    with open(config_path, 'r') as f:
+        config = yaml.safe_load(f)
+    
+    return config.get('test', {})
+
+
+def get_test_repo_url() -> str:
+    """
+    Get the test repository URL from configuration.
+    
+    Returns:
+        The configured test repository URL
+    """
+    config = load_test_config()
+    return config.get('github', {}).get('test_repo_url', 'https://github.com/amartyamandal/test_iac_agent_private.git')
+
+
+def get_test_repo_owner() -> str:
+    """
+    Get the test repository owner from configuration.
+    
+    Returns:
+        The configured test repository owner
+    """
+    config = load_test_config()
+    return config.get('github', {}).get('test_repo_owner', 'amartyamandal')
+
+
+def get_test_repo_name() -> str:
+    """
+    Get the test repository name from configuration.
+    
+    Returns:
+        The configured test repository name
+    """
+    config = load_test_config()
+    return config.get('github', {}).get('test_repo_name', 'test_iac_agent_private')
+
+
+def get_public_test_repo_url() -> str:
+    """
+    Get the public test repository URL from configuration.
+    
+    Returns:
+        The configured public test repository URL
+    """
+    config = load_test_config()
+    return config.get('github', {}).get('public_test_repo_url', 'https://github.com/amartyamandal/test_iac_agent_public.git')
+
+
+def should_skip_integration_tests() -> bool:
+    """
+    Check if integration tests should be skipped when no GitHub token is available.
+    
+    Returns:
+        True if integration tests should be skipped without a token
+    """
+    config = load_test_config()
+    return config.get('settings', {}).get('skip_integration_tests_without_token', True)
+
+
+def should_use_real_github_api() -> bool:
+    """
+    Check if tests should use real GitHub API calls.
+    
+    Returns:
+        True if real GitHub API calls should be used
+    """
+    config = load_test_config()
+    return config.get('settings', {}).get('use_real_github_api', False)
+
+
+def should_mock_network_calls() -> bool:
+    """
+    Check if network calls should be mocked by default.
+    
+    Returns:
+        True if network calls should be mocked
+    """
+    config = load_test_config()
+    return config.get('settings', {}).get('mock_network_calls', True)
+
+
+# Convenience function for backwards compatibility
+def get_test_github_repo() -> str:
+    """
+    Get the test GitHub repository URL.
+    Alias for get_test_repo_url() for backwards compatibility.
+    
+    Returns:
+        The configured test repository URL
+    """
+    return get_test_repo_url()

diagram_to_iac/templates/issue_frontmatter.yml

@@ -0,0 +1,240 @@
+# Issue Frontmatter Template for R2D Umbrella Issues
+# =====================================================
+# This template provides the structured metadata format for GitHub issues
+# created by the DevOps-in-a-Box R2D Action.
+
+# Standard R2D Issue Metadata
+r2d_metadata:
+  # Core identifiers
+  run_key: "{run_key}"
+  repo_url: "{repo_url}"
+  commit_sha: "{commit_sha}"
+  job_name: "{job_name}"
+  
+  # Timestamps
+  created_at: "{created_at}"
+  updated_at: "{updated_at}"
+  
+  # Status tracking
+  status: "{status}"
+  wait_reason: "{wait_reason}"
+  
+  # Associated resources
+  umbrella_issue_id: "{umbrella_issue_id}"
+  linked_pr: "{linked_pr}"
+  branch_name: "{branch_name}"
+  thread_id: "{thread_id}"
+  
+  # Artifacts and outputs
+  artifacts_path: "{artifacts_path}"
+  terraform_summary: "{terraform_summary}"
+  
+  # Retry information
+  retry_count: {retry_count}
+  predecessor_run: "{predecessor_run}"
+  
+  # Agent status summary
+  agent_statuses:
+    supervisor:
+      status: "{supervisor_status}"
+      last_updated: "{supervisor_last_updated}"
+    git_agent:
+      status: "{git_agent_status}"
+      last_updated: "{git_agent_last_updated}"
+    terraform_agent:
+      status: "{terraform_agent_status}"
+      last_updated: "{terraform_agent_last_updated}"
+    shell_agent:
+      status: "{shell_agent_status}"
+      last_updated: "{shell_agent_last_updated}"
+
+# Issue Template Configuration
+issue_template:
+  title: "🚀 R2D Deployment: {repo_name} ({short_sha})"
+  labels:
+    - "r2d-deployment"
+    - "automated"
+    - "infrastructure"
+  assignees:
+    - "github-copilot"  # Auto-assign to GitHub Copilot for AI assistance
+  
+  # Issue body sections
+  body_sections:
+    header:
+      title: "## 🤖 DevOps-in-a-Box: Automated R2D Deployment"
+      content: |
+        This is an automated deployment issue created by the DevOps-in-a-Box R2D Action.
+        
+        **Repository:** {repo_url}
+        **Commit:** `{commit_sha}`
+        **Job:** {job_name}
+        **Started:** {created_at}
+    
+    status:
+      title: "## 📊 Deployment Status"
+      content: |
+        - **Overall Status:** {status}
+        - **Current Phase:** {current_phase}
+        - **Progress:** {progress_percentage}%
+        
+        {status_details}
+    
+    agents:
+      title: "## 🤖 Agent Status"
+      content: |
+        | Agent | Status | Last Updated | Notes |
+        |-------|--------|--------------|-------|
+        | Supervisor | {supervisor_status} | {supervisor_last_updated} | {supervisor_notes} |
+        | Git Agent | {git_agent_status} | {git_agent_last_updated} | {git_agent_notes} |
+        | Terraform Agent | {terraform_agent_status} | {terraform_agent_last_updated} | {terraform_agent_notes} |
+        | Shell Agent | {shell_agent_status} | {shell_agent_last_updated} | {shell_agent_notes} |
+    
+    resources:
+      title: "## 🔗 Related Resources"
+      content: |
+        - **Branch:** {branch_name}
+        - **Thread ID:** {thread_id}
+        - **Artifacts:** {artifacts_path}
+        {linked_resources}
+    
+    terraform:
+      title: "## ⚡ Terraform Operations"
+      content: |
+        ```
+        {terraform_summary}
+        ```
+    
+    logs:
+      title: "## 📋 Deployment Logs"
+      content: |
+        <details>
+        <summary>Click to view detailed logs</summary>
+        
+        ```
+        {deployment_logs}
+        ```
+        </details>
+    
+    commands:
+      title: "## 🔧 Available Commands"
+      content: |
+        You can control this deployment by commenting on this issue:
+        
+        - `retry` - Retry the current step
+        - `cancel` - Cancel the deployment
+        - `status` - Get current status
+        - `logs` - Show recent logs
+        - `help` - Show all available commands
+    
+    footer:
+      title: "## 🤖 Automation Info"
+      content: |
+        This issue is managed by the DevOps-in-a-Box R2D Action.
+        
+        **Run Key:** `{run_key}`
+        **Retry Count:** {retry_count}
+        **Predecessor:** {predecessor_run}
+        
+        ---
+        *Powered by [DevOps-in-a-Box](https://github.com/amartyamandal/diagram-to-iac)*
+
+# Status messages for different phases
+status_messages:
+  created: "🆕 Deployment created and queued"
+  in_progress: "🚀 Deployment in progress"
+  waiting_for_pat: "⏳ Waiting for Personal Access Token configuration"
+  waiting_for_pr: "🔄 Waiting for Pull Request review and merge"
+  completed: "✅ Deployment completed successfully"
+  failed: "❌ Deployment failed"
+  cancelled: "🛑 Deployment cancelled"
+
+# Progress indicators
+progress_indicators:
+  created: 10
+  in_progress: 50
+  waiting_for_pat: 30
+  waiting_for_pr: 80
+  completed: 100
+  failed: 0
+  cancelled: 0
+
+# Command responses
+command_responses:
+  retry: |
+    🔄 **Retry Requested**
+    
+    The deployment will be retried from the current step.
+    This may take a few minutes to start.
+    
+  cancel: |
+    🛑 **Cancellation Requested**
+    
+    The deployment has been marked for cancellation.
+    Any running operations will be stopped gracefully.
+    
+  status: |
+    📊 **Current Status**
+    
+    - **Phase:** {current_phase}
+    - **Progress:** {progress_percentage}%
+    - **Last Updated:** {last_updated}
+    
+    {detailed_status}
+    
+  help: |
+    🔧 **Available Commands**
+    
+    Comment on this issue with any of these commands:
+    
+    - `retry` - Retry the current step
+    - `cancel` - Cancel the deployment  
+    - `status` - Get current status
+    - `logs` - Show recent logs
+    - `help` - Show this help message
+    
+    **Note:** Only repository members can execute commands.
+
+# Error templates
+error_templates:
+  terraform_auth_error: |
+    ❌ **Terraform Authentication Error**
+    
+    The deployment failed because Terraform Cloud authentication is not properly configured.
+    
+    **Required Action:**
+    1. Ensure your `TFE_TOKEN` secret is set in repository settings
+    2. Verify the token has access to the required workspace
+    3. Comment `retry` to restart the deployment
+    
+  git_auth_error: |
+    ❌ **Git Authentication Error**
+    
+    The deployment failed because Git operations require authentication.
+    
+    **Required Action:**
+    1. Ensure your `GITHUB_TOKEN` has sufficient permissions
+    2. Verify repository access settings
+    3. Comment `retry` to restart the deployment
+    
+  missing_terraform_files: |
+    ❌ **Missing Terraform Files**
+    
+    The deployment failed because no Terraform files were found in the repository.
+    
+    **Required Action:**
+    1. Ensure your repository contains `.tf` files
+    2. Check that files are in the expected directory structure
+    3. Update the repository and create a new issue
+    
+  policy_violation: |
+    ❌ **Security Policy Violation**
+    
+    The deployment was blocked by security policies.
+    
+    **Details:**
+    {policy_details}
+    
+    **Required Action:**
+    1. Review and fix the security issues listed above
+    2. Update your Terraform code
+    3. Create a new deployment issue

diagram_to_iac/tools/api_utils.py

@@ -3,8 +3,14 @@ import os
 from openai import OpenAI
 from anthropic import Anthropic
 import requests
-import google.generativeai as genai
-import googleapiclient.discovery
+try:
+    import google.generativeai as genai
+except ImportError:
+    genai = None
+try:
+    import googleapiclient.discovery
+except ImportError:
+    googleapiclient = None
 from concurrent.futures import ThreadPoolExecutor, TimeoutError
 
 # Import centralized configuration
@@ -45,6 +51,10 @@ def test_openai_api():
 
 def test_gemini_api():
     try:
+        if genai is None:
+            print("❌ Gemini API error: google-generativeai package not installed.")
+            return False
+            
         google_api_key = os.environ.get("GOOGLE_API_KEY")
         if not google_api_key:
             print("❌ Gemini API error: GOOGLE_API_KEY environment variable not set.")