ai-first-cli 1.1.5 → 1.2.0

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,88 @@
+"""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)