downgraded to python 3.11

.gitignore

@@ -0,0 +1,11 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+.env

.python-version

@@ -0,0 +1 @@
+3.10

CLAUDE.md

@@ -0,0 +1,55 @@
+# Development Practice
+
+1. Act as a pairing partner for the user. Do not commit anything until explicit consent is given
+2. Use test-driven development (TDD) practice.
+  * Write a failing test
+  * Implement by writing minimal amount of code to make the test pass
+  * Refactor
+3. Update this document with up-to-date project structures and architecture.
+4. Run unit tests after every change: `uv run pytest tests/ -v`
+
+# Architecture
+
+## Framework
+  * Smolagents - abstracts interaction with LLMs (Ollama for local development, OpenAI for production)
+    * Use LiteLLMModel wrapper for local development
+    * Use OpenAIServerModel for production
+    * ToolCallingAgent with FinalAnswerTool for code analysis
+  * Gradio - Implements web UI with drag & drop file upload
+  * Langfuse - Observability (planned)
+
+## Model Configuration
+  * Environment-based configuration via .env file
+  * Local development: Ollama with qwen2.5-coder model via LiteLLMModel
+  * Production: OpenAI gpt-4o-mini via OpenAIServerModel
+  * Configuration variables:
+    * ENVIRONMENT (development|production)
+    * DEVELOPMENT_MODEL_ID (default: ollama/qwen2.5-coder)
+    * PRODUCTION_MODEL_ID (default: gpt-4o-mini)
+
+## Project Structure
+```
+src/
+├── agents/
+│   └── code_analyzer.py    # CodeAnalyzerAgent for business logic extraction
+└── main.py                 # CLI interface for development/testing
+tests/
+├── test_code_analyzer_agent.py  # Unit tests for CodeAnalyzerAgent
+└── tictactoe.ads           # Sample Ada file for testing
+app.py                      # Gradio web interface
+requirements.txt            # Generated from uv dependencies
+pyproject.toml             # Project configuration and dependencies
+.env                       # Environment configuration
+```
+
+## Agents
+  * **CodeAnalyzerAgent**: Analyzes Ada files to extract business logic
+    * Uses dependency injection pattern (model passed as parameter)
+    * 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
+
+## Hosting Platform
+  * Hugging Face Spaces with Gradio SDK
+
+

IDEAS.md

@@ -0,0 +1,16 @@
+Project: Ada Conversion Assistant
+
+This project would help user modernize legacy Ada project, widely used in the defense industry.
+
+Ideally, the user would be able to upload the entire codebase in a zip file and this tool would 
+
+1. Describe the overall structure and business logic in the code
+2. Convert Ada modules into modern programming languagues such as python or typescript
+3. Download the converted project in a zip file
+4. Have a chat bot that can answer any question about the project
+
+Hosting Platform: Hugging Face
+Fremwork: smolagent
+UI: Gradio
+Tracing: Langfuse
+LLM: OpenAI

README.md

@@ -0,0 +1,73 @@
+---
+title: Ada Assistant
+emoji: 📊
+colorFrom: pink
+colorTo: purple
+sdk: gradio
+sdk_version: 5.33.2
+app_file: app.py
+pinned: false
+---
+
+# Ada Conversion Assistant
+
+A modern tool for analyzing legacy Ada codebases and providing conversion recommendations to modern programming languages.
+
+## Features
+
+- **Business Logic Analysis**: Extracts core algorithms, data structures, and business rules from Ada code
+- **Conversion Recommendations**: Provides guidance on complexity and modernization approaches
+- **Web Interface**: Drag & drop file upload with Gradio UI
+- **LLM-Powered**: Uses AI models (Ollama for development, OpenAI for production) via smolagents
+
+## Architecture
+
+- **Framework**: Smolagents for LLM abstraction, Gradio for UI
+- **Agents**: Multi-agent architecture with specialized CodeAnalyzerAgent
+- **Hosting**: Designed for Hugging Face Spaces deployment
+- **Observability**: Langfuse integration (planned)
+
+## Usage
+
+### Web Interface
+1. Upload Ada files (.ads, .adb, .ada)
+2. Click "Analyze Business Logic"
+3. View extracted business logic and conversion recommendations
+
+### Command Line
+```bash
+uv run src/main.py
+```
+
+## Development
+
+### Setup
+```bash
+# Install dependencies
+uv install
+
+# Set environment variables
+cp .env.example .env
+```
+
+### Configuration
+- `ENVIRONMENT`: "development" or "production"
+- `DEVELOPMENT_MODEL_ID`: Ollama Model for local development (default: ollama/qwen2.5-coder)
+- `PRODUCTION_MODEL_ID`: OpenAI Model for production (default: gpt-4o-mini)
+
+### Testing
+```bash
+uv run pytest tests/
+```
+
+## Project Structure
+```
+src/
+├── agents/
+│   └── code_analyzer.py    # Business logic analysis agent
+└── main.py                 # CLI interface
+tests/
+├── test_code_analyzer_agent.py
+└── tictactoe.ads          # Test Ada file
+app.py                     # Gradio web interface
+```

app.py

@@ -0,0 +1,71 @@
+import gradio as gr
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+from smolagents import LiteLLMModel, OpenAIServerModel
+from src.agents.code_analyzer import CodeAnalyzerAgent
+import json
+
+# Load environment variables
+load_dotenv()
+
+def analyze_ada_file(file):
+    """Analyze uploaded Ada file and extract business logic"""
+    if file is None:
+        return "No file uploaded"
+    
+    try:
+        # Initialize model
+        environment = os.getenv("ENVIRONMENT", "development")
+        if environment == "production":
+            model_id = os.getenv("PRODUCTION_MODEL_ID", "gpt-4o-mini")
+            model = OpenAIServerModel(
+                model_id=model_id,
+                api_key=os.environ["OPENAI_API_KEY"]
+            )
+        else:
+            model_id = os.getenv("DEVELOPMENT_MODEL_ID", "ollama/llama3.2")
+            model = LiteLLMModel(model_id=model_id)
+        
+        # Initialize analyzer
+        analyzer = CodeAnalyzerAgent(model)
+        
+        # Analyze the uploaded file
+        result = analyzer.extract_business_logic(file.name)
+        
+        # Format result for display
+        return json.dumps(result, indent=2)
+        
+    except Exception as e:
+        return f"Error analyzing file: {str(e)}"
+
+# Create Gradio interface
+with gr.Blocks(title="Ada Conversion Assistant") as demo:
+    gr.Markdown("# Ada Conversion Assistant")
+    gr.Markdown("Upload your Ada files (.ads, .adb, .ada) to analyze business logic and get conversion recommendations.")
+    
+    with gr.Row():
+        with gr.Column():
+            file_input = gr.File(
+                label="Upload Ada File",
+                file_types=[".ads", ".adb", ".ada"],
+                file_count="single"
+            )
+            analyze_btn = gr.Button("Analyze", variant="primary")
+            
+        with gr.Column():
+            output = gr.Textbox(
+                label="Analysis Result",
+                lines=20,
+                max_lines=30,
+                show_copy_button=True
+            )
+    
+    analyze_btn.click(
+        fn=analyze_ada_file,
+        inputs=[file_input],
+        outputs=[output]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "ada-assistant2"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "gradio>=5.33.2",
+    "litellm>=1.72.4",
+    "pytest>=8.4.0",
+    "python-dotenv>=1.1.0",
+    "smolagents>=1.18.0",
+]

requirements.txt

@@ -0,0 +1,260 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile pyproject.toml -o requirements.txt
+aiofiles==24.1.0
+    # via gradio
+aiohappyeyeballs==2.6.1
+    # via aiohttp
+aiohttp==3.12.12
+    # via litellm
+aiosignal==1.3.2
+    # via aiohttp
+annotated-types==0.7.0
+    # via pydantic
+anyio==4.9.0
+    # via
+    #   gradio
+    #   httpx
+    #   openai
+    #   starlette
+async-timeout==5.0.1
+    # via aiohttp
+attrs==25.3.0
+    # via
+    #   aiohttp
+    #   jsonschema
+    #   referencing
+certifi==2025.4.26
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+charset-normalizer==3.4.2
+    # via requests
+click==8.2.1
+    # via
+    #   litellm
+    #   typer
+    #   uvicorn
+distro==1.9.0
+    # via openai
+exceptiongroup==1.3.0
+    # via
+    #   anyio
+    #   pytest
+fastapi==0.115.12
+    # via gradio
+ffmpy==0.6.0
+    # via gradio
+filelock==3.18.0
+    # via huggingface-hub
+frozenlist==1.7.0
+    # via
+    #   aiohttp
+    #   aiosignal
+fsspec==2025.5.1
+    # via
+    #   gradio-client
+    #   huggingface-hub
+gradio==5.33.2
+    # via ada-assistant2 (pyproject.toml)
+gradio-client==1.10.3
+    # via gradio
+groovy==0.1.2
+    # via gradio
+h11==0.16.0
+    # via
+    #   httpcore
+    #   uvicorn
+hf-xet==1.1.3
+    # via huggingface-hub
+httpcore==1.0.9
+    # via httpx
+httpx==0.28.1
+    # via
+    #   gradio
+    #   gradio-client
+    #   litellm
+    #   openai
+    #   safehttpx
+huggingface-hub==0.33.0
+    # via
+    #   gradio
+    #   gradio-client
+    #   smolagents
+    #   tokenizers
+idna==3.10
+    # via
+    #   anyio
+    #   httpx
+    #   requests
+    #   yarl
+importlib-metadata==8.7.0
+    # via litellm
+iniconfig==2.1.0
+    # via pytest
+jinja2==3.1.6
+    # via
+    #   gradio
+    #   litellm
+    #   smolagents
+jiter==0.10.0
+    # via openai
+jsonschema==4.24.0
+    # via litellm
+jsonschema-specifications==2025.4.1
+    # via jsonschema
+litellm==1.72.4
+    # via ada-assistant2 (pyproject.toml)
+markdown-it-py==3.0.0
+    # via rich
+markupsafe==3.0.2
+    # via
+    #   gradio
+    #   jinja2
+mdurl==0.1.2
+    # via markdown-it-py
+multidict==6.4.4
+    # via
+    #   aiohttp
+    #   yarl
+numpy==2.2.6
+    # via
+    #   gradio
+    #   pandas
+openai==1.86.0
+    # via litellm
+orjson==3.10.18
+    # via gradio
+packaging==25.0
+    # via
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   pytest
+pandas==2.3.0
+    # via gradio
+pillow==11.2.1
+    # via
+    #   gradio
+    #   smolagents
+pluggy==1.6.0
+    # via pytest
+propcache==0.3.2
+    # via
+    #   aiohttp
+    #   yarl
+pydantic==2.11.6
+    # via
+    #   fastapi
+    #   gradio
+    #   litellm
+    #   openai
+pydantic-core==2.33.2
+    # via pydantic
+pydub==0.25.1
+    # via gradio
+pygments==2.19.1
+    # via
+    #   pytest
+    #   rich
+pytest==8.4.0
+    # via ada-assistant2 (pyproject.toml)
+python-dateutil==2.9.0.post0
+    # via pandas
+python-dotenv==1.1.0
+    # via
+    #   ada-assistant2 (pyproject.toml)
+    #   litellm
+    #   smolagents
+python-multipart==0.0.20
+    # via gradio
+pytz==2025.2
+    # via pandas
+pyyaml==6.0.2
+    # via
+    #   gradio
+    #   huggingface-hub
+referencing==0.36.2
+    # via
+    #   jsonschema
+    #   jsonschema-specifications
+regex==2024.11.6
+    # via tiktoken
+requests==2.32.4
+    # via
+    #   huggingface-hub
+    #   smolagents
+    #   tiktoken
+rich==14.0.0
+    # via
+    #   smolagents
+    #   typer
+rpds-py==0.25.1
+    # via
+    #   jsonschema
+    #   referencing
+ruff==0.11.13
+    # via gradio
+safehttpx==0.1.6
+    # via gradio
+semantic-version==2.10.0
+    # via gradio
+shellingham==1.5.4
+    # via typer
+six==1.17.0
+    # via python-dateutil
+smolagents==1.18.0
+    # via ada-assistant2 (pyproject.toml)
+sniffio==1.3.1
+    # via
+    #   anyio
+    #   openai
+starlette==0.46.2
+    # via
+    #   fastapi
+    #   gradio
+tiktoken==0.9.0
+    # via litellm
+tokenizers==0.21.1
+    # via litellm
+tomli==2.2.1
+    # via pytest
+tomlkit==0.13.3
+    # via gradio
+tqdm==4.67.1
+    # via
+    #   huggingface-hub
+    #   openai
+typer==0.16.0
+    # via gradio
+typing-extensions==4.14.0
+    # via
+    #   anyio
+    #   exceptiongroup
+    #   fastapi
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   multidict
+    #   openai
+    #   pydantic
+    #   pydantic-core
+    #   referencing
+    #   rich
+    #   typer
+    #   typing-inspection
+    #   uvicorn
+typing-inspection==0.4.1
+    # via pydantic
+tzdata==2025.2
+    # via pandas
+urllib3==2.4.0
+    # via requests
+uvicorn==0.34.3
+    # via gradio
+websockets==15.0.1
+    # via gradio-client
+yarl==1.20.1
+    # via aiohttp
+zipp==3.23.0
+    # via importlib-metadata

src/agents/code_analyzer.py

@@ -0,0 +1,164 @@
+"""
+Code Analyzer Agent for Ada Conversion Assistant
+
+This agent is responsible for:
+1. Parsing Ada code files
+2. Extracting project structure and dependencies  
+3. Identifying business logic patterns
+4. Generating analysis reports for conversion
+"""
+
+from typing import Dict, Any, Union
+from pathlib import Path
+from smolagents import ToolCallingAgent, FinalAnswerTool
+
+
+class CodeAnalyzerAgent:
+    """Agent specialized in analyzing Ada codebases"""
+    
+    def __init__(self, model: Any):
+        # Model passed, create ToolCallingAgent internally with Ada-specific configuration
+        # I would have used CodeAgent but kept throwing error no matter what model I used
+        self.model = model
+        self.code_agent = ToolCallingAgent(
+            model=self.model,
+            tools=[FinalAnswerTool()]
+        )
+        
+        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
+        
+        # Try to extract JSON from the response
+        json_match = re.search(r'\{.*\}', response, re.DOTALL)
+        if json_match:
+            try:
+                return json.loads(json_match.group())
+            except json.JSONDecodeError:
+                pass
+        
+        # Fallback if JSON parsing fails
+        return {
+            'file_type': 'unknown',
+            'packages': [],
+            'procedures': [],
+            'functions': [],
+            'types': [],
+            'dependencies': [],
+            'error': "LLM response could not be parsed"
+        }
+    
+    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)
+    
+    def extract_business_logic(self, ada_file_path: Union[Path, str]) -> Dict[str, Any]:
+        """
+        Extract business logic patterns from Ada file using LLM
+        
+        Args:
+            ada_file_path: Path to Ada file to analyze
+            
+        Returns:
+            Business logic analysis with conversion recommendations
+        """
+        # Convert to Path object if string
+        file_path = Path(ada_file_path)
+        
+        # Read Ada file contents
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                file_content = f.read()
+        except Exception as e:
+            print(f"Error reading Ada file {file_path}: {e}")
+            return self._create_fallback_business_logic_with_error(f"File read error: {str(e)}")
+        
+        # Create business logic analysis prompt
+        analysis_prompt = self._create_business_logic_prompt(file_path, file_content)
+        
+        try:
+            # Use the code agent to analyze business logic
+            result = self.code_agent.run(analysis_prompt)
+            
+            # Extract response text from RunResult
+            response_text = self._extract_response_text(result)
+            
+            # Parse the LLM response and ensure structure
+            business_logic = self._parse_llm_response(response_text)
+            business_logic = self._ensure_business_logic_structure(business_logic)
+            
+            return business_logic
+            
+        except Exception as e:
+            print(f"LLM business logic analysis failed: {e}")
+            return self._create_fallback_business_logic_with_error(f"LLM analysis failed: {str(e)}")
+    
+    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.
+        
+        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"
+        }}
+        
+        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.
+        """
+    
+    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]:
+        """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
+        }

src/main.py

@@ -0,0 +1,56 @@
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+from smolagents import LiteLLMModel, OpenAIServerModel
+from agents.code_analyzer import CodeAnalyzerAgent
+import json
+
+# Load environment variables
+load_dotenv()
+
+
+def main():
+    print("Hello from ada-assistant!")
+    
+    environment = os.getenv("ENVIRONMENT", "development")
+    print(f"Running in {environment} mode")
+    
+    # Get model configuration from environment
+    if environment == "production":
+        model_id = os.getenv("PRODUCTION_MODEL_ID", "gpt-4o-mini")
+        model = OpenAIServerModel(
+            model_id=model_id,
+            api_key=os.environ["OPENAI_API_KEY"]
+        )
+    else:
+        model_id = os.getenv("DEVELOPMENT_MODEL_ID", "ollama/llama3.2")
+        model = LiteLLMModel(model_id=model_id)
+    
+    print(f"Using model: {model_id}")
+    
+    # Initialize CodeAnalyzerAgent with model (it will create CodeAgent internally)
+    analyzer = CodeAnalyzerAgent(model)
+    
+    print(f"CodeAnalyzerAgent initialized successfully with {len(analyzer.supported_extensions)} supported file types!")
+    
+    # Test extract_business_logic with tictactoe.ads file
+    print("\n" + "="*50)
+    print("Testing extract_business_logic with tictactoe.ads")
+    print("="*50)
+    
+    tictactoe_file = Path(__file__).parent.parent / "tests" / "tictactoe.ads"
+    
+    if tictactoe_file.exists():
+        print(f"Analyzing Ada file: {tictactoe_file}")
+        
+        print("\nExtracting business logic...")
+        result = analyzer.extract_business_logic(tictactoe_file)
+        
+        print("\nBusiness Logic Analysis:")
+        print(json.dumps(result, indent=2, default=str))
+    else:
+        print(f"Test file not found: {tictactoe_file}")
+
+
+if __name__ == "__main__":
+    main()

tests/test_code_analyzer_agent.py

@@ -0,0 +1,100 @@
+"""
+Unit tests for CodeAnalyzerAgent
+"""
+
+import pytest
+from pathlib import Path
+from unittest.mock import Mock, MagicMock
+from src.agents.code_analyzer import CodeAnalyzerAgent
+
+
+class TestCodeAnalyzerAgent:
+    """Test suite for CodeAnalyzerAgent"""
+    
+    @pytest.fixture
+    def mock_model(self):
+        """Mock model for testing"""
+        return Mock()
+    
+    @pytest.fixture
+    def analyzer_agent(self, mock_model):
+        """Create CodeAnalyzerAgent instance with mocked model"""
+        return CodeAnalyzerAgent(mock_model)
+    
+    def test_initialization_with_model(self, mock_model):
+        """Test agent initialization with model parameter"""
+        agent = CodeAnalyzerAgent(mock_model)
+        
+        assert agent.model == mock_model
+        assert agent.supported_extensions == ['.ads', '.adb', '.ada']
+        assert agent.analysis_results == {}
+        assert hasattr(agent, 'code_agent')
+    
+    
+    def test_extract_business_logic_with_ada_file(self, mock_model, tmp_path):
+        """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_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_result.messages.append(mock_message)
+        
+        analyzer_agent = CodeAnalyzerAgent(mock_model)
+        analyzer_agent.code_agent.run = MagicMock(return_value=mock_result)
+        
+        # Create test Ada file
+        ada_file = tmp_path / "tictactoe.ads"
+        ada_file.write_text("""
+package Tictactoe
+with SPARK_Mode => On
+is
+   type Slot is (Empty, Player, Computer);
+   type Pos is new Integer range 1 .. 3;
+   type Column is array (Pos) of Slot;
+   type Board is array (Pos) of Column;
+
+   My_Board : Board := (others => (others => Empty));
+
+   procedure Initialize
+     with Post => Num_Free_Slots = 9;
+
+   procedure Player_Play (S : String)
+     with Pre => not Is_Full and Won = Empty,
+     Post => Num_Free_Slots = Num_Free_Slots'Old - 1;
+
+   function Won return Slot;
+   function Is_Full return Boolean is (Num_Free_Slots = 0);
+end Tictactoe;
+        """.strip())
+        
+        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 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"
+        
+        # Verify LLM analysis was called
+        analyzer_agent.code_agent.run.assert_called_once()
+    

tests/tictactoe.ads

@@ -0,0 +1,52 @@
+package Tictactoe
+with SPARK_Mode => On
+is
+
+   type Slot is (Empty, Player, Computer);
+   type Pos is new Integer range 1 .. 3;
+   type Column is array (Pos) of Slot;
+   type Board is array (Pos) of Column;
+
+   My_Board : Board := (others => (others => Empty));
+
+   -- Game operations
+
+   procedure Initialize
+     with Post => Num_Free_Slots = 9;
+
+   procedure Player_Play (S : String)
+     with Pre => not Is_Full and Won = Empty,
+     Post => Num_Free_Slots = Num_Free_Slots'Old - 1;
+
+   procedure Computer_Play
+     with Pre => not Is_Full and Won = Empty,
+     Post => Num_Free_Slots = Num_Free_Slots'Old - 1;
+
+   procedure Display;
+
+   function Won return Slot;
+
+   function One_Free_Slot (X, Y : Pos) return Integer is
+     (if My_Board(X)(Y) = Empty then 1 else 0);
+
+   function Count_Free_Slots (X, Y : Pos) return Integer is
+     (One_Free_Slot(1,1) +
+      (if Y >= 2 then One_Free_Slot(1,2) else 0) +
+      (if Y >= 3 then One_Free_Slot(1,3) else 0) +
+      (if X >= 2 then
+         One_Free_Slot(2,1) +
+         (if Y >= 2 then One_Free_Slot(2,2) else 0) +
+         (if Y >= 3 then One_Free_Slot(2,3) else 0)
+       else 0) +
+      (if X >= 3 then
+         One_Free_Slot(3,1) +
+         (if Y >= 2 then One_Free_Slot(3,2) else 0) +
+         (if Y >= 3 then One_Free_Slot(3,3) else 0)
+       else 0));
+
+   function Num_Free_Slots return Natural is
+     (Count_Free_Slots(3,3));
+
+   function Is_Full return Boolean is (Num_Free_Slots = 0);
+
+end Tictactoe;