### Starting Documentation Development Server

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Commands to set up and run a local development server for the project's documentation using npm.

```bash
cd docs
npm install
npm run dev  # Start development server at http://localhost:3000
```

--------------------------------

### Local Development Setup with Hatch (Python)

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

This snippet demonstrates the local development setup for RobotCode using Hatch, a Python project and package manager. It covers environment creation and installing editable packages for VS Code and IntelliJ.

```python
# Install Hatch (choose one method):
# Option A: Using system package manager (if available)
# Ubuntu/Debian: sudo apt install hatch
# Fedora: sudo dnf install hatch
# Arch: sudo pacman -S hatch

# Option B: Using pipx (recommended if not in package manager)
pip install pipx
pipx install hatch

# Option C: Check https://hatch.pypa.io/latest/install/ for other methods

# Create development environment
hatch env create devel

# install needed packages for the vscode and intellij packaging
hatch run build:install-bundled-editable
```

--------------------------------

### Clone Repository and Install Dependencies (Bash)

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Clones the RobotCode repository and installs necessary Node.js dependencies using npm. This is a common step for local development.

```bash
git clone https://github.com/robotcodedev/robotcode.git
cd robotcode

# Install Node.js dependencies
npm install --also-dev
```

--------------------------------

### Building Documentation for Production

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Commands to build the project's documentation for production deployment using npm.

```bash
cd docs
npm run build  # Build for production
npm run preview  # Preview production build
```

--------------------------------

### Install robotcode-repl using pip

Source: https://github.com/robotcodedev/robotcode/blob/main/packages/repl/README.md

Installs the robotcode-repl package, enabling the interactive REPL for Robot Framework. This is the primary method to get started with the tool.

```console
pip install robotcode-repl
```

--------------------------------

### Building Project Package

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Command to package the project for distribution using Hatch. This generates the necessary distribution files.

```bash
hatch run build:package
```

--------------------------------

### Install Robot Framework Core Dependency

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/02_get_started/index.md

This snippet shows the basic content for a `requirements.txt` file, listing Robot Framework as a core dependency for a project.

```txt
robotframework
```

--------------------------------

### Code Quality and Linting Commands

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Execute commands to ensure code quality and adherence to style guides. These commands utilize the 'hatch' build tool for linting and formatting checks.

```bash
hatch run lint:typing
```

```bash
hatch run lint:style
```

```bash
hatch run lint:all
```

--------------------------------

### Managing Node.js Dependencies

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Commands to clean and reinstall Node.js dependencies, useful for resolving issues related to package management.

```bash
# Clean and reinstall npm dependencies
rm -rf node_modules package-lock.json
npm install --also-dev
```

--------------------------------

### Create Basic Robot Framework Test Case

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/02_get_started/index.md

A simple Robot Framework test case that logs the message 'Hello world' to the debug console. This serves as a basic example for new users.

```robotframework
*** Test Cases ***
First Test Case
    Log    Hello world
```

--------------------------------

### Release and Documentation Management Commands

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Manage project releases and documentation updates using 'hatch'. This includes updating changelogs, versions, packaging, and publishing.

```bash
hatch run build:update-changelog
```

```bash
hatch run build:update-git-versions
```

```bash
hatch run build:bump [major|minor|patch]
```

```bash
hatch run build:package
```

```bash
hatch run build:publish
```

--------------------------------

### Install Dependencies with pip

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/02_get_started/index.md

Installs Robot Framework and other dependencies specified in the requirements.txt file using pip. This command should be executed in the project's root directory within the terminal.

```shell
pip install -r requirements.txt
```

--------------------------------

### Python/Backend Development Commands

Source: https://github.com/robotcodedev/robotcode/blob/main/CLAUDE.md

Commands for setting up the development environment, installing packages, running tests, linting, formatting, building, and publishing Python packages using Hatch.

```bash
# Setup development environment
hatch env create devel

# Install all packages in development mode
hatch run install-packages

# Run tests
hatch run test:test
hatch run test:test-reset  # Reset regression test snapshots

# Linting and formatting
hatch run lint:all      # Run mypy and ruff checks
hatch run lint:fix      # Auto-fix formatting and linting issues
hatch run lint:typing   # Type checking only
hatch run lint:style    # Code style checks only

# Build and packaging
hatch run build:package     # Build packages
hatch run build:publish     # Publish to PyPI
```

--------------------------------

### Git Branching and Committing

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Standard Git commands for creating a new feature branch, committing changes, and preparing for a pull request. Essential for collaborative development.

```bash
git checkout -b feature/your-feature-name
```

```bash
git commit -m "Your commit message"
```

--------------------------------

### Install Robot Framework with Robocop and Browser Library

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/02_get_started/index.md

This snippet demonstrates how to list additional dependencies in a `requirements.txt` file, including Robot Framework, robotframework-robocop for linting, and robotframework-browser for browser automation.

```txt
robotframework
robotframework-robocop
robotframework-browser
```

--------------------------------

### VS Code Extension Development Commands

Source: https://github.com/robotcodedev/robotcode/blob/main/CLAUDE.md

Commands for installing dependencies, performing development builds, and production builds for the VS Code extension.

```bash
# Install dependencies
npm install --include=dev

# Build extension
npm run compile         # Development build
npm run package         # Production build

# Testing
npm run test
```

--------------------------------

### Verify Robot Framework Installation

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/02_get_started/index.md

This command checks if Robot Framework is installed correctly by displaying its version. It's typically run in a terminal or command prompt within an activated virtual environment.

```shell
robot --version
```

--------------------------------

### Troubleshooting Hatch Environment Issues

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Commands to resolve common issues with Hatch environment creation and management, including pruning old environments and recreating the development environment.

```bash
# Clear Hatch cache and try again
hatch env prune
hatch env create devel
```

--------------------------------

### Hatch Environment Management

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Commands for managing Hatch environments, including creation, display, and running tasks within specific environments. Useful for setting up and interacting with project dependencies.

```bash
hatch env create devel
```

```bash
hatch env show
```

--------------------------------

### VS Code Python Interpreter Configuration

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Instructions for configuring the VS Code Python interpreter to correctly point to the development environment managed by Hatch.

```bash
# Use hatch env find devel to get the exact path
# Manually select the interpreter in VS Code using this path
```

--------------------------------

### Resolving Test Import Errors

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Steps to fix import errors in tests by ensuring the correct Hatch environment is activated and development packages are installed.

```bash
# Ensure you're in the correct hatch environment
# Run hatch run build:install-bundled-editable to install development packages
```

--------------------------------

### Basic TOML Syntax Example

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/02_get_started/configuration.md

Demonstrates the fundamental syntax of TOML files, including comments, key-value pairs, and nested sections.

```toml
# This is a comment
key = "value"

[section]
nested_key = "nested value"
```

--------------------------------

### Project Maintenance and Code Generation Commands

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Utilize 'hatch' to manage project maintenance tasks and generate essential project files, including syntax definitions and configuration schemas.

```bash
hatch run generate-tmlanguage
```

```bash
hatch run create-json-schema
```

```bash
hatch run generate-rf-options
```

```bash
hatch run build:install-bundled-editable
```

--------------------------------

### Configure Git for Automatic Commit Signing

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Sets Git to automatically sign all commits with your GPG key. This is a global configuration for your Git environment.

```bash
git config --global commit.gpgsign true
```

--------------------------------

### Hatch Task Execution

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Commands to run specific tasks using Hatch, including tests, linting, and code formatting. Allows for targeted execution of development workflows.

```bash
hatch run devel.py312-rf73:test
```

```bash
hatch run lint:all
```

```bash
hatch run lint:style
```

--------------------------------

### IntelliJ Plugin Development Commands

Source: https://github.com/robotcodedev/robotcode/blob/main/CLAUDE.md

Commands for building the IntelliJ plugin and running a development instance from the command line.

```bash
cd intellij-client

# Build plugin
./gradlew build

# Run development instance
./gradlew runIde
```

--------------------------------

### Installing robotcode-runner

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/02_get_started/configuration.md

Provides the command to install the necessary package for running Robot Framework tests using robotcode.

```bash
pip install robotcode[runner]
```

--------------------------------

### Verify Signed Commits

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Displays the commit history, including signature verification status for each commit. Useful for confirming that your commits are indeed signed.

```bash
git log --show-signature
```

--------------------------------

### Running All Tests with Hatch

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Commands to execute tests across various Python and Robot Framework versions using Hatch. The `test` command runs all combinations, while specific versions can be targeted.

```bash
hatch run test
```

```bash
hatch run test tests/specific_test.py
```

--------------------------------

### Robot Framework Example Snippet

Source: https://github.com/robotcodedev/robotcode/blob/main/resources/report_issue_body_template.md

This snippet demonstrates a basic Robot Framework test case structure, including settings and a test case with a keyword call. It serves as an example for users to provide code when reporting issues.

```robotframework
***Settings***
Library  Collections

***Test Cases***
a simple test
    do something    # this should shown something
```

--------------------------------

### Targeted Test Execution with Hatch

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Execute tests against specific Python and Robot Framework version combinations using Hatch. This is crucial for focused development and debugging.

```bash
hatch run test.rf70:test
```

```bash
hatch run test.rf73:test
```

```bash
hatch run devel.py39-rf73:test
```

```bash
hatch run devel.py312-rf73:test
```

```bash
hatch run rfbeta:test
```

```bash
hatch run rfmaster:test
```

```bash
hatch run rfdevel:test
```

--------------------------------

### TOML: Example of passing arguments to Robot Framework

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/config.md

Provides an example of how to pass command-line arguments to the Robot Framework executable via the robot.toml file.

```toml
args = ["-t", "abc"]
```

--------------------------------

### Install robotcode-repl-server using pip

Source: https://github.com/robotcodedev/robotcode/blob/main/packages/repl_server/README.md

This command installs the robotcode-repl-server package using pip, the Python package installer. Ensure you have Python and pip installed.

```console
pip install robotcode-repl-server
```

--------------------------------

### Install RobotCode CLI Tool

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/cli.md

Installs the core RobotCode CLI tool and optional packages for expanded functionality. Use `[all]` to install all dependencies.

```bash
pip install robotcode

```

```bash
pip install robotcode[runner]
pip install robotcode[analyze]
pip install robotcode[debugger]
pip install robotcode[repl]
pip install robotcode[language-server]

```

```bash
pip install robotcode[all]

```

--------------------------------

### Get Robot Framework Environment Information

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/cli.md

Displays information about the current Robot Framework environment. This command provides insights into the setup and configuration.

```bash
robotcode discover info
```

--------------------------------

### Install robotcode-analyze

Source: https://github.com/robotcodedev/robotcode/blob/main/packages/analyze/README.md

Installs the robotcode-analyze package using pip. This is the primary method for integrating the tool into your Python environment.

```console
pip install robotcode-analyze
```

--------------------------------

### Install robotcode-runner

Source: https://github.com/robotcodedev/robotcode/blob/main/packages/runner/README.md

This snippet shows the command to install the robotcode-runner package using pip. It's a straightforward installation for Python projects.

```console
pip install robotcode-runner
```

--------------------------------

### Commit Message Format

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

The standard format for commit messages, including type, scope, subject, body, and footer for clear and consistent project history.

```text
<type>(<scope>): <subject>

<body>

<footer>
```

--------------------------------

### Running Specific Tests and Coverage

Source: https://github.com/robotcodedev/robotcode/blob/main/CLAUDE.md

Commands for executing the full test suite, testing specific environments, and generating coverage reports using Hatch.

```bash
# Run full test suite
hatch run test

# Test specific environment
hatch run devel.py312-rf73:test

# Coverage reporting
hatch run cov
```

--------------------------------

### Install robotcode-plugin using pip

Source: https://github.com/robotcodedev/robotcode/blob/main/packages/plugin/README.md

This snippet shows the command to install the robotcode-plugin package using pip, the standard Python package installer. Ensure you have Python and pip installed.

```console
pip install robotcode-plugin
```

--------------------------------

### Install robotcode-core using pip

Source: https://github.com/robotcodedev/robotcode/blob/main/packages/core/README.md

This snippet shows how to install the robotcode-core package using pip, the standard Python package installer. It is a straightforward command-line operation.

```console
pip install robotcode-core
```

--------------------------------

### TOML: Example of defining environment variables

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/config.md

Shows how to define environment variables that will be set before Robot Framework execution, using the robot.toml configuration.

```toml
[env]
TEST_VAR = "test"
SECRET = "password"
```

--------------------------------

### Install robotcode-robot using pip

Source: https://github.com/robotcodedev/robotcode/blob/main/packages/robot/README.md

This snippet shows the command to install the robotcode-robot package using pip, the Python package installer. Ensure you have Python and pip installed.

```console
pip install robotcode-robot
```

--------------------------------

### Install robotcode-language-server with pip

Source: https://github.com/robotcodedev/robotcode/blob/main/packages/language_server/README.md

This command installs the robotcode-language-server package using pip. It provides LSP capabilities for Robot Framework development, enabling features like code completion, linting, and navigation within IDEs.

```console
pip install robotcode-language-server
```

--------------------------------

### TOML: Example of setting default profiles

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/config.md

Demonstrates how to configure default profiles in robot.toml, which are used if no profile is specified on the command line.

```toml
default_profiles = ["default", "Firefox"]
```

--------------------------------

### Install robotcode-debugger using pip

Source: https://github.com/robotcodedev/robotcode/blob/main/packages/debugger/README.md

This snippet shows the command to install the robotcode-debugger package using pip, the Python package installer. It's a straightforward command for setting up the debugging tool.

```console
pip install robotcode-debugger
```

--------------------------------

### Install robotcode-jsonrpc2

Source: https://github.com/robotcodedev/robotcode/blob/main/packages/jsonrpc2/README.md

Installs the robotcode-jsonrpc2 package using pip. This is the standard way to add the library to your Python environment.

```console
pip install robotcode-jsonrpc2
```

--------------------------------

### Robot Framework Settings Example

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/04_tip_and_tricks/01_avoiding_a_global_resource_file.md

Demonstrates how to declare libraries and resources within the Settings section of a Robot Framework suite file. This practice serves as documentation by clearly stating the dependencies and functionalities utilized by the suite.

```robotframework
*** Settings ***
Library   LoginProcess
Resource  CustomerManagement.resource
Resource  DatabaseValidation.resource
```

--------------------------------

### TOML: Example of inheriting multiple profiles

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/config.md

Illustrates how to specify multiple profiles to inherit from in Robot Framework's robot.toml configuration.

```toml
inherits = ["default", "Firefox"]
```

--------------------------------

### RobotCode Language Server Command

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/cli.md

Starts the RobotCode Language Server. This server enhances IDEs by providing features like syntax highlighting, auto-completion, and code analysis for Robot Framework development.

```text
language-server

```

--------------------------------

### TOML: Example of enabling a profile with a condition

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/config.md

Demonstrates how to conditionally enable a Robot Framework profile using an environment variable check within the robot.toml file.

```toml
# enabled if TEST_VAR is set
enabled = { if = 'environ.get("CI") == "true"' }
```

--------------------------------

### Install robotcode-modifiers using pip

Source: https://github.com/robotcodedev/robotcode/blob/main/packages/modifiers/README.md

Demonstrates the command to install the robotcode-modifiers package using pip. This is the standard method for adding Python packages to a project.

```console
pip install robotcode-modifiers
```

--------------------------------

### Create Python Virtual Environment (Python Way)

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/02_get_started/index.md

Creates a virtual Python environment named '.venv' in the current directory using the built-in 'venv' module. This isolates project dependencies.

```shell
python -m venv .venv
```

--------------------------------

### Run Robot Framework Language Server

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/cli.md

Starts the Robot Framework Language Server in various communication modes. Supports stdio, TCP, socket, and pipe connections, with options for specifying addresses and ports.

```text
robotcode language-server [OPTIONS] [PATHS]...

Options:
- --stdio
  Run in `stdio` mode. (Equivalent to `--mode stdio`) *NOTE:* This option is mutually exclusive with options: pipe, socket, pipe-name, tcp, mode, port, bind.  [env var: ROBOTCODE_STDIO]

- --tcp [<ADDRESS>:]<PORT>
  Run in `tcp` server mode and listen at the given port. (Equivalent to `--mode tcp --port <port>`) *NOTE:* This option is mutually exclusive with options: pipe, stdio, socket, pipe-name, mode, port.

- --socket [<ADDRESS>:]<PORT>
  Run in `socket` mode and connect to the given port. (Equivalent to `--mode socket --port <port>`) *NOTE:* This option is mutually exclusive with options: pipe, stdio, pipe-name, tcp, mode, port.

- --pipe NAME
  Run in `pipe` mode and connect to the given pipe name. (Equivalent to `--mode pipe --pipe-name <name>`) *NOTE:* This option is mutually exclusive with options: stdio, socket, pipe-name, tcp, mode, port, bind.

- --mode [tcp|pipe|stdio|socket]
  The mode to use for the debug launch server. *NOTE:* This option is mutually exclusive with options: tcp, pipe, stdio, socket.  [env var: ROBOTCODE_MODE; default: stdio]

- --port PORT
  The port to listen on or connect to. (Only valid for `tcp` and `socket mode`) *NOTE:* This option is mutually exclusive with options: pipe, pipe-name.  [env var: ROBOTCODE_PORT; default: 6610; 1<=x<=65535]

- --bind ADDRESS *
  Specify alternate bind address. If no address is specified `localhost` is used. (Only valid for tcp and socket mode) *NOTE:* This option is mutually exclusive with options: pipe, pipe-name.  [env var: ROBOTCODE_BIND; default: 127.0.0.1]

- --pipe-name NAME
  The pipe to listen on or connect to. (Only valid in `pipe` and `pipe-server` mode) *NOTE:* This option is mutually exclusive with options: pipe, stdio, socket, tcp, port, bind.  [env var: ROBOTCODE_PIPE_NAME]

- --version
  Show the version and exit.

- --help
  Show this message and exit.
```

--------------------------------

### rebot.start-time

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/config.md

Sets the execution start time for the test run. The timestamp format is flexible, accepting various separators and omitting zero-valued parts. This is useful for overriding or setting a start time for combined suites. Corresponds to the `--starttime timestamp` option.

```robotframework
--starttime 2023-10-27 10:30:00
```

```robotframework
--starttime 20231027T103000
```

--------------------------------

### Get Descriptions of Robot Framework Configuration Settings

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/cli.md

Retrieves descriptions for Robot Framework configuration settings. If a setting name or wildcard pattern is provided, it shows the description for matching settings. Otherwise, it displays descriptions for all available configuration settings.

```text
robotcode config info desc
robotcode config info desc python-path
robotcode config info desc rebot.*
robotcode config info desc *tag*
```

--------------------------------

### Run Robot Framework Interactively (robotcode repl)

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/cli.md

Starts an interactive session with Robot Framework, allowing users to execute commands and test scripts in real-time. Supports setting variables, specifying output directories, and controlling logging. It's useful for quick testing and debugging of Robot Framework syntax and libraries.

```text
robotcode repl [OPTIONS] [FILES]...

Options:
- -v, --variable name:value *
  Set variables in the test data. see `robot --variable` option.

- -V, --variablefile PATH *
  Python or YAML file file to read variables from. see `robot --variablefile` option.

- -P, --pythonpath PATH *
  Additional locations where to search test libraries and other extensions when they are imported. see `robot --pythonpath` option.

- -k, --show-keywords
  Executed keywords will be shown in the output.

- -i, --inspect
  Activate inspection mode. This forces a prompt to appear after the REPL script is executed.

- -d, --outputdir DIR
  Where to create output files. see `robot --outputdir` option.

- -o, --output FILE
  XML output file. see `robot --output` option.

- -r, --report FILE
  HTML output file. see `robot --report` option.

- -l, --log FILE
  HTML log file. see `robot --log` option.

- -x, --xunit FILE
  xUnit output file. see `robot --xunit` option.

- -s, --source FILE
  Specifies the path to a source file. This file must not exist and will neither be read nor written. It is used solely to set the current working directory for the REPL script and to assign a name to the internal suite.

- --version
  Show the version and exit.

- --help
  Show this message and exit.
```

--------------------------------

### Start Robot Framework REPL Server (robotcode repl-server)

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/cli.md

Launches a REPL server that clients can connect to for running Robot Framework scripts remotely. It supports various connection modes like stdio, tcp, socket, and pipe, along with options for port binding, variable setting, and output configuration. This is useful for remote execution and integration with other tools.

```text
robotcode repl-server [OPTIONS] [FILES]...

Options:
- --stdio
  Run in `stdio` mode. (Equivalent to `--mode stdio`) *NOTE:* This option is mutually exclusive with options: pipe, pipe-server, socket, tcp, mode, pipe-name, port, bind.  [env var: ROBOTCODE_STDIO]

- --tcp [<ADDRESS>:]<PORT>
  Run in `tcp` server mode and listen at the given port. (Equivalent to `--mode tcp --port <port>`) *NOTE:* This option is mutually exclusive with options: pipe, stdio, pipe-server, socket, pipe-name, mode, port.

- --socket [<ADDRESS>:]<PORT>
  Run in `socket` mode and connect to the given port. (Equivalent to `--mode socket --port <port>`) *NOTE:* This option is mutually exclusive with options: pipe, stdio, pipe-server, pipe-name, tcp, mode, port.

- --pipe NAME
  Run in `pipe` mode and connect to the given pipe name. (Equivalent to `--mode pipe --pipe-name <name>`) *NOTE:* This option is mutually exclusive with options: stdio, pipe-server, socket, pipe-name, tcp, mode, port, bind.

- --pipe-server NAME
  Run in `pipe-server` mode and listen at the given pipe name. (Equivalent to `--mode pipe-server --pipe-name <name>`) *NOTE:* This option is mutually exclusive with options: pipe, stdio, socket, pipe-name, tcp, mode, port, bind.

- --mode [stdio|tcp|socket|pipe|pipe-server]
  The mode to use for the debug launch server. *NOTE:* This option is mutually exclusive with options: pipe, stdio, pipe-server, socket, tcp.  [env var: ROBOTCODE_MODE; default: stdio]

- --port PORT
  The port to listen on or connect to. (Only valid for `tcp` and `socket mode`) *NOTE:* This option is mutually exclusive with options: pipe, pipe-server, pipe-name.  [env var: ROBOTCODE_PORT; default: 6601; 1<=x<=65535]

- --bind ADDRESS *
  Specify alternate bind address. If no address is specified `localhost` is used. (Only valid for tcp and socket mode) *NOTE:* This option is mutually exclusive with options: pipe, pipe-server, pipe-name.  [env var: ROBOTCODE_BIND; default: 127.0.0.1]

- --pipe-name NAME
  The pipe to listen on or connect to. (Only valid in `pipe` and `pipe-server` mode) *NOTE:* This option is mutually exclusive with options: pipe, stdio, pipe-server, socket, tcp, port, bind.  [env var: ROBOTCODE_PIPE_NAME]

- -v, --variable name:value *
  Set variables in the test data. see `robot --variable` option.

- -V, --variablefile PATH *
  Python or YAML file file to read variables from. see `robot --variablefile` option.

- -P, --pythonpath PATH *
  Additional locations where to search test libraries and other extensions when they are imported. see `robot --pythonpath` option.

- -d, --outputdir DIR
  Where to create output files. see `robot --outputdir` option.

- -o, --output FILE
  XML output file. see `robot --output` option.

- -r, --report FILE
  HTML output file. see `robot --report` option.

- -l, --log FILE
  HTML log file. see `robot --log` option.

- -x, --xunit FILE
  xUnit output file. see `robot --xunit` option.

- --version
  Show the version and exit.

- -s, --source FILE
  Specifies the path to a source file. This file must not exist and will neither be read nor written. It is used solely to set the current working directory for the REPL script and to assign a name to the internal suite.

- --help
  Show this message and exit.
```

--------------------------------

### RETURN Statement Examples in Robot Framework

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/04_tip_and_tricks/02_why_variable_not_found.md

Shows how to use the RETURN statement to pass single or multiple values from a keyword. It demonstrates basic calculations and retrieving user details.

```robotframework
*** Keywords ***
Calculate Total Price
    [Arguments]    ${base_price}    ${tax_rate}=0.1    ${discount}=0
    ${tax_amount}=    Evaluate    ${base_price} * ${tax_rate}
    ${discounted_price}=    Evaluate    ${base_price} - ${discount}
    ${total}=    Evaluate    ${discounted_price} + ${tax_amount}
    RETURN    ${total}

Get User Details
    [Arguments]    ${user_id}
    ${name}=    Query Database    SELECT name FROM users WHERE id=${user_id}
    ${email}=    Query Database    SELECT email FROM users WHERE id=${user_id}
    ${role}=     Query Database    SELECT role FROM users WHERE id=${user_id}
    RETURN    ${name}    ${email}    ${role}

*** Test Cases ***
Test With Return Values
    ${price}=    Calculate Total Price    100    0.2    10
    Should Be Equal As Numbers    ${price}    108

    ${name}    ${email}    ${role}=    Get User Details    123
    Log    User: ${name} (${email}) has role: ${role}
```

--------------------------------

### Login and Get Customer Details Test Case

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/04_tip_and_tricks/01_avoiding_a_global_resource_file.md

A sample Robot Framework test case that demonstrates logging into an application and retrieving customer details. It relies on imported resource files for keywords.

```robot
# Only importing what is needed
Resource    ui/login.resource
Resource    api/customers.resource

*** Test Cases ***
Valid Login
    Login To Application    valid_user    valid_password
    Get Customer Details    123
```

--------------------------------

### Robot Framework Keyword: Setup Test Data (New Approach)

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/04_tip_and_tricks/02_why_variable_not_found.md

This Robot Framework keyword showcases the recommended approach for setting test data by returning values directly. This method ensures clear data flow, making variables traceable by RobotCode.

```Robot Framework
*** Keywords ***
Setup Test Data
    ${user}=    Create Test User
    ${token}=    Get Auth Token    ${user}
    RETURN    ${user}    ${token}
```

--------------------------------

### Extend RobotCode hint diagnostics

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/config.md

Extends the list of diagnostic codes that RobotCode treats as hints. Useful for guiding developers towards best practices or potential improvements.

```toml
[tool.robotcode-analyze.modifiers]
extend_hint = ["VariableNotFound", "multiple-keywords"]

```

--------------------------------

### RobotCode REPL Usage

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/index.md

RobotCode provides an interactive Read-Eval-Print Loop (REPL) for trying keywords and prototyping flows. It can be used for local sessions or via a 'repl-server' in headless setups, facilitating experimentation and debugging.

```bash
robotcode repl
repl-server
```

--------------------------------

### Activate Python Virtual Environment (Cross-Platform)

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/02_get_started/index.md

Provides commands to activate a Python virtual environment on different operating systems (Windows PowerShell, Windows CMD, Mac/Linux). Activation modifies the shell's PATH to prioritize the virtual environment's Python interpreter and packages.

```shell
myenv\Scripts\activate.ps1
```

```shell
myenv\Scripts\activate.cmd
```

```shell
source myenv/bin/activate
```

--------------------------------

### Robot Framework Global Resource File Example

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/04_tip_and_tricks/01_avoiding_a_global_resource_file.md

This snippet demonstrates a typical Robot Framework resource file designed to be global. It imports multiple libraries and other resource files, and declares numerous variables, illustrating the common practice that can lead to project-wide issues due to its all-encompassing nature.

```robotframework
*** Settings ***
# Global.resource - tries to do everything
Library    SeleniumLibrary
Library    RequestsLibrary
Library    DatabaseLibrary
Library    OperatingSystem
Resource   LoginKeywords.resource
Resource   CustomerKeywords.resource
Resource   OrderKeywords.resource
Resource   ApiKeywords.resource
Resource   ReportingKeywords.resource
# ...and 20+ more imports

*** Variables ***
${GLOBAL_URL}    https://example.com
${DB_CONNECTION}    connection_string
# ...hundreds of variables for different modules

*** Keywords ***
```

--------------------------------

### Configure RobotCode Analyze Arguments for Library

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/config.md

Specifies a list of libraries for which arguments will be ignored during analysis. This is useful for libraries that get variables from Python files with complex data. Glob patterns can be used. Requires 'RobotCode: Clear Cache and Restart Language Servers' if changed.

```yaml
robotcode.analyze:
  cache:
    ignore_arguments_for_library:
      - "**/mylibfolder/mylib.py"
      - "MyLib"
      - "mylib.subpackage.subpackage"
```

--------------------------------

### Robot Framework Test Case: Test With Clear Data Flow

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/04_tip_and_tricks/02_why_variable_not_found.md

This Robot Framework test case demonstrates how to consume data returned from a keyword like 'Setup Test Data' (new approach). It highlights the explicit assignment of returned values to local variables, enhancing traceability.

```Robot Framework
*** Test Cases ***
Test With Clear Data Flow
    ${user}    ${token}=    Setup Test Data
    # Variables are explicit and traceable
```

--------------------------------

### Simplified Test Execution with robotcode run

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/02_get_started/configuration.md

Illustrates how to execute tests using the `robotcode run` command when test paths are defined in robot.toml, including tag filtering.

```bash
# run all tests
robotcode run

# run tests and only include/exclude tests with specific tags
robotcode run -i regression -e wip
```

--------------------------------

### Running Robot Framework Tests with robotcode

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/02_get_started/configuration.md

Demonstrates common command-line usage patterns for executing Robot Framework tests with robotcode, including specifying profiles, overriding variables, and filtering by tags.

```bash
# Run all tests in a directory
robotcode robot tests/

# Run with a specific profile
robotcode -p dev robot tests/

# Combine multiple profiles
robotcode -p base -p windows robot tests/

# Override variables on command line
robotcode -p dev -v BROWSER:firefox robot tests/

# Run tests by tag
robotcode robot -i smoke -i regression tests/
```

--------------------------------

### Sign Previous Commits with Git Rebase

Source: https://github.com/robotcodedev/robotcode/blob/main/CONTRIBUTING.md

Amends previous commits to add a GPG signature. This command is used to sign commits that were made before enabling automatic signing or if signing was missed.

```bash
git rebase --exec 'git commit --amend --no-edit -S' -i HEAD~<number-of-commits>
```

--------------------------------

### Run Robot Framework Tests with robotcode robot

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/cli.md

Executes Robot Framework tests using the 'robot' command. It accepts configurations, profiles, options, and arguments which are passed directly to the Robot Framework execution. Use '-- --help' to view Robot Framework's specific help.

```bash
robotcode robot
robotcode robot tests
robotcode robot -i regression -e wip tests
robotcode --profile ci robot -i regression -e wip tests
```

```text
robotcode robot [OPTIONS] [ROBOT_OPTIONS_AND_ARGS]...
```

--------------------------------

### Core Robot Framework Settings in robot.toml

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/02_get_started/configuration.md

Illustrates how to configure essential Robot Framework command-line options like output directory, log level, and languages, along with global variables within the TOML file.

```toml
# Basic settings
output-dir = "output"
log-level = "INFO"
languages = ["en", "fi"]

# Global variables
[variables]
BROWSER = "Chrome"
LOGIN_URL = "https://example.com/login"
TIMEOUT = "20s"
```

--------------------------------

### Robot.toml Profiles for Different Environments

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/02_get_started/configuration.md

Shows how to create and manage profiles in robot.toml for distinct testing environments, defining specific settings and variables for each.

```toml
# Default settings (applies to all profiles)
output-dir = "results"
log-level = "INFO"

# Development environment profile
[profiles.dev]
output-dir = "results/dev"
variables = { ENVIRONMENT = "development", API_URL = "http://dev-api.example.com" }

# Production testing profile
[profiles.prod]
output-dir = "results/prod"
variables = { ENVIRONMENT = "production", API_URL = "https://api.example.com" }
```

--------------------------------

### Robot Framework Conditional Variable Assignment Example

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/04_tip_and_tricks/02_why_variable_not_found.md

Demonstrates how variables set within conditional branches (IF/ELSE) or loops might not be recognized by RobotCode due to static analysis limitations. The example shows 'VariableNotFound' errors when logging variables that are conditionally set.

```robotframework
*** Test Cases ***
test different environments
  IF    '${ENV}' == 'production'
      Set Suite Variable    ${API_URL}    https://api.production.example.com
  ELSE
      Set Suite Variable    ${TEST_URL}    https://api.test.example.com
  END

  Log    ${API_URL}     # [!code error] Error: VariableNotFound
  Log    ${TEST_URL}    # [!code error] Error: VariableNotFound

```

--------------------------------

### Safe Variable Access with Get Variable Value (Robot Framework)

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/04_tip_and_tricks/02_why_variable_not_found.md

Demonstrates safe variable access using Robot Framework's `Get Variable Value` keyword (available from version 5.0). This allows retrieving a variable's value with a specified default if the variable is not found, and safely checks for the existence of nested or optional variables.

```robotframework
*** Test Cases ***
Safe Variable Access
    # Get variable with default if not exists
    ${url}=    Get Variable Value    ${API_URL}    https://default.example.com

    # Check nested variables safely
    ${timeout}=    Get Variable Value    ${CONFIG.timeout}    30

    # Use None as default to check existence
    ${optional_var}=    Get Variable Value    ${OPTIONAL_SETTING}    ${None}
    IF    $optional_var is not None
        Log    Optional setting is: ${optional_var}
    END
```

--------------------------------

### List RobotCode Configuration Settings

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/cli.md

Lists all available configuration settings for RobotCode. It supports searching for specific settings by name, including wildcard matching. Dependencies include the RobotCode CLI itself.

```text
robotcode config info list
robotcode config info list rebot.*
robotcode config info list *tag*
```

--------------------------------

### RobotCode CLI Tools for Test Execution and Debugging

Source: https://github.com/robotcodedev/robotcode/blob/main/README.md

RobotCode extends Robot Framework's command-line capabilities with tools for test execution, debugging, and code analysis. It supports `robot.toml` for configuration, features a Debug Adapter Protocol (DAP) debugger, and includes an interactive REPL for quick experimentation.

```bash
# Example of using RobotCode CLI for test execution
robotcode test my_tests/

# Example of using RobotCode CLI for debugging
robotcode debug my_tests/my_test.robot
```

--------------------------------

### Robot Framework CLI Commands

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/index.md

RobotCode enhances standard Robot Framework CLI commands such as 'robot', 'rebot', 'libdoc', and 'discover'. It also introduces a unified CLI for profiles, environments, and repeatable execution, ideal for local development and CI pipelines.

```bash
robot
rebot
libdoc
discover
```

--------------------------------

### Generate Test Documentation with robotcode testdoc

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/cli.md

Generates documentation for Robot Framework tests using the 'testdoc' command. Similar to the 'robot' command, it passes configurations, profiles, options, and arguments directly to the underlying testdoc execution. Use '-- --help' to access Robot Framework's testdoc help.

```text
robotcode testdoc [OPTIONS] [ROBOT_OPTIONS_AND_ARGS]...
```

--------------------------------

### TOML: Example of hiding a profile with a condition

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/config.md

Shows how to conditionally hide a Robot Framework profile based on an environment variable in robot.toml.

```toml
hidden = { if = 'environ.get("CI") == "true"' }
```

--------------------------------

### Profile Inheritance in robot.toml

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/02_get_started/configuration.md

Demonstrates how profiles can inherit settings from a base profile to reduce redundancy and maintain consistency across configurations.

```toml
# Base profile with common settings
[profiles.base]
log-level = "INFO"
variables = { TIMEOUT = "20s" }

# Development profile builds on base settings
[profiles.dev]
inherits = ["base"]
variables = { ENVIRONMENT = "development", API_URL = "http://dev-api.example.com" }

# Testing profile also builds on base settings
[profiles.test]
inherits = ["base"]
variables = { ENVIRONMENT = "testing", API_URL = "http://test-api.example.com" }
```

--------------------------------

### Discover Robot Framework Files

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/cli.md

Lists all files that are used to discover tests. Currently, only `.robot` and `.resource` files are shown. It supports displaying full paths instead of relative ones.

```bash
robotcode discover files .
robotcode discover files --full-paths .
```

--------------------------------

### Discover Robot Framework Project Information (robotcode discover)

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/cli.md

Provides commands to discover information about the current Robot Framework project. This includes finding tests, suites, tasks, files, and diagnostics. It supports filtering and configuration through options and arguments, allowing detailed introspection of the project structure.

```text
robotcode discover [OPTIONS] COMMAND [ARGS]...
```

--------------------------------

### Robot Framework Variables Definition Example

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/04_tip_and_tricks/02_why_variable_not_found.md

Demonstrates defining default variables like browser type and headless mode in the '*** Variables ***' section of a Robot Framework file. These defaults can be overridden by command-line arguments.

```robotframework
*** Settings ***
Library    Browser

*** Variables ***
${BROWSER}      chromium
${HEADLESS}     FALSE

*** Test Cases ***
Open Browser Test
    New Browser    browser=${BROWSER}    headless=${HEADLESS}
    New Page       https://example.com
    # Further test steps...
    Close Browser
```

--------------------------------

### libdoc Documentation Format

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/config.md

Specifies the source documentation format for libdoc. Supported formats include ROBOT, HTML, TEXT, and REST. The default is ROBOT.

```bash
# Example for setting documentation format
libdoc --docformat ROBOT my_library.py
libdoc --docformat HTML my_library.py
```

--------------------------------

### Rebot Documentation Configuration

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/config.md

Sets the documentation for the top-level suite. Supports simple formatting and can read documentation from a file. If the value contains spaces, it must be quoted.

```shell
--doc "Very *good* example"
--doc doc_from_file.txt
```

--------------------------------

### Enable Legacy Output Format (robot)

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/config.md

Creates an XML output file in a format compatible with Robot Framework 6.x and earlier.

```robot
--legacyoutput
```

--------------------------------

### Robot Framework API Customer Details Keyword

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/04_tip_and_tricks/01_avoiding_a_global_resource_file.md

Provides a Robot Framework keyword to fetch customer details using the RequestsLibrary. It makes a GET request to a customer API endpoint and returns the JSON response.

```robot
*** Settings ***
Library    RequestsLibrary

*** Keywords ***
Get Customer Details
    [Arguments]    ${customer_id}
    ${response}=    GET    ${API_URL}/customers/${customer_id}
    [Return]    ${response.json()}
```

--------------------------------

### Discover All Robot Framework Project Elements (robotcode discover all)

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/cli.md

Discovers all elements like suites, tests, and tasks within a Robot Framework project, respecting configurations, profiles, and options. It allows filtering by tags, long names, and path types (full or relative). Users can pass additional Robot Framework arguments using `-- --help`.

```text
robotcode discover all [OPTIONS] [ROBOT_OPTIONS_AND_ARGS]...
```

--------------------------------

### Defining Test Paths in robot.toml

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/02_get_started/configuration.md

Shows how to specify the directories containing tests directly within the robot.toml file, allowing for simpler execution commands.

```toml
paths = ["tests"]
```

--------------------------------

### Start RobotCode Debug Session

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/cli.md

Initiates a Robot Framework debug session, waiting for incoming connections. It offers numerous options to control the debug behavior, such as enabling/disabling debug mode, stopping on entry, waiting for clients, setting timeouts, and configuring the debug protocol (TCP or pipe).

```text
robotcode debug [OPTIONS] [ROBOT_OPTIONS_AND_ARGS]...

Options:
--debug / --no-debug
--stop-on-entry / --no-stop-on-entry
--wait-for-client / --no-wait-for-client
--wait-for-client-timeout FLOAT
--configuration-done-timeout FLOAT
--debugpy / --no-debugpy
--debugpy-wait-for-client / --no-debugpy-wait-for-client
--debugpy-port INTEGER
--output-messages / --no-output-messages
--output-log / --no-output-log
--output-timestamps / --no-output-timestamps
--group-output / --no-group-output
--tcp [<ADDRESS>:]<PORT>
--pipe-server NAME
--mode [tcp|pipe-server]
--port PORT
--bind ADDRESS *
--pipe-name NAME
--version
--help
```

--------------------------------

### libdoc Spec Documentation Format

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/03_reference/config.md

Specifies the documentation format used within XML and JSON spec files. RAW preserves the original format, while HTML converts it. Defaults vary based on spec file type.

```bash
# Example for RAW documentation format in spec files
libdoc --specdocformat RAW my_library.py

# Example for HTML documentation format in spec files
libdoc --specdocformat HTML my_library.py
```

--------------------------------

### Robot Framework: Variable override through called keywords

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/04_tip_and_tricks/02_why_variable_not_found.md

This Robot Framework example shows how a variable defined in a test case can be overridden by a variable with the same name but a wider scope (global) set within a called keyword. This highlights the potential for hard-to-understand effects if not managed carefully.

```robotframework
*** Test Cases ***
test variable scopes
    VAR    ${a_var}    a local value
    Log    ${a_var}  # Output: a local value
    Do Something
    Log    ${a_var}  # Output: a global value - the local variable was overridden


*** Keywords ***
Do Something
    VAR    ${a_var}    a global value    scope=global

```

--------------------------------

### Get Configuration Value with Fallback (Robot Framework)

Source: https://github.com/robotcodedev/robotcode/blob/main/docs/04_tip_and_tricks/02_why_variable_not_found.md

This keyword retrieves a configuration value using a given key. If the variable corresponding to the key does not exist, it returns a specified default value and logs a warning. It relies on `Run Keyword And Return Status` and `Variable Should Exist`.

```robotframework
*** Keywords ***
Get Configuration Value
    [Arguments]    ${key}    ${default}=${EMPTY}
    ${exists}=    Run Keyword And Return Status
    ...    Variable Should Exist    ${${key}}
    IF    ${exists}
        ${value}=    Set Variable    ${${key}}
    ELSE
        ${value}=    Set Variable    ${default}
        Log    Variable ${key} not found, using default: ${default}    WARN
    END
    RETURN    ${value}
```