ai-first-cli 1.3.0 → 1.3.5

package/test-projects/flask-app/app/__init__.py

@@ -1,46 +0,0 @@
-"""Flask application factory."""
-
-from flask import Flask
-from flask_sqlalchemy import SQLAlchemy
-from flask_migrate import Migrate
-from flask_login import LoginManager
-from config import Config
-
-db = SQLAlchemy()
-migrate = Migrate()
-login_manager = LoginManager()
-
-
-def create_app(config_class=Config):
-    """Application factory pattern."""
-    app = Flask(__name__)
-    app.config.from_object(config_class)
-
-    # Initialize extensions
-    db.init_app(app)
-    migrate.init_app(app, db)
-    login_manager.init_app(app)
-    login_manager.login_view = "auth.login"
-    login_manager.login_message = "Please log in to access this page."
-
-    # Register blueprints
-    from app.main import bp as main_bp
-
-    app.register_blueprint(main_bp)
-
-    from app.auth import bp as auth_bp
-
-    app.register_blueprint(auth_bp, url_prefix="/auth")
-
-    from app.blog import bp as blog_bp
-
-    app.register_blueprint(blog_bp, url_prefix="/blog")
-
-    from app.api import bp as api_bp
-
-    app.register_blueprint(api_bp, url_prefix="/api/v1")
-
-    return app
-
-
-from app import models

package/test-projects/flask-app/app/api/__init__.py

@@ -1,7 +0,0 @@
-"""API blueprint."""
-
-from flask import Blueprint
-
-bp = Blueprint("api", __name__)
-
-from app.api import routes

package/test-projects/flask-app/app/api/routes.py

@@ -1,122 +0,0 @@
-"""API blueprint routes."""
-
-from flask import Blueprint, request, jsonify
-from app import db
-from app.models import Post, Category, Tag, User, Comment
-
-bp = Blueprint("api", __name__)
-
-
-@bp.route("/posts", methods=["GET"])
-def api_get_posts():
-    """API: Get all posts."""
-    page = request.args.get("page", 1, type=int)
-    per_page = request.args.get("per_page", 10, type=int)
-
-    query = Post.query.filter_by(is_published=True)
-
-    # Filter by category
-    category_slug = request.args.get("category")
-    if category_slug:
-        category = Category.query.filter_by(slug=category_slug).first()
-        if category:
-            query = query.filter_by(category_id=category.id)
-
-    # Search
-    search = request.args.get("q")
-    if search:
-        query = query.filter(
-            db.or_(Post.title.ilike(f"%{search}%"), Post.content.ilike(f"%{search}%"))
-        )
-
-    posts = query.order_by(Post.published_at.desc()).paginate(
-        page=page, per_page=per_page, error_out=False
-    )
-
-    return jsonify(
-        {
-            "posts": [
-                {
-                    "id": p.id,
-                    "title": p.title,
-                    "slug": p.slug,
-                    "summary": p.summary,
-                    "author": p.author.username,
-                    "published_at": p.published_at.isoformat()
-                    if p.published_at
-                    else None,
-                    "view_count": p.view_count,
-                    "category": p.category.name if p.category else None,
-                    "tags": [t.name for t in p.tags],
-                }
-                for p in posts.items
-            ],
-            "total": posts.total,
-            "pages": posts.pages,
-            "current_page": page,
-        }
-    )
-
-
-@bp.route("/posts/<string:slug>", methods=["GET"])
-def api_get_post(slug):
-    """API: Get single post."""
-    post = Post.query.filter_by(slug=slug, is_published=True).first_or_404()
-    post.increment_view()
-
-    return jsonify(
-        {
-            "id": post.id,
-            "title": post.title,
-            "slug": post.slug,
-            "content": post.content,
-            "summary": post.summary,
-            "author": post.author.username,
-            "published_at": post.published_at.isoformat()
-            if post.published_at
-            else None,
-            "view_count": post.view_count,
-            "category": post.category.name if post.category else None,
-            "tags": [t.name for t in post.tags],
-            "comments_count": post.comments.count(),
-        }
-    )
-
-
-@bp.route("/categories", methods=["GET"])
-def api_get_categories():
-    """API: Get all categories."""
-    categories = Category.query.all()
-    return jsonify(
-        {
-            "categories": [
-                {
-                    "id": c.id,
-                    "name": c.name,
-                    "slug": c.slug,
-                    "description": c.description,
-                    "posts_count": c.posts.count(),
-                }
-                for c in categories
-            ]
-        }
-    )
-
-
-@bp.route("/tags", methods=["GET"])
-def api_get_tags():
-    """API: Get all tags."""
-    tags = Tag.query.all()
-    return jsonify(
-        {
-            "tags": [
-                {
-                    "id": t.id,
-                    "name": t.name,
-                    "slug": t.slug,
-                    "posts_count": t.posts.count(),
-                }
-                for t in tags
-            ]
-        }
-    )

package/test-projects/flask-app/app/auth/__init__.py

@@ -1,7 +0,0 @@
-"""Authentication blueprint."""
-
-from flask import Blueprint
-
-bp = Blueprint("auth", __name__)
-
-from app.auth import routes, forms

package/test-projects/flask-app/app/auth/forms.py

@@ -1,52 +0,0 @@
-"""Authentication forms."""
-
-from flask_wtf import FlaskForm
-from wtforms import StringField, PasswordField, BooleanField, SubmitField
-from wtforms.validators import ValidationError, DataRequired, Email, EqualTo, Length
-from app.models import User
-
-
-class LoginForm(FlaskForm):
-    """Login form."""
-
-    username = StringField("Username", validators=[DataRequired()])
-    password = PasswordField("Password", validators=[DataRequired()])
-    remember_me = BooleanField("Remember Me")
-    submit = SubmitField("Sign In")
-
-
-class RegistrationForm(FlaskForm):
-    """Registration form."""
-
-    username = StringField(
-        "Username", validators=[DataRequired(), Length(min=3, max=20)]
-    )
-    email = StringField("Email", validators=[DataRequired(), Email()])
-    full_name = StringField("Full Name", validators=[Length(max=100)])
-    password = PasswordField(
-        "Password",
-        validators=[
-            DataRequired(),
-            Length(min=8, message="Password must be at least 8 characters"),
-        ],
-    )
-    password2 = PasswordField(
-        "Repeat Password",
-        validators=[
-            DataRequired(),
-            EqualTo("password", message="Passwords must match"),
-        ],
-    )
-    submit = SubmitField("Register")
-
-    def validate_username(self, username):
-        """Validate username is unique."""
-        user = User.query.filter_by(username=username.data).first()
-        if user is not None:
-            raise ValidationError("Username already taken.")
-
-    def validate_email(self, email):
-        """Validate email is unique."""
-        user = User.query.filter_by(email=email.data).first()
-        if user is not None:
-            raise ValidationError("Email already registered.")

package/test-projects/flask-app/app/auth/routes.py

@@ -1,68 +0,0 @@
-"""Authentication blueprint routes."""
-
-from flask import Blueprint, render_template, redirect, url_for, flash, request
-from flask_login import login_user, logout_user, login_required, current_user
-from werkzeug.urls import url_parse
-from app import db
-from app.models import User
-from app.auth.forms import LoginForm, RegistrationForm
-
-bp = Blueprint("auth", __name__)
-
-
-@bp.route("/login", methods=["GET", "POST"])
-def login():
-    """User login."""
-    if current_user.is_authenticated:
-        return redirect(url_for("main.index"))
-
-    form = LoginForm()
-    if form.validate_on_submit():
-        user = User.query.filter_by(username=form.username.data).first()
-        if user is None or not user.check_password(form.password.data):
-            flash("Invalid username or password")
-            return redirect(url_for("auth.login"))
-
-        login_user(user, remember=form.remember_me.data)
-        next_page = request.args.get("next")
-        if not next_page or url_parse(next_page).netloc != "":
-            next_page = url_for("main.index")
-        return redirect(next_page)
-
-    return render_template("auth/login.html", title="Sign In", form=form)
-
-
-@bp.route("/logout")
-def logout():
-    """User logout."""
-    logout_user()
-    return redirect(url_for("main.index"))
-
-
-@bp.route("/register", methods=["GET", "POST"])
-def register():
-    """User registration."""
-    if current_user.is_authenticated:
-        return redirect(url_for("main.index"))
-
-    form = RegistrationForm()
-    if form.validate_on_submit():
-        user = User(
-            username=form.username.data,
-            email=form.email.data,
-            full_name=form.full_name.data,
-        )
-        user.set_password(form.password.data)
-        db.session.add(user)
-        db.session.commit()
-        flash("Congratulations, you are now a registered user!")
-        return redirect(url_for("auth.login"))
-
-    return render_template("auth/register.html", title="Register", form=form)
-
-
-@bp.route("/profile")
-@login_required
-def profile():
-    """User profile."""
-    return render_template("auth/profile.html", title="Profile")

package/test-projects/flask-app/app/blog/__init__.py

@@ -1,7 +0,0 @@
-"""Blog blueprint."""
-
-from flask import Blueprint
-
-bp = Blueprint("blog", __name__)
-
-from app.blog import routes, forms

package/test-projects/flask-app/app/blog/forms.py

@@ -1,35 +0,0 @@
-"""Blog forms."""
-
-from flask_wtf import FlaskForm
-from wtforms import StringField, TextAreaField, BooleanField, SubmitField, SelectField
-from wtforms.validators import DataRequired, Length
-
-
-class PostForm(FlaskForm):
-    """Blog post form."""
-
-    title = StringField("Title", validators=[DataRequired(), Length(min=1, max=200)])
-    summary = TextAreaField("Summary", validators=[Length(max=500)])
-    content = TextAreaField("Content", validators=[DataRequired()])
-    category_id = SelectField("Category", coerce=int, choices=[])
-    tags = StringField("Tags (comma separated)")
-    is_published = BooleanField("Publish immediately")
-    submit = SubmitField("Save Post")
-
-    def __init__(self, *args, **kwargs):
-        """Initialize form with categories."""
-        super(PostForm, self).__init__(*args, **kwargs)
-        from app.models import Category
-
-        self.category_id.choices = [(0, "No Category")] + [
-            (c.id, c.name) for c in Category.query.all()
-        ]
-
-
-class CommentForm(FlaskForm):
-    """Comment form."""
-
-    content = TextAreaField(
-        "Comment", validators=[DataRequired(), Length(min=1, max=2000)]
-    )
-    submit = SubmitField("Post Comment")

package/test-projects/flask-app/app/blog/routes.py

@@ -1,140 +0,0 @@
-"""Blog blueprint routes."""
-
-from flask import Blueprint, render_template, redirect, url_for, flash, request, abort
-from flask_login import login_required, current_user
-from app import db
-from app.models import Post, Category, Tag, Comment
-from app.blog.forms import PostForm, CommentForm
-
-bp = Blueprint("blog", __name__)
-
-
-def generate_slug(title):
-    """Generate URL slug from title."""
-    import re
-
-    slug = re.sub(r"[^\w\s-]", "", title.lower())
-    slug = re.sub(r"[-\s]+", "-", slug)
-    return slug.strip("-")
-
-
-@bp.route("/create", methods=["GET", "POST"])
-@login_required
-def create_post():
-    """Create new blog post."""
-    form = PostForm()
-    if form.validate_on_submit():
-        post = Post(
-            title=form.title.data,
-            slug=generate_slug(form.title.data),
-            content=form.content.data,
-            summary=form.summary.data,
-            is_published=form.is_published.data,
-            user_id=current_user.id,
-        )
-
-        # Set category
-        if form.category_id.data:
-            post.category_id = form.category_id.data
-
-        # Add tags
-        if form.tags.data:
-            tag_names = [t.strip() for t in form.tags.data.split(",")]
-            for tag_name in tag_names:
-                tag = Tag.query.filter_by(name=tag_name).first()
-                if not tag:
-                    tag = Tag(name=tag_name, slug=generate_slug(tag_name))
-                    db.session.add(tag)
-                post.tags.append(tag)
-
-        db.session.add(post)
-        db.session.commit()
-
-        # Publish if requested
-        if form.is_published.data:
-            post.publish()
-
-        flash("Your post has been created!")
-        return redirect(url_for("blog.post", slug=post.slug))
-
-    return render_template("blog/create.html", title="Create Post", form=form)
-
-
-@bp.route("/<string:slug>/edit", methods=["GET", "POST"])
-@login_required
-def edit_post(slug):
-    """Edit blog post."""
-    post = Post.query.filter_by(slug=slug).first_or_404()
-
-    # Check ownership
-    if post.user_id != current_user.id and not current_user.is_admin:
-        abort(403)
-
-    form = PostForm(obj=post)
-    if form.validate_on_submit():
-        post.title = form.title.data
-        post.slug = generate_slug(form.title.data)
-        post.content = form.content.data
-        post.summary = form.summary.data
-
-        # Update publish status
-        if form.is_published.data and not post.is_published:
-            post.publish()
-        elif not form.is_published.data and post.is_published:
-            post.unpublish()
-
-        db.session.commit()
-        flash("Your post has been updated!")
-        return redirect(url_for("blog.post", slug=post.slug))
-
-    return render_template("blog/edit.html", title="Edit Post", form=form, post=post)
-
-
-@bp.route("/<string:slug>/delete", methods=["POST"])
-@login_required
-def delete_post(slug):
-    """Delete blog post."""
-    post = Post.query.filter_by(slug=slug).first_or_404()
-
-    # Check ownership
-    if post.user_id != current_user.id and not current_user.is_admin:
-        abort(403)
-
-    db.session.delete(post)
-    db.session.commit()
-    flash("Your post has been deleted.")
-    return redirect(url_for("main.index"))
-
-
-@bp.route("/<string:slug>")
-def post(slug):
-    """View blog post."""
-    post = Post.query.filter_by(slug=slug).first_or_404()
-
-    # Only show published posts to non-authors
-    if not post.is_published and (
-        not current_user.is_authenticated
-        or (current_user.id != post.user_id and not current_user.is_admin)
-    ):
-        abort(404)
-
-    form = CommentForm()
-    return render_template("blog/post.html", post=post, form=form)
-
-
-@bp.route("/<string:slug>/comment", methods=["POST"])
-@login_required
-def add_comment(slug):
-    """Add comment to post."""
-    post = Post.query.filter_by(slug=slug).first_or_404()
-    form = CommentForm()
-
-    if form.validate_on_submit():
-        comment = Comment(
-            content=form.content.data, post_id=post.id, user_id=current_user.id
-        )
-        db.session.add(comment)
-        db.session.commit()
-        flash("Your comment has been added.")
-
-    return redirect(url_for("blog.post", slug=post.slug))

package/test-projects/flask-app/app/main/__init__.py

@@ -1,7 +0,0 @@
-"""Main blueprint."""
-
-from flask import Blueprint
-
-bp = Blueprint("main", __name__)
-
-from app.main import routes

package/test-projects/flask-app/app/main/routes.py

@@ -1,88 +0,0 @@
-"""Main blueprint routes."""
-
-from flask import Blueprint, render_template, request, current_app
-from app.models import Post, Category, Tag
-from app import db
-
-bp = Blueprint("main", __name__)
-
-
-@bp.route("/")
-def index():
-    """Home page."""
-    page = request.args.get("page", 1, type=int)
-    posts = (
-        Post.query.filter_by(is_published=True)
-        .order_by(Post.published_at.desc())
-        .paginate(
-            page=page, per_page=current_app.config["POSTS_PER_PAGE"], error_out=False
-        )
-    )
-    return render_template("index.html", posts=posts)
-
-
-@bp.route("/about")
-def about():
-    """About page."""
-    return render_template("about.html")
-
-
-@bp.route("/post/<string:slug>")
-def post(slug):
-    """Single post page."""
-    post = Post.query.filter_by(slug=slug, is_published=True).first_or_404()
-    post.increment_view()
-    return render_template("post.html", post=post)
-
-
-@bp.route("/category/<string:slug>")
-def category(slug):
-    """Category page."""
-    category = Category.query.filter_by(slug=slug).first_or_404()
-    page = request.args.get("page", 1, type=int)
-    posts = (
-        Post.query.filter_by(category_id=category.id, is_published=True)
-        .order_by(Post.published_at.desc())
-        .paginate(
-            page=page, per_page=current_app.config["POSTS_PER_PAGE"], error_out=False
-        )
-    )
-    return render_template("category.html", category=category, posts=posts)
-
-
-@bp.route("/tag/<string:slug>")
-def tag(slug):
-    """Tag page."""
-    tag = Tag.query.filter_by(slug=slug).first_or_404()
-    page = request.args.get("page", 1, type=int)
-    posts = (
-        tag.posts.filter_by(is_published=True)
-        .order_by(Post.published_at.desc())
-        .paginate(
-            page=page, per_page=current_app.config["POSTS_PER_PAGE"], error_out=False
-        )
-    )
-    return render_template("tag.html", tag=tag, posts=posts)
-
-
-@bp.route("/search")
-def search():
-    """Search page."""
-    q = request.args.get("q", "")
-    page = request.args.get("page", 1, type=int)
-
-    if not q:
-        return render_template("search.html", posts=None, q=q)
-
-    posts = (
-        Post.query.filter(
-            Post.is_published == True,
-            db.or_(Post.title.ilike(f"%{q}%"), Post.content.ilike(f"%{q}%")),
-        )
-        .order_by(Post.published_at.desc())
-        .paginate(
-            page=page, per_page=current_app.config["POSTS_PER_PAGE"], error_out=False
-        )
-    )
-
-    return render_template("search.html", posts=posts, q=q)