Delete backend

backend/__init__.py

@@ -1 +0,0 @@
-"""AutoForge backend package."""

backend/agents/__init__.py

@@ -1 +0,0 @@
-"""AutoForge agents package."""

backend/analysis/__init__.py

@@ -1 +0,0 @@
-"""AutoForge analysis package."""

backend/api/__init__.py

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

backend/api/auth.py

@@ -1,110 +0,0 @@
-"""Authentication API: signup, login, and current-user retrieval."""
-
-from datetime import datetime, timedelta, timezone
-
-from fastapi import APIRouter, Depends, HTTPException, status
-from jose import jwt
-from passlib.context import CryptContext
-from pydantic import BaseModel, EmailStr, Field
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from backend.api.deps import get_current_user, get_db
-from backend.config.settings import get_settings
-from backend.db.models import User
-from backend.db.repository import create_user, get_user_by_email, get_user_by_username
-
-router = APIRouter(prefix="/api/auth", tags=["auth"])
-
-pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
-
-
-# ── Schemas ──────────────────────────────────────────────────────────
-
-class SignupRequest(BaseModel):
-    username: str = Field(..., min_length=3, max_length=80)
-    email: EmailStr
-    password: str = Field(..., min_length=6)
-
-
-class LoginRequest(BaseModel):
-    username: str
-    password: str
-
-
-class TokenResponse(BaseModel):
-    access_token: str
-    token_type: str = "bearer"
-
-
-class UserResponse(BaseModel):
-    id: str
-    username: str
-    email: str
-    created_at: datetime
-
-    model_config = {"from_attributes": True}
-
-
-# ── Helpers ──────────────────────────────────────────────────────────
-
-def _hash_password(password: str) -> str:
-    return pwd_context.hash(password)
-
-
-def _verify_password(plain: str, hashed: str) -> bool:
-    return pwd_context.verify(plain, hashed)
-
-
-def _create_token(user_id: str) -> str:
-    settings = get_settings()
-    expire = datetime.now(timezone.utc) + timedelta(minutes=settings.jwt_expire_minutes)
-    payload = {"sub": user_id, "exp": expire}
-    return jwt.encode(payload, settings.secret_key, algorithm=settings.jwt_algorithm)
-
-
-# ── Routes ───────────────────────────────────────────────────────────
-
-@router.post("/signup", response_model=TokenResponse, status_code=status.HTTP_201_CREATED)
-async def signup(body: SignupRequest, session: AsyncSession = Depends(get_db)):
-    """Register a new user account."""
-    # Check for duplicate username
-    if await get_user_by_username(session, body.username):
-        raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT,
-            detail="Username already taken",
-        )
-
-    # Check for duplicate email
-    if await get_user_by_email(session, body.email):
-        raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT,
-            detail="Email already registered",
-        )
-
-    user = await create_user(
-        session,
-        username=body.username,
-        email=body.email,
-        hashed_password=_hash_password(body.password),
-    )
-
-    return TokenResponse(access_token=_create_token(user.id))
-
-
-@router.post("/login", response_model=TokenResponse)
-async def login(body: LoginRequest, session: AsyncSession = Depends(get_db)):
-    """Authenticate and receive a JWT."""
-    user = await get_user_by_username(session, body.username)
-    if not user or not _verify_password(body.password, user.hashed_password):
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid username or password",
-        )
-
-    return TokenResponse(access_token=_create_token(user.id))
-
-
-@router.get("/me", response_model=UserResponse)
-async def me(current_user: User = Depends(get_current_user)):
-    """Return the currently authenticated user."""
-    return current_user

backend/api/dependencies.py

@@ -1,49 +0,0 @@
-"""
-Authentication dependencies for FastAPI.
-
-Extracts and validates JWT from the Authorization header.
-"""
-
-from fastapi import Depends, HTTPException, status
-from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
-from jose import JWTError, jwt
-from sqlalchemy.orm import Session
-
-from backend.config.settings import get_settings
-from backend.db.database import get_db
-from backend.db.models import User
-
-security = HTTPBearer()
-
-
-def get_current_user(
-    credentials: HTTPAuthorizationCredentials = Depends(security),
-    db: Session = Depends(get_db),
-) -> User:
-    """Decode the JWT and return the authenticated User, or raise 401."""
-    settings = get_settings()
-    token = credentials.credentials
-
-    credentials_exception = HTTPException(
-        status_code=status.HTTP_401_UNAUTHORIZED,
-        detail="Invalid or expired token",
-        headers={"WWW-Authenticate": "Bearer"},
-    )
-
-    try:
-        payload = jwt.decode(
-            token,
-            settings.SECRET_KEY,
-            algorithms=[settings.JWT_ALGORITHM],
-        )
-        user_id: int | None = payload.get("sub")
-        if user_id is None:
-            raise credentials_exception
-    except JWTError:
-        raise credentials_exception
-
-    user = db.query(User).filter(User.id == int(user_id)).first()
-    if user is None:
-        raise credentials_exception
-
-    return user

backend/api/deps.py

@@ -1,46 +0,0 @@
-"""Shared FastAPI dependencies."""
-
-from fastapi import Depends, HTTPException, status
-from fastapi.security import OAuth2PasswordBearer
-from jose import JWTError, jwt
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from backend.config.settings import get_settings
-from backend.db.database import async_session_factory
-from backend.db.repository import get_user_by_id
-
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/login")
-
-
-async def get_db() -> AsyncSession:
-    """Yield an async database session for request scope."""
-    async with async_session_factory() as session:
-        yield session
-
-
-async def get_current_user(
-    token: str = Depends(oauth2_scheme),
-    session: AsyncSession = Depends(get_db),
-):
-    """Decode JWT and return the authenticated user."""
-    settings = get_settings()
-    credentials_exception = HTTPException(
-        status_code=status.HTTP_401_UNAUTHORIZED,
-        detail="Invalid or expired token",
-        headers={"WWW-Authenticate": "Bearer"},
-    )
-
-    try:
-        payload = jwt.decode(
-            token, settings.secret_key, algorithms=[settings.jwt_algorithm]
-        )
-        user_id: str = payload.get("sub")
-        if user_id is None:
-            raise credentials_exception
-    except JWTError:
-        raise credentials_exception
-
-    user = await get_user_by_id(session, user_id)
-    if user is None:
-        raise credentials_exception
-    return user

backend/api/health.py

@@ -1,17 +0,0 @@
-"""Health check endpoint."""
-
-from fastapi import APIRouter
-from pydantic import BaseModel
-
-router = APIRouter(tags=["health"])
-
-
-class HealthResponse(BaseModel):
-    status: str
-    version: str
-
-
-@router.get("/health", response_model=HealthResponse)
-async def health():
-    """Return application health status."""
-    return HealthResponse(status="ok", version="0.1.0")

backend/api/workflows.py

@@ -1,81 +0,0 @@
-"""Workflow API endpoints."""
-
-from datetime import datetime
-from typing import Optional
-
-from fastapi import APIRouter, Depends, HTTPException, status
-from pydantic import BaseModel, Field
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from backend.api.deps import get_current_user, get_db
-from backend.db.models import User
-from backend.db.repository import create_workflow, get_workflow_by_id, get_workflows_by_user
-
-router = APIRouter(prefix="/api/workflows", tags=["workflows"])
-
-
-# ── Schemas ──────────────────────────────────────────────────────────
-
-class WorkflowCreateRequest(BaseModel):
-    prompt: str = Field(..., min_length=1)
-
-
-class TaskResponse(BaseModel):
-    id: str
-    task_type: str
-    status: str
-    created_at: datetime
-
-    model_config = {"from_attributes": True}
-
-
-class WorkflowResponse(BaseModel):
-    id: str
-    prompt: str
-    status: str
-    created_at: datetime
-    updated_at: datetime
-
-    model_config = {"from_attributes": True}
-
-
-class WorkflowDetailResponse(WorkflowResponse):
-    tasks: list[TaskResponse] = []
-
-
-# ── Routes ───────────────────────────────────────────────────────────
-
-@router.post("", response_model=WorkflowResponse, status_code=status.HTTP_201_CREATED)
-async def create(
-    body: WorkflowCreateRequest,
-    current_user: User = Depends(get_current_user),
-    session: AsyncSession = Depends(get_db),
-):
-    """Create a new workflow (status=pending, no execution yet)."""
-    workflow = await create_workflow(session, user_id=current_user.id, prompt=body.prompt)
-    return workflow
-
-
-@router.get("", response_model=list[WorkflowResponse])
-async def list_workflows(
-    current_user: User = Depends(get_current_user),
-    session: AsyncSession = Depends(get_db),
-):
-    """List all workflows for the current user."""
-    workflows = await get_workflows_by_user(session, current_user.id)
-    return workflows
-
-
-@router.get("/{workflow_id}", response_model=WorkflowDetailResponse)
-async def get_workflow(
-    workflow_id: str,
-    current_user: User = Depends(get_current_user),
-    session: AsyncSession = Depends(get_db),
-):
-    """Get a single workflow with its tasks."""
-    workflow = await get_workflow_by_id(session, workflow_id)
-    if not workflow:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Workflow not found")
-    if workflow.user_id != current_user.id:
-        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Access denied")
-    return workflow

backend/config/__init__.py

@@ -1 +0,0 @@
-"""AutoForge configuration package."""

backend/config/settings.py

@@ -1,39 +0,0 @@
-"""Application settings loaded from environment variables."""
-
-from pydantic_settings import BaseSettings
-from pydantic import Field
-
-
-class Settings(BaseSettings):
-    """AutoForge configuration."""
-
-    # Application
-    secret_key: str = Field(default="change-this-to-a-random-secret-key")
-    debug: bool = Field(default=True)
-    host: str = Field(default="0.0.0.0")
-    port: int = Field(default=8000)
-
-    # Database
-    database_url: str = Field(default="sqlite+aiosqlite:///data/autoforge.db")
-
-    # Gemini LLM
-    gemini_api_key: str = Field(default="")
-    gemini_model: str = Field(default="gemini-2.0-flash")
-
-    # Docker
-    docker_enabled: bool = Field(default=False)
-
-    # JWT
-    jwt_algorithm: str = Field(default="HS256")
-    jwt_expire_minutes: int = Field(default=1440)  # 24 hours
-
-    model_config = {
-        "env_file": ".env",
-        "env_file_encoding": "utf-8",
-        "case_sensitive": False,
-    }
-
-
-def get_settings() -> Settings:
-    """Return application settings singleton."""
-    return Settings()

backend/db/__init__.py

@@ -1 +0,0 @@
-"""AutoForge database package."""

backend/db/database.py

@@ -1,41 +0,0 @@
-"""SQLAlchemy async database engine and session management."""
-
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
-from sqlalchemy.orm import DeclarativeBase
-
-from backend.config.settings import get_settings
-
-
-class Base(DeclarativeBase):
-    """SQLAlchemy declarative base for all models."""
-    pass
-
-
-_settings = get_settings()
-
-engine = create_async_engine(
-    _settings.database_url,
-    echo=_settings.debug,
-    connect_args={"check_same_thread": False},
-)
-
-async_session_factory = async_sessionmaker(
-    engine,
-    class_=AsyncSession,
-    expire_on_commit=False,
-)
-
-
-async def init_db() -> None:
-    """Create all database tables."""
-    # Import models so they register with Base.metadata
-    import backend.db.models  # noqa: F401
-
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)
-
-
-async def get_async_session() -> AsyncSession:
-    """Yield an async database session."""
-    async with async_session_factory() as session:
-        yield session

backend/db/models.py

@@ -1,109 +0,0 @@
-"""SQLAlchemy ORM models for AutoForge."""
-
-import uuid
-from datetime import datetime, timezone
-
-from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, Text
-from sqlalchemy.orm import relationship
-
-from backend.db.database import Base
-
-
-def _utcnow() -> datetime:
-    return datetime.now(timezone.utc)
-
-
-def _generate_uuid() -> str:
-    return str(uuid.uuid4())
-
-
-class User(Base):
-    """User account."""
-
-    __tablename__ = "users"
-
-    id = Column(String(36), primary_key=True, default=_generate_uuid)
-    username = Column(String(80), unique=True, nullable=False, index=True)
-    email = Column(String(255), unique=True, nullable=False, index=True)
-    hashed_password = Column(String(255), nullable=False)
-    created_at = Column(DateTime(timezone=True), default=_utcnow, nullable=False)
-
-    workflows = relationship("Workflow", back_populates="user", lazy="selectin")
-
-    def __repr__(self) -> str:
-        return f"<User {self.username}>"
-
-
-class Workflow(Base):
-    """A code-generation workflow initiated by a user."""
-
-    __tablename__ = "workflows"
-
-    id = Column(String(36), primary_key=True, default=_generate_uuid)
-    user_id = Column(String(36), ForeignKey("users.id"), nullable=False, index=True)
-    prompt = Column(Text, nullable=False)
-    status = Column(String(20), nullable=False, default="pending")
-    created_at = Column(DateTime(timezone=True), default=_utcnow, nullable=False)
-    updated_at = Column(DateTime(timezone=True), default=_utcnow, onupdate=_utcnow, nullable=False)
-
-    user = relationship("User", back_populates="workflows")
-    tasks = relationship("Task", back_populates="workflow", lazy="selectin")
-    events = relationship("Event", back_populates="workflow", lazy="selectin")
-
-    def __repr__(self) -> str:
-        return f"<Workflow {self.id} [{self.status}]>"
-
-
-class Task(Base):
-    """A single task within a workflow DAG."""
-
-    __tablename__ = "tasks"
-
-    id = Column(String(36), primary_key=True, default=_generate_uuid)
-    workflow_id = Column(String(36), ForeignKey("workflows.id"), nullable=False, index=True)
-    task_type = Column(String(50), nullable=False)
-    status = Column(String(20), nullable=False, default="pending")
-    input_data = Column(Text, nullable=True)
-    output_data = Column(Text, nullable=True)
-    created_at = Column(DateTime(timezone=True), default=_utcnow, nullable=False)
-
-    workflow = relationship("Workflow", back_populates="tasks")
-    attempts = relationship("Attempt", back_populates="task", lazy="selectin")
-
-    def __repr__(self) -> str:
-        return f"<Task {self.id} [{self.task_type}]>"
-
-
-class Attempt(Base):
-    """A single execution attempt for a task (supports retry logic)."""
-
-    __tablename__ = "attempts"
-
-    id = Column(String(36), primary_key=True, default=_generate_uuid)
-    task_id = Column(String(36), ForeignKey("tasks.id"), nullable=False, index=True)
-    attempt_number = Column(Integer, nullable=False, default=1)
-    status = Column(String(20), nullable=False, default="pending")
-    error_message = Column(Text, nullable=True)
-    created_at = Column(DateTime(timezone=True), default=_utcnow, nullable=False)
-
-    task = relationship("Task", back_populates="attempts")
-
-    def __repr__(self) -> str:
-        return f"<Attempt {self.id} #{self.attempt_number}>"
-
-
-class Event(Base):
-    """A workflow event for streaming to the frontend."""
-
-    __tablename__ = "events"
-
-    id = Column(String(36), primary_key=True, default=_generate_uuid)
-    workflow_id = Column(String(36), ForeignKey("workflows.id"), nullable=False, index=True)
-    event_type = Column(String(50), nullable=False)
-    payload = Column(Text, nullable=True)
-    created_at = Column(DateTime(timezone=True), default=_utcnow, nullable=False)
-
-    workflow = relationship("Workflow", back_populates="events")
-
-    def __repr__(self) -> str:
-        return f"<Event {self.id} [{self.event_type}]>"

backend/db/repository.py

@@ -1,124 +0,0 @@
-"""Repository layer for database CRUD operations."""
-
-from typing import Optional
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from backend.db.models import Attempt, Event, Task, User, Workflow
-
-
-# ── User operations ──────────────────────────────────────────────────
-
-async def create_user(
-    session: AsyncSession,
-    username: str,
-    email: str,
-    hashed_password: str,
-) -> User:
-    """Create and persist a new user."""
-    user = User(
-        username=username,
-        email=email,
-        hashed_password=hashed_password,
-    )
-    session.add(user)
-    await session.commit()
-    await session.refresh(user)
-    return user
-
-
-async def get_user_by_username(session: AsyncSession, username: str) -> Optional[User]:
-    """Look up a user by username."""
-    result = await session.execute(select(User).where(User.username == username))
-    return result.scalar_one_or_none()
-
-
-async def get_user_by_email(session: AsyncSession, email: str) -> Optional[User]:
-    """Look up a user by email."""
-    result = await session.execute(select(User).where(User.email == email))
-    return result.scalar_one_or_none()
-
-
-async def get_user_by_id(session: AsyncSession, user_id: str) -> Optional[User]:
-    """Look up a user by ID."""
-    result = await session.execute(select(User).where(User.id == user_id))
-    return result.scalar_one_or_none()
-
-
-# ── Workflow operations ──────────────────────────────────────────────
-
-async def create_workflow(
-    session: AsyncSession,
-    user_id: str,
-    prompt: str,
-) -> Workflow:
-    """Create a new workflow record."""
-    workflow = Workflow(user_id=user_id, prompt=prompt)
-    session.add(workflow)
-    await session.commit()
-    await session.refresh(workflow)
-    return workflow
-
-
-async def get_workflows_by_user(session: AsyncSession, user_id: str) -> list[Workflow]:
-    """Return all workflows for a given user, newest first."""
-    result = await session.execute(
-        select(Workflow)
-        .where(Workflow.user_id == user_id)
-        .order_by(Workflow.created_at.desc())
-    )
-    return list(result.scalars().all())
-
-
-async def get_workflow_by_id(session: AsyncSession, workflow_id: str) -> Optional[Workflow]:
-    """Return a single workflow by ID."""
-    result = await session.execute(select(Workflow).where(Workflow.id == workflow_id))
-    return result.scalar_one_or_none()
-
-
-# ── Task operations ──────────────────────────────────────────────────
-
-async def create_task(
-    session: AsyncSession,
-    workflow_id: str,
-    task_type: str,
-    input_data: Optional[str] = None,
-) -> Task:
-    """Create a new task within a workflow."""
-    task = Task(workflow_id=workflow_id, task_type=task_type, input_data=input_data)
-    session.add(task)
-    await session.commit()
-    await session.refresh(task)
-    return task
-
-
-# ── Attempt operations ───────────────────────────────────────────────
-
-async def create_attempt(
-    session: AsyncSession,
-    task_id: str,
-    attempt_number: int = 1,
-) -> Attempt:
-    """Create an execution attempt for a task."""
-    attempt = Attempt(task_id=task_id, attempt_number=attempt_number)
-    session.add(attempt)
-    await session.commit()
-    await session.refresh(attempt)
-    return attempt
-
-
-# ── Event operations ─────────────────────────────────────────────────
-
-async def create_event(
-    session: AsyncSession,
-    workflow_id: str,
-    event_type: str,
-    payload: Optional[str] = None,
-) -> Event:
-    """Create a workflow event."""
-    event = Event(workflow_id=workflow_id, event_type=event_type, payload=payload)
-    session.add(event)
-    await session.commit()
-    await session.refresh(event)
-    return event

backend/events/__init__.py

@@ -1 +0,0 @@
-"""AutoForge events package."""

backend/execution/__init__.py

@@ -1 +0,0 @@
-"""AutoForge execution package."""

backend/llm/__init__.py

@@ -1 +0,0 @@
-# AutoForge LLM Providers

backend/llm/gemini.py

@@ -1,121 +0,0 @@
-"""Google Gemini LLM provider."""
-
-import json
-from typing import Any, Optional
-
-import httpx
-
-from backend.config.settings import get_settings
-from backend.llm.provider import LLMProvider
-
-
-class GeminiProviderError(Exception):
-    """Raised when the Gemini API returns an error."""
-    pass
-
-
-class GeminiNotConfiguredError(GeminiProviderError):
-    """Raised when the Gemini API key is not set."""
-    pass
-
-
-class GeminiProvider(LLMProvider):
-    """LLM provider backed by Google Gemini.
-
-    Reads ``GEMINI_API_KEY`` and ``GEMINI_MODEL`` from application
-    settings.  Communicates with the Gemini REST API via ``httpx``.
-    """
-
-    BASE_URL = "https://generativelanguage.googleapis.com/v1beta"
-
-    def __init__(self) -> None:
-        settings = get_settings()
-        self.api_key = settings.gemini_api_key
-        self.model = settings.gemini_model
-
-        if not self.api_key:
-            raise GeminiNotConfiguredError(
-                "GEMINI_API_KEY is not set. "
-                "Please configure it in your .env file."
-            )
-
-    # ── Public API ───────────────────────────────────────────────────
-
-    async def generate(
-        self,
-        prompt: str,
-        *,
-        system_prompt: Optional[str] = None,
-        temperature: float = 0.7,
-        max_tokens: int = 4096,
-    ) -> str:
-        """Send a prompt to Gemini and return the generated text."""
-        contents = []
-        if system_prompt:
-            contents.append({"role": "user", "parts": [{"text": system_prompt}]})
-            contents.append({"role": "model", "parts": [{"text": "Understood."}]})
-        contents.append({"role": "user", "parts": [{"text": prompt}]})
-
-        body = {
-            "contents": contents,
-            "generationConfig": {
-                "temperature": temperature,
-                "maxOutputTokens": max_tokens,
-            },
-        }
-
-        data = await self._request(body)
-        return self._extract_text(data)
-
-    async def generate_structured(
-        self,
-        prompt: str,
-        schema: dict[str, Any],
-        *,
-        system_prompt: Optional[str] = None,
-    ) -> dict[str, Any]:
-        """Send a prompt to Gemini and parse the response as JSON."""
-        schema_instruction = (
-            f"Respond ONLY with valid JSON matching this schema:\n"
-            f"```json\n{json.dumps(schema, indent=2)}\n```"
-        )
-        full_prompt = f"{prompt}\n\n{schema_instruction}"
-        raw = await self.generate(full_prompt, system_prompt=system_prompt, temperature=0.2)
-
-        # Strip markdown code fences if present
-        text = raw.strip()
-        if text.startswith("```"):
-            text = text.split("\n", 1)[1] if "\n" in text else text[3:]
-        if text.endswith("```"):
-            text = text[:-3]
-        text = text.strip()
-
-        try:
-            return json.loads(text)
-        except json.JSONDecodeError as exc:
-            raise GeminiProviderError(f"Failed to parse Gemini response as JSON: {exc}")
-
-    # ── Internals ────────────────────────────────────────────────────
-
-    async def _request(self, body: dict) -> dict:
-        """Make a POST request to the Gemini generateContent endpoint."""
-        url = (
-            f"{self.BASE_URL}/models/{self.model}:generateContent"
-            f"?key={self.api_key}"
-        )
-
-        async with httpx.AsyncClient(timeout=60.0) as client:
-            response = await client.post(url, json=body)
-            if response.status_code != 200:
-                raise GeminiProviderError(
-                    f"Gemini API error {response.status_code}: {response.text}"
-                )
-            return response.json()
-
-    @staticmethod
-    def _extract_text(data: dict) -> str:
-        """Extract generated text from the Gemini response payload."""
-        try:
-            return data["candidates"][0]["content"]["parts"][0]["text"]
-        except (KeyError, IndexError) as exc:
-            raise GeminiProviderError(f"Unexpected Gemini response structure: {exc}")

backend/llm/provider.py

@@ -1,55 +0,0 @@
-"""Abstract LLM provider interface."""
-
-from abc import ABC, abstractmethod
-from typing import Any, Optional
-
-
-class LLMProvider(ABC):
-    """Base class for all LLM providers.
-
-    Every concrete provider must implement ``generate`` and
-    ``generate_structured`` so the rest of AutoForge can remain
-    provider-agnostic.
-    """
-
-    @abstractmethod
-    async def generate(
-        self,
-        prompt: str,
-        *,
-        system_prompt: Optional[str] = None,
-        temperature: float = 0.7,
-        max_tokens: int = 4096,
-    ) -> str:
-        """Generate a free-form text completion.
-
-        Args:
-            prompt: The user-facing prompt.
-            system_prompt: Optional system-level instruction.
-            temperature: Sampling temperature.
-            max_tokens: Maximum tokens in the response.
-
-        Returns:
-            The generated text.
-        """
-        ...
-
-    @abstractmethod
-    async def generate_structured(
-        self,
-        prompt: str,
-        schema: dict[str, Any],
-        *,
-        system_prompt: Optional[str] = None,
-    ) -> dict[str, Any]:
-        """Generate output conforming to a JSON schema.
-
-        Args:
-            prompt: The user-facing prompt.
-            schema: A JSON Schema the response must match.
-            system_prompt: Optional system-level instruction.
-
-        Returns:
-            A dictionary matching the provided schema.
-        """
-        ...

backend/main.py

@@ -1,64 +0,0 @@
-"""AutoForge FastAPI application entry point."""
-
-import os
-from contextlib import asynccontextmanager
-from pathlib import Path
-
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-
-from backend.api.auth import router as auth_router
-from backend.api.health import router as health_router
-from backend.api.workflows import router as workflows_router
-from backend.config.settings import get_settings
-from backend.db.database import init_db
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Startup and shutdown lifecycle."""
-    # Ensure data directory exists
-    os.makedirs("data", exist_ok=True)
-    # Initialize database tables
-    await init_db()
-    yield
-
-
-app = FastAPI(
-    title="AutoForge",
-    description="Autonomous AI coding system",
-    version="0.1.0",
-    lifespan=lifespan,
-)
-
-# CORS — permissive for local development
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# API routers
-app.include_router(health_router)
-app.include_router(auth_router)
-app.include_router(workflows_router)
-
-# Serve frontend static files
-frontend_path = Path(__file__).resolve().parent.parent / "frontend"
-if frontend_path.is_dir():
-    app.mount("/", StaticFiles(directory=str(frontend_path), html=True), name="frontend")
-
-
-if __name__ == "__main__":
-    import uvicorn
-
-    settings = get_settings()
-    uvicorn.run(
-        "backend.main:app",
-        host=settings.host,
-        port=settings.port,
-        reload=settings.debug,
-    )

backend/orchestration/__init__.py

@@ -1 +0,0 @@
-"""AutoForge orchestration package."""