scriptgini 1.3.1__tar.gz → 1.4.0__tar.gz

{scriptgini-1.3.1 → scriptgini-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptgini
-Version: 1.3.1
+Version: 1.4.0
 Summary: Agentic AI system that converts functional test cases into automation test scripts.
 Author: ScriptGini Team
 License: Proprietary
@@ -443,7 +443,7 @@ The project follows an **enterprise-grade development roadmap** with 6 sprints c
 | **Sprint 2** | RBAC + Multi-Tenancy | 32-38pts | 🟡 Core delivered (RBAC hardening pending) |
 | **Sprint 3** | Durable Execution | 34-40pts | ✅ Completed (Redis + Celery queue foundation) |
 | **Sprint 4** | Security & Hardening | 30-36pts | 🟡 In progress (isolation boundary + breakout tests pending) |
-| **Sprint 5** | Reporting & Analytics | 28-34pts | 🔲 Pending (Artifact storage, dashboards) |
+| **Sprint 5** | Reporting & Analytics | 28-34pts | ✅ Completed (Reports APIs, trends/flakiness, retention cleanup) |
 | **Sprint 6** | Advanced Features | 24-30pts | 🔲 Pending (Webhooks, defect sync, versioning) |
 
 ---

{scriptgini-1.3.1 → scriptgini-1.4.0}/README.md

@@ -429,7 +429,7 @@ The project follows an **enterprise-grade development roadmap** with 6 sprints c
 | **Sprint 2** | RBAC + Multi-Tenancy | 32-38pts | 🟡 Core delivered (RBAC hardening pending) |
 | **Sprint 3** | Durable Execution | 34-40pts | ✅ Completed (Redis + Celery queue foundation) |
 | **Sprint 4** | Security & Hardening | 30-36pts | 🟡 In progress (isolation boundary + breakout tests pending) |
-| **Sprint 5** | Reporting & Analytics | 28-34pts | 🔲 Pending (Artifact storage, dashboards) |
+| **Sprint 5** | Reporting & Analytics | 28-34pts | ✅ Completed (Reports APIs, trends/flakiness, retention cleanup) |
 | **Sprint 6** | Advanced Features | 24-30pts | 🔲 Pending (Webhooks, defect sync, versioning) |
 
 ---

scriptgini-1.4.0/app/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "1.4.0"
+__api_version__ = "v1.4.0"
+

{scriptgini-1.3.1 → scriptgini-1.4.0}/app/config.py

@@ -40,6 +40,7 @@ class Settings(BaseSettings):
     SCRIPT_GENERATION_TIMEOUT_SECONDS: int = 180
     PLAYWRIGHT_RUN_HEADED: bool = True
     SCRIPT_EXECUTION_TIMEOUT_SECONDS: int = 300
+    ARTIFACT_RETENTION_DAYS: int = 30
     EXECUTION_ENV_ALLOWED_KEYS: str = "PATH,SYSTEMROOT,TEMP,TMP,HOME,USERPROFILE,PYTHONPATH,PYTHONHOME,PYTHONIOENCODING"
     EXECUTION_ENV_ALLOWED_PREFIXES: str = "PLAYWRIGHT_"
     SKIP_REVIEW_FOR_OLLAMA: bool = True

{scriptgini-1.3.1 → scriptgini-1.4.0}/app/main.py

@@ -14,7 +14,19 @@ from fastapi.staticfiles import StaticFiles
 from app import __version__
 from app.config import settings
 from app.llm.provider import get_llm_diagnostics
-from app.routers import projects, test_cases, scripts, bulk_jobs, analytics, demo, auth, api_key, organizations, execution
+from app.routers import (
+    analytics,
+    api_key,
+    auth,
+    bulk_jobs,
+    demo,
+    execution,
+    organizations,
+    projects,
+    reports,
+    scripts,
+    test_cases,
+)
 
 logging.basicConfig(level=logging.DEBUG if settings.DEBUG else logging.INFO)
 logger = logging.getLogger(__name__)
@@ -148,11 +160,13 @@ app.include_router(test_cases.router, prefix="/api/v1")
 app.include_router(scripts.router, prefix="/api/v1")
 app.include_router(bulk_jobs.router, prefix="/api/v1")
 app.include_router(analytics.router, prefix="/api/v1")
+app.include_router(analytics.insights_router, prefix="/api/v1")
 app.include_router(demo.router, prefix="/api/v1")
 app.include_router(auth.router, prefix="/api/v1")
 app.include_router(api_key.router, prefix="/api/v1")
 app.include_router(organizations.router, prefix="/api/v1")
 app.include_router(execution.router, prefix="/api/v1")
+app.include_router(reports.router, prefix="/api/v1")
 app.mount("/static", StaticFiles(directory=static_dir), name="static")
 
 

scriptgini-1.4.0/app/routers/analytics.py

@@ -0,0 +1,198 @@
+from datetime import date, datetime, time, timezone
+
+from sqlalchemy import case, func
+from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends, HTTPException
+
+from app.database import get_db
+from app.models.project import Project
+from app.models.script_run import ScriptRun, ScriptRunStatus
+from app.models.test_case import TestCase
+from app.schemas.analytics import (
+    FlakinessItemResponse,
+    FlakinessResponse,
+    RecentFailureResponse,
+    RunAnalyticsResponse,
+    TrendPointResponse,
+    TrendsResponse,
+)
+
+router = APIRouter(prefix="/projects/{project_id}/analytics", tags=["Run Analytics"])
+insights_router = APIRouter(prefix="/analytics", tags=["Run Analytics"])
+
+
+@router.get("/runs", response_model=RunAnalyticsResponse)
+def get_run_analytics(project_id: int, db: Session = Depends(get_db)):
+    project = db.query(Project).filter(Project.id == project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    aggregate = (
+        db.query(
+            func.count(ScriptRun.id),
+            func.sum(case((ScriptRun.success.is_(True), 1), else_=0)),
+            func.sum(case((ScriptRun.status == ScriptRunStatus.failed, 1), else_=0)),
+            func.sum(case((ScriptRun.status == ScriptRunStatus.timed_out, 1), else_=0)),
+            func.avg(ScriptRun.duration_seconds),
+        )
+        .filter(ScriptRun.project_id == project_id)
+        .one()
+    )
+
+    total_runs = int(aggregate[0] or 0)
+    success_runs = int(aggregate[1] or 0)
+    failed_runs = int(aggregate[2] or 0)
+    timed_out_runs = int(aggregate[3] or 0)
+    avg_duration = float(aggregate[4] or 0.0)
+
+    failed_items = (
+        db.query(ScriptRun, TestCase.title)
+        .outerjoin(TestCase, TestCase.id == ScriptRun.test_case_id)
+        .filter(ScriptRun.project_id == project_id)
+        .filter(ScriptRun.success.is_(False))
+        .order_by(ScriptRun.created_at.desc(), ScriptRun.id.desc())
+        .limit(10)
+        .all()
+    )
+
+    recent_failures = [
+        RecentFailureResponse(
+            run_id=run.id,
+            script_id=run.script_id,
+            test_case_id=run.test_case_id,
+            test_case_title=tc_title,
+            exit_code=run.exit_code,
+            duration_seconds=run.duration_seconds,
+            stderr_excerpt=(run.stderr or "")[:240],
+            created_at=run.created_at,
+        )
+        for run, tc_title in failed_items
+    ]
+
+    success_rate = round((success_runs / total_runs) * 100, 2) if total_runs else 0.0
+
+    return RunAnalyticsResponse(
+        project_id=project_id,
+        total_runs=total_runs,
+        success_runs=success_runs,
+        failed_runs=failed_runs,
+        timed_out_runs=timed_out_runs,
+        success_rate=success_rate,
+        average_duration_seconds=round(avg_duration, 2),
+        recent_failures=recent_failures,
+    )
+
+
+def _resolve_datetime_range(start_date: date | None, end_date: date | None) -> tuple[datetime | None, datetime | None]:
+    start_dt = datetime.combine(start_date, time.min, tzinfo=timezone.utc) if start_date else None
+    end_dt = datetime.combine(end_date, time.max, tzinfo=timezone.utc) if end_date else None
+    return start_dt, end_dt
+
+
+@insights_router.get("/trends", response_model=TrendsResponse)
+def get_trends(
+    project_id: int | None = None,
+    start_date: date | None = None,
+    end_date: date | None = None,
+    db: Session = Depends(get_db),
+):
+    if project_id is not None:
+        project = db.query(Project).filter(Project.id == project_id).first()
+        if not project:
+            raise HTTPException(status_code=404, detail="Project not found")
+
+    start_dt, end_dt = _resolve_datetime_range(start_date, end_date)
+    bucket_expr = func.date(ScriptRun.created_at)
+    query = (
+        db.query(
+            bucket_expr.label("bucket"),
+            func.count(ScriptRun.id).label("total_runs"),
+            func.sum(case((ScriptRun.success.is_(True), 1), else_=0)).label("success_runs"),
+            func.avg(ScriptRun.duration_seconds).label("avg_duration"),
+        )
+        .group_by(bucket_expr)
+        .order_by(bucket_expr.asc())
+    )
+
+    if project_id is not None:
+        query = query.filter(ScriptRun.project_id == project_id)
+    if start_dt is not None:
+        query = query.filter(ScriptRun.created_at >= start_dt)
+    if end_dt is not None:
+        query = query.filter(ScriptRun.created_at <= end_dt)
+
+    points: list[TrendPointResponse] = []
+    for row in query.all():
+        total_runs = int(row.total_runs or 0)
+        success_runs = int(row.success_runs or 0)
+        success_rate = round((success_runs / total_runs) * 100, 2) if total_runs else 0.0
+        points.append(
+            TrendPointResponse(
+                bucket=str(row.bucket),
+                total_runs=total_runs,
+                success_rate=success_rate,
+                average_duration_seconds=round(float(row.avg_duration or 0.0), 2),
+            )
+        )
+
+    return TrendsResponse(project_id=project_id, start_date=start_dt, end_date=end_dt, points=points)
+
+
+@insights_router.get("/flakiness", response_model=FlakinessResponse)
+def get_flakiness(
+    project_id: int | None = None,
+    start_date: date | None = None,
+    end_date: date | None = None,
+    min_runs: int = 3,
+    db: Session = Depends(get_db),
+):
+    if project_id is not None:
+        project = db.query(Project).filter(Project.id == project_id).first()
+        if not project:
+            raise HTTPException(status_code=404, detail="Project not found")
+
+    min_runs = max(1, min_runs)
+    start_dt, end_dt = _resolve_datetime_range(start_date, end_date)
+
+    query = db.query(
+        ScriptRun.script_id.label("script_id"),
+        ScriptRun.test_case_id.label("test_case_id"),
+        func.count(ScriptRun.id).label("total_runs"),
+        func.sum(case((ScriptRun.success.is_(False), 1), else_=0)).label("failed_runs"),
+        func.max(case((ScriptRun.success.is_(False), ScriptRun.created_at), else_=None)).label("last_failure_at"),
+    ).group_by(ScriptRun.script_id, ScriptRun.test_case_id)
+
+    if project_id is not None:
+        query = query.filter(ScriptRun.project_id == project_id)
+    if start_dt is not None:
+        query = query.filter(ScriptRun.created_at >= start_dt)
+    if end_dt is not None:
+        query = query.filter(ScriptRun.created_at <= end_dt)
+
+    rows = query.having(func.count(ScriptRun.id) >= min_runs).all()
+    items: list[FlakinessItemResponse] = []
+    for row in rows:
+        total_runs = int(row.total_runs or 0)
+        failed_runs = int(row.failed_runs or 0)
+        flakiness_score = round((failed_runs / total_runs) * 100, 2) if total_runs else 0.0
+        confidence_score = round(min(1.0, total_runs / 10.0) * 100, 2)
+        items.append(
+            FlakinessItemResponse(
+                script_id=int(row.script_id),
+                test_case_id=int(row.test_case_id),
+                total_runs=total_runs,
+                failed_runs=failed_runs,
+                flakiness_score=flakiness_score,
+                confidence_score=confidence_score,
+                last_failure_at=row.last_failure_at,
+            )
+        )
+
+    items.sort(key=lambda item: (-item.flakiness_score, -item.confidence_score, -item.total_runs))
+    return FlakinessResponse(
+        project_id=project_id,
+        start_date=start_dt,
+        end_date=end_dt,
+        min_runs=min_runs,
+        items=items,
+    )

scriptgini-1.4.0/app/routers/reports.py

@@ -0,0 +1,188 @@
+import base64
+from datetime import datetime, timezone
+from io import BytesIO
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import StreamingResponse
+from sqlalchemy.orm import Session
+
+from app.config import settings
+from app.database import get_db
+from app.models.execution_job import ExecutionJob
+from app.schemas.reports import ArtifactItemResponse, ArtifactListResponse, ExecutionLogsResponse, ExecutionReportResponse
+from app.services import rbac as rbac_service
+from app.services.auth_dependencies import require_auth_with_scopes
+
+router = APIRouter(prefix="/reports", tags=["Reports"])
+
+
+def _ensure_project_access(db: Session, project_id: int, user_id: int) -> None:
+    rbac_service.ensure_project_exists(db, project_id)
+    existing_members = rbac_service.list_project_members(db, project_id)
+    if not existing_members:
+        return
+
+    membership = rbac_service.get_user_project_membership(db, project_id, user_id)
+    if membership is None or membership.role not in rbac_service.READ_ROLES:
+        raise HTTPException(status_code=403, detail="Insufficient project role")
+
+
+def _get_execution_or_404(execution_id: int, db: Session) -> ExecutionJob:
+    job = db.query(ExecutionJob).filter(ExecutionJob.id == execution_id).first()
+    if not job:
+        raise HTTPException(status_code=404, detail="Execution job not found")
+    return job
+
+
+def _result_payload(job: ExecutionJob) -> dict:
+    return job.result_payload if isinstance(job.result_payload, dict) else {}
+
+
+def _artifact_items(job: ExecutionJob) -> list[ArtifactItemResponse]:
+    payload = _result_payload(job)
+    raw_artifacts = payload.get("artifacts")
+    if not isinstance(raw_artifacts, list):
+        return []
+
+    items: list[ArtifactItemResponse] = []
+    for idx, raw in enumerate(raw_artifacts, start=1):
+        if not isinstance(raw, dict):
+            continue
+        artifact_id = str(raw.get("id") or idx)
+        filename = str(raw.get("filename") or f"artifact-{artifact_id}.bin")
+        artifact_type = str(raw.get("type") or "generic")
+        content_type = str(raw.get("content_type") or "application/octet-stream")
+        content = raw.get("content")
+        size_bytes = len(content.encode("utf-8")) if isinstance(content, str) else int(raw.get("size_bytes") or 0)
+        items.append(
+            ArtifactItemResponse(
+                id=artifact_id,
+                type=artifact_type,
+                filename=filename,
+                content_type=content_type,
+                size_bytes=size_bytes,
+                created_at=job.completed_at,
+            )
+        )
+    return items
+
+
+@router.get("/{execution_id}", response_model=ExecutionReportResponse)
+def get_execution_report(
+    execution_id: int,
+    current_user=Depends(require_auth_with_scopes({"execution:read"})),
+    db: Session = Depends(get_db),
+):
+    job = _get_execution_or_404(execution_id, db)
+    _ensure_project_access(db, job.project_id, current_user.id)
+
+    duration_seconds = 0.0
+    if job.started_at and job.completed_at:
+        duration_seconds = max(0.0, (job.completed_at - job.started_at).total_seconds())
+    elif job.started_at:
+        now = datetime.now(timezone.utc)
+        if job.started_at.tzinfo is None:
+            now = now.replace(tzinfo=None)
+        duration_seconds = max(0.0, (now - job.started_at).total_seconds())
+
+    payload = _result_payload(job)
+    duration_seconds = float(payload.get("duration_seconds") or duration_seconds)
+
+    return ExecutionReportResponse(
+        execution_id=job.id,
+        project_id=job.project_id,
+        script_id=job.script_id,
+        test_case_id=job.test_case_id,
+        status=job.status,
+        duration_seconds=duration_seconds,
+        started_at=job.started_at,
+        completed_at=job.completed_at,
+        cancelled_at=job.cancelled_at,
+        error_message=job.error_message,
+    )
+
+
+@router.get("/{execution_id}/logs", response_model=ExecutionLogsResponse)
+def get_execution_logs(
+    execution_id: int,
+    current_user=Depends(require_auth_with_scopes({"execution:read"})),
+    db: Session = Depends(get_db),
+):
+    job = _get_execution_or_404(execution_id, db)
+    _ensure_project_access(db, job.project_id, current_user.id)
+
+    payload = _result_payload(job)
+    stdout = payload.get("stdout")
+    stderr = payload.get("stderr")
+
+    if not isinstance(stdout, str):
+        stdout = ""
+    if not isinstance(stderr, str):
+        stderr = ""
+
+    return ExecutionLogsResponse(execution_id=job.id, stdout=stdout, stderr=stderr)
+
+
+@router.get("/{execution_id}/artifacts", response_model=ArtifactListResponse)
+def list_execution_artifacts(
+    execution_id: int,
+    current_user=Depends(require_auth_with_scopes({"execution:read"})),
+    db: Session = Depends(get_db),
+):
+    job = _get_execution_or_404(execution_id, db)
+    _ensure_project_access(db, job.project_id, current_user.id)
+
+    items = _artifact_items(job)
+    return ArtifactListResponse(
+        execution_id=job.id,
+        retention_days=max(1, settings.ARTIFACT_RETENTION_DAYS),
+        artifacts=items,
+    )
+
+
+@router.get("/{execution_id}/download/{artifact_id}")
+def download_execution_artifact(
+    execution_id: int,
+    artifact_id: str,
+    current_user=Depends(require_auth_with_scopes({"execution:read"})),
+    db: Session = Depends(get_db),
+):
+    job = _get_execution_or_404(execution_id, db)
+    _ensure_project_access(db, job.project_id, current_user.id)
+
+    payload = _result_payload(job)
+    raw_artifacts = payload.get("artifacts")
+    if not isinstance(raw_artifacts, list):
+        raise HTTPException(status_code=404, detail="Artifact not found")
+
+    selected: dict | None = None
+    for idx, raw in enumerate(raw_artifacts, start=1):
+        if not isinstance(raw, dict):
+            continue
+        current_id = str(raw.get("id") or idx)
+        if current_id == artifact_id:
+            selected = raw
+            break
+
+    if selected is None:
+        raise HTTPException(status_code=404, detail="Artifact not found")
+
+    content = selected.get("content")
+    if not isinstance(content, str):
+        raise HTTPException(status_code=404, detail="Artifact content unavailable")
+
+    encoding = str(selected.get("encoding") or "utf-8").lower()
+    if encoding == "base64":
+        try:
+            raw_bytes = base64.b64decode(content, validate=True)
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail="Invalid artifact encoding") from exc
+    else:
+        raw_bytes = content.encode("utf-8")
+
+    filename = str(selected.get("filename") or f"artifact-{artifact_id}.bin")
+    content_type = str(selected.get("content_type") or "application/octet-stream")
+
+    response = StreamingResponse(BytesIO(raw_bytes), media_type=content_type)
+    response.headers["Content-Disposition"] = f'attachment; filename="{filename}"'
+    return response

scriptgini-1.4.0/app/schemas/analytics.py

@@ -0,0 +1,59 @@
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict
+
+
+class RecentFailureResponse(BaseModel):
+    run_id: int
+    script_id: int
+    test_case_id: int
+    test_case_title: str | None = None
+    exit_code: int
+    duration_seconds: float
+    stderr_excerpt: str
+    created_at: datetime
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class RunAnalyticsResponse(BaseModel):
+    project_id: int
+    total_runs: int
+    success_runs: int
+    failed_runs: int
+    timed_out_runs: int
+    success_rate: float
+    average_duration_seconds: float
+    recent_failures: list[RecentFailureResponse]
+
+
+class TrendPointResponse(BaseModel):
+    bucket: str
+    total_runs: int
+    success_rate: float
+    average_duration_seconds: float
+
+
+class TrendsResponse(BaseModel):
+    project_id: int | None = None
+    start_date: datetime | None = None
+    end_date: datetime | None = None
+    points: list[TrendPointResponse]
+
+
+class FlakinessItemResponse(BaseModel):
+    script_id: int
+    test_case_id: int
+    total_runs: int
+    failed_runs: int
+    flakiness_score: float
+    confidence_score: float
+    last_failure_at: datetime | None = None
+
+
+class FlakinessResponse(BaseModel):
+    project_id: int | None = None
+    start_date: datetime | None = None
+    end_date: datetime | None = None
+    min_runs: int
+    items: list[FlakinessItemResponse]

scriptgini-1.4.0/app/schemas/reports.py

@@ -0,0 +1,39 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from app.models.execution_job import ExecutionJobStatus
+
+
+class ExecutionReportResponse(BaseModel):
+    execution_id: int
+    project_id: int
+    script_id: int
+    test_case_id: int
+    status: ExecutionJobStatus
+    duration_seconds: float
+    started_at: datetime | None = None
+    completed_at: datetime | None = None
+    cancelled_at: datetime | None = None
+    error_message: str | None = None
+
+
+class ExecutionLogsResponse(BaseModel):
+    execution_id: int
+    stdout: str
+    stderr: str
+
+
+class ArtifactItemResponse(BaseModel):
+    id: str
+    type: str
+    filename: str
+    content_type: str
+    size_bytes: int
+    created_at: datetime | None = None
+
+
+class ArtifactListResponse(BaseModel):
+    execution_id: int
+    retention_days: int
+    artifacts: list[ArtifactItemResponse]

{scriptgini-1.3.1 → scriptgini-1.4.0}/app/tasks.py

@@ -5,13 +5,14 @@ These tasks are executed by Celery workers and should not block the API.
 Examples: Script generation, test execution, file processing, etc.
 """
 
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 import logging
 
 from celery import shared_task
 from app.config import settings
 from app.database import SessionLocal
 from app.models.execution_job import ExecutionJob, ExecutionJobStatus, can_transition
+from app.models.script_run import ScriptRun
 
 logger = logging.getLogger(__name__)
 
@@ -245,11 +246,47 @@ def cleanup_old_artifacts(days: int = 30):
     """
     db = SessionLocal()
     try:
-        logger.info(f"Cleaning up artifacts older than {days} days")
-        
-        # TODO: Implement cleanup logic
-        # Delete old execution records, logs, artifacts beyond retention period
-        
-        return {"status": "completed", "removed_count": 0}
+        retention_days = max(1, int(days))
+        if not hasattr(db, "query"):
+            logger.warning("Skipping artifact cleanup because session does not support query operations")
+            return {
+                "status": "completed",
+                "removed_count": 0,
+                "removed_script_runs": 0,
+                "removed_execution_jobs": 0,
+                "retention_days": retention_days,
+            }
+
+        cutoff = datetime.now(timezone.utc) - timedelta(days=retention_days)
+        logger.info("Cleaning up artifacts older than %s days", retention_days)
+
+        removed_script_runs = (
+            db.query(ScriptRun)
+            .filter(ScriptRun.created_at < cutoff)
+            .delete(synchronize_session=False)
+        )
+        removed_execution_jobs = (
+            db.query(ExecutionJob)
+            .filter(
+                ExecutionJob.updated_at < cutoff,
+                ExecutionJob.status.in_(
+                    [
+                        ExecutionJobStatus.completed,
+                        ExecutionJobStatus.failed,
+                        ExecutionJobStatus.cancelled,
+                    ]
+                ),
+            )
+            .delete(synchronize_session=False)
+        )
+        db.commit()
+
+        return {
+            "status": "completed",
+            "removed_count": int(removed_script_runs + removed_execution_jobs),
+            "removed_script_runs": int(removed_script_runs),
+            "removed_execution_jobs": int(removed_execution_jobs),
+            "retention_days": retention_days,
+        }
     finally:
         db.close()

{scriptgini-1.3.1 → scriptgini-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scriptgini"
-version = "1.3.1"
+version = "1.4.0"
 description = "Agentic AI system that converts functional test cases into automation test scripts."
 readme = "README.md"
 requires-python = ">=3.11"

{scriptgini-1.3.1 → scriptgini-1.4.0}/scriptgini.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptgini
-Version: 1.3.1
+Version: 1.4.0
 Summary: Agentic AI system that converts functional test cases into automation test scripts.
 Author: ScriptGini Team
 License: Proprietary
@@ -443,7 +443,7 @@ The project follows an **enterprise-grade development roadmap** with 6 sprints c
 | **Sprint 2** | RBAC + Multi-Tenancy | 32-38pts | 🟡 Core delivered (RBAC hardening pending) |
 | **Sprint 3** | Durable Execution | 34-40pts | ✅ Completed (Redis + Celery queue foundation) |
 | **Sprint 4** | Security & Hardening | 30-36pts | 🟡 In progress (isolation boundary + breakout tests pending) |
-| **Sprint 5** | Reporting & Analytics | 28-34pts | 🔲 Pending (Artifact storage, dashboards) |
+| **Sprint 5** | Reporting & Analytics | 28-34pts | ✅ Completed (Reports APIs, trends/flakiness, retention cleanup) |
 | **Sprint 6** | Advanced Features | 24-30pts | 🔲 Pending (Webhooks, defect sync, versioning) |
 
 ---

{scriptgini-1.3.1 → scriptgini-1.4.0}/scriptgini.egg-info/SOURCES.txt

@@ -32,6 +32,7 @@ app/routers/demo.py
 app/routers/execution.py
 app/routers/organizations.py
 app/routers/projects.py
+app/routers/reports.py
 app/routers/scripts.py
 app/routers/test_cases.py
 app/schemas/__init__.py
@@ -44,6 +45,7 @@ app/schemas/generated_script.py
 app/schemas/membership.py
 app/schemas/organization.py
 app/schemas/project.py
+app/schemas/reports.py
 app/schemas/test_case.py
 app/services/api_key.py
 app/services/auth.py
@@ -59,4 +61,5 @@ tests/test_auth.py
 tests/test_coverage.py
 tests/test_infra_services_coverage.py
 tests/test_sprint2_rbac.py
-tests/test_sprint3_execution.py
+tests/test_sprint3_execution.py
+tests/test_sprint5_reporting_analytics.py