diagram-to-iac 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

diagram_to_iac/agents/terraform_langgraph/parser.py

@@ -0,0 +1,76 @@
+import json
+from typing import Any, Set
+
+
+def _flatten(obj: Any) -> str:
+    """Recursively convert a JSON object into a space separated string."""
+    if isinstance(obj, dict):
+        return " ".join(_flatten(v) for v in obj.values())
+    if isinstance(obj, list):
+        return " ".join(_flatten(i) for i in obj)
+    return str(obj)
+
+
+def classify_terraform_error(output: str) -> Set[str]:
+    """Classify Terraform JSON error output into common categories.
+
+    Parameters
+    ----------
+    output: str
+        Raw JSON error string returned by Terraform.
+
+    Returns
+    -------
+    Set[str]
+        A set of tags describing the error. Possible tags include
+        ``syntax_fmt``, ``needs_pat``, ``missing_backend`` and
+        ``policy_block``.
+    """
+    text = output
+    try:
+        data = json.loads(output)
+    except json.JSONDecodeError:
+        # Try newline separated JSON objects
+        parts = []
+        for line in output.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                parts.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+        if parts:
+            text = " ".join(_flatten(p) for p in parts)
+        else:
+            text = output
+    else:
+        text = _flatten(data)
+
+    lowered = text.lower()
+    tags: Set[str] = set()
+
+    if any(
+        keyword in lowered for keyword in ["syntax", "invalid", "parse", "unexpected"]
+    ):
+        tags.add("syntax_fmt")
+
+    if "token" in lowered and (
+        "unauthorized" in lowered
+        or "auth" in lowered
+        or "permission" in lowered
+        or "credential" in lowered
+    ):
+        tags.add("needs_pat")
+
+    if "backend" in lowered and any(
+        k in lowered for k in ["required", "missing", "no", "not configured"]
+    ):
+        tags.add("missing_backend")
+
+    if "policy" in lowered and any(
+        k in lowered for k in ["fail", "denied", "violation"]
+    ):
+        tags.add("policy_block")
+
+    return tags

diagram_to_iac/core/__init__.py

@@ -0,0 +1,7 @@
+from .issue_tracker import IssueTracker
+from .errors import MissingSecretError
+
+__all__ = [
+    "IssueTracker",
+    "MissingSecretError",
+]

diagram_to_iac/core/agent_base.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+
+class AgentBase(ABC):
+    """Abstract base class for all agents."""
+
+    @abstractmethod
+    def plan(self, *args, **kwargs):
+        """Generates a plan for the agent to execute."""
+        pass
+
+    @abstractmethod
+    def run(self, *args, **kwargs):
+        """Executes the agent's plan or a given task."""
+        pass
+
+    @abstractmethod
+    def report(self, *args, **kwargs):
+        """Reports the results or progress of the agent's execution."""
+        pass

diagram_to_iac/core/enhanced_memory.py

@@ -0,0 +1,302 @@
+from typing import Any, Dict, Optional, List
+from abc import ABC, abstractmethod
+import json
+import os
+from pathlib import Path
+
+# Abstract base for memory implementations
+class MemoryInterface(ABC):
+    """Abstract interface for agent memory systems."""
+    
+    @abstractmethod
+    def get_state(self) -> Dict[str, Any]:
+        """Retrieve the current state."""
+        pass
+    
+    @abstractmethod
+    def update_state(self, key: str, value: Any) -> None:
+        """Update a specific key in the state."""
+        pass
+    
+    @abstractmethod
+    def replace_state(self, new_state: Dict[str, Any]) -> None:
+        """Replace the entire state with a new one."""
+        pass
+    
+    @abstractmethod
+    def clear_state(self) -> None:
+        """Clear the state."""
+        pass
+    
+    @abstractmethod
+    def get_conversation_history(self) -> List[Dict[str, Any]]:
+        """Get conversation history."""
+        pass
+    
+    @abstractmethod
+    def add_to_conversation(self, role: str, content: str, metadata: Optional[Dict] = None) -> None:
+        """Add a message to conversation history."""
+        pass
+
+
+class InMemoryMemory(MemoryInterface):
+    """
+    Simple in-memory implementation of the memory interface.
+    Data is lost when the process ends.
+    """
+    
+    def __init__(self):
+        self._state: Dict[str, Any] = {}
+        self._conversation_history: List[Dict[str, Any]] = []
+
+    def get_state(self) -> Dict[str, Any]:
+        """Retrieve the current state."""
+        return self._state.copy()
+
+    def update_state(self, key: str, value: Any) -> None:
+        """Update a specific key in the state."""
+        self._state[key] = value
+
+    def replace_state(self, new_state: Dict[str, Any]) -> None:
+        """Replace the entire state with a new one."""
+        self._state = new_state.copy()
+
+    def clear_state(self) -> None:
+        """Clear the state."""
+        self._state = {}
+        self._conversation_history = []
+    
+    def get_conversation_history(self) -> List[Dict[str, Any]]:
+        """Get conversation history."""
+        return self._conversation_history.copy()
+    
+    def add_to_conversation(self, role: str, content: str, metadata: Optional[Dict] = None) -> None:
+        """Add a message to conversation history."""
+        message = {
+            "role": role,
+            "content": content,
+            "timestamp": self._get_timestamp(),
+            "metadata": metadata or {}
+        }
+        self._conversation_history.append(message)
+    
+    def _get_timestamp(self) -> str:
+        """Get current timestamp as ISO string."""
+        from datetime import datetime
+        return datetime.now().isoformat()
+
+
+class PersistentFileMemory(MemoryInterface):
+    """
+    File-based memory implementation that persists state to disk.
+    Useful for maintaining state across agent restarts.
+    """
+    
+    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"
+        
+        self.file_path = Path(file_path)
+        self._state: Dict[str, Any] = {}
+        self._conversation_history: List[Dict[str, Any]] = []
+        self._load_data()
+
+    def _load_data(self) -> None:
+        """Load state from the file."""
+        if self.file_path.exists():
+            try:
+                with open(self.file_path, 'r') as f:
+                    data = json.load(f)
+                    self._state = data.get('state', {})
+                    self._conversation_history = data.get('conversation_history', [])
+            except (json.JSONDecodeError, KeyError) as e:
+                print(f"Warning: Could not load memory from {self.file_path}: {e}")
+                self._state = {}
+                self._conversation_history = []
+        else:
+            self._state = {}
+            self._conversation_history = []
+
+    def _save_data(self) -> None:
+        """Save current state to the file."""
+        try:
+            self.file_path.parent.mkdir(parents=True, exist_ok=True)
+            data = {
+                'state': self._state,
+                'conversation_history': self._conversation_history
+            }
+            with open(self.file_path, 'w') as f:
+                json.dump(data, f, indent=2)
+        except Exception as e:
+            print(f"Warning: Could not save memory to {self.file_path}: {e}")
+
+    def get_state(self) -> Dict[str, Any]:
+        """Retrieve the current state."""
+        return self._state.copy()
+
+    def update_state(self, key: str, value: Any) -> None:
+        """Update a specific key in the state."""
+        self._state[key] = value
+        self._save_data()
+
+    def replace_state(self, new_state: Dict[str, Any]) -> None:
+        """Replace the entire state with a new one."""
+        self._state = new_state.copy()
+        self._save_data()
+
+    def clear_state(self) -> None:
+        """Clear the state and remove the file."""
+        self._state = {}
+        self._conversation_history = []
+        # Remove the file completely
+        if self.file_path.exists():
+            try:
+                self.file_path.unlink()
+            except Exception as e:
+                print(f"Warning: Could not remove memory file {self.file_path}: {e}")
+    
+    def get_conversation_history(self) -> List[Dict[str, Any]]:
+        """Get conversation history."""
+        return self._conversation_history.copy()
+    
+    def add_to_conversation(self, role: str, content: str, metadata: Optional[Dict] = None) -> None:
+        """Add a message to conversation history."""
+        message = {
+            "role": role,
+            "content": content,
+            "timestamp": self._get_timestamp(),
+            "metadata": metadata or {}
+        }
+        self._conversation_history.append(message)
+        self._save_data()
+    
+    def _get_timestamp(self) -> str:
+        """Get current timestamp as ISO string."""
+        from datetime import datetime
+        return datetime.now().isoformat()
+
+
+class LangGraphMemoryAdapter(MemoryInterface):
+    """
+    Adapter to integrate custom memory with LangGraph's checkpointer system.
+    Provides a bridge between our memory interface and LangGraph's state management.
+    """
+    
+    def __init__(self, base_memory: MemoryInterface):
+        self.base_memory = base_memory
+    
+    def get_state(self) -> Dict[str, Any]:
+        """Retrieve the current state."""
+        return self.base_memory.get_state()
+    
+    def update_state(self, key: str, value: Any) -> None:
+        """Update a specific key in the state."""
+        self.base_memory.update_state(key, value)
+    
+    def replace_state(self, new_state: Dict[str, Any]) -> None:
+        """Replace the entire state with a new one."""
+        self.base_memory.replace_state(new_state)
+    
+    def clear_state(self) -> None:
+        """Clear the state."""
+        self.base_memory.clear_state()
+    
+    def get_conversation_history(self) -> List[Dict[str, Any]]:
+        """Get conversation history."""
+        return self.base_memory.get_conversation_history()
+    
+    def add_to_conversation(self, role: str, content: str, metadata: Optional[Dict] = None) -> None:
+        """Add a message to conversation history."""
+        self.base_memory.add_to_conversation(role, content, metadata)
+    
+    def sync_from_langgraph_state(self, langgraph_state: Dict[str, Any]) -> None:
+        """
+        Sync state from LangGraph state format to memory.
+        
+        Args:
+            langgraph_state: State dictionary from LangGraph
+        """
+        # Store the entire LangGraph state
+        self.base_memory.update_state("langgraph_state", langgraph_state)
+        
+        # Also extract and store specific components for convenience
+        if "tool_output" in langgraph_state and langgraph_state["tool_output"]:
+            self.base_memory.update_state("last_tool_outputs", langgraph_state["tool_output"])
+        
+        # Add timestamp for sync tracking
+        from datetime import datetime
+        self.base_memory.update_state("last_sync", datetime.now().isoformat())
+    
+    def sync_to_langgraph_state(self, base_langgraph_state: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Sync state from our memory to LangGraph state format.
+        
+        Args:
+            base_langgraph_state: Base LangGraph state to merge memory context into
+            
+        Returns:
+            Updated LangGraph state with memory context
+        """
+        # Start with the base state
+        updated_state = base_langgraph_state.copy()
+        
+        # Get current memory state and conversation
+        state = self.get_state()
+        conversation = self.get_conversation_history()
+        
+        # Create memory context
+        memory_context = {}
+        
+        # Add conversation history to memory context
+        if conversation:
+            memory_context["conversation_history"] = conversation
+        
+        # Add other memory state (excluding special keys)
+        for key, value in state.items():
+            if key not in ["langgraph_state", "last_sync"]:
+                memory_context[key] = value
+        
+        # Add memory context to the updated state
+        updated_state["memory_context"] = memory_context
+        
+        return updated_state
+    
+    def get_checkpoint_metadata(self) -> Dict[str, Any]:
+        """Get metadata for LangGraph checkpoint."""
+        return {
+            "conversation_length": len(self.get_conversation_history()),
+            "state_keys": list(self.get_state().keys()),
+            "last_updated": self.base_memory._get_timestamp() if hasattr(self.base_memory, '_get_timestamp') else None
+        }
+
+
+# Factory function for easy memory creation
+def create_memory(memory_type: str = "in_memory", **kwargs) -> MemoryInterface:
+    """
+    Factory function to create memory instances.
+    
+    Args:
+        memory_type: Type of memory to create ("in_memory", "memory", "persistent", or "langgraph")
+        **kwargs: Additional arguments for memory initialization
+    
+    Returns:
+        MemoryInterface: Configured memory instance
+    """
+    if memory_type in ("in_memory", "memory"):
+        return InMemoryMemory()
+    elif memory_type == "persistent":
+        return PersistentFileMemory(**kwargs)
+    elif memory_type == "langgraph":
+        # Create LangGraph adapter with specified base memory type
+        base_memory_type = kwargs.pop('base_memory_type', 'in_memory')
+        if base_memory_type == "persistent":
+            base_memory = PersistentFileMemory(**kwargs)
+        else:
+            base_memory = InMemoryMemory()
+        return LangGraphMemoryAdapter(base_memory)
+    else:
+        raise ValueError(f"Unknown memory type: {memory_type}")

diagram_to_iac/core/errors.py

@@ -0,0 +1,4 @@
+class MissingSecretError(RuntimeError):
+    """Raised when a required secret environment variable is missing."""
+
+

diagram_to_iac/core/issue_tracker.py

@@ -0,0 +1,49 @@
+import json
+from pathlib import Path
+from typing import Dict, Optional
+
+class IssueTracker:
+    """Simple persistent tracker for GitHub issues keyed by repo and error type."""
+
+    def __init__(self, file_path: Optional[str] = None):
+        if file_path is None:
+            base_dir = Path(__file__).resolve().parents[3]
+            file_path = base_dir / "data" / "db" / "issue_tracker.json"
+        self.file_path = Path(file_path)
+        self._table: Dict[str, Dict[str, int]] = {}
+        self._load()
+
+    def _load(self) -> None:
+        if self.file_path.exists():
+            try:
+                with open(self.file_path, "r") as f:
+                    self._table = json.load(f)
+            except Exception:
+                self._table = {}
+        else:
+            self.file_path.parent.mkdir(parents=True, exist_ok=True)
+            self._table = {}
+
+    def _save(self) -> None:
+        try:
+            self.file_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(self.file_path, "w") as f:
+                json.dump(self._table, f, indent=2)
+        except Exception:
+            pass
+
+    def get_issue(self, repo_url: str, error_type: str) -> Optional[int]:
+        return self._table.get(repo_url, {}).get(error_type)
+
+    def record_issue(self, repo_url: str, error_type: str, issue_id: int) -> None:
+        repo_map = self._table.setdefault(repo_url, {})
+        repo_map[error_type] = issue_id
+        self._save()
+
+    def clear(self) -> None:
+        self._table = {}
+        if self.file_path.exists():
+            try:
+                self.file_path.unlink()
+            except Exception:
+                pass

diagram_to_iac/core/memory.py

@@ -0,0 +1,132 @@
+from typing import Any, Dict, List, Optional
+import json
+import os
+from pathlib import Path
+from subprocess import check_output, CalledProcessError
+# Intended to be a thin wrapper over LangGraph's StateGraph node store.
+# For now, a simple dictionary-based state.
+
+class Memory:
+    """
+    Thin wrapper over LangGraph’s StateGraph node store;
+    later could be swapped for Redis or another persistent store.
+    LangGraph nodes can read/write via graph.state.
+    This class provides a conceptual placeholder for that state management.
+    """
+    def __init__(self):
+        self._state: Dict[str, Any] = {}
+
+    def get_state(self) -> Dict[str, Any]:
+        """Retrieves the current state."""
+        return self._state
+
+    def update_state(self, key: str, value: Any) -> None:
+        """Updates a specific key in the state."""
+        self._state[key] = value
+
+    def replace_state(self, new_state: Dict[str, Any]) -> None:
+        """Replaces the entire state with a new one."""
+        self._state = new_state
+
+    def clear_state(self) -> None:
+        """Clears the state."""
+        self._state = {}
+
+# Enhanced memory system - import the new capabilities
+from .enhanced_memory import (
+    MemoryInterface, 
+    InMemoryMemory, 
+    PersistentFileMemory, 
+    LangGraphMemoryAdapter,
+    create_memory
+)
+
+# Add conversation tracking to the original Memory class
+class EnhancedMemory(Memory):
+    """
+    Enhanced version of the original Memory class with conversation tracking.
+    Provides backward compatibility while adding new features.
+    """
+    
+    def __init__(self):
+        super().__init__()
+        self._conversation_history: List[Dict[str, Any]] = []
+    
+    def get_conversation_history(self) -> List[Dict[str, Any]]:
+        """Get conversation history."""
+        return self._conversation_history.copy()
+    
+    def add_to_conversation(self, role: str, content: str, metadata: Optional[Dict] = None) -> None:
+        """Add a message to conversation history."""
+        from datetime import datetime
+        message = {
+            "role": role,
+            "content": content,
+            "timestamp": datetime.now().isoformat(),
+            "metadata": metadata or {}
+        }
+        self._conversation_history.append(message)
+    
+    def clear_state(self) -> None:
+        """Clear both state and conversation history."""
+        super().clear_state()
+        self._conversation_history = []
+
+# Example of how it might be used with LangGraph (conceptual)
+# from langgraph.graph import StateGraph
+#
+# class AgentState(TypedDict):
+#     input_query: str
+#     processed_data: Any
+#     final_result: str
+#
+# graph = StateGraph(AgentState)
+# memory_instance = Memory() # This would be integrated with the graph's actual state mechanism
+
+# --- Agent state persistence helpers ---
+
+# Default path for the persistent agent state JSON file. Allows override via
+# `AGENT_STATE_FILE` environment variable for testing.
+_DEFAULT_AGENT_STATE_PATH = (
+    Path(__file__).resolve().parents[3]
+    / "state"
+    / ".agent_state"
+    / "agent_state.json"
+)
+AGENT_STATE_PATH = Path(os.environ.get("AGENT_STATE_FILE", _DEFAULT_AGENT_STATE_PATH))
+
+
+def agent_state_enabled() -> bool:
+    """Return ``True`` if persistent agent state should be used."""
+    return os.environ.get("AGENT_STATE_ENABLED", "0") == "1"
+
+
+def load_agent_state() -> Dict[str, Any]:
+    """Load agent state from ``AGENT_STATE_PATH`` if it exists and persistence is enabled."""
+    if not agent_state_enabled():
+        return {}
+    if AGENT_STATE_PATH.exists():
+        try:
+            with open(AGENT_STATE_PATH, "r") as f:
+                return json.load(f)
+        except json.JSONDecodeError:
+            return {}
+    return {}
+
+
+def save_agent_state(state: Dict[str, Any]) -> None:
+    """Persist agent state to ``AGENT_STATE_PATH`` if persistence is enabled."""
+    if not agent_state_enabled():
+        return
+    AGENT_STATE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with open(AGENT_STATE_PATH, "w") as f:
+        json.dump(state, f, indent=2)
+
+
+def current_git_sha() -> Optional[str]:
+    """Return the current git commit SHA, or ``None`` if unavailable."""
+    try:
+        return check_output(["git", "rev-parse", "HEAD"], text=True).strip()
+    except Exception:
+        return None
+

diagram_to_iac/services/__init__.py

@@ -0,0 +1,10 @@
+from .observability import LogBus, log_event, get_log_path, reset_log_bus
+from .step_summary import generate_step_summary
+
+__all__ = [
+    "LogBus",
+    "log_event",
+    "get_log_path",
+    "reset_log_bus",
+    "generate_step_summary",
+]

diagram_to_iac/services/observability.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+import threading
+from typing import Any, Dict
+
+
+class LogBus:
+    """Simple JSONL logging service."""
+
+    def __init__(self, log_dir: str | Path | None = None) -> None:
+        self.log_dir = Path(log_dir) if log_dir else Path(__file__).resolve().parents[3] / "logs"
+        self.log_dir.mkdir(parents=True, exist_ok=True)
+        timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        self.log_path = self.log_dir / f"run-{timestamp}.jsonl"
+        self._lock = threading.Lock()
+
+    def log(self, event: Dict[str, Any]) -> None:
+        """Append an event as a JSON line with timestamp."""
+        payload = event.copy()
+        payload.setdefault("timestamp", datetime.now(timezone.utc).isoformat())
+        line = json.dumps(payload)
+        with self._lock:
+            try:
+                with open(self.log_path, "a", encoding="utf-8") as f:
+                    f.write(line + "\n")
+            except Exception as exc:  # noqa: BLE001
+                # Logging should never raise; print error and continue
+                print(f"LogBus write failed: {exc}")
+
+
+_global_bus: LogBus | None = None
+
+
+def _get_bus() -> LogBus:
+    global _global_bus
+    if _global_bus is None:
+        _global_bus = LogBus()
+    return _global_bus
+
+
+def log_event(event_type: str, **kwargs: Any) -> None:
+    """Write a structured log event using the global bus."""
+    event = {"type": event_type, **kwargs}
+    _get_bus().log(event)
+
+
+def get_log_path() -> Path:
+    """Return the path of the current log file."""
+    return _get_bus().log_path
+
+
+def reset_log_bus() -> None:
+    """Create a fresh global log bus with a new log file."""
+    global _global_bus
+    # Nothing to close since LogBus opens files on demand
+    _global_bus = LogBus()