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

diagram_to_iac/services/step_summary.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import json
+import re
+from datetime import datetime
+from pathlib import Path
+
+
+def _parse_timestamp(ts: str) -> datetime:
+    try:
+        return datetime.fromisoformat(ts)
+    except Exception:
+        # Fallback for timestamps that may not be ISO formatted
+        return datetime.strptime(ts.split(".")[0], "%Y-%m-%dT%H:%M:%S")
+
+
+def generate_step_summary(log_path: str | Path, output_path: str | Path, *, stdout: bool = False) -> str:
+    """Generate a Markdown step summary from JSONL logs."""
+    log_path = Path(log_path)
+    output_path = Path(output_path)
+
+    modules: set[str] = set()
+    adds = changes = destroys = 0
+    critical = high = medium = low = 0
+    start: datetime | None = None
+    end: datetime | None = None
+
+    if not log_path.exists():
+        raise FileNotFoundError(log_path)
+
+    with log_path.open("r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            data = json.loads(line)
+            ts = data.get("timestamp")
+            if ts:
+                ts_dt = _parse_timestamp(ts)
+                if start is None or ts_dt < start:
+                    start = ts_dt
+                if end is None or ts_dt > end:
+                    end = ts_dt
+            result = data.get("result", "")
+            if result:
+                modules.update(re.findall(r"module\.([\w-]+)", result))
+                m = re.search(r"Plan:\s*(\d+)\s*to\s*add,\s*(\d+)\s*to\s*change,\s*(\d+)\s*to\s*destroy", result)
+                if m:
+                    adds = int(m.group(1))
+                    changes = int(m.group(2))
+                    destroys = int(m.group(3))
+                m = re.search(r"(\d+)\s*critical", result, re.IGNORECASE)
+                if m:
+                    critical = int(m.group(1))
+                m = re.search(r"(\d+)\s*high", result, re.IGNORECASE)
+                if m:
+                    high = int(m.group(1))
+                m = re.search(r"(\d+)\s*medium", result, re.IGNORECASE)
+                if m:
+                    medium = int(m.group(1))
+                m = re.search(r"(\d+)\s*low", result, re.IGNORECASE)
+                if m:
+                    low = int(m.group(1))
+
+    runtime = (end - start).total_seconds() if start and end else 0
+    modules_str = ", ".join(sorted(modules)) if modules else "root"
+
+    md = (
+        "| Module | Adds | Changes | Destroys | Critical | High | Medium | Low | Run Time (s) |\n"
+        "| --- | --- | --- | --- | --- | --- | --- | --- | --- |\n"
+        f"| {modules_str} | {adds} | {changes} | {destroys} | {critical} | {high} | {medium} | {low} | {int(runtime)} |\n"
+    )
+
+    output_path.write_text(md, encoding="utf-8")
+    if stdout:
+        print(md)
+    return md

diagram_to_iac/tools/__init__.py

@@ -0,0 +1,11 @@
+# This file makes the 'tools' module a package.
+
+# Note: Agent-specific tools organization:
+# - cal_utils, text_utils -> tools/hello/
+# - git_tools -> tools/git/ (moved from agents/git_langgraph/tools/)
+# - shell_tools -> agents/shell_langgraph/tools/
+
+# You can expose shared tools here as needed
+# For example:
+# from .llm_utils import router (if router.py is in llm_utils subdirectory)
+# from .cv_utils import some_vision_function

diagram_to_iac/tools/api_utils.py

@@ -5,9 +5,7 @@ from anthropic import Anthropic
 import requests
 import google.generativeai as genai
 import googleapiclient.discovery
-# Add the parent directory to sys.path to import env_loader
-# sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-# from scripts.env_loader import load_env_keys
+from concurrent.futures import ThreadPoolExecutor, TimeoutError
 
 def test_openai_api():
     try:
@@ -15,12 +13,20 @@ def test_openai_api():
             print("❌ OpenAI API error: OPENAI_API_KEY environment variable not set.")
             return False
         client = OpenAI()
-        response = client.chat.completions.create(
-            # Consider using a newer model if appropriate, e.g., "gpt-4o-mini" or "gpt-3.5-turbo"
-            model="gpt-3.5-turbo",
-            messages=[{"role": "user", "content": "Hello, are you working?"}],
-            max_tokens=10
-        )
+        
+        # Run the API call with a 10-second timeout
+        with ThreadPoolExecutor(max_workers=1) as executor:
+            future = executor.submit(
+                client.chat.completions.create,
+                model="gpt-3.5-turbo",
+                messages=[{"role": "user", "content": "Hello, are you working?"}],
+                max_tokens=10
+            )
+            try:
+                response = future.result(timeout=10)
+            except TimeoutError:
+                print("❌ OpenAI API error: request timed out.")
+                return False
         return True
     except Exception as e:
         print(f"❌ Open AI API error: {str(e)}")
@@ -33,8 +39,16 @@ def test_gemini_api():
             print("❌ Gemini API error: GOOGLE_API_KEY environment variable not set.")
             return False
         genai.configure(api_key=google_api_key)
-        model = genai.GenerativeModel('gemini-1.5-flash-latest') # Corrected model name
-        response = model.generate_content("Hello, are you working?")
+        model = genai.GenerativeModel('gemini-2.0-flash') # Corrected model name
+        
+        # Run the API call with a 10-second timeout
+        with ThreadPoolExecutor(max_workers=1) as executor:
+            future = executor.submit(model.generate_content, "Hello, are you working?")
+            try:
+                response = future.result(timeout=10)
+            except TimeoutError:
+                print("❌ Gemini API error: request timed out.")
+                return False
         return True
     except Exception as e:
         print(f"❌ Gemini API error: {str(e)}")
@@ -46,11 +60,20 @@ def test_anthropic_api():
             print("❌ Anthropic API error: ANTHROPIC_API_KEY environment variable not set.")
             return False
         client = Anthropic()
-        response = client.messages.create(
-            model="claude-3-haiku-20240307",
-            max_tokens=10,
-            messages=[{"role": "user", "content": "Hello, are you working?"}]
-        )
+        
+        # Run the API call with a 10-second timeout
+        with ThreadPoolExecutor(max_workers=1) as executor:
+            future = executor.submit(
+                client.messages.create,
+                model="claude-3-haiku-20240307",
+                max_tokens=10,
+                messages=[{"role": "user", "content": "Hello, are you working?"}]
+            )
+            try:
+                response = future.result(timeout=10)
+            except TimeoutError:
+                print("❌ Anthropic API error: request timed out.")
+                return False
         return True
     except Exception as e:
         print(f"❌ Anthropic API error: {str(e)}")
@@ -69,9 +92,18 @@ def test_github_api():
             "Accept": "application/vnd.github.v3+json"
         }
         
-        # Try to get the authenticated user
-        url = "https://api.github.com/user"
-        response = requests.get(url, headers=headers)
+        # Run the API call with a 10-second timeout
+        with ThreadPoolExecutor(max_workers=1) as executor:
+            future = executor.submit(
+                requests.get,
+                "https://api.github.com/user",
+                headers=headers
+            )
+            try:
+                response = future.result(timeout=10)
+            except TimeoutError:
+                print("❌ GitHub API error: request timed out.")
+                return False
         
         if response.status_code == 200:
             user_data = response.json()
@@ -85,25 +117,75 @@ def test_github_api():
         print(f"❌ GitHub API error: {str(e)}")
         return False
 
+def test_Terraform_API():
+    try:
+        if not os.environ.get("TFE_TOKEN"):
+            print("❌ Terraform API error: TFE_TOKEN environment variable not set.")
+            return False
+        headers = {
+            "Authorization": f"Bearer {os.environ.get('TFE_TOKEN')}",
+            "Content-Type": "application/vnd.api+json"
+        }
+        # Run the API call with a 10-second timeout
+        with ThreadPoolExecutor(max_workers=1) as executor:
+            future = executor.submit(
+                requests.get,
+                "https://app.terraform.io/api/v2/organizations",
+                headers=headers
+            )
+            try:
+                response = future.result(timeout=10)
+            except TimeoutError:
+                print("❌ Terraform API error: request timed out.")
+                return False
+        if response.status_code == 200:
+            org_data = response.json()
+            # print(f"✅ Terraform API works! Organizations: {org_data}")
+            return True
+        else:
+            print(f"❌ Terraform API error: Status code {response.status_code}")
+            if hasattr(response, 'text'):
+                print(f"   Response body: {response.text}")
+            return False
+    except requests.exceptions.ConnectionError as e:
+        print(f"❌ Terraform API error: Connection failed - {str(e)}")
+        print("   This could be due to:")
+        print("   - Network connectivity issues")
+        print("   - DNS resolution problems")
+        print("   - Firewall blocking the connection")
+        return False
+    except requests.exceptions.SSLError as e:
+        print(f"❌ Terraform API error: SSL/TLS error - {str(e)}")
+        return False
+    except requests.exceptions.Timeout as e:
+        print(f"❌ Terraform API error: Request timeout - {str(e)}")
+        return False
+    except requests.exceptions.RequestException as e:
+        print(f"❌ Terraform API error: Request failed - {str(e)}")
+        return False
+    except Exception as e:
+        print(f"❌ Terraform API error: Unexpected error - {str(e)}")
+        return False
+
 def test_all_apis():
     print("Hello from the test workflow!")
-    print("Loading environment keys...")
-    # Load environment keys once before running all tests
-    #load_env_keys()
+    
     
     print("Testing API connections...")
     openai_success = test_openai_api()
     gemini_success = test_gemini_api()
     anthropic_success = test_anthropic_api()
-    github_success = test_github_api()  # Added GitHub API test
+    github_success = test_github_api()  
+    terraform_success = test_Terraform_API()  
     
     print("\nSummary:")
     print(f"OpenAI API: {'✅ Working' if openai_success else '❌ Failed'}")
     print(f"Gemini API: {'✅ Working' if gemini_success else '❌ Failed'}")
     print(f"Anthropic API: {'✅ Working' if anthropic_success else '❌ Failed'}")
-    print(f"GitHub API: {'✅ Working' if github_success else '❌ Failed'}")  # Added GitHub API result
-    
-    if openai_success and gemini_success and anthropic_success and github_success:  # Updated condition
+    print(f"GitHub API: {'✅ Working' if github_success else '❌ Failed'}")  
+    print(f"Terraform API: {'✅ Working' if terraform_success else '❌ Failed'}")
+
+    if openai_success and gemini_success and anthropic_success and github_success and terraform_success:  # Updated condition
         print("\n🎉 All APIs are working correctly!")
     else:
         print("\n⚠️ Some APIs failed. Check the errors above.")

diagram_to_iac/tools/git/__init__.py

@@ -0,0 +1,45 @@
+"""
+Git Tools Package
+
+This package contains git-related tools and utilities:
+- git: Core git operations (clone, GitHub CLI)
+- git_config.yaml: Configuration for git operations
+
+Moved from agents/git_langgraph/tools for better organization.
+"""
+
+from .git import (
+    GitExecutor,
+    git_clone,
+    gh_open_issue,
+    get_git_executor,
+    GitCloneInput,
+    GitCloneOutput,
+    GhOpenIssueInput,
+    GhOpenIssueOutput,
+)
+
+# Ensure the tool functions reference the exported get_git_executor so that
+# tests can patch `diagram_to_iac.tools.git.get_git_executor` and have the
+# patch affect the functions imported from this package. Without this,
+# git_clone and gh_open_issue would retain references to the original function
+# defined in ``git.py`` making patching ineffective.
+import importlib
+
+def _patched_get_git_executor():
+    """Resolve get_git_executor dynamically so tests can patch it easily."""
+    return importlib.import_module(__name__).get_git_executor()
+
+git_clone.func.__globals__["get_git_executor"] = _patched_get_git_executor
+gh_open_issue.func.__globals__["get_git_executor"] = _patched_get_git_executor
+
+__all__ = [
+    "GitExecutor", 
+    "git_clone", 
+    "gh_open_issue",
+    "get_git_executor",
+    "GitCloneInput",
+    "GitCloneOutput",
+    "GhOpenIssueInput", 
+    "GhOpenIssueOutput"
+]