Upload 17 files

.flake8

@@ -0,0 +1,6 @@
+[flake8]
+exclude = fixtures, __jac_gen__, build, examples, vendor, ./server/src/tests/*, temp*
+plugins = flake8_import_order, flake8_docstrings, flake8_comprehensions, flake8_bugbear, flake8_annotations, pep8_naming, flake8_simplify
+max-line-length = 120
+ignore = E203, W503, ANN101, ANN102, I201, ANN401, D401, SIM115, E501
+per-file-ignores = server/src/utils/onboarding_questions.py:E501

.gitignore

@@ -0,0 +1,10 @@
+.aider*
+.env*
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+*.pyw
+*.pyz
+*.pywz
+aider_websocket_*

.pre-commit-config.yaml

@@ -0,0 +1,33 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.3.0
+    hooks:
+      - id: check-yaml
+        args: [--allow-multiple-documents]
+      - id: check-json
+      - id: trailing-whitespace
+  - repo: https://github.com/psf/black
+    rev: 24.1.1
+    hooks:
+      - id: black
+  - hooks:
+    - args:
+      - --profile
+      - black
+      id: isort
+    repo: https://github.com/pycqa/isort
+    rev: 5.12.0
+  - repo: https://github.com/PyCQA/flake8
+    rev: 6.1.0
+    hooks:
+      - id: flake8
+        additional_dependencies: [pep8-naming, flake8_docstrings, flake8_comprehensions, flake8_bugbear, flake8_annotations, flake8_simplify]
+        exclude: "examples|vendor"
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.8.0
+    hooks:
+      - id: mypy
+        exclude: 'venv|.conda|.git|.vscode|__pycache__|tests|examples|vendor|build|dist|.*.egg-info|.*.egg|temp*'
+        args:
+          - --follow-imports=silent
+          - --ignore-missing-imports

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY . /app
+
+RUN pip install -r requirements.txt
+RUN aider-install
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/core/config.py

@@ -0,0 +1,44 @@
+"""Configuration settings for the application."""
+
+from typing import List
+
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    """Settings for the application."""
+
+    OPENAI_API_KEY: str
+    AIDER_MODEL: str = "gpt-4o"
+    TEMP_DIR_PREFIX: str = "aider_websocket_"
+    ADMIN_API_KEY: str
+    AZURE_API_KEY: str
+    AZURE_API_VERSION: str
+    AZURE_API_BASE: str
+    # AIDER_MODEL_METADATA_FILE: str = ".aider.model.metadata.json"
+    # AIDER_GITIGNORE: bool = True
+    EXCLUDE_PATTERNS: List[str] = [
+        "__pycache__",
+        "*.pyc",
+        "*.pyo",
+        "*.pyd",
+        ".git",
+        ".gitignore",
+        ".env",
+        ".DS_Store",
+        "*.log",
+        ".pytest_cache",
+        ".coverage",
+        ".mypy_cache",
+        ".idea",
+        ".vscode",
+    ]
+
+    class Config:
+        """Settings configuration."""
+
+        env_file = ".env"
+        case_sensitive = True
+
+
+settings = Settings()

app/main.py

@@ -0,0 +1,140 @@
+"""Main entry point for the FastAPI application."""
+
+import asyncio
+import os
+
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.routers import admin, aider
+from app.services.session_manager import session_manager
+
+RESTRICTED_COMMANDS = {
+    "/model",  # Prevents model switching
+    "/tokens",
+}
+
+app = FastAPI(title="Aider WebSocket Server")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Frontend URL
+    allow_credentials=True,  # Required for WebSocket with credentials
+    allow_methods=["*"],  # Allow all HTTP methods (GET, POST, etc.)
+    allow_headers=["*"],  # Allow all headers
+)
+
+app.include_router(admin.router)
+app.include_router(aider.router)
+
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket) -> None:
+    """Websocket endpoint for handling commands and sessions."""
+    await websocket.accept()
+
+    try:
+        data = await websocket.receive_json()
+        repo_url = data.get("repo_url")
+
+        try:
+            session_id = await session_manager.create_session(repo_url=repo_url)
+            await websocket.send_json(
+                {"type": "status", "content": f"Session created with ID: {session_id}"}
+            )
+        except Exception as e:
+            await websocket.send_json(
+                {"type": "error", "content": f"Failed to create session: {str(e)}"}
+            )
+            return
+
+        aider_service = session_manager.get_session(session_id)
+
+        output_task = asyncio.create_task(aider_service.process_output(websocket))
+
+        while True:
+            try:
+                data = await websocket.receive_json()
+                command = data.get("command")
+
+                if command == "send_to_aider":
+                    message = data.get("message", "")
+                    if message.startswith("/"):
+                        cmd = message.split()[0].lower()
+                        if cmd in RESTRICTED_COMMANDS:
+                            await websocket.send_json(
+                                {
+                                    "type": "error",
+                                    "content": f"Command '{cmd}' is not allowed in this environment.",
+                                }
+                            )
+                            continue
+                    await aider_service.send_command(message)
+                elif command == "list_files":
+                    files = await aider_service.list_files()
+                    await websocket.send_json({"type": "files", "content": files})
+                elif command == "read_file":
+                    filename = data.get("filename")
+                    if filename:
+                        content = await aider_service.read_file(filename)
+                        await websocket.send_json(
+                            {"type": "file_content", "content": content}
+                        )
+                    else:
+                        await websocket.send_json(
+                            {"type": "error", "content": "Filename not provided"}
+                        )
+                elif command == "download":
+                    zip_path = await aider_service.create_download_zip()
+                    if zip_path:
+                        try:
+                            with open(zip_path, "rb") as f:
+                                zip_content = f.read()
+                            await websocket.send_bytes(zip_content)
+                        finally:
+                            if os.path.exists(zip_path):
+                                os.remove(zip_path)
+                    else:
+                        await websocket.send_json(
+                            {
+                                "type": "error",
+                                "content": "Failed to create download zip",
+                            }
+                        )
+                elif command.startswith("/"):
+                    cmd = command.split()[0].lower()
+                    if cmd in RESTRICTED_COMMANDS:
+                        await websocket.send_json(
+                            {
+                                "type": "error",
+                                "content": f"Command '{cmd}' is not allowed in this environment.",
+                            }
+                        )
+                        continue
+
+                    command_str = command
+                    if "args" in data:
+                        args = data.get("args", [])
+                        command_str += " " + " ".join(args)
+                    await aider_service.send_command(command_str)
+                else:
+                    await websocket.send_json(
+                        {"type": "error", "content": "Unknown command"}
+                    )
+
+            except WebSocketDisconnect:
+                break
+            except Exception as e:
+                await websocket.send_json({"type": "error", "content": str(e)})
+
+    except Exception as e:
+        await websocket.send_json({"type": "error", "content": str(e)})
+    finally:
+        output_task.cancel()
+        await session_manager.cleanup_session(session_id)
+
+
+@app.on_event("shutdown")
+async def shutdown_event() -> None:
+    """Clean up all sessions when the server shuts down."""
+    await session_manager.cleanup_all_sessions()

app/models/__init__.py

@@ -0,0 +1 @@
+"""Initialize the models package."""

app/models/admin.py

@@ -0,0 +1,36 @@
+"""Admin API models."""
+
+from typing import List, Optional
+
+from pydantic import BaseModel
+
+
+class SessionInfo(BaseModel):
+    """Session information."""
+
+    id: str
+    path: str
+    created_at: float
+    size: int
+
+
+class SessionList(BaseModel):
+    """List of sessions."""
+
+    sessions: List[SessionInfo]
+
+
+class ConfigUpdate(BaseModel):
+    """Configuration update model."""
+
+    openai_api_key: Optional[str] = None
+    aider_model: Optional[str] = None
+    temp_dir_prefix: Optional[str] = None
+
+
+class ConfigResponse(BaseModel):
+    """Configuration response model."""
+
+    openai_api_key: Optional[str]
+    aider_model: str
+    temp_dir_prefix: str

app/routers/__init__.py

@@ -0,0 +1 @@
+"""Initializes the routers module."""

app/routers/admin.py

@@ -0,0 +1,117 @@
+"""Admin router module for managing Aider sessions and configurations."""
+
+import os
+import shutil
+import tempfile
+
+from fastapi import APIRouter, Depends, HTTPException, Security
+from fastapi.security import APIKeyHeader
+
+from app.core.config import settings
+from app.models.admin import ConfigResponse, ConfigUpdate, SessionInfo, SessionList
+
+router = APIRouter(prefix="/admin", tags=["admin"])
+
+# Security
+API_KEY_NAME = "X-API-Key"
+api_key_header = APIKeyHeader(name=API_KEY_NAME)
+
+# Define dependency outside of function signature
+verify_admin_dep = Security(api_key_header)
+
+
+async def verify_admin_key(api_key: str = verify_admin_dep) -> str:
+    """Verify the admin API key."""
+    if api_key != settings.ADMIN_API_KEY:
+        raise HTTPException(status_code=403, detail="Invalid API key")
+    return api_key
+
+
+@router.get("/sessions", response_model=SessionList)
+async def list_sessions(api_key: str = Depends(verify_admin_key)) -> SessionList:
+    """List all active Aider sessions."""
+    sessions = []
+    temp_dir = tempfile.gettempdir()
+
+    for dir_name in os.listdir(temp_dir):
+        if dir_name.startswith(settings.TEMP_DIR_PREFIX):
+            session_path = os.path.join(temp_dir, dir_name)
+            if os.path.isdir(session_path):
+                sessions.append(
+                    SessionInfo(
+                        id=dir_name,
+                        path=session_path,
+                        created_at=os.path.getctime(session_path),
+                        size=sum(
+                            os.path.getsize(os.path.join(session_path, f))
+                            for f in os.listdir(session_path)
+                            if os.path.isfile(os.path.join(session_path, f))
+                        ),
+                    )
+                )
+
+    return SessionList(sessions=sessions)
+
+
+@router.delete("/sessions/{session_id}")
+async def delete_session(
+    session_id: str, api_key: str = Depends(verify_admin_key)
+) -> dict:
+    """Delete a specific Aider session."""
+    session_path = os.path.join(tempfile.gettempdir(), session_id)
+
+    if not os.path.exists(session_path):
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    try:
+        shutil.rmtree(session_path)
+        return {"message": "Session deleted successfully"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/sessions")
+async def delete_all_sessions(api_key: str = Depends(verify_admin_key)) -> dict:
+    """Delete all Aider sessions."""
+    temp_dir = tempfile.gettempdir()
+    deleted_count = 0
+
+    for dir_name in os.listdir(temp_dir):
+        if dir_name.startswith(settings.TEMP_DIR_PREFIX):
+            session_path = os.path.join(temp_dir, dir_name)
+            if os.path.isdir(session_path):
+                try:
+                    shutil.rmtree(session_path)
+                    deleted_count += 1
+                except Exception as e:
+                    raise HTTPException(status_code=500, detail=str(e))
+
+    return {"message": f"Deleted {deleted_count} sessions"}
+
+
+@router.get("/config", response_model=ConfigResponse)
+async def get_config(api_key: str = Depends(verify_admin_key)) -> ConfigResponse:
+    """Get current configuration settings."""
+    masked_key = (
+        settings.OPENAI_API_KEY[:8] + "..." if settings.OPENAI_API_KEY else None
+    )
+    return ConfigResponse(
+        openai_api_key=masked_key,
+        aider_model=settings.AIDER_MODEL,
+        temp_dir_prefix=settings.TEMP_DIR_PREFIX,
+    )
+
+
+@router.put("/config")
+async def update_config(
+    config: ConfigUpdate, api_key: str = Depends(verify_admin_key)
+) -> dict:
+    """Update configuration settings."""
+    if config.openai_api_key:
+        settings.OPENAI_API_KEY = config.openai_api_key
+    if config.aider_model:
+        settings.AIDER_MODEL = config.aider_model
+    if config.temp_dir_prefix:
+        settings.TEMP_DIR_PREFIX = config.temp_dir_prefix
+
+    return {"message": "Configuration updated successfully"}

app/routers/aider.py

@@ -0,0 +1,357 @@
+"""Aider router module for managing AI development sessions."""
+
+from typing import List, Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from app.services.session_manager import session_manager
+
+router = APIRouter(prefix="/aider", tags=["aider"])
+
+
+class AiderCommand(BaseModel):
+    """Command structure for Aider operations."""
+
+    command: str
+    args: Optional[List[str]] = None
+    session_id: str
+
+
+class FileOperation(BaseModel):
+    """File operation structure for Aider."""
+
+    files: List[str]
+    session_id: str
+
+
+class ModelSwitch(BaseModel):
+    """Model switching structure for Aider."""
+
+    model: str
+    session_id: str
+
+
+class TokenBudget(BaseModel):
+    """Token budget structure for Aider."""
+
+    tokens: str
+    session_id: str
+
+
+class ReasoningEffort(BaseModel):
+    """Reasoning effort structure for Aider."""
+
+    level: str
+    session_id: str
+
+
+class WebScrape(BaseModel):
+    """Web scraping structure for Aider."""
+
+    url: str
+    session_id: str
+
+
+class CreateSession(BaseModel):
+    """Session creation structure for Aider."""
+
+    repo_url: Optional[str] = None
+
+
+def get_session(session_id: str) -> None:
+    """Helper function to get a session or raise HTTPException."""
+    session = session_manager.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+
+@router.post("/create-session")
+async def create_session(session_params: Optional[CreateSession] = None) -> dict:
+    """Create a new aider session, optionally with a cloned repository."""
+    try:
+        repo_url = None
+        if session_params and session_params.repo_url:
+            repo_url = session_params.repo_url
+
+        session_id = await session_manager.create_session(repo_url=repo_url)
+        return {"session_id": session_id, "message": "Session created successfully"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/add")
+async def add_files(files: FileOperation) -> dict:
+    """Add files to the chat session."""
+    get_session(files.session_id)
+    return {"command": "/add", "files": files.files}
+
+
+@router.post("/architect")
+async def architect_mode(command: AiderCommand) -> dict:
+    """Enter architect/editor mode."""
+    get_session(command.session_id)
+    return {
+        "command": "/architect",
+        "prompt": command.args[0] if command.args else None,
+    }
+
+
+@router.post("/ask")
+async def ask_mode(command: AiderCommand) -> dict:
+    """Enter ask mode."""
+    get_session(command.session_id)
+    return {"command": "/ask", "prompt": command.args[0] if command.args else None}
+
+
+@router.post("/chat-mode")
+async def chat_mode(command: AiderCommand) -> dict:
+    """Switch to a new chat mode."""
+    get_session(command.session_id)
+    return {"command": "/chat-mode", "mode": command.args[0] if command.args else None}
+
+
+@router.post("/clear")
+async def clear_chat(command: AiderCommand) -> dict:
+    """Clear the chat history."""
+    get_session(command.session_id)
+    return {"command": "/clear"}
+
+
+@router.post("/code")
+async def code_mode(command: AiderCommand) -> dict:
+    """Enter code mode."""
+    get_session(command.session_id)
+    return {"command": "/code", "prompt": command.args[0] if command.args else None}
+
+
+@router.post("/commit")
+async def commit_changes(command: AiderCommand) -> dict:
+    """Commit changes to the repository."""
+    get_session(command.session_id)
+    return {"command": "/commit", "message": command.args[0] if command.args else None}
+
+
+@router.post("/context")
+async def context_mode(command: AiderCommand) -> dict:
+    """Enter context mode."""
+    get_session(command.session_id)
+    return {"command": "/context", "prompt": command.args[0] if command.args else None}
+
+
+@router.post("/copy")
+async def copy_last_message(command: AiderCommand) -> dict:
+    """Copy the last assistant message."""
+    get_session(command.session_id)
+    return {"command": "/copy"}
+
+
+@router.post("/copy-context")
+async def copy_context(command: AiderCommand) -> dict:
+    """Copy the current chat context."""
+    get_session(command.session_id)
+    return {"command": "/copy-context"}
+
+
+@router.post("/diff")
+async def show_diff(command: AiderCommand) -> dict:
+    """Show diff of changes."""
+    get_session(command.session_id)
+    return {"command": "/diff"}
+
+
+@router.post("/drop")
+async def drop_files(files: FileOperation) -> dict:
+    """Remove files from chat session."""
+    get_session(files.session_id)
+    return {"command": "/drop", "files": files.files}
+
+
+@router.post("/editor")
+async def open_editor(command: AiderCommand) -> dict:
+    """Open editor for prompt."""
+    get_session(command.session_id)
+    return {"command": "/editor", "prompt": command.args[0] if command.args else None}
+
+
+@router.post("/editor-model")
+async def switch_editor_model(model: ModelSwitch) -> dict:
+    """Switch the editor model."""
+    get_session(model.session_id)
+    return {"command": "/editor-model", "model": model.model}
+
+
+@router.post("/git")
+async def git_command(command: AiderCommand) -> dict:
+    """Run a git command."""
+    get_session(command.session_id)
+    return {"command": "/git", "git_command": command.args[0] if command.args else None}
+
+
+@router.post("/help")
+async def help_command(command: AiderCommand) -> dict:
+    """Get help about aider."""
+    get_session(command.session_id)
+    return {"command": "/help", "question": command.args[0] if command.args else None}
+
+
+@router.post("/lint")
+async def lint_files(files: Optional[FileOperation] = None) -> dict:
+    """Lint files."""
+    if files:
+        get_session(files.session_id)
+    return {"command": "/lint", "files": files.files if files else None}
+
+
+@router.post("/load")
+async def load_commands(command: AiderCommand) -> dict:
+    """Load commands from a file."""
+    get_session(command.session_id)
+    return {"command": "/load", "file": command.args[0] if command.args else None}
+
+
+@router.post("/ls")
+async def list_files(command: AiderCommand) -> dict:
+    """List all known files."""
+    get_session(command.session_id)
+    return {"command": "/ls"}
+
+
+@router.post("/map")
+async def show_map(command: AiderCommand) -> dict:
+    """Show repository map."""
+    get_session(command.session_id)
+    return {"command": "/map"}
+
+
+@router.post("/map-refresh")
+async def refresh_map(command: AiderCommand) -> dict:
+    """Refresh repository map."""
+    get_session(command.session_id)
+    return {"command": "/map-refresh"}
+
+
+@router.post("/model")
+async def switch_model(model: ModelSwitch) -> dict:
+    """Switch the main model."""
+    get_session(model.session_id)
+    return {"command": "/model", "model": model.model}
+
+
+@router.post("/models")
+async def search_models(command: AiderCommand) -> dict:
+    """Search available models."""
+    get_session(command.session_id)
+    return {"command": "/models", "query": command.args[0] if command.args else None}
+
+
+@router.post("/multiline-mode")
+async def toggle_multiline(command: AiderCommand) -> dict:
+    """Toggle multiline mode."""
+    get_session(command.session_id)
+    return {"command": "/multiline-mode"}
+
+
+@router.post("/paste")
+async def paste_content(command: AiderCommand) -> dict:
+    """Paste content from clipboard."""
+    get_session(command.session_id)
+    content = command.args[0] if command.args else None
+    name = command.args[1] if len(command.args) > 1 else None
+    return {"command": "/paste", "content": content, "name": name}
+
+
+@router.post("/read-only")
+async def set_read_only(files: FileOperation, read_only: bool = True) -> dict:
+    """Set files as read-only."""
+    get_session(files.session_id)
+    return {"command": "/read-only", "files": files.files, "read_only": read_only}
+
+
+@router.post("/reasoning-effort")
+async def set_reasoning_effort(level: ReasoningEffort) -> dict:
+    """Set reasoning effort level."""
+    get_session(level.session_id)
+    return {"command": "/reasoning-effort", "level": level.level}
+
+
+@router.post("/reset")
+async def reset_session(command: AiderCommand) -> dict:
+    """Reset the session."""
+    get_session(command.session_id)
+    return {"command": "/reset"}
+
+
+@router.post("/run")
+async def run_command(command: AiderCommand) -> dict:
+    """Run a shell command."""
+    get_session(command.session_id)
+    shell_command = command.args[0] if command.args else None
+    add_output = command.args[1] == "true" if len(command.args) > 1 else False
+    return {"command": "/run", "shell_command": shell_command, "add_output": add_output}
+
+
+@router.post("/save")
+async def save_commands(command: AiderCommand) -> dict:
+    """Save commands to a file."""
+    get_session(command.session_id)
+    return {"command": "/save", "file": command.args[0] if command.args else None}
+
+
+@router.post("/settings")
+async def show_settings(command: AiderCommand) -> dict:
+    """Show current settings."""
+    get_session(command.session_id)
+    return {"command": "/settings"}
+
+
+@router.post("/test")
+async def test_command(command: AiderCommand) -> dict:
+    """Run a test command."""
+    get_session(command.session_id)
+    return {
+        "command": "/test",
+        "shell_command": command.args[0] if command.args else None,
+    }
+
+
+@router.post("/think-tokens")
+async def set_think_tokens(tokens: TokenBudget) -> dict:
+    """Set thinking token budget."""
+    get_session(tokens.session_id)
+    return {"command": "/think-tokens", "tokens": tokens.tokens}
+
+
+@router.post("/tokens")
+async def show_tokens(command: AiderCommand) -> dict:
+    """Show token usage."""
+    get_session(command.session_id)
+    return {"command": "/tokens"}
+
+
+@router.post("/undo")
+async def undo_last_commit(command: AiderCommand) -> dict:
+    """Undo last commit."""
+    get_session(command.session_id)
+    return {"command": "/undo"}
+
+
+@router.post("/voice")
+async def record_voice(command: AiderCommand) -> dict:
+    """Record and transcribe voice input."""
+    get_session(command.session_id)
+    return {"command": "/voice"}
+
+
+@router.post("/weak-model")
+async def switch_weak_model(model: ModelSwitch) -> dict:
+    """Switch the weak model."""
+    get_session(model.session_id)
+    return {"command": "/weak-model", "model": model.model}
+
+
+@router.post("/web")
+async def scrape_webpage(url: WebScrape) -> dict:
+    """Scrape a webpage."""
+    get_session(url.session_id)
+    return {"command": "/web", "url": url.url}

app/services/aider_service.py

@@ -0,0 +1,272 @@
+"""Module for managing Aider sessions and interactions."""
+
+import asyncio
+import fnmatch
+import os
+import re
+import shutil
+import signal
+import tempfile
+import zipfile
+from typing import Optional
+
+from ansi2html import Ansi2HTMLConverter
+from fastapi import WebSocket
+
+from app.core.config import settings
+from app.utils.output_parser import AiderOutputParser
+
+
+class AiderService:
+    """AiderService class to manage Aider sessions and interactions."""
+
+    def __init__(self) -> None:
+        """Initialize the AiderService with default values."""
+        self.converter = Ansi2HTMLConverter()
+        self.output_parser = AiderOutputParser()
+        self.temp_dir: Optional[str] = None
+        self.aider_process: Optional[asyncio.subprocess.Process] = None
+        self.running_process: Optional[asyncio.subprocess.Process] = None
+
+    async def initialize(self, repo_url: Optional[str] = None) -> str:
+        """Initialize a new Aider session with a temporary directory.
+
+        Args:
+            repo_url: Optional URL to a git repository to clone. If provided,
+                      the repository will be cloned instead of initializing an empty repo.
+
+        Returns:
+            The path to the temporary directory.
+        """
+        self.temp_dir = tempfile.mkdtemp(prefix=settings.TEMP_DIR_PREFIX)
+
+        if repo_url:
+            if not self._is_valid_git_url(repo_url):
+                raise Exception(f"Invalid git repository URL format: {repo_url}")
+
+            git_process = await asyncio.create_subprocess_exec(
+                "git",
+                "clone",
+                repo_url,
+                ".",
+                cwd=self.temp_dir,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, stderr = await git_process.communicate()
+
+            if git_process.returncode != 0:
+                error_msg = (
+                    stderr.decode() if stderr else "Unknown error during git clone"
+                )
+                raise Exception(f"Failed to clone repository: {error_msg}")
+
+            print(f"Successfully cloned repository: {repo_url}")
+        else:
+            git_process = await asyncio.create_subprocess_exec(
+                "git",
+                "init",
+                cwd=self.temp_dir,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, stderr = await git_process.communicate()
+
+            if git_process.returncode != 0:
+                error_msg = (
+                    stderr.decode() if stderr else "Unknown error during git init"
+                )
+                raise Exception(f"Failed to initialize git repository: {error_msg}")
+
+        return self.temp_dir
+
+    def _is_valid_git_url(self, url: str) -> bool:
+        """Validate if the string looks like a git URL."""
+        patterns = [
+            # SSH format
+            r"^git@[a-zA-Z0-9\-\.]+:[a-zA-Z0-9\-\.\/]+\.git$",
+            # HTTPS format
+            r"^https?:\/\/[a-zA-Z0-9\-\.]+\/[a-zA-Z0-9\-\.\/]+\.git$",
+            # Alternative HTTPS format without .git suffix
+            r"^https?:\/\/[a-zA-Z0-9\-\.]+\/[a-zA-Z0-9\-\.\/]+$",
+            # Filesystem path
+            r"^\/[a-zA-Z0-9\-\.\/]+\.git$",
+            r"^\/[a-zA-Z0-9\-\.\/]+$",
+            r"^[a-zA-Z]:\\[a-zA-Z0-9\-\.\\]+\.git$",
+            r"^[a-zA-Z]:\\[a-zA-Z0-9\-\.\\]+$",
+        ]
+
+        return any(re.match(pattern, url) for pattern in patterns)
+
+    async def start_aider(self) -> None:
+        """Start the Aider process."""
+        env = os.environ.copy()
+        env["OPENAI_API_KEY"] = settings.OPENAI_API_KEY
+        env["AZURE_API_KEY"] = settings.AZURE_API_KEY
+        env["AZURE_API_VERSION"] = settings.AZURE_API_VERSION
+        env["AZURE_API_BASE"] = settings.AZURE_API_BASE
+        # env["AIDER_MODEL_METADATA_FILE"] = settings.AIDER_MODEL_METADATA_FILE
+        # env["AIDER_GITIGNORE"] = settings.AIDER_GITIGNORE
+
+        self.aider_process = await asyncio.create_subprocess_exec(
+            # "aider", "--model", settings.AIDER_MODEL,
+            "aider",
+            "--model",
+            "azure/bcsai-gpt4o",
+            "--no-gitignore",
+            "--no-show-model-warnings",
+            "--no-suggest-shell-commands",
+            "--no-check-update",
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=self.temp_dir,
+            env=env,
+        )
+
+    async def send_command(self, command: str) -> None:
+        """Send a command to the Aider process."""
+        if not self.aider_process or not self.aider_process.stdin:
+            raise Exception("Aider process is not running or stdin is not available")
+
+        try:
+            if not command.endswith("\n"):
+                command += "\n"
+
+            self.aider_process.stdin.write(command.encode())
+            await self.aider_process.stdin.drain()
+        except Exception as e:
+            raise Exception(f"Failed to send command to Aider: {str(e)}")
+
+    async def process_output(self, websocket: WebSocket) -> None:
+        """Process and send Aider output to the websocket."""
+        if not self.aider_process:
+            return
+
+        try:
+            while True:
+                line = await self.aider_process.stdout.readline()
+                if not line:
+                    break
+
+                line_str = line.decode().strip()
+                if not line_str:
+                    continue
+
+                blocks = self.output_parser.parse_output(line_str)
+
+                for block in blocks:
+                    if block.is_code_block:
+                        html_output = self.converter.convert(block.content, full=False)
+                        await websocket.send_json(
+                            {"type": "code_block", "content": html_output}
+                        )
+                    elif block.is_prompt:
+                        await websocket.send_json(
+                            {"type": "prompt", "content": block.content}
+                        )
+                    elif block.is_separator:
+                        await websocket.send_json(
+                            {"type": "separator", "content": block.content}
+                        )
+                    elif block.is_token_info:
+                        await websocket.send_json(
+                            {"type": "token_info", "content": block.content}
+                        )
+                    else:
+                        html_output = self.converter.convert(block.content, full=False)
+                        await websocket.send_json(
+                            {"type": "output", "content": html_output}
+                        )
+        except Exception as e:
+            await websocket.send_json(
+                {"type": "error", "content": f"Error processing output: {str(e)}"}
+            )
+
+    async def create_download_zip(self) -> Optional[str]:
+        """Create a zip file of the temporary directory contents, excluding specified patterns.
+
+        Returns:
+            The path to the created zip file, or None if the temporary directory doesn't exist.
+        """
+        if not self.temp_dir or not os.path.exists(self.temp_dir):
+            return None
+
+        zip_path = tempfile.mktemp(suffix=".zip")
+
+        try:
+            with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zipf:
+                for root, dirs, files in os.walk(self.temp_dir):
+                    dirs[:] = [
+                        d
+                        for d in dirs
+                        if not any(
+                            fnmatch.fnmatch(d, pattern)
+                            for pattern in settings.EXCLUDE_PATTERNS
+                        )
+                    ]
+
+                    for file in files:
+                        file_path = os.path.join(root, file)
+                        if any(
+                            fnmatch.fnmatch(file, pattern)
+                            for pattern in settings.EXCLUDE_PATTERNS
+                        ):
+                            continue
+
+                        arcname = os.path.relpath(file_path, self.temp_dir)
+                        zipf.write(file_path, arcname)
+
+            return zip_path
+        except Exception as e:
+            print(f"Error creating zip file: {str(e)}")
+            if os.path.exists(zip_path):
+                os.remove(zip_path)
+            return None
+
+    async def cleanup(self) -> None:
+        """Clean up resources."""
+        if self.aider_process and self.aider_process.returncode is None:
+            try:
+                self.aider_process.terminate()
+                await self.aider_process.wait()
+            except Exception:
+                pass
+
+        if self.running_process and self.running_process.returncode is None:
+            try:
+                self.running_process.send_signal(signal.SIGINT)
+                await self.running_process.wait()
+            except Exception:
+                pass
+
+        if self.temp_dir:
+            try:
+                shutil.rmtree(self.temp_dir, ignore_errors=True)
+            except Exception:
+                pass
+            self.temp_dir = None
+
+    async def list_files(self) -> list:
+        """List files in the temporary directory."""
+        if not self.temp_dir:
+            return []
+
+        files = []
+        for root, _, filenames in os.walk(self.temp_dir):
+            for filename in filenames:
+                files.append(
+                    os.path.relpath(os.path.join(root, filename), self.temp_dir)
+                )
+        return files
+
+    async def read_file(self, filename: str) -> str:
+        """Read a file from the temporary directory."""
+        if not self.temp_dir:
+            return "File not found"
+
+        file_path = os.path.join(self.temp_dir, filename)
+        if os.path.exists(file_path):
+            with open(file_path, "r") as f:
+                return f.read()
+        return "File not found"

app/services/session_manager.py

@@ -0,0 +1,49 @@
+"""Session manager for AiderService."""
+
+import uuid
+from typing import Dict, Optional
+
+from app.services.aider_service import AiderService
+
+
+class SessionManager:
+    """Session manager for AiderService."""
+
+    def __init__(self) -> None:
+        """Initialize the session manager."""
+        self.sessions: Dict[str, AiderService] = {}
+
+    async def create_session(self, repo_url: Optional[str] = None) -> str:
+        """Create a new session and return its ID.
+
+        Args:
+            repo_url: Optional URL to a git repository to clone. If provided,
+                     the repository will be cloned instead of initializing an empty repo.
+
+        Returns:
+            The session ID as a string.
+        """
+        session_id = str(uuid.uuid4())
+        aider_service = AiderService()
+        await aider_service.initialize(repo_url=repo_url)
+        await aider_service.start_aider()
+        self.sessions[session_id] = aider_service
+        return session_id
+
+    def get_session(self, session_id: str) -> Optional[AiderService]:
+        """Get an existing session by ID."""
+        return self.sessions.get(session_id)
+
+    async def cleanup_session(self, session_id: str) -> None:
+        """Clean up a session and remove it from the manager."""
+        if session_id in self.sessions:
+            await self.sessions[session_id].cleanup()
+            del self.sessions[session_id]
+
+    async def cleanup_all_sessions(self) -> None:
+        """Clean up all sessions."""
+        for session_id in list(self.sessions.keys()):
+            await self.cleanup_session(session_id)
+
+
+session_manager = SessionManager()

app/utils/output_parser.py

@@ -0,0 +1,101 @@
+"""Module to parse the output of the Aider model."""
+
+import re
+from dataclasses import dataclass
+from typing import List
+
+
+@dataclass
+class AiderOutputBlock:
+    """A single block of output from the Aider model."""
+
+    content: str
+    type: str  # 'text', 'code', 'prompt', 'separator', 'token_info'
+    is_code_block: bool = False
+    is_prompt: bool = False
+    is_separator: bool = False
+    is_token_info: bool = False
+
+
+class AiderOutputParser:
+    """Output parser for Aider model."""
+
+    def __init__(self) -> None:
+        """Initialize the output parser."""
+        self.code_block_pattern = re.compile(
+            r"<<<<<<< SEARCH\n(.*?)\n=======\n(.*?)\n>>>>>>> REPLACE", re.DOTALL
+        )
+        self.prompt_pattern = re.compile(r"^> (.*)$", re.MULTILINE)
+        self.separator_pattern = re.compile(r"^─+$", re.MULTILINE)
+        self.token_info_pattern = re.compile(
+            r"Tokens: (.*?) sent, (.*?) received\. Cost: (.*?) message, (.*?) session\."
+        )
+        self.aider_pattern = re.compile(r"\baider\b", re.IGNORECASE)
+
+    def parse_output(self, output: str) -> List[AiderOutputBlock]:
+        """Parse the output from the Aider model into blocks."""
+        blocks = []
+        current_block = []
+
+        for line in output.split("\n"):
+
+            line = line.rstrip("\r")
+
+            line = re.sub(self.aider_pattern, "Dev Assist", line)
+
+            if not line.strip():
+                if current_block:
+                    blocks.append(self._create_text_block("".join(current_block)))
+                    current_block = []
+                continue
+
+            if "<<<<<<< SEARCH" in line:
+                if current_block:
+                    blocks.append(self._create_text_block("".join(current_block)))
+                    current_block = []
+                blocks.append(self._create_code_block(line))
+                continue
+
+            if line.startswith("> "):
+                if current_block:
+                    blocks.append(self._create_text_block("".join(current_block)))
+                    current_block = []
+                prompt_content = line[2:].strip()
+                blocks.append(self._create_prompt_block(prompt_content))
+                continue
+
+            if re.match(self.separator_pattern, line):
+                if current_block:
+                    blocks.append(self._create_text_block("".join(current_block)))
+                    current_block = []
+                blocks.append(self._create_separator_block(line))
+                continue
+
+            if re.match(self.token_info_pattern, line):
+                if current_block:
+                    blocks.append(self._create_text_block("".join(current_block)))
+                    current_block = []
+                blocks.append(self._create_token_info_block(line))
+                continue
+
+            current_block.append(line + "\n")
+
+        if current_block:
+            blocks.append(self._create_text_block("".join(current_block)))
+
+        return blocks
+
+    def _create_text_block(self, content: str) -> AiderOutputBlock:
+        return AiderOutputBlock(content=content, type="text")
+
+    def _create_code_block(self, content: str) -> AiderOutputBlock:
+        return AiderOutputBlock(content=content, type="code", is_code_block=True)
+
+    def _create_prompt_block(self, content: str) -> AiderOutputBlock:
+        return AiderOutputBlock(content=content, type="prompt", is_prompt=True)
+
+    def _create_separator_block(self, content: str) -> AiderOutputBlock:
+        return AiderOutputBlock(content=content, type="separator", is_separator=True)
+
+    def _create_token_info_block(self, content: str) -> AiderOutputBlock:
+        return AiderOutputBlock(content=content, type="token_info", is_token_info=True)

client.py

@@ -0,0 +1,169 @@
+import streamlit as st
+import streamlit.components.v1 as components
+
+st.title("Aider WebSocket Client")
+st.write(
+    "Interact with the Aider WebSocket server. Send commands, run files, and terminate running processes."
+)
+
+html_code = """
+<div>
+    <div id="messages" style="height: 300px; overflow-y: scroll; border: 1px solid #ccc; padding: 10px;"></div>
+    <input id="repo_url" type="text" placeholder="Repository URL (optional)" style="margin-top: 10px; width: 300px;">
+    <button onclick="connectToAider()" style="margin-left: 10px;">Connect to Aider</button>
+    <input id="aider_input" type="text" placeholder="Send to Aider" style="margin-top: 10px; width: 300px;">
+    <button onclick="sendToAider()" style="margin-left: 10px;">Send to Aider</button>
+    <button onclick="listFiles()" style="margin-left: 10px;">List Files</button>
+    <input id="filename_input" type="text" placeholder="Filename to run/read" style="margin-top: 10px; width: 300px;">
+    <button onclick="runFile()" style="margin-left: 10px;">Run File</button>
+    <button onclick="terminateProcess()" style="margin-left: 10px;">Terminate Process</button>
+    <button onclick="readFile()" style="margin-left: 10px;">Read File</button>
+    <button onclick="downloadFiles()" style="margin-left: 10px;">Download Files</button>
+</div>
+<script>
+    let ws;
+
+    function connectToAider() {
+        const repoUrl = document.getElementById('repo_url').value;
+
+        // Close existing connection if any
+        if (ws) {
+            ws.close();
+        }
+
+        // Create a new WebSocket connection
+        ws = new WebSocket('ws://localhost:8000/ws');
+
+        ws.onopen = function() {
+            // Send initial connection parameters
+            ws.send(JSON.stringify({
+                repo_url: repoUrl || null
+            }));
+
+            const messagesDiv = document.getElementById('messages');
+            messagesDiv.innerHTML += '<div style="color: green;">Connected to Aider' + (repoUrl ? ' with repository: ' + repoUrl : '') + '</div><br>';
+
+            // Enable the input field
+            document.getElementById('aider_input').disabled = false;
+        };
+
+        ws.onmessage = function(event) {
+            // Check if the message is binary (zip file)
+            if (event.data instanceof Blob) {
+                // Create a download link for the zip file
+                const url = window.URL.createObjectURL(event.data);
+                const a = document.createElement('a');
+                a.href = url;
+                a.download = 'aider_files.zip';
+                document.body.appendChild(a);
+                a.click();
+                window.URL.revokeObjectURL(url);
+                document.body.removeChild(a);
+                return;
+            }
+
+            const data = JSON.parse(event.data);
+            const messagesDiv = document.getElementById('messages');
+            if (data.type === 'output') {
+                messagesDiv.innerHTML += data.content + '<br>';
+            } else if (data.type === 'files') {
+                messagesDiv.innerHTML += 'Files: ' + data.content.join(', ') + '<br>';
+            } else if (data.type === 'file_content') {
+                messagesDiv.innerHTML += 'File content:<br>' + data.content + '<br>';
+            } else if (data.type === 'error') {
+                messagesDiv.innerHTML += '<div style="color: red;">Error: ' + data.content + '</div><br>';
+            } else if (data.type === 'status') {
+                messagesDiv.innerHTML += '<div style="color: blue;">Status: ' + data.content + '</div><br>';
+            }
+            messagesDiv.scrollTop = messagesDiv.scrollHeight;
+        };
+
+        ws.onerror = function(error) {
+            const messagesDiv = document.getElementById('messages');
+            messagesDiv.innerHTML += '<div style="color: red;">WebSocket Error: ' + error.message + '</div><br>';
+            document.getElementById('aider_input').disabled = true;
+        };
+
+        ws.onclose = function(event) {
+            const messagesDiv = document.getElementById('messages');
+            if (event.wasClean) {
+                messagesDiv.innerHTML += '<div style="color: blue;">Connection closed cleanly, code=' + event.code + ' reason=' + event.reason + '</div><br>';
+            } else {
+                messagesDiv.innerHTML += '<div style="color: red;">Connection died unexpectedly</div><br>';
+            }
+            document.getElementById('aider_input').disabled = true;
+        };
+    }
+
+    function sendToAider() {
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            alert('Please connect to Aider first');
+            return;
+        }
+
+        const input = document.getElementById('aider_input').value;
+        if (input) {
+            ws.send(JSON.stringify({command: 'send_to_aider', message: input}));
+            document.getElementById('aider_input').value = '';
+        }
+    }
+
+    function listFiles() {
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            alert('Please connect to Aider first');
+            return;
+        }
+
+        ws.send(JSON.stringify({command: 'list_files'}));
+    }
+
+    function readFile() {
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            alert('Please connect to Aider first');
+            return;
+        }
+
+        const filename = document.getElementById('filename_input').value;
+        if (filename) {
+            ws.send(JSON.stringify({command: 'read_file', filename: filename}));
+        }
+    }
+
+    function runFile() {
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            alert('Please connect to Aider first');
+            return;
+        }
+
+        const filename = document.getElementById('filename_input').value;
+        if (filename) {
+            ws.send(JSON.stringify({command: 'run_file', filename: filename}));
+        }
+    }
+
+    function terminateProcess() {
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            alert('Please connect to Aider first');
+            return;
+        }
+
+        ws.send(JSON.stringify({command: 'terminate_process'}));
+    }
+
+    function downloadFiles() {
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            alert('Please connect to Aider first');
+            return;
+        }
+
+        ws.send(JSON.stringify({command: 'download'}));
+    }
+
+    // Show connection button by default
+    window.onload = function() {
+        document.getElementById('aider_input').disabled = true;
+    };
+</script>
+"""
+
+components.html(html_code, height=500)

mypy.ini

@@ -0,0 +1,17 @@
+[mypy]
+python_version = 3.12
+ignore_missing_imports = True
+
+[mypy-requests.*]
+ignore_missing_imports = True
+# Paths to exclude from checking
+# exclude = venv|__jac_gen__|tests|stubs|support|vendor|examples/reference|setup.py
+
+# Treating type checking issues as errors
+# strict = True
+
+# Allow redefinition of functions with different types
+# allow_redefinition = True
+
+# Ignore missing imports from certain modules
+# ignore_missing_imports = True

requirements.txt

@@ -0,0 +1,8 @@
+fastapi>=0.68.0
+uvicorn>=0.15.0
+python-dotenv>=0.19.0
+ansi2html>=1.8.0
+pydantic>=2.0.0
+pydantic-settings>=2.0.0
+aider-install
+shutil