commiter-cli 0.3.0__py3-none-any.whl

tests/fixtures/arch_monorepo/apps/api/middleware/auth.py

@@ -0,0 +1,17 @@
+import jwt
+from functools import wraps
+from flask import request, jsonify
+
+def require_auth(f):
+    @wraps(f)
+    def decorated(*args, **kwargs):
+        token = request.headers.get("Authorization", "").replace("Bearer ", "")
+        if not token:
+            return jsonify(error="Missing token"), 401
+        try:
+            payload = jwt.decode(token, "secret", algorithms=["HS256"])
+            request.user_id = payload["sub"]
+        except jwt.ExpiredSignatureError:
+            return jsonify(error="Token expired"), 401
+        return f(*args, **kwargs)
+    return decorated

tests/fixtures/arch_monorepo/apps/api/middleware/rate_limit.py

@@ -0,0 +1,10 @@
+from functools import wraps
+from flask import request, jsonify
+
+def rate_limit(max_requests=60, window=60):
+    def decorator(f):
+        @wraps(f)
+        def decorated(*args, **kwargs):
+            return f(*args, **kwargs)
+        return decorated
+    return decorator

tests/fixtures/arch_monorepo/apps/api/routes/auth.py

@@ -0,0 +1,46 @@
+from flask import Blueprint, request, jsonify
+
+auth_bp = Blueprint("auth", __name__)
+
+
+@auth_bp.route("/login", methods=["POST"])
+def login():
+    email = request.json["email"]
+    password = request.json["password"]
+    user = db.table("users").select("*").eq("email", email).single().execute()
+    session = db.table("sessions").insert({
+        "user_id": user.data["id"],
+        "ip_address": request.remote_addr,
+    }).execute()
+    return jsonify(access_token="jwt...", refresh_token="rt...", expires_in=3600)
+
+
+@auth_bp.route("/refresh", methods=["POST"])
+def refresh_token():
+    refresh = request.cookies.get("refresh_token")
+    session = db.table("sessions").select("*").eq("refresh_token", refresh).single().execute()
+    db.table("sessions").update({"refreshed_at": "now()"}).eq("id", session.data["id"]).execute()
+    return jsonify(access_token="jwt...", expires_in=3600)
+
+
+@auth_bp.route("/logout", methods=["POST"])
+@login_required
+def logout():
+    db.table("sessions").delete().eq("user_id", request.user_id).execute()
+    return jsonify(success=True)
+
+
+@auth_bp.route("/signup", methods=["POST"])
+def signup():
+    email = request.json["email"]
+    password = request.json["password"]
+    display_name = request.json["display_name"]
+    user = db.table("users").insert({
+        "email": email,
+        "display_name": display_name,
+    }).execute()
+    db.table("workspaces").insert({
+        "name": f"{display_name}'s Workspace",
+        "owner_id": user.data[0]["id"],
+    }).execute()
+    return jsonify(user=user.data[0], access_token="jwt...")

tests/fixtures/arch_monorepo/apps/api/routes/invites.py

@@ -0,0 +1,30 @@
+from flask import Blueprint, request, jsonify
+
+invites_bp = Blueprint("invites", __name__)
+
+
+@invites_bp.route("/", methods=["POST"])
+@login_required
+def create_invite():
+    email = request.json["email"]
+    workspace_id = request.json["workspace_id"]
+    invite = db.table("invites").insert({
+        "email": email,
+        "workspace_id": workspace_id,
+        "invited_by": request.user_id,
+        "status": "pending",
+    }).execute()
+    return jsonify(invite=invite.data[0])
+
+
+@invites_bp.route("/<invite_id>/accept", methods=["POST"])
+@login_required
+def accept_invite(invite_id):
+    invite = db.table("invites").select("*").eq("id", invite_id).single().execute()
+    db.table("invites").update({"status": "accepted"}).eq("id", invite_id).execute()
+    db.table("workspace_members").insert({
+        "workspace_id": invite.data["workspace_id"],
+        "user_id": request.user_id,
+        "role": "member",
+    }).execute()
+    return jsonify(success=True)

tests/fixtures/arch_monorepo/apps/api/routes/notifications.py

@@ -0,0 +1,25 @@
+from flask import Blueprint, request, jsonify
+
+notifications_bp = Blueprint("notifications", __name__)
+
+
+@notifications_bp.route("/", methods=["GET"])
+@login_required
+def list_notifications():
+    notifications = db.table("notifications").select("*").eq("user_id", request.user_id).order("created_at", desc=True).limit(50).execute()
+    return jsonify(notifications=notifications.data)
+
+
+@notifications_bp.route("/read", methods=["POST"])
+@login_required
+def mark_read():
+    notification_ids = request.json["ids"]
+    db.table("notifications").update({"read": True}).in_("id", notification_ids).execute()
+    return jsonify(success=True)
+
+
+@notifications_bp.route("/unread-count", methods=["GET"])
+@login_required
+def unread_count():
+    result = db.table("notifications").select("id", count="exact").eq("user_id", request.user_id).eq("read", False).execute()
+    return jsonify(count=result.count)

tests/fixtures/arch_monorepo/apps/api/routes/projects.py

@@ -0,0 +1,80 @@
+from flask import Blueprint, request, jsonify
+
+projects_bp = Blueprint("projects", __name__)
+
+
+@projects_bp.route("/", methods=["GET"])
+@login_required
+def list_projects():
+    workspace_id = request.args.get("workspace_id")
+    projects = db.table("projects").select("*").eq("workspace_id", workspace_id).execute()
+    return jsonify(projects=projects.data)
+
+
+@projects_bp.route("/", methods=["POST"])
+@login_required
+def create_project():
+    name = request.json["name"]
+    description = request.json.get("description", "")
+    workspace_id = request.json["workspace_id"]
+    color = request.json.get("color", "#3b82f6")
+    project = db.table("projects").insert({
+        "name": name,
+        "description": description,
+        "workspace_id": workspace_id,
+        "color": color,
+        "owner_id": request.user_id,
+    }).execute()
+    # Create default columns for kanban
+    for col_name in ["To Do", "In Progress", "Done"]:
+        db.table("columns").insert({
+            "project_id": project.data[0]["id"],
+            "name": col_name,
+        }).execute()
+    return jsonify(project=project.data[0])
+
+
+@projects_bp.route("/<project_id>", methods=["GET"])
+@login_required
+def get_project(project_id):
+    project = db.table("projects").select("*").eq("id", project_id).single().execute()
+    members = db.table("project_members").select("*, users(display_name, avatar_url)").eq("project_id", project_id).execute()
+    columns = db.table("columns").select("*").eq("project_id", project_id).order("position").execute()
+    return jsonify(project=project.data, members=members.data, columns=columns.data)
+
+
+@projects_bp.route("/<project_id>", methods=["PUT"])
+@login_required
+def update_project(project_id):
+    updates = {k: v for k, v in request.json.items() if k in ("name", "description", "color", "archived")}
+    project = db.table("projects").update(updates).eq("id", project_id).execute()
+    return jsonify(project=project.data[0])
+
+
+@projects_bp.route("/<project_id>", methods=["DELETE"])
+@login_required
+def delete_project(project_id):
+    db.table("tasks").delete().eq("project_id", project_id).execute()
+    db.table("columns").delete().eq("project_id", project_id).execute()
+    db.table("project_members").delete().eq("project_id", project_id).execute()
+    db.table("projects").delete().eq("id", project_id).execute()
+    return jsonify(success=True)
+
+
+@projects_bp.route("/<project_id>/members", methods=["POST"])
+@login_required
+def add_member(project_id):
+    user_id = request.json["user_id"]
+    role = request.json.get("role", "member")
+    member = db.table("project_members").insert({
+        "project_id": project_id,
+        "user_id": user_id,
+        "role": role,
+    }).execute()
+    # Send notification to the invited user
+    db.table("notifications").insert({
+        "user_id": user_id,
+        "type": "project_invite",
+        "data": {"project_id": project_id, "invited_by": request.user_id},
+    }).execute()
+    return jsonify(member=member.data[0])

tests/fixtures/arch_monorepo/apps/api/routes/tasks.py

@@ -0,0 +1,91 @@
+from flask import Blueprint, request, jsonify
+
+tasks_bp = Blueprint("tasks", __name__)
+
+
+@tasks_bp.route("/", methods=["GET"])
+@login_required
+def list_tasks():
+    project_id = request.args.get("project_id")
+    column_id = request.args.get("column_id")
+    query = db.table("tasks").select("*, assignee:users(display_name, avatar_url)")
+    if project_id:
+        query = query.eq("project_id", project_id)
+    if column_id:
+        query = query.eq("column_id", column_id)
+    tasks = query.order("position").execute()
+    return jsonify(tasks=tasks.data)
+
+
+@tasks_bp.route("/", methods=["POST"])
+@login_required
+def create_task():
+    title = request.json["title"]
+    description = request.json.get("description", "")
+    project_id = request.json["project_id"]
+    column_id = request.json["column_id"]
+    assignee_id = request.json.get("assignee_id")
+    priority = request.json.get("priority", "medium")
+    due_date = request.json.get("due_date")
+    task = db.table("tasks").insert({
+        "title": title,
+        "description": description,
+        "project_id": project_id,
+        "column_id": column_id,
+        "assignee_id": assignee_id,
+        "priority": priority,
+        "due_date": due_date,
+        "creator_id": request.user_id,
+    }).execute()
+    # Notify assignee
+    if assignee_id and assignee_id != request.user_id:
+        db.table("notifications").insert({
+            "user_id": assignee_id,
+            "type": "task_assigned",
+            "data": {"task_id": task.data[0]["id"], "assigned_by": request.user_id},
+        }).execute()
+    return jsonify(task=task.data[0])
+
+
+@tasks_bp.route("/<task_id>", methods=["PUT"])
+@login_required
+def update_task(task_id):
+    allowed = ("title", "description", "column_id", "assignee_id", "priority", "due_date", "position", "completed")
+    updates = {k: v for k, v in request.json.items() if k in allowed}
+    task = db.table("tasks").update(updates).eq("id", task_id).execute()
+    # Log activity
+    db.table("activity_log").insert({
+        "user_id": request.user_id,
+        "action": "task_updated",
+        "entity_type": "task",
+        "entity_id": task_id,
+        "changes": updates,
+    }).execute()
+    return jsonify(task=task.data[0])
+
+
+@tasks_bp.route("/<task_id>", methods=["DELETE"])
+@login_required
+def delete_task(task_id):
+    db.table("comments").delete().eq("task_id", task_id).execute()
+    db.table("tasks").delete().eq("id", task_id).execute()
+    return jsonify(success=True)
+
+
+@tasks_bp.route("/<task_id>/comments", methods=["GET"])
+@login_required
+def list_comments(task_id):
+    comments = db.table("comments").select("*, author:users(display_name, avatar_url)").eq("task_id", task_id).order("created_at").execute()
+    return jsonify(comments=comments.data)
+
+
+@tasks_bp.route("/<task_id>/comments", methods=["POST"])
+@login_required
+def create_comment(task_id):
+    body = request.json["body"]
+    comment = db.table("comments").insert({
+        "task_id": task_id,
+        "author_id": request.user_id,
+        "body": body,
+    }).execute()
+    return jsonify(comment=comment.data[0])

tests/fixtures/arch_monorepo/apps/api/routes/users.py

@@ -0,0 +1,48 @@
+from flask import Blueprint, request, jsonify
+
+users_bp = Blueprint("users", __name__)
+
+
+@users_bp.route("/me", methods=["GET"])
+@login_required
+def get_profile():
+    user = db.table("users").select("*").eq("id", request.user_id).single().execute()
+    return jsonify(user=user.data)
+
+
+@users_bp.route("/me", methods=["PUT"])
+@login_required
+def update_profile():
+    display_name = request.json.get("display_name")
+    bio = request.json.get("bio")
+    avatar_url = request.json.get("avatar_url")
+    user = db.table("users").update({
+        "display_name": display_name,
+        "bio": bio,
+        "avatar_url": avatar_url,
+    }).eq("id", request.user_id).execute()
+    return jsonify(user=user.data[0])
+
+
+@users_bp.route("/me/avatar", methods=["POST"])
+@login_required
+def upload_avatar():
+    file = request.files["avatar"]
+    url = storage.upload(f"avatars/{request.user_id}", file)
+    db.table("users").update({"avatar_url": url}).eq("id", request.user_id).execute()
+    return jsonify(avatar_url=url)
+
+
+@users_bp.route("/<user_id>", methods=["GET"])
+@login_required
+def get_user(user_id):
+    user = db.table("users").select("id, display_name, bio, avatar_url").eq("id", user_id).single().execute()
+    return jsonify(user=user.data)
+
+
+@users_bp.route("/search", methods=["GET"])
+@login_required
+def search_users():
+    query = request.args.get("q", "")
+    users = db.table("users").select("id, display_name, avatar_url").ilike("display_name", f"%{query}%").execute()
+    return jsonify(users=users.data)

tests/fixtures/arch_monorepo/apps/api/services/email.py

@@ -0,0 +1,11 @@
+"""Email notification service — sends via Celery background tasks."""
+
+
+def send_invite_email(email, workspace_name, invited_by_name):
+    """Queue an invite email for async delivery."""
+    pass
+
+
+def send_task_notification(user_email, task_title, action):
+    """Queue a task notification email."""
+    pass

tests/fixtures/backend_b/app.py

@@ -0,0 +1,17 @@
+from flask import Flask, jsonify
+
+app = Flask(__name__)
+
+
+@app.route("/api/reports", methods=["GET"])
+def list_reports():
+    reports = db.table("reports").select("*").execute()
+    return jsonify(data=reports.data)
+
+
+@app.route("/api/user-stats/<user_id>", methods=["GET"])
+def user_stats(user_id):
+    # This service also reads from the 'users' table — shared with flask_app
+    user = db.table("users").select("name, email").eq("id", user_id).execute()
+    stats = db.table("reports").select("*").eq("user_id", user_id).execute()
+    return jsonify(user=user.data[0], report_count=len(stats.data))

tests/fixtures/fastapi_app/app.py

@@ -0,0 +1,48 @@
+from fastapi import FastAPI, Depends
+from pydantic import BaseModel
+from typing import Optional
+
+app = FastAPI()
+
+
+class ItemCreate(BaseModel):
+    name: str
+    price: float
+    description: Optional[str] = None
+    category: str
+
+
+class ItemResponse(BaseModel):
+    id: int
+    name: str
+    price: float
+
+
+class UserCreate(BaseModel):
+    email: str
+    password: str
+    display_name: str
+
+
+def get_current_user():
+    pass
+
+
+@app.post("/api/items")
+def create_item(item: ItemCreate):
+    return {"id": 1, "name": item.name, "price": item.price}
+
+
+@app.get("/api/items/{item_id}")
+def get_item(item_id: int):
+    return {"id": item_id, "name": "Test", "price": 9.99}
+
+
+@app.post("/api/users", response_model=UserCreate)
+def create_user(user: UserCreate, current_user=Depends(get_current_user)):
+    return user
+
+
+@app.delete("/api/items/{item_id}")
+def delete_item(item_id: int, current_user=Depends(get_current_user)):
+    return {"status": "deleted"}

tests/fixtures/fastapi_crossfile/routes.py

@@ -0,0 +1,18 @@
+from fastapi import FastAPI, Depends
+from .schemas import UserCreate, UserResponse, ItemCreate
+
+app = FastAPI()
+
+
+def get_current_user():
+    pass
+
+
+@app.post("/api/users")
+def create_user(user: UserCreate):
+    return {"id": 1, "email": user.email}
+
+
+@app.post("/api/items")
+def create_item(item: ItemCreate, current_user=Depends(get_current_user)):
+    return {"id": 1, "name": item.name}

tests/fixtures/fastapi_crossfile/schemas.py

@@ -0,0 +1,21 @@
+from pydantic import BaseModel
+from typing import Optional
+
+
+class UserCreate(BaseModel):
+    email: str
+    password: str
+    display_name: str
+
+
+class UserResponse(BaseModel):
+    id: int
+    email: str
+    display_name: str
+    is_active: bool = True
+
+
+class ItemCreate(BaseModel):
+    name: str
+    price: float
+    description: Optional[str] = None

tests/fixtures/flask_app/app.py

@@ -0,0 +1,33 @@
+from flask import Flask, request, jsonify
+
+app = Flask(__name__)
+
+
+@app.route("/api/users", methods=["GET"])
+@login_required
+def list_users():
+    users = db.table("users").select("*").execute()
+    return jsonify(data=users.data, count=len(users.data))
+
+
+@app.route("/api/users/<user_id>", methods=["GET"])
+@login_required
+def get_user(user_id):
+    user = db.table("users").select("*").eq("id", user_id).execute()
+    return jsonify(data=user.data[0])
+
+
+@app.route("/api/users", methods=["POST"])
+def create_user():
+    name = request.json["name"]
+    email = request.json["email"]
+    password = request.json["password"]
+    user = db.table("users").insert({"name": name, "email": email}).execute()
+    return jsonify(id=user.data[0]["id"], status="created")
+
+
+@app.route("/api/items/<item_id>", methods=["DELETE"])
+@login_required
+def delete_item(item_id):
+    db.table("items").delete().eq("id", item_id).execute()
+    return jsonify(status="deleted")

tests/fixtures/flask_blueprint/app.py

@@ -0,0 +1,7 @@
+from flask import Flask
+from .routes.users import users_bp
+from .routes.items import items_bp
+
+app = Flask(__name__)
+app.register_blueprint(users_bp, url_prefix="/api/v1/users")
+app.register_blueprint(items_bp, url_prefix="/api/v1/items")

tests/fixtures/flask_blueprint/routes/items.py

@@ -0,0 +1,13 @@
+from flask import Blueprint, request, jsonify
+
+items_bp = Blueprint("items", __name__)
+
+
+@items_bp.get("/")
+def list_items():
+    return jsonify(items=[])
+
+
+@items_bp.delete("/<item_id>")
+def delete_item(item_id):
+    return jsonify(status="deleted")

tests/fixtures/flask_blueprint/routes/users.py

@@ -0,0 +1,20 @@
+from flask import Blueprint, request, jsonify
+
+users_bp = Blueprint("users", __name__)
+
+
+@users_bp.route("/", methods=["GET"])
+def list_users():
+    return jsonify(users=[])
+
+
+@users_bp.route("/<user_id>", methods=["GET"])
+def get_user(user_id):
+    return jsonify(id=user_id, name="John")
+
+
+@users_bp.route("/", methods=["POST"])
+def create_user():
+    name = request.json["name"]
+    email = request.json["email"]
+    return jsonify(id=1, name=name)

tests/fixtures/middleware_test_flask/routes/public.py

@@ -0,0 +1,8 @@
+from flask import Blueprint, jsonify
+
+bp = Blueprint("public", __name__)
+
+
+@bp.route("/health", methods=["GET"])
+def health():
+    return jsonify(status="ok")

tests/fixtures/middleware_test_flask/routes/users.py

@@ -0,0 +1,26 @@
+from flask import Blueprint, request, jsonify
+
+bp = Blueprint("users", __name__)
+
+
+@bp.before_request
+def require_auth():
+    """All routes on this blueprint require authentication."""
+    if not request.headers.get("Authorization"):
+        return jsonify(error="Unauthorized"), 401
+
+
+@bp.route("/", methods=["GET"])
+def list_users():
+    return jsonify(users=[])
+
+
+@bp.route("/<user_id>", methods=["GET"])
+def get_user(user_id):
+    return jsonify(id=user_id, name="John")
+
+
+@bp.route("/", methods=["POST"])
+def create_user():
+    name = request.json["name"]
+    return jsonify(id=1, name=name)

tests/fixtures/python_deep_imports/app/api/health.py

@@ -0,0 +1,11 @@
+from fastapi import APIRouter
+
+# One level up: from app/api/ -> app/shared/models.py (../shared.models)
+from ..shared.models import PaginationParams
+
+router = APIRouter()
+
+
+@router.get("/health")
+def health_check():
+    return {"status": "ok"}

tests/fixtures/python_deep_imports/app/api/v1/items.py

@@ -0,0 +1,18 @@
+from fastapi import APIRouter
+
+# Two levels up to schemas
+from ...schemas.item import ItemCreate, ItemUpdate
+
+router = APIRouter()
+
+
+@router.post("/items")
+def create_item(item: ItemCreate):
+    result = db.table("items").insert({"name": item.name, "price": item.price}).execute()
+    return {"id": 1, "name": item.name}
+
+
+@router.put("/items/{item_id}")
+def update_item(item_id: int, item: ItemUpdate):
+    db.table("items").update({"name": item.name}).eq("id", item_id).execute()
+    return {"status": "updated"}

tests/fixtures/python_deep_imports/app/api/v1/users.py

@@ -0,0 +1,27 @@
+from fastapi import APIRouter, Depends
+
+# Two levels up: from app/api/v1/ -> app/schemas/user.py (../../schemas.user)
+from ...schemas.user import UserCreate, UserResponse
+
+# Three levels relative: from app/api/v1/ -> app/shared/models.py (../../shared.models)
+from ...shared.models import PaginationParams
+
+router = APIRouter()
+
+
+@router.get("/users")
+def list_users(pagination: PaginationParams):
+    users = db.table("users").select("*").execute()
+    return {"users": users.data, "page": pagination.page}
+
+
+@router.post("/users")
+def create_user(user: UserCreate):
+    result = db.table("users").insert({"email": user.email}).execute()
+    return {"id": result.data[0]["id"], "email": user.email}
+
+
+@router.get("/users/{user_id}")
+def get_user(user_id: int):
+    user = db.table("users").select("*").eq("id", user_id).execute()
+    return {"user": user.data[0]}