@protolabsai/proto 0.14.0

package/dist/bundled/qc-helper/docs/ide-integration/ide-companion-spec.md

@@ -0,0 +1,182 @@
+# Qwen Code Companion Plugin: Interface Specification
+
+> Last Updated: September 15, 2025
+
+This document defines the contract for building a companion plugin to enable Qwen Code's IDE mode. For VS Code, these features (native diffing, context awareness) are provided by the official extension ([marketplace](https://marketplace.visualstudio.com/items?itemName=qwenlm.qwen-code-vscode-ide-companion)). This specification is for contributors who wish to bring similar functionality to other editors like JetBrains IDEs, Sublime Text, etc.
+
+## I. The Communication Interface
+
+Qwen Code and the IDE plugin communicate through a local communication channel.
+
+### 1. Transport Layer: MCP over HTTP
+
+The plugin **MUST** run a local HTTP server that implements the **Model Context Protocol (MCP)**.
+
+- **Protocol:** The server must be a valid MCP server. We recommend using an existing MCP SDK for your language of choice if available.
+- **Endpoint:** The server should expose a single endpoint (e.g., `/mcp`) for all MCP communication.
+- **Port:** The server **MUST** listen on a dynamically assigned port (i.e., listen on port `0`).
+
+### 2. Discovery Mechanism: The Lock File
+
+For Qwen Code to connect, it needs to discover what port your server is using. The plugin **MUST** facilitate this by creating a "lock file" and setting the port environment variable.
+
+- **How the CLI Finds the File:** The CLI reads the port from `QWEN_CODE_IDE_SERVER_PORT`, then reads `~/.qwen/ide/<PORT>.lock`. (Legacy fallbacks exist for older extensions; see note below.)
+- **File Location:** The file must be created in a specific directory: `~/.qwen/ide/`. Your plugin must create this directory if it doesn't exist.
+- **File Naming Convention:** The filename is critical and **MUST** follow the pattern:
+  `<PORT>.lock`
+  - `<PORT>`: The port your MCP server is listening on.
+- **File Content & Workspace Validation:** The file **MUST** contain a JSON object with the following structure:
+
+  ```json
+  {
+    "port": 12345,
+    "workspacePath": "/path/to/project1:/path/to/project2",
+    "authToken": "a-very-secret-token",
+    "ppid": 1234,
+    "ideName": "VS Code"
+  }
+  ```
+  - `port` (number, required): The port of the MCP server.
+  - `workspacePath` (string, required): A list of all open workspace root paths, delimited by the OS-specific path separator (`:` for Linux/macOS, `;` for Windows). The CLI uses this path to ensure it's running in the same project folder that's open in the IDE. If the CLI's current working directory is not a sub-directory of `workspacePath`, the connection will be rejected. Your plugin **MUST** provide the correct, absolute path(s) to the root of the open workspace(s).
+  - `authToken` (string, required): A secret token for securing the connection. The CLI will include this token in an `Authorization: Bearer <token>` header on all requests.
+  - `ppid` (number, required): The parent process ID of the IDE process.
+  - `ideName` (string, required): A user-friendly name for the IDE (e.g., `VS Code`, `JetBrains IDE`).
+
+- **Authentication:** To secure the connection, the plugin **MUST** generate a unique, secret token and include it in the discovery file. The CLI will then include this token in the `Authorization` header for all requests to the MCP server (e.g., `Authorization: Bearer a-very-secret-token`). Your server **MUST** validate this token on every request and reject any that are unauthorized.
+- **Environment Variables (Required):** Your plugin **MUST** set `QWEN_CODE_IDE_SERVER_PORT` in the integrated terminal so the CLI can locate the correct `<PORT>.lock` file.
+
+**Legacy note:** For extensions older than v0.5.1, Qwen Code may fall back to reading JSON files in the system temp directory named `qwen-code-ide-server-<PID>.json` or `qwen-code-ide-server-<PORT>.json`. New integrations should not rely on these legacy files.
+
+## II. The Context Interface
+
+To enable context awareness, the plugin **MAY** provide the CLI with real-time information about the user's activity in the IDE.
+
+### `ide/contextUpdate` Notification
+
+The plugin **MAY** send an `ide/contextUpdate` [notification](https://modelcontextprotocol.io/specification/2025-06-18/basic/index#notifications) to the CLI whenever the user's context changes.
+
+- **Triggering Events:** This notification should be sent (with a recommended debounce of 50ms) when:
+  - A file is opened, closed, or focused.
+  - The user's cursor position or text selection changes in the active file.
+- **Payload (`IdeContext`):** The notification parameters **MUST** be an `IdeContext` object:
+
+  ```typescript
+  interface IdeContext {
+    workspaceState?: {
+      openFiles?: File[];
+      isTrusted?: boolean;
+    };
+  }
+
+  interface File {
+    // Absolute path to the file
+    path: string;
+    // Last focused Unix timestamp (for ordering)
+    timestamp: number;
+    // True if this is the currently focused file
+    isActive?: boolean;
+    cursor?: {
+      // 1-based line number
+      line: number;
+      // 1-based character number
+      character: number;
+    };
+    // The text currently selected by the user
+    selectedText?: string;
+  }
+  ```
+
+  **Note:** The `openFiles` list should only include files that exist on disk. Virtual files (e.g., unsaved files without a path, editor settings pages) **MUST** be excluded.
+
+### How the CLI Uses This Context
+
+After receiving the `IdeContext` object, the CLI performs several normalization and truncation steps before sending the information to the model.
+
+- **File Ordering:** The CLI uses the `timestamp` field to determine the most recently used files. It sorts the `openFiles` list based on this value. Therefore, your plugin **MUST** provide an accurate Unix timestamp for when a file was last focused.
+- **Active File:** The CLI considers only the most recent file (after sorting) to be the "active" file. It will ignore the `isActive` flag on all other files and clear their `cursor` and `selectedText` fields. Your plugin should focus on setting `isActive: true` and providing cursor/selection details only for the currently focused file.
+- **Truncation:** To manage token limits, the CLI truncates both the file list (to 10 files) and the `selectedText` (to 16KB).
+
+While the CLI handles the final truncation, it is highly recommended that your plugin also limits the amount of context it sends.
+
+## III. The Diffing Interface
+
+To enable interactive code modifications, the plugin **MAY** expose a diffing interface. This allows the CLI to request that the IDE open a diff view, showing proposed changes to a file. The user can then review, edit, and ultimately accept or reject these changes directly within the IDE.
+
+### `openDiff` Tool
+
+The plugin **MUST** register an `openDiff` tool on its MCP server.
+
+- **Description:** This tool instructs the IDE to open a modifiable diff view for a specific file.
+- **Request (`OpenDiffRequest`):** The tool is invoked via a `tools/call` request. The `arguments` field within the request's `params` **MUST** be an `OpenDiffRequest` object.
+
+  ```typescript
+  interface OpenDiffRequest {
+    // The absolute path to the file to be diffed.
+    filePath: string;
+    // The proposed new content for the file.
+    newContent: string;
+  }
+  ```
+
+- **Response (`CallToolResult`):** The tool **MUST** immediately return a `CallToolResult` to acknowledge the request and report whether the diff view was successfully opened.
+  - On Success: If the diff view was opened successfully, the response **MUST** contain empty content (i.e., `content: []`).
+  - On Failure: If an error prevented the diff view from opening, the response **MUST** have `isError: true` and include a `TextContent` block in the `content` array describing the error.
+
+  The actual outcome of the diff (acceptance or rejection) is communicated asynchronously via notifications.
+
+### `closeDiff` Tool
+
+The plugin **MUST** register a `closeDiff` tool on its MCP server.
+
+- **Description:** This tool instructs the IDE to close an open diff view for a specific file.
+- **Request (`CloseDiffRequest`):** The tool is invoked via a `tools/call` request. The `arguments` field within the request's `params` **MUST** be an `CloseDiffRequest` object.
+
+  ```typescript
+  interface CloseDiffRequest {
+    // The absolute path to the file whose diff view should be closed.
+    filePath: string;
+  }
+  ```
+
+- **Response (`CallToolResult`):** The tool **MUST** return a `CallToolResult`.
+  - On Success: If the diff view was closed successfully, the response **MUST** include a single **TextContent** block in the content array containing the file's final content before closing.
+  - On Failure: If an error prevented the diff view from closing, the response **MUST** have `isError: true` and include a `TextContent` block in the `content` array describing the error.
+
+### `ide/diffAccepted` Notification
+
+When the user accepts the changes in a diff view (e.g., by clicking an "Apply" or "Save" button), the plugin **MUST** send an `ide/diffAccepted` notification to the CLI.
+
+- **Payload:** The notification parameters **MUST** include the file path and the final content of the file. The content may differ from the original `newContent` if the user made manual edits in the diff view.
+
+  ```typescript
+  {
+    // The absolute path to the file that was diffed.
+    filePath: string;
+    // The full content of the file after acceptance.
+    content: string;
+  }
+  ```
+
+### `ide/diffRejected` Notification
+
+When the user rejects the changes (e.g., by closing the diff view without accepting), the plugin **MUST** send an `ide/diffRejected` notification to the CLI.
+
+- **Payload:** The notification parameters **MUST** include the file path of the rejected diff.
+
+  ```typescript
+  {
+    // The absolute path to the file that was diffed.
+    filePath: string;
+  }
+  ```
+
+## IV. The Lifecycle Interface
+
+The plugin **MUST** manage its resources and the discovery file correctly based on the IDE's lifecycle.
+
+- **On Activation (IDE startup/plugin enabled):**
+  1.  Start the MCP server.
+  2.  Create the discovery file.
+- **On Deactivation (IDE shutdown/plugin disabled):**
+  1.  Stop the MCP server.
+  2.  Delete the discovery file.

package/dist/bundled/qc-helper/docs/ide-integration/ide-integration.md

@@ -0,0 +1,144 @@
+# IDE Integration
+
+Qwen Code can integrate with your IDE to provide a more seamless and context-aware experience. This integration allows the CLI to understand your workspace better and enables powerful features like native in-editor diffing.
+
+Currently, the only supported IDE is [Visual Studio Code](https://code.visualstudio.com/) and other editors that support VS Code extensions. To build support for other editors, see the [IDE Companion Extension Spec](../ide-integration/ide-companion-spec).
+
+## Features
+
+- **Workspace Context:** The CLI automatically gains awareness of your workspace to provide more relevant and accurate responses. This context includes:
+  - The **10 most recently accessed files** in your workspace.
+  - Your active cursor position.
+  - Any text you have selected (up to a 16KB limit; longer selections will be truncated).
+
+- **Native Diffing:** When Qwen suggests code modifications, you can view the changes directly within your IDE's native diff viewer. This allows you to review, edit, and accept or reject the suggested changes seamlessly.
+
+- **VS Code Commands:** You can access Qwen Code features directly from the VS Code Command Palette (`Cmd+Shift+P` or `Ctrl+Shift+P`):
+  - `Qwen Code: Run`: Starts a new Qwen Code session in the integrated terminal.
+  - `Qwen Code: Accept Diff`: Accepts the changes in the active diff editor.
+  - `Qwen Code: Close Diff Editor`: Rejects the changes and closes the active diff editor.
+  - `Qwen Code: View Third-Party Notices`: Displays the third-party notices for the extension.
+
+## Installation and Setup
+
+There are three ways to set up the IDE integration:
+
+### 1. Automatic Nudge (Recommended)
+
+When you run Qwen Code inside a supported editor, it will automatically detect your environment and prompt you to connect. Answering "Yes" will automatically run the necessary setup, which includes installing the companion extension and enabling the connection.
+
+### 2. Manual Installation from CLI
+
+If you previously dismissed the prompt or want to install the extension manually, you can run the following command inside Qwen Code:
+
+```
+/ide install
+```
+
+This will find the correct extension for your IDE and install it.
+
+### 3. Manual Installation from a Marketplace
+
+You can also install the extension directly from a marketplace.
+
+- **For Visual Studio Code:** Install from the [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=qwenlm.qwen-code-vscode-ide-companion).
+- **For VS Code Forks:** To support forks of VS Code, the extension is also published on the [Open VSX Registry](https://open-vsx.org/extension/qwenlm/qwen-code-vscode-ide-companion). Follow your editor's instructions for installing extensions from this registry.
+
+> NOTE:
+> The "Qwen Code Companion" extension may appear towards the bottom of search results. If you don't see it immediately, try scrolling down or sorting by "Newly Published".
+>
+> After manually installing the extension, you must run `/ide enable` in the CLI to activate the integration.
+
+## Usage
+
+### Enabling and Disabling
+
+You can control the IDE integration from within the CLI:
+
+- To enable the connection to the IDE, run:
+  ```
+  /ide enable
+  ```
+- To disable the connection, run:
+  ```
+  /ide disable
+  ```
+
+When enabled, Qwen Code will automatically attempt to connect to the IDE companion extension.
+
+### Checking the Status
+
+To check the connection status and see the context the CLI has received from the IDE, run:
+
+```
+/ide status
+```
+
+If connected, this command will show the IDE it's connected to and a list of recently opened files it is aware of.
+
+(Note: The file list is limited to 10 recently accessed files within your workspace and only includes local files on disk.)
+
+### Working with Diffs
+
+When you ask Qwen model to modify a file, it can open a diff view directly in your editor.
+
+**To accept a diff**, you can perform any of the following actions:
+
+- Click the **checkmark icon** in the diff editor's title bar.
+- Save the file (e.g., with `Cmd+S` or `Ctrl+S`).
+- Open the Command Palette and run **Qwen Code: Accept Diff**.
+- Respond with `yes` in the CLI when prompted.
+
+**To reject a diff**, you can:
+
+- Click the **'x' icon** in the diff editor's title bar.
+- Close the diff editor tab.
+- Open the Command Palette and run **Qwen Code: Close Diff Editor**.
+- Respond with `no` in the CLI when prompted.
+
+You can also **modify the suggested changes** directly in the diff view before accepting them.
+
+If you select ‘Yes, allow always’ in the CLI, changes will no longer show up in the IDE as they will be auto-accepted.
+
+## Using with Sandboxing
+
+If you are using Qwen Code within a sandbox, please be aware of the following:
+
+- **On macOS:** The IDE integration requires network access to communicate with the IDE companion extension. You must use a Seatbelt profile that allows network access.
+- **In a Docker Container:** If you run Qwen Code inside a Docker (or Podman) container, the IDE integration can still connect to the VS Code extension running on your host machine. The CLI is configured to automatically find the IDE server on `host.docker.internal`. No special configuration is usually required, but you may need to ensure your Docker networking setup allows connections from the container to the host.
+
+## Troubleshooting
+
+If you encounter issues with IDE integration, here are some common error messages and how to resolve them.
+
+### Connection Errors
+
+- **Message:** `🔴 Disconnected: Failed to connect to IDE companion extension for [IDE Name]. Please ensure the extension is running and try restarting your terminal. To install the extension, run /ide install.`
+  - **Cause:** Qwen Code could not find the necessary environment variables (`QWEN_CODE_IDE_WORKSPACE_PATH` or `QWEN_CODE_IDE_SERVER_PORT`) to connect to the IDE. This usually means the IDE companion extension is not running or did not initialize correctly.
+  - **Solution:**
+    1.  Make sure you have installed the **Qwen Code Companion** extension in your IDE and that it is enabled.
+    2.  Open a new terminal window in your IDE to ensure it picks up the correct environment.
+
+- **Message:** `🔴 Disconnected: IDE connection error. The connection was lost unexpectedly. Please try reconnecting by running /ide enable`
+  - **Cause:** The connection to the IDE companion was lost.
+  - **Solution:** Run `/ide enable` to try and reconnect. If the issue continues, open a new terminal window or restart your IDE.
+
+### Configuration Errors
+
+- **Message:** `🔴 Disconnected: Directory mismatch. Qwen Code is running in a different location than the open workspace in [IDE Name]. Please run the CLI from the same directory as your project's root folder.`
+  - **Cause:** The CLI's current working directory is outside the folder or workspace you have open in your IDE.
+  - **Solution:** `cd` into the same directory that is open in your IDE and restart the CLI.
+
+- **Message:** `🔴 Disconnected: To use this feature, please open a workspace folder in [IDE Name] and try again.`
+  - **Cause:** You have no workspace open in your IDE.
+  - **Solution:** Open a workspace in your IDE and restart the CLI.
+
+### General Errors
+
+- **Message:** `IDE integration is not supported in your current environment. To use this feature, run Qwen Code in one of these supported IDEs: [List of IDEs]`
+  - **Cause:** You are running Qwen Code in a terminal or environment that is not a supported IDE.
+  - **Solution:** Run Qwen Code from the integrated terminal of a supported IDE, like VS Code.
+
+- **Message:** `No installer is available for IDE. Please install the Qwen Code Companion extension manually from the marketplace.`
+  - **Cause:** You ran `/ide install`, but the CLI does not have an automated installer for your specific IDE.
+  - **Solution:** Open your IDE's extension marketplace, search for "Qwen Code Companion", and install it manually.

package/dist/bundled/qc-helper/docs/integration-github-action.md

@@ -0,0 +1,241 @@
+# Github Actions：qwen-code-action
+
+## Overview
+
+`qwen-code-action` is a GitHub Action that integrates [Qwen Code] into your development workflow via the [Qwen Code CLI]. It acts both as an autonomous agent for critical routine coding tasks, and an on-demand collaborator you can quickly delegate work to.
+
+Use it to perform GitHub pull request reviews, triage issues, perform code analysis and modification, and more using [Qwen Code] conversationally (e.g., `@qwencoder fix this issue`) directly inside your GitHub repositories.
+
+## Features
+
+- **Automation**: Trigger workflows based on events (e.g. issue opening) or schedules (e.g. nightly).
+- **On-demand Collaboration**: Trigger workflows in issue and pull request
+  comments by mentioning the [Qwen Code CLI](./features/commands) (e.g., `@qwencoder /review`).
+- **Extensible with Tools**: Leverage [Qwen Code](../developers/tools/introduction.md) models' tool-calling capabilities to interact with other CLIs like the [GitHub CLI] (`gh`).
+- **Customizable**: Use a `QWEN.md` file in your repository to provide
+  project-specific instructions and context to [Qwen Code CLI](./features/commands).
+
+## Quick Start
+
+Get started with Qwen Code CLI in your repository in just a few minutes:
+
+### 1. Get a Qwen API Key
+
+Obtain your API key from [DashScope](https://help.aliyun.com/zh/model-studio/qwen-code) (Alibaba Cloud's AI platform)
+
+### 2. Add it as a GitHub Secret
+
+Store your API key as a secret named `QWEN_API_KEY` in your repository:
+
+- Go to your repository's **Settings > Secrets and variables > Actions**
+- Click **New repository secret**
+- Name: `QWEN_API_KEY`, Value: your API key
+
+### 3. Update your .gitignore
+
+Add the following entries to your `.gitignore` file:
+
+```gitignore
+# qwen-code-cli settings
+.qwen/
+
+# GitHub App credentials
+gha-creds-*.json
+```
+
+### 4. Choose a Workflow
+
+You have two options to set up a workflow:
+
+**Option A: Use setup command (Recommended)**
+
+1. Start the Qwen Code CLI in your terminal:
+
+   ```shell
+   qwen
+   ```
+
+2. In Qwen Code CLI in your terminal, type:
+
+   ```
+   /setup-github
+   ```
+
+**Option B: Manually copy workflows**
+
+1. Copy the pre-built workflows from the [`examples/workflows`](./common-workflow) directory to your repository's `.github/workflows` directory. Note: the `qwen-dispatch.yml` workflow must also be copied, which triggers the workflows to run.
+
+### 5. Try it out
+
+**Pull Request Review:**
+
+- Open a pull request in your repository and wait for automatic review
+- Comment `@qwencoder /review` on an existing pull request to manually trigger a review
+
+**Issue Triage:**
+
+- Open an issue and wait for automatic triage
+- Comment `@qwencoder /triage` on existing issues to manually trigger triaging
+
+**General AI Assistance:**
+
+- In any issue or pull request, mention `@qwencoder` followed by your request
+- Examples:
+  - `@qwencoder explain this code change`
+  - `@qwencoder suggest improvements for this function`
+  - `@qwencoder help me debug this error`
+  - `@qwencoder write unit tests for this component`
+
+## Workflows
+
+This action provides several pre-built workflows for different use cases. Each workflow is designed to be copied into your repository's `.github/workflows` directory and customized as needed.
+
+### Qwen Code Dispatch
+
+This workflow acts as a central dispatcher for Qwen Code CLI, routing requests to the appropriate workflow based on the triggering event and the command provided in the comment. For a detailed guide on how to set up the dispatch workflow, go to the [Qwen Code Dispatch workflow documentation](./common-workflow).
+
+### Issue Triage
+
+This action can be used to triage GitHub Issues automatically or on a schedule. For a detailed guide on how to set up the issue triage system, go to the [GitHub Issue Triage workflow documentation](./examples/workflows/issue-triage).
+
+### Pull Request Review
+
+This action can be used to automatically review pull requests when they are opened. For a detailed guide on how to set up the pull request review system, go to the [GitHub PR Review workflow documentation](./common-workflow).
+
+### Qwen Code CLI Assistant
+
+This type of action can be used to invoke a general-purpose, conversational Qwen Code AI assistant within the pull requests and issues to perform a wide range of tasks. For a detailed guide on how to set up the general-purpose Qwen Code CLI workflow, go to the [Qwen Code Assistant workflow documentation](./common-workflow).
+
+## Configuration
+
+### Inputs
+
+<!-- BEGIN_AUTOGEN_INPUTS -->
+
+- <a name="__input_qwen_api_key"></a><a href="#user-content-__input_qwen_api_key"><code>qwen*api_key</code></a>: *(Optional)\_ The API key for the Qwen API.
+
+- <a name="__input_qwen_cli_version"></a><a href="#user-content-__input_qwen_cli_version"><code>qwen*cli_version</code></a>: *(Optional, default: `latest`)\_ The version of the Qwen Code CLI to install. Can be "latest", "preview", "nightly", a specific version number, or a git branch, tag, or commit. For more information, see [Qwen Code CLI releases](https://github.com/QwenLM/qwen-code-action/blob/main/docs/releases.md).
+
+- <a name="__input_qwen_debug"></a><a href="#user-content-__input_qwen_debug"><code>qwen*debug</code></a>: *(Optional)\_ Enable debug logging and output streaming.
+
+- <a name="__input_qwen_model"></a><a href="#user-content-__input_qwen_model"><code>qwen*model</code></a>: *(Optional)\_ The model to use with Qwen Code.
+
+- <a name="__input_prompt"></a><a href="#user-content-__input_prompt"><code>prompt</code></a>: _(Optional, default: `You are a helpful assistant.`)_ A string passed to the Qwen Code CLI's [`--prompt` argument](https://github.com/QwenLM/qwen-code-action/blob/main/docs/cli/configuration.md#command-line-arguments).
+
+- <a name="__input_settings"></a><a href="#user-content-__input_settings"><code>settings</code></a>: _(Optional)_ A JSON string written to `.qwen/settings.json` to configure the CLI's _project_ settings.
+  For more details, see the documentation on [settings files](https://github.com/QwenLM/qwen-code-action/blob/main/docs/cli/configuration.md#settings-files).
+
+- <a name="__input_use_qwen_code_assist"></a><a href="#user-content-__input_use_qwen_code_assist"><code>use*qwen_code_assist</code></a>: *(Optional, default: `false`)\_ Whether to use Code Assist for Qwen Code model access instead of the default Qwen Code API key.
+  For more information, see the [Qwen Code CLI documentation](https://github.com/QwenLM/qwen-code-action/blob/main/docs/cli/authentication.md).
+
+- <a name="__input_use_vertex_ai"></a><a href="#user-content-__input_use_vertex_ai"><code>use*vertex_ai</code></a>: *(Optional, default: `false`)\_ Whether to use Vertex AI for Qwen Code model access instead of the default Qwen Code API key.
+  For more information, see the [Qwen Code CLI documentation](https://github.com/QwenLM/qwen-code-action/blob/main/docs/cli/authentication.md).
+
+- <a name="__input_extensions"></a><a href="#user-content-__input_extensions"><code>extensions</code></a>: _(Optional)_ A list of Qwen Code CLI extensions to install.
+
+- <a name="__input_upload_artifacts"></a><a href="#user-content-__input_upload_artifacts"><code>upload*artifacts</code></a>: *(Optional, default: `false`)\_ Whether to upload artifacts to the github action.
+
+- <a name="__input_use_pnpm"></a><a href="#user-content-__input_use_pnpm"><code>use*pnpm</code></a>: *(Optional, default: `false`)\_ Whether or not to use pnpm instead of npm to install qwen-code-cli
+
+- <a name="__input_workflow_name"></a><a href="#user-content-__input_workflow_name"><code>workflow*name</code></a>: *(Optional, default: `${{ github.workflow }}`)\_ The GitHub workflow name, used for telemetry purposes.
+
+<!-- END_AUTOGEN_INPUTS -->
+
+### Outputs
+
+<!-- BEGIN_AUTOGEN_OUTPUTS -->
+
+- <a name="__output_summary"></a><a href="#user-content-__output_summary"><code>summary</code></a>: The summarized output from the Qwen Code CLI execution.
+
+- <a name="__output_error"></a><a href="#user-content-__output_error"><code>error</code></a>: The error output from the Qwen Code CLI execution, if any.
+
+<!-- END_AUTOGEN_OUTPUTS -->
+
+### Repository Variables
+
+We recommend setting the following values as repository variables so they can be reused across all workflows. Alternatively, you can set them inline as action inputs in individual workflows or to override repository-level values.
+
+| Name               | Description                                               | Type     | Required | When Required             |
+| ------------------ | --------------------------------------------------------- | -------- | -------- | ------------------------- |
+| `DEBUG`            | Enables debug logging for the Qwen Code CLI.              | Variable | No       | Never                     |
+| `QWEN_CLI_VERSION` | Controls which version of the Qwen Code CLI is installed. | Variable | No       | Pinning the CLI version   |
+| `APP_ID`           | GitHub App ID for custom authentication.                  | Variable | No       | Using a custom GitHub App |
+
+To add a repository variable:
+
+1. Go to your repository's **Settings > Secrets and variables > Actions > New variable**.
+2. Enter the variable name and value.
+3. Save.
+
+For details about repository variables, refer to the [GitHub documentation on variables][variables].
+
+### Secrets
+
+You can set the following secrets in your repository:
+
+| Name              | Description                                   | Required | When Required                              |
+| ----------------- | --------------------------------------------- | -------- | ------------------------------------------ |
+| `QWEN_API_KEY`    | Your Qwen API key from DashScope.             | Yes      | Required for all workflows that call Qwen. |
+| `APP_PRIVATE_KEY` | Private key for your GitHub App (PEM format). | No       | Using a custom GitHub App.                 |
+
+To add a secret:
+
+1. Go to your repository's **Settings > Secrets and variables >Actions > New repository secret**.
+2. Enter the secret name and value.
+3. Save.
+
+For more information, refer to the [official GitHub documentation on creating and using encrypted secrets][secrets].
+
+## Authentication
+
+This action requires authentication to the GitHub API and optionally to Qwen Code services.
+
+### GitHub Authentication
+
+You can authenticate with GitHub in two ways:
+
+1. **Default `GITHUB_TOKEN`:** For simpler use cases, the action can use the
+   default `GITHUB_TOKEN` provided by the workflow.
+2. **Custom GitHub App (Recommended):** For the most secure and flexible
+   authentication, we recommend creating a custom GitHub App.
+
+For detailed setup instructions for both Qwen and GitHub authentication, go to the
+[**Authentication documentation**](./configuration/auth).
+
+## Extensions
+
+The Qwen Code CLI can be extended with additional functionality through extensions.
+These extensions are installed from source from their GitHub repositories.
+
+For detailed instructions on how to set up and configure extensions, go to the
+[Extensions documentation](../developers/extensions/extension).
+
+## Best Practices
+
+To ensure the security, reliability, and efficiency of your automated workflows, we strongly recommend following our best practices. These guidelines cover key areas such as repository security, workflow configuration, and monitoring.
+
+Key recommendations include:
+
+- **Securing Your Repository:** Implementing branch and tag protection, and restricting pull request approvers.
+- **Monitoring and Auditing:** Regularly reviewing action logs and enabling OpenTelemetry for deeper insights into performance and behavior.
+
+For a comprehensive guide on securing your repository and workflows, please refer to our [**Best Practices documentation**](./common-workflow).
+
+## Customization
+
+Create a QWEN.md file in the root of your repository to provide
+project-specific context and instructions to [Qwen Code CLI](./common-workflow). This is useful for defining
+coding conventions, architectural patterns, or other guidelines the model should
+follow for a given repository.
+
+## Contributing
+
+Contributions are welcome! Check out the Qwen Code CLI **Contributing Guide** for more details on how to get started.
+
+[secrets]: https://docs.github.com/en/actions/security-guides/using-secrets-in-github-actions
+[Qwen Code]: https://github.com/QwenLM/qwen-code
+[DashScope]: https://dashscope.console.aliyun.com/apiKey
+[Qwen Code CLI]: https://github.com/QwenLM/qwen-code-action/
+[variables]: https://docs.github.com/en/actions/how-tos/write-workflows/choose-what-workflows-do/use-variables#creating-configuration-variables-for-a-repository
+[GitHub CLI]: https://docs.github.com/en/github-cli/github-cli
+[QWEN.md]: https://github.com/QwenLM/qwen-code-action/blob/main/docs/cli/configuration.md#context-files-hierarchical-instructional-context

package/dist/bundled/qc-helper/docs/integration-jetbrains.md

@@ -0,0 +1,81 @@
+# JetBrains IDEs
+
+> JetBrains IDEs provide native support for AI coding assistants through the Agent Client Protocol (ACP). This integration allows you to use Qwen Code directly within your JetBrains IDE with real-time code suggestions.
+
+### Features
+
+- **Native agent experience**: Integrated AI assistant panel within your JetBrains IDE
+- **Agent Client Protocol**: Full support for ACP enabling advanced IDE interactions
+- **Symbol management**: #-mention files to add them to the conversation context
+- **Conversation history**: Access to past conversations within the IDE
+
+### Requirements
+
+- JetBrains IDE with ACP support (IntelliJ IDEA, WebStorm, PyCharm, etc.)
+- Qwen Code CLI installed
+
+### Installation
+
+#### Install from ACP Registry (Recommend)
+
+1. Install Qwen Code CLI:
+
+   ```bash
+   npm install -g @qwen-code/qwen-code
+   ```
+
+2. Open your JetBrains IDE and navigate to AI Chat tool window.
+
+3. Click **Add ACP Agent**, then click **Install**.
+
+   ![Install](https://img.alicdn.com/imgextra/i4/O1CN01qNdPCW1y8AcqxRgCy_!!6000000006533-2-tps-2490-1788.png)
+
+   For users using JetBrains AI Assistant and/or other ACP agents, click **Install From ACP Registry** in Agents List, then install Qwen Code ACP.
+
+   ![Add from Agents List](https://img.alicdn.com/imgextra/i2/O1CN01ZyOugP26BOKzNgZXx_!!6000000007623-2-tps-479-523.png)
+
+4. The Qwen Code agent should now be available in the AI Assistant panel.
+
+   ![Qwen Code in JetBrains AI Chat](https://img.alicdn.com/imgextra/i4/O1CN013kAVE41XVzbIZOxyv_!!6000000002930-2-tps-3188-2170.png)
+
+#### Manual Install (for older version of JetBrains IDEs)
+
+1. Install Qwen Code CLI:
+
+   ```bash
+   npm install -g @qwen-code/qwen-code
+   ```
+
+2. Open your JetBrains IDE and navigate to AI Chat tool window.
+
+3. Click the 3-dot menu in the upper-right corner and select **Configure ACP Agent** and configure Qwen Code with the following settings:
+
+```json
+{
+  "agent_servers": {
+    "qwen": {
+      "command": "/path/to/qwen",
+      "args": ["--acp"],
+      "env": {}
+    }
+  }
+}
+```
+
+4. The Qwen Code agent should now be available in the AI Assistant panel
+
+![Qwen Code in JetBrains AI Chat](https://img.alicdn.com/imgextra/i3/O1CN01ZxYel21y433Ci6eg0_!!6000000006524-2-tps-2774-1494.png)
+
+## Troubleshooting
+
+### Agent not appearing
+
+- Run `qwen --version` in terminal to verify installation
+- Ensure your JetBrains IDE version supports ACP
+- Restart your JetBrains IDE
+
+### Qwen Code not responding
+
+- Check your internet connection
+- Verify CLI works by running `qwen` in terminal
+- [File an issue on GitHub](https://github.com/qwenlm/qwen-code/issues) if the problem persists