wip

CLAUDE.md

@@ -31,12 +31,18 @@
 ```
 src/
 ├── agents/
-│   └── code_analyzer.py    # CodeAnalyzerAgent for business logic extraction
+│   ├── code_analyzer.py    # CodeAnalyzerAgent for business logic extraction
+│   └── ada_converter.py    # AdaConverterAgent for Ada to Python conversion
+├── tools/
+│   └── project_handler.py  # Zip extraction and file handling utilities
+├── ui.py                   # Gradio UI components and logic
 └── main.py                 # CLI interface for development/testing
 tests/
 ├── test_code_analyzer_agent.py  # Unit tests for CodeAnalyzerAgent
+├── test_ada_converter_agent.py  # Unit tests for AdaConverterAgent
+├── test_project_handler.py      # Unit tests for project handler
 └── tictactoe.ads           # Sample Ada file for testing
-app.py                      # Gradio web interface
+app.py                      # Application entry point and agent initialization
 requirements.txt            # Generated from uv dependencies
 pyproject.toml             # Project configuration and dependencies
 .env                       # Environment configuration
@@ -48,6 +54,12 @@ pyproject.toml             # Project configuration and dependencies
     * extract_business_logic() method analyzes Ada code via LLM
     * Returns structured JSON with core algorithms, data structures, business rules
     * Handles JSON parsing errors with fallback responses
+  
+  * **AdaConverterAgent**: Converts Ada code to Python code
+    * Uses dependency injection pattern (model passed as parameter)
+    * convert_to_python() method converts Ada files to equivalent Python code
+    * Follows Ada to Python conversion principles (procedures→functions, packages→modules, etc.)
+    * Generates clean, PEP 8 compliant Python code with type hints
 
 ## Hosting Platform
   * Hugging Face Spaces with Gradio SDK

app.py

@@ -2,6 +2,7 @@ import os
 from dotenv import load_dotenv
 from smolagents import LiteLLMModel, OpenAIServerModel
 from src.agents.code_analyzer import CodeAnalyzerAgent
+from src.agents.ada_converter import AdaConverterAgent
 from src.ui import create_interface
 from langfuse import get_client
 from openinference.instrumentation.smolagents import SmolagentsInstrumentor
@@ -19,8 +20,8 @@ else:
 
 SmolagentsInstrumentor().instrument()
 
-def initialize_analyzer():
-    """Initialize the CodeAnalyzerAgent with appropriate model"""
+def initialize_agents():
+    """Initialize the agents with appropriate model"""
     environment = os.getenv("ENVIRONMENT", "development")
     temperature = 0.1
 
@@ -38,10 +39,13 @@ def initialize_analyzer():
             temperature=temperature
         )
     
-    return CodeAnalyzerAgent(model)
+    analyzer = CodeAnalyzerAgent(model)
+    converter = AdaConverterAgent(model)
+    
+    return analyzer, converter
 
 # Create Gradio interface
 if __name__ == "__main__":
-    analyzer = initialize_analyzer()
-    app = create_interface(analyzer)
+    analyzer, converter = initialize_agents()
+    app = create_interface(analyzer, converter)
     app.launch()

src/agents/ada_converter.py

@@ -0,0 +1,64 @@
+"""Ada to Python converter agent."""
+
+from smolagents import ToolCallingAgent, FinalAnswerTool
+
+
+class AdaConverterAgent:
+    """Agent that converts Ada code to Python code."""
+    
+    def __init__(self, model):
+        """Initialize the converter agent with a model."""
+        self.model = model
+        self.converter_agent = ToolCallingAgent(
+            model=self.model,
+            tools=[FinalAnswerTool()],
+        )
+    
+    def convert_to_python(self, ada_file_path):
+        """Convert Ada file to Python code."""
+        try:
+            # Read the Ada file
+            with open(ada_file_path, 'r', encoding='utf-8') as f:
+                ada_code = f.read()
+            
+            # Create the conversion prompt
+            prompt = f"""You are an expert Ada and Python programmer. Your task is to convert Ada code to equivalent Python code.
+
+Key conversion principles:
+1. Convert Ada procedures to Python functions
+2. Convert Ada packages to Python modules/classes
+3. Convert Ada types to appropriate Python types
+4. Convert Ada control structures to Python equivalents
+5. Convert Ada exception handling to Python try/except
+6. Maintain the original logic and functionality
+7. Use Pythonic idioms and conventions
+8. Add appropriate type hints where beneficial
+
+Always provide clean, readable Python code that follows PEP 8 standards.
+
+Convert the following Ada code to Python:
+
+```ada
+{ada_code}
+```
+
+Please provide only the Python code without any explanations or markdown formatting."""
+            
+            # Run the conversion
+            result = self.converter_agent.run(prompt)
+            
+            # Extract response text like CodeAnalyzerAgent does
+            return self._extract_response_text(result)
+            
+        except Exception as e:
+            return f"Error converting Ada code: {str(e)}"
+    
+    def _extract_response_text(self, result) -> str:
+        """Extract text response from ToolCallingAgent result"""
+
+        print(f"_extract_response_text result = {result}")
+
+        if hasattr(result, 'messages') and result.messages:
+            return str(result.messages[-1].content)
+        else:
+            return str(result)

src/agents/code_analyzer.py

@@ -8,10 +8,9 @@ This agent is responsible for:
 4. Generating analysis reports for conversion
 """
 
-from typing import Dict, Any, Union
+from typing import Any, Union
 from pathlib import Path
 from smolagents import ToolCallingAgent, FinalAnswerTool
-import json
 
 class CodeAnalyzerAgent:
     """Agent specialized in analyzing Ada codebases"""
@@ -28,21 +27,14 @@ class CodeAnalyzerAgent:
         self.supported_extensions = ['.ads', '.adb', '.ada']
         self.analysis_results = {}
     
-    def _parse_llm_response(self, response: str) -> Dict[str, Any]:
-        """Parse LLM response and extract JSON analysis"""
-        import json
-        import re
-
-        return json.loads(response);
-            
     def _extract_response_text(self, result) -> str:
         """Extract text response from CodeAgent result"""
         if hasattr(result, 'messages') and result.messages:
             return str(result.messages[-1].content)
         else:
-            return str(result).replace("\n", "")
+            return str(result)
     
-    def extract_business_logic(self, ada_file_path: Union[Path, str]) -> Dict[str, Any]:
+    def extract_business_logic(self, ada_file_path: Union[Path, str]) -> str:
         """
         Extract business logic patterns from Ada file using LLM
         
@@ -70,10 +62,10 @@ class CodeAnalyzerAgent:
             # Use the code agent to analyze business logic
             result = self.code_agent.run(analysis_prompt)
             
-            # Extract response text from RunResult
+            # Extract response text from RunResult (now markdown)
             response_text = self._extract_response_text(result)
             
-            return json.loads(response_text)
+            return response_text
             
         except Exception as e:
             print(f"LLM business logic analysis failed: {e}")
@@ -82,64 +74,62 @@ class CodeAnalyzerAgent:
     def _create_business_logic_prompt(self, file_path: Path, file_content: str) -> str:
         """Create structured business logic analysis prompt for LLM"""
         return f"""
-        Analyze the business logic of this Ada code and return ONLY a JSON object.
-        Do not write code or execute anything - just analyze and respond with JSON.
+        Analyze the business logic of this Ada code and return a well-formatted markdown report.
+        Do not write code or execute anything - just analyze and respond with markdown.
         
         Ada File: {file_path}
         Ada Code Content:
         {file_content}
         
-        Return this exact JSON structure with your analysis:
-        {{
-            "core_algorithms": ["list of main algorithms and logic"],
-            "data_structures": ["list of key data structures and types"],
-            "business_rules": ["list of business rules and constraints"],
-            "domain_concepts": ["list of domain-specific concepts"],
-            "conversion_complexity": "low|medium|high",
-            "recommended_approach": "description of conversion strategy"
-        }}
-        JSON key/values must be quoted with double-quotes, not single-quotes.
-        JSON should never contain line-break (\n) in it.
-        
-        Focus on identifying:
-        - Core business algorithms and computational logic from the Ada code
-        - Important data structures, types, and their relationships
-        - Business rules, constraints, and validation logic (especially SPARK contracts)
-        - Domain-specific concepts and terminology
-        - Complexity level for conversion to modern languages like Python/TypeScript
-        - Recommended approach for modernization based on the code patterns
-        
-        Return ONLY the JSON object, nothing else.
+        Structure your analysis as follows in markdown format:
+
+        # Business Logic Analysis
+
+        ## Core Algorithms
+        - List the main algorithms and computational logic found in the code
+        - Describe the key processing steps and workflows
+
+        ## Data Structures & Types
+        - Identify important data structures, types, and their relationships
+        - Note any custom types or complex data arrangements
+
+        ## Business Rules & Constraints
+        - List business rules, validation logic, and constraints
+        - Pay special attention to SPARK contracts and formal specifications
+        - Note any domain-specific rules or policies
+
+        ## Domain Concepts
+        - Identify domain-specific concepts and terminology
+        - Explain the business context and purpose of the code
+
+        ## Conversion Complexity
+        **Level**: Low/Medium/High
+
+        **Reasoning**: Explain why this complexity level was assigned
+
+        ## Recommended Approach
+        Describe the recommended strategy for converting this code to modern languages like Python/TypeScript, including:
+        - Key architectural considerations
+        - Potential challenges and solutions
+        - Suggested modernization patterns
+
+        Focus on providing clear, actionable insights for code modernization and conversion.
+        Return ONLY the markdown report, nothing else.
         """
     
-    def _ensure_business_logic_structure(self, business_logic: Dict[str, Any]) -> Dict[str, Any]:
-        """Ensure business logic response has required structure with defaults"""
-        if not isinstance(business_logic, dict):
-            business_logic = {}
-        
-        defaults = {
-            'core_algorithms': [],
-            'data_structures': [],
-            'business_rules': [],
-            'domain_concepts': [],
-            'conversion_complexity': 'medium',
-            'recommended_approach': 'Standard modernization approach recommended'
-        }
-        
-        for key, default_value in defaults.items():
-            if key not in business_logic:
-                business_logic[key] = default_value
-        
-        return business_logic
     
-    def _create_fallback_business_logic_with_error(self, error_msg: str) -> Dict[str, Any]:
+    def _create_fallback_business_logic_with_error(self, error_msg: str) -> str:
         """Create fallback business logic response when analysis fails"""
-        return {
-            'core_algorithms': [],
-            'data_structures': [],
-            'business_rules': [],
-            'domain_concepts': [],
-            'conversion_complexity': 'unknown',
-            'recommended_approach': 'Manual analysis recommended due to error',
-            'error': error_msg
-        }
+        return f"""# Business Logic Analysis
+
+## Error
+Analysis failed with error: {error_msg}
+
+## Recommended Approach
+Manual analysis recommended due to analysis failure. Please review the Ada code manually or try again.
+
+## Next Steps
+- Check if the file is valid Ada code
+- Verify network connectivity for LLM access
+- Consider using a different analysis approach
+        """

src/ui.py

@@ -1,7 +1,6 @@
 """UI components and logic for the Ada Assistant Gradio interface."""
 
 import gradio as gr
-import json
 from src.tools.project_handler import unzip_project
 
 
@@ -23,14 +22,14 @@ def extract_project(file):
 def analyze_ada_file(file, analyzer):
     """Analyze uploaded Ada file and extract business logic"""
     try:
-        # Analyze the uploaded file
+        # Analyze the uploaded file (now returns markdown)
         result = analyzer.extract_business_logic(file.name)
 
-        # Format result for display
-        return json.dumps(result, indent=2)
+        # Return markdown result directly
+        return result
         
     except Exception as e:
-        return f"Error analyzing file: {str(e)}"
+        return f"# Error\n\nError analyzing file: {str(e)}"
 
 
 def handle_zip_upload(zip_file):
@@ -47,23 +46,19 @@ def handle_zip_upload(zip_file):
         return None, f"Error processing zip file: {str(e)}"
 
 
-def create_file_selection_handler(analyzer):
-    """Create file selection handler with analyzer dependency"""
+def create_file_selection_handler(analyzer, converter):
+    """Create file selection handler with analyzer and converter dependencies"""
     def handle_file_selection(selected_file):
         """Handle file selection from FileExplorer"""
 
         if not selected_file:
-            return "", "", gr.Code(visible=False), gr.JSON(visible=False)
+            return "", "", gr.Markdown(visible=False), gr.Code(visible=False)
         
         # Check if it's an Ada file
         if not (selected_file.endswith('.ads') or selected_file.endswith('.adb')):
-            return "", "", gr.Code(visible=False), gr.JSON(visible=False)
+            return "", "", gr.Markdown(visible=False), gr.Code(visible=False)
         
         try:
-            # Read the Ada source code
-            with open(selected_file, 'r', encoding='utf-8') as f:
-                source_code = f.read()
-            
             # Create a mock file object for analyze_ada_file
             class MockFile:
                 def __init__(self, name):
@@ -71,20 +66,18 @@ def create_file_selection_handler(analyzer):
             
             mock_file = MockFile(selected_file)
             
-            # Analyze the Ada file
+            # Analyze the Ada file (now returns markdown)
             analysis_result = analyze_ada_file(mock_file, analyzer)
+            
+            # Convert Ada file to Python
+            python_code = converter.convert_to_python(selected_file)
 
-            # Try to parse analysis result as JSON, fallback to string display
-            try:
-                parsed_result = json.loads(analysis_result)
-
-                return parsed_result
-            except:
-                # If not valid JSON, display as text
-                return {"analysis": analysis_result}
+            # Return markdown analysis and python code
+            return analysis_result, python_code, gr.Markdown(visible=True), gr.Code(visible=True)
                 
         except Exception as e:
-            return {"error": f"Error processing file: {str(e)}"}
+            error_markdown = f"# Error\n\nError processing file: {str(e)}"
+            return error_markdown, "", gr.Markdown(visible=True), gr.Code(visible=False)
     
     return handle_file_selection
 
@@ -96,7 +89,7 @@ def update_explorer(path):
     return gr.FileExplorer(visible=False)
 
 
-def create_interface(analyzer):
+def create_interface(analyzer, converter):
     """Create the main Gradio interface"""
     with gr.Blocks(title="Ada Assistant - Project Analyzer") as app:
         gr.Markdown("# Ada Assistant - Project Analyzer")
@@ -129,9 +122,18 @@ def create_interface(analyzer):
         with gr.Row():
             with gr.Column(scale=1):
                 # Analysis results display
-                analysis_results = gr.JSON(
+                analysis_results = gr.Markdown(
                     label="Business Logic Analysis",
-                    visible=True
+                    visible=False
+                )
+            
+            with gr.Column(scale=1):
+                # Python code display
+                python_code_display = gr.Code(
+                    label="Converted Python Code",
+                    language="python",
+                    lines=20,
+                    visible=False
                 )
         
         # Hidden state to store extracted path
@@ -152,11 +154,11 @@ def create_interface(analyzer):
         )
         
         # Handle file selection
-        handle_file_selection = create_file_selection_handler(analyzer)
+        handle_file_selection = create_file_selection_handler(analyzer, converter)
         file_explorer.change(
             fn=handle_file_selection,
             inputs=[file_explorer],
-            outputs=[analysis_results]
+            outputs=[analysis_results, python_code_display, analysis_results, python_code_display]
         )
     
     return app

tests/test_ada_converter_agent.py

@@ -0,0 +1,63 @@
+"""Tests for AdaConverterAgent."""
+
+import unittest
+from unittest.mock import Mock, patch
+from src.agents.ada_converter import AdaConverterAgent
+
+
+class TestAdaConverterAgent(unittest.TestCase):
+    """Test cases for AdaConverterAgent."""
+    
+    def setUp(self):
+        """Set up test fixtures."""
+        self.mock_model = Mock()
+        self.agent = AdaConverterAgent(self.mock_model)
+    
+    def test_initialization_with_model(self):
+        """Test that agent initializes correctly with a model."""
+        self.assertIsNotNone(self.agent)
+        self.assertEqual(self.agent.model, self.mock_model)
+    
+    @patch('builtins.open', create=True)
+    @patch('src.agents.ada_converter.ToolCallingAgent')
+    def test_convert_to_python_with_ada_file(self, mock_tool_calling_agent, mock_open):
+        """Test converting Ada code to Python."""
+        # Setup
+        ada_code = """
+        procedure Hello is
+        begin
+           Put_Line("Hello, World!");
+        end Hello;
+        """
+        
+        mock_open.return_value.__enter__.return_value.read.return_value = ada_code
+        
+        # Mock the LLM response
+        expected_python = """
+def hello():
+    print("Hello, World!")
+
+if __name__ == "__main__":
+    hello()
+        """
+        
+        # Mock the ToolCallingAgent response
+        mock_result = Mock()
+        mock_result.messages = [Mock(content=expected_python.strip())]
+        mock_tool_calling_agent.return_value.run.return_value = mock_result
+        
+        # Create agent
+        agent = AdaConverterAgent(self.mock_model)
+        
+        # Test
+        result = agent.convert_to_python("test_file.adb")
+        
+        # Verify
+        self.assertIsInstance(result, str)
+        self.assertIn("def hello()", result)
+        self.assertIn('print("Hello, World!")', result)
+        mock_tool_calling_agent.return_value.run.assert_called_once()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_code_analyzer_agent.py

@@ -35,19 +35,39 @@ class TestCodeAnalyzerAgent:
         """Test extract_business_logic with Ada file path and mocked LLM response"""
         from unittest.mock import MagicMock
         
-        # Mock the CodeAgent run method to return business logic analysis
+        # Mock the CodeAgent run method to return markdown business logic analysis
         mock_result = MagicMock()
         mock_result.messages = []
         mock_message = MagicMock()
-        mock_message.content = '''
-        {
-            "core_algorithms": ["TicTacToe game logic", "Board state evaluation", "Win condition checking"],
-            "data_structures": ["Board array structure", "Position type system", "Slot enumeration"],
-            "business_rules": ["SPARK verification contracts", "Pre/post conditions", "Game state constraints"],
-            "domain_concepts": ["Game board management", "Player moves", "Win detection"],
-            "conversion_complexity": "medium",
-            "recommended_approach": "Translate to Python classes with similar structure"
-        }
+        mock_message.content = '''# Business Logic Analysis
+
+## Core Algorithms
+- TicTacToe game logic
+- Board state evaluation
+- Win condition checking
+
+## Data Structures & Types
+- Board array structure
+- Position type system
+- Slot enumeration
+
+## Business Rules & Constraints
+- SPARK verification contracts
+- Pre/post conditions
+- Game state constraints
+
+## Domain Concepts
+- Game board management
+- Player moves
+- Win detection
+
+## Conversion Complexity
+**Level**: Medium
+
+**Reasoning**: Moderate complexity due to formal verification contracts
+
+## Recommended Approach
+Translate to Python classes with similar structure
         '''
         mock_result.messages.append(mock_message)
         
@@ -81,19 +101,20 @@ end Tictactoe;
         
         result = analyzer_agent.extract_business_logic(ada_file)
         
-        # Verify result structure
-        assert isinstance(result, dict)
-        assert 'core_algorithms' in result
-        assert 'data_structures' in result
-        assert 'business_rules' in result
-        assert 'domain_concepts' in result
-        assert 'conversion_complexity' in result
-        assert 'recommended_approach' in result
+        # Verify result is markdown string
+        assert isinstance(result, str)
+        assert "# Business Logic Analysis" in result
+        assert "## Core Algorithms" in result
+        assert "## Data Structures & Types" in result
+        assert "## Business Rules & Constraints" in result
+        assert "## Domain Concepts" in result
+        assert "## Conversion Complexity" in result
+        assert "## Recommended Approach" in result
         
         # Verify LLM found business logic concepts
-        assert "TicTacToe game logic" in result['core_algorithms']
-        assert "Board array structure" in result['data_structures']
-        assert result['conversion_complexity'] == "medium"
+        assert "TicTacToe game logic" in result
+        assert "Board array structure" in result
+        assert "Medium" in result
         
         # Verify LLM analysis was called
         analyzer_agent.code_agent.run.assert_called_once()