Initial commit - AmkyawDev Coder Backend

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for caching
+COPY backend/requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY backend/ .
+
+# Expose port
+EXPOSE 7860
+
+# Run the application
+CMD ["uvicorn", "src.app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,38 @@
----
-title: Amkyawdev Coder Backend
-emoji: 🌍
-colorFrom: pink
-colorTo: green
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# AmkyawDev Coder Backend
+
+AI-Powered Development Platform Backend built with FastAPI.
+
+## Features
+
+- 🤖 **Skill Agent** - Execute specialized AI skills
+- 🔗 **Long Chain Agent** - Orchestrate complex workflows
+- 💻 **Script Agent** - Generate and optimize code
+- 📦 **Zip System** - Compile and compress files
+- 🚀 **Deploy System** - Deploy to multiple cloud providers
+- 🧠 **Memory System** - AI-powered memory management
+
+## API Endpoints
+
+### Agents
+- `POST /api/agents/skill/execute` - Execute skill agent
+- `POST /api/agents/long-chain/execute` - Execute long chain workflow
+- `POST /api/agents/script/generate` - Generate code
+
+### Systems
+- `POST /api/systems/zip/compile` - Compile files to zip
+- `POST /api/systems/deploy/deploy` - Deploy to cloud
+- `POST /api/systems/memory/search` - Search memory
+
+## Setup
+
+1. Create `.env` file with your API keys
+2. Run `pip install -r requirements.txt`
+3. Run `uvicorn src.app:app --reload`
+
+## Environment Variables
+
+```
+GROQ_API_KEY=your_groq_api_key
+HUGGINGFACE_API_KEY=your_hf_api_key
+FIREBASE_CREDENTIALS_PATH=path/to/credentials.json
+```

backend/.env

@@ -0,0 +1,21 @@
+# Application
+APP_NAME=AmkyawDev Coder Backend
+ENVIRONMENT=production
+DEBUG=false
+
+# Groq API
+GROQ_API_KEY=
+GROQ_MODEL=llama-3.1-70b-versatile
+
+# Hugging Face
+HUGGINGFACE_API_KEY=
+
+# Firebase
+FIREBASE_CREDENTIALS_PATH=
+FIREBASE_DATABASE_URL=
+
+# Deployment
+VERCEL_TOKEN=
+NETLIFY_TOKEN=
+AWS_ACCESS_KEY_ID=
+AWS_SECRET_ACCESS_KEY=

backend/requirements.txt

@@ -0,0 +1,44 @@
+# FastAPI & Server
+fastapi==0.115.0
+uvicorn[standard]==0.30.6
+python-multipart==0.0.12
+
+# AI Services
+groq==0.8.0
+huggingface_hub==0.26.2
+
+# Database & Vector
+chromadb==0.5.5
+qdrant-client==1.12.1
+firebase-admin==6.5.0
+
+# Deployment
+boto3==1.35.36
+python-gitlab==1.18.0
+
+# Utilities
+pydantic==2.9.2
+pydantic-settings==2.5.2
+python-dotenv==1.0.1
+httpx==0.27.2
+tenacity==9.0.0
+tiktoken==0.7.0
+
+# Zip & File handling
+zipfile36==0.1.3
+python-magic==0.4.27
+
+# Security
+rate-limit==0.7.1
+slowapi==0.1.9
+
+# Testing
+pytest==8.3.3
+pytest-asyncio==0.24.0
+pytest-cov==5.0.0
+httpx==0.27.2
+
+# Development
+black==24.8.0
+ruff==0.6.9
+mypy==1.11.2

backend/src/api/agents/skill/orchestrator.py

@@ -0,0 +1,39 @@
+"""Skill Agent Orchestrator"""
+from typing import Dict, Any, List, Optional
+from src.services.groq_service import generate_response
+from src.api.core.logger import logger
+
+
+class SkillOrchestrator:
+    def __init__(self):
+        self.available_skills = {
+            "code_review": "Review code for bugs, security issues, and best practices",
+            "bug_detection": "Find and analyze bugs in code",
+            "documentation": "Generate documentation for code",
+            "refactoring": "Suggest code improvements and refactoring",
+        }
+    
+    async def execute(
+        self,
+        prompt: str,
+        skill_type: str,
+        context: Optional[Dict[str, Any]] = None,
+        tools: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        if skill_type not in self.available_skills:
+            raise ValueError(f"Unknown skill type: {skill_type}")
+        
+        messages = [
+            {
+                "role": "system",
+                "content": f"You are a skilled {skill_type} expert. {self.available_skills[skill_type]}"
+            },
+            {"role": "user", "content": prompt}
+        ]
+        
+        try:
+            result = await generate_response(messages)
+            return {"skill_type": skill_type, "result": result, "status": "success"}
+        except Exception as e:
+            logger.error(f"Skill execution failed: {e}")
+            raise

backend/src/api/agents/skill/router.py

@@ -0,0 +1,79 @@
+"""
+Skill Agent Router - API Endpoints
+"""
+from fastapi import APIRouter, HTTPException
+from typing import Dict, Any
+from src.models.agent_models import SkillRequest, SkillResponse, TaskStatus
+from src.api.agents.skill.orchestrator import SkillOrchestrator
+from src.api.core.logger import logger
+import time
+
+router = APIRouter()
+orchestrator = SkillOrchestrator()
+
+
+@router.post("/execute", response_model=SkillResponse)
+async def execute_skill(request: SkillRequest) -> SkillResponse:
+    """
+    Execute a skill agent task
+    
+    - **prompt**: The task description
+    - **skill_type**: Type of skill (code_review, bug_detection, documentation, etc.)
+    - **context**: Optional context data
+    - **tools**: Optional list of available tools
+    """
+    start_time = time.time()
+    
+    try:
+        logger.info(f"Executing skill: {request.skill_type}")
+        
+        result = await orchestrator.execute(
+            prompt=request.prompt,
+            skill_type=request.skill_type,
+            context=request.context,
+            tools=request.tools,
+        )
+        
+        execution_time = time.time() - start_time
+        
+        return SkillResponse(
+            status=TaskStatus.COMPLETED,
+            result=result,
+            execution_time=execution_time,
+        )
+    
+    except Exception as e:
+        logger.error(f"Skill execution error: {str(e)}")
+        execution_time = time.time() - start_time
+        
+        return SkillResponse(
+            status=TaskStatus.FAILED,
+            error=str(e),
+            execution_time=execution_time,
+        )
+
+
+@router.get("/types")
+async def get_skill_types() -> Dict[str, Any]:
+    """Get available skill types"""
+    return {
+        "skills": [
+            {"id": "code_review", "name": "Code Review", "description": "Review code for issues"},
+            {"id": "bug_detection", "name": "Bug Detection", "description": "Find bugs in code"},
+            {"id": "documentation", "name": "Documentation", "description": "Generate documentation"},
+            {"id": "refactoring", "name": "Refactoring", "description": "Refactor code for better quality"},
+        ]
+    }
+
+
+@router.get("/tools")
+async def get_available_tools() -> Dict[str, Any]:
+    """Get available tools for skill execution"""
+    return {
+        "tools": [
+            {"id": "file_reader", "name": "File Reader", "description": "Read files from workspace"},
+            {"id": "file_writer", "name": "File Writer", "description": "Write files to workspace"},
+            {"id": "search", "name": "Search", "description": "Search in files"},
+            {"id": "git", "name": "Git", "description": "Git operations"},
+        ]
+    }

backend/src/api/core/logger.py

@@ -0,0 +1,15 @@
+"""
+Logger Configuration
+"""
+import logging
+import sys
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+logger = logging.getLogger("amkyawdev")

backend/src/app.py

@@ -0,0 +1,86 @@
+"""
+AmkyawDev Coder Backend - FastAPI Application Entry Point
+"""
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+
+from src.api.agents.skill.router import router as skill_router
+from src.api.agents.long_chain.router import router as long_chain_router
+from src.api.agents.script.router import router as script_router
+from src.api.systems.zip.router import router as zip_router
+from src.api.systems.deploy.router import router as deploy_router
+from src.api.systems.memory.router import router as memory_router
+from src.middleware.auth import AuthMiddleware
+from src.middleware.rate_limit import RateLimitMiddleware
+from src.config.settings import settings
+from src.api.core.logger import logger
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan events"""
+    logger.info("Starting AmkyawDev Coder Backend...")
+    logger.info(f"Environment: {settings.ENVIRONMENT}")
+    yield
+    logger.info("Shutting down AmkyawDev Coder Backend...")
+
+
+app = FastAPI(
+    title="AmkyawDev Coder Backend",
+    description="AI-Powered Development Platform Backend",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+# CORS Configuration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.CORS_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Custom Middleware
+app.add_middleware(AuthMiddleware)
+app.add_middleware(RateLimitMiddleware)
+
+# Include Routers
+app.include_router(skill_router, prefix="/api/agents/skill", tags=["Skill Agent"])
+app.include_router(long_chain_router, prefix="/api/agents/long-chain", tags=["Long Chain Agent"])
+app.include_router(script_router, prefix="/api/agents/script", tags=["Script Agent"])
+app.include_router(zip_router, prefix="/api/systems/zip", tags=["Zip System"])
+app.include_router(deploy_router, prefix="/api/systems/deploy", tags=["Deploy System"])
+app.include_router(memory_router, prefix="/api/systems/memory", tags=["Memory System"])
+
+
+@app.get("/")
+async def root():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "service": "AmkyawDev Coder Backend",
+        "version": "1.0.0"
+    }
+
+
+@app.get("/api/health")
+async def health_check():
+    """Detailed health check"""
+    return {
+        "status": "healthy",
+        "environment": settings.ENVIRONMENT,
+        "groq_configured": bool(settings.GROQ_API_KEY),
+        "hf_configured": bool(settings.HUGGINGFACE_API_KEY),
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "src.app:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=settings.ENVIRONMENT == "development"
+    )

backend/src/config/settings.py

@@ -0,0 +1,58 @@
+"""
+Application Settings - Environment Configuration
+"""
+from pydantic_settings import BaseSettings
+from typing import List
+from functools import lru_cache
+
+
+class Settings(BaseSettings):
+    # Application
+    APP_NAME: str = "AmkyawDev Coder Backend"
+    ENVIRONMENT: str = "development"
+    DEBUG: bool = True
+    
+    # CORS
+    CORS_ORIGINS: List[str] = ["*"]
+    
+    # Groq API
+    GROQ_API_KEY: str = ""
+    GROQ_MODEL: str = "llama-3.1-70b-versatile"
+    GROQ_BASE_URL: str = "https://api.groq.com/openai/v1"
+    
+    # Hugging Face
+    HUGGINGFACE_API_KEY: str = ""
+    HF_INFERENCE_ENDPOINT: str = ""
+    
+    # Firebase
+    FIREBASE_CREDENTIALS_PATH: str = ""
+    FIREBASE_DATABASE_URL: str = ""
+    
+    # Vector Database
+    CHROMA_HOST: str = "localhost"
+    CHROMA_PORT: int = 8000
+    
+    # Deployment
+    VERCEL_TOKEN: str = ""
+    NETLIFY_TOKEN: str = ""
+    AWS_ACCESS_KEY_ID: str = ""
+    AWS_SECRET_ACCESS_KEY: str = ""
+    
+    # Rate Limiting
+    RATE_LIMIT_PER_MINUTE: int = 60
+    
+    # Memory
+    MEMORY_MAX_TOKENS: int = 4096
+    MEMORY_VECTOR_DIMENSION: int = 768
+
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+
+
+@lru_cache()
+def get_settings() -> Settings:
+    return Settings()
+
+
+settings = get_settings()

backend/src/middleware/auth.py

@@ -0,0 +1,20 @@
+"""
+Authentication Middleware
+"""
+from fastapi import Request, HTTPException
+from starlette.middleware.base import BaseHTTPMiddleware
+from src.api.core.logger import logger
+
+
+class AuthMiddleware(BaseHTTPMiddleware):
+    """Simple authentication middleware"""
+    
+    async def dispatch(self, request: Request, call_next):
+        # Skip auth for health endpoints
+        if request.url.path in ["/", "/api/health"]:
+            return await call_next(request)
+        
+        # TODO: Implement Firebase auth token verification
+        # For now, allow all requests
+        response = await call_next(request)
+        return response

backend/src/middleware/rate_limit.py

@@ -0,0 +1,15 @@
+"""
+Rate Limiting Middleware
+"""
+from fastapi import Request
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+from slowapi.middleware import SlowAPIMiddleware
+from src.config.settings import settings
+
+limiter = Limiter(key_func=get_remote_address)
+
+
+class RateLimitMiddleware(SlowAPIMiddleware):
+    """Rate limiting middleware"""
+    pass

backend/src/models/agent_models.py

@@ -0,0 +1,69 @@
+"""
+Agent Models - Pydantic Models for Agents
+"""
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict, Any
+from enum import Enum
+
+
+class AgentType(str, Enum):
+    SKILL = "skill"
+    LONG_CHAIN = "long_chain"
+    SCRIPT = "script"
+
+
+class TaskStatus(str, Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class SkillRequest(BaseModel):
+    """Request model for Skill Agent"""
+    prompt: str = Field(..., description="The task prompt")
+    skill_type: str = Field(..., description="Type of skill to execute")
+    context: Optional[Dict[str, Any]] = Field(default=None, description="Additional context")
+    tools: Optional[List[str]] = Field(default=None, description="Available tools")
+
+
+class SkillResponse(BaseModel):
+    """Response model for Skill Agent"""
+    status: TaskStatus
+    result: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+    execution_time: float = 0.0
+
+
+class ChainRequest(BaseModel):
+    """Request model for Long Chain Agent"""
+    workflow: str = Field(..., description="Workflow name or definition")
+    input_data: Dict[str, Any] = Field(..., description="Input data for workflow")
+    steps: Optional[List[str]] = Field(default=None, description="Specific steps to execute")
+
+
+class ChainResponse(BaseModel):
+    """Response model for Long Chain Agent"""
+    status: TaskStatus
+    workflow: str
+    steps_completed: List[Dict[str, Any]] = []
+    final_result: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+    total_time: float = 0.0
+
+
+class ScriptRequest(BaseModel):
+    """Request model for Script Agent"""
+    language: str = Field(default="python", description="Programming language")
+    prompt: str = Field(..., description="Code generation prompt")
+    template: Optional[str] = Field(default=None, description="Code template to use")
+    optimize: bool = Field(default=False, description="Whether to optimize the code")
+
+
+class ScriptResponse(BaseModel):
+    """Response model for Script Agent"""
+    status: TaskStatus
+    code: Optional[str] = None
+    language: str
+    explanation: Optional[str] = None
+    error: Optional[str] = None

backend/src/services/groq_service.py

@@ -0,0 +1,82 @@
+"""
+Groq API Service - LLM Integration
+"""
+from groq import Groq
+from typing import Optional, List, Dict, Any
+from src.config.settings import settings
+from src.api.core.logger import logger
+
+client: Optional[Groq] = None
+
+
+def get_groq_client() -> Groq:
+    """Get or create Groq client instance"""
+    global client
+    if client is None:
+        client = Groq(api_key=settings.GROQ_API_KEY)
+    return client
+
+
+async def generate_response(
+    messages: List[Dict[str, str]],
+    model: str = None,
+    temperature: float = 0.7,
+    max_tokens: int = 4096,
+) -> str:
+    """
+    Generate response using Groq API
+    
+    Args:
+        messages: List of message dicts with 'role' and 'content'
+        model: Model name (defaults to settings.GROQ_MODEL)
+        temperature: Sampling temperature
+        max_tokens: Maximum tokens to generate
+    
+    Returns:
+        Generated response string
+    """
+    try:
+        groq_client = get_groq_client()
+        model = model or settings.GROQ_MODEL
+        
+        response = groq_client.chat.completions.create(
+            model=model,
+            messages=messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+        
+        return response.choices[0].message.content
+    
+    except Exception as e:
+        logger.error(f"Groq API error: {str(e)}")
+        raise
+
+
+async def stream_response(
+    messages: List[Dict[str, str]],
+    model: str = None,
+    temperature: float = 0.7,
+) -> str:
+    """Stream response from Groq API"""
+    try:
+        groq_client = get_groq_client()
+        model = model or settings.GROQ_MODEL
+        
+        stream = groq_client.chat.completions.create(
+            model=model,
+            messages=messages,
+            temperature=temperature,
+            stream=True,
+        )
+        
+        full_response = ""
+        for chunk in stream:
+            if chunk.choices[0].delta.content:
+                full_response += chunk.choices[0].delta.content
+        
+        return full_response
+    
+    except Exception as e:
+        logger.error(f"Groq streaming error: {str(e)}")
+        raise