Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,37 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Installer les dépendances système
+RUN apt-get update && apt-get install -y \
+  git \
+  curl \
+  && rm -rf /var/lib/apt/lists/*
+
+# Copier requirements
+COPY backend/requirements.txt .
+
+# Installer les dépendances Python
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copier le code
+COPY backend/ ./backend/
+COPY data/ ./data/
+
+# Créer les répertoires nécessaires
+RUN mkdir -p logs
+
+# Exposer le port (Hugging Face Spaces utilise 7860)
+EXPOSE 7860
+
+# Variables d'environnement
+ENV PYTHONUNBUFFERED=1
+ENV HOST=0.0.0.0
+ENV PORT=7860
+
+# Healthcheck
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+  CMD curl -f http://localhost:7860/health || exit 1
+
+# Lancer le serveur
+CMD ["uvicorn", "backend.app.main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

README.md

@@ -1,11 +1,85 @@
----
-title: Slm Code Engine
-emoji: 🏢
-colorFrom: blue
-colorTo: red
-sdk: docker
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: SLM Code Engine
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+---
+
+# 🤖 SLM Code Engine
+
+Moteur de code intelligent avec Micro-SLMs spécialisés pour la génération de code.
+
+## 🚀 Utilisation
+
+### API Endpoint
+
+```
+POST /api/v1/query
+```
+
+### Exemple de requête
+
+```bash
+curl -X POST https://YOUR-USERNAME-slm-code-engine.hf.space/api/v1/query \
+  -H "Content-Type: application/json" \
+  -d '{
+    "task": "boilerplate",
+    "code": "",
+    "language": "python",
+    "context": "Génère une fonction pour calculer la moyenne"
+  }'
+```
+
+### Réponse
+
+```json
+{
+  "success": true,
+  "result": "def calculer_moyenne(nombres):\n    return sum(nombres) / len(nombres)",
+  "explanation": "Fonction pour calculer la moyenne d'une liste",
+  "used_slm": true,
+  "total_duration_ms": 2500
+}
+```
+
+## 🧠 Modèles disponibles
+
+- **boilerplate_slm** : Génération de code boilerplate Python (Phi-2 fine-tuné)
+- **Groq API** : Fallback pour tâches complexes (Llama 3.3 70B)
+
+## 📊 Endpoints
+
+| Endpoint | Méthode | Description |
+|----------|---------|-------------|
+| `/health` | GET | Vérifier le statut du serveur |
+| `/api/v1/query` | POST | Générer du code |
+| `/cache/stats` | GET | Statistiques du cache de modèles |
+
+## 🔧 Configuration
+
+Le système utilise :
+- **Routeur intelligent** : Sélectionne automatiquement le meilleur modèle
+- **Cache LRU** : Garde les modèles en mémoire pour des réponses rapides
+- **Automates** : Formatage et linting automatiques
+
+## 📈 Performance
+
+- **Micro-SLM** : ~2-5s par requête
+- **Groq API** : ~1-3s par requête
+- **Cache hit** : ~0.1s par requête
+
+## 🛠️ Technologies
+
+- **Backend** : FastAPI + Uvicorn
+- **Modèles** : Phi-2 (2.7B), Llama 3.3 (70B via Groq)
+- **Framework** : Transformers, PEFT, PyTorch
+
+## 📝 License
+
+Apache 2.0
+
+---
+
+Développé avec ❤️ pour la communauté des développeurs

backend/.pytest_cache/.gitignore

@@ -0,0 +1,2 @@
+# Created by pytest automatically.
+*

backend/.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

backend/.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

backend/.pytest_cache/v/cache/lastfailed

@@ -0,0 +1,8 @@
+{
+  "tests/test_automata.py::TestPythonLinter::test_can_handle_lint_task": true,
+  "tests/test_automata_unit.py::TestPythonFormatter::test_format_already_formatted": true,
+  "tests/test_automata_unit.py::TestTestTemplateGenerator::test_can_handle_test_task": true,
+  "tests/test_automata_unit.py::TestTestTemplateGenerator::test_generate_template": true,
+  "tests/test_orchestrator.py::test_orchestrator_valid_code_no_changes": true,
+  "tests/test_code_validators.py::TestExecutionValidator::test_timeout": true
+}

backend/.pytest_cache/v/cache/nodeids

@@ -0,0 +1,74 @@
+[
+  "tests/test_api.py::test_health_endpoint",
+  "tests/test_api.py::test_query_fix_endpoint",
+  "tests/test_api.py::test_query_format_endpoint",
+  "tests/test_api.py::test_query_invalid_task",
+  "tests/test_api.py::test_query_missing_code",
+  "tests/test_api.py::test_query_with_context",
+  "tests/test_api.py::test_query_with_trace",
+  "tests/test_api.py::test_stats_endpoint",
+  "tests/test_automata.py::TestASTFixer::test_can_handle_fix_task",
+  "tests/test_automata.py::TestASTFixer::test_fix_missing_colon",
+  "tests/test_automata.py::TestASTFixer::test_fix_multiple_errors",
+  "tests/test_automata.py::TestASTFixer::test_valid_code_unchanged",
+  "tests/test_automata.py::TestPythonFormatter::test_can_handle_python_format",
+  "tests/test_automata.py::TestPythonFormatter::test_cannot_handle_other_language",
+  "tests/test_automata.py::TestPythonFormatter::test_format_execution",
+  "tests/test_automata.py::TestPythonFormatter::test_format_invalid_syntax",
+  "tests/test_automata.py::TestPythonLinter::test_can_handle_format_task",
+  "tests/test_automata.py::TestPythonLinter::test_can_handle_lint_task",
+  "tests/test_automata.py::TestPythonLinter::test_lint_clean_code",
+  "tests/test_automata.py::TestTestTemplateGenerator::test_can_handle_test_task",
+  "tests/test_automata.py::TestTestTemplateGenerator::test_generate_class_tests",
+  "tests/test_automata.py::TestTestTemplateGenerator::test_generate_function_tests",
+  "tests/test_automata_unit.py::TestASTFixer::test_can_handle_python_fix",
+  "tests/test_automata_unit.py::TestASTFixer::test_fix_missing_colon",
+  "tests/test_automata_unit.py::TestASTFixer::test_fix_missing_colon_if",
+  "tests/test_automata_unit.py::TestASTFixer::test_no_changes_needed",
+  "tests/test_automata_unit.py::TestPythonFormatter::test_can_handle_python",
+  "tests/test_automata_unit.py::TestPythonFormatter::test_cannot_handle_other_languages",
+  "tests/test_automata_unit.py::TestPythonFormatter::test_cannot_handle_other_tasks",
+  "tests/test_automata_unit.py::TestPythonFormatter::test_format_already_formatted",
+  "tests/test_automata_unit.py::TestPythonFormatter::test_format_messy_code",
+  "tests/test_automata_unit.py::TestPythonLinter::test_can_handle_python",
+  "tests/test_automata_unit.py::TestPythonLinter::test_lint_code",
+  "tests/test_automata_unit.py::TestRuntimeFixer::test_fix_index_error",
+  "tests/test_automata_unit.py::TestRuntimeFixer::test_fix_zero_division",
+  "tests/test_automata_unit.py::TestTestTemplateGenerator::test_can_handle_test_task",
+  "tests/test_automata_unit.py::TestTestTemplateGenerator::test_generate_template",
+  "tests/test_automata_unit.py::TestTraceParser::test_can_handle_explain_with_trace",
+  "tests/test_automata_unit.py::TestTraceParser::test_parse_python_traceback",
+  "tests/test_automata_unit.py::TestTraceParser::test_parse_syntax_error",
+  "tests/test_code_validators.py::TestCompositeValidator::test_all_validators",
+  "tests/test_code_validators.py::TestCompositeValidator::test_overall_score",
+  "tests/test_code_validators.py::TestCompositeValidator::test_syntax_failure_stops_execution",
+  "tests/test_code_validators.py::TestExecutionValidator::test_runtime_error",
+  "tests/test_code_validators.py::TestExecutionValidator::test_successful_execution",
+  "tests/test_code_validators.py::TestExecutionValidator::test_timeout",
+  "tests/test_code_validators.py::TestQualityValidator::test_high_quality_code",
+  "tests/test_code_validators.py::TestQualityValidator::test_low_quality_code",
+  "tests/test_code_validators.py::TestSyntaxValidator::test_indentation_error",
+  "tests/test_code_validators.py::TestSyntaxValidator::test_invalid_syntax",
+  "tests/test_code_validators.py::TestSyntaxValidator::test_valid_syntax",
+  "tests/test_code_validators.py::TestTestValidator::test_failing_tests",
+  "tests/test_code_validators.py::TestTestValidator::test_passing_tests",
+  "tests/test_orchestrator.py::test_orchestrator_fix_via_automata",
+  "tests/test_orchestrator.py::test_orchestrator_format_via_automata",
+  "tests/test_orchestrator.py::test_orchestrator_performance",
+  "tests/test_orchestrator.py::test_orchestrator_pipeline_tracking",
+  "tests/test_orchestrator.py::test_orchestrator_valid_code_no_changes",
+  "tests/test_orchestrator_unit.py::TestOrchestratorInit::test_automata_loaded",
+  "tests/test_orchestrator_unit.py::TestOrchestratorInit::test_initialization",
+  "tests/test_orchestrator_unit.py::TestOrchestratorPipeline::test_duration_tracking",
+  "tests/test_orchestrator_unit.py::TestOrchestratorPipeline::test_pipeline_records_steps",
+  "tests/test_orchestrator_unit.py::TestOrchestratorRouting::test_fix_tries_automata_first",
+  "tests/test_orchestrator_unit.py::TestOrchestratorRouting::test_format_uses_automata",
+  "tests/test_orchestrator_unit.py::TestOrchestratorShutdown::test_shutdown",
+  "tests/test_orchestrator_unit.py::TestOrchestratorStatus::test_get_status",
+  "tests/test_orchestrator_unit.py::TestOrchestratorStatus::test_status_before_init",
+  "tests/test_router.py::test_router_boilerplate_task",
+  "tests/test_router.py::test_router_explain_task",
+  "tests/test_router.py::test_router_fix_task",
+  "tests/test_router.py::test_router_format_task",
+  "tests/test_router.py::test_router_test_task"
+]

backend/.ruff_cache/.gitignore

@@ -0,0 +1,2 @@
+# Automatically created by ruff.
+*

backend/.ruff_cache/CACHEDIR.TAG

@@ -0,0 +1 @@
+Signature: 8a477f597d28d172789f06886806bc55

backend/app/__init__.py

@@ -0,0 +1,4 @@
+"""
+SLM Code Engine - Main application package
+"""
+__version__ = "0.1.0"

backend/app/api/__init__.py

@@ -0,0 +1 @@
+"""API package"""

backend/app/api/cache.py

@@ -0,0 +1,45 @@
+"""
+Cache Statistics Endpoint
+
+Provides real-time statistics about the model cache.
+"""
+from fastapi import APIRouter
+from app.core.model_cache import model_cache
+
+router = APIRouter(prefix="/cache", tags=["cache"])
+
+
+@router.get("/stats")
+async def get_cache_stats():
+    """Get model cache statistics"""
+    return model_cache.get_stats()
+
+
+@router.post("/clear")
+async def clear_cache():
+    """Clear all cached models"""
+    await model_cache.clear()
+    return {"message": "Cache cleared successfully"}
+
+
+@router.post("/preload/{model_name}")
+async def preload_model(model_name: str):
+    """Preload a model into cache"""
+    from app.core.slm_registry import slm_registry
+    from app.engines.micro_slm import MicroSLMEngine
+    
+    micro_slm_info = slm_registry.get_model(model_name)
+    if not micro_slm_info:
+        return {"error": f"Model {model_name} not found in registry"}
+    
+    async def load_micro_slm():
+        engine = MicroSLMEngine(
+            name=model_name,
+            model_path=micro_slm_info.model_path
+        )
+        await engine.initialize()
+        return engine
+    
+    await model_cache.preload(model_name, load_micro_slm)
+    
+    return {"message": f"Model {model_name} preloaded successfully"}

backend/app/automata/__init__.py

@@ -0,0 +1,16 @@
+"""Automata package"""
+from app.automata.base import BaseAutomaton
+from app.automata.formatter import PythonFormatter
+from app.automata.linter import PythonLinter
+from app.automata.trace_parser import TraceParser
+from app.automata.ast_fixer import ASTFixer
+from app.automata.test_generator import TestTemplateGenerator
+
+__all__ = [
+    "BaseAutomaton",
+    "PythonFormatter",
+    "PythonLinter",
+    "TraceParser",
+    "ASTFixer",
+    "TestTemplateGenerator"
+]

backend/app/automata/ast_fixer.py

@@ -0,0 +1,196 @@
+"""
+AST-based code fixer for simple syntax errors
+
+Uses Python's AST module to detect and fix common issues:
+- Indentation errors
+- Missing colons
+- Simple syntax errors
+"""
+import ast
+import logging
+from typing import Dict, Any, Optional
+
+from app.automata.base import BaseAutomaton
+from app.models.schemas import TaskType, Language
+from app.utils.localization import get_string
+
+logger = logging.getLogger(__name__)
+
+
+class ASTFixer(BaseAutomaton):
+    """Fixes simple Python syntax errors using AST analysis"""
+
+    def __init__(self):
+        super().__init__("ast_fixer")
+
+    def can_handle(
+        self,
+        code: str,
+        language: Language,
+        task: TaskType
+    ) -> bool:
+        """Check if can fix this code"""
+        return (
+            language == Language.PYTHON
+            and task == TaskType.FIX
+        )
+
+    async def execute(
+        self,
+        code: str,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Try to fix simple syntax errors"""
+        try:
+            # First, try to parse as-is
+            ast.parse(code)
+
+            # No syntax errors
+            return self._format_result(
+                success=True,
+                result=code,
+                explanation=get_string("ast_fixer_no_errors"),
+                suggestions=[]
+            )
+
+        except SyntaxError as e:
+            # Try multiple passes to fix errors (up to 5)
+            current_code = code
+            fixes_applied = []
+            max_attempts = 5
+
+            for attempt in range(max_attempts):
+                try:
+                    # Try to parse current code
+                    ast.parse(current_code)
+                    # Success! All errors fixed
+                    return self._format_result(
+                        success=True,
+                        result=current_code,
+                        explanation=get_string(
+                            "ast_fixer_fixed_issues",
+                            issue_count=len(fixes_applied),
+                            issues=', '.join(fixes_applied)
+                        ),
+                        suggestions=[get_string("ast_fixer_suggestion_linter")]
+                    )
+                except SyntaxError as error:
+                    # Try to fix this error
+                    fixed_code, explanation = self._attempt_fix(current_code, error)
+
+                    if fixed_code and fixed_code != current_code:
+                        current_code = fixed_code
+                        fixes_applied.append(explanation)
+                    else:
+                        # Can't fix this error
+                        break
+
+            # Check if we made any progress
+            if fixes_applied:
+                # Some fixes worked - return False to trigger SLM fallback
+                return self._format_result(
+                    success=False,
+                    result=current_code,
+                    explanation=get_string("ast_fixer_failed_autofix"),
+                    suggestions=[get_string("ast_fixer_suggestion_slm")]
+                )
+            else:
+                # No fixes worked - trigger SLM fallback
+                return self._format_result(
+                    success=False,
+                    explanation=get_string("ast_fixer_syntax_error", error=str(e)),
+                    suggestions=[get_string("ast_fixer_suggestion_slm")]
+                )
+
+        except Exception as e:
+            logger.error(f"AST analysis failed: {e}")
+            return self._format_result(
+                success=False,
+                explanation=get_string("ast_fixer_analysis_error", error=str(e))
+            )
+
+    def _attempt_fix(self, code: str, error: SyntaxError) -> tuple[Optional[str], Optional[str]]:
+        """Attempt to fix common syntax errors"""
+        lines = code.split('\n')
+        error_line = error.lineno - 1 if error.lineno else 0
+
+        # Common fixes
+        fixes = [
+            self._fix_missing_colon,
+            self._fix_indentation,
+            self._fix_parentheses,
+        ]
+
+        for fix_func in fixes:
+            try:
+                fixed_code, explanation = fix_func(lines, error_line, error)
+                if fixed_code:
+                    return fixed_code, explanation
+            except Exception as e:
+                logger.debug(f"Fix attempt failed: {e}")
+                continue
+
+        return None, None
+
+    def _fix_missing_colon(self, lines: list, error_line: int, error: SyntaxError) -> tuple[Optional[str], Optional[str]]:
+        """Fix missing colon in function/class definitions"""
+        if error_line >= len(lines):
+            return None, None
+
+        line = lines[error_line].rstrip()
+
+        # Check if it's a definition without colon
+        keywords = ['def ', 'class ', 'if ', 'elif ', 'else', 'for ', 'while ', 'try', 'except', 'finally', 'with ']
+
+        for keyword in keywords:
+            if line.strip().startswith(keyword) and not line.endswith(':'):
+                # Add missing colon
+                lines[error_line] = line + ':'
+                fixed_code = '\n'.join(lines)
+                return fixed_code, get_string(
+                    "ast_fixer_added_colon",
+                    keyword=keyword.strip(),
+                    line_number=error_line + 1
+                )
+
+        return None, None
+
+    def _fix_indentation(self, lines: list, error_line: int, error: SyntaxError) -> tuple[Optional[str], Optional[str]]:
+        """Fix simple indentation errors"""
+        if error_line >= len(lines) or error_line == 0:
+            return None, None
+
+        current_line = lines[error_line]
+        prev_line = lines[error_line - 1].rstrip()
+
+        # If previous line ends with colon, current should be indented
+        if prev_line.endswith(':'):
+            if not current_line.startswith('    ') and current_line.strip():
+                lines[error_line] = '    ' + current_line.lstrip()
+                fixed_code = '\n'.join(lines)
+                return fixed_code, get_string("ast_fixer_fixed_indentation", line_number=error_line + 1)
+
+        return None, None
+
+    def _fix_parentheses(self, lines: list, error_line: int, error: SyntaxError) -> tuple[Optional[str], Optional[str]]:
+        """Fix unmatched parentheses"""
+        if error_line >= len(lines):
+            return None, None
+
+        line = lines[error_line]
+
+        # Count parentheses
+        open_count = line.count('(')
+        close_count = line.count(')')
+
+        if open_count > close_count:
+            # Missing closing parenthesis
+            lines[error_line] = line.rstrip() + ')' * (open_count - close_count)
+            fixed_code = '\n'.join(lines)
+            return fixed_code, get_string("ast_fixer_added_paren", line_number=error_line + 1)
+
+        elif close_count > open_count:
+            # Extra closing parenthesis - harder to fix automatically
+            pass
+
+        return None, None

backend/app/automata/base.py

@@ -0,0 +1,78 @@
+"""
+Base class for all automata
+
+Automata are deterministic, rule-based components that handle
+specific tasks without requiring LLM inference.
+"""
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+import logging
+
+from app.models.schemas import TaskType, Language
+
+logger = logging.getLogger(__name__)
+
+
+class BaseAutomaton(ABC):
+    """Base class for all automata"""
+
+    def __init__(self, name: str):
+        self.name = name
+        logger.info(f"Initializing automaton: {name}")
+
+    @abstractmethod
+    def can_handle(
+        self,
+        code: str,
+        language: Language,
+        task: TaskType
+    ) -> bool:
+        """
+        Determine if this automaton can handle the task
+
+        Args:
+            code: Source code
+            language: Programming language
+            task: Task type
+
+        Returns:
+            True if automaton can handle this task
+        """
+        pass
+
+    @abstractmethod
+    async def execute(
+        self,
+        code: str,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Execute the automaton
+
+        Args:
+            code: Source code to process
+            **kwargs: Additional parameters
+
+        Returns:
+            Dict with:
+            - success: bool
+            - result: str (processed code or output)
+            - explanation: Optional[str]
+            - suggestions: Optional[List[str]]
+        """
+        pass
+
+    def _format_result(
+        self,
+        success: bool,
+        result: Optional[str] = None,
+        explanation: Optional[str] = None,
+        suggestions: Optional[list] = None
+    ) -> Dict[str, Any]:
+        """Helper to format results consistently"""
+        return {
+            "success": success,
+            "result": result,
+            "explanation": explanation,
+            "suggestions": suggestions or []
+        }

backend/app/automata/formatter.py

@@ -0,0 +1,86 @@
+"""
+Python code formatter using Black
+"""
+import logging
+from typing import Dict, Any
+
+from app.automata.base import BaseAutomaton
+from app.models.schemas import TaskType, Language
+
+logger = logging.getLogger(__name__)
+
+
+class PythonFormatter(BaseAutomaton):
+    """Formats Python code using Black"""
+
+    def __init__(self):
+        super().__init__("python_formatter")
+        self._black_available = False
+
+        try:
+            import black
+            self._black = black
+            self._black_available = True
+            logger.info("Black formatter loaded successfully")
+        except ImportError:
+            logger.warning("Black not available, formatter will be limited")
+
+    def can_handle(
+        self,
+        code: str,
+        language: Language,
+        task: TaskType
+    ) -> bool:
+        """Check if can format this code"""
+        return (
+            self._black_available
+            and language == Language.PYTHON
+            and task == TaskType.FORMAT
+        )
+
+    async def execute(
+        self,
+        code: str,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Format Python code with Black"""
+        if not self._black_available:
+            return self._format_result(
+                success=False,
+                explanation="Black formatter not available"
+            )
+
+        try:
+            # Format with Black
+            mode = self._black.Mode(
+                line_length=88,
+                string_normalization=True,
+                magic_trailing_comma=True
+            )
+
+            formatted_code = self._black.format_str(code, mode=mode)
+
+            if formatted_code == code:
+                return self._format_result(
+                    success=True,
+                    result=code,
+                    explanation="Code is already properly formatted",
+                    suggestions=[]
+                )
+
+            return self._format_result(
+                success=True,
+                result=formatted_code,
+                explanation="Code formatted with Black (PEP 8 style)",
+                suggestions=[
+                    "Consider using Black in your pre-commit hooks",
+                    "Configure Black in pyproject.toml for project-wide consistency"
+                ]
+            )
+
+        except Exception as e:
+            logger.error(f"Black formatting failed: {e}")
+            return self._format_result(
+                success=False,
+                explanation=f"Formatting error: {str(e)}"
+            )

backend/app/automata/linter.py

@@ -0,0 +1,139 @@
+"""
+Python code linter using Ruff
+"""
+import logging
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Dict, Any
+
+from app.automata.base import BaseAutomaton
+from app.models.schemas import TaskType, Language
+
+logger = logging.getLogger(__name__)
+
+
+class PythonLinter(BaseAutomaton):
+    """Lints and auto-fixes Python code using Ruff"""
+
+    def __init__(self):
+        super().__init__("python_linter")
+        self._ruff_available = self._check_ruff()
+
+    def _check_ruff(self) -> bool:
+        """Check if Ruff is available"""
+        try:
+            # Use python -m ruff for better cross-platform compatibility
+            result = subprocess.run(
+                [sys.executable, "-m", "ruff", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                logger.info(f"Ruff available: {result.stdout.strip()}")
+                return True
+        except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+            logger.warning(f"Ruff not available: {e}")
+
+        return False
+
+    def can_handle(
+        self,
+        code: str,
+        language: Language,
+        task: TaskType
+    ) -> bool:
+        """Check if can lint this code"""
+        return (
+            self._ruff_available
+            and language == Language.PYTHON
+            and task in [TaskType.FIX, TaskType.FORMAT]
+        )
+
+    async def execute(
+        self,
+        code: str,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Lint and auto-fix Python code with Ruff"""
+        if not self._ruff_available:
+            return self._format_result(
+                success=False,
+                explanation="Ruff linter not available"
+            )
+
+        try:
+            # Create temporary file
+            with tempfile.NamedTemporaryFile(
+                mode='w',
+                suffix='.py',
+                delete=False,
+                encoding='utf-8'
+            ) as tmp:
+                tmp.write(code)
+                tmp_path = tmp.name
+
+            try:
+                # Run Ruff check using python -m
+                check_result = subprocess.run(
+                    [sys.executable, "-m", "ruff", "check", tmp_path, "--output-format=json"],
+                    capture_output=True,
+                    text=True,
+                    timeout=10
+                )
+
+                # Run Ruff fix using python -m
+                fix_result = subprocess.run(
+                    [sys.executable, "-m", "ruff", "check", tmp_path, "--fix"],
+                    capture_output=True,
+                    text=True,
+                    timeout=10
+                )
+
+                # Read fixed code
+                fixed_code = Path(tmp_path).read_text(encoding='utf-8')
+
+                # Count issues
+                import json
+                try:
+                    issues = json.loads(check_result.stdout) if check_result.stdout else []
+                    issue_count = len(issues)
+                except json.JSONDecodeError:
+                    issue_count = 0
+
+                if fixed_code == code:
+                    return self._format_result(
+                        success=True,
+                        result=code,
+                        explanation="No linting issues found" if issue_count == 0 else f"Found {issue_count} issues but couldn't auto-fix",
+                        suggestions=["Code follows Python best practices"] if issue_count == 0 else []
+                    )
+
+                return self._format_result(
+                    success=True,
+                    result=fixed_code,
+                    explanation=f"Auto-fixed {issue_count} linting issues",
+                    suggestions=[
+                        "Configure Ruff in pyproject.toml",
+                        "Add Ruff to your CI/CD pipeline"
+                    ]
+                )
+
+            finally:
+                # Cleanup
+                Path(tmp_path).unlink(missing_ok=True)
+
+        except subprocess.TimeoutExpired:
+            logger.error("Ruff execution timed out")
+            return self._format_result(
+                success=False,
+                explanation="Linting timed out"
+            )
+        except Exception as e:
+            logger.error(f"Ruff linting failed: {e}")
+            return self._format_result(
+                success=False,
+                explanation=f"Linting error: {str(e)}"
+            )

backend/app/automata/runtime_fixer.py

@@ -0,0 +1,297 @@
+"""
+Runtime error fixer for common Python errors
+
+Fixes simple runtime errors based on trace analysis:
+- ZeroDivisionError: Add checks before division
+- NameError: Detect typos in variable names
+- IndexError: Add boundary checks
+- SyntaxError with = vs ==: Fix comparison operators
+"""
+import ast
+import re
+import logging
+from typing import Dict, Any, Optional, List, Tuple
+from difflib import get_close_matches
+
+from app.automata.base import BaseAutomaton
+from app.models.schemas import TaskType, Language
+
+logger = logging.getLogger(__name__)
+
+
+class RuntimeFixer(BaseAutomaton):
+    """Fixes common runtime errors using trace analysis"""
+
+    def __init__(self):
+        super().__init__("runtime_fixer")
+
+    def can_handle(
+        self,
+        code: str,
+        language: Language,
+        task: TaskType,
+        trace: Optional[str] = None
+    ) -> bool:
+        """Check if can fix this code"""
+        return (
+            language == Language.PYTHON
+            and task == TaskType.FIX
+            and trace is not None  # Need trace to know what to fix
+        )
+
+    async def execute(
+        self,
+        code: str,
+        trace: Optional[str] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Try to fix runtime errors based on trace"""
+        if not trace:
+            return self._format_result(
+                success=False,
+                explanation="No trace provided"
+            )
+
+        # Identify error type from trace
+        error_type = self._identify_error_type(trace)
+
+        if not error_type:
+            return self._format_result(
+                success=False,
+                explanation="Unknown error type"
+            )
+
+        # Try to fix based on error type
+        fixers = {
+            "ZeroDivisionError": self._fix_zero_division,
+            "NameError": self._fix_name_error,
+            "IndexError": self._fix_index_error,
+            "SyntaxError": self._fix_syntax_error,
+        }
+
+        fixer_func = fixers.get(error_type)
+        if not fixer_func:
+            return self._format_result(
+                success=False,
+                explanation=f"No fixer available for {error_type}"
+            )
+
+        # Apply the fix
+        try:
+            fixed_code, explanation = fixer_func(code, trace)
+            if fixed_code:
+                return self._format_result(
+                    success=True,
+                    result=fixed_code,
+                    explanation=explanation,
+                    suggestions=["Test the fixed code with various inputs"]
+                )
+            else:
+                return self._format_result(
+                    success=False,
+                    explanation="Could not automatically fix this error"
+                )
+        except Exception as e:
+            logger.error(f"Runtime fixer failed: {e}")
+            return self._format_result(
+                success=False,
+                explanation=f"Fix attempt failed: {str(e)}"
+            )
+
+    def _identify_error_type(self, trace: str) -> Optional[str]:
+        """Identify the type of error from trace"""
+        error_patterns = [
+            (r"ZeroDivisionError", "ZeroDivisionError"),
+            (r"NameError: name '(\w+)' is not defined", "NameError"),
+            (r"IndexError", "IndexError"),
+            (r"SyntaxError.*'=' .*'=='", "SyntaxError"),
+        ]
+
+        for pattern, error_type in error_patterns:
+            if re.search(pattern, trace):
+                return error_type
+
+        return None
+
+    def _fix_zero_division(self, code: str, trace: str) -> Tuple[Optional[str], Optional[str]]:
+        """Fix division by zero errors"""
+        try:
+            tree = ast.parse(code)
+        except:
+            return None, None
+
+        # Find all divisions
+        class DivisionFixer(ast.NodeTransformer):
+            def __init__(self):
+                self.fixed = False
+
+            def visit_BinOp(self, node):
+                # Check if it's a division
+                if isinstance(node.op, (ast.Div, ast.FloorDiv)):
+                    # Check if denominator could be zero
+                    denom = node.right
+
+                    # If denominator is len() or similar, add check
+                    if isinstance(denom, ast.Call):
+                        if isinstance(denom.func, ast.Name) and denom.func.id == 'len':
+                            # This is a len() call - needs check
+                            self.fixed = True
+                            # We'll handle this at statement level
+                    elif isinstance(denom, ast.Name):
+                        # Variable - might need check
+                        self.fixed = True
+
+                return self.generic_visit(node)
+
+        fixer = DivisionFixer()
+        fixer.visit(tree)
+
+        if not fixer.fixed:
+            return None, None
+
+        # Add protective check
+        # For now, simple pattern matching approach
+        lines = code.split('\n')
+        fixed_lines = []
+
+        for line in lines:
+            # Look for division with len()
+            if '/ len(' in line or '// len(' in line:
+                # Extract the variable being divided
+                indent = len(line) - len(line.lstrip())
+                spacing = ' ' * indent
+
+                # Add check before division
+                # Extract the len() argument
+                match = re.search(r'len\((\w+)\)', line)
+                if match:
+                    var_name = match.group(1)
+                    fixed_lines.append(f"{spacing}if not {var_name}:")
+                    fixed_lines.append(f"{spacing}    return 0")
+                fixed_lines.append(line)
+            else:
+                fixed_lines.append(line)
+
+        fixed_code = '\n'.join(fixed_lines)
+
+        # Verify it parses
+        try:
+            ast.parse(fixed_code)
+            return fixed_code, "Added zero-division check"
+        except:
+            return None, None
+
+    def _fix_name_error(self, code: str, trace: str) -> Tuple[Optional[str], Optional[str]]:
+        """Fix undefined variable names (typos)"""
+        # Extract the undefined variable name
+        match = re.search(r"name '(\w+)' is not defined", trace)
+        if not match:
+            return None, None
+
+        undefined_var = match.group(1)
+
+        # Parse code to find all defined variables
+        try:
+            tree = ast.parse(code)
+        except:
+            return None, None
+
+        # Collect all defined names
+        defined_names = set()
+
+        class NameCollector(ast.NodeVisitor):
+            def visit_Name(self, node):
+                if isinstance(node.ctx, ast.Store):
+                    defined_names.add(node.id)
+
+            def visit_FunctionDef(self, node):
+                # Add function parameters
+                for arg in node.args.args:
+                    defined_names.add(arg.arg)
+                self.generic_visit(node)
+
+        NameCollector().visit(tree)
+
+        # Find closest match
+        matches = get_close_matches(undefined_var, defined_names, n=1, cutoff=0.6)
+
+        if matches:
+            correct_name = matches[0]
+            # Replace typo with correct name
+            fixed_code = re.sub(r'\b' + undefined_var + r'\b', correct_name, code)
+
+            # Verify it parses
+            try:
+                ast.parse(fixed_code)
+                return fixed_code, f"Fixed typo: '{undefined_var}' → '{correct_name}'"
+            except:
+                return None, None
+
+        return None, None
+
+    def _fix_index_error(self, code: str, trace: str) -> Tuple[Optional[str], Optional[str]]:
+        """Fix index out of range errors"""
+        lines = code.split('\n')
+        fixed_lines = []
+
+        for line in lines:
+            # Look for array indexing [0], [1], etc.
+            if re.search(r'\w+\[\d+\]', line):
+                indent = len(line) - len(line.lstrip())
+                spacing = ' ' * indent
+
+                # Extract the variable being indexed
+                match = re.search(r'(\w+)\[(\d+)\]', line)
+                if match:
+                    var_name = match.group(1)
+                    index = match.group(2)
+
+                    # Add check
+                    fixed_lines.append(f"{spacing}if not {var_name}:")
+                    fixed_lines.append(f"{spacing}    return None")
+                fixed_lines.append(line)
+            else:
+                fixed_lines.append(line)
+
+        fixed_code = '\n'.join(fixed_lines)
+
+        # Verify it parses
+        try:
+            ast.parse(fixed_code)
+            if fixed_code != code:
+                return fixed_code, "Added index bounds check"
+        except:
+            pass
+
+        return None, None
+
+    def _fix_syntax_error(self, code: str, trace: str) -> Tuple[Optional[str], Optional[str]]:
+        """Fix = vs == in conditions"""
+        if "'=' " in trace and "'=='" in trace:
+            # This is the = vs == error
+            # Fix by replacing = with == in if statements
+            lines = code.split('\n')
+            fixed_lines = []
+            fixed = False
+
+            for line in lines:
+                # Look for if x = value pattern
+                if 'if ' in line and ' = ' in line and not line.strip().endswith('='):
+                    # Replace = with ==
+                    parts = line.split(' = ', 1)
+                    if len(parts) == 2:
+                        fixed_line = parts[0] + ' == ' + parts[1]
+                        fixed_lines.append(fixed_line)
+                        fixed = True
+                        continue
+                fixed_lines.append(line)
+
+            if fixed:
+                fixed_code = '\n'.join(fixed_lines)
+                try:
+                    ast.parse(fixed_code)
+                    return fixed_code, "Fixed comparison: '=' → '=='"
+                except:
+                    pass
+
+        return None, None

backend/app/automata/test_generator.py

@@ -0,0 +1,161 @@
+"""
+Template-based test generator
+
+Generates basic test structure using templates.
+SLM will fill in the specific test cases.
+"""
+import re
+import logging
+from typing import Dict, Any, Optional, List
+
+from app.automata.base import BaseAutomaton
+from app.models.schemas import TaskType, Language
+
+logger = logging.getLogger(__name__)
+
+
+class TestTemplateGenerator(BaseAutomaton):
+    """Generates test templates for code"""
+
+    def __init__(self):
+        super().__init__("test_template")
+
+        self.templates = {
+            Language.PYTHON: self._python_template,
+            Language.JAVASCRIPT: self._javascript_template,
+        }
+
+    def can_handle(
+        self,
+        code: str,
+        language: Language,
+        task: TaskType
+    ) -> bool:
+        """Check if can generate test template"""
+        # Only generates templates, not full tests
+        # Returns partial result for SLM to complete
+        return False  # Let SLM handle full test generation
+
+    async def execute(
+        self,
+        code: str,
+        language: Language = Language.PYTHON,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Generate test template"""
+        template_func = self.templates.get(language)
+
+        if not template_func:
+            return self._format_result(
+                success=False,
+                explanation=f"No template for {language}"
+            )
+
+        try:
+            # Extract function/class names
+            entities = self._extract_entities(code, language)
+
+            # Generate template
+            template = template_func(entities)
+
+            return self._format_result(
+                success=True,
+                result=template,
+                explanation=f"Generated test template for {len(entities)} entities",
+                suggestions=[
+                    "Fill in test cases with specific scenarios",
+                    "Add edge cases and error handling tests",
+                    "Consider using parametrized tests"
+                ]
+            )
+
+        except Exception as e:
+            logger.error(f"Template generation failed: {e}")
+            return self._format_result(
+                success=False,
+                explanation=f"Generation error: {str(e)}"
+            )
+
+    def _extract_entities(self, code: str, language: Language) -> List[Dict[str, str]]:
+        """Extract functions and classes from code"""
+        entities = []
+
+        if language == Language.PYTHON:
+            # Extract Python functions and classes
+            func_pattern = r'^def\s+(\w+)\s*\('
+            class_pattern = r'^class\s+(\w+)'
+
+            for match in re.finditer(func_pattern, code, re.MULTILINE):
+                entities.append({"type": "function", "name": match.group(1)})
+
+            for match in re.finditer(class_pattern, code, re.MULTILINE):
+                entities.append({"type": "class", "name": match.group(1)})
+
+        elif language == Language.JAVASCRIPT:
+            # Extract JavaScript functions
+            func_pattern = r'function\s+(\w+)\s*\('
+            arrow_pattern = r'const\s+(\w+)\s*=\s*\('
+
+            for match in re.finditer(func_pattern, code, re.MULTILINE):
+                entities.append({"type": "function", "name": match.group(1)})
+
+            for match in re.finditer(arrow_pattern, code, re.MULTILINE):
+                entities.append({"type": "function", "name": match.group(1)})
+
+        return entities
+
+    def _python_template(self, entities: List[Dict[str, str]]) -> str:
+        """Generate Python test template"""
+        template = '''"""
+Unit tests for generated code
+"""
+import pytest
+
+
+'''
+        for entity in entities:
+            if entity["type"] == "function":
+                template += f'''def test_{entity["name"]}():
+    """Test {entity["name"]} function"""
+    # TODO: Add test cases
+    pass
+
+
+'''
+            elif entity["type"] == "class":
+                template += f'''class Test{entity["name"]}:
+    """Test {entity["name"]} class"""
+
+    def test_init(self):
+        """Test initialization"""
+        # TODO: Add test
+        pass
+
+    def test_methods(self):
+        """Test methods"""
+        # TODO: Add test
+        pass
+
+
+'''
+
+        return template
+
+    def _javascript_template(self, entities: List[Dict[str, str]]) -> str:
+        """Generate JavaScript test template"""
+        template = '''/**
+ * Unit tests for generated code
+ */
+
+'''
+        for entity in entities:
+            template += f'''describe('{entity["name"]}', () => {{
+    test('should work correctly', () => {{
+        // TODO: Add test cases
+        expect(true).toBe(true);
+    }});
+}});
+
+'''
+
+        return template

backend/app/automata/trace_parser.py

@@ -0,0 +1,177 @@
+"""
+Error trace parser and explainer
+
+Uses regex and pattern matching to extract key information
+from error traces before passing to LLM.
+"""
+import re
+import logging
+from typing import Dict, Any, Optional, List
+
+from app.automata.base import BaseAutomaton
+from app.models.schemas import TaskType, Language
+
+logger = logging.getLogger(__name__)
+
+
+class TraceParser(BaseAutomaton):
+    """Parses and extracts information from error traces"""
+
+    def __init__(self):
+        super().__init__("trace_parser")
+
+        # Common error patterns
+        self.patterns = {
+            "python": [
+                (r"(\w+Error): (.+)", "error_type"),
+                (r'File "([^"]+)", line (\d+)', "file_location"),
+                (r"NameError: name '(\w+)' is not defined", "undefined_variable"),
+                (r"TypeError: (.+)", "type_error"),
+                (r"AttributeError: (.+) has no attribute '(\w+)'", "attribute_error"),
+                (r"IndexError: (.+)", "index_error"),
+                (r"KeyError: (.+)", "key_error"),
+            ],
+            "javascript": [
+                (r"(\w+Error): (.+)", "error_type"),
+                (r"at (.+) \((.+):(\d+):(\d+)\)", "stack_location"),
+                (r"ReferenceError: (\w+) is not defined", "undefined_variable"),
+                (r"TypeError: (.+)", "type_error"),
+            ]
+        }
+
+    def can_handle(
+        self,
+        code: str,
+        language: Language,
+        task: TaskType
+    ) -> bool:
+        """Check if can parse this trace"""
+        # Only handle explain tasks
+        return task == TaskType.EXPLAIN
+
+    async def execute(
+        self,
+        code: str,
+        trace: Optional[str] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Parse error trace"""
+        if not trace:
+            return self._format_result(
+                success=False,
+                explanation="No trace provided"
+            )
+
+        try:
+            # Detect language from trace
+            language = self._detect_language(trace)
+
+            # Extract structured information
+            info = self._extract_info(trace, language)
+
+            if not info:
+                # Couldn't parse, let SLM handle it
+                return self._format_result(
+                    success=False,
+                    explanation="Trace format not recognized, needs SLM analysis"
+                )
+
+            # Build explanation
+            explanation = self._build_explanation(info)
+            suggestions = self._get_suggestions(info)
+
+            return self._format_result(
+                success=True,
+                result=trace,  # Return original trace
+                explanation=explanation,
+                suggestions=suggestions
+            )
+
+        except Exception as e:
+            logger.error(f"Trace parsing failed: {e}")
+            return self._format_result(
+                success=False,
+                explanation=f"Parse error: {str(e)}"
+            )
+
+    def _detect_language(self, trace: str) -> str:
+        """Detect programming language from trace"""
+        if "Traceback (most recent call last)" in trace or "Error:" in trace:
+            return "python"
+        elif "at " in trace and "Error:" in trace:
+            return "javascript"
+        return "unknown"
+
+    def _extract_info(self, trace: str, language: str) -> Dict[str, Any]:
+        """Extract structured information from trace"""
+        info = {
+            "language": language,
+            "error_type": None,
+            "error_message": None,
+            "file": None,
+            "line": None,
+            "details": {}
+        }
+
+        patterns = self.patterns.get(language, [])
+
+        for pattern, name in patterns:
+            match = re.search(pattern, trace)
+            if match:
+                if name == "error_type":
+                    info["error_type"] = match.group(1)
+                    info["error_message"] = match.group(2)
+                elif name == "file_location":
+                    info["file"] = match.group(1)
+                    info["line"] = match.group(2)
+                elif name == "undefined_variable":
+                    info["details"]["undefined_var"] = match.group(1)
+                elif name in ["type_error", "attribute_error", "index_error", "key_error"]:
+                    info["details"][name] = match.groups()
+
+        return info if info["error_type"] else {}
+
+    def _build_explanation(self, info: Dict[str, Any]) -> str:
+        """Build human-readable explanation"""
+        error_type = info.get("error_type", "Unknown")
+        error_msg = info.get("error_message", "")
+        file_info = ""
+
+        if info.get("file") and info.get("line"):
+            file_info = f" in {info['file']} at line {info['line']}"
+
+        explanation = f"**{error_type}**{file_info}\n\n{error_msg}"
+
+        # Add specific guidance
+        if "undefined_var" in info.get("details", {}):
+            var = info["details"]["undefined_var"]
+            explanation += f"\n\nThe variable '{var}' is used but not defined. Check for typos or ensure it's declared before use."
+
+        return explanation
+
+    def _get_suggestions(self, info: Dict[str, Any]) -> List[str]:
+        """Get suggestions based on error type"""
+        error_type = info.get("error_type", "")
+        suggestions = []
+
+        if error_type == "NameError":
+            suggestions.append("Check for typos in variable names")
+            suggestions.append("Ensure variables are defined before use")
+            suggestions.append("Check import statements")
+
+        elif error_type == "TypeError":
+            suggestions.append("Verify function arguments match expected types")
+            suggestions.append("Check None values before operations")
+            suggestions.append("Add type hints for better clarity")
+
+        elif error_type == "AttributeError":
+            suggestions.append("Verify the object has the expected attribute")
+            suggestions.append("Check for None values")
+            suggestions.append("Review object initialization")
+
+        elif error_type == "IndexError":
+            suggestions.append("Check list/array bounds")
+            suggestions.append("Verify index values are within range")
+            suggestions.append("Use len() to validate indices")
+
+        return suggestions

backend/app/config.py

@@ -0,0 +1,91 @@
+"""
+Configuration management for SLM Code Engine
+"""
+from pathlib import Path
+from typing import Optional
+from pydantic_settings import BaseSettings
+from pydantic import Field
+
+
+class Settings(BaseSettings):
+    """Application settings with environment variable support"""
+
+    # API Configuration
+    api_host: str = Field(default="0.0.0.0", env="API_HOST")
+    api_port: int = Field(default=8000, env="API_PORT")
+    api_workers: int = Field(default=1, env="API_WORKERS")
+    debug: bool = Field(default=True, env="DEBUG")
+
+    # Groq Configuration
+    groq_api_key: Optional[str] = Field(default=None, env="GROQ_API_KEY")
+
+    # Localization
+    language: str = Field(
+        default="en",
+        env="LANGUAGE",
+        description="Language for responses (e.g., 'en', 'fr')",
+    )
+
+    # Project paths
+    project_root: Path = Path(__file__).parent.parent.parent
+    models_dir: Path = Field(default_factory=lambda: Path(__file__).parent.parent.parent / "models")
+    data_dir: Path = Field(default_factory=lambda: Path(__file__).parent.parent.parent / "data")
+    cache_dir: Path = Field(default_factory=lambda: Path(__file__).parent.parent.parent / "data" / "cache")
+
+    # Models Configuration
+    starcoder_model: str = Field(default="phi-2.Q4_K_M.gguf", env="STARCODER_MODEL")
+    codet5_model: str = Field(default="codet5-small", env="CODET5_MODEL")
+    embedding_model: str = Field(default="all-MiniLM-L6-v2", env="EMBEDDING_MODEL")
+
+    # Model inference settings
+    max_tokens: int = Field(default=2048, env="MAX_TOKENS")
+    temperature: float = Field(default=0.2, env="TEMPERATURE")
+    n_ctx: int = Field(default=4096, env="N_CTX")  # Context window
+    n_threads: Optional[int] = Field(default=None, env="N_THREADS")  # CPU threads
+
+    # Database
+    db_path: Path = Field(default_factory=lambda: Path(__file__).parent.parent.parent / "data" / "usage.db")
+
+    # Sandbox Configuration
+    sandbox_enabled: bool = Field(default=True, env="SANDBOX_ENABLED")
+    sandbox_timeout: int = Field(default=30, env="SANDBOX_TIMEOUT")  # seconds
+    sandbox_memory_limit: str = Field(default="512m", env="SANDBOX_MEMORY_LIMIT")
+
+    # Orchestrator Configuration
+    router_threshold: float = Field(default=0.7, env="ROUTER_THRESHOLD")  # Confidence threshold
+    enable_automata_first: bool = Field(default=True, env="ENABLE_AUTOMATA_FIRST")
+    enable_automata_first: bool = Field(default=True, env="ENABLE_AUTOMATA_FIRST")
+    enable_rag: bool = Field(default=True, env="ENABLE_RAG")  # Enable RAG context enrichment
+    enable_distillation: bool = Field(default=True, env="ENABLE_DISTILLATION")  # Enable data collection
+
+    # Logging
+    log_level: str = Field(default="INFO", env="LOG_LEVEL")
+    log_file: Optional[Path] = Field(default=None, env="LOG_FILE")
+
+    class Config:
+        # Look for .env in project root
+        env_file = str(Path(__file__).parent.parent.parent / ".env")
+        env_file_encoding = "utf-8"
+        case_sensitive = False
+        extra = "ignore"  # Ignore extra fields in .env
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # Ensure directories exist
+        self.models_dir.mkdir(parents=True, exist_ok=True)
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+    @property
+    def starcoder_path(self) -> Path:
+        """Get full path to StarCoder model (currently using Phi-2)"""
+        return self.models_dir / "phi-2" / self.starcoder_model
+
+    @property
+    def codet5_path(self) -> Path:
+        """Get full path to CodeT5 model"""
+        return self.models_dir / "codet5-small"
+
+
+# Global settings instance
+settings = Settings()

backend/app/core/__init__.py

@@ -0,0 +1 @@
+"""Core package"""

backend/app/core/automata_manager.py

@@ -0,0 +1,73 @@
+"""
+Automata Manager
+
+Manages the lifecycle and execution of deterministic automata.
+Automata are fast, rule-based code processors that handle simple tasks.
+"""
+import logging
+from typing import Dict, Optional, Any
+from app.models.schemas import TaskType, Language
+
+logger = logging.getLogger(__name__)
+
+
+class AutomataManager:
+    """Manager for deterministic automata"""
+    
+    def __init__(self):
+        self.automata: Dict[str, Any] = {}
+        logger.info("AutomataManager initialized")
+    
+    def register_automaton(self, name: str, automaton: Any):
+        """Register an automaton"""
+        self.automata[name] = automaton
+        logger.info(f"Registered automaton: {name}")
+    
+    def get_automaton(self, name: str) -> Optional[Any]:
+        """Get an automaton by name"""
+        return self.automata.get(name)
+    
+    def list_automata(self) -> list:
+        """List all registered automata"""
+        return list(self.automata.keys())
+    
+    async def execute(
+        self,
+        automaton_name: str,
+        code: str,
+        language: Language,
+        task: TaskType,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Execute an automaton"""
+        automaton = self.get_automaton(automaton_name)
+        
+        if not automaton:
+            return {
+                "success": False,
+                "error": f"Automaton '{automaton_name}' not found"
+            }
+        
+        try:
+            if hasattr(automaton, 'can_handle'):
+                if not automaton.can_handle(code, language, task):
+                    return {
+                        "success": False,
+                        "error": "Automaton cannot handle this task"
+                    }
+            
+            if hasattr(automaton, 'execute'):
+                result = await automaton.execute(code, **kwargs)
+                return result
+            else:
+                return {
+                    "success": False,
+                    "error": "Automaton does not implement execute method"
+                }
+        
+        except Exception as e:
+            logger.error(f"Error executing automaton {automaton_name}: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }

backend/app/core/distillation.py

@@ -0,0 +1,92 @@
+"""
+Distillation Logger
+
+Captures high-quality interactions (Teacher -> Student) for Knowledge Distillation.
+Logs Prompt/Response pairs to a dataset file for future fine-tuning of local SLMs.
+"""
+import json
+import logging
+import time
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+from app.config import settings
+from app.models.schemas import TaskType, Language
+
+logger = logging.getLogger(__name__)
+
+
+class DistillationLogger:
+    """Logs interactions for knowledge distillation"""
+
+    def __init__(self):
+        self.enabled = settings.enable_distillation
+        self.dataset_dir = settings.data_dir / "datasets"
+        self.dataset_file = self.dataset_dir / "distillation_v1.jsonl"
+        
+        if self.enabled:
+            self._ensure_setup()
+
+    def _ensure_setup(self):
+        """Ensure dataset directory exists"""
+        try:
+            self.dataset_dir.mkdir(parents=True, exist_ok=True)
+            logger.info(f"Distillation logger initialized. Dataset: {self.dataset_file}")
+        except Exception as e:
+            logger.error(f"Failed to setup distillation logger: {e}")
+            self.enabled = False
+
+    async def log_interaction(
+        self,
+        task: TaskType,
+        language: Language,
+        code_input: str,
+        context: Optional[str],
+        output: str,
+        model: str,
+        score: float = 1.0
+    ):
+        """
+        Log a successful interaction
+        
+        Format follows Alpaca/Instruction tuning standards:
+        {
+            "instruction": "The task description",
+            "input": "The code context (optional)",
+            "output": "The model response",
+            ...metadata
+        }
+        """
+        if not self.enabled:
+            return
+
+        try:
+            # Construct instruction based on task
+            instruction = f"Perform task: {task} for language: {language}"
+            if context:
+                instruction += f". Context: {context}"
+
+            entry = {
+                "instruction": instruction,
+                "input": code_input,
+                "output": output,
+                "metadata": {
+                    "task": task,
+                    "language": language,
+                    "teacher_model": model,
+                    "timestamp": time.time(),
+                    "score": score
+                }
+            }
+
+            # Append to JSONL file
+            with open(self.dataset_file, "a", encoding="utf-8") as f:
+                f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+            
+            logger.debug("Logged distillation example")
+
+        except Exception as e:
+            logger.error(f"Failed to log distillation example: {e}")
+
+# Global instance
+distillation_logger = DistillationLogger()

backend/app/core/lifecycle.py

@@ -0,0 +1,97 @@
+"""
+Lifecycle Manager
+
+Manages the lifecycle of engines and components:
+- Initialization
+- Health checks
+- Graceful shutdown
+- Resource cleanup
+"""
+import logging
+import asyncio
+from typing import Dict, Any, List
+from contextlib import asynccontextmanager
+
+logger = logging.getLogger(__name__)
+
+
+class LifecycleManager:
+    """Manages component lifecycle"""
+    
+    def __init__(self):
+        self.components: Dict[str, Any] = {}
+        self.initialized = False
+        logger.info("LifecycleManager created")
+    
+    def register_component(self, name: str, component: Any):
+        """Register a component for lifecycle management"""
+        self.components[name] = component
+        logger.info(f"Registered component: {name}")
+    
+    async def initialize_all(self):
+        """Initialize all registered components"""
+        logger.info("Initializing all components...")
+        
+        for name, component in self.components.items():
+            try:
+                if hasattr(component, 'initialize'):
+                    logger.info(f"Initializing {name}...")
+                    await component.initialize()
+                    logger.info(f"✓ {name} initialized")
+            except Exception as e:
+                logger.error(f"Failed to initialize {name}: {e}")
+                raise
+        
+        self.initialized = True
+        logger.info("All components initialized successfully")
+    
+    async def shutdown_all(self):
+        """Shutdown all components gracefully"""
+        logger.info("Shutting down all components...")
+        
+        for name, component in reversed(list(self.components.items())):
+            try:
+                if hasattr(component, 'shutdown'):
+                    logger.info(f"Shutting down {name}...")
+                    await component.shutdown()
+                    logger.info(f"✓ {name} shut down")
+            except Exception as e:
+                logger.error(f"Error shutting down {name}: {e}")
+        
+        self.initialized = False
+        logger.info("All components shut down")
+    
+    async def health_check(self) -> Dict[str, Any]:
+        """Check health of all components"""
+        health_status = {
+            "status": "healthy",
+            "components": {}
+        }
+        
+        for name, component in self.components.items():
+            try:
+                if hasattr(component, 'health_check'):
+                    component_health = await component.health_check()
+                    health_status["components"][name] = component_health
+                else:
+                    health_status["components"][name] = {
+                        "status": "unknown",
+                        "message": "No health check implemented"
+                    }
+            except Exception as e:
+                health_status["components"][name] = {
+                    "status": "unhealthy",
+                    "error": str(e)
+                }
+                health_status["status"] = "degraded"
+        
+        return health_status
+    
+    @asynccontextmanager
+    async def lifespan(self):
+        """Context manager for application lifespan"""
+        try:
+            await self.initialize_all()
+            yield
+        finally:
+            await self.shutdown_all()

backend/app/core/model_cache.py

@@ -0,0 +1,240 @@
+"""
+Model Cache with LRU Eviction
+
+Intelligent caching system for Micro-SLMs to minimize loading time.
+Keeps the most recently used models in memory.
+"""
+import logging
+import asyncio
+from collections import OrderedDict
+from typing import Optional, Callable, Any, Dict
+from datetime import datetime
+
+try:
+    import psutil
+    HAS_PSUTIL = True
+except ImportError:
+    HAS_PSUTIL = False
+
+logger = logging.getLogger(__name__)
+
+
+class ModelCache:
+    """
+    LRU (Least Recently Used) Cache for Micro-SLM models.
+    
+    Features:
+    - Automatic eviction of least recently used models
+    - Memory usage tracking
+    - Async model loading
+    - Thread-safe operations
+    """
+    
+    def __init__(
+        self,
+        max_models: int = 3,
+        max_memory_mb: int = 2000,
+        enable_stats: bool = True
+    ):
+        """
+        Initialize the model cache.
+        
+        Args:
+            max_models: Maximum number of models to keep in cache
+            max_memory_mb: Maximum memory usage in MB (soft limit)
+            enable_stats: Enable statistics tracking
+        """
+        self.cache: OrderedDict[str, Any] = OrderedDict()
+        self.max_models = max_models
+        self.max_memory_mb = max_memory_mb
+        self.enable_stats = enable_stats
+        
+        # Statistics
+        self.stats = {
+            "hits": 0,
+            "misses": 0,
+            "evictions": 0,
+            "loads": 0
+        }
+        
+        # Locks for thread safety
+        self._lock = asyncio.Lock()
+        
+        logger.info(f"ModelCache initialized: max_models={max_models}, max_memory={max_memory_mb}MB")
+    
+    async def get_or_load(
+        self,
+        model_name: str,
+        loader_func: Callable,
+        *args,
+        **kwargs
+    ) -> Any:
+        """
+        Get model from cache or load it if not present.
+        
+        Args:
+            model_name: Unique identifier for the model
+            loader_func: Async function to load the model
+            *args, **kwargs: Arguments to pass to loader_func
+        
+        Returns:
+            The loaded model instance
+        """
+        async with self._lock:
+            # Check cache
+            if model_name in self.cache:
+                # Cache hit
+                self.cache.move_to_end(model_name)
+                self.stats["hits"] += 1
+                
+                logger.info(
+                    f"✅ Cache HIT: {model_name} "
+                    f"(hit rate: {self.get_hit_rate():.1%})"
+                )
+                
+                return self.cache[model_name]
+            
+            # Cache miss - need to load
+            self.stats["misses"] += 1
+            logger.info(f"❌ Cache MISS: {model_name}")
+            
+            # Check if we need to evict
+            await self._evict_if_needed()
+            
+            # Load the model
+            logger.info(f"📥 Loading model: {model_name}...")
+            load_start = datetime.now()
+            
+            try:
+                model = await loader_func(*args, **kwargs)
+                load_duration = (datetime.now() - load_start).total_seconds()
+                
+                logger.info(f"✓ Loaded {model_name} in {load_duration:.2f}s")
+                
+                # Add to cache
+                self.cache[model_name] = model
+                self.cache.move_to_end(model_name)
+                self.stats["loads"] += 1
+                
+                return model
+            
+            except Exception as e:
+                logger.error(f"Failed to load {model_name}: {e}")
+                raise
+    
+    async def _evict_if_needed(self):
+        """Evict least recently used model if cache is full"""
+        
+        # Check model count limit
+        if len(self.cache) >= self.max_models:
+            await self._evict_oldest()
+            return
+        
+        # Check memory limit
+        memory_usage = self._get_memory_usage_mb()
+        if memory_usage > self.max_memory_mb:
+            logger.warning(
+                f"Memory usage ({memory_usage:.0f}MB) exceeds limit "
+                f"({self.max_memory_mb}MB)"
+            )
+            await self._evict_oldest()
+    
+    async def _evict_oldest(self):
+        """Evict the least recently used model"""
+        
+        if not self.cache:
+            return
+        
+        # Get oldest (first) item
+        oldest_name = next(iter(self.cache))
+        oldest_model = self.cache.pop(oldest_name)
+        
+        self.stats["evictions"] += 1
+        
+        logger.info(f"🗑️ Evicting: {oldest_name}")
+        
+        # Cleanup model resources
+        try:
+            if hasattr(oldest_model, 'shutdown'):
+                await oldest_model.shutdown()
+            elif hasattr(oldest_model, 'cleanup'):
+                await oldest_model.cleanup()
+        except Exception as e:
+            logger.warning(f"Error during model cleanup: {e}")
+    
+    def _get_memory_usage_mb(self) -> float:
+        """Get current process memory usage in MB"""
+        if not HAS_PSUTIL:
+            return 0.0
+        
+        try:
+            process = psutil.Process()
+            return process.memory_info().rss / (1024 * 1024)
+        except Exception:
+            return 0.0
+    
+    def get_hit_rate(self) -> float:
+        """Calculate cache hit rate"""
+        total = self.stats["hits"] + self.stats["misses"]
+        if total == 0:
+            return 0.0
+        return self.stats["hits"] / total
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get cache statistics"""
+        return {
+            **self.stats,
+            "cached_models": len(self.cache),
+            "model_names": list(self.cache.keys()),
+            "hit_rate": self.get_hit_rate(),
+            "memory_usage_mb": self._get_memory_usage_mb()
+        }
+    
+    async def clear(self):
+        """Clear all cached models"""
+        async with self._lock:
+            logger.info("Clearing model cache...")
+            
+            for name, model in self.cache.items():
+                try:
+                    if hasattr(model, 'shutdown'):
+                        await model.shutdown()
+                except Exception as e:
+                    logger.warning(f"Error shutting down {name}: {e}")
+            
+            self.cache.clear()
+            logger.info("Cache cleared")
+    
+    async def preload(self, model_name: str, loader_func: Callable, *args, **kwargs):
+        """
+        Preload a model into cache (prefetching).
+        
+        Useful for anticipating which model will be needed next.
+        """
+        logger.info(f"🔮 Prefetching: {model_name}")
+        await self.get_or_load(model_name, loader_func, *args, **kwargs)
+    
+    def contains(self, model_name: str) -> bool:
+        """Check if model is in cache"""
+        return model_name in self.cache
+    
+    async def remove(self, model_name: str):
+        """Manually remove a model from cache"""
+        async with self._lock:
+            if model_name in self.cache:
+                model = self.cache.pop(model_name)
+                logger.info(f"Removed {model_name} from cache")
+                
+                try:
+                    if hasattr(model, 'shutdown'):
+                        await model.shutdown()
+                except Exception as e:
+                    logger.warning(f"Error shutting down {model_name}: {e}")
+
+
+# Global cache instance
+model_cache = ModelCache(
+    max_models=3,  # Keep 3 models in memory
+    max_memory_mb=2000,  # 2GB soft limit
+    enable_stats=True
+)

backend/app/core/orchestrator.py

@@ -0,0 +1,695 @@
+"""
+Core orchestrator for SLM Code Engine
+
+Responsible for:
+- Routing tasks to appropriate engines (automata vs SLM)
+- Building execution pipelines
+- Coordinating between micro-SLMs and automata
+- Collecting metrics and logging
+"""
+import time
+import logging
+from typing import Dict, Any, List, Optional
+from pathlib import Path
+
+from app.config import settings
+from app.models.schemas import TaskType, Language
+from app.core.router import Router
+from app.core.router_v2 import router_v2
+from app.core.task_decomposer import task_decomposer
+from app.core.slm_registry import slm_registry
+from app.core.automata_manager import AutomataManager
+from app.core.rag import RAGRetriever
+from app.core.lifecycle import LifecycleManager
+from app.core.pipeline import Pipeline
+from app.core.model_cache import model_cache
+from app.engines.base import BaseEngine
+from app.automata.base import BaseAutomaton
+from app.rag.retriever import CodeRetriever
+
+logger = logging.getLogger(__name__)
+
+
+class Orchestrator:
+    """Main orchestrator coordinating all components"""
+
+    def __init__(self):
+        self.router = Router()
+        self.router_v2 = router_v2  # New micro-SLM router
+        self.task_decomposer = task_decomposer
+        self.slm_registry = slm_registry
+        self.automata_manager = AutomataManager()
+        self.pipeline: Optional[Pipeline] = None
+        self.engines: Dict[str, BaseEngine] = {}
+        self.automata: Dict[str, BaseAutomaton] = {}
+        self.retriever = None
+        self.enable_decomposition = True  # Enable task decomposition
+        self.initialized = False
+        self._metrics = []
+
+    async def initialize(self):
+        """Initialize all components"""
+        logger.info("Initializing orchestrator...")
+
+        try:
+            # Initialize router
+            self.router = Router()
+            await self.router.initialize()
+
+            # Initialize pipeline builder
+            self.pipeline = Pipeline()
+
+            # Load automata (lightweight, always loaded)
+            await self._load_automata()
+
+            # Load SLM engines (lazy loading for performance)
+            await self._load_engines()
+
+            # Initialize RAG retriever (lazy loading)
+            index_path = settings.data_dir / "rag_index.faiss"
+            self.retriever = CodeRetriever(index_path=str(index_path))
+            logger.info("RAG retriever configured (lazy loading)")
+
+            self.initialized = True
+            logger.info("Orchestrator initialized successfully")
+
+        except Exception as e:
+            logger.error(f"Failed to initialize orchestrator: {e}")
+            raise
+
+    async def _load_automata(self):
+        """Load all available automata"""
+        logger.info("Loading automata...")
+
+        try:
+            # Import automata (we'll create these files next)
+            from app.automata.formatter import PythonFormatter
+            from app.automata.linter import PythonLinter
+            from app.automata.trace_parser import TraceParser
+            from app.automata.ast_fixer import ASTFixer
+            from app.automata.test_generator import TestTemplateGenerator
+            from app.automata.runtime_fixer import RuntimeFixer
+
+            # Register automata
+            self.automata["python_formatter"] = PythonFormatter()
+            self.automata["python_linter"] = PythonLinter()
+            self.automata["trace_parser"] = TraceParser()
+            self.automata["ast_fixer"] = ASTFixer()
+            self.automata["runtime_fixer"] = RuntimeFixer()  # NEW: Fix runtime errors
+            self.automata["test_template"] = TestTemplateGenerator()
+
+            logger.info(f"Loaded {len(self.automata)} automata: {list(self.automata.keys())}")
+
+        except Exception as e:
+            logger.warning(f"Failed to load some automata: {e}")
+            # Non-critical, continue with available automata
+
+    async def _load_engines(self):
+        """Load SLM engines (lazy loading)"""
+        logger.info("Loading SLM engines...")
+
+        # For V1, we'll implement lazy loading
+        # Engines are loaded on first use to save memory
+        logger.info("SLM engines configured for lazy loading")
+
+    async def _get_engine(self, engine_name: str) -> BaseEngine:
+        """Get or load an engine on demand"""
+        if engine_name not in self.engines:
+            logger.info(f"Loading engine: {engine_name}")
+
+            try:
+                if engine_name == "groq":
+                    from app.engines.groq_engine import GroqEngine
+                    self.engines[engine_name] = GroqEngine()
+                    await self.engines[engine_name].initialize()
+                
+                elif engine_name == "phi2":
+                    from app.engines.phi2 import Phi2Engine
+                    self.engines[engine_name] = Phi2Engine()
+                    await self.engines[engine_name].initialize()
+                
+                elif engine_name == "starcoder":
+                    from app.engines.starcoder import StarCoderEngine
+                    self.engines[engine_name] = StarCoderEngine()
+                    await self.engines[engine_name].initialize()
+
+                elif engine_name == "codet5":
+                    from app.engines.codet5 import CodeT5Engine
+                    self.engines[engine_name] = CodeT5Engine()
+                    await self.engines[engine_name].initialize()
+
+                else:
+                    # Check if it's a registered Micro-SLM
+                    micro_slm_info = self.slm_registry.get_model(engine_name)
+                    if micro_slm_info:
+                        from app.engines.micro_slm import MicroSLMEngine
+                        
+                        # Use cache for Micro-SLMs
+                        async def load_micro_slm():
+                            engine = MicroSLMEngine(
+                                name=engine_name,
+                                model_path=micro_slm_info.model_path
+                            )
+                            await engine.initialize()
+                            return engine
+                        
+                        self.engines[engine_name] = await model_cache.get_or_load(
+                            model_name=engine_name,
+                            loader_func=load_micro_slm
+                        )
+                    else:
+                        raise ValueError(f"Unknown engine: {engine_name}")
+
+                logger.info(f"Engine {engine_name} loaded successfully")
+
+            except Exception as e:
+                logger.error(f"Failed to load engine {engine_name}: {e}")
+                raise
+
+        return self.engines[engine_name]
+
+    async def process(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str] = None,
+        trace: Optional[str] = None,
+        history: Optional[List[Dict[str, str]]] = None
+    ) -> Dict[str, Any]:
+        """
+        Main processing method
+
+        Args:
+            task: Type of task to perform
+            code: Source code to process
+            language: Programming language
+            context: Additional context
+            trace: Error trace (if applicable)
+            history: Conversation history for context
+
+        Returns:
+            Dict with results and metadata
+        """
+        start_time = time.time()
+        pipeline_steps = []
+
+        try:
+            # Step 0: Check if we should decompose this task
+            if self.enable_decomposition and self._should_decompose(task):
+                return await self._process_with_decomposition(
+                    task=task,
+                    code=code,
+                    language=language,
+                    context=context,
+                    trace=trace,
+                    history=history,
+                    start_time=start_time,
+                    pipeline_steps=pipeline_steps
+                )
+            
+            # Step 1: Route the task using RouterV2 (supports Micro-SLMs)
+            routing_decision = await self.router_v2.route_task(
+                task=task,
+                code=code,
+                language=language,
+                context=context
+            )
+
+            logger.info(f"Routing decision: {routing_decision}")
+
+            # Step 2: Try automata first (if enabled and applicable)
+            if settings.enable_automata_first and routing_decision.get("try_automata"):
+                automata_result = await self._try_automata(
+                    task=task,
+                    code=code,
+                    language=language,
+                    trace=trace,
+                    pipeline_steps=pipeline_steps
+                )
+
+                if automata_result.get("success"):
+                    # Check if code was actually modified
+                    code_changed = automata_result.get("result") != code
+
+                    # For FIX tasks, if code unchanged, try SLM for deeper analysis
+                    if task == TaskType.FIX and not code_changed:
+                        logger.info("Automata found no issues, trying SLM for deeper analysis")
+                        # Continue to SLM fallback
+                    else:
+                        # Automata succeeded with changes, return result
+                        duration_ms = (time.time() - start_time) * 1000
+                        return {
+                            "success": True,
+                            "task": task,
+                            "result": automata_result["result"],
+                            "explanation": automata_result.get("explanation"),
+                            "suggestions": automata_result.get("suggestions", []),
+                            "used_automata": True,
+                            "used_slm": False,
+                            "pipeline": pipeline_steps,
+                            "total_duration_ms": duration_ms
+                        }
+
+            # Step 3: Use SLM
+            slm_result = await self._use_slm(
+                task=task,
+                code=code,
+                language=language,
+                context=context,
+                trace=trace,
+                routing_decision=routing_decision,
+                pipeline_steps=pipeline_steps,
+                history=history
+            )
+
+            duration_ms = (time.time() - start_time) * 1000
+
+            return {
+                "success": slm_result.get("success", True),
+                "task": task,
+                "result": slm_result.get("result"),
+                "explanation": slm_result.get("explanation"),
+                "suggestions": slm_result.get("suggestions", []),
+                "used_automata": len([s for s in pipeline_steps if s["step_type"] == "automata"]) > 0,
+                "used_slm": True,
+                "pipeline": pipeline_steps,
+                "total_duration_ms": duration_ms
+            }
+
+        except Exception as e:
+            logger.error(f"Error in orchestrator.process: {e}", exc_info=True)
+            duration_ms = (time.time() - start_time) * 1000
+
+            from app.utils.localization import get_string
+            error_message = get_string("backend_error_generic", error=str(e))
+
+            return {
+                "success": False,
+                "task": task,
+                "error": error_message,
+                "used_automata": False,
+                "used_slm": False,
+                "pipeline": pipeline_steps,
+                "total_duration_ms": duration_ms
+            }
+
+    async def _try_automata(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        trace: Optional[str],
+        pipeline_steps: List[Dict]
+    ) -> Dict[str, Any]:
+        """Try to handle task with automata only"""
+
+        # Map tasks to automata
+        automata_map = {
+            TaskType.FORMAT: ["python_formatter"] if language == Language.PYTHON else [],
+            TaskType.EXPLAIN: ["trace_parser"] if trace else [],
+            TaskType.FIX: ["runtime_fixer", "ast_fixer", "python_linter"] if language == Language.PYTHON else [],
+        }
+
+        automata_to_try = automata_map.get(task, [])
+
+        for automaton_name in automata_to_try:
+            if automaton_name not in self.automata:
+                continue
+
+            automaton = self.automata[automaton_name]
+            step_start = time.time()
+
+            try:
+                if automaton.can_handle(code, language, task):
+                    result = await automaton.execute(code, trace=trace)
+
+                    step_duration = (time.time() - step_start) * 1000
+                    pipeline_steps.append({
+                        "step_type": "automata",
+                        "component": automaton_name,
+                        "duration_ms": step_duration,
+                        "success": True,
+                        "details": {"automaton": automaton_name}
+                    })
+
+                    if result.get("success"):
+                        return result
+
+            except Exception as e:
+                logger.warning(f"Automaton {automaton_name} failed: {e}")
+                step_duration = (time.time() - step_start) * 1000
+                pipeline_steps.append({
+                    "step_type": "automata",
+                    "component": automaton_name,
+                    "duration_ms": step_duration,
+                    "success": False,
+                    "details": {"error": str(e)}
+                })
+
+        return {"success": False}
+
+    async def _use_slm(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str],
+        trace: Optional[str],
+        routing_decision: Dict,
+        pipeline_steps: List[Dict],
+        history: Optional[List[Dict[str, str]]] = None
+    ) -> Dict[str, Any]:
+        """Use SLM engine to process task"""
+
+        # Determine which engine to use
+        # If routed to micro_slm, use the handler_name as the engine name
+        if routing_decision.get("handler_type") == "micro_slm":
+            engine_name = routing_decision.get("handler_name")
+        else:
+            engine_name = routing_decision.get("engine", "groq")
+
+        # Enrich context with RAG examples
+        enriched_context = context or ""
+        if self.retriever and settings.enable_rag:
+            try:
+                rag_context = self.retriever.build_context(
+                    query_code=code,
+                    language=language,
+                    task=task,
+                    k=3  # Retrieve top 3 similar examples
+                )
+                if rag_context:
+                    enriched_context = f"{enriched_context}\n\n{rag_context}" if enriched_context else rag_context
+                    logger.debug("Enriched context with RAG examples")
+            except Exception as e:
+                logger.warning(f"Failed to enrich context with RAG: {e}")
+
+        step_start = time.time()
+
+        try:
+            engine = await self._get_engine(engine_name)
+
+            result = await engine.process(
+                task=task,
+                code=code,
+                language=language,
+                context=enriched_context,
+                trace=trace,
+                history=history
+            )
+
+            step_duration = (time.time() - step_start) * 1000
+            pipeline_steps.append({
+                "step_type": "slm",
+                "component": engine_name,
+                "duration_ms": step_duration,
+                "success": True,
+                "details": {"engine": engine_name}
+            })
+
+            # Log for distillation if using Teacher model (Groq)
+            if engine_name == "groq" and result.get("success"):
+                try:
+                    from app.core.distillation import distillation_logger
+                    await distillation_logger.log_interaction(
+                        task=task,
+                        language=language,
+                        code_input=code,
+                        context=enriched_context,
+                        output=result.get("result") or result.get("explanation", ""),
+                        model="groq-llama-3"
+                    )
+                except Exception as e:
+                    logger.warning(f"Failed to log distillation data: {e}")
+
+            return result
+
+        except Exception as e:
+            logger.error(f"SLM {engine_name} failed: {e}", exc_info=True)
+            step_duration = (time.time() - step_start) * 1000
+            pipeline_steps.append({
+                "step_type": "slm",
+                "component": engine_name,
+                "duration_ms": step_duration,
+                "success": False,
+                "details": {"error": str(e)}
+            })
+            raise
+
+    async def translate(
+        self,
+        code: str,
+        source_lang: Language,
+        target_lang: Language,
+        preserve_comments: bool = True
+    ) -> Dict[str, Any]:
+        """Translate code between languages"""
+        context = f"Translate from {source_lang} to {target_lang}"
+        if preserve_comments:
+            context += ". Preserve all comments."
+
+        return await self.process(
+            task=TaskType.TRANSLATE,
+            code=code,
+            language=source_lang,
+            context=context
+        )
+
+    async def generate_boilerplate(
+        self,
+        template_type: str,
+        language: Language,
+        name: str,
+        options: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Generate boilerplate code"""
+        context = f"Generate {template_type} boilerplate for {name}"
+        if options:
+            context += f" with options: {options}"
+
+        return await self.process(
+            task=TaskType.BOILERPLATE,
+            code="",  # Empty code for generation
+            language=language,
+            context=context
+        )
+
+    async def get_status(self) -> Dict[str, Any]:
+        """Get orchestrator status"""
+        return {
+            "ready": self.initialized,
+            "models_loaded": {
+                engine: True for engine in self.engines.keys()
+            },
+            "automata_available": list(self.automata.keys())
+        }
+    
+    def _should_decompose(self, task: TaskType) -> bool:
+        """Determine if a task should be decomposed into subtasks"""
+        # Decompose complex tasks
+        decomposable_tasks = [
+            TaskType.FIX,
+            TaskType.REFACTOR,
+            TaskType.FORMAT
+        ]
+        return task in decomposable_tasks
+    
+    async def _process_with_decomposition(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str],
+        trace: Optional[str],
+        history: Optional[List[Dict[str, str]]],
+        start_time: float,
+        pipeline_steps: List[Dict]
+    ) -> Dict[str, Any]:
+        """Process task using decomposition and micro-SLM routing"""
+        
+        logger.info("Using decomposition-based processing")
+        
+        # Step 1: Decompose task into subtasks
+        subtasks = await self.task_decomposer.decompose(
+            task=task,
+            code=code,
+            language=language,
+            context=context,
+            trace=trace
+        )
+        
+        logger.info(f"Decomposed into {len(subtasks)} subtasks")
+        
+        # Step 2: Process each subtask
+        results = []
+        current_code = code
+        
+        for i, subtask in enumerate(subtasks):
+            logger.info(f"Processing subtask {i+1}/{len(subtasks)}: {subtask.subtask_type}")
+            
+            # Route subtask to best handler
+            routing = await self.router_v2.route_subtask(
+                subtask_type=subtask.subtask_type,
+                code=current_code,
+                language=language,
+                context=subtask.context
+            )
+            
+            logger.info(f"Routed to: {routing['handler_type']} ({routing['handler_name']})")
+            
+            # Execute based on handler type
+            step_start = time.time()
+            
+            if routing['handler_type'] == 'automata':
+                # Use automaton
+                result = await self._execute_automaton(
+                    automaton_name=routing['handler_name'],
+                    code=current_code,
+                    trace=trace,
+                    pipeline_steps=pipeline_steps
+                )
+            
+            elif routing['handler_type'] == 'micro_slm':
+                # Use micro-SLM
+                logger.warning(f"Micro-SLM execution not yet fully implemented, falling back to Groq")
+                result = await self._execute_groq(
+                    task=task,
+                    code=current_code,
+                    language=language,
+                    context=subtask.context,
+                    trace=trace,
+                    history=history,
+                    pipeline_steps=pipeline_steps
+                )
+            
+            else:  # groq
+                # Use Groq
+                result = await self._execute_groq(
+                    task=task,
+                    code=current_code,
+                    language=language,
+                    context=subtask.context,
+                    trace=trace,
+                    history=history,
+                    pipeline_steps=pipeline_steps
+                )
+            
+            step_duration = (time.time() - step_start) * 1000
+            
+            # Record step
+            pipeline_steps.append({
+                "step_type": routing['handler_type'],
+                "component": routing['handler_name'],
+                "subtask": subtask.subtask_type,
+                "duration_ms": step_duration,
+                "success": result.get("success", False)
+            })
+            
+            # Update current_code for next subtask
+            if result.get("success") and result.get("result"):
+                current_code = result["result"]
+            
+            results.append(result)
+        
+        # Step 3: Combine results
+        duration_ms = (time.time() - start_time) * 1000
+        
+        # Get final result (last successful result)
+        final_result = current_code
+        
+        # Combine explanations
+        explanations = [r.get("explanation", "") for r in results if r.get("explanation")]
+        combined_explanation = "\n\n".join(explanations) if explanations else "Processed via decomposition"
+        
+        return {
+            "success": True,
+            "task": task,
+            "result": final_result,
+            "explanation": combined_explanation,
+            "suggestions": ["Code processed through micro-SLM mesh"],
+            "used_automata": any(s["step_type"] == "automata" for s in pipeline_steps),
+            "used_slm": any(s["step_type"] in ["micro_slm", "groq"] for s in pipeline_steps),
+            "pipeline": pipeline_steps,
+            "total_duration_ms": duration_ms,
+            "subtasks_processed": len(subtasks)
+        }
+    
+    async def _execute_automaton(
+        self,
+        automaton_name: str,
+        code: str,
+        trace: Optional[str],
+        pipeline_steps: List[Dict]
+    ) -> Dict[str, Any]:
+        """Execute an automaton"""
+        try:
+            automaton = self.automata.get(automaton_name)
+            if not automaton:
+                return {"success": False, "error": f"Automaton {automaton_name} not found"}
+            
+            result = await automaton.execute(code, trace=trace)
+            return result
+        
+        except Exception as e:
+            logger.error(f"Automaton execution failed: {e}")
+            return {"success": False, "error": str(e)}
+    
+    async def _execute_groq(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str],
+        trace: Optional[str],
+        history: Optional[List[Dict[str, str]]],
+        pipeline_steps: List[Dict]
+    ) -> Dict[str, Any]:
+        """Execute using Groq engine"""
+        try:
+            engine = await self._get_engine("groq")
+            
+            # Enrich context with RAG if available
+            enriched_context = context or ""
+            if self.retriever and settings.enable_rag:
+                try:
+                    rag_context = self.retriever.build_context(
+                        query_code=code,
+                        language=language,
+                        task=task,
+                        k=3
+                    )
+                    if rag_context:
+                        enriched_context = f"{enriched_context}\n\n{rag_context}" if enriched_context else rag_context
+                except Exception as e:
+                    logger.warning(f"RAG enrichment failed: {e}")
+            
+            result = await engine.process(
+                task=task,
+                code=code,
+                language=language,
+                context=enriched_context,
+                trace=trace,
+                history=history
+            )
+            
+            return result
+        
+        except Exception as e:
+            logger.error(f"Groq execution failed: {e}")
+            return {"success": False, "error": str(e)}
+
+
+    async def shutdown(self):
+        """Cleanup resources"""
+        logger.info("Shutting down orchestrator...")
+
+        for engine_name, engine in self.engines.items():
+            try:
+                await engine.shutdown()
+                logger.info(f"Engine {engine_name} shutdown complete")
+            except Exception as e:
+                logger.error(f"Error shutting down engine {engine_name}: {e}")
+
+        self.initialized = False
+        logger.info("Orchestrator shutdown complete")

backend/app/core/orchestrator_decomposition.py

@@ -0,0 +1,193 @@
+    def _should_decompose(self, task: TaskType) -> bool:
+        """Determine if a task should be decomposed into subtasks"""
+        # Decompose complex tasks
+        decomposable_tasks = [
+            TaskType.FIX,
+            TaskType.REFACTOR,
+            TaskType.FORMAT
+        ]
+        return task in decomposable_tasks
+    
+    async def _process_with_decomposition(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str],
+        trace: Optional[str],
+        history: Optional[List[Dict[str, str]]],
+        start_time: float,
+        pipeline_steps: List[Dict]
+    ) -> Dict[str, Any]:
+        """Process task using decomposition and micro-SLM routing"""
+        
+        logger.info("Using decomposition-based processing")
+        
+        # Step 1: Decompose task into subtasks
+        subtasks = await self.task_decomposer.decompose(
+            task=task,
+            code=code,
+            language=language,
+            context=context,
+            trace=trace
+        )
+        
+        logger.info(f"Decomposed into {len(subtasks)} subtasks")
+        
+        # Step 2: Process each subtask
+        results = []
+        current_code = code
+        
+        for i, subtask in enumerate(subtasks):
+            logger.info(f"Processing subtask {i+1}/{len(subtasks)}: {subtask.subtask_type}")
+            
+            # Route subtask to best handler
+            routing = await self.router_v2.route_subtask(
+                subtask_type=subtask.subtask_type,
+                code=current_code,
+                language=language,
+                context=subtask.context
+            )
+            
+            logger.info(f"Routed to: {routing['handler_type']} ({routing['handler_name']})")
+            
+            # Execute based on handler type
+            step_start = time.time()
+            
+            if routing['handler_type'] == 'automata':
+                # Use automaton
+                result = await self._execute_automaton(
+                    automaton_name=routing['handler_name'],
+                    code=current_code,
+                    trace=trace,
+                    pipeline_steps=pipeline_steps
+                )
+            
+            elif routing['handler_type'] == 'micro_slm':
+                # Use micro-SLM (placeholder for now)
+                logger.warning(f"Micro-SLM execution not yet implemented, falling back to Groq")
+                result = await self._execute_groq(
+                    task=task,
+                    code=current_code,
+                    language=language,
+                    context=subtask.context,
+                    trace=trace,
+                    history=history,
+                    pipeline_steps=pipeline_steps
+                )
+            
+            else:  # groq
+                # Use Groq
+                result = await self._execute_groq(
+                    task=task,
+                    code=current_code,
+                    language=language,
+                    context=subtask.context,
+                    trace=trace,
+                    history=history,
+                    pipeline_steps=pipeline_steps
+                )
+            
+            step_duration = (time.time() - step_start) * 1000
+            
+            # Record step
+            pipeline_steps.append({
+                "step_type": routing['handler_type'],
+                "component": routing['handler_name'],
+                "subtask": subtask.subtask_type,
+                "duration_ms": step_duration,
+                "success": result.get("success", False)
+            })
+            
+            # Update current_code for next subtask
+            if result.get("success") and result.get("result"):
+                current_code = result["result"]
+            
+            results.append(result)
+        
+        # Step 3: Combine results
+        duration_ms = (time.time() - start_time) * 1000
+        
+        # Get final result (last successful result)
+        final_result = current_code
+        
+        # Combine explanations
+        explanations = [r.get("explanation", "") for r in results if r.get("explanation")]
+        combined_explanation = "\n\n".join(explanations) if explanations else "Processed via decomposition"
+        
+        return {
+            "success": True,
+            "task": task,
+            "result": final_result,
+            "explanation": combined_explanation,
+            "suggestions": ["Code processed through micro-SLM mesh"],
+            "used_automata": any(s["step_type"] == "automata" for s in pipeline_steps),
+            "used_slm": any(s["step_type"] in ["micro_slm", "groq"] for s in pipeline_steps),
+            "pipeline": pipeline_steps,
+            "total_duration_ms": duration_ms,
+            "subtasks_processed": len(subtasks)
+        }
+    
+    async def _execute_automaton(
+        self,
+        automaton_name: str,
+        code: str,
+        trace: Optional[str],
+        pipeline_steps: List[Dict]
+    ) -> Dict[str, Any]:
+        """Execute an automaton"""
+        try:
+            automaton = self.automata.get(automaton_name)
+            if not automaton:
+                return {"success": False, "error": f"Automaton {automaton_name} not found"}
+            
+            result = await automaton.execute(code, trace=trace)
+            return result
+        
+        except Exception as e:
+            logger.error(f"Automaton execution failed: {e}")
+            return {"success": False, "error": str(e)}
+    
+    async def _execute_groq(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str],
+        trace: Optional[str],
+        history: Optional[List[Dict[str, str]]],
+        pipeline_steps: List[Dict]
+    ) -> Dict[str, Any]:
+        """Execute using Groq engine"""
+        try:
+            engine = await self._get_engine("groq")
+            
+            # Enrich context with RAG if available
+            enriched_context = context or ""
+            if self.retriever and settings.enable_rag:
+                try:
+                    rag_context = self.retriever.build_context(
+                        query_code=code,
+                        language=language,
+                        task=task,
+                        k=3
+                    )
+                    if rag_context:
+                        enriched_context = f"{enriched_context}\n\n{rag_context}" if enriched_context else rag_context
+                except Exception as e:
+                    logger.warning(f"RAG enrichment failed: {e}")
+            
+            result = await engine.process(
+                task=task,
+                code=code,
+                language=language,
+                context=enriched_context,
+                trace=trace,
+                history=history
+            )
+            
+            return result
+        
+        except Exception as e:
+            logger.error(f"Groq execution failed: {e}")
+            return {"success": False, "error": str(e)}

backend/app/core/pipeline.py

@@ -0,0 +1,42 @@
+"""
+Pipeline builder for multi-step task execution
+
+Future feature for V1.5: Chain multiple automata/SLMs
+V1: Simple pass-through
+"""
+import logging
+from typing import List, Dict, Any
+
+logger = logging.getLogger(__name__)
+
+
+class Pipeline:
+    """Builds and executes multi-step pipelines"""
+
+    def __init__(self):
+        logger.info("Pipeline builder initialized (simple mode for V1)")
+
+    async def build(
+        self,
+        task: str,
+        steps: List[str]
+    ) -> List[Dict[str, Any]]:
+        """
+        Build execution pipeline
+
+        V1: Returns simple single-step pipeline
+        V1.5+: Will support multi-step chaining
+        """
+        # For V1, we don't chain steps yet
+        # This is a placeholder for future functionality
+        return []
+
+    async def execute(
+        self,
+        pipeline: List[Dict[str, Any]],
+        input_data: str
+    ) -> Dict[str, Any]:
+        """Execute a pipeline"""
+        # V1: Not used yet
+        # V1.5+: Will execute multi-step pipelines
+        pass

backend/app/core/rag.py

@@ -0,0 +1,124 @@
+"""
+RAG Retriever
+
+Retrieval-Augmented Generation for code context.
+Retrieves relevant code examples and documentation to enhance SLM responses.
+"""
+import logging
+from typing import List, Dict, Any, Optional
+from pathlib import Path
+import json
+
+logger = logging.getLogger(__name__)
+
+
+class RAGRetriever:
+    """Retrieval-Augmented Generation retriever for code context"""
+    
+    def __init__(self, examples_dir: Optional[Path] = None):
+        self.examples_dir = examples_dir or Path("data/examples")
+        self.examples_cache: Dict[str, List[Dict]] = {}
+        logger.info(f"RAGRetriever initialized with examples_dir: {self.examples_dir}")
+    
+    def load_examples(self, language: str = "python") -> List[Dict[str, Any]]:
+        """Load code examples for a specific language"""
+        cache_key = language
+        
+        if cache_key in self.examples_cache:
+            return self.examples_cache[cache_key]
+        
+        examples = []
+        
+        # Look for example files
+        if self.examples_dir.exists():
+            for example_file in self.examples_dir.glob(f"{language}*.json"):
+                try:
+                    with open(example_file, 'r', encoding='utf-8') as f:
+                        file_examples = json.load(f)
+                        if isinstance(file_examples, list):
+                            examples.extend(file_examples)
+                        else:
+                            examples.append(file_examples)
+                except Exception as e:
+                    logger.warning(f"Failed to load examples from {example_file}: {e}")
+        
+        self.examples_cache[cache_key] = examples
+        logger.info(f"Loaded {len(examples)} examples for {language}")
+        
+        return examples
+    
+    async def retrieve_context(
+        self,
+        query: str,
+        language: str = "python",
+        task_type: Optional[str] = None,
+        max_results: int = 3
+    ) -> List[Dict[str, Any]]:
+        """
+        Retrieve relevant code examples based on query
+        
+        Args:
+            query: Search query (e.g., task description)
+            language: Programming language
+            task_type: Optional task type filter
+            max_results: Maximum number of results to return
+        
+        Returns:
+            List of relevant code examples
+        """
+        examples = self.load_examples(language)
+        
+        if not examples:
+            return []
+        
+        # Simple keyword-based retrieval
+        # In production, you'd use embeddings and vector search
+        query_lower = query.lower()
+        
+        scored_examples = []
+        for example in examples:
+            score = 0
+            
+            # Check task type match
+            if task_type and example.get('task') == task_type:
+                score += 10
+            
+            # Check description match
+            description = example.get('description', '').lower()
+            if any(word in description for word in query_lower.split()):
+                score += 5
+            
+            # Check code content match
+            code = example.get('code', '').lower()
+            if any(word in code for word in query_lower.split()):
+                score += 2
+            
+            if score > 0:
+                scored_examples.append((score, example))
+        
+        # Sort by score and return top results
+        scored_examples.sort(reverse=True, key=lambda x: x[0])
+        
+        results = [example for score, example in scored_examples[:max_results]]
+        
+        logger.debug(f"Retrieved {len(results)} examples for query: {query}")
+        
+        return results
+    
+    def format_context(self, examples: List[Dict[str, Any]]) -> str:
+        """Format retrieved examples as context string"""
+        if not examples:
+            return ""
+        
+        context_parts = ["Here are some relevant code examples:\n"]
+        
+        for i, example in enumerate(examples, 1):
+            context_parts.append(f"\nExample {i}:")
+            if 'description' in example:
+                context_parts.append(f"Description: {example['description']}")
+            if 'code' in example:
+                context_parts.append(f"```{example.get('language', 'python')}")
+                context_parts.append(example['code'])
+                context_parts.append("```")
+        
+        return "\n".join(context_parts)

backend/app/core/router.py

@@ -0,0 +1,100 @@
+"""
+Router for determining how to handle tasks
+
+Uses a combination of:
+- Rule-based routing (simple cases)
+- Embedding-based classification (complex cases)
+"""
+import logging
+from typing import Dict, Any, Optional
+
+from app.models.schemas import TaskType, Language
+
+logger = logging.getLogger(__name__)
+
+
+class Router:
+    """Routes tasks to appropriate engines or automata"""
+
+    def __init__(self):
+        self.initialized = False
+        self.embedding_model = None
+
+    async def initialize(self):
+        """Initialize router components"""
+        logger.info("Initializing router...")
+
+        # For V1, we use simple rule-based routing
+        # V1.5 will add embedding-based classification
+        self.initialized = True
+        logger.info("Router initialized (rule-based mode)")
+
+    async def route(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Determine how to handle the task
+
+        Returns:
+            Dict with routing decision:
+            - try_automata: bool
+            - engine: str (which SLM to use)
+            - confidence: float
+        """
+
+        # Check if Groq is configured
+        from app.config import settings
+        use_groq = bool(settings.groq_api_key)
+        default_engine = "groq" if use_groq else "phi2"
+
+        # Rule-based routing
+        routing = {
+            "try_automata": False,
+            "engine": default_engine,
+            "confidence": 0.8
+        }
+
+        # Simple rules
+        if task == TaskType.FORMAT:
+            # Formatting is best handled by automata
+            routing["try_automata"] = True
+            routing["confidence"] = 0.95
+
+        elif task == TaskType.FIX and language == Language.PYTHON:
+            # Try automata first for Python fixes
+            routing["try_automata"] = True
+            routing["engine"] = default_engine
+            routing["confidence"] = 0.7
+
+        elif task == TaskType.EXPLAIN:
+            # Explanation needs SLM
+            routing["try_automata"] = True
+            routing["engine"] = default_engine
+            routing["confidence"] = 0.85
+
+        elif task == TaskType.TRANSLATE:
+            # Translation needs SLM
+            routing["engine"] = default_engine
+            routing["confidence"] = 0.9
+
+        elif task in [TaskType.TEST, TaskType.BOILERPLATE]:
+            # Generation tasks need SLM
+            routing["engine"] = default_engine
+            routing["confidence"] = 0.8
+
+        elif task == TaskType.REFACTOR:
+            # Refactoring needs SLM
+            routing["engine"] = default_engine
+            routing["confidence"] = 0.75
+
+        logger.debug(f"Routing decision for {task}: {routing}")
+        return routing
+
+    def _calculate_confidence(self, task: TaskType, code: str) -> float:
+        """Calculate confidence in routing decision"""
+        # Placeholder for future embedding-based classification
+        return 0.8

backend/app/core/router_v2.py

@@ -0,0 +1,174 @@
+"""
+Router v2 - Intelligent Capability-Based Routing
+
+Routes subtasks to the most appropriate handler:
+1. Automata (fastest, deterministic)
+2. Micro-SLMs (fast, specialized)
+3. Groq (slow, general-purpose, teacher)
+"""
+import logging
+from typing import Dict, Any, Optional
+from app.models.schemas import TaskType, Language
+from app.core.slm_registry import slm_registry
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class RouterV2:
+    """Intelligent router for micro-SLM mesh"""
+    
+    def __init__(self):
+        self.min_micro_slm_accuracy = 0.85  # Minimum accuracy to use micro-SLM
+        self.automata_capabilities = {
+            # Map subtask types to automata names
+            "fix_syntax": "ast_fixer",
+            "format_code": "black",
+            "format_imports": "isort",
+        }
+    
+    async def route_subtask(
+        self,
+        subtask_type: str,
+        code: str,
+        language: Language,
+        context: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Route a subtask to the best handler
+        
+        Returns:
+            {
+                "handler_type": "automata" | "micro_slm" | "groq",
+                "handler_name": str,
+                "confidence": float
+            }
+        """
+        logger.debug(f"Routing subtask: {subtask_type}")
+        
+        # Step 1: Check if automata can handle it
+        automata_result = await self._try_automata(subtask_type, code, language)
+        if automata_result:
+            return automata_result
+        
+        # Step 2: Check if micro-SLM can handle it
+        micro_slm_result = await self._try_micro_slm(subtask_type, code, language)
+        if micro_slm_result:
+            return micro_slm_result
+        
+        # Step 3: Fall back to Groq
+        return {
+            "handler_type": "groq",
+            "handler_name": "groq",
+            "confidence": 1.0,  # Groq is always confident
+            "reason": "No specialized handler available"
+        }
+    
+    async def _try_automata(
+        self,
+        subtask_type: str,
+        code: str,
+        language: Language
+    ) -> Optional[Dict[str, Any]]:
+        """Check if an automaton can handle this subtask"""
+        
+        automaton_name = self.automata_capabilities.get(subtask_type)
+        
+        if not automaton_name:
+            return None
+        
+        logger.debug(f"Automaton '{automaton_name}' can handle '{subtask_type}'")
+        
+        return {
+            "handler_type": "automata",
+            "handler_name": automaton_name,
+            "confidence": 1.0,  # Automata are deterministic
+            "reason": f"Automaton '{automaton_name}' handles this pattern"
+        }
+    
+    async def _try_micro_slm(
+        self,
+        subtask_type: str,
+        code: str,
+        language: Language
+    ) -> Optional[Dict[str, Any]]:
+        """Check if a micro-SLM can handle this subtask"""
+        
+        # Query registry for micro-SLMs with this capability
+        best_micro_slm = slm_registry.get_best_for_capability(
+            capability=subtask_type,
+            min_accuracy=self.min_micro_slm_accuracy
+        )
+        
+        if not best_micro_slm:
+            logger.debug(f"No micro-SLM available for '{subtask_type}'")
+            return None
+        
+        logger.info(
+            f"Micro-SLM '{best_micro_slm.name}' selected for '{subtask_type}' "
+            f"(accuracy: {best_micro_slm.accuracy:.2f})"
+        )
+        
+        return {
+            "handler_type": "micro_slm",
+            "handler_name": best_micro_slm.name,
+            "confidence": best_micro_slm.accuracy,
+            "reason": f"Specialized micro-SLM (accuracy: {best_micro_slm.accuracy:.2f})"
+        }
+    
+    async def route_task(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Route a full task (backward compatibility with old Router)
+        
+        This is used when task is NOT decomposed
+        """
+        logger.info(f"RouterV2 checking for capability: {task.value}")
+        
+        # Step 1: Check for automata (fastest)
+        if task == TaskType.FORMAT and language == Language.PYTHON:
+            return {
+                "handler_type": "automata",
+                "handler_name": "black",
+                "confidence": 1.0,
+                "try_automata": True,
+                "engine": "black"
+            }
+        
+        # Step 2: Check for Micro-SLMs
+        micro_slm_info = slm_registry.get_best_for_capability(
+            capability=task.value,  # Use task.value to get string like "boilerplate"
+            min_accuracy=self.min_micro_slm_accuracy
+        )
+        
+        if micro_slm_info:
+            logger.info(
+                f"Micro-SLM '{micro_slm_info.name}' selected for '{task.value}' "
+                f"(accuracy: {micro_slm_info.accuracy:.2f})"
+            )
+            return {
+                "handler_type": "micro_slm",
+                "handler_name": micro_slm_info.name,
+                "confidence": micro_slm_info.accuracy,
+                "try_automata": False,
+                "engine": micro_slm_info.name  # Use Micro-SLM as engine
+            }
+        
+        # Step 3: Fall back to Groq
+        logger.info(f"No Micro-SLM found for '{task.value}', using Groq")
+        return {
+            "handler_type": "groq",
+            "handler_name": "groq",
+            "confidence": 1.0,
+            "try_automata": settings.enable_automata_first,
+            "engine": "groq"
+        }
+
+
+# Global instance
+router_v2 = RouterV2()

backend/app/core/slm_registry.py

@@ -0,0 +1,120 @@
+"""
+SLM Registry
+
+Manages the registration and discovery of specialized micro-SLMs.
+Acts as the central catalog for the "Mesh" architecture.
+"""
+import json
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass, asdict
+from datetime import datetime
+
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MicroSLMInfo:
+    """Metadata for a registered micro-SLM"""
+    name: str
+    model_path: str
+    base_model: str
+    capabilities: List[str]
+    accuracy: float
+    avg_latency_ms: float
+    size_mb: float
+    training_samples: int
+    last_updated: str
+    metadata: Dict[str, Any]
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+class SLMRegistry:
+    """
+    Registry for managing micro-SLMs.
+    Persists data to a JSON file.
+    """
+
+    def __init__(self):
+        self.registry_file = settings.data_dir / "slm_registry.json"
+        self.models: Dict[str, MicroSLMInfo] = {}
+        self._load_registry()
+
+    def _load_registry(self):
+        """Load registry from disk"""
+        if self.registry_file.exists():
+            try:
+                with open(self.registry_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    for name, info in data.items():
+                        self.models[name] = MicroSLMInfo(**info)
+                logger.info(f"Loaded {len(self.models)} micro-SLMs from registry")
+            except Exception as e:
+                logger.error(f"Failed to load SLM registry: {e}")
+                self.models = {}
+
+    def _save_registry(self):
+        """Save registry to disk"""
+        try:
+            data = {name: model.to_dict() for name, model in self.models.items()}
+            with open(self.registry_file, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+            logger.info("Saved SLM registry to disk")
+        except Exception as e:
+            logger.error(f"Failed to save SLM registry: {e}")
+
+    def register(self, info: MicroSLMInfo):
+        """Register or update a micro-SLM"""
+        self.models[info.name] = info
+        self._save_registry()
+        logger.info(f"Registered micro-SLM: {info.name}")
+
+    def get_model(self, name: str) -> Optional[MicroSLMInfo]:
+        """Get model info by name"""
+        return self.models.get(name)
+
+    def get_best_for_capability(self, capability: str, min_accuracy: float = 0.0) -> Optional[MicroSLMInfo]:
+        """
+        Find the best model for a specific capability (subtask).
+        Returns the model with the highest accuracy that meets the minimum requirement.
+        """
+        candidates = [
+            m for m in self.models.values()
+            if capability in m.capabilities and m.accuracy >= min_accuracy
+        ]
+
+        if not candidates:
+            return None
+
+        # Sort by accuracy (descending)
+        candidates.sort(key=lambda x: x.accuracy, reverse=True)
+        return candidates[0]
+
+    def get_all_models(self) -> List[MicroSLMInfo]:
+        """Get all registered models"""
+        return list(self.models.values())
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get registry statistics"""
+        capabilities = set()
+        total_size = 0.0
+        
+        for m in self.models.values():
+            capabilities.update(m.capabilities)
+            total_size += m.size_mb
+            
+        return {
+            "total_micro_slms": len(self.models),
+            "total_size_mb": round(total_size, 2),
+            "capabilities_covered": list(capabilities),
+            "last_updated": datetime.now().isoformat()
+        }
+
+
+# Global instance
+slm_registry = SLMRegistry()

backend/app/core/task_decomposer.py

@@ -0,0 +1,309 @@
+"""
+Task Decomposer
+
+Breaks down complex code tasks into atomic subtasks that can be handled
+by specialized micro-SLMs or automata.
+"""
+import logging
+from typing import List, Dict, Any, Optional
+from app.models.schemas import TaskType, Language
+
+logger = logging.getLogger(__name__)
+
+
+class Subtask:
+    """Represents an atomic subtask"""
+    
+    def __init__(
+        self,
+        subtask_type: str,
+        code: str,
+        priority: int = 1,
+        context: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ):
+        self.subtask_type = subtask_type
+        self.code = code
+        self.priority = priority
+        self.context = context
+        self.metadata = metadata or {}
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "subtask_type": self.subtask_type,
+            "code": self.code,
+            "priority": self.priority,
+            "context": self.context,
+            "metadata": self.metadata
+        }
+
+
+class TaskDecomposer:
+    """Decomposes complex tasks into atomic subtasks"""
+    
+    def __init__(self):
+        # Define decomposition rules
+        self.decomposition_rules = {
+            TaskType.FIX: self._decompose_fix,
+            TaskType.REFACTOR: self._decompose_refactor,
+            TaskType.TEST: self._decompose_test,
+            TaskType.BOILERPLATE: self._decompose_boilerplate,
+            TaskType.EXPLAIN: self._decompose_explain,
+            TaskType.FORMAT: self._decompose_format,
+            TaskType.TRANSLATE: self._decompose_translate,
+        }
+    
+    async def decompose(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str] = None,
+        trace: Optional[str] = None
+    ) -> List[Subtask]:
+        """
+        Decompose a task into subtasks
+        
+        Returns:
+            List of Subtask objects, ordered by priority
+        """
+        logger.info(f"Decomposing task: {task}")
+        
+        # Get decomposition function for this task type
+        decompose_fn = self.decomposition_rules.get(task)
+        
+        if not decompose_fn:
+            # No decomposition needed, return single subtask
+            return [Subtask(
+                subtask_type=task.value,
+                code=code,
+                priority=1,
+                context=context
+            )]
+        
+        # Decompose
+        subtasks = await decompose_fn(code, language, context, trace)
+        
+        # Sort by priority
+        subtasks.sort(key=lambda x: x.priority)
+        
+        logger.info(f"Decomposed into {len(subtasks)} subtasks")
+        return subtasks
+    
+    async def _decompose_fix(
+        self,
+        code: str,
+        language: Language,
+        context: Optional[str],
+        trace: Optional[str]
+    ) -> List[Subtask]:
+        """Decompose fix task"""
+        subtasks = []
+        
+        # Priority 1: Syntax errors (must fix first)
+        if self._has_syntax_errors(code, language):
+            subtasks.append(Subtask(
+                subtask_type="fix_syntax",
+                code=code,
+                priority=1,
+                context=trace
+            ))
+        
+        # Priority 2: Import errors
+        if self._has_import_errors(code, trace):
+            subtasks.append(Subtask(
+                subtask_type="fix_imports",
+                code=code,
+                priority=2,
+                context=trace
+            ))
+        
+        # Priority 3: Runtime errors
+        if trace and "Error" in trace:
+            subtasks.append(Subtask(
+                subtask_type="fix_runtime_error",
+                code=code,
+                priority=3,
+                context=trace
+            ))
+        
+        # If no specific errors detected, general fix
+        if not subtasks:
+            subtasks.append(Subtask(
+                subtask_type="fix_general",
+                code=code,
+                priority=1,
+                context=context
+            ))
+        
+        return subtasks
+    
+    async def _decompose_refactor(
+        self,
+        code: str,
+        language: Language,
+        context: Optional[str],
+        trace: Optional[str]
+    ) -> List[Subtask]:
+        """Decompose refactor task"""
+        subtasks = []
+        
+        # Check what kind of refactoring is needed
+        if context:
+            context_lower = context.lower()
+            
+            if "performance" in context_lower or "optimize" in context_lower:
+                subtasks.append(Subtask(
+                    subtask_type="optimize_performance",
+                    code=code,
+                    priority=1,
+                    context=context
+                ))
+            
+            if "readability" in context_lower or "clean" in context_lower:
+                subtasks.append(Subtask(
+                    subtask_type="improve_readability",
+                    code=code,
+                    priority=2,
+                    context=context
+                ))
+            
+            if "type" in context_lower or "hint" in context_lower:
+                subtasks.append(Subtask(
+                    subtask_type="add_type_hints",
+                    code=code,
+                    priority=3,
+                    context=context
+                ))
+        
+        # Default: general refactoring
+        if not subtasks:
+            subtasks.append(Subtask(
+                subtask_type="refactor_general",
+                code=code,
+                priority=1,
+                context=context
+            ))
+        
+        return subtasks
+    
+    async def _decompose_test(
+        self,
+        code: str,
+        language: Language,
+        context: Optional[str],
+        trace: Optional[str]
+    ) -> List[Subtask]:
+        """Decompose test generation task"""
+        return [Subtask(
+            subtask_type="generate_tests",
+            code=code,
+            priority=1,
+            context=context
+        )]
+    
+    async def _decompose_boilerplate(
+        self,
+        code: str,
+        language: Language,
+        context: Optional[str],
+        trace: Optional[str]
+    ) -> List[Subtask]:
+        """Decompose boilerplate generation"""
+        return [Subtask(
+            subtask_type="generate_boilerplate",
+            code=code,
+            priority=1,
+            context=context
+        )]
+    
+    async def _decompose_explain(
+        self,
+        code: str,
+        language: Language,
+        context: Optional[str],
+        trace: Optional[str]
+    ) -> List[Subtask]:
+        """Decompose explain task"""
+        return [Subtask(
+            subtask_type="explain_code",
+            code=code,
+            priority=1,
+            context=context
+        )]
+    
+    async def _decompose_format(
+        self,
+        code: str,
+        language: Language,
+        context: Optional[str],
+        trace: Optional[str]
+    ) -> List[Subtask]:
+        """Decompose format task"""
+        subtasks = []
+        
+        if language == Language.PYTHON:
+            # Python-specific formatting pipeline
+            subtasks.append(Subtask(
+                subtask_type="format_imports",
+                code=code,
+                priority=1
+            ))
+            subtasks.append(Subtask(
+                subtask_type="format_code",
+                code=code,
+                priority=2
+            ))
+        else:
+            subtasks.append(Subtask(
+                subtask_type="format_general",
+                code=code,
+                priority=1
+            ))
+        
+        return subtasks
+    
+    async def _decompose_translate(
+        self,
+        code: str,
+        language: Language,
+        context: Optional[str],
+        trace: Optional[str]
+    ) -> List[Subtask]:
+        """Decompose translation task"""
+        return [Subtask(
+            subtask_type="translate_code",
+            code=code,
+            priority=1,
+            context=context
+        )]
+    
+    # Helper methods for error detection
+    
+    def _has_syntax_errors(self, code: str, language: Language) -> bool:
+        """Check if code has syntax errors"""
+        if language == Language.PYTHON:
+            try:
+                compile(code, '<string>', 'exec')
+                return False
+            except SyntaxError:
+                return True
+        return False
+    
+    def _has_import_errors(self, code: str, trace: Optional[str]) -> bool:
+        """Check if there are import-related errors"""
+        if not trace:
+            return False
+        
+        import_error_indicators = [
+            "ImportError",
+            "ModuleNotFoundError",
+            "cannot import",
+            "No module named"
+        ]
+        
+        return any(indicator in trace for indicator in import_error_indicators)
+
+
+# Global instance
+task_decomposer = TaskDecomposer()

backend/app/engines/__init__.py

@@ -0,0 +1,10 @@
+"""SLM Engines package"""
+from app.engines.base import BaseEngine
+from app.engines.starcoder import StarCoderEngine
+from app.engines.codet5 import CodeT5Engine
+
+__all__ = [
+    "BaseEngine",
+    "StarCoderEngine",
+    "CodeT5Engine"
+]

backend/app/engines/base.py

@@ -0,0 +1,279 @@
+"""
+Base class for all SLM engines
+
+Engines are neural network-based components that use
+Small Language Models for code understanding and generation.
+"""
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+import logging
+
+from app.models.schemas import TaskType, Language
+
+logger = logging.getLogger(__name__)
+
+
+class BaseEngine(ABC):
+    """Base class for all SLM engines"""
+
+    def __init__(self, name: str, model_path: Optional[str] = None):
+        self.name = name
+        self.model_path = model_path
+        self.model = None
+        self.initialized = False
+        logger.info(f"Creating engine: {name}")
+
+    @abstractmethod
+    async def initialize(self):
+        """
+        Initialize the engine and load model
+
+        Should set self.initialized = True when done
+        """
+        pass
+
+    @abstractmethod
+    async def process(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str] = None,
+        trace: Optional[str] = None,
+        history: Optional[list] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Process a task using the SLM
+
+        Args:
+            task: Type of task
+            code: Source code
+            language: Programming language
+            context: Additional context
+            trace: Error trace
+            history: Conversation history for context
+            **kwargs: Additional parameters
+
+        Returns:
+            Dict with:
+            - success: bool
+            - result: str (generated/fixed code or explanation)
+            - explanation: Optional[str]
+            - suggestions: Optional[List[str]]
+        """
+        pass
+
+    @abstractmethod
+    async def shutdown(self):
+        """Cleanup and free resources"""
+        pass
+
+    def build_prompt(self, task: TaskType, code: str, context: Optional[str] = None) -> str:
+        """
+        Build prompt for SLM based on task type
+        
+        Args:
+            task: Type of task
+            code: Source code
+            context: Additional context
+            
+        Returns:
+            Formatted prompt string
+        """
+        if task == TaskType.FIX:
+            return self._build_fix_prompt(code, context)
+        elif task == TaskType.EXPLAIN:
+            return self._build_explain_prompt(code, context)
+        elif task == TaskType.REFACTOR:
+            return self._build_refactor_prompt(code, context)
+        elif task == TaskType.TEST:
+            return self._build_test_prompt(code, context)
+        elif task == TaskType.BOILERPLATE:
+            return self._build_boilerplate_prompt(context)
+        elif task == TaskType.TRANSLATE:
+            return self._build_translate_prompt(code, context)
+        else:
+            return f"Code:\n{code}\n\nTask: {task}"
+    
+    def get_stop_tokens(self, task: TaskType) -> list:
+        """
+        Get stop tokens to prevent over-generation
+        
+        Args:
+            task: Type of task
+            
+        Returns:
+            List of stop tokens
+        """
+        # Common stop tokens
+        common_stops = ["```", "\n\n\n", "# Example", "# Test"]
+        
+        # Task-specific stops
+        task_stops = {
+            TaskType.FIX: ["# Fixed code:", "# Original:"],
+            TaskType.BOILERPLATE: ["# Usage:", "# Example usage:"],
+            TaskType.TEST: ["# Run tests:"],
+            TaskType.EXPLAIN: ["# Code:", "# Summary:"],
+        }
+        
+        return common_stops + task_stops.get(task, [])
+
+    def _build_fix_prompt(self, code: str, context: Optional[str]) -> str:
+        """Build prompt for code fixing"""
+        prompt = """Fix the following Python code. Return ONLY the corrected code without explanation.
+
+Rules:
+- Fix syntax errors
+- Fix logic errors
+- Maintain original functionality
+- Keep the same structure
+- Do not add comments unless necessary
+
+"""
+        if context:
+            prompt += f"Additional context: {context}\n\n"
+        
+        prompt += f"Code to fix:\n```python\n{code}\n```\n\n"
+        prompt += "Fixed code:\n```python\n"
+        return prompt
+
+    def _build_explain_prompt(self, code: str, context: Optional[str]) -> str:
+        """Build prompt for explaining code"""
+        prompt = """Explain the following Python code in detail.
+
+Rules:
+- Provide a high-level summary.
+- Break down the code into logical sections and explain each.
+- Highlight key concepts and potential improvements.
+- Use clear and concise language.
+
+"""
+        if context:
+            prompt += f"Focus on: {context}\n\n"
+
+        prompt += f"Code to explain:\n```python\n{code}\n```\n\n"
+        prompt += "Explanation:\n"
+        return prompt
+
+    def _build_refactor_prompt(self, code: str, context: Optional[str]) -> str:
+        """Build prompt for refactoring code"""
+        prompt = """Refactor the following Python code to improve readability, maintainability, and performance. Return ONLY the refactored code without explanation.
+
+Rules:
+- Maintain original functionality.
+- Apply Python best practices and idioms.
+- Improve variable names, function structure, and overall design.
+- Do not add comments unless necessary.
+
+"""
+        if context:
+            prompt += f"Refactoring requirements: {context}\n\n"
+
+        prompt += f"Original code:\n```python\n{code}\n```\n\n"
+        prompt += "Refactored code:\n```python\n"
+        return prompt
+
+    def _build_test_prompt(self, code: str, context: Optional[str]) -> str:
+        """Build prompt for generating unit tests"""
+        prompt = """Generate comprehensive unit tests for the following Python code using `pytest`. Return ONLY the test code without explanation.
+
+Rules:
+- Cover normal cases, edge cases, and error cases.
+- Use descriptive test function names.
+- Include assertions for expected behavior.
+- Use `pytest.fixture` for setup if needed.
+
+"""
+        if context:
+            prompt += f"Test requirements: {context}\n\n"
+
+        prompt += f"Code to test:\n```python\n{code}\n```\n\n"
+        prompt += "Test code:\n```python\n"
+        return prompt
+
+    def _build_translate_prompt(self, code: str, context: Optional[str]) -> str:
+        """Build prompt for translating code"""
+        prompt = """Translate the following code. Return ONLY the translated code without explanation.
+
+"""
+        if context:
+            prompt += f"{context}\n\n"
+        
+        prompt += f"Code to translate:\n```\n{code}\n```\n\n"
+        prompt += "Translated code:\n```\n"
+        return prompt
+    
+    def _build_boilerplate_prompt(self, context: Optional[str]) -> str:
+        """Build prompt for boilerplate generation"""
+        prompt = """Generate clean, well-structured Python code based on the description below.
+
+Requirements:
+- Follow PEP 8 style guide
+- Include docstrings
+- Handle edge cases
+- Use type hints where appropriate
+- Keep it simple and readable
+
+"""
+        if context:
+            prompt += f"Description: {context}\n\n"
+        else:
+            prompt += "Description: Create a basic implementation\n\n"
+        
+        prompt += "Code:\n```python\n"
+        return prompt
+
+    def _default_prompt(
+        self,
+        code: str,
+        language: Language,
+        context: Optional[str],
+        trace: Optional[str]
+    ) -> str:
+        """Default prompt"""
+        return f"Process the following {language} code:\n\n```{language}\n{code}\n```"
+
+    def _format_result(
+        self,
+        success: bool,
+        result: Optional[str] = None,
+        explanation: Optional[str] = None,
+        suggestions: Optional[list] = None
+    ) -> Dict[str, Any]:
+        """Helper to format results consistently"""
+        return {
+            "success": success,
+            "result": result,
+            "explanation": explanation,
+            "suggestions": suggestions or []
+        }
+
+    def _extract_code_from_response(self, response: str) -> str:
+        """Extract code from model response (handles markdown code blocks)"""
+        import re
+
+        # Look for ```language\ncode\n``` pattern
+        pattern = r'```(?:\w+)?\n(.*?)\n?```'
+        matches = re.findall(pattern, response, re.DOTALL)
+
+        if matches:
+            # Return first code block
+            return matches[0].strip()
+
+        # If no code blocks, check if response looks like code already
+        # (happens when prompt ends with ``` and model just generates code)
+        lines = response.strip().split('\n')
+
+        # Skip empty lines at start/end
+        while lines and not lines[0].strip():
+            lines.pop(0)
+        while lines and not lines[-1].strip():
+            lines.pop()
+
+        # If we have content, return it
+        if lines:
+            return '\n'.join(lines)
+
+        # Empty response
+        return ""

backend/app/engines/codet5.py

@@ -0,0 +1,180 @@
+"""
+CodeT5 engine implementation
+
+Uses CodeT5-small for code explanation and translation.
+Loaded via HuggingFace transformers.
+"""
+import logging
+from typing import Dict, Any, Optional
+from pathlib import Path
+
+from app.engines.base import BaseEngine
+from app.models.schemas import TaskType, Language
+from app.config import settings
+from app.utils.localization import get_string
+
+logger = logging.getLogger(__name__)
+
+
+class CodeT5Engine(BaseEngine):
+    """CodeT5-small engine for explanations and translation"""
+
+    def __init__(self):
+        super().__init__(
+            name="codet5",
+            model_path=str(settings.codet5_path)
+        )
+        self.tokenizer = None
+        self.model_instance = None
+        self.torch = None
+
+    async def initialize(self):
+        """Load CodeT5 model"""
+        if self.initialized:
+            logger.info("CodeT5 already initialized")
+            return
+
+        logger.info(f"Loading CodeT5 from {self.model_path}")
+
+        try:
+            from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+            import torch
+            self.torch = torch
+
+            model_name = "Salesforce/codet5-small"
+            if Path(self.model_path).exists():
+                model_name = str(self.model_path)
+            else:
+                logger.warning(f"Local model not found at {self.model_path}, using default: {model_name}")
+
+            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+            self.model_instance = AutoModelForSeq2SeqLM.from_pretrained(model_name)
+            self.model_instance.eval()
+
+            if self.torch.cuda.is_available():
+                self.model_instance = self.model_instance.cuda()
+                logger.info("CodeT5 loaded on GPU")
+            else:
+                logger.info("CodeT5 loaded on CPU")
+
+            self.initialized = True
+            logger.info("CodeT5 loaded successfully")
+
+        except Exception as e:
+            logger.error(f"Failed to load CodeT5: {e}")
+            raise
+
+    async def process(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str] = None,
+        trace: Optional[str] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Process task with CodeT5"""
+        if not self.initialized:
+            await self.initialize()
+
+        try:
+            prompt = self._build_codet5_prompt(task, code, language, context, trace)
+            logger.info(f"CodeT5 processing {task} for {language}")
+            logger.debug(f"Prompt: {prompt[:200]}...")
+
+            inputs = self.tokenizer(prompt, return_tensors="pt", max_length=512, truncation=True)
+            if self.torch.cuda.is_available():
+                inputs = {k: v.cuda() for k, v in inputs.items()}
+
+            with self.torch.no_grad():
+                outputs = self.model_instance.generate(
+                    **inputs,
+                    max_length=settings.max_tokens,
+                    temperature=settings.temperature,
+                    num_beams=2,
+                    early_stopping=True
+                )
+            generated_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+            if task == TaskType.EXPLAIN:
+                return self._format_result(
+                    success=True,
+                    explanation=generated_text.strip(),
+                    suggestions=self._get_explanation_suggestions()
+                )
+            elif task == TaskType.TRANSLATE:
+                return self._format_result(
+                    success=True,
+                    result=generated_text.strip(),
+                    explanation=get_string("codet5_translate_explanation"),
+                    suggestions=[get_string("codet5_translate_suggestion")]
+                )
+            else:
+                return self._format_result(success=True, result=generated_text.strip())
+
+        except Exception as e:
+            logger.error(f"CodeT5 processing failed: {e}", exc_info=True)
+            return self._format_result(
+                success=False,
+                explanation=get_string("codet5_error", error=str(e))
+            )
+
+    def _build_codet5_prompt(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str],
+        trace: Optional[str]
+    ) -> str:
+        """Build an improved, task-specific prompt for CodeT5."""
+        
+        base_instruction = f"As an expert programmer, please perform the following task in {settings.language}."
+
+        if task == TaskType.EXPLAIN:
+            if trace:
+                instruction = (
+                    f"{base_instruction} Explain the root cause of the following error trace "
+                    f"in the context of the provided {language.value} code."
+                )
+                return f"{instruction}\n\nError Trace:\n{trace}\n\nCode:\n{code}"
+            else:
+                instruction = (
+                    f"{base_instruction} Provide a concise summary of the following "
+                    f"{language.value} code. Describe its purpose and functionality."
+                )
+                return f"{instruction}\n\nCode:\n{code}"
+
+        elif task == TaskType.TRANSLATE:
+            target_language = "the target language"
+            if context:
+                match = re.search(r"to (\w+)", context, re.IGNORECASE)
+                if match:
+                    target_language = match.group(1)
+            
+            instruction = f"Translate the following {language.value} code to {target_language}."
+            return f"{instruction}\n\n{code}"
+
+        else:
+            return f"Process the following {language.value} code:\n{code}"
+
+    def _get_explanation_suggestions(self) -> list:
+        """Get suggestions for explanation tasks using localized strings."""
+        return [
+            get_string("codet5_explanation_suggestion_1"),
+            get_string("codet5_explanation_suggestion_2")
+        ]
+
+    async def shutdown(self):
+        """Cleanup CodeT5"""
+        logger.info("Shutting down CodeT5 engine")
+        if self.model_instance:
+            del self.model_instance
+            self.model_instance = None
+        if self.tokenizer:
+            del self.tokenizer
+            self.tokenizer = None
+        if self.torch:
+            del self.torch
+            self.torch = None
+        self.initialized = False

backend/app/engines/groq_engine.py

@@ -0,0 +1,228 @@
+"""
+Groq API engine implementation
+
+Uses Groq's ultra-fast inference API with models like:
+- llama-3.1-70b-versatile (best quality)
+- llama-3.1-8b-instant (fastest)
+- mixtral-8x7b-32768 (good balance)
+"""
+import logging
+import os
+from typing import Dict, Any, Optional
+
+from app.engines.base import BaseEngine
+from app.models.schemas import TaskType, Language
+
+logger = logging.getLogger(__name__)
+
+
+class GroqEngine(BaseEngine):
+    """Groq API engine for code tasks"""
+
+    def __init__(self):
+        super().__init__(
+            name="groq",
+            model_path=None  # API-based, no local model
+        )
+        self.client = None
+        self.api_key = None
+        # Use environment variable for model or default to current stable model
+        self.model_name = os.getenv("GROQ_MODEL", "llama-3.3-70b-versatile")
+
+    async def initialize(self):
+        """Initialize Groq client"""
+        if self.initialized:
+            logger.info("Groq already initialized")
+            return
+
+        logger.info("Initializing Groq API client")
+
+        try:
+            # Get API key from settings
+            from app.config import settings
+            self.api_key = settings.groq_api_key
+            
+            if not self.api_key:
+                raise ValueError(
+                    "GROQ_API_KEY not found in configuration.\\n"
+                    "Please add it to your .env file:\\n"
+                    "GROQ_API_KEY=gsk_your_key_here"
+                )
+            
+            # Import Groq client
+            try:
+                from groq import Groq
+            except ImportError:
+                raise ImportError(
+                    "Groq package not installed.\\n"
+                    "Install with: pip install groq"
+                )
+            
+            self.client = Groq(api_key=self.api_key)
+            
+            self.initialized = True
+            logger.info(f"Groq initialized with model: {self.model_name}")
+
+        except Exception as e:
+            logger.error(f"Failed to initialize Groq: {e}")
+            raise
+
+    async def process(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str] = None,
+        trace: Optional[str] = None,
+        history: Optional[list] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Process task with Groq"""
+        if not self.initialized:
+            await self.initialize()
+
+        try:
+            # Build prompt
+            prompt = self._build_groq_prompt(task, code, language, context, trace)
+            
+            logger.info(f"Groq processing {task} for {language}")
+            logger.debug(f"Using model: {self.model_name}")
+
+            # Get language from settings
+            from app.config import settings
+            lang_instruction = ""
+            if settings.language == "fr":
+                lang_instruction = " Répondez toujours en français. Expliquez le code en français."
+            
+            # Add instruction for file creation
+            file_instruction = " If the user asks to create a file, specify the filename in your explanation using the format: [FILE: filename.ext]"
+
+            # Build message chain
+            messages = [
+                {
+                    "role": "system",
+                    "content": f"You are an expert programmer. Provide clear, concise, and correct code solutions.{lang_instruction}{file_instruction}"
+                }
+            ]
+            
+            # Add conversation history if provided
+            if history:
+                for msg in history:
+                    messages.append({
+                        "role": msg.get("role", "user"),
+                        "content": msg.get("content", "")
+                    })
+            
+            # Add current prompt as the last user message
+            messages.append({
+                "role": "user",
+                "content": prompt
+            })
+
+            # Call Groq API
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=messages,
+                temperature=0.3,  # Low for code accuracy
+                max_tokens=2048,
+                top_p=0.95
+            )
+
+            generated_text = response.choices[0].message.content.strip()
+            
+            logger.debug(f"Generated {len(generated_text)} chars")
+
+            # Extract code from response
+            if task in [TaskType.FIX, TaskType.REFACTOR, TaskType.TRANSLATE, TaskType.BOILERPLATE, TaskType.TEST]:
+                result_code = self._extract_code_from_response(generated_text)
+                
+                # If no code block found, use whole response
+                if not result_code:
+                    result_code = generated_text
+                
+                return self._format_result(
+                    success=True,
+                    result=result_code,
+                    explanation=f"Generated using Groq ({self.model_name})",
+                    suggestions=[
+                        "Review the generated code",
+                        "Test thoroughly before production use"
+                    ]
+                )
+            
+            elif task == TaskType.EXPLAIN:
+                return self._format_result(
+                    success=True,
+                    explanation=generated_text,
+                    suggestions=[
+                        "Review the explanation for accuracy"
+                    ]
+                )
+            
+            else:
+                return self._format_result(
+                    success=True,
+                    result=generated_text
+                )
+
+        except Exception as e:
+            logger.error(f"Groq processing failed: {e}", exc_info=True)
+            return self._format_result(
+                success=False,
+                explanation=f"Groq API error: {str(e)}"
+            )
+
+    def _build_groq_prompt(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str],
+        trace: Optional[str]
+    ) -> str:
+        """Build prompt for Groq"""
+        
+        if task == TaskType.BOILERPLATE:
+            prompt = f"Write {language.value} code that {context}.\\n\\n"
+            prompt += "Provide ONLY the code, no explanations.\\n\\n"
+            prompt += f"```{language.value}\\n"
+            return prompt
+        
+        elif task == TaskType.FIX:
+            prompt = f"Fix this {language.value} code:\\n\\n```{language.value}\\n{code}\\n```\\n\\n"
+            if trace:
+                prompt += f"Error:\\n```\\n{trace}\\n```\\n\\n"
+            prompt += "Provide the corrected code only.\\n\\n"
+            prompt += f"```{language.value}\\n"
+            return prompt
+        
+        elif task == TaskType.EXPLAIN:
+            prompt = f"Explain this {language.value} code:\\n\\n```{language.value}\\n{code}\\n```\\n\\n"
+            if context:
+                prompt += f"Focus on: {context}\\n\\n"
+            prompt += "Provide a clear explanation."
+            return prompt
+        
+        elif task == TaskType.REFACTOR:
+            prompt = f"Refactor this {language.value} code to improve it:\\n\\n```{language.value}\\n{code}\\n```\\n\\n"
+            if context:
+                prompt += f"Requirements: {context}\\n\\n"
+            prompt += "Provide the refactored code only.\\n\\n"
+            prompt += f"```{language.value}\\n"
+            return prompt
+        
+        elif task == TaskType.TEST:
+            prompt = f"Write comprehensive tests for this {language.value} code:\\n\\n```{language.value}\\n{code}\\n```\\n\\n"
+            prompt += f"Use pytest for Python or appropriate framework for {language.value}.\\n\\n"
+            prompt += f"```{language.value}\\n"
+            return prompt
+        
+        else:
+            prompt = f"Process this {language.value} code:\\n\\n```{language.value}\\n{code}\\n```"
+            return prompt
+
+    async def shutdown(self):
+        """Cleanup Groq"""
+        logger.info("Shutting down Groq engine")
+        self.client = None
+        self.initialized = False

backend/app/engines/micro_slm.py

@@ -0,0 +1,135 @@
+"""
+Micro-SLM Engine
+
+Generic engine for running specialized micro-SLMs (usually based on Phi-2 or similar).
+Loads models dynamically from the registry.
+"""
+import logging
+import torch
+from typing import Dict, Any, Optional, List
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from app.engines.base import BaseEngine
+from app.models.schemas import TaskType, Language
+
+logger = logging.getLogger(__name__)
+
+
+class MicroSLMEngine(BaseEngine):
+    """
+    Generic engine for Micro-SLMs.
+    Can load any HuggingFace model compatible with AutoModelForCausalLM.
+    """
+
+    def __init__(self, name: str, model_path: str):
+        super().__init__(name=name, model_path=model_path)
+        self.tokenizer = None
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        
+        # Support Hugging Face Hub models with 'hf://' prefix
+        # Example: hf://vienoux/boilerplate-slm
+        if model_path.startswith("hf://"):
+            self.hf_model_id = model_path[5:]  # Remove 'hf://' prefix
+            self.is_hf_model = True
+        else:
+            self.hf_model_id = model_path  # Use as-is for local paths
+            self.is_hf_model = False
+
+    async def initialize(self):
+        """Load the model and tokenizer"""
+        if self.initialized:
+            return
+
+        if self.is_hf_model:
+            logger.info(f"Loading Micro-SLM {self.name} from Hugging Face Hub: {self.hf_model_id} on {self.device}")
+        else:
+            logger.info(f"Loading Micro-SLM {self.name} from local path: {self.model_path} on {self.device}")
+        
+        try:
+            # Load from Hugging Face Hub or local path
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                self.hf_model_id,
+                trust_remote_code=True
+            )
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.hf_model_id,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                device_map="auto" if self.device == "cuda" else None,
+                trust_remote_code=True
+            )
+            
+            if self.device == "cpu":
+                self.model.to("cpu")
+                
+            self.initialized = True
+            logger.info(f"Micro-SLM {self.name} initialized successfully")
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize Micro-SLM {self.name}: {e}")
+            raise
+
+    async def process(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str] = None,
+        trace: Optional[str] = None,
+        history: Optional[list] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Process task using the micro-SLM"""
+        
+        if not self.initialized:
+            await self.initialize()
+
+        prompt = self.build_prompt(task, code, context)
+        
+        try:
+            inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
+            
+            # Generate
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_new_tokens=512,
+                    temperature=0.2,
+                    do_sample=True,
+                    pad_token_id=self.tokenizer.eos_token_id
+                )
+            
+            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            
+            # Extract just the new part (remove prompt)
+            generated_text = response[len(prompt):].strip()
+            
+            # Extract code block if present
+            result_code = self._extract_code_from_response(generated_text)
+            if not result_code:
+                result_code = generated_text  # Fallback to full text if no block found
+
+            return self._format_result(
+                success=True,
+                result=result_code,
+                explanation=f"Generated by {self.name}"
+            )
+
+        except Exception as e:
+            logger.error(f"Error in Micro-SLM {self.name}: {e}")
+            return self._format_result(
+                success=False,
+                explanation=f"Error: {str(e)}"
+            )
+
+    async def shutdown(self):
+        """Unload model to free memory"""
+        if self.model:
+            del self.model
+        if self.tokenizer:
+            del self.tokenizer
+        
+        if self.device == "cuda":
+            torch.cuda.empty_cache()
+            
+        self.initialized = False
+        logger.info(f"Micro-SLM {self.name} unloaded")

backend/app/engines/phi2.py

@@ -0,0 +1,191 @@
+"""
+Phi-2 engine implementation
+
+Uses Microsoft Phi-2 (quantized GGUF) for code generation, fixing, and refactoring.
+Loaded via llama-cpp-python.
+"""
+import logging
+import re
+from typing import Dict, Any, Optional
+from pathlib import Path
+
+from app.engines.base import BaseEngine
+from app.models.schemas import TaskType, Language
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class Phi2Engine(BaseEngine):
+    """Phi-2 engine for code tasks"""
+
+    def __init__(self):
+        # Use Phi-2 model path from settings
+        model_path = settings.models_dir / "phi-2-Q4_K_M.gguf"
+        super().__init__(
+            name="phi2",
+            model_path=str(model_path)
+        )
+        self.llm = None
+
+    async def initialize(self):
+        """Load Phi-2 model"""
+        if self.initialized:
+            logger.info("Phi-2 already initialized")
+            return
+
+        logger.info(f"Loading Phi-2 from {self.model_path}")
+
+        try:
+            if not Path(self.model_path).exists():
+                raise FileNotFoundError(
+                    f"Model file not found: {self.model_path}\n"
+                    f"Please run: python scripts/download_phi2.py"
+                )
+            
+            from llama_cpp import Llama
+            
+            self.llm = Llama(
+                model_path=self.model_path,
+                n_ctx=2048,  # Context window
+                n_threads=4,  # CPU threads
+                n_batch=512,
+                verbose=False
+            )
+            
+            self.initialized = True
+            logger.info("Phi-2 loaded successfully")
+
+        except Exception as e:
+            logger.error(f"Failed to load Phi-2: {e}")
+            raise
+
+    async def process(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str] = None,
+        trace: Optional[str] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Process task with Phi-2"""
+        if not self.initialized:
+            await self.initialize()
+
+        try:
+            # Build Phi-2-specific prompt (simple completion format)
+            prompt = self._build_phi2_prompt(task, code, context)
+            
+            logger.info(f"Phi-2 processing {task} for {language}")
+            logger.debug(f"Prompt: {prompt[:300]}...")
+
+            # Task-specific max tokens (increased for better output)
+            task_max_tokens = {
+                TaskType.FIX: 512,
+                TaskType.EXPLAIN: 512,
+                TaskType.REFACTOR: 1024,
+                TaskType.TEST: 1024,
+                TaskType.TRANSLATE: 1024,
+                TaskType.BOILERPLATE: 512  # Enough for simple functions
+            }
+            max_tokens = task_max_tokens.get(task, 512)
+
+            # Get stop tokens
+            stop_tokens = ["\n\n\n", "###", "Example:", "Note:"]
+
+            # Generate with Phi-2
+            response = self.llm(
+                prompt,
+                max_tokens=max_tokens,
+                temperature=0.7,  # Higher for more creative code
+                top_p=0.95,
+                top_k=50,
+                repeat_penalty=1.15,
+                stop=stop_tokens,
+                echo=False
+            )
+
+            generated_text = response["choices"][0]["text"].strip()
+            
+            logger.debug(f"Generated: {generated_text[:200]}...")
+
+            # Extract code from response
+            if task in [TaskType.FIX, TaskType.REFACTOR, TaskType.TRANSLATE, TaskType.BOILERPLATE, TaskType.TEST]:
+                result_code = self._extract_code_from_response(generated_text)
+                
+                # If extraction fails, use the whole response
+                if not result_code:
+                    result_code = generated_text
+                
+                return self._format_result(
+                    success=True,
+                    result=result_code,
+                    explanation=f"Generated using Phi-2",
+                    suggestions=[
+                        "Review the generated code for accuracy",
+                        "Test the code before using in production"
+                    ]
+                )
+            
+            elif task == TaskType.EXPLAIN:
+                return self._format_result(
+                    success=True,
+                    explanation=generated_text,
+                    suggestions=[
+                        "Review the explanation for accuracy",
+                        "Consider adding inline comments to your code for clarity"
+                    ]
+                )
+            
+            else:
+                return self._format_result(
+                    success=True,
+                    result=generated_text
+                )
+
+        except Exception as e:
+            logger.error(f"Phi-2 processing failed: {e}", exc_info=True)
+            return self._format_result(
+                success=False,
+                explanation=f"Error: {str(e)}"
+            )
+    
+    def _build_phi2_prompt(self, task: TaskType, code: str, context: Optional[str]) -> str:
+        """Build Phi-2-specific prompt (simple completion format)"""
+        
+        if task == TaskType.BOILERPLATE:
+            # For code generation
+            prompt = f"Write a Python function that {context}.\n\n"
+            prompt += "def "
+            return prompt
+        
+        elif task == TaskType.FIX:
+            prompt = "Fix this Python code:\n\n"
+            prompt += f"{code}\n\n"
+            prompt += "Fixed code:\n\n"
+            return prompt
+        
+        elif task == TaskType.EXPLAIN:
+            prompt = f"Explain this Python code:\n\n{code}\n\nExplanation: "
+            return prompt
+        
+        elif task == TaskType.REFACTOR:
+            prompt = f"Refactor this Python code to make it better:\n\n{code}\n\nRefactored code:\n\n"
+            return prompt
+        
+        elif task == TaskType.TEST:
+            prompt = f"Write pytest tests for this Python code:\n\n{code}\n\nimport pytest\n\n"
+            return prompt
+        
+        else:
+            prompt = f"Process this code:\n\n{code}\n\nResult:\n\n"
+            return prompt
+
+    async def shutdown(self):
+        """Cleanup Phi-2"""
+        logger.info("Shutting down Phi-2 engine")
+        if self.llm:
+            del self.llm
+            self.llm = None
+        self.initialized = False

backend/app/engines/starcoder.py

@@ -0,0 +1,212 @@
+"""
+StarCoder engine implementation
+
+Uses StarCoder2-3B (quantized) for code generation, fixing, and refactoring.
+Loaded via llama-cpp-python (GGUF format).
+"""
+import logging
+import re
+from typing import Dict, Any, Optional
+from pathlib import Path
+
+from app.engines.base import BaseEngine
+from app.models.schemas import TaskType, Language
+from app.config import settings
+from app.utils.localization import get_string
+
+logger = logging.getLogger(__name__)
+
+
+class StarCoderEngine(BaseEngine):
+    """StarCoder2-3B engine for code tasks"""
+
+    def __init__(self):
+        super().__init__(
+            name="starcoder",
+            model_path=str(settings.starcoder_path)
+        )
+        self.llm = None
+
+    async def initialize(self):
+        """Load StarCoder model"""
+        if self.initialized:
+            logger.info("StarCoder already initialized")
+            return
+
+        logger.info(f"Loading StarCoder from {self.model_path}")
+
+        try:
+            if not Path(self.model_path).exists():
+                raise FileNotFoundError(
+                    f"Model file not found: {self.model_path}\n"
+                    f"Please run: python scripts/download_models.py"
+                )
+            from llama_cpp import Llama
+            self.llm = Llama(
+                model_path=self.model_path,
+                n_ctx=settings.n_ctx,
+                n_threads=settings.n_threads,
+                n_batch=512,
+                verbose=False
+            )
+            self.initialized = True
+            logger.info("StarCoder loaded successfully")
+
+        except Exception as e:
+            logger.error(f"Failed to load StarCoder: {e}")
+            raise
+
+    async def process(
+        self,
+        task: TaskType,
+        code: str,
+        language: Language,
+        context: Optional[str] = None,
+        trace: Optional[str] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Process task with StarCoder"""
+        if not self.initialized:
+            await self.initialize()
+
+        try:
+            prompt = self._build_prompt(task, code, language, context, trace)
+            logger.info(f"StarCoder processing {task} for {language}")
+            logger.debug(f"Prompt: {prompt[:300]}...")
+
+            task_max_tokens = {
+                TaskType.FIX: 512,
+                TaskType.EXPLAIN: 512,
+                TaskType.REFACTOR: 1024,
+                TaskType.TEST: 1024,
+                TaskType.TRANSLATE: 1024,
+                TaskType.BOILERPLATE: 2048
+            }
+            max_tokens = task_max_tokens.get(task, 512)
+
+            response = self.llm(
+                prompt,
+                max_tokens=max_tokens,
+                temperature=0.1,
+                top_p=0.9,
+                top_k=20,
+                repeat_penalty=1.2,
+                stop=["\n```\n", "```\n\n", "\nExample", "\nNow fix", "\nBuggy code", "Exercise"],
+                echo=False
+            )
+
+            generated_text = response["choices"][0]["text"]
+
+            if task in [TaskType.FIX, TaskType.REFACTOR, TaskType.TRANSLATE, TaskType.BOILERPLATE]:
+                result_code = self._extract_code_from_response(generated_text, language)
+                explanation = self._extract_explanation(generated_text)
+                return self._format_result(
+                    success=True,
+                    result=result_code or code, # Return original code if extraction fails
+                    explanation=explanation,
+                    suggestions=self._generate_suggestions(task)
+                )
+            elif task == TaskType.EXPLAIN:
+                return self._format_result(
+                    success=True,
+                    result=None,
+                    explanation=generated_text.strip(),
+                    suggestions=[]
+                )
+            elif task == TaskType.TEST:
+                test_code = self._extract_code_from_response(generated_text, language)
+                return self._format_result(
+                    success=True,
+                    result=test_code,
+                    explanation=get_string("starcoder_test_explanation"),
+                    suggestions=self._generate_suggestions(task)
+                )
+            else:
+                return self._format_result(
+                    success=True,
+                    result=generated_text.strip()
+                )
+        except Exception as e:
+            logger.error(f"StarCoder processing failed: {e}", exc_info=True)
+            return self._format_result(
+                success=False,
+                explanation=get_string("starcoder_error", error=str(e))
+            )
+
+    def _build_prompt(self, task: TaskType, code: str, language: Language, context: Optional[str], trace: Optional[str]) -> str:
+        """Builds a task-specific, improved prompt."""
+        
+        system_prompt_content = (
+            "You are an expert programmer and a helpful coding assistant. "
+            "Provide a clear and concise response. "
+            f"The user's preferred language for explanations is {settings.language}."
+        )
+
+        system_block = f"<|system|>\n{system_prompt_content}\n<|end|>".replace('\n', '\n')
+
+        task_instructions = {
+            TaskType.FIX: (
+                "The following code has an error. Analyze the code and the error trace, then provide a corrected version. "
+                "Explain the fix in a comment or before the code block."
+            ),
+            TaskType.EXPLAIN: "Explain the following code. Describe its purpose, how it works, and any key algorithms or patterns used.",
+            TaskType.REFACTOR: "Refactor the following code to improve its readability, performance, or maintainability. Explain the changes made.",
+            TaskType.TEST: (f"Generate a comprehensive suite of unit tests for the following {language.value} code "
+                            "using a standard testing framework (e.g., pytest for Python, Jest for JavaScript)."),
+            TaskType.TRANSLATE: f"Translate the following code snippet from its current language to {language.value}. Preserve logic and comments.",
+            TaskType.BOILERPLATE: f"Generate boilerplate code for a {context} in {language.value}."
+        }
+        
+        instruction = task_instructions.get(task, "Process the following code:")
+
+        prompt_parts = []
+        prompt_parts.append(system_block)
+        prompt_parts.append(f"<|user|>\n{instruction}")
+
+        if context:
+            prompt_parts.append(f"\nHere is some additional context and examples:\n```\n{context}\n```")
+
+        if trace:
+            prompt_parts.append(f"\nHere is the error trace:\n```\n{trace}\n```")
+
+        prompt_parts.append(f"\nHere is the code:\n```{{language.value}}\n{code}\n```")
+        prompt_parts.append(f"\n<|assistant|>\n")
+
+        return "\n".join(prompt_parts)
+
+    def _extract_code_from_response(self, text: str, language: Language) -> Optional[str]:
+        """Extracts the first code block from the model's response."""
+        pattern = re.compile(r"```(?:" + re.escape(language.value) + r")?\s*\n(.*?)\n```", re.DOTALL)
+        match = pattern.search(text)
+        if match:
+            return match.group(1).strip()
+        
+        if text.strip() and "```" not in text:
+            return text.strip()
+            
+        return None
+
+    def _extract_explanation(self, text: str) -> Optional[str]:
+        """Extract explanation from response (text before the first code block)."""
+        parts = re.split(r"```.*", text, 1)
+        if parts and parts[0].strip():
+            return parts[0].strip()
+        return None
+
+    def _generate_suggestions(self, task: TaskType) -> list:
+        """Generate task-specific suggestions using localized strings."""
+        suggestion_keys = {
+            TaskType.FIX: ["starcoder_suggestion_fix_1", "starcoder_suggestion_fix_2"],
+            TaskType.REFACTOR: ["starcoder_suggestion_refactor_1", "starcoder_suggestion_refactor_2"],
+            TaskType.TRANSLATE: ["starcoder_suggestion_translate_1", "starcoder_suggestion_translate_2"],
+            TaskType.BOILERPLATE: ["starcoder_suggestion_boilerplate_1", "starcoder_suggestion_boilerplate_2"],
+            TaskType.TEST: ["starcoder_suggestion_test_1", "starcoder_suggestion_test_2"]
+        }
+        return [get_string(key) for key in suggestion_keys.get(task, [])]
+
+    async def shutdown(self):
+        """Cleanup StarCoder"""
+        logger.info("Shutting down StarCoder engine")
+        if self.llm:
+            self.llm = None
+        self.initialized = False

backend/app/locales/en.json

@@ -0,0 +1,124 @@
+{
+  "cli_ready": "Ready! Start chatting or type /help for commands",
+  "cli_help_title": "SLM Code Engine - Interactive CLI",
+  "cli_help_commands_title": "Available Commands:",
+  "cli_help_command_help": "/help          - Show this help message",
+  "cli_help_command_status": "/status        - Show the status of the backend and loaded models",
+  "cli_help_command_history": "/history       - Show the command history",
+  "cli_help_command_save": "/save          - (After a good response) Save the last interaction to improve the model",
+  "cli_help_command_exit": "/exit          - Exit the interactive CLI",
+  "cli_help_examples_title": "Examples:",
+  "cli_help_example_fix": "fix this code:\n<code>",
+  "cli_help_example_explain": "explain this error:\n<traceback>",
+  "backend_error_generic": "An unexpected error occurred: {error}",
+  "automaton_applied_fix": "Automaton '{automaton_name}' applied a fix.",
+  "slm_applied_fix": "SLM '{engine_name}' applied a fix.",
+  "explanation_generated": "Explanation generated by '{component_name}'.",
+  "ast_fixer_no_errors": "No syntax errors detected by AST scan.",
+  "ast_fixer_fixed_issues": "Fixed {issue_count} issue(s): {issues}",
+  "ast_fixer_suggestion_linter": "Consider using a linter to prevent future errors.",
+  "ast_fixer_failed_autofix": "Found syntax issues but could not auto-fix them.",
+  "ast_fixer_suggestion_slm": "Complex errors require SLM analysis.",
+  "ast_fixer_syntax_error": "Syntax error detected but could not auto-fix: {error}",
+  "ast_fixer_analysis_error": "An error occurred during AST analysis: {error}",
+  "ast_fixer_added_colon": "Added missing colon after {keyword} statement on line {line_number}",
+  "ast_fixer_fixed_indentation": "Fixed indentation on line {line_number}",
+  "ast_fixer_added_paren": "Added missing closing parenthesis on line {line_number}",
+  "cmd_help_title": "SLM Code Engine - Available Commands",
+  "cmd_help_col_command": "Command",
+  "cmd_help_col_description": "Description",
+  "cmd_help_desc_help": "Show this help message",
+  "cmd_help_desc_exit": "Exit the SLM Code Engine",
+  "cmd_help_desc_clear": "Clear conversation history",
+  "cmd_help_desc_history": "Show last N messages (default: all)",
+  "cmd_help_desc_status": "Check backend status and loaded models",
+  "cmd_help_desc_file": "Set current working file",
+  "cmd_help_desc_lang": "Set current language (python, javascript, etc.)",
+  "cmd_help_desc_save": "Save current session",
+  "cmd_help_desc_load": "Load a previous session",
+  "cmd_help_desc_read": "Read and display a file",
+  "cmd_help_desc_write": "Write content to a file",
+  "cmd_read_usage": "Usage: /read <path>",
+  "cmd_read_not_found": "File not found: {path}",
+  "cmd_read_error": "Error reading file: {error}",
+  "cmd_write_usage": "Usage: /write <path> [content]",
+  "cmd_write_success": "✓ File written: {path}",
+  "cmd_write_error": "Error writing file: {error}",
+  "cmd_write_no_content": "No content provided and no previous result to save.",
+  "cmd_help_tips_title": "💡 Usage Tips:",
+  "cmd_help_tip_1": "• Type naturally: 'fix this code', 'explain this error', etc.",
+  "cmd_help_tip_2": "• Paste code directly - the assistant will understand the context",
+  "cmd_help_tip_3": "• Use /file to set a working file for context",
+  "cmd_help_tip_4": "• Conversation history is maintained automatically",
+  "cmd_unknown": "Unknown command: /{cmd}",
+  "cmd_unknown_suggestion": "Type /help for available commands",
+  "cmd_exit_message": "Goodbye! 👋",
+  "cmd_clear_success": "✓ Conversation history cleared",
+  "cmd_history_empty": "No conversation history yet",
+  "cmd_history_title": "📜 Conversation History ({count} messages)",
+  "cmd_status_error": "Error checking status: {error}",
+  "cmd_status_title": "🚀 Backend Status",
+  "cmd_file_current": "Current file: {file}",
+  "cmd_file_none": "No file set",
+  "cmd_file_usage": "Usage: /file <path>",
+  "cmd_file_not_found": "File not found: {path}",
+  "cmd_file_success": "✓ Current file set to: {path}",
+  "cmd_lang_current": "Current language: {lang}",
+  "cmd_lang_usage": "Usage: /lang <python|javascript|typescript|bash|rust|go|auto>",
+  "cmd_lang_invalid": "Invalid language: {lang}",
+  "cmd_lang_valid": "Valid options: {options}",
+  "cmd_lang_success": "✓ Language set to: {lang}",
+  "cmd_save_success": "✓ Session saved: {path}",
+  "cmd_save_error": "Error saving session: {error}",
+  "cmd_load_usage": "Usage: /load <session_file>",
+  "cmd_load_success": "✓ Session loaded: {path}",
+  "cmd_load_success_details": "Messages: {count}",
+  "cmd_load_error": "Error loading session: {error}",
+  "repl_banner_title": "SLM Code Engine - Interactive CLI",
+  "repl_banner_subtitle": "Local AI-powered code assistant (100% local)",
+  "repl_banner_help_hint": "Type /help for available commands or just chat naturally",
+  "repl_backend_check": "Checking backend connection...",
+  "repl_backend_conn_error_title": "Connection Error",
+  "repl_backend_conn_error_message": "❌ Cannot connect to SLM backend",
+  "repl_backend_conn_error_expected": "Expected backend at: {url}",
+  "repl_backend_conn_error_start_prompt": "Please start the backend:",
+  "repl_backend_conn_success": "✓ Connected to backend (v{version})",
+  "repl_backend_models_loaded": "Models loaded: {models}",
+  "repl_error_panel_title": "❌ Error",
+  "repl_result_panel_title": "✅ {task} Result",
+  "repl_explanation_panel_title": "💡 Explanation",
+  "repl_suggestions_title": "💡 Suggestions:",
+  "repl_performance_info": "⚡ {duration:.2f}s using {used_info}",
+  "repl_processing": "🤔 Processing...",
+  "repl_connection_lost": "❌ Lost connection to backend",
+  "repl_api_error": "❌ API error: {status_code}",
+  "repl_generic_error": "❌ Error: {error}",
+  "repl_ready": "Ready! Start chatting or type /help for commands",
+  "repl_prompt": "You",
+  "repl_interrupt_exit_hint": "Use /exit to quit",
+  "repl_interrupt_goodbye": "Interrupted. Goodbye! 👋",
+  "repl_session_saved": "Session saved",
+  "repl_autowrite_confirm": "🤖 Assistant wants to create file: {file}",
+  "repl_autowrite_prompt": "Do you want to create this file?",
+  "cmd_feedback_saved": "✓ Feedback saved. Thank you for helping the assistant improve!",
+  "cmd_feedback_no_last_interaction": "There is no previous interaction to save.",
+  "cmd_feedback_error": "Error saving feedback: {error}",
+  "cmd_help_desc_session_save": "Save the current chat session to a file",
+  "starcoder_test_explanation": "Generated unit tests.",
+  "starcoder_suggestion_test_1": "Review and adjust test cases as needed.",
+  "starcoder_suggestion_test_2": "Add more edge cases if necessary.",
+  "starcoder_suggestion_fix_1": "Review the fix to ensure it addresses the root cause.",
+  "starcoder_suggestion_fix_2": "Add tests to prevent regression.",
+  "starcoder_suggestion_refactor_1": "Consider adding documentation.",
+  "starcoder_suggestion_refactor_2": "Review performance implications.",
+  "starcoder_suggestion_translate_1": "Verify behavior matches original code.",
+  "starcoder_suggestion_translate_2": "Check for language-specific idioms.",
+  "starcoder_suggestion_boilerplate_1": "Customize the generated code for your needs.",
+  "starcoder_suggestion_boilerplate_2": "Add error handling as appropriate.",
+  "starcoder_error": "Processing error: {error}",
+  "codet5_explanation_suggestion_1": "Review the explanation for accuracy.",
+  "codet5_explanation_suggestion_2": "Consider adding inline comments to your code for clarity.",
+  "codet5_translate_explanation": "Translated code to target language.",
+  "codet5_translate_suggestion": "Verify the translation maintains original behavior and syntax.",
+  "codet5_error": "Processing error: {error}"
+}

backend/app/locales/fr.json

@@ -0,0 +1,124 @@
+{
+  "cli_ready": "Prêt ! Discutez ou tapez /help pour voir les commandes",
+  "cli_help_title": "SLM Code Engine - CLI Interactif",
+  "cli_help_commands_title": "Commandes Disponibles :",
+  "cli_help_command_help": "/help          - Affiche ce message d'aide",
+  "cli_help_command_status": "/status        - Affiche le statut du backend et des modèles chargés",
+  "cli_help_command_history": "/history       - Affiche l'historique des commandes",
+  "cli_help_command_save": "/save          - (Après une bonne réponse) Sauvegarde la dernière interaction pour améliorer le modèle",
+  "cli_help_command_exit": "/exit          - Quitte le CLI interactif",
+  "cli_help_examples_title": "Exemples :",
+  "cli_help_example_fix": "corrige ce code :\n<code>",
+  "cli_help_example_explain": "explique cette erreur :\n<traceback>",
+  "backend_error_generic": "Une erreur inattendue est survenue : {error}",
+  "automaton_applied_fix": "L'automate '{automaton_name}' a appliqué une correction.",
+  "slm_applied_fix": "Le SLM '{engine_name}' a appliqué une correction.",
+  "explanation_generated": "Explication générée par '{component_name}'.",
+  "ast_fixer_no_errors": "Aucune erreur de syntaxe détectée par l'analyse AST.",
+  "ast_fixer_fixed_issues": "{issue_count} problème(s) corrigé(s) : {issues}",
+  "ast_fixer_suggestion_linter": "Envisagez d'utiliser un linter pour prévenir de futures erreurs.",
+  "ast_fixer_failed_autofix": "Des problèmes de syntaxe ont été trouvés mais n'ont pas pu être corrigés automatiquement.",
+  "ast_fixer_suggestion_slm": "Les erreurs complexes nécessitent une analyse par le SLM.",
+  "ast_fixer_syntax_error": "Erreur de syntaxe détectée mais non corrigible automatiquement : {error}",
+  "ast_fixer_analysis_error": "Une erreur est survenue lors de l'analyse AST : {error}",
+  "ast_fixer_added_colon": "Deux-points manquant ajouté après l'instruction {keyword} à la ligne {line_number}",
+  "ast_fixer_fixed_indentation": "Indentation corrigée à la ligne {line_number}",
+  "ast_fixer_added_paren": "Parenthèse fermante manquante ajoutée à la ligne {line_number}",
+  "cmd_help_title": "SLM Code Engine - Commandes Disponibles",
+  "cmd_help_col_command": "Commande",
+  "cmd_help_col_description": "Description",
+  "cmd_help_desc_help": "Affiche ce message d'aide",
+  "cmd_help_desc_exit": "Quitte le SLM Code Engine",
+  "cmd_help_desc_clear": "Efface l'historique de la conversation",
+  "cmd_help_desc_history": "Affiche les N derniers messages (défaut : tous)",
+  "cmd_help_desc_status": "Vérifie le statut du backend et les modèles chargés",
+  "cmd_help_desc_file": "Définit le fichier de travail actuel",
+  "cmd_help_desc_lang": "Définit la langue actuelle (python, javascript, etc.)",
+  "cmd_help_desc_save": "Sauvegarde la session actuelle",
+  "cmd_help_desc_load": "Charge une session précédente",
+  "cmd_help_desc_read": "Lit et affiche un fichier",
+  "cmd_help_desc_write": "Écrit du contenu dans un fichier",
+  "cmd_read_usage": "Usage : /read <chemin>",
+  "cmd_read_not_found": "Fichier non trouvé : {path}",
+  "cmd_read_error": "Erreur de lecture du fichier : {error}",
+  "cmd_write_usage": "Usage : /write <chemin> [contenu]",
+  "cmd_write_success": "✓ Fichier écrit : {path}",
+  "cmd_write_error": "Erreur d'écriture du fichier : {error}",
+  "cmd_write_no_content": "Aucun contenu fourni et aucun résultat précédent à sauvegarder.",
+  "cmd_help_tips_title": "💡 Astuces d'Utilisation :",
+  "cmd_help_tip_1": "• Tapez naturellement : 'corrige ce code', 'explique cette erreur', etc.",
+  "cmd_help_tip_2": "• Collez du code directement - l'assistant comprendra le contexte",
+  "cmd_help_tip_3": "• Utilisez /file pour définir un fichier de travail pour le contexte",
+  "cmd_help_tip_4": "• L'historique de la conversation est conservé automatiquement",
+  "cmd_unknown": "Commande inconnue : /{cmd}",
+  "cmd_unknown_suggestion": "Tapez /help pour voir les commandes disponibles",
+  "cmd_exit_message": "Au revoir ! 👋",
+  "cmd_clear_success": "✓ Historique de la conversation effacé",
+  "cmd_history_empty": "Pas encore d'historique de conversation",
+  "cmd_history_title": "📜 Historique de la Conversation ({count} messages)",
+  "cmd_status_error": "Erreur lors de la vérification du statut : {error}",
+  "cmd_status_title": "🚀 Statut du Backend",
+  "cmd_file_current": "Fichier actuel : {file}",
+  "cmd_file_none": "Aucun fichier défini",
+  "cmd_file_usage": "Usage : /file <chemin>",
+  "cmd_file_not_found": "Fichier non trouvé : {path}",
+  "cmd_file_success": "✓ Fichier de travail défini : {path}",
+  "cmd_lang_current": "Langue actuelle : {lang}",
+  "cmd_lang_usage": "Usage : /lang <python|javascript|typescript|bash|rust|go|auto>",
+  "cmd_lang_invalid": "Langue invalide : {lang}",
+  "cmd_lang_valid": "Options valides : {options}",
+  "cmd_lang_success": "✓ Langue définie : {lang}",
+  "cmd_save_success": "✓ Session sauvegardée : {path}",
+  "cmd_save_error": "Erreur lors de la sauvegarde de la session : {error}",
+  "cmd_load_usage": "Usage : /load <fichier_session>",
+  "cmd_load_success": "✓ Session chargée : {path}",
+  "cmd_load_success_details": "Messages : {count}",
+  "cmd_load_error": "Erreur lors du chargement de la session : {error}",
+  "repl_banner_title": "SLM Code Engine - CLI Interactif",
+  "repl_banner_subtitle": "Assistant de code IA (100% local)",
+  "repl_banner_help_hint": "Tapez /help pour les commandes ou discutez normalement",
+  "repl_backend_check": "Vérification de la connexion au backend...",
+  "repl_backend_conn_error_title": "Erreur de Connexion",
+  "repl_backend_conn_error_message": "❌ Connexion impossible au backend SLM",
+  "repl_backend_conn_error_expected": "Backend attendu à : {url}",
+  "repl_backend_conn_error_start_prompt": "Veuillez démarrer le backend :",
+  "repl_backend_conn_success": "✓ Connecté au backend (v{version})",
+  "repl_backend_models_loaded": "Modèles chargés : {models}",
+  "repl_error_panel_title": "❌ Erreur",
+  "repl_result_panel_title": "✅ Résultat de {task}",
+  "repl_explanation_panel_title": "💡 Explication",
+  "repl_suggestions_title": "💡 Suggestions :",
+  "repl_performance_info": "⚡ {duration:.2f}s en utilisant {used_info}",
+  "repl_processing": "🤔 Traitement en cours...",
+  "repl_connection_lost": "❌ Connexion au backend perdue",
+  "repl_api_error": "❌ Erreur API : {status_code}",
+  "repl_generic_error": "❌ Erreur : {error}",
+  "repl_ready": "Prêt ! Discutez ou tapez /help pour voir les commandes",
+  "repl_prompt": "Vous",
+  "repl_interrupt_exit_hint": "Utilisez /exit pour quitter",
+  "repl_interrupt_goodbye": "Interrompu. Au revoir ! 👋",
+  "repl_session_saved": "Session sauvegardée",
+  "repl_autowrite_confirm": "🤖 L'assistant veut créer le fichier : {file}",
+  "repl_autowrite_prompt": "Voulez-vous créer ce fichier ?",
+  "cmd_feedback_saved": "✓ Feedback sauvegardé. Merci d'aider l'assistant à s'améliorer !",
+  "cmd_feedback_no_last_interaction": "Il n'y a pas d'interaction précédente à sauvegarder.",
+  "cmd_feedback_error": "Erreur lors de la sauvegarde du feedback : {error}",
+  "cmd_help_desc_session_save": "Sauvegarde la session de chat actuelle dans un fichier",
+  "starcoder_test_explanation": "Tests unitaires générés.",
+  "starcoder_suggestion_test_1": "Révisez et ajustez les cas de test si nécessaire.",
+  "starcoder_suggestion_test_2": "Ajoutez plus de cas limites si nécessaire.",
+  "starcoder_suggestion_fix_1": "Vérifiez que la correction résout la cause première du problème.",
+  "starcoder_suggestion_fix_2": "Ajoutez des tests pour prévenir les régressions.",
+  "starcoder_suggestion_refactor_1": "Envisagez d'ajouter de la documentation.",
+  "starcoder_suggestion_refactor_2": "Examinez les implications sur la performance.",
+  "starcoder_suggestion_translate_1": "Vérifiez que le comportement correspond au code original.",
+  "starcoder_suggestion_translate_2": "Vérifiez les idiomes spécifiques au langage.",
+  "starcoder_suggestion_boilerplate_1": "Personnalisez le code généré pour vos besoins.",
+  "starcoder_suggestion_boilerplate_2": "Ajoutez la gestion des erreurs de manière appropriée.",
+  "starcoder_error": "Erreur de traitement : {error}",
+  "codet5_explanation_suggestion_1": "Vérifiez l'exactitude de l'explication.",
+  "codet5_explanation_suggestion_2": "Envisagez d'ajouter des commentaires en ligne à votre code pour plus de clarté.",
+  "codet5_translate_explanation": "Code traduit dans la langue cible.",
+  "codet5_translate_suggestion": "Vérifiez que la traduction conserve le comportement et la syntaxe d'origine.",
+  "codet5_error": "Erreur de traitement : {error}"
+}

backend/app/main.py

@@ -0,0 +1,265 @@
+"""
+FastAPI main application for SLM Code Engine
+"""
+import logging
+from contextlib import asynccontextmanager
+from typing import Dict
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+
+from app.config import settings
+from app.models.schemas import (
+    QueryRequest,
+    QueryResponse,
+    HealthResponse,
+    TranslateRequest,
+    BoilerplateRequest,
+    FeedbackRequest,
+    FeedbackResponse,
+)
+from app.core.orchestrator import Orchestrator
+from app import __version__
+
+# Configure logging
+logging.basicConfig(
+    level=getattr(logging, settings.log_level),
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+# Global orchestrator instance
+orchestrator: Orchestrator = None
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Lifecycle manager for the application"""
+    global orchestrator
+
+    logger.info("Starting SLM Code Engine...")
+
+    try:
+        # Initialize orchestrator
+        orchestrator = Orchestrator()
+        await orchestrator.initialize()
+        logger.info("Orchestrator initialized successfully")
+
+        yield
+
+    except Exception as e:
+        logger.error(f"Failed to initialize: {e}")
+        raise
+
+    finally:
+        # Cleanup
+        logger.info("Shutting down SLM Code Engine...")
+        if orchestrator:
+            await orchestrator.shutdown()
+
+
+# Create FastAPI app
+app = FastAPI(
+    title="SLM Code Engine",
+    description="Local AI-powered code assistant using Small Language Models",
+    version=__version__,
+    lifespan=lifespan
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure appropriately for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/", response_model=Dict[str, str])
+async def root():
+    """Root endpoint"""
+    return {
+        "name": "SLM Code Engine",
+        "version": __version__,
+        "status": "running",
+        "docs": "/docs"
+    }
+
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint"""
+    if not orchestrator:
+        raise HTTPException(status_code=503, detail="Orchestrator not initialized")
+
+    status = await orchestrator.get_status()
+
+    return HealthResponse(
+        status="healthy" if status["ready"] else "initializing",
+        version=__version__,
+        models_loaded=status.get("models_loaded", {}),
+        automata_available=status.get("automata_available", [])
+    )
+
+
+@app.post("/api/v1/query", response_model=QueryResponse)
+async def process_query(request: QueryRequest):
+    """
+    Main endpoint for code processing
+
+    Supports:
+    - fix: Fix code errors
+    - explain: Explain code or errors
+    - refactor: Refactor code
+    - test: Generate unit tests
+    - translate: Translate code between languages
+    - format: Format code
+    - boilerplate: Generate boilerplate code
+    """
+    if not orchestrator:
+        raise HTTPException(status_code=503, detail="Orchestrator not initialized")
+
+    try:
+        logger.info(f"Processing {request.task} request for {request.language}")
+
+        result = await orchestrator.process(
+            task=request.task,
+            code=request.code,
+            language=request.language,
+            context=request.context,
+            trace=request.trace
+        )
+
+        return QueryResponse(**result)
+
+    except Exception as e:
+        logger.error(f"Error processing query: {e}", exc_info=True)
+        return QueryResponse(
+            success=False,
+            task=request.task,
+            error=str(e),
+            used_automata=False,
+            used_slm=False,
+            pipeline=[],
+            total_duration_ms=0
+        )
+
+
+@app.post("/api/v1/translate", response_model=QueryResponse)
+async def translate_code(request: TranslateRequest):
+    """Translate code between programming languages"""
+    if not orchestrator:
+        raise HTTPException(status_code=503, detail="Orchestrator not initialized")
+
+    try:
+        result = await orchestrator.translate(
+            code=request.code,
+            source_lang=request.source_language,
+            target_lang=request.target_language,
+            preserve_comments=request.preserve_comments
+        )
+
+        return QueryResponse(**result)
+
+    except Exception as e:
+        logger.error(f"Error translating code: {e}", exc_info=True)
+        return QueryResponse(
+            success=False,
+            task="translate",
+            error=str(e),
+            used_automata=False,
+            used_slm=False,
+            pipeline=[],
+            total_duration_ms=0
+        )
+
+
+@app.post("/api/v1/boilerplate", response_model=QueryResponse)
+async def generate_boilerplate(request: BoilerplateRequest):
+    """Generate boilerplate code"""
+    if not orchestrator:
+        raise HTTPException(status_code=503, detail="Orchestrator not initialized")
+
+    try:
+        result = await orchestrator.generate_boilerplate(
+            template_type=request.template_type,
+            language=request.language,
+            name=request.name,
+            options=request.options
+        )
+
+        return QueryResponse(**result)
+
+    except Exception as e:
+        logger.error(f"Error generating boilerplate: {e}", exc_info=True)
+        return QueryResponse(
+            success=False,
+            task="boilerplate",
+            error=str(e),
+            used_automata=False,
+            used_slm=False,
+            pipeline=[],
+            total_duration_ms=0
+        )
+
+
+from app.storage.feedback import FeedbackLogger
+
+
+@app.post("/api/v1/feedback", response_model=FeedbackResponse)
+async def log_feedback(request: FeedbackRequest):
+    """
+    Endpoint to log positive user feedback on an interaction.
+    This feedback is used to improve the model over time.
+    """
+    try:
+        feedback_logger = FeedbackLogger()
+        entry_created = feedback_logger.log_feedback(
+            task=request.task.value,
+            language=request.language.value,
+            request_code=request.request_code,
+            response_code=request.response_code,
+            response_explanation=request.response_explanation
+        )
+        
+        if entry_created:
+            message = "Feedback logged successfully. Thank you!"
+        else:
+            message = "This feedback was already recorded."
+
+        return FeedbackResponse(
+            success=True,
+            message=message,
+            entry_created=entry_created
+        )
+
+    except Exception as e:
+        logger.error(f"Error logging feedback: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Failed to log feedback: {str(e)}")
+
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request, exc):
+    """Global exception handler"""
+    logger.error(f"Unhandled exception: {exc}", exc_info=True)
+    return JSONResponse(
+        status_code=500,
+        content={
+            "error": "Internal server error",
+            "detail": str(exc) if settings.debug else "An error occurred"
+        }
+    )
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(
+        "app.main:app",
+        host=settings.api_host,
+        port=settings.api_port,
+        reload=settings.debug,
+        workers=settings.api_workers
+    )

backend/app/models/__init__.py

@@ -0,0 +1 @@
+"""Models package"""

backend/app/models/schemas.py

@@ -0,0 +1,154 @@
+"""
+Pydantic models for API requests and responses
+"""
+from enum import Enum
+from typing import Optional, Dict, Any, List
+from pydantic import BaseModel, Field
+
+
+class TaskType(str, Enum):
+    """Supported task types"""
+    FIX = "fix"
+    EXPLAIN = "explain"
+    REFACTOR = "refactor"
+    TEST = "test"
+    TRANSLATE = "translate"
+    FORMAT = "format"
+    BOILERPLATE = "boilerplate"
+
+
+class Language(str, Enum):
+    """Supported programming languages"""
+    PYTHON = "python"
+    JAVASCRIPT = "javascript"
+    TYPESCRIPT = "typescript"
+    BASH = "bash"
+    RUST = "rust"
+    GO = "go"
+    AUTO = "auto"  # Auto-detect
+
+
+class QueryRequest(BaseModel):
+    """Request for code processing"""
+    task: TaskType = Field(..., description="Type of task to perform")
+    code: str = Field(..., description="Source code to process")
+    language: Language = Field(default=Language.AUTO, description="Programming language")
+    context: Optional[str] = Field(default=None, description="Additional context or instructions")
+    trace: Optional[str] = Field(default=None, description="Error trace (for fix/explain tasks)")
+    history: Optional[List[Dict[str, str]]] = Field(default=None, description="Conversation history for context")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "task": "fix",
+                "code": "def hello)\n  print('hello')",
+                "language": "python",
+                "context": "Fix syntax errors"
+            }
+        }
+
+
+class ExecutionStep(BaseModel):
+    """Single step in the execution pipeline"""
+    step_type: str = Field(..., description="Type of step (automata/slm)")
+    component: str = Field(..., description="Component used (e.g., 'black', 'starcoder')")
+    duration_ms: float = Field(..., description="Execution duration in milliseconds")
+    success: bool = Field(..., description="Whether step succeeded")
+    details: Optional[Dict[str, Any]] = Field(default=None, description="Additional details")
+
+
+class QueryResponse(BaseModel):
+    """Response from code processing"""
+    success: bool = Field(..., description="Whether request succeeded")
+    task: TaskType = Field(..., description="Task type executed")
+
+    # Results
+    result: Optional[str] = Field(default=None, description="Processed code or explanation")
+    explanation: Optional[str] = Field(default=None, description="Human-readable explanation")
+    suggestions: Optional[List[str]] = Field(default=None, description="Additional suggestions")
+
+    # Metadata
+    used_automata: bool = Field(..., description="Whether automata were used")
+    used_slm: bool = Field(..., description="Whether SLM was used")
+    pipeline: List[ExecutionStep] = Field(default_factory=list, description="Execution pipeline steps")
+
+    # Performance
+    total_duration_ms: float = Field(..., description="Total execution time")
+
+    # Error handling
+    error: Optional[str] = Field(default=None, description="Error message if failed")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "success": True,
+                "task": "fix",
+                "result": "def hello():\n    print('hello')",
+                "explanation": "Fixed: Missing ':' after function definition and incorrect indentation",
+                "suggestions": ["Consider adding type hints", "Add docstring"],
+                "used_automata": False,
+                "used_slm": True,
+                "pipeline": [
+                    {
+                        "step_type": "slm",
+                        "component": "starcoder",
+                        "duration_ms": 1234.5,
+                        "success": True
+                    }
+                ],
+                "total_duration_ms": 1250.0,
+                "error": None
+            }
+        }
+
+
+class HealthResponse(BaseModel):
+    """Health check response"""
+    status: str = Field(..., description="Service status")
+    version: str = Field(..., description="API version")
+    models_loaded: Dict[str, bool] = Field(..., description="Model loading status")
+    automata_available: List[str] = Field(..., description="Available automata")
+
+
+class TranslateRequest(BaseModel):
+    """Request for code translation"""
+    code: str = Field(..., description="Source code to translate")
+    source_language: Language = Field(..., description="Source language")
+    target_language: Language = Field(..., description="Target language")
+    preserve_comments: bool = Field(default=True, description="Preserve code comments")
+
+
+class BoilerplateRequest(BaseModel):
+    """Request for boilerplate generation"""
+    template_type: str = Field(..., description="Type of boilerplate (cli, api, class, etc.)")
+    language: Language = Field(..., description="Programming language")
+    name: str = Field(..., description="Name for the component")
+    options: Optional[Dict[str, Any]] = Field(default=None, description="Additional options")
+
+
+class FeedbackRequest(BaseModel):
+    """Request to log a successful interaction for feedback"""
+    task: TaskType = Field(..., description="The task that was performed")
+    language: Language = Field(..., description="The programming language")
+    request_code: str = Field(..., description="The original user code or query")
+    response_code: Optional[str] = Field(default=None, description="The successful code response from the AI")
+    response_explanation: Optional[str] = Field(default=None, description="The successful explanation from the AI")
+    session_id: Optional[str] = Field(default=None, description="The session ID for context")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "task": "fix",
+                "language": "python",
+                "request_code": "def hello)",
+                "response_code": "def hello():",
+                "response_explanation": "Added missing parentheses."
+            }
+        }
+
+
+class FeedbackResponse(BaseModel):
+    """Response from logging feedback"""
+    success: bool = Field(..., description="Whether the feedback was logged successfully")
+    message: str = Field(..., description="A confirmation message")
+    entry_created: bool = Field(..., description="Whether a new feedback entry was created (vs. being a duplicate)")

backend/app/rag/__init__.py

@@ -0,0 +1,10 @@
+"""
+RAG (Retrieval Augmented Generation) module
+
+Provides code example retrieval using FAISS vector similarity search
+"""
+from .embedder import CodeEmbedder
+from .vector_store import VectorStore
+from .retriever import CodeRetriever
+
+__all__ = ["CodeEmbedder", "VectorStore", "CodeRetriever"]

backend/app/rag/embedder.py

@@ -0,0 +1,95 @@
+"""
+Code embedder using sentence-transformers
+
+Converts code snippets into vector embeddings for similarity search
+"""
+import logging
+from typing import List, Optional
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+class CodeEmbedder:
+    """Generates embeddings for code using sentence-transformers"""
+
+    def __init__(self, model_name: str = "microsoft/codebert-base"):
+        """
+        Initialize the code embedder
+
+        Args:
+            model_name: HuggingFace model for code embeddings
+                       Default: microsoft/codebert-base (125M params, fast)
+        """
+        self.model_name = model_name
+        self.model: Optional[object] = None
+
+    def initialize(self):
+        """Load the embedding model (lazy loading)"""
+        if self.model is not None:
+            return
+
+        try:
+            from sentence_transformers import SentenceTransformer
+
+            logger.info(f"Loading embedding model: {self.model_name}")
+            self.model = SentenceTransformer(self.model_name)
+            logger.info("Embedding model loaded successfully")
+
+        except Exception as e:
+            logger.error(f"Failed to load embedding model: {e}")
+            raise
+
+    def embed(self, code: str) -> np.ndarray:
+        """
+        Generate embedding for a single code snippet
+
+        Args:
+            code: Source code string
+
+        Returns:
+            Embedding vector as numpy array
+        """
+        if self.model is None:
+            self.initialize()
+
+        try:
+            # Truncate very long code (max 512 tokens for CodeBERT)
+            if len(code) > 2000:
+                code = code[:2000]
+
+            embedding = self.model.encode(code, convert_to_numpy=True)
+            return embedding
+
+        except Exception as e:
+            logger.error(f"Failed to generate embedding: {e}")
+            raise
+
+    def embed_batch(self, codes: List[str]) -> np.ndarray:
+        """
+        Generate embeddings for multiple code snippets
+
+        Args:
+            codes: List of source code strings
+
+        Returns:
+            Matrix of embeddings (n_samples x embedding_dim)
+        """
+        if self.model is None:
+            self.initialize()
+
+        try:
+            # Truncate long codes
+            truncated_codes = [c[:2000] if len(c) > 2000 else c for c in codes]
+
+            embeddings = self.model.encode(
+                truncated_codes,
+                convert_to_numpy=True,
+                show_progress_bar=True
+            )
+
+            return embeddings
+
+        except Exception as e:
+            logger.error(f"Failed to generate batch embeddings: {e}")
+            raise

backend/app/rag/retriever.py

@@ -0,0 +1,215 @@
+"""
+Code retriever - High-level interface for RAG
+
+Combines embedding and vector search to retrieve similar code examples
+"""
+import logging
+from typing import List, Dict, Any, Optional
+from pathlib import Path
+
+from .embedder import CodeEmbedder
+from .vector_store import VectorStore
+from app.models.schemas import Language, TaskType
+
+logger = logging.getLogger(__name__)
+
+
+class CodeRetriever:
+    """High-level interface for code example retrieval"""
+
+    def __init__(
+        self,
+        embedder: Optional[CodeEmbedder] = None,
+        vector_store: Optional[VectorStore] = None,
+        index_path: Optional[str] = None
+    ):
+        """
+        Initialize code retriever
+
+        Args:
+            embedder: CodeEmbedder instance (creates default if None)
+            vector_store: VectorStore instance (creates default if None)
+            index_path: Path to FAISS index file
+        """
+        self.embedder = embedder or CodeEmbedder()
+        self.vector_store = vector_store or VectorStore(
+            embedding_dim=768,  # CodeBERT dimension
+            index_path=index_path
+        )
+        self.initialized = False
+
+    def initialize(self):
+        """Initialize embedder and vector store"""
+        if self.initialized:
+            return
+
+        try:
+            logger.info("Initializing CodeRetriever...")
+
+            # Initialize embedder
+            self.embedder.initialize()
+
+            # Initialize vector store
+            self.vector_store.initialize()
+
+            self.initialized = True
+            logger.info("CodeRetriever initialized successfully")
+
+        except Exception as e:
+            logger.error(f"Failed to initialize CodeRetriever: {e}")
+            raise
+
+    def add_examples(
+        self,
+        codes: List[str],
+        languages: List[Language],
+        tasks: List[TaskType],
+        descriptions: Optional[List[str]] = None
+    ):
+        """
+        Add code examples to the index
+
+        Args:
+            codes: List of code snippets
+            languages: List of programming languages
+            tasks: List of task types
+            descriptions: Optional list of descriptions
+        """
+        if not self.initialized:
+            self.initialize()
+
+        try:
+            logger.info(f"Adding {len(codes)} code examples to index")
+
+            # Generate embeddings
+            embeddings = self.embedder.embed_batch(codes)
+
+            # Prepare metadata
+            metadata = []
+            for i, (code, lang, task) in enumerate(zip(codes, languages, tasks)):
+                meta = {
+                    "code": code,
+                    "language": lang.value if hasattr(lang, 'value') else str(lang),
+                    "task": task.value if hasattr(task, 'value') else str(task),
+                    "description": descriptions[i] if descriptions and i < len(descriptions) else None
+                }
+                metadata.append(meta)
+
+            # Add to vector store
+            self.vector_store.add(embeddings, metadata)
+
+            logger.info(f"Successfully added {len(codes)} examples")
+
+        except Exception as e:
+            logger.error(f"Failed to add examples: {e}")
+            raise
+
+    def retrieve(
+        self,
+        query_code: str,
+        language: Optional[Language] = None,
+        task: Optional[TaskType] = None,
+        k: int = 3
+    ) -> List[Dict[str, Any]]:
+        """
+        Retrieve similar code examples
+
+        Args:
+            query_code: Code snippet to find similar examples for
+            language: Filter by programming language (optional)
+            task: Filter by task type (optional)
+            k: Number of examples to retrieve
+
+        Returns:
+            List of similar code examples with metadata
+        """
+        if not self.initialized:
+            self.initialize()
+
+        try:
+            logger.debug(f"Retrieving {k} similar examples for query")
+
+            # Generate query embedding
+            query_embedding = self.embedder.embed(query_code)
+
+            # Search vector store (get more results for filtering)
+            search_k = k * 3 if (language or task) else k
+            results = self.vector_store.search(query_embedding, k=search_k)
+
+            # Filter by language/task if specified
+            filtered_results = []
+            for distance, metadata in results:
+                # Apply filters
+                if language and metadata.get("language") != (
+                    language.value if hasattr(language, 'value') else str(language)
+                ):
+                    continue
+
+                if task and metadata.get("task") != (
+                    task.value if hasattr(task, 'value') else str(task)
+                ):
+                    continue
+
+                filtered_results.append({
+                    "code": metadata.get("code"),
+                    "language": metadata.get("language"),
+                    "task": metadata.get("task"),
+                    "description": metadata.get("description"),
+                    "similarity_score": 1.0 / (1.0 + distance)  # Convert distance to similarity
+                })
+
+                if len(filtered_results) >= k:
+                    break
+
+            logger.info(f"Retrieved {len(filtered_results)} similar examples")
+            return filtered_results
+
+        except Exception as e:
+            logger.error(f"Failed to retrieve examples: {e}")
+            return []
+
+    def save(self):
+        """Save the vector store index"""
+        if self.initialized:
+            self.vector_store.save()
+
+    def clear(self):
+        """Clear all indexed examples"""
+        if self.initialized:
+            self.vector_store.clear()
+
+    def build_context(
+        self,
+        query_code: str,
+        language: Optional[Language] = None,
+        task: Optional[TaskType] = None,
+        k: int = 3
+    ) -> str:
+        """
+        Build context string from retrieved examples
+
+        Args:
+            query_code: Code snippet to find similar examples for
+            language: Filter by programming language
+            task: Filter by task type
+            k: Number of examples to include
+
+        Returns:
+            Formatted context string for LLM prompts
+        """
+        examples = self.retrieve(query_code, language, task, k)
+
+        if not examples:
+            return ""
+
+        context_parts = ["Here are similar code examples:\n"]
+
+        for i, example in enumerate(examples, 1):
+            context_parts.append(f"\nExample {i}:")
+            if example.get("description"):
+                context_parts.append(f"Description: {example['description']}")
+            context_parts.append(f"```{example.get('language', 'python')}")
+            context_parts.append(example.get("code", ""))
+            context_parts.append("```")
+
+        return "\n".join(context_parts)