docs: redesign the README and some docs and added powered by IntelliJ to README and docs

Author: d-biehl

README.md

@@ -1,35 +1,37 @@
-
-# RobotCode - Language Support for Robot Framework in Visual Studio Code
+# RobotCode - The Ultimate Robot Framework Toolset
 
 [![License](https://img.shields.io/github/license/robotcodedev/robotcode?style=flat&logo=apache)](https://github.com/robotcodedev/robotcode/blob/master/LICENSE)
 [![Build Status](https://img.shields.io/github/actions/workflow/status/robotcodedev/robotcode/build-test-package-publish.yml?branch=main&style=flat&logo=github)](https://github.com/robotcodedev/robotcode/actions?query=workflow:build_test_package_publish)
-
 [![VS Code Marketplace](https://img.shields.io/visual-studio-marketplace/v/d-biehl.robotcode?style=flat&label=VS%20Marketplace&logo=visual-studio-code)](https://marketplace.visualstudio.com/items?itemName=d-biehl.robotcode)
 [![Installs](https://img.shields.io/visual-studio-marketplace/i/d-biehl.robotcode?style=flat)](https://marketplace.visualstudio.com/items?itemName=d-biehl.robotcode)
-
 [![JETBRAINS Marketplace](https://img.shields.io/jetbrains/plugin/v/26216.svg)](https://plugins.jetbrains.com/plugin/26216)
 [![Downloads](https://img.shields.io/jetbrains/plugin/d/26216.svg)](https://plugins.jetbrains.com/plugin/26216)
-
-
 [![PyPI - Version](https://img.shields.io/pypi/v/robotcode.svg?style=flat)](https://pypi.org/project/robotcode)
 [![Python Version](https://img.shields.io/pypi/pyversions/robotcode.svg?style=flat)](https://pypi.org/project/robotcode)
 [![Downloads](https://img.shields.io/pypi/dm/robotcode.svg?style=flat&label=downloads)](https://pypi.org/project/robotcode)
 
 ---
 
-**RobotCode** is a Visual Studio Code extension that enhances your workflow with [Robot Framework](https://robotframework.org/).
-It provides a rich set of features to help you write, run, and debug your Robot Framework tests directly within Visual Studio Code.
+## What is RobotCode?
+
+RobotCode is a comprehensive toolkit for Robot Framework development, offering advanced features to enhance your productivity and streamline your workflow. Whether you're using Visual Studio Code, IntelliJ, or other LSP-compatible editors, RobotCode ensures a consistent and seamless experience.
+
+### Key Advantages:
+
+- **Built on Robot Framework Core**
+  RobotCode uses Robot Framework's native parser for syntax validation, error messages, and behavior, ensuring full compatibility and reliability in your projects.
 
-## Why RobotCode?
+- **Powered by the Language Server Protocol (LSP)**
+  By leveraging the LSP, RobotCode provides real-time code navigation, intelligent auto-completion, and refactoring capabilities across various editors and IDEs.
 
-**Built on Robot Framework Core**
-RobotCode is based on the Robot Framework Core and uses its parser, ensuring complete compatibility and consistency. This means you get the same syntax validation, error messages, and behavior as if you were running Robot Framework directly.
+- **Multi-Platform IDE Extensions**
+  RobotCode offers robust extensions for Visual Studio Code and IntelliJ Platform, delivering the same high-quality features regardless of your preferred development environment. Thanks to LSP, it also works with editors like Neovim and Sublime Text.
 
-**Powered by the Language Server Protocol**
-RobotCode is built on the Language Server Protocol (LSP), a modern standard for implementing language support across multiple editors and IDEs. This ensures a seamless and responsive user experience, while making it easier to maintain compatibility with evolving IDE features.
+- **Enhanced CLI Tools**
+  Extend Robot Framework's command-line capabilities with tools for test execution, debugging, and code analysis. Features include `robot.toml` support, a Debug Adapter Protocol (DAP) debugger, and an interactive REPL for quick experimentation.
+
+With RobotCode, you can focus on building and testing your automation workflows while enjoying an integrated and efficient development experience.
 
-**Powerful Command Line Tools**
-RobotCode extends the Robot Framework CLI with enhanced tools for test execution, analysis, and debugging. It supports [`robot.toml`](https://robotcode.io/03_reference/) configurations, integrates a Debug Adapter Protocol (DAP) compatible debugger, and provides an interactive REPL environment for experimenting with Robot Framework commands. Modular and flexible, these tools streamline your workflow for both development and production.
 
 ## Key Features
 
@@ -50,28 +52,84 @@ RobotCode extends the Robot Framework CLI with enhanced tools for test execution
 - **RobotCode Repl and Notebooks**: Play with Robot Framework in a Jupyter Notebook-like environment.
 - **And More!**: Check out the [official documentation](https://robotcode.io) for more details.
 
+
 ## Requirements
 
 - Python 3.8 or newer
 - Robot Framework 4.1 or newer
+
+### IDE Support
+
 - Visual Studio Code 1.86 or newer
+- PyCharm 2024.3.2 or newer or IntelliJ IDEA 2024.3.2 or newer
+
 
 ## Getting Started
 
-1. Install the [RobotCode extension](https://marketplace.visualstudio.com/items?itemName=d-biehl.robotcode) from the Visual Studio Marketplace.
-2. Configure your Robot Framework environment with the command-line tools provided by the extension.
-3. Start writing and running your Robot Framework tests!
+### Visual Studio Code
+
+1. **Install the RobotCode Extension**
+   Open the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=d-biehl.robotcode) and install the RobotCode extension.
 
-For a more detailed guide, check out the [Let's get started](https://robotcode.io/02_get_started/) Guide on the [RobotCode](https://robotcode.io) website.
+2. **Set Up Your Environment**
+   Configure your Robot Framework environment using the tools and commands provided by the extension or the `robot.toml` file.
 
-## Extensions
+3. **Start Testing**
+   Begin writing and running your Robot Framework tests directly in VS Code.
 
+4. **Explore More**
+   Visit the [Getting Started Guide](https://robotcode.io/02_get_started/) for detailed setup instructions and advanced features.
+
+**Extensions:**
 RobotCode automatically installs the [Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python) and the [Python Debugger](https://marketplace.visualstudio.com/items?itemName=ms-python.debugpy) extension. Additional extensions may be required depending on your project needs.
 
+
+### IntelliJ IDEA or PyCharm
+
+1. **Install the RobotCode Plugin**
+   Choose one of the following methods to install the RobotCode plugin in your IDE:
+
+   - **Install via the Built-in Plugin Marketplace**
+      Navigate to:
+      <kbd>Settings/Preferences</kbd> > <kbd>Plugins</kbd> > <kbd>Marketplace</kbd> > Search for "RobotCode" and click <kbd>Install</kbd>.
+
+   - **Use the JetBrains Marketplace**
+      Alternatively, install the plugin directly from the [JetBrains Marketplace](https://plugins.jetbrains.com/plugin/26216). Click the <kbd>Install to ...</kbd> button if your IDE is running.
+
+   - **Manual Installation**
+      Download the [latest release](https://github.com/robotcodedev/robotcode/releases/latest) and install it manually:
+      <kbd>Settings/Preferences</kbd> > <kbd>Plugins</kbd> > <kbd>⚙️</kbd> > <kbd>Install plugin from disk...</kbd>.
+
+2. **Set Up Your Environment**
+   Configure your Robot Framework environment using the tools and commands provided by the plugin or the `robot.toml` file.
+
+3. **Start Testing**
+   Begin developing and executing your Robot Framework tests.
+
+4. **Explore More**
+   Visit the [Getting Started Guide](https://robotcode.io/02_get_started/) for detailed setup instructions and advanced features.
+
+**Plugins:**
+RobotCode automatically installs the [LSP4IJ](https://plugins.jetbrains.com/plugin/23257). Additional plugins may be required depending on your project needs.
+
+
 ## Documentation
 
-For more details on installation, setup, and usage, refer to the [official RobotCode documentation](https://robotcode.io).
+For detailed instructions, visit our **[official documentation](https://robotcode.io)**.
+Here are some additional resources to help you troubleshoot or learn more:
+
+- **[Q&A](https://github.com/robotcodedev/robotcode/discussions/categories/q-a):** Answers to common questions about RobotCode.
+- **[Troubleshooting Guide](https://robotcode.io/04_tip_and_tricks/troubleshooting):** Solutions for setup issues, performance problems, and debugging errors.
+- **[Command Line Tools Reference](https://robotcode.io/03_reference/):** Comprehensive documentation on using RobotCode’s CLI tools.
+- **[Changelog](https://github.com/robotcodedev/robotcode/blob/main/CHANGELOG.md):** Track changes, updates, and new features in each release.
+- **[Support](https://robotcode.io/support/):** Learn how to get help and report issues.
+
 
 ## License
 
 This project is licensed under the [Apache 2.0 License](https://spdx.org/licenses/Apache-2.0.html).
+
+---
+
+## Powered by
+[![JetBrains logo.](docs/images/jetbrains.svg)](https://jb.gg/OpenSourceSupport)

docs/01_about/index.md

@@ -1,6 +1,22 @@
 # What is RobotCode?
 
-**RobotCode** is your all-in-one extension for working with the [Robot Framework](https://robotframework.org/) in [Visual Studio Code](https://code.visualstudio.com/). Whether you're writing, testing, or debugging, RobotCode provides a comprehensive toolkit that makes every aspect of your development process smoother and more efficient.
+**RobotCode**
+Is a set of tools and extensions and plugins for working with [Robot Framework](https://robotframework.org/) in different IDEs, editors and on the command line.
+
+
+**Built on Robot Framework Core**
+RobotCode is based on the Robot Framework Core and uses its parser, ensuring complete compatibility and consistency. This means you get the same syntax validation, error messages, and behavior as if you were running Robot Framework directly.
+
+**Powered by the Language Server Protocol**
+RobotCode is built on the Language Server Protocol (LSP), a modern standard for implementing language support across multiple editors and IDEs. This ensures a seamless and responsive user experience, while making it easier to maintain compatibility with evolving IDE features.
+
+**Extensions for Visual Studio Code and the IntelliJ Platform**
+RobotCode is available for Visual Studio Code, IntelliJ Platform. This ensures that you can use the same features and tools across different IDEs and editors.
+Because the extensions are based on the same codebase, you can expect the same level of quality and features across all platforms.
+(Because it is based on the Language Server Protocol, it is also possible to use it in other editors that support the LSP, like Neovim, Sublime Text, and more.)
+
+**Powerful Command Line Tools**
+RobotCode extends the Robot Framework CLI with enhanced tools for test execution, code analysis and debugging. It supports [`robot.toml`](https://robotcode.io/03_reference/) configurations, integrates a Debug Adapter Protocol (DAP) compatible debugger, and provides an interactive REPL environment for experimenting with Robot Framework commands. Modular and flexible, these tools streamline your workflow for both development and production.
 
 ## Key Features
 
@@ -22,7 +38,7 @@
 - **Seamless Integration with Robot Framework:** RobotCode uses the version of Robot Framework installed in your environment for diagnostics, ensuring accuracy and consistency with your actual test runs.
 - **Enhanced Linting with Robocop:** For developers who want to go further, RobotCode integrates with [Robocop](https://robocop.readthedocs.io/) to provide even more detailed analysis and linting, giving you insights into how to optimize your code.
 
-### Code Formatting
+### Code Formatting and Tidying
 
 - **Automatic Code Formatting:** Keep your code clean and consistent with RobotCode’s formatting tools. You can choose to use the built-in `robot.tidy` tool (now deprecated) or the more powerful [Robotidy](https://robotidy.readthedocs.io/). With just a few clicks, your code is neatly organized and ready for review.
 - **Customizable Formatting Options:** Tailor the formatting rules to suit your project’s needs, ensuring that your codebase remains consistent and easy to read.
@@ -39,6 +55,29 @@
 - **Manage Multiple Projects Seamlessly:** With support for [Multi-root Workspaces](https://code.visualstudio.com/docs/editor/multi-root-workspaces), RobotCode allows you to work on multiple Robot Framework projects simultaneously, each with its own settings and Python environments. Whether you prefer to have separate environments or share the same one across projects, RobotCode offers the flexibility to match your workflow.
 - **Smooth Workflow Transitions:** Easily switch between different projects and configurations without losing your place or context, making it easier to manage complex development environments and large codebases.
 
+### Debug Adapter Protocol (DAP) Compatible Debugger
+
+- **Robust Debugging Capabilities:** RobotCode integrates a Debug Adapter Protocol (DAP) compatible debugger, enabling you to debug your Robot Framework tests with ease. Set breakpoints, step through code, inspect variables, and more, all from within your favorite editor.
+- Every IDE that supports the DAP can be used with RobotCode to debug Robot Framework tests.
+
+### Robot Framwork Repl and Notebooks
+
+- **Interactive REPL Environment:** Experiment with Robot Framework commands in an interactive Read-Eval-Print Loop (REPL) environment, perfect for testing out new ideas or troubleshooting issues on the fly.
+- **Jupyter Notebook-Like Experience:** Enjoy the flexibility of a Jupyter Notebook-like environment for working with Robot Framework code, allowing you to explore, test, and iterate quickly and efficiently.
+(direct integration with Jupyter Notebooks is planned for a future release.)
+
+### Command Line Tools
+
+- **Enhanced Robot Framework CLI:** RobotCode extends the Robot Framework CLI with enhanced tools for test execution, code analysis, and debugging.
+
+### Configure your Robot Framework environment with `robot.toml`
+
+- **Flexible Configuration Options:** RobotCode supports the use of [`robot.toml`](https://robotcode.io/03_reference/) configuration files, allowing you to customize your Robot Framework environment with ease. Define settings for test execution in the development, production, or testing environments, and switch between configurations effortlessly.
+- **Consistent Environment Management:** By using `robot.toml`, you can ensure that your Robot Framework settings are consistent across different projects and environments, reducing the risk of errors and simplifying the development process.
+- **Version Control Integration:** Store your `robot.toml` files in version control systems like Git, enabling you to share configurations with your team and maintain a history of changes over time.
+- **CI/CD Pipeline Integration**: Use `robot.toml` to define your test execution settings in CI/CD pipelines, ensuring that your tests run consistently across different environments and platforms.
+
+
 ---
 
 **RobotCode** isn’t just a tool—it’s your coding partner. With its powerful features and seamless integration, RobotCode helps you be more productive and enjoy your coding experience. Whether you’re a seasoned Robot Framework user or just getting started, RobotCode is here to help you build, test, and deploy with confidence. Let's create something amazing together!