ai-first-cli 1.1.5 → 1.2.0

package/test-projects/fastapi-app/ai-context/tech_stack.md

@@ -0,0 +1,32 @@
+# Technology Stack
+
+**Languages**: Markdown, JSON, Python
+
+## Languages
+- Markdown
+- JSON
+- Python
+
+## Frameworks
+- None detected
+
+## Key Libraries
+- None detected
+
+## Development Tools
+- None detected
+
+## Package Managers
+- None detected
+
+## Testing
+- None detected
+
+## Linters
+- None detected
+
+## Formatters
+- None detected
+
+---
+*Generated by ai-first*

package/test-projects/fastapi-app/ai-context/tools.json

@@ -0,0 +1,10 @@
+{
+  "compatibleAgents": [
+    "ai-first-bridge",
+    "opencode",
+    "cursor",
+    "windsurf",
+    "cline"
+  ],
+  "schemaVersion": "1.0"
+}

package/test-projects/fastapi-app/app/database.py

@@ -0,0 +1,21 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+SQLALCHEMY_DATABASE_URL = "sqlite:///./fastapi_app.db"
+
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
+)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+
+def get_db():
+    """Dependency to get database session."""
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

package/test-projects/fastapi-app/app/dependencies.py

@@ -0,0 +1,107 @@
+from datetime import datetime, timedelta
+from typing import Optional
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from sqlalchemy.orm import Session
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from app import models, schemas
+from app.database import get_db
+
+# Security configuration
+SECRET_KEY = "your-secret-key-here-change-in-production"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="api/v1/auth/token")
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Verify a password against its hash."""
+    return pwd_context.verify(plain_password, hashed_password)
+
+
+def get_password_hash(password: str) -> str:
+    """Hash a password."""
+    return pwd_context.hash(password)
+
+
+def get_user(db: Session, username: str) -> Optional[models.User]:
+    """Get user by username."""
+    return db.query(models.User).filter(models.User.username == username).first()
+
+
+def get_user_by_email(db: Session, email: str) -> Optional[models.User]:
+    """Get user by email."""
+    return db.query(models.User).filter(models.User.email == email).first()
+
+
+def authenticate_user(
+    db: Session, username: str, password: str
+) -> Optional[models.User]:
+    """Authenticate a user."""
+    user = get_user(db, username)
+    if not user:
+        return None
+    if not verify_password(password, user.hashed_password):
+        return None
+    return user
+
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None) -> str:
+    """Create JWT access token."""
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=15)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+
+async def get_current_user(
+    token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)
+) -> models.User:
+    """Get current authenticated user."""
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+        token_data = schemas.TokenData(username=username)
+    except JWTError:
+        raise credentials_exception
+
+    user = get_user(db, username=token_data.username)
+    if user is None:
+        raise credentials_exception
+
+    return user
+
+
+async def get_current_active_user(
+    current_user: models.User = Depends(get_current_user),
+) -> models.User:
+    """Get current active user."""
+    if not current_user.is_active:
+        raise HTTPException(status_code=400, detail="Inactive user")
+    return current_user
+
+
+async def get_current_superuser(
+    current_user: models.User = Depends(get_current_active_user),
+) -> models.User:
+    """Get current superuser."""
+    if not current_user.is_superuser:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN, detail="Not enough permissions"
+        )
+    return current_user

package/test-projects/fastapi-app/app/main.py

@@ -0,0 +1,47 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.database import engine, Base
+from app.routers import auth, posts
+
+# Create database tables
+Base.metadata.create_all(bind=engine)
+
+# Create FastAPI app
+app = FastAPI(
+    title="FastAPI Blog",
+    description="A modern blog API built with FastAPI",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(auth.router, prefix="/api/v1")
+app.include_router(posts.router, prefix="/api/v1")
+
+
+@app.get("/")
+def read_root():
+    """Root endpoint."""
+    return {"message": "Welcome to FastAPI Blog", "docs": "/docs", "version": "1.0.0"}
+
+
+@app.get("/health")
+def health_check():
+    """Health check endpoint."""
+    return {"status": "healthy"}
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)

package/test-projects/fastapi-app/app/models.py

@@ -0,0 +1,149 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    Boolean,
+    DateTime,
+    ForeignKey,
+    Text,
+    Table,
+)
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+from app.database import Base
+
+# Association table for many-to-many relationship
+post_tags = Table(
+    "post_tags",
+    Base.metadata,
+    Column("post_id", Integer, ForeignKey("posts.id")),
+    Column("tag_id", Integer, ForeignKey("tags.id")),
+)
+
+
+class User(Base):
+    """User model for authentication and posts."""
+
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String, unique=True, index=True, nullable=False)
+    username = Column(String, unique=True, index=True, nullable=False)
+    hashed_password = Column(String, nullable=False)
+    full_name = Column(String)
+    bio = Column(Text)
+    is_active = Column(Boolean, default=True)
+    is_superuser = Column(Boolean, default=False)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+
+    # Relationships
+    posts = relationship("Post", back_populates="author", cascade="all, delete-orphan")
+    comments = relationship(
+        "Comment", back_populates="author", cascade="all, delete-orphan"
+    )
+
+    def __repr__(self):
+        return f"<User(username='{self.username}', email='{self.email}')>"
+
+
+class Post(Base):
+    """Blog post model."""
+
+    __tablename__ = "posts"
+
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(String(255), nullable=False)
+    slug = Column(String(255), unique=True, index=True, nullable=False)
+    content = Column(Text, nullable=False)
+    summary = Column(String(500))
+    is_published = Column(Boolean, default=False)
+    published_at = Column(DateTime(timezone=True))
+    view_count = Column(Integer, default=0)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+    author_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+
+    # Relationships
+    author = relationship("User", back_populates="posts")
+    comments = relationship(
+        "Comment", back_populates="post", cascade="all, delete-orphan"
+    )
+    tags = relationship("Tag", secondary=post_tags, back_populates="posts")
+    category_id = Column(Integer, ForeignKey("categories.id"))
+    category = relationship("Category", back_populates="posts")
+
+    def __repr__(self):
+        return f"<Post(title='{self.title}', slug='{self.slug}')>"
+
+    def publish(self):
+        """Publish the post."""
+        from datetime import datetime
+
+        self.is_published = True
+        self.published_at = datetime.utcnow()
+
+    def unpublish(self):
+        """Unpublish the post."""
+        self.is_published = False
+        self.published_at = None
+
+
+class Comment(Base):
+    """Comment model for blog posts."""
+
+    __tablename__ = "comments"
+
+    id = Column(Integer, primary_key=True, index=True)
+    content = Column(Text, nullable=False)
+    is_approved = Column(Boolean, default=False)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+
+    # Foreign keys
+    post_id = Column(Integer, ForeignKey("posts.id"), nullable=False)
+    author_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    parent_id = Column(Integer, ForeignKey("comments.id"), nullable=True)
+
+    # Relationships
+    post = relationship("Post", back_populates="comments")
+    author = relationship("User", back_populates="comments")
+    replies = relationship("Comment", backref="parent", remote_side=[id])
+
+    def __repr__(self):
+        return f"<Comment(id={self.id}, post_id={self.post_id})>"
+
+
+class Category(Base):
+    """Category model for organizing posts."""
+
+    __tablename__ = "categories"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(100), unique=True, nullable=False)
+    slug = Column(String(100), unique=True, index=True, nullable=False)
+    description = Column(Text)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    # Relationships
+    posts = relationship("Post", back_populates="category")
+
+    def __repr__(self):
+        return f"<Category(name='{self.name}')>"
+
+
+class Tag(Base):
+    """Tag model for posts."""
+
+    __tablename__ = "tags"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(50), unique=True, nullable=False)
+    slug = Column(String(50), unique=True, index=True, nullable=False)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    # Relationships
+    posts = relationship("Post", secondary=post_tags, back_populates="tags")
+
+    def __repr__(self):
+        return f"<Tag(name='{self.name}')>"

package/test-projects/fastapi-app/app/routers/auth.py

@@ -0,0 +1,117 @@
+from datetime import timedelta
+from typing import List
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from app import models, schemas
+from app.database import get_db
+from app.dependencies import (
+    authenticate_user,
+    create_access_token,
+    get_current_active_user,
+    get_password_hash,
+    ACCESS_TOKEN_EXPIRE_MINUTES,
+    get_user,
+    get_user_by_email,
+)
+
+router = APIRouter(prefix="/auth", tags=["authentication"])
+
+
+@router.post(
+    "/register", response_model=schemas.User, status_code=status.HTTP_201_CREATED
+)
+def register(user: schemas.UserCreate, db: Session = Depends(get_db)):
+    """Register a new user."""
+    # Check if username exists
+    db_user = get_user(db, username=user.username)
+    if db_user:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Username already registered",
+        )
+
+    # Check if email exists
+    db_user = get_user_by_email(db, email=user.email)
+    if db_user:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail="Email already registered"
+        )
+
+    # Create new user
+    hashed_password = get_password_hash(user.password)
+    db_user = models.User(
+        email=user.email,
+        username=user.username,
+        hashed_password=hashed_password,
+        full_name=user.full_name,
+        bio=user.bio,
+    )
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+
+    return db_user
+
+
+@router.post("/token", response_model=schemas.Token)
+def login(form_data: schemas.LoginRequest, db: Session = Depends(get_db)):
+    """Login and get access token."""
+    user = authenticate_user(db, form_data.username, form_data.password)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    access_token = create_access_token(
+        data={"sub": user.username}, expires_delta=access_token_expires
+    )
+
+    return {"access_token": access_token, "token_type": "bearer"}
+
+
+@router.get("/me", response_model=schemas.User)
+def read_users_me(current_user: models.User = Depends(get_current_active_user)):
+    """Get current user information."""
+    return current_user
+
+
+@router.put("/me", response_model=schemas.User)
+def update_user_me(
+    user_update: schemas.UserUpdate,
+    current_user: models.User = Depends(get_current_active_user),
+    db: Session = Depends(get_db),
+):
+    """Update current user."""
+    update_data = user_update.model_dump(exclude_unset=True)
+
+    for field, value in update_data.items():
+        setattr(current_user, field, value)
+
+    db.commit()
+    db.refresh(current_user)
+
+    return current_user
+
+
+@router.post("/change-password")
+def change_password(
+    old_password: str,
+    new_password: str,
+    current_user: models.User = Depends(get_current_active_user),
+    db: Session = Depends(get_db),
+):
+    """Change user password."""
+    from app.dependencies import verify_password, get_password_hash
+
+    if not verify_password(old_password, current_user.hashed_password):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail="Incorrect password"
+        )
+
+    current_user.hashed_password = get_password_hash(new_password)
+    db.commit()
+
+    return {"message": "Password updated successfully"}