Initial commit

init_project.py

@@ -0,0 +1,795 @@
+#!/usr/bin/env python3
+"""
+Project initialization script for Firefly III Analytics
+Creates the complete directory structure and scaffolding
+"""
+
+import os
+import sys
+from pathlib import Path
+
+def create_dir(path):
+    """Create directory if it doesn't exist"""
+    Path(path).mkdir(parents=True, exist_ok=True)
+    print(f"✓ Created directory: {path}")
+
+def create_file(path, content):
+    """Create file with content"""
+    Path(path).parent.mkdir(parents=True, exist_ok=True)
+    with open(path, 'w', encoding='utf-8') as f:
+        f.write(content)
+    print(f"✓ Created file: {path}")
+
+# Backend files
+backend_pyproject = '''[project]
+name = "firefly-analytics-backend"
+version = "0.1.0"
+description = "Firefly III Analytics & Reporting Backend"
+requires-python = ">=3.11"
+
+dependencies = [
+    "fastapi==0.104.1",
+    "uvicorn[standard]==0.24.0",
+    "httpx==0.25.2",
+    "python-dotenv==1.0.0",
+    "pydantic==2.5.0",
+    "pydantic-settings==2.1.0",
+    "sqlalchemy==2.0.23",
+    "python-dateutil==2.8.2",
+    "apscheduler==3.10.4",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest==7.4.3",
+    "pytest-asyncio==0.21.1",
+    "black==23.12.0",
+    "ruff==0.1.8",
+]
+'''
+
+backend_dockerfile = '''FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \\
+    gcc \\
+    && rm -rf /var/lib/apt/lists/*
+
+COPY pyproject.toml pyproject.toml
+COPY app/ app/
+
+RUN pip install --no-cache-dir -e .
+RUN mkdir -p /app/data
+
+EXPOSE 8000
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]
+'''
+
+backend_config = '''"""
+Firefly III Analytics Backend - Configuration
+"""
+import os
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    """Application settings from environment variables"""
+    
+    # Firefly III
+    FIREFLY_URL: str = os.getenv("FIREFLY_URL", "https://firefly.scsimedia.duckdns.org")
+    FIREFLY_API_TOKEN: str = os.getenv("FIREFLY_API_TOKEN", "")
+    
+    # Database
+    DATABASE_URL: str = os.getenv("DATABASE_URL", "sqlite:///./data/app.db")
+    
+    # Sync
+    SYNC_INTERVAL_MINUTES: int = int(os.getenv("SYNC_INTERVAL_MINUTES", "30"))
+    
+    # API
+    API_TIMEOUT: int = 30
+    
+    class Config:
+        env_file = ".env"
+
+settings = Settings()
+'''
+
+backend_models = '''"""
+Database models for Firefly III Analytics
+"""
+from sqlalchemy import Column, Integer, String, Float, DateTime, Boolean, Text, ForeignKey
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import relationship
+from datetime import datetime
+
+Base = declarative_base()
+
+class Transaction(Base):
+    """Transaction model"""
+    __tablename__ = "transactions"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    firefly_id = Column(Integer, unique=True, index=True)
+    date = Column(DateTime, index=True)
+    amount = Column(Float)
+    description = Column(String)
+    type = Column(String)  # withdrawal, deposit, transfer
+    category_id = Column(Integer, ForeignKey("categories.id"))
+    from_account_id = Column(Integer, ForeignKey("accounts.id"))
+    to_account_id = Column(Integer, ForeignKey("accounts.id"))
+    notes = Column(Text, nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    
+    category = relationship("Category", foreign_keys=[category_id])
+    from_account = relationship("Account", foreign_keys=[from_account_id])
+    to_account = relationship("Account", foreign_keys=[to_account_id])
+
+class Category(Base):
+    """Category model"""
+    __tablename__ = "categories"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    firefly_id = Column(Integer, unique=True, index=True)
+    name = Column(String, unique=True, index=True)
+    type = Column(String)  # expense, revenue, etc
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    
+    transactions = relationship("Transaction", foreign_keys=[Transaction.category_id])
+
+class Account(Base):
+    """Account model"""
+    __tablename__ = "accounts"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    firefly_id = Column(Integer, unique=True, index=True)
+    name = Column(String, unique=True, index=True)
+    type = Column(String)  # asset, expense, revenue, liability, etc
+    balance = Column(Float)
+    currency_code = Column(String)
+    active = Column(Boolean, default=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+class SyncLog(Base):
+    """Track sync operations"""
+    __tablename__ = "sync_logs"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    entity_type = Column(String)  # transactions, categories, accounts
+    last_sync = Column(DateTime)
+    status = Column(String)  # success, failure
+    message = Column(String, nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+'''
+
+backend_database = '''"""
+Database initialization and connection
+"""
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, Session
+from app.config import settings
+from app.models import Base
+
+engine = create_engine(
+    settings.DATABASE_URL,
+    connect_args={"check_same_thread": False} if "sqlite" in settings.DATABASE_URL else {}
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+def init_db():
+    """Initialize database tables"""
+    Base.metadata.create_all(bind=engine)
+
+def get_db() -> Session:
+    """Get database session"""
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+'''
+
+backend_firefly_client = '''"""
+Firefly III API Client
+"""
+import httpx
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+from app.config import settings
+import logging
+
+logger = logging.getLogger(__name__)
+
+class FireflyClient:
+    """Client for Firefly III API"""
+    
+    def __init__(self):
+        self.base_url = settings.FIREFLY_URL.rstrip('/')
+        self.headers = {
+            "Authorization": f"Bearer {settings.FIREFLY_API_TOKEN}",
+            "Accept": "application/vnd.api+json",
+            "Content-Type": "application/json"
+        }
+    
+    async def get_transactions(
+        self,
+        start_date: Optional[str] = None,
+        end_date: Optional[str] = None,
+        limit: int = 50
+    ) -> List[Dict[str, Any]]:
+        """Fetch transactions from Firefly III"""
+        async with httpx.AsyncClient() as client:
+            params = {"limit": limit}
+            if start_date:
+                params["start"] = start_date
+            if end_date:
+                params["end"] = end_date
+            
+            try:
+                response = await client.get(
+                    f"{self.base_url}/api/v1/transactions",
+                    headers=self.headers,
+                    params=params,
+                    timeout=settings.API_TIMEOUT
+                )
+                response.raise_for_status()
+                data = response.json()
+                return data.get("data", [])
+            except Exception as e:
+                logger.error(f"Error fetching transactions: {e}")
+                return []
+    
+    async def get_categories(self) -> List[Dict[str, Any]]:
+        """Fetch categories from Firefly III"""
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(
+                    f"{self.base_url}/api/v1/categories",
+                    headers=self.headers,
+                    timeout=settings.API_TIMEOUT
+                )
+                response.raise_for_status()
+                data = response.json()
+                return data.get("data", [])
+            except Exception as e:
+                logger.error(f"Error fetching categories: {e}")
+                return []
+    
+    async def get_accounts(self) -> List[Dict[str, Any]]:
+        """Fetch accounts from Firefly III"""
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(
+                    f"{self.base_url}/api/v1/accounts",
+                    headers=self.headers,
+                    timeout=settings.API_TIMEOUT
+                )
+                response.raise_for_status()
+                data = response.json()
+                return data.get("data", [])
+            except Exception as e:
+                logger.error(f"Error fetching accounts: {e}")
+                return []
+
+firefly_client = FireflyClient()
+'''
+
+backend_main = '''"""
+Firefly III Analytics Backend - Main Application
+"""
+import os
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from dotenv import load_dotenv
+
+from app.database import init_db
+from app.routers import transactions, categories, accounts, reports, summary
+from app.services.sync_service import start_sync_scheduler, stop_sync_scheduler
+
+load_dotenv()
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Startup and shutdown events"""
+    # Startup
+    init_db()
+    start_sync_scheduler()
+    yield
+    # Shutdown
+    stop_sync_scheduler()
+
+app = FastAPI(
+    title="Firefly III Analytics API",
+    description="Analytics and reporting for Firefly III",
+    version="0.1.0",
+    lifespan=lifespan
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000", "http://localhost"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(transactions.router, prefix="/api/transactions", tags=["transactions"])
+app.include_router(categories.router, prefix="/api/categories", tags=["categories"])
+app.include_router(accounts.router, prefix="/api/accounts", tags=["accounts"])
+app.include_router(reports.router, prefix="/api/reports", tags=["reports"])
+app.include_router(summary.router, prefix="/api/summary", tags=["summary"])
+
+@app.get("/")
+async def root():
+    """Health check"""
+    return {"status": "ok", "message": "Firefly III Analytics API"}
+
+@app.get("/health")
+async def health():
+    """Health check endpoint"""
+    return {"status": "healthy"}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+'''
+
+backend_routers_init = '''"""
+API routers
+"""
+'''
+
+backend_routers_transactions = '''"""
+Transactions API endpoints
+"""
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy.orm import Session
+from app.database import get_db
+from app.services.transaction_service import TransactionService
+from datetime import datetime, timedelta
+
+router = APIRouter()
+transaction_service = TransactionService()
+
+@router.get("/")
+async def get_transactions(
+    start_date: str = Query(None),
+    end_date: str = Query(None),
+    category_id: int = Query(None),
+    db: Session = Depends(get_db)
+):
+    """Get transactions with optional filtering"""
+    filters = {}
+    if start_date:
+        filters["start_date"] = datetime.fromisoformat(start_date)
+    if end_date:
+        filters["end_date"] = datetime.fromisoformat(end_date)
+    if category_id:
+        filters["category_id"] = category_id
+    
+    transactions = await transaction_service.get_transactions(db, filters)
+    return {"data": transactions, "count": len(transactions)}
+'''
+
+backend_routers_categories = '''"""
+Categories API endpoints
+"""
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+from app.database import get_db
+from app.services.category_service import CategoryService
+
+router = APIRouter()
+category_service = CategoryService()
+
+@router.get("/")
+async def get_categories(db: Session = Depends(get_db)):
+    """Get all categories"""
+    categories = category_service.get_all_categories(db)
+    return {"data": categories, "count": len(categories)}
+'''
+
+backend_routers_accounts = '''"""
+Accounts API endpoints
+"""
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+from app.database import get_db
+from app.services.account_service import AccountService
+
+router = APIRouter()
+account_service = AccountService()
+
+@router.get("/")
+async def get_accounts(db: Session = Depends(get_db)):
+    """Get all accounts"""
+    accounts = account_service.get_all_accounts(db)
+    return {"data": accounts, "count": len(accounts)}
+'''
+
+backend_routers_reports = '''"""
+Reports API endpoints
+"""
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy.orm import Session
+from app.database import get_db
+from app.services.report_service import ReportService
+from datetime import datetime
+
+router = APIRouter()
+report_service = ReportService()
+
+@router.get("/spending-by-category")
+async def spending_by_category(
+    start_date: str = Query(...),
+    end_date: str = Query(...),
+    db: Session = Depends(get_db)
+):
+    """Get spending by category for date range"""
+    start = datetime.fromisoformat(start_date)
+    end = datetime.fromisoformat(end_date)
+    data = await report_service.get_spending_by_category(db, start, end)
+    return {"data": data}
+
+@router.get("/income-vs-expenses")
+async def income_vs_expenses(
+    start_date: str = Query(...),
+    end_date: str = Query(...),
+    db: Session = Depends(get_db)
+):
+    """Get income vs expenses for date range"""
+    start = datetime.fromisoformat(start_date)
+    end = datetime.fromisoformat(end_date)
+    data = await report_service.get_income_vs_expenses(db, start, end)
+    return {"data": data}
+
+@router.get("/trends")
+async def trends(
+    start_date: str = Query(...),
+    end_date: str = Query(...),
+    db: Session = Depends(get_db)
+):
+    """Get financial trends over time"""
+    start = datetime.fromisoformat(start_date)
+    end = datetime.fromisoformat(end_date)
+    data = await report_service.get_trends(db, start, end)
+    return {"data": data}
+
+@router.get("/budget-vs-actual")
+async def budget_vs_actual(
+    start_date: str = Query(...),
+    end_date: str = Query(...),
+    db: Session = Depends(get_db)
+):
+    """Get budget vs actual spending"""
+    start = datetime.fromisoformat(start_date)
+    end = datetime.fromisoformat(end_date)
+    data = await report_service.get_budget_vs_actual(db, start, end)
+    return {"data": data}
+'''
+
+backend_routers_summary = '''"""
+Summary API endpoints
+"""
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+from app.database import get_db
+from app.services.summary_service import SummaryService
+
+router = APIRouter()
+summary_service = SummaryService()
+
+@router.get("/")
+async def get_summary(db: Session = Depends(get_db)):
+    """Get dashboard summary metrics"""
+    summary = await summary_service.get_summary(db)
+    return summary
+'''
+
+backend_sync_service = '''"""
+Background sync service for Firefly III data
+"""
+from apscheduler.schedulers.background import BackgroundScheduler
+from app.config import settings
+from app.clients.firefly_client import firefly_client
+from app.database import SessionLocal
+from app.models import Transaction, Category, Account, SyncLog
+from datetime import datetime
+import logging
+import asyncio
+
+logger = logging.getLogger(__name__)
+scheduler = BackgroundScheduler()
+
+async def sync_data():
+    """Sync data from Firefly III"""
+    db = SessionLocal()
+    try:
+        # Sync categories
+        categories = await firefly_client.get_categories()
+        for cat in categories:
+            attrs = cat.get("attributes", {})
+            existing = db.query(Category).filter_by(firefly_id=cat["id"]).first()
+            if existing:
+                existing.name = attrs.get("name")
+                existing.type = attrs.get("type")
+                existing.updated_at = datetime.utcnow()
+            else:
+                db.add(Category(
+                    firefly_id=cat["id"],
+                    name=attrs.get("name"),
+                    type=attrs.get("type")
+                ))
+        
+        # Sync accounts
+        accounts = await firefly_client.get_accounts()
+        for acc in accounts:
+            attrs = acc.get("attributes", {})
+            existing = db.query(Account).filter_by(firefly_id=acc["id"]).first()
+            if existing:
+                existing.name = attrs.get("name")
+                existing.type = attrs.get("type")
+                existing.balance = float(attrs.get("current_balance", 0))
+                existing.currency_code = attrs.get("currency_code")
+                existing.updated_at = datetime.utcnow()
+            else:
+                db.add(Account(
+                    firefly_id=acc["id"],
+                    name=attrs.get("name"),
+                    type=attrs.get("type"),
+                    balance=float(attrs.get("current_balance", 0)),
+                    currency_code=attrs.get("currency_code")
+                ))
+        
+        # Sync transactions
+        transactions = await firefly_client.get_transactions()
+        for txn in transactions:
+            attrs = txn.get("attributes", {})
+            existing = db.query(Transaction).filter_by(firefly_id=txn["id"]).first()
+            if not existing:
+                db.add(Transaction(
+                    firefly_id=txn["id"],
+                    date=datetime.fromisoformat(attrs.get("date")),
+                    amount=float(attrs.get("amount", 0)),
+                    description=attrs.get("description"),
+                    type=attrs.get("type"),
+                    notes=attrs.get("notes")
+                ))
+        
+        db.commit()
+        logger.info("Data sync completed successfully")
+    except Exception as e:
+        logger.error(f"Error syncing data: {e}")
+        db.rollback()
+    finally:
+        db.close()
+
+def sync_job():
+    """Wrapper for async sync job"""
+    asyncio.run(sync_data())
+
+def start_sync_scheduler():
+    """Start background sync scheduler"""
+    if not scheduler.running:
+        scheduler.add_job(sync_job, 'interval', minutes=settings.SYNC_INTERVAL_MINUTES)
+        scheduler.start()
+        logger.info(f"Sync scheduler started (interval: {settings.SYNC_INTERVAL_MINUTES} minutes)")
+
+def stop_sync_scheduler():
+    """Stop background sync scheduler"""
+    if scheduler.running:
+        scheduler.shutdown()
+        logger.info("Sync scheduler stopped")
+'''
+
+backend_transaction_service = '''"""
+Transaction service business logic
+"""
+from sqlalchemy.orm import Session
+from sqlalchemy import func
+from app.models import Transaction
+from datetime import datetime
+
+class TransactionService:
+    def get_transactions(self, db: Session, filters: dict):
+        """Get transactions with filters"""
+        query = db.query(Transaction)
+        
+        if "start_date" in filters:
+            query = query.filter(Transaction.date >= filters["start_date"])
+        if "end_date" in filters:
+            query = query.filter(Transaction.date <= filters["end_date"])
+        if "category_id" in filters:
+            query = query.filter(Transaction.category_id == filters["category_id"])
+        
+        return query.order_by(Transaction.date.desc()).all()
+'''
+
+backend_category_service = '''"""
+Category service business logic
+"""
+from sqlalchemy.orm import Session
+from app.models import Category
+
+class CategoryService:
+    def get_all_categories(self, db: Session):
+        """Get all categories"""
+        return db.query(Category).all()
+'''
+
+backend_account_service = '''"""
+Account service business logic
+"""
+from sqlalchemy.orm import Session
+from app.models import Account
+
+class AccountService:
+    def get_all_accounts(self, db: Session):
+        """Get all accounts"""
+        return db.query(Account).all()
+'''
+
+backend_report_service = '''"""
+Report service for generating analytics
+"""
+from sqlalchemy.orm import Session
+from sqlalchemy import func
+from app.models import Transaction, Category, Account
+from datetime import datetime
+from typing import Dict, List, Any
+
+class ReportService:
+    async def get_spending_by_category(self, db: Session, start: datetime, end: datetime) -> Dict[str, Any]:
+        """Get spending breakdown by category"""
+        results = db.query(
+            Category.name,
+            func.sum(Transaction.amount).label("total")
+        ).join(
+            Transaction
+        ).filter(
+            Transaction.date >= start,
+            Transaction.date <= end,
+            Transaction.type == "withdrawal"
+        ).group_by(Category.name).all()
+        
+        return {
+            "period": {"start": start.isoformat(), "end": end.isoformat()},
+            "data": [{"category": r[0], "amount": float(r[1]) if r[1] else 0} for r in results]
+        }
+    
+    async def get_income_vs_expenses(self, db: Session, start: datetime, end: datetime) -> Dict[str, Any]:
+        """Get income vs expenses"""
+        income = db.query(func.sum(Transaction.amount)).filter(
+            Transaction.date >= start,
+            Transaction.date <= end,
+            Transaction.type == "deposit"
+        ).scalar() or 0
+        
+        expenses = db.query(func.sum(Transaction.amount)).filter(
+            Transaction.date >= start,
+            Transaction.date <= end,
+            Transaction.type == "withdrawal"
+        ).scalar() or 0
+        
+        return {
+            "period": {"start": start.isoformat(), "end": end.isoformat()},
+            "income": float(income),
+            "expenses": float(expenses),
+            "net": float(income - expenses)
+        }
+    
+    async def get_trends(self, db: Session, start: datetime, end: datetime) -> Dict[str, Any]:
+        """Get financial trends over time"""
+        results = db.query(
+            func.date(Transaction.date).label("date"),
+            func.sum(Transaction.amount).label("amount")
+        ).filter(
+            Transaction.date >= start,
+            Transaction.date <= end
+        ).group_by(func.date(Transaction.date)).order_by("date").all()
+        
+        return {
+            "period": {"start": start.isoformat(), "end": end.isoformat()},
+            "data": [{"date": str(r[0]), "amount": float(r[1]) if r[1] else 0} for r in results]
+        }
+    
+    async def get_budget_vs_actual(self, db: Session, start: datetime, end: datetime) -> Dict[str, Any]:
+        """Get budget vs actual spending (requires budget data)"""
+        return {
+            "period": {"start": start.isoformat(), "end": end.isoformat()},
+            "data": [],
+            "note": "Budget comparison requires budget data from Firefly III"
+        }
+'''
+
+backend_summary_service = '''"""
+Summary service for dashboard metrics
+"""
+from sqlalchemy.orm import Session
+from sqlalchemy import func
+from app.models import Transaction, Account
+from datetime import datetime, timedelta
+
+class SummaryService:
+    async def get_summary(self, db: Session):
+        """Get dashboard summary"""
+        # Last 30 days
+        thirty_days_ago = datetime.utcnow() - timedelta(days=30)
+        
+        total_assets = db.query(func.sum(Account.balance)).scalar() or 0
+        recent_transactions = db.query(func.count(Transaction.id)).filter(
+            Transaction.date >= thirty_days_ago
+        ).scalar() or 0
+        
+        last_30_income = db.query(func.sum(Transaction.amount)).filter(
+            Transaction.date >= thirty_days_ago,
+            Transaction.type == "deposit"
+        ).scalar() or 0
+        
+        last_30_expenses = db.query(func.sum(Transaction.amount)).filter(
+            Transaction.date >= thirty_days_ago,
+            Transaction.type == "withdrawal"
+        ).scalar() or 0
+        
+        return {
+            "total_assets": float(total_assets),
+            "recent_transactions": recent_transactions,
+            "last_30_days": {
+                "income": float(last_30_income),
+                "expenses": float(last_30_expenses),
+                "net": float(last_30_income - last_30_expenses)
+            }
+        }
+'''
+
+def main():
+    base_path = Path(os.getcwd())
+    
+    # Create backend structure
+    print("Setting up Firefly III Analytics Backend...")
+    create_file("backend/pyproject.toml", backend_pyproject)
+    create_file("backend/Dockerfile", backend_dockerfile)
+    create_file("backend/app/__init__.py", "")
+    create_file("backend/app/config.py", backend_config)
+    create_file("backend/app/models.py", backend_models)
+    create_file("backend/app/database.py", backend_database)
+    create_file("backend/app/main.py", backend_main)
+    
+    # Routers
+    create_file("backend/app/routers/__init__.py", backend_routers_init)
+    create_file("backend/app/routers/transactions.py", backend_routers_transactions)
+    create_file("backend/app/routers/categories.py", backend_routers_categories)
+    create_file("backend/app/routers/accounts.py", backend_routers_accounts)
+    create_file("backend/app/routers/reports.py", backend_routers_reports)
+    create_file("backend/app/routers/summary.py", backend_routers_summary)
+    
+    # Clients
+    create_file("backend/app/clients/__init__.py", "")
+    create_file("backend/app/clients/firefly_client.py", backend_firefly_client)
+    
+    # Services
+    create_file("backend/app/services/__init__.py", "")
+    create_file("backend/app/services/sync_service.py", backend_sync_service)
+    create_file("backend/app/services/transaction_service.py", backend_transaction_service)
+    create_file("backend/app/services/category_service.py", backend_category_service)
+    create_file("backend/app/services/account_service.py", backend_account_service)
+    create_file("backend/app/services/report_service.py", backend_report_service)
+    create_file("backend/app/services/summary_service.py", backend_summary_service)
+    
+    print("\n✓ Backend scaffolding complete!")
+    print("\nNext steps:")
+    print("1. Create .env file with your Firefly III API token")
+    print("2. cd backend && python -m venv venv")
+    print("3. source venv/bin/activate")
+    print("4. pip install -e .")
+    print("5. uvicorn app.main:app --reload")
+
+if __name__ == "__main__":
+    main()