Merge pull request #2274 from meraj-lt/stage

Add new images and update documentation for LambdaTest AI Cloud GitHu…

Author: surishubham

assets/images/kaneai-github-app/github-app-install-success-page.png

@@ -0,0 +1,331 @@
+---
+id: github-app-integration
+title: LambdaTest AI Cloud GitHub App Integration
+hide_title: true
+sidebar_label: KaneAI GitHub App Integration
+description: Step-by-step guide to install, configure, and use the LambdaTest AI Cloud GitHub App for automated AI-powered test case generation.
+keywords:
+  - github app
+  - lambdatest integration
+  - AI test generation
+  - PR automation
+  - test management
+url: https://www.lambdatest.com/support/docs/github-app-integration/
+site_name: LambdaTest
+slug: github-app-integration/
+---
+
+<script type="application/ld+json"
+      dangerouslySetInnerHTML={{ __html: JSON.stringify({
+       "@context": "https://schema.org",
+        "@type": "BreadcrumbList",
+        "itemListElement": [{
+          "@type": "ListItem",
+          "position": 1,
+          "name": "LambdaTest",
+          "item": "https://www.lambdatest.com"
+        },{
+          "@type": "ListItem",
+          "position": 2,
+          "name": "Support",
+          "item": "https://www.lambdatest.com/support/docs/"
+        },{
+          "@type": "ListItem",
+          "position": 3,
+          "name": "LambdaTest AI Cloud GitHub App Integration",
+          "item": "https://www.lambdatest.com/support/docs/github-app-integration/"
+        }]
+      })
+    }}
+></script>
+
+# LambdaTest AI Cloud GitHub App Integration
+
+## 1. Overview
+
+### What is the LambdaTest AI Cloud GitHub App?
+
+The LambdaTest AI Cloud GitHub App leverages KaneAI, our advanced AI testing agent, to transform how your team approaches quality assurance. Instead of manually writing test cases for every code change, the app intelligently analyzes your pull requests, understands the business logic and technical implementation, and automatically generates relevant end-to-end test scenarios.
+
+### How It Works
+
+When a developer creates a pull request, simply add a comment to trigger the AI workflow. The app then:
+
+1. **Analyzes** the code changes, PR content and repository context (including your README)
+2. **Generates** intelligent test cases using KaneAI's AI engine
+3. **Authors** executable test scripts with proper assertions and validations
+4. **Executes** tests on LambdaTest's cloud infrastructure via HyperExecute
+5. **Reports** results with AI-powered Root Cause Analysis (RCA) for failures
+
+All of this happens automatically, with real-time progress updates posted directly to your pull request.
+
+### Key Benefits
+
+- **Accelerated Test Coverage**: Automatically generate comprehensive test cases for every PR, significantly reducing the time from code commit to production-ready testing
+- **Intelligent Test Design**: AI-powered analysis creates contextually relevant test scenarios that understand both code changes and business logic
+- **Seamless Developer Experience**: Native GitHub integration means developers never leave their workflow—all updates, results, and insights appear directly in PR comments
+- **Enterprise Scalability**: Leverages HyperExecute for parallel test execution across multiple browsers, devices, and platforms
+- **Continuous Quality Intelligence**: AI-driven Root Cause Analysis automatically diagnoses test failures, reducing debugging time and accelerating resolution
+- **Unified Test Management**: All generated tests sync with LambdaTest Test Manager, providing centralized visibility and control across your QA operations
+
+---
+
+## 2. Prerequisites
+
+Before implementing the LambdaTest AI Cloud GitHub App in your development workflow, ensure your organization has the following:
+
+### Account Requirements
+
+- **LambdaTest Enterprise Account**: An active LambdaTest account with appropriate licensing. [Sign up now](https://accounts.lambdatest.com/register) if you don't have an account yet.
+
+- **KaneAI Access**: This integration requires KaneAI to be enabled on your LambdaTest account. New signups receive a 14-day free trial of KaneAI with full feature access. 
+
+### Repository Requirements
+
+- **GitHub Repository Access**: Administrative access to the GitHub repositories where you want to install the app
+<!-- - **Repository README**: A well-documented README.md file in your repository (the AI uses this for contextual understanding of your application) -->
+
+
+---
+
+## 3. Installation
+
+Follow these steps to install and authorize the LambdaTest AI Cloud GitHub App for your organization.
+
+### Step 1: Access GitHub Marketplace
+
+Navigate to the [LambdaTest AI Cloud GitHub App](https://github.com/apps/lambdatest-ai-cloud) on GitHub Marketplace and click **Install** to begin the installation process.
+
+<img loading="lazy" src={require('../assets/images/kaneai-github-app/install-github-app.png').default} alt="Trigger KaneAI workflow" className="doc_img"/>
+
+
+### Step 2: Configure Repository Access
+
+During installation, you'll need to specify which repositories should have access to the app:
+
+- **Organization-wide Installation**: Select **All repositories** to enable the app across your entire GitHub organization
+- **Selective Installation**: Choose **Only select repositories** and specify individual repositories for more granular control
+
+<img loading="lazy" src={require('../assets/images/kaneai-github-app/github-repository-selection.png').default} alt="Trigger KaneAI workflow" className="doc_img"/>
+
+After making your selection and clicking the **Install and Authorize** button, you will be redirected to LambdaTest's integration page where under the **My Integrations** section you will be able to see this application.
+
+<img loading="lazy" src={require('../assets/images/kaneai-github-app/integration-success.png').default} alt="Trigger KaneAI workflow" className="doc_img"/>
+
+
+:::tip Best Practice
+For pilot programs or initial rollouts, we recommend installing on a select subset of repositories first. Once your team is comfortable with the workflow, you can expand access organization-wide.
+:::
+
+### Step 3: Verify Successful Installation
+
+Confirm the installation was successful by:
+
+1. Navigating to your GitHub organization's **Settings** page
+2. In left side menu under **Integrations**, click **Applications**.
+3. Selecting **Installed GitHub Apps** from the left sidebar
+4. Verifying that **LambdaTest AI Cloud** appears in the list of installed applications
+
+You can also click on the app to review and modify repository access permissions at any time.
+
+<img loading="lazy" src={require('../assets/images/kaneai-github-app/github-app-install-success-page.png').default} alt="Trigger KaneAI workflow" className="doc_img"/>
+
+---
+
+## 3.1 Uninstalling the GitHub App
+
+If you need to remove the LambdaTest AI Cloud GitHub App from your organization:
+
+1. Navigate to the [LambdaTest AI Cloud GitHub App](https://github.com/apps/lambdatest-ai-cloud) on GitHub Marketplace
+2. Click on the **Configure** button to access the app settings
+3. Scroll down to the bottom of the page to find the **Danger Zone** section
+4. Click on the **Uninstall** button to remove the app from your organization
+5. Confirm the uninstallation when prompted
+
+<img loading="lazy" src={require('../assets/images/kaneai-github-app/uninstall-github-app.png').default} alt="Uninstall GitHub App" className="doc_img"/>
+
+:::tip caution
+Uninstalling the GitHub App will stop all AI-powered test generation workflows on your pull requests. This action cannot be undone, and you'll need to reinstall the app to restore functionality.
+:::
+
+---
+
+## 4. Repository Configuration
+
+After installing the GitHub App, each repository requires a configuration file to connect your GitHub workflow with your LambdaTest Test Manager environment. This configuration defines where tests should be stored, who should be assigned, and which environment to test against.
+
+### Configuration File Setup
+
+Create a `.lambdatest/config.yaml` file in the root directory of your repository with the following structure:
+
+```yaml
+# LambdaTest AI Cloud Configuration
+project_id: "your_project_id"
+folder_id: "your_folder_id"
+assignee: your_user_id
+environment_id: environment_id
+test_url: "https://your-deployed-app-url.com/"
+```
+
+### Configuration Parameters
+
+| Parameter | Description | How to Obtain |
+|-----------|-------------|---------------|
+| `project_id` | The unique identifier for your LambdaTest Test Manager project | Navigate to your project in Test Manager and copy the ID from the URL |
+| `folder_id` | The folder where generated test cases will be organized | Create or select a folder in Test Manager and obtain its ID from the URL |
+| `assignee` | The LambdaTest user ID who will be assigned to test runs for executions | Can be referenced from APIs |
+| `environment_id` | The target testing environment (browser, OS, device configurations) | Create environments in Test Manager and reference their IDs |
+| `test_url` | The base URL of your application under test | Your staging or testing environment URL where tests will be executed |
+
+> **Note:** All configuration IDs can be retrieved programmatically from the [LambdaTest Test Manager API Documentation](https://www.lambdatest.com/support/api-doc/?key=test-management).
+
+:::tip Maximize AI Context
+The `README.md` file in your repository is analyzed by KaneAI to understand your application's purpose, architecture, and business logic. A comprehensive README significantly improves the quality and relevance of generated test cases. Include:
+- Application overview and key features
+- User workflows and critical paths
+- Architecture and technology stack
+- Business rules and validation logic
+:::
+
+### Repository Structure
+
+Your final repository structure should look like this:
+
+```
+your-repo/
+├── .lambdatest/
+│   └── config.yaml          # LambdaTest configuration
+    └── agent.md             # Optional file for custom instructions to enhance responses
+├── src/                     # Your application source code
+├── README.md                # Detailed project documentation (used by AI)
+└── ... other project files
+```
+
+### Configuration Best Practices
+
+- **Environment Segregation**: Use separate `project_id` and `folder_id` values for different branches (e.g., staging vs. production) to maintain test organization
+- **Team Assignment**: Configure `assignee` to route test runs to the appropriate QA team member or use a shared team account for visibility
+- **Dynamic URLs**: For teams with ephemeral preview environments, consider parameterizing `test_url` or updating it per deployment
+- **Version Control**: Commit `.lambdatest/config.yaml` to your repository so all team members use consistent configuration
+
+---
+
+## 5. Triggering Test Generation
+
+With the GitHub App installed and your repository configured, you're ready to start generating AI-powered tests for your pull requests.
+
+### Initiating the Workflow
+
+The test generation workflow is triggered through a simple comment on any pull request in your repository. Once your development work is ready for testing:
+
+1. **Create a Pull Request**: Push your feature branch and open a PR as you normally would
+2. **Add a Trigger Comment**: Post any of the following commands in the PR comments section:
+
+```bash
+@LambdaTest Validate this PR
+#OR
+@KaneAI Validate this PR
+```
+
+Any of these commands will initiate the complete AI-powered testing workflow, from analysis to execution and reporting.
+
+<img loading="lazy" src={require('../assets/images/kaneai-github-app/1-flow_triggered.png').default} alt="Trigger KaneAI workflow" className="doc_img"/>
+
+### What Happens Next
+
+After you post the trigger comment, KaneAI immediately begins working:
+
+1. **Code Analysis**: The AI examines all code changes in the pull request, including file modifications, additions, and deletions
+2. **Context Gathering**: Your repository's README.md, PR Title, Description, Comments and AGENT.md are analyzed to understand application context
+3. **Test Strategy**: Based on the changes and context, the AI determines which areas require testing and what scenarios to cover
+4. **Test Generation**: Intelligent test cases are created with appropriate assertions, validations, and edge case handling
+
+This entire process typically completes within minutes, depending on the complexity of your code changes.
+
+
+## 6. Automated Workflow and Real-Time Tracking
+
+The LambdaTest AI Cloud GitHub App provides complete transparency throughout the testing lifecycle. From the moment you trigger the workflow, you'll receive real-time updates directly in your pull request—keeping your entire team informed without requiring context switching or dashboard checking.
+
+### Unified Progress Tracking
+
+As soon as the workflow begins, KaneAI posts a comprehensive progress tracker comment to your PR. This dynamic comment serves as your single source of truth for the entire testing operation.
+
+**The Progress Tracker includes:**
+
+- **Current Workflow Status**: Real-time updates on which phase is currently executing
+- **Test Case Pipeline**: Progress through analysis, generation, authoring, and code generation phases
+- **Intelligent Test Case Suggestion**: AI suggests semantically similar test cases present in the project
+- **Test Run Management**: Execution status, including configuration, triggering, monitoring, and completion
+- **Reporting Status**: Final report generation and PR approval recommendation
+
+This tracker automatically updates as each stage completes, providing instant visibility into the workflow without requiring any manual refreshes.
+
+<img loading="lazy" src={require('../assets/images/kaneai-github-app/2-progress-tracker.png').default} alt="KaneAI Progress Tracker" className="doc_img"/>
+
+### Detailed Step Comments
+
+In addition to the main progress tracker, KaneAI creates dedicated, detailed comments for each major milestone. These comments provide actionable information and direct access to relevant resources.
+
+#### 1. AI-Generated Test Case Inventory
+
+Once KaneAI completes test generation, a detailed comment lists every test case that was created, including:
+
+- **Test Case Names**: Descriptive titles reflecting the functionality being tested
+- **Coverage Areas**: Which features, components, or user flows each test validates
+- **Authoring Status**: Real-time updates as each test case is converted into executable code
+- **Direct Links**: Quick access to view, edit, or customize tests in LambdaTest Test Manager
+
+This comment updates dynamically as test authoring progresses, so you can monitor the transition from conceptual test cases to executable automation.
+
+<img loading="lazy" src={require('../assets/images/kaneai-github-app/3-test-cases-generated.png').default} alt="AI Generated Test Cases" className="doc_img"/>
+
+#### 2. Duplicate Detection and Test Optimization
+
+To prevent test redundancy and optimize your test suite, KaneAI performs semantic analysis against your existing test inventory:
+
+- **Similar Test Identification**: Finds existing tests that cover similar functionality or user scenarios
+- **Test Suite Optimization**: Helps maintain a lean, efficient test suite by preventing duplicate coverage
+
+This intelligent analysis ensures your test repository remains organized and maintainable as it grows over time.
+
+<img loading="lazy" src={require('../assets/images/kaneai-github-app/4-similar-test-cases.png').default} alt="Semantically Similar Test Cases" className="doc_img"/>
+
+#### 3. Test Execution Dashboard
+
+When test execution begins on HyperExecute, a dedicated comment provides:
+
+- **Test Run Configuration**: Details about the execution environment, browser matrix, and parallel execution settings
+- **Real-Time Execution Status**: Live updates as tests run, including pass/fail counts and completion percentage
+- **HyperExecute Dashboard Link**: Direct access to detailed logs, screenshots, video recordings, and network traces
+
+<img loading="lazy" src={require('../assets/images/kaneai-github-app/5-test-run-created.png').default} alt="Test Run Execution" className="doc_img"/>
+
+#### 4. Comprehensive Test Report with AI-Powered Insights
+
+Upon completion, KaneAI generates a final report that goes far beyond simple pass/fail metrics:
+
+- **Executive Summary**: High-level test coverage and success rate for quick stakeholder review
+- **Detailed Test Results**: Pass/fail status for each individual test case with failure details
+- **AI Root Cause Analysis (RCA)**: For any failures, KaneAI automatically analyzes logs, screenshots, and stack traces to identify:
+  - The specific component or code path that failed
+  - Potential root causes (e.g., locator changes, timing issues, data validation errors)
+  - Recommended remediation steps
+- **PR Approval Recommendation**: Based on test results and failure severity, KaneAI suggests whether the PR should be approved, requires changes, or needs further investigation
+
+This intelligent reporting dramatically reduces the time from test completion to actionable insights, accelerating your deployment cycles.
+
+<img loading="lazy" src={require('../assets/images/kaneai-github-app/6-report-generated.png').default} alt="Final Report Generated" className="doc_img"/>
+
+<!-- <img loading="lazy" src={require('../assets/images/kaneai-github-app/7-rca-for-failed-tests.png').default} alt="AI RCA for Failed Tests" className="doc_img"/> -->
+
+### Benefits: Unified Visibility
+
+The GitHub-native workflow provides critical advantages for enterprise teams:
+
+- **Developer-Centric Experience**: All testing information lives where developers already work—no need to check external dashboards or switch contexts
+- **Stakeholder Transparency**: Product managers, architects, and other stakeholders can follow testing progress by simply monitoring the PR
+- **Audit Trail and Compliance**: Every test run, result, and AI recommendation is permanently documented in your PR history
+- **Deep-Dive Capability**: When detailed analysis is needed, one-click access to LambdaTest Test Manager and HyperExecute provides comprehensive diagnostics
+- **Asynchronous Collaboration**: Team members in different time zones can review testing status and results without requiring synchronous communication  
+