kinemotion 0.48.0__tar.gz → 0.49.0__tar.gz

kinemotion-0.49.0/.basic-memory/development/feature-request-system-configuration.md

@@ -0,0 +1,97 @@
+---
+title: Feature Request System Configuration
+type: note
+permalink: development/feature-request-system-configuration
+---
+
+# Feature Request & Feedback System Configuration
+
+## Frontend Configuration
+
+### External Links Setup
+Edit `frontend/src/config/links.ts`:
+
+```typescript
+export const EXTERNAL_LINKS = {
+  // Replace with actual Google Forms URL
+  FEATURE_REQUEST: 'https://docs.google.com/forms/d/e/YOUR_FORM_ID/viewform',
+  GITHUB_ISSUES: 'https://github.com/feniix/kinemotion/issues',
+  DOCUMENTATION: 'https://github.com/feniix/kinemotion#readme',
+} as const
+
+export const UI_CONFIG = {
+  FEATURE_REQUEST: {
+    enabled: true,
+    buttonText: 'Request Feature',
+    buttonIcon: '💡',
+    tooltip: 'Share your ideas and suggestions for improving Kinemotion',
+    openInNewTab: true,
+  },
+} as const
+```
+
+### Google Forms Setup
+
+1. Create form at [Google Forms](https://forms.google.com)
+2. Include fields:
+   - Feature category (Analysis, UI, Performance, etc.)
+   - Feature description
+   - Use case/priority
+   - Additional comments
+3. Get form URL and update FEATURE_REQUEST constant
+
+## Component Usage
+
+### FeatureRequestButton Props
+```typescript
+<FeatureRequestButton
+  variant="primary"     // or "secondary"
+  size="medium"          // "small", "medium", "large"
+  showIcon={true}
+  className="custom-class"
+/>
+```
+
+### Button Styles
+- **Primary**: Blue background (`#6366f1`), white text
+- **Secondary**: Light gray background (`#f3f4f6`), dark text
+- **Sizes**: Small (0.75rem font), Medium (0.875rem), Large (1rem font)
+
+## Database Detection
+
+The frontend automatically detects backend database connectivity:
+
+```typescript
+const { status: dbStatus, loading: dbLoading } = useDatabaseStatus()
+
+// Conditional UI rendering
+{dbStatus?.database_connected && (
+  <button>Add Coach Feedback</button>
+)}
+
+{!dbStatus?.database_connected && (
+  <span>Database Offline - Feedback Unavailable</span>
+)}
+```
+
+## Files Created
+- `frontend/src/components/FeatureRequestButton.tsx`
+- `frontend/src/components/FeedbackForm.tsx`
+- `frontend/src/hooks/useDatabaseStatus.ts`
+- `frontend/src/config/links.ts`
+
+## Integration Points
+- **ResultsDisplay**: Dedicated feedback section
+- **Health Check**: Database status in `/health` endpoint
+- **Analytics**: Google Analytics tracking included
+
+## User Flow
+1. Analysis completes → Results display
+2. "Share Your Feedback" section appears
+3. Options based on database status:
+   - Database connected: Coach feedback + feature request + report issue
+   - Database offline: Feature request + report issue + error message
+4. Feature request opens Google Forms in new tab
+5. Coach feedback saves to Supabase (if connected)
+
+This system provides comprehensive user feedback collection while maintaining a seamless experience.

kinemotion-0.49.0/.basic-memory/development/supabase-database-integration-setup.md

@@ -0,0 +1,104 @@
+---
+title: Supabase Database Integration Setup
+type: note
+permalink: development/supabase-database-integration-setup
+---
+
+# Supabase Database Integration for Coach Feedback
+
+## Database Schema
+
+Run this SQL in Supabase SQL Editor to create the required tables:
+
+```sql
+-- Analysis Sessions Table
+CREATE TABLE IF NOT EXISTS analysis_sessions (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+    jump_type VARCHAR(50) NOT NULL CHECK (jump_type IN ('cmj', 'drop_jump')),
+    quality_preset VARCHAR(20) NOT NULL CHECK (quality_preset IN ('fast', 'balanced', 'accurate')),
+    original_video_url TEXT,
+    debug_video_url TEXT,
+    results_json_url TEXT,
+    analysis_data JSONB NOT NULL,
+    processing_time_s FLOAT,
+    upload_id VARCHAR(50),
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- Coach Feedback Table
+CREATE TABLE IF NOT EXISTS coach_feedback (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    analysis_session_id UUID NOT NULL REFERENCES analysis_sessions(id) ON DELETE CASCADE,
+    coach_user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+    notes TEXT,
+    rating INTEGER CHECK (rating >= 1 AND rating <= 5),
+    tags TEXT[] DEFAULT '{}',
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- Indexes and RLS policies included in full schema
+```
+
+## Backend Integration
+
+### New Files Created:
+- `backend/src/kinemotion_backend/database.py` - Async Supabase client
+- `backend/src/kinemotion_backend/analysis_api.py` - Feedback API endpoints
+- `backend/src/kinemotion_backend/models.py` - Pydantic models
+- `backend/supabase-schema.sql` - Complete database schema
+
+### API Endpoints:
+- `POST /api/analysis/sessions` - Create analysis sessions
+- `GET /api/analysis/sessions` - List user sessions
+- `GET /api/analysis/sessions/{id}` - Get session with feedback
+- `POST /api/analysis/sessions/{id}/feedback` - Add coach feedback
+- `GET /api/analysis/database-status` - Check database connection
+
+### Key Features:
+- Optional authentication (works with/without user login)
+- JSONB storage for flexible analysis data querying
+- Row Level Security for data privacy
+- Async database operations
+- Graceful error handling
+
+## Frontend Integration
+
+### Components Added:
+- `FeedbackForm.tsx` - Modal feedback form with rating, tags, notes
+- `FeatureRequestButton.tsx` - Reusable feature request button
+- `useDatabaseStatus.ts` - Hook for checking database connectivity
+
+### Configuration:
+- `config/links.ts` - External links and UI settings
+- Google Forms integration for feature requests
+- Conditional UI based on database status
+
+### User Experience:
+- Smart feedback section with multiple options
+- Database connection detection
+- Responsive design
+- Analytics tracking ready
+
+## Setup Requirements:
+1. Run database schema in Supabase
+2. Configure SUPABASE_URL and SUPABASE_ANON_KEY
+3. Update Google Forms URL in frontend config
+4. Test integration with authenticated/unauthenticated users
+
+## Example Queries:
+```sql
+-- Average jump height by user
+SELECT user_id, AVG((analysis_data->'data'->>'jump_height')::float) as avg_jump_height
+FROM analysis_sessions WHERE jump_type = 'cmj' GROUP BY user_id;
+
+-- Sessions with feedback
+SELECT s.*, f.rating, f.notes
+FROM analysis_sessions s
+LEFT JOIN coach_feedback f ON s.id = f.analysis_session_id
+WHERE f.id IS NOT NULL;
+```
+
+This system enables comprehensive coach feedback collection and athlete performance tracking.

{kinemotion-0.48.0 → kinemotion-0.49.0}/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- version list -->
 
+## v0.49.0 (2025-12-13)
+
+### Bug Fixes
+
+- Normalize timing log event names to proper snake_case keys
+  ([`ecbb154`](https://github.com/feniix/kinemotion/commit/ecbb154dc19f2de47c10bea9f638b13eb71026b4))
+
+### Chores
+
+- Update sonar app version
+  ([`2975f7b`](https://github.com/feniix/kinemotion/commit/2975f7bf0ab4732ca92f7c9728ed3d8911992ca1))
+
+### Features
+
+- Implement comprehensive feedback system with Supabase database integration
+  ([`9bcf73f`](https://github.com/feniix/kinemotion/commit/9bcf73f79436e2b4de900b58f95258719fcdce80))
+
+
 ## v0.48.0 (2025-12-12)
 
 ### Chores

{kinemotion-0.48.0 → kinemotion-0.49.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.48.0
+Version: 0.49.0
 Summary: Video-based kinematic analysis for athletic performance
 Project-URL: Homepage, https://github.com/feniix/kinemotion
 Project-URL: Repository, https://github.com/feniix/kinemotion

kinemotion-0.49.0/backend/src/kinemotion_backend/analysis_api.py

@@ -0,0 +1,303 @@
+"""API endpoints for analysis sessions and coach feedback."""
+
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+
+from kinemotion_backend.auth import SupabaseAuth
+from kinemotion_backend.database import get_database_client
+from kinemotion_backend.models import (
+    AnalysisSessionCreate,
+    AnalysisSessionResponse,
+    AnalysisSessionWithFeedback,
+    CoachFeedbackCreate,
+    CoachFeedbackResponse,
+    DatabaseError,
+)
+
+logger = structlog.get_logger()
+router = APIRouter(prefix="/api/analysis", tags=["Analysis"])
+security = HTTPBearer()
+auth = SupabaseAuth()
+
+
+async def get_current_user_id(
+    credentials: HTTPAuthorizationCredentials = Depends(security),  # noqa: B008
+) -> str:
+    """Extract user ID from JWT token."""
+    try:
+        return auth.get_user_id(credentials.credentials)
+    except Exception as e:
+        logger.warning("user_authentication_failed", error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication credentials",
+        ) from e
+
+
+@router.post(
+    "/sessions",
+    response_model=AnalysisSessionResponse,
+    status_code=status.HTTP_201_CREATED,
+    responses={400: {"model": DatabaseError}, 500: {"model": DatabaseError}},
+)
+async def create_analysis_session(
+    session_data: AnalysisSessionCreate,
+    user_id: str = Depends(get_current_user_id),
+) -> AnalysisSessionResponse:
+    """Create a new analysis session record.
+
+    This endpoint stores analysis metadata and results in the database.
+    It's typically called after video analysis is completed.
+    """
+    try:
+        db_client = get_database_client()
+        session_record = await db_client.create_analysis_session(
+            user_id=user_id,
+            jump_type=session_data.jump_type,
+            quality_preset=session_data.quality_preset,
+            analysis_data=session_data.analysis_data,
+            original_video_url=session_data.original_video_url,
+            debug_video_url=session_data.debug_video_url,
+            results_json_url=session_data.results_json_url,
+            processing_time_s=session_data.processing_time_s,
+            upload_id=session_data.upload_id,
+        )
+
+        logger.info(
+            "analysis_session_api_created",
+            session_id=session_record["id"],
+            user_id=user_id,
+            jump_type=session_data.jump_type,
+        )
+
+        return AnalysisSessionResponse(**session_record)
+
+    except Exception as e:
+        logger.error(
+            "create_analysis_session_api_error",
+            error=str(e),
+            user_id=user_id,
+            exc_info=True,
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to create analysis session: {str(e)}",
+        ) from e
+
+
+@router.get(
+    "/sessions",
+    response_model=list[AnalysisSessionResponse],
+    responses={401: {"model": DatabaseError}, 500: {"model": DatabaseError}},
+)
+async def get_user_analysis_sessions(
+    limit: int = 50,
+    user_id: str = Depends(get_current_user_id),
+) -> list[AnalysisSessionResponse]:
+    """Get analysis sessions for the current user.
+
+    Args:
+        limit: Maximum number of sessions to return (default: 50)
+    """
+    try:
+        if limit <= 0 or limit > 100:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Limit must be between 1 and 100",
+            )
+
+        db_client = get_database_client()
+        sessions = await db_client.get_user_analysis_sessions(
+            user_id=user_id, limit=limit
+        )
+
+        logger.info(
+            "user_analysis_sessions_api_retrieved",
+            user_id=user_id,
+            count=len(sessions),
+        )
+
+        return [AnalysisSessionResponse(**session) for session in sessions]
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(
+            "get_user_analysis_sessions_api_error",
+            error=str(e),
+            user_id=user_id,
+            exc_info=True,
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to retrieve analysis sessions: {str(e)}",
+        ) from e
+
+
+@router.get(
+    "/sessions/{session_id}",
+    response_model=AnalysisSessionWithFeedback,
+    responses={
+        401: {"model": DatabaseError},
+        404: {"model": DatabaseError},
+        500: {"model": DatabaseError},
+    },
+)
+async def get_analysis_session(
+    session_id: str,
+    user_id: str = Depends(get_current_user_id),
+) -> AnalysisSessionWithFeedback:
+    """Get a specific analysis session with feedback.
+
+    Users can only access their own analysis sessions.
+    """
+    try:
+        db_client = get_database_client()
+        session = await db_client.get_analysis_session(
+            session_id=session_id, user_id=user_id
+        )
+
+        if not session:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Analysis session not found",
+            )
+
+        # Get feedback for this session
+        feedback = await db_client.get_session_feedback(analysis_session_id=session_id)
+
+        logger.info(
+            "analysis_session_api_retrieved",
+            session_id=session_id,
+            user_id=user_id,
+            feedback_count=len(feedback),
+        )
+
+        session_with_feedback = AnalysisSessionWithFeedback(**session)
+        session_with_feedback.feedback = [
+            CoachFeedbackResponse(**fb) for fb in feedback
+        ]
+
+        return session_with_feedback
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(
+            "get_analysis_session_api_error",
+            error=str(e),
+            session_id=session_id,
+            user_id=user_id,
+            exc_info=True,
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to retrieve analysis session: {str(e)}",
+        ) from e
+
+
+@router.get(
+    "/database-status",
+    response_model=dict[str, Any],
+    responses={500: {"model": DatabaseError}},
+)
+async def get_database_status() -> dict[str, Any]:
+    """Check if the database is connected and working."""
+    try:
+        db_client = get_database_client()
+
+        # Try a simple query to test the connection
+        # We'll test by trying to access the analysis_sessions table
+        db_client.client.table("analysis_sessions").select("id").limit(1).execute()
+
+        return {
+            "database_connected": True,
+            "tables_exist": True,
+            "message": "Database connection successful",
+        }
+
+    except Exception as e:
+        logger.error("database_status_check_failed", error=str(e), exc_info=True)
+        return {
+            "database_connected": False,
+            "tables_exist": False,
+            "message": f"Database connection failed: {str(e)}",
+        }
+
+
+@router.post(
+    "/sessions/{session_id}/feedback",
+    response_model=CoachFeedbackResponse,
+    status_code=status.HTTP_201_CREATED,
+    responses={
+        400: {"model": DatabaseError},
+        401: {"model": DatabaseError},
+        404: {"model": DatabaseError},
+        500: {"model": DatabaseError},
+    },
+)
+async def create_coach_feedback(
+    session_id: str,
+    feedback_data: CoachFeedbackCreate,
+    coach_user_id: str = Depends(get_current_user_id),
+) -> CoachFeedbackResponse:
+    """Add coach feedback to an analysis session.
+
+    Any authenticated user can provide feedback on analysis sessions.
+    """
+    try:
+        # Validate that the session exists
+        db_client = get_database_client()
+        session = await db_client.get_analysis_session(
+            session_id=session_id, user_id=coach_user_id
+        )
+
+        if not session:
+            # Try to get session without user restriction
+            # (coaches can provide feedback on any session)
+            # This would require modifying the database client
+            # to allow unrestricted access for feedback
+            # For now, we'll assume users can only provide feedback
+            # on their own sessions
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Analysis session not found",
+            )
+
+        # Override the session_id from the URL to ensure consistency
+        feedback_data.analysis_session_id = session_id
+
+        feedback_record = await db_client.create_coach_feedback(
+            analysis_session_id=session_id,
+            coach_user_id=coach_user_id,
+            notes=feedback_data.notes,
+            rating=feedback_data.rating,
+            tags=feedback_data.tags,
+        )
+
+        logger.info(
+            "coach_feedback_api_created",
+            feedback_id=feedback_record["id"],
+            session_id=session_id,
+            coach_user_id=coach_user_id,
+        )
+
+        return CoachFeedbackResponse(**feedback_record)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(
+            "create_coach_feedback_api_error",
+            error=str(e),
+            session_id=session_id,
+            coach_user_id=coach_user_id,
+            exc_info=True,
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to create coach feedback: {str(e)}",
+        ) from e

{kinemotion-0.48.0 → kinemotion-0.49.0}/backend/src/kinemotion_backend/app.py

@@ -4,6 +4,7 @@ Real metrics integration with Cloudflare R2 storage for video and results manage
 """
 
 import os
+import re
 import tempfile
 from contextlib import asynccontextmanager
 from datetime import datetime, timezone
@@ -33,6 +34,8 @@ from kinemotion.core.timing import (
 from slowapi import Limiter, _rate_limit_exceeded_handler
 from slowapi.util import get_remote_address
 
+from kinemotion_backend.analysis_api import router as analysis_router
+from kinemotion_backend.database import get_database_client
 from kinemotion_backend.logging_config import get_logger, setup_logging
 from kinemotion_backend.middleware import RequestLoggingMiddleware
 
@@ -360,6 +363,8 @@ try:
 except ValueError:
     logger.warning("r2_storage_not_configured", message="R2 credentials not provided")
 
+# Include analysis API router
+app.include_router(analysis_router)
 
 # ========== Helper Functions ==========
 
@@ -520,6 +525,18 @@ async def health_check() -> dict[str, Any]:
     except Exception:
         kinemotion_version = "unknown"
 
+    # Check database connection
+    database_connected = False
+    try:
+        from kinemotion_backend.database import get_database_client
+
+        db_client = get_database_client()
+        # Test database with a simple query
+        db_client.client.table("analysis_sessions").select("id").limit(1).execute()
+        database_connected = True
+    except Exception as db_error:
+        logger.warning("database_health_check_failed", error=str(db_error))
+
     return {
         "status": "ok",
         "service": "kinemotion-backend",
@@ -528,6 +545,7 @@ async def health_check() -> dict[str, Any]:
         "timestamp": datetime.now(timezone.utc).isoformat(),
         "r2_configured": r2_client is not None,
         "trackers_initialized": len(global_pose_trackers) > 0,
+        "database_connected": database_connected,
     }
 
 
@@ -672,9 +690,10 @@ async def analyze_video(
             and "timing_breakdown_ms" in metrics["metadata"]["processing"]
         ):
             timing_breakdown = metrics["metadata"]["processing"]["timing_breakdown_ms"]
-            # Normalize keys for easier jq parsing: spaces → underscores, lowercase
+            # Normalize keys: remove special chars, spaces → underscores, lowercase
             normalized_timings = {
-                stage.lower().replace(" ", "_") + "_ms": duration
+                re.sub(r"[^\w\s]", "", stage).lower().replace(" ", "_")
+                + "_ms": duration
                 for stage, duration in timing_breakdown.items()
             }
             # Log each timing stage as a separate event for granular monitoring
@@ -744,6 +763,51 @@ async def analyze_video(
                     )
         processing_time = time.time() - start_time
 
+        # Optionally store analysis session in database if user is authenticated
+        user_id = None
+        try:
+            auth_header = request.headers.get("Authorization")
+            if auth_header and auth_header.startswith("Bearer "):
+                from kinemotion_backend.auth import SupabaseAuth
+
+                auth = SupabaseAuth()
+                token = auth_header.split(" ")[1]
+                user_id = auth.get_user_id(token)
+                logger.info("user_authenticated_for_analysis", user_id=user_id)
+        except Exception as e:
+            logger.info("analysis_save_no_auth", reason=str(e))
+            user_id = None
+
+        # Store in database if authenticated
+        session_id = None
+        if user_id:
+            try:
+                db_client = get_database_client()
+                session_record = await db_client.create_analysis_session(
+                    user_id=user_id,
+                    jump_type=jump_type,
+                    quality_preset=quality,
+                    analysis_data=metrics,
+                    original_video_url=original_video_url,
+                    debug_video_url=debug_video_url,
+                    results_json_url=results_url,
+                    processing_time_s=processing_time,
+                    upload_id=upload_id,
+                )
+                session_id = session_record["id"]
+                logger.info(
+                    "analysis_session_saved",
+                    session_id=session_id,
+                    user_id=user_id,
+                )
+            except Exception as e:
+                # Log error but don't fail the analysis - this is optional storage
+                logger.warning(
+                    "analysis_session_save_failed",
+                    error=str(e),
+                    user_id=user_id,
+                )
+
         # Build successful response
         jump_type_display = "drop_jump" if jump_type == "drop_jump" else "cmj"
         response = AnalysisResponse(