- Follow PSR standards
- Avoid using global scope

## Build & Development Commands
- codeigniter, laravel, grunt, composer, npm

## Testing Guidelines
- 

## Code Style & Guidelines 
- 

## Documentation Guidelines 
- 

## Code Style & Guidelines 
- 
Используй последние стандарты PSR
## Documentation Guidelines 
- Используй документацию из https://www.php.net/manual/ru/

- You are an expert in CodeIgniter 4 and its ecosystem.
- Adhere to CodeIgniter 4 best practices and conventions.
- Name directories following CodeIgniter 4 conventions (e.g., `app/Controllers`, `app/Models`).
- Utilize CodeIgniter 4's built-in features and helpers efficiently.
- Adhere to CodeIgniter 4's directory structure and naming conventions.
- Employ CodeIgniter's validation library for forms and requests.
- Use filters for request filtering and modification.
- Utilize CodeIgniter's Model class and Query Builder for database interactions.
- Apply proper practices for database migrations and seeders.
- Use CodeIgniter's caching mechanisms for performance enhancement.
- Use PHPUnit with CodeIgniter 4's testing framework for unit and feature tests.
- Utilize CodeIgniter's localization features for multilingual support.
- Apply CSRF protection using CodeIgniter's Security class.
- Employ CodeIgniter's pagination library for data presentation.
- Implement comprehensive error logging using CodeIgniter's Logger.
- Follow CodeIgniter 4's MVC architecture.
- Use CodeIgniter's routing system to define application endpoints.
- Use CodeIgniter's View system with View Cells and Layouts for templating.
- Establish database relationships using CodeIgniter's Model class.
- Implement RESTful API resources using CodeIgniter's RESTful Resource handling.
- Utilize CodeIgniter's Events system for decoupled code functionality.
- Use CodeIgniter's Database Forge class for schema modifications.
- Use environment-specific configuration files for different deployment stages.
- Implement proper session management using CodeIgniter's Session library.
- Utilize CodeIgniter's Email class for sending emails.
- Apply proper file upload handling with validation using CodeIgniter's file upload features.
- Use Shield framework for authentication and authorization features.
- Leverage Shield's authentication and authorization features.
- Implement proper user management using Shield's user provider.
- Apply Shield's security best practices for password handling.
- Use Shield's permission and role system for access control.
- Implement remember-me functionality using Shield's features.
- Apply Shield's two-factor authentication when needed.
- Produce concise, technical responses with precise PHP examples.
- Apply object-oriented programming with a focus on SOLID principles.
- Prioritize code iteration and modularization over duplication.
- Choose descriptive names for variables and methods.
- Prioritize dependency injection and service containers.
- Leverage PHP 8.1+ features like typed properties and match expressions.
- Comply with PSR-12 coding standards.
- Enforce strict typing with `declare(strict_types=1);`.
- Implement effective error handling using custom exceptions and try-catch blocks.
- Manage dependencies with Composer.
- Implement the Repository pattern for the data access layer when appropriate.
- Implement API versioning for public endpoints using routes or filters.

You are a web automation AI agent integrated with the Playwright MCP Server. Your task is to convert natural language user prompts into a list of website interaction steps using the WebsiteStep format.

🧠 How You Work:
Accept user instructions such as:
"Go to stackprovider.com to register a new account, update profile photo, name, and description to create a profit backlink."

Then break the task into small, logical web steps in this format:

type WebsiteStep = {
  _id?: string;
  stepName: string;
  action: string; // e.g., "goto", "click", "fill", "upload", "waitForSelector"
  value?: string; // value to use in fill, goto, etc.
  selector?: string; // CSS or XPath selector
  verifyType?: EmailVerifyType;
  regularExpression?: string;
  emailReSendDelay?: string;
  emailReSendSelector?: string;
  waitForEmailReceive?: string;
  errorCount?: number;
  required?: boolean; // If true, step must succeed before continuing
};
⚠️ Rules & Conventions:
If action is "navigatee", replace it with "goto".

If required: true, the automation must pause or stop if the step fails.

Be logical and sequential — break complex instructions into clear steps (e.g., navigate → click signup → fill email → submit → wait).

Include selectors where needed for filling or clicking.

Use verifyType and regularExpression for handling email confirmations.

Ensure the output is clean, parseable, and ready for execution by a Playwright bot.

Please generate a Python function that performs the following task
Requirements:
Code must be readable and maintainable
Include type hints for all parameters and return values
Ensure Docker compatibility where applicable

Analyze the entire codebase I upload. Identify the purpose of each file and component. Then, rewrite the app with clean and modular React + Tailwind code, fully functional RTL layout, and integration with Supabase (auth, database) and Google Drive (file upload & sync).

Requirements:
- Keep the design and structure exactly the same unless improvements are needed.
- Use Tailwind classes with clean structure.
- Ensure full RTL support in layout and UI.
- Add tooltips and labels where relevant.
- Add support for user authentication (Supabase).
- Add file upload logic and Drive/Supabase sync.
- Output clean code with reusable components.

Please wait until I finish uploading all the files before processing.

Analyze the provided TailwindCSS layout and debug flex/grid issues.

- Ensure proper **container spacing and alignment**.
- Debug **flex/grid ordering problems**.
- Suggest improvements for **responsive design using Tailwind utilities**.
- Fix **CSS specificity conflicts with Vue components**.

Write a short usage guide for this component, including any dependencies and expected inputs or behavior.

You are an advanced smart assistant with expertise in reading and interpreting API documentation. Your primary goal is to efficiently locate relevant information within various API documents, extract necessary parameters, and synthesize this information into comprehensive solutions. You excel at understanding complex technical details and can merge multiple data points to create clear, actionable insights. Always ensure that your responses are concise, accurate, and tailored to the user's specific needs, providing examples or code snippets when applicable.

Example 1: Fetching User Data from a REST API
User Query: "How can I retrieve user data from the XYZ API?"

Assistant Response:

Locate the API Documentation: Start by finding the section that describes the user data endpoint.
Extract Parameters:
Endpoint: GET /users
Query Parameters:
id (optional): The unique identifier for the user.
fields (optional): Comma-separated list of fields to return.
Construct the API Call:
GET https://api.xyz.com/users?id=123&fields=name,email
Response Handling: Ensure to check the response format (JSON) and handle any potential errors (e.g., 404 for not found).
Example 2: Posting Data to a Webhook
User Query: "How do I send data to the ABC webhook?"

Assistant Response:

Locate the API Documentation: Find the section that details how to interact with the webhook.

Extract Parameters:

Endpoint: POST /webhook
Request Body:
event_type: Type of event (e.g., user_signup).
data: Object containing relevant user information.
Construct the API Call:

POST https://api.abc.com/webhook
Content-Type: application/json

{
    "event_type": "user_signup",
    "data": {
        "user_id": "123",
        "user_email": "user@example.com"
    }
}
Response Handling: Confirm the expected response (e.g., 200 OK) and handle any errors accordingly.

Instructions for Implementation:
API Documentation Access: Ensure the assistant has access to the relevant API documentation, either through direct links or a database of documents.
Information Extraction Logic: Implement parsing logic to identify key sections of the documentation, such as endpoints, parameters, and response formats.
Response Generation: Develop a template for constructing responses that includes the extracted information, example API calls, and error handling guidelines.
Testing and Iteration: Regularly test the assistant with various API queries to refine its ability to extract and synthesize information accurately.

Please write an e2e test using Playwright, following these guidelines:
- Tests live in the app/tests directory
- Tests are split into 3 parts: selectors, actions, and tests
- Selectors live in app/tests/_selectors and are responsible only for getting elements on a give page. Here is an example:
```BlockForm.selectors.ts
import { Page } from "@playwright/test";

export class BlockFormSelectors {
  static readonly getOwnerPersonalRadio = (page: Page) =>
    page.getByLabel("Personal");

  static readonly getSlugInput = (page: Page) =>
    page.getByRole("textbox", { name: "Slug" });

  static readonly getDescriptionInput = (page: Page) =>
    page.getByRole("textbox", { name: "Description" });
}
```

- Actions live in app/tests/_actions and are responsible for taking basic actions in a given part of the application. Here is an example:
```Organization.actions.ts
import { Page } from "@playwright/test";
import { OrganizationFormSelectors } from "../_selectors/OrganizationForm.selectors";
import { NavBarSelectors } from "../_selectors/NavBar.selectors";

export class OrganizationActions {
  public static createOrganization = async ({
    page,
    name,
    slug,
    biography,
  }: {
    page: Page;
    name: string;
    slug: string;
    biography: string;
  }) => {
    await NavBarSelectors.getCreateButton(page).click();
    await NavBarSelectors.getCreateOrganizationButton(page).click();

    await OrganizationFormSelectors.getNameInput(page).fill(name);
    await OrganizationFormSelectors.getSlugInput(page).fill(slug);
    await OrganizationFormSelectors.getBiographyInput(page).fill(biography);

    await OrganizationFormSelectors.getCreateOrganizationButton(page).click();
  };
}
```

- Tests live in app/tests and are the full tests, written with the Jest framework. Here is an example:
```block.spec.ts
_test("Can create a new block", async ({ page }) => {
  const blockName = "Test Block";
  const blockDescription = "Test block description";
  const blockSlug = "test-block";
  const blockRule = "This is a test block rule";

  await BlockActions.createBlock({
    page,
    name: blockName,
    description: blockDescription,
    slug: blockSlug,
    rule: blockRule,
  });

  await GlobalActions.expectPath({
    page,
    path: ROUTES.PACKAGE({
      ownerSlug: TEST_USER_EXPECTED_SLUG,
      packageSlug: blockSlug,
    }),
  });

  await expect(page.getByText(blockName).first()).toBeVisible();
  await expect(page.getByText(blockDescription)).toBeVisible();
  await expect(page.getByText(blockRule)).toBeVisible();
})
```

Please write tests that cover the basic functionality described below, making sure to correctly create the corresponding selectors, actions, and tests in their respective files:

Generate relevant unit or UI tests for this web component using Playwright or another modern test framework.

Please review my Next.js code with a focus on optimization areas.

Use the below as a starting point, but consider any other potential areas for improvement.

You do not need to address every single area below, only what is relevant to the user's code.

1. Images: Check for proper usage of next/image, responsive sizing, priority loading for LCP, and correct image formats.

2. Font Loading: Verify next/font implementation, font subsetting, and proper loading strategies.

3. Component Loading: Identify opportunities for lazy loading using next/dynamic, especially for client components and heavy libraries.

4. Metadata: Ensure proper metadata implementation for SEO using either config-based or file-based approaches.

5. Performance: Look for:
   - Layout shift issues
   - Proper static/dynamic component usage
   - Bundle size optimization opportunities
   - Correct usage of loading states

Please point out any issues and suggest specific optimizations based on Next.js best practices.

Generate a data processing pipeline with these requirements:

Input:
- Data loading from multiple sources (CSV, SQL, APIs)
- Input validation and schema checks
- Error logging for data quality issues

Processing:
- Standardized cleaning (missing values, outliers, types)
- Memory-efficient operations for large datasets
- Numerical transformations using NumPy
- Feature engineering and aggregations

Quality & Monitoring:
- Data quality checks at key stages
- Validation visualizations with Matplotlib
- Performance monitoring

Structure:
- Modular, documented code with error handling
- Configuration management
- Reproducible in Jupyter notebooks
- Example usage and tests

The user has provided the following information:

Review how environment variables are used. Ask questions about sensitive data handling, deployment practices, and potential exposure points.

What's one most meaningful thing I could do to improve the quality of this code? It shouldn't be too drastic but should still improve the code.

<!-- Sequential Thinking Workflow -->
<assistant>
    <toolbox>
        <mcp_server name="sequential-thinking"
                        role="workflow_controller"
                        execution="sequential-thinking"
                        description="Initiate the sequential-thinking MCP server">
            <tool name="STEP" value="1">
                <description>Gather context by reading the relevant file(s).</description>
                <arguments>
                    <argument name="instructions" value="Seek proper context in the codebase to understand what is required. If you are unsure, ask the user." type="string" required="true"/>
                    <argument name="should_read_entire_file" type="boolean" default="true" required="false"/>
                </arguments>
                <result type="string" description="Context gathered from the file(s). Output can be passed to subsequent steps."/>
            </tool>
            <tool name="STEP" value="2">
                <description>Generate code changes based on the gathered context (from STEP 1).</description>
                <arguments>
                    <argument name="instructions" value="Generate the proper changes/corrections based on context from STEP 1." type="string" required="true"/>
                    <argument name="code_edit" type="object" required="true" description="Output: The proposed code modifications."/>
                </arguments>
                <result type="object" description="The generated code changes (code_edit object). Output can be passed to subsequent steps."/>
            </tool>
            <tool name="STEP" value="3">
                <description>Review the generated changes (from STEP 2) and suggest improvements.</description>
                <arguments>
                    <argument name="instructions" type="string" value="Review the changes applied in STEP 2 for gaps, correctness, and adherence to guidelines. Suggest improvements or identify any additional steps needed." required="true"/>
                </arguments>
                <result type="string" description="Review feedback, suggested improvements, or confirmation of completion. Final output of the workflow."/>
            </tool>
        </mcp_server>
    </toolbox>
</assistant>

Please create a new PyTorch module following these guidelines:
- Include docstrings for the model class and methods
- Add type hints for all parameters
- Add basic validation in __init__

Create an exploratory data analysis workflow that includes:

Data Overview:
- Basic statistics (mean, median, std, quartiles)
- Missing values and data types
- Unique value distributions

Visualizations:
- Numerical: histograms, box plots
- Categorical: bar charts, frequency plots
- Relationships: correlation matrices
- Temporal patterns (if applicable)

Quality Assessment:
- Outlier detection
- Data inconsistencies
- Value range validation

Insights & Documentation:
- Key findings summary
- Data quality issues
- Variable relationships
- Next steps recommendations
- Reproducible Jupyter notebook

The user has provided the following information: