ai-first-cli 1.3.1 → 1.3.5

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

@@ -1,32 +0,0 @@
-# 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-dev/tools.json

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

package/test-projects/fastapi-app/README.md

@@ -1,118 +0,0 @@
-# FastAPI Blog
-
-A modern, fast blog API built with FastAPI, SQLAlchemy, and Pydantic.
-
-## Features
-
-- **High Performance**: Built on FastAPI (one of the fastest Python frameworks)
-- **Automatic API Documentation**: Interactive docs at `/docs` (Swagger UI) and `/redoc` (ReDoc)
-- **Type Safety**: Full type hints with Pydantic models
-- **Authentication**: JWT token-based authentication
-- **Database**: SQLAlchemy ORM with SQLite (easily switchable to PostgreSQL)
-- **Modern Python**: Python 3.9+ with async support
-
-## Project Structure
-
-```
-fastapi-app/
-├── app/
-│   ├── __init__.py
-│   ├── main.py              # FastAPI application entry point
-│   ├── database.py          # Database configuration
-│   ├── models.py            # SQLAlchemy models
-│   ├── schemas.py           # Pydantic schemas
-│   ├── dependencies.py      # Authentication & dependencies
-│   └── routers/
-│       ├── __init__.py
-│       ├── auth.py          # Authentication endpoints
-│       └── posts.py         # Blog post endpoints
-├── tests/
-└── requirements.txt
-```
-
-## Models
-
-### User
-- Authentication with JWT tokens
-- Profile information (bio, full_name)
-- Relationships: posts, comments
-
-### Post
-- Blog posts with title, content, slug
-- Publishing workflow (draft → published)
-- Categories and tags
-- View counter
-
-### Comment
-- Nested comments (replies)
-- Approval system
-
-### Category
-- Post categorization
-- URL-friendly slugs
-
-### Tag
-- Post tagging system
-- Many-to-many relationship with posts
-
-## API Endpoints
-
-### Authentication
-- `POST /api/v1/auth/register` - Register new user
-- `POST /api/v1/auth/token` - Login and get token
-- `GET /api/v1/auth/me` - Get current user
-- `PUT /api/v1/auth/me` - Update profile
-- `POST /api/v1/auth/change-password` - Change password
-
-### Posts
-- `GET /api/v1/posts/` - List posts (with filters)
-- `POST /api/v1/posts/` - Create post
-- `GET /api/v1/posts/{slug}` - Get single post
-- `PUT /api/v1/posts/{post_id}` - Update post
-- `DELETE /api/v1/posts/{post_id}` - Delete post
-- `POST /api/v1/posts/{post_id}/publish` - Publish post
-- `GET /api/v1/posts/my/posts` - Get my posts
-
-### Filters Available
-- `category_slug` - Filter by category
-- `tag_slug` - Filter by tag
-- `search` - Search in title/content
-- `published_only` - Show only published (default: true)
-
-## Setup
-
-```bash
-# Install dependencies
-pip install -r requirements.txt
-
-# Run the application
-python -m app.main
-
-# Or using uvicorn directly
-uvicorn app.main:app --reload
-
-# Access API documentation
-# OpenAPI (Swagger UI): http://localhost:8000/docs
-# ReDoc: http://localhost:8000/redoc
-```
-
-## Testing with ai-first
-
-```bash
-# Generate AI context
-ai-first init --root fastapi-app
-
-# Generate repository map
-ai-first map --root fastapi-app
-
-# Generate SQLite index
-ai-first index --root fastapi-app
-```
-
-## Key Features
-
-- **Pydantic v2**: Latest version with better performance
-- **SQLAlchemy 2.0**: Modern ORM syntax
-- **Dependency Injection**: FastAPI's powerful DI system
-- **Automatic Validation**: Request/response validation out of the box
-- **Type Hints**: Full IDE support with autocomplete

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

@@ -1,21 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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"}