scriptgini 0.1.2__py3-none-any.whl

app/llm/provider.py

@@ -0,0 +1,192 @@
+"""
+LLM Provider Factory for ScriptGini.
+
+Supports: OpenAI, Ollama (local), OpenRouter, Google Gemini, AWS Bedrock.
+Each provider returns a LangChain BaseChatModel so the agent layer is
+provider-agnostic.
+"""
+from __future__ import annotations
+
+import hashlib
+import logging
+from typing import Literal
+
+from langchain_core.language_models import BaseChatModel
+
+from app.config import settings
+
+LLMProvider = Literal["openai", "ollama", "openrouter", "gemini", "bedrock"]
+logger = logging.getLogger(__name__)
+
+
+def _mask_secret(secret: str) -> str:
+    value = (secret or "").strip()
+    if not value:
+        return "<missing>"
+    if len(value) <= 8:
+        return "****"
+    digest = hashlib.sha256(value.encode("utf-8")).hexdigest()[:8]
+    return f"{value[:4]}...{value[-4:]}(len={len(value)},sha256={digest})"
+
+
+def _provider_secret(provider: LLMProvider) -> tuple[str | None, str]:
+    if provider == "openai":
+        return "OPENAI_API_KEY", settings.OPENAI_API_KEY
+    if provider == "openrouter":
+        return "OPENROUTER_API_KEY", settings.OPENROUTER_API_KEY
+    if provider == "gemini":
+        return "GOOGLE_API_KEY", settings.GOOGLE_API_KEY
+    return None, ""
+
+
+def _default_model_for_provider(provider: LLMProvider) -> str:
+    if provider == "openai":
+        return settings.OPENAI_MODEL
+    if provider == "ollama":
+        return settings.OLLAMA_MODEL
+    if provider == "openrouter":
+        return settings.OPENROUTER_MODEL
+    if provider == "gemini":
+        return settings.GEMINI_MODEL
+    return settings.BEDROCK_MODEL_ID
+
+
+def get_llm_diagnostics(provider: LLMProvider | None = None, model: str | None = None) -> dict[str, str | bool]:
+    resolved_provider: LLMProvider = provider or settings.DEFAULT_LLM_PROVIDER
+    resolved_model = model or _default_model_for_provider(resolved_provider)
+    secret_env, secret_value = _provider_secret(resolved_provider)
+    has_secret = bool(secret_value.strip()) if secret_env else True
+    return {
+        "provider": resolved_provider,
+        "model": resolved_model,
+        "api_key_env": secret_env or "<not-required>",
+        "api_key_present": has_secret,
+        "api_key_masked": _mask_secret(secret_value) if secret_env else "<not-required>",
+    }
+
+
+def get_llm(
+    provider: LLMProvider | None = None,
+    *,
+    model: str | None = None,
+    temperature: float = 0.1,
+) -> BaseChatModel:
+    """
+    Return a LangChain chat model for the requested provider.
+
+    Args:
+        provider: One of 'openai', 'ollama', 'openrouter', 'gemini', 'bedrock'.
+                  Defaults to settings.DEFAULT_LLM_PROVIDER.
+        model:    Override the model name. Falls back to per-provider default.
+        temperature: Sampling temperature (low value keeps output deterministic).
+    """
+    provider = provider or settings.DEFAULT_LLM_PROVIDER
+    diagnostics = get_llm_diagnostics(provider, model)
+    logger.info(
+        "LLM pick: provider=%s model=%s api_key_env=%s api_key_present=%s api_key=%s",
+        diagnostics["provider"],
+        diagnostics["model"],
+        diagnostics["api_key_env"],
+        diagnostics["api_key_present"],
+        diagnostics["api_key_masked"],
+    )
+
+    if provider == "openai":
+        return _openai(model or settings.OPENAI_MODEL, temperature)
+    if provider == "ollama":
+        return _ollama(model or settings.OLLAMA_MODEL, temperature)
+    if provider == "openrouter":
+        return _openrouter(model or settings.OPENROUTER_MODEL, temperature)
+    if provider == "gemini":
+        return _gemini(model or settings.GEMINI_MODEL, temperature)
+    if provider == "bedrock":
+        return _bedrock(model or settings.BEDROCK_MODEL_ID, temperature)
+
+    raise ValueError(f"Unknown LLM provider: {provider!r}")
+
+
+# ---------------------------------------------------------------------------
+# Provider implementations
+# ---------------------------------------------------------------------------
+
+def _openai(model: str, temperature: float) -> BaseChatModel:
+    from langchain_openai import ChatOpenAI
+
+    kwargs = {
+        "model": model,
+        "temperature": temperature,
+        "timeout": settings.LLM_REQUEST_TIMEOUT_SECONDS,
+    }
+    if settings.OPENAI_API_KEY.strip():
+        kwargs["api_key"] = settings.OPENAI_API_KEY
+
+    return ChatOpenAI(
+        **kwargs,
+    )
+
+
+def _ollama(model: str, temperature: float) -> BaseChatModel:
+    from langchain_ollama import ChatOllama
+
+    timeout_seconds = settings.OLLAMA_REQUEST_TIMEOUT_SECONDS
+    return ChatOllama(
+        model=model,
+        temperature=temperature,
+        base_url=settings.OLLAMA_BASE_URL,
+        num_predict=settings.OLLAMA_NUM_PREDICT,
+        sync_client_kwargs={"timeout": timeout_seconds},
+        async_client_kwargs={"timeout": timeout_seconds},
+    )
+
+
+def _openrouter(model: str, temperature: float) -> BaseChatModel:
+    # OpenRouter exposes an OpenAI-compatible API endpoint.
+    from langchain_openai import ChatOpenAI
+
+    kwargs = {
+        "model": model,
+        "temperature": temperature,
+        "base_url": settings.OPENROUTER_BASE_URL,
+        "timeout": settings.LLM_REQUEST_TIMEOUT_SECONDS,
+        "default_headers": {
+            "HTTP-Referer": "https://scriptgini.local",
+            "X-Title": "ScriptGini",
+        },
+    }
+    if settings.OPENROUTER_API_KEY.strip():
+        kwargs["api_key"] = settings.OPENROUTER_API_KEY
+
+    return ChatOpenAI(
+        **kwargs,
+    )
+
+
+def _gemini(model: str, temperature: float) -> BaseChatModel:
+    from langchain_google_genai import ChatGoogleGenerativeAI
+
+    normalized_model = model.removeprefix("models/")
+
+    kwargs = {
+        "model": normalized_model,
+        "temperature": temperature,
+    }
+    if settings.GOOGLE_API_KEY.strip():
+        kwargs["google_api_key"] = settings.GOOGLE_API_KEY
+
+    return ChatGoogleGenerativeAI(**kwargs)
+
+
+def _bedrock(model: str, temperature: float) -> BaseChatModel:
+    import boto3
+    from langchain_aws import ChatBedrock
+
+    boto_session = boto3.Session(
+        aws_access_key_id=settings.AWS_ACCESS_KEY_ID or None,
+        aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY or None,
+        region_name=settings.AWS_REGION_NAME,
+    )
+    return ChatBedrock(
+        model_id=model,
+        client=boto_session.client("bedrock-runtime"),
+        model_kwargs={"temperature": temperature},
+    )

app/main.py

@@ -0,0 +1,76 @@
+import logging
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.responses import FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+
+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
+
+logging.basicConfig(level=logging.DEBUG if settings.DEBUG else logging.INFO)
+logger = logging.getLogger(__name__)
+
+static_dir = Path(__file__).resolve().parent / "static"
+
+app = FastAPI(
+    title=settings.APP_NAME,
+    description=(
+        "Enterprise-grade Agentic AI system that converts functional test cases "
+        "into high-quality automation scripts."
+    ),
+    version="1.0.4",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(projects.router, prefix="/api/v1")
+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(demo.router, prefix="/api/v1")
+app.mount("/static", StaticFiles(directory=static_dir), name="static")
+
+
+@app.on_event("startup")
+def log_llm_runtime_config() -> None:
+    diagnostics = get_llm_diagnostics()
+    logger.info(
+        "Runtime LLM default: provider=%s model=%s api_key_env=%s api_key_present=%s api_key=%s",
+        diagnostics["provider"],
+        diagnostics["model"],
+        diagnostics["api_key_env"],
+        diagnostics["api_key_present"],
+        diagnostics["api_key_masked"],
+    )
+
+
+@app.get("/api/v1/runtime/llm", tags=["Runtime"])
+def runtime_llm():
+    default_diagnostics = get_llm_diagnostics()
+    return {
+        "default_provider": default_diagnostics["provider"],
+        "default_model": default_diagnostics["model"],
+        "provider_diagnostics": {
+            provider: get_llm_diagnostics(provider) for provider in ["openai", "openrouter", "gemini", "ollama", "bedrock"]
+        },
+    }
+
+
+@app.get("/", include_in_schema=False)
+def index():
+    return FileResponse(static_dir / "index.html")
+
+
+@app.get("/health", tags=["Health"])
+def health():
+    return {"status": "ok", "app": settings.APP_NAME}

app/models/bulk_job.py

@@ -0,0 +1,67 @@
+import enum
+from datetime import datetime, timezone
+
+from sqlalchemy import DateTime, Enum as SAEnum, ForeignKey, Integer, String, Text
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.database import Base
+
+
+class BulkJobKind(str, enum.Enum):
+    generate = "generate"
+    run = "run"
+
+
+class BulkJobStatus(str, enum.Enum):
+    pending = "pending"
+    running = "running"
+    completed = "completed"
+    failed = "failed"
+
+
+class BulkJobItemStatus(str, enum.Enum):
+    pending = "pending"
+    running = "running"
+    completed = "completed"
+    failed = "failed"
+    skipped = "skipped"
+
+
+class BulkJob(Base):
+    __tablename__ = "bulk_jobs"
+
+    id: Mapped[int] = mapped_column(primary_key=True, index=True)
+    project_id: Mapped[int] = mapped_column(ForeignKey("projects.id", ondelete="CASCADE"), nullable=False, index=True)
+    kind: Mapped[BulkJobKind] = mapped_column(SAEnum(BulkJobKind), nullable=False)
+    status: Mapped[BulkJobStatus] = mapped_column(SAEnum(BulkJobStatus), nullable=False, default=BulkJobStatus.pending)
+    total_items: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+    completed_items: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+    failed_items: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+    skipped_items: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(timezone.utc)
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        default=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(timezone.utc),
+    )
+
+
+class BulkJobItem(Base):
+    __tablename__ = "bulk_job_items"
+
+    id: Mapped[int] = mapped_column(primary_key=True, index=True)
+    job_id: Mapped[int] = mapped_column(ForeignKey("bulk_jobs.id", ondelete="CASCADE"), nullable=False, index=True)
+    test_case_id: Mapped[int] = mapped_column(ForeignKey("test_cases.id", ondelete="CASCADE"), nullable=False, index=True)
+    script_id: Mapped[int | None] = mapped_column(ForeignKey("generated_scripts.id", ondelete="SET NULL"), nullable=True, index=True)
+    status: Mapped[BulkJobItemStatus] = mapped_column(SAEnum(BulkJobItemStatus), nullable=False, default=BulkJobItemStatus.pending)
+    message: Mapped[str | None] = mapped_column(Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(timezone.utc)
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        default=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(timezone.utc),
+    )

app/models/generated_script.py

@@ -0,0 +1,39 @@
+import enum
+from datetime import datetime, timezone
+
+from sqlalchemy import String, Text, DateTime, ForeignKey, Enum as SAEnum, Integer
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.database import Base
+
+
+class ScriptStatus(str, enum.Enum):
+    pending = "pending"
+    generating = "generating"
+    completed = "completed"
+    failed = "failed"
+
+
+class GeneratedScript(Base):
+    __tablename__ = "generated_scripts"
+
+    id: Mapped[int] = mapped_column(primary_key=True, index=True)
+    project_id: Mapped[int] = mapped_column(ForeignKey("projects.id", ondelete="CASCADE"), nullable=False, index=True)
+    test_case_id: Mapped[int] = mapped_column(ForeignKey("test_cases.id", ondelete="CASCADE"), nullable=False, index=True)
+    framework: Mapped[str] = mapped_column(String(100), nullable=False)
+    llm_provider: Mapped[str] = mapped_column(String(100), nullable=False)
+    llm_model: Mapped[str] = mapped_column(String(255), nullable=False)
+    script_content: Mapped[str | None] = mapped_column(Text, nullable=True)
+    status: Mapped[ScriptStatus] = mapped_column(
+        SAEnum(ScriptStatus), default=ScriptStatus.pending, nullable=False
+    )
+    error_message: Mapped[str | None] = mapped_column(Text, nullable=True)
+    token_usage: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(timezone.utc)
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        default=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(timezone.utc),
+    )

app/models/project.py

@@ -0,0 +1,46 @@
+import enum
+from datetime import datetime, timezone
+
+from sqlalchemy import String, Text, DateTime, Enum as SAEnum
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.database import Base
+
+
+class TestFramework(str, enum.Enum):
+    playwright_python = "playwright_python"
+    selenium_python = "selenium_python"
+    uft_vbscript = "uft_vbscript"
+    cypress_js = "cypress_js"
+
+
+class SelectorPreference(str, enum.Enum):
+    role = "role"
+    label = "label"
+    testid = "testid"
+    css = "css"
+    xpath = "xpath"
+
+
+class Project(Base):
+    __tablename__ = "projects"
+
+    id: Mapped[int] = mapped_column(primary_key=True, index=True)
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+    description: Mapped[str | None] = mapped_column(Text, nullable=True)
+    aut_base_url: Mapped[str] = mapped_column(String(2048), nullable=False)
+    default_framework: Mapped[TestFramework] = mapped_column(
+        SAEnum(TestFramework), default=TestFramework.playwright_python, nullable=False
+    )
+    selector_preference: Mapped[SelectorPreference] = mapped_column(
+        SAEnum(SelectorPreference), default=SelectorPreference.role, nullable=False
+    )
+    auth_hints: Mapped[str | None] = mapped_column(Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(timezone.utc)
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        default=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(timezone.utc),
+    )

app/models/script_run.py

@@ -0,0 +1,32 @@
+import enum
+from datetime import datetime, timezone
+
+from sqlalchemy import Boolean, DateTime, Enum as SAEnum, Float, ForeignKey, Integer, String, Text
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.database import Base
+
+
+class ScriptRunStatus(str, enum.Enum):
+    completed = "completed"
+    failed = "failed"
+    timed_out = "timed_out"
+
+
+class ScriptRun(Base):
+    __tablename__ = "script_runs"
+
+    id: Mapped[int] = mapped_column(primary_key=True, index=True)
+    script_id: Mapped[int] = mapped_column(ForeignKey("generated_scripts.id", ondelete="CASCADE"), nullable=False, index=True)
+    project_id: Mapped[int] = mapped_column(ForeignKey("projects.id", ondelete="CASCADE"), nullable=False, index=True)
+    test_case_id: Mapped[int] = mapped_column(ForeignKey("test_cases.id", ondelete="CASCADE"), nullable=False, index=True)
+    status: Mapped[ScriptRunStatus] = mapped_column(SAEnum(ScriptRunStatus), nullable=False)
+    success: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
+    exit_code: Mapped[int] = mapped_column(Integer, nullable=False)
+    stdout: Mapped[str] = mapped_column(Text, nullable=False, default="")
+    stderr: Mapped[str] = mapped_column(Text, nullable=False, default="")
+    duration_seconds: Mapped[float] = mapped_column(Float, nullable=False)
+    command: Mapped[str] = mapped_column(String(1024), nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(timezone.utc)
+    )

app/models/test_case.py

@@ -0,0 +1,34 @@
+import enum
+from datetime import datetime, timezone
+
+from sqlalchemy import String, Text, DateTime, ForeignKey, Enum as SAEnum
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.database import Base
+
+
+class TestCaseFormat(str, enum.Enum):
+    step_based = "step_based"
+    bdd = "bdd"
+
+
+class TestCase(Base):
+    __tablename__ = "test_cases"
+
+    id: Mapped[int] = mapped_column(primary_key=True, index=True)
+    project_id: Mapped[int] = mapped_column(ForeignKey("projects.id", ondelete="CASCADE"), nullable=False, index=True)
+    title: Mapped[str] = mapped_column(String(512), nullable=False)
+    format: Mapped[TestCaseFormat] = mapped_column(
+        SAEnum(TestCaseFormat), default=TestCaseFormat.step_based, nullable=False
+    )
+    content: Mapped[str] = mapped_column(Text, nullable=False)
+    preconditions: Mapped[str | None] = mapped_column(Text, nullable=True)
+    test_data_hints: Mapped[str | None] = mapped_column(Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(timezone.utc)
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        default=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(timezone.utc),
+    )

app/routers/analytics.py

@@ -0,0 +1,73 @@
+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 RunAnalyticsResponse, RecentFailureResponse
+
+router = APIRouter(prefix="/projects/{project_id}/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,
+    )