refactor: Separate prepare and build into independent microservices

Convert to true microservices architecture where prepare and build
services have COMPLETELY SEPARATE CODEBASES with NO shared code.
Services communicate ONLY via HTTP.

```
/
├── asu/                # Build service (heavy, existing codebase)
│   └── Calls prepare service via HTTP
└── asu-prepare/        # Prepare service (NEW, separate codebase)
    ├── main.py
    ├── build_request.py
    ├── package_changes.py
    ├── package_resolution.py
    ├── config.py
    └── Containerfile
```

NEW completely independent microservice for package resolution:

**Files Created:**
- `asu-prepare/main.py` - Standalone FastAPI app (170 lines)
- `asu-prepare/build_request.py` - Data models (175 lines)
- `asu-prepare/package_changes.py` - Migration logic (copied, 198 lines)
- `asu-prepare/package_resolution.py` - Resolution (copied, 195 lines)
- `asu-prepare/config.py` - Minimal config (35 lines)
- `asu-prepare/pyproject.toml` - Minimal dependencies
- `asu-prepare/Containerfile` - Lightweight container
- `asu-prepare/README.md` - Documentation

**Dependencies:** ONLY FastAPI, Pydantic, Uvicorn
**NO Dependencies on:** Redis, RQ, Podman, ImageBuilder, asu/*

**API:**
- `POST /api/v1/prepare` - Package resolution
- `GET /health` - Health check

**Resources:**
- 512MB RAM, 0.5 CPU
- <1s response time
- Completely stateless

Modified to call prepare service via HTTP:

**Modified Files:**
- `asu/routers/api.py`:
  - `/build/prepare` now proxies to prepare service via HTTP
  - Removed services imports
  - Restored original build logic
  - Added httpx for HTTP calls

- `asu/config.py`:
  - Added `prepare_service_url` setting
  - Default: `http://asu-prepare:8001`

**Deleted:**
- `asu/services/` directory (no longer sharing code)
- `Containerfile.prepare` (moved to asu-prepare/)
- `Containerfile.build` (using main Containerfile)

```
Build Service                Prepare Service
     │                              │
     ├─ HTTP POST /api/v1/prepare ─>│
     │                              ├─ Resolve packages
     │<─ JSON response ─────────────┤
     ├─ Add cache info              │
     └─ Return to client            │
```

Updated `podman-compose.microservices.yml`:
- Prepare service builds from `./asu-prepare/`
- Build service builds from `./ ` (main directory)
- Build service has `PREPARE_SERVICE_URL` env var
- Worker also has `PREPARE_SERVICE_URL`
- Services communicate via internal network

1. **No Shared Code**
   - Each service has its OWN copy of files
   - NO `from asu.X import Y` between services
   - Can version/deploy independently

2. **HTTP-Only Communication**
   - Services talk via HTTP API
   - Clear service boundaries
   - Could use different languages

3. **Code Duplication is OK**
   - Prefer duplication over coupling
   - Each service is self-contained
   - Independent evolution

✅ True microservices independence
✅ No import/dependency conflicts
✅ Can deploy services separately
✅ Scale services independently
✅ Could rewrite in different language
✅ Clear API contracts
✅ Fault isolation

```bash
podman-compose -f podman-compose.microservices.yml up -d

podman-compose up -d
```

- Updated `ARCHITECTURE.md` with new design
- Added `asu-prepare/README.md`
- Documented HTTP communication pattern
- Explained code duplication philosophy

This refactoring enables true microservices with complete independence,
allowing each service to be developed, tested, deployed, and scaled
separately with NO shared code dependencies.

Author: claude

ARCHITECTURE.md

@@ -0,0 +1,27 @@
+# Containerfile for ASU Prepare Service
+# Minimal, lightweight service with NO build dependencies
+
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install minimal dependencies only
+COPY pyproject.toml ./
+RUN pip install poetry && \
+    poetry config virtualenvs.create false && \
+    poetry install --only main --no-root --no-interaction --no-ansi && \
+    rm -rf ~/.cache/pypoetry
+
+# Copy prepare service code ONLY
+COPY *.py ./
+COPY README.md ./
+
+# Expose port
+EXPOSE 8001
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD python -c "import httpx; httpx.get('http://localhost:8001/health')" || exit 1
+
+# Run prepare service
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8001"]

Containerfile.build

@@ -0,0 +1,142 @@
+# ASU Prepare Service
+
+Lightweight microservice for OpenWrt firmware build request preparation.
+
+## Purpose
+
+This service handles **package resolution and validation** for OpenWrt firmware build requests. It runs completely independently from the build service and has NO dependencies on:
+
+- ❌ Redis/RQ (no queue management)
+- ❌ Podman (no container operations)
+- ❌ ImageBuilder (no firmware building)
+- ❌ Build infrastructure
+
+## What It Does
+
+✅ Validates build requests
+✅ Applies package changes/migrations (e.g., `auc` → `owut`)
+✅ Resolves hardware-specific package requirements
+✅ Returns prepared package lists for user approval
+✅ Tracks all changes made
+
+## API
+
+### POST /api/v1/prepare
+
+Prepare a build request without executing it.
+
+**Request:**
+```json
+{
+  "version": "24.10.0",
+  "target": "ath79/generic",
+  "profile": "tplink_archer-c7-v5",
+  "packages": ["luci", "auc"]
+}
+```
+
+**Response:**
+```json
+{
+  "status": "prepared",
+  "original_packages": ["luci", "auc"],
+  "resolved_packages": ["luci", "owut"],
+  "changes": [
+    {
+      "type": "migration",
+      "action": "replace",
+      "from_package": "auc",
+      "to_package": "owut",
+      "reason": "Package renamed in 24.10",
+      "automatic": true
+    }
+  ],
+  "prepared_request": { ... },
+  "request_hash": "abc123..."
+}
+```
+
+### GET /health
+
+Health check endpoint for load balancers.
+
+## Running
+
+### Development
+
+```bash
+cd asu-prepare
+poetry install
+poetry run uvicorn main:app --reload --port 8001
+```
+
+### Production (Docker/Podman)
+
+```bash
+podman build -t asu-prepare -f Containerfile .
+podman run -p 8001:8001 asu-prepare
+```
+
+## Dependencies
+
+Minimal dependencies (no heavy build tools):
+
+- FastAPI - Web framework
+- Uvicorn - ASGI server
+- Pydantic - Data validation
+
+## Resource Requirements
+
+- **CPU**: 0.5 cores
+- **RAM**: 512MB
+- **Response Time**: <1 second
+- **Scalability**: Horizontal (stateless)
+
+## Architecture
+
+This service is completely stateless and can be scaled horizontally:
+
+```
+Load Balancer
+      ↓
+  ┌───┴───┬───────┬───────┐
+  ↓       ↓       ↓       ↓
+Prepare Prepare Prepare Prepare
+  (1)     (2)     (3)     (4)
+```
+
+Each instance can handle requests independently.
+
+## Communication with Build Service
+
+The build service makes HTTP requests to this service:
+
+```python
+# In build service
+import httpx
+
+async with httpx.AsyncClient() as client:
+    response = await client.post(
+        "http://prepare-service:8001/api/v1/prepare",
+        json=build_request.model_dump()
+    )
+    prepared = response.json()
+```
+
+## Testing
+
+```bash
+poetry run pytest
+```
+
+## Configuration
+
+Environment variables:
+
+- `UPSTREAM_URL` - OpenWrt downloads URL (default: https://downloads.openwrt.org)
+- `MAX_DEFAULTS_LENGTH` - Max first-boot script size (default: 20480)
+- `MAX_CUSTOM_ROOTFS_SIZE_MB` - Max custom rootfs size (default: 1024)
+
+## License
+
+Same as ASU main project

Containerfile.prepare

@@ -0,0 +1,19 @@
+"""
+ASU Prepare Service - Independent Microservice
+
+This is a standalone microservice that handles package resolution and
+validation for OpenWrt firmware build requests.
+
+It does NOT:
+- Build firmware (no Podman, no ImageBuilder)
+- Queue jobs (no Redis, no RQ)
+- Store state (completely stateless)
+
+It DOES:
+- Validate build requests
+- Apply package changes/migrations
+- Return resolved package lists
+- Provide detailed change tracking
+"""
+
+__version__ = "1.0.0"

asu-prepare/Containerfile

@@ -0,0 +1,36 @@
+"""
+Minimal configuration for prepare service
+
+No Redis, No Podman, No build infrastructure.
+Only validation and package resolution settings.
+"""
+
+from pydantic_settings import BaseSettings
+
+
+class PrepareSettings(BaseSettings):
+    """Settings for the prepare service"""
+
+    # Defaults validation
+    max_defaults_length: int = 20480
+    max_custom_rootfs_size_mb: int = 1024
+
+    # Upstream for validation data
+    upstream_url: str = "https://downloads.openwrt.org"
+
+    # Service identification
+    service_name: str = "asu-prepare"
+    service_version: str = "1.0.0"
+
+    # Supported branches (simplified, could be loaded dynamically)
+    branches: dict[str, dict[str, str]] = {
+        "SNAPSHOT": {"name": "SNAPSHOT", "path": "snapshots"},
+        "24.10": {"name": "24.10", "path": "releases/{version}"},
+        "23.05": {"name": "23.05", "path": "releases/{version}"},
+        "22.03": {"name": "22.03", "path": "releases/{version}"},
+        "21.02": {"name": "21.02", "path": "releases/{version}"},
+    }
+
+
+# Global settings instance
+settings = PrepareSettings()