@protolabsai/proto 0.14.0

package/dist/bundled/qc-helper/docs/features/language.md

@@ -0,0 +1,139 @@
+# Internationalization (i18n) & Language
+
+Qwen Code is built for multilingual workflows: it supports UI localization (i18n/l10n) in the CLI, lets you choose the assistant output language, and allows custom UI language packs.
+
+## Overview
+
+From a user point of view, Qwen Code’s “internationalization” spans multiple layers:
+
+| Capability / Setting     | What it controls                                                       | Where stored                 |
+| ------------------------ | ---------------------------------------------------------------------- | ---------------------------- |
+| `/language ui`           | Terminal UI text (menus, system messages, prompts)                     | `~/.qwen/settings.json`      |
+| `/language output`       | Language the AI responds in (an output preference, not UI translation) | `~/.qwen/output-language.md` |
+| Custom UI language packs | Overrides/extends built-in UI translations                             | `~/.qwen/locales/*.js`       |
+
+## UI Language
+
+This is the CLI’s UI localization layer (i18n/l10n): it controls the language of menus, prompts, and system messages.
+
+### Setting the UI Language
+
+Use the `/language ui` command:
+
+```bash
+/language ui zh-CN    # Chinese
+/language ui en-US    # English
+/language ui ru-RU    # Russian
+/language ui de-DE    # German
+/language ui ja-JP    # Japanese
+```
+
+Aliases are also supported:
+
+```bash
+/language ui zh       # Chinese
+/language ui en       # English
+/language ui ru       # Russian
+/language ui de       # German
+/language ui ja       # Japanese
+```
+
+### Auto-detection
+
+On first startup, Qwen Code detects your system locale and sets the UI language automatically.
+
+Detection priority:
+
+1. `QWEN_CODE_LANG` environment variable
+2. `LANG` environment variable
+3. System locale via JavaScript Intl API
+4. Default: English
+
+## LLM Output Language
+
+The LLM output language controls what language the AI assistant responds in, regardless of what language you type your questions in.
+
+### How It Works
+
+The LLM output language is controlled by a rule file at `~/.qwen/output-language.md`. This file is automatically included in the LLM's context during startup, instructing it to respond in the specified language.
+
+### Auto-detection
+
+On first startup, if no `output-language.md` file exists, Qwen Code automatically creates one based on your system locale. For example:
+
+- System locale `zh` creates a rule for Chinese responses
+- System locale `en` creates a rule for English responses
+- System locale `ru` creates a rule for Russian responses
+- System locale `de` creates a rule for German responses
+- System locale `ja` creates a rule for Japanese responses
+
+### Manual Setting
+
+Use `/language output <language>` to change:
+
+```bash
+/language output Chinese
+/language output English
+/language output Japanese
+/language output German
+```
+
+Any language name works. The LLM will be instructed to respond in that language.
+
+> [!note]
+>
+> After changing the output language, restart Qwen Code for the change to take effect.
+
+### File Location
+
+```
+~/.qwen/output-language.md
+```
+
+## Configuration
+
+### Via Settings Dialog
+
+1. Run `/settings`
+2. Find "Language" under General
+3. Select your preferred UI language
+
+### Via Environment Variable
+
+```bash
+export QWEN_CODE_LANG=zh
+```
+
+This influences auto-detection on first startup (if you haven’t set a UI language and no `output-language.md` file exists yet).
+
+## Custom Language Packs
+
+For UI translations, you can create custom language packs in `~/.qwen/locales/`:
+
+- Example: `~/.qwen/locales/es.js` for Spanish
+- Example: `~/.qwen/locales/fr.js` for French
+
+User directory takes precedence over built-in translations.
+
+> [!tip]
+>
+> Contributions are welcome! If you’d like to improve built-in translations or add new languages.
+> For a concrete example, see [PR #1238: feat(i18n): add Russian language support](https://github.com/QwenLM/qwen-code/pull/1238).
+
+### Language Pack Format
+
+```javascript
+// ~/.qwen/locales/es.js
+export default {
+  Hello: 'Hola',
+  Settings: 'Configuracion',
+  // ... more translations
+};
+```
+
+## Related Commands
+
+- `/language` - Show current language settings
+- `/language ui [lang]` - Set UI language
+- `/language output <language>` - Set LLM output language
+- `/settings` - Open settings dialog

package/dist/bundled/qc-helper/docs/features/lsp.md

@@ -0,0 +1,453 @@
+# Language Server Protocol (LSP) Support
+
+Qwen Code provides native Language Server Protocol (LSP) support, enabling advanced code intelligence features like go-to-definition, find references, diagnostics, and code actions. This integration allows the AI agent to understand your code more deeply and provide more accurate assistance.
+
+## Overview
+
+LSP support in Qwen Code works by connecting to language servers that understand your code. Once you configure servers via `.lsp.json` (or extensions), Qwen Code can start them and use them to:
+
+- Navigate to symbol definitions
+- Find all references to a symbol
+- Get hover information (documentation, type info)
+- View diagnostic messages (errors, warnings)
+- Access code actions (quick fixes, refactorings)
+- Analyze call hierarchies
+
+## Quick Start
+
+LSP auto-enables when a `.lsp.json` file exists in your project root. You can also enable it explicitly:
+
+```bash
+proto --lsp
+```
+
+Or in `~/.proto/settings.json`:
+
+```json
+{
+  "general": {
+    "lsp": true
+  }
+}
+```
+
+LSP servers are configuration-driven. Define them in `.lsp.json` (or via extensions) for proto to start them.
+
+### Prerequisites
+
+You need to have the language server for your programming language installed:
+
+| Language              | Language Server            | Install Command                                                                |
+| --------------------- | -------------------------- | ------------------------------------------------------------------------------ |
+| TypeScript/JavaScript | typescript-language-server | `npm install -g typescript-language-server typescript`                         |
+| Python                | pylsp                      | `pip install python-lsp-server`                                                |
+| Go                    | gopls                      | `go install golang.org/x/tools/gopls@latest`                                   |
+| Rust                  | rust-analyzer              | [Installation guide](https://rust-analyzer.github.io/manual.html#installation) |
+| C/C++                 | clangd                     | Install LLVM/clangd via your package manager                                   |
+| Java                  | jdtls                      | Install JDTLS and a JDK                                                        |
+
+## Configuration
+
+### .lsp.json File
+
+You can configure language servers using a `.lsp.json` file in your project root. This uses the language-keyed format described in the [Claude Code plugin LSP configuration reference](https://code.claude.com/docs/en/plugins-reference#lsp-servers).
+
+**Basic format:**
+
+```json
+{
+  "typescript": {
+    "command": "typescript-language-server",
+    "args": ["--stdio"],
+    "extensionToLanguage": {
+      ".ts": "typescript",
+      ".tsx": "typescriptreact",
+      ".js": "javascript",
+      ".jsx": "javascriptreact"
+    }
+  }
+}
+```
+
+### C/C++ (clangd) configuration
+
+Dependencies:
+
+- clangd (LLVM) must be installed and available in PATH.
+- A compile database (`compile_commands.json`) or `compile_flags.txt` is required for accurate results.
+
+Example:
+
+```json
+{
+  "cpp": {
+    "command": "clangd",
+    "args": [
+      "--background-index",
+      "--clang-tidy",
+      "--header-insertion=iwyu",
+      "--completion-style=detailed"
+    ]
+  }
+}
+```
+
+### Java (jdtls) configuration
+
+Dependencies:
+
+- JDK installed and available in PATH (`java`).
+- JDTLS installed and available in PATH (`jdtls`).
+
+Example:
+
+```json
+{
+  "java": {
+    "command": "jdtls",
+    "args": ["-configuration", ".jdtls-config", "-data", ".jdtls-workspace"]
+  }
+}
+```
+
+### Configuration Options
+
+#### Required Fields
+
+| Option    | Type   | Description                                       |
+| --------- | ------ | ------------------------------------------------- |
+| `command` | string | Command to start the LSP server (must be in PATH) |
+
+#### Optional Fields
+
+| Option                  | Type     | Default   | Description                                             |
+| ----------------------- | -------- | --------- | ------------------------------------------------------- |
+| `args`                  | string[] | `[]`      | Command line arguments                                  |
+| `transport`             | string   | `"stdio"` | Transport type: `stdio`, `tcp`, or `socket`             |
+| `env`                   | object   | -         | Environment variables                                   |
+| `initializationOptions` | object   | -         | LSP initialization options                              |
+| `settings`              | object   | -         | Server settings via `workspace/didChangeConfiguration`  |
+| `extensionToLanguage`   | object   | -         | Maps file extensions to language identifiers            |
+| `workspaceFolder`       | string   | -         | Override workspace folder (must be within project root) |
+| `startupTimeout`        | number   | `10000`   | Startup timeout in milliseconds                         |
+| `shutdownTimeout`       | number   | `5000`    | Shutdown timeout in milliseconds                        |
+| `restartOnCrash`        | boolean  | `false`   | Auto-restart on crash                                   |
+| `maxRestarts`           | number   | `3`       | Maximum restart attempts                                |
+| `trustRequired`         | boolean  | `true`    | Require trusted workspace                               |
+
+### TCP/Socket Transport
+
+For servers that use TCP or Unix socket transport:
+
+```json
+{
+  "remote-lsp": {
+    "transport": "tcp",
+    "socket": {
+      "host": "127.0.0.1",
+      "port": 9999
+    },
+    "extensionToLanguage": {
+      ".custom": "custom"
+    }
+  }
+}
+```
+
+## Available LSP Operations
+
+Qwen Code exposes LSP functionality through the unified `lsp` tool. Here are the available operations:
+
+### Code Navigation
+
+#### Go to Definition
+
+Find where a symbol is defined.
+
+```
+Operation: goToDefinition
+Parameters:
+  - filePath: Path to the file
+  - line: Line number (1-based)
+  - character: Column number (1-based)
+```
+
+#### Find References
+
+Find all references to a symbol.
+
+```
+Operation: findReferences
+Parameters:
+  - filePath: Path to the file
+  - line: Line number (1-based)
+  - character: Column number (1-based)
+  - includeDeclaration: Include the declaration itself (optional)
+```
+
+#### Go to Implementation
+
+Find implementations of an interface or abstract method.
+
+```
+Operation: goToImplementation
+Parameters:
+  - filePath: Path to the file
+  - line: Line number (1-based)
+  - character: Column number (1-based)
+```
+
+### Symbol Information
+
+#### Hover
+
+Get documentation and type information for a symbol.
+
+```
+Operation: hover
+Parameters:
+  - filePath: Path to the file
+  - line: Line number (1-based)
+  - character: Column number (1-based)
+```
+
+#### Document Symbols
+
+Get all symbols in a document.
+
+```
+Operation: documentSymbol
+Parameters:
+  - filePath: Path to the file
+```
+
+#### Workspace Symbol Search
+
+Search for symbols across the workspace.
+
+```
+Operation: workspaceSymbol
+Parameters:
+  - query: Search query string
+  - limit: Maximum results (optional)
+```
+
+### Call Hierarchy
+
+#### Prepare Call Hierarchy
+
+Get the call hierarchy item at a position.
+
+```
+Operation: prepareCallHierarchy
+Parameters:
+  - filePath: Path to the file
+  - line: Line number (1-based)
+  - character: Column number (1-based)
+```
+
+#### Incoming Calls
+
+Find all functions that call the given function.
+
+```
+Operation: incomingCalls
+Parameters:
+  - callHierarchyItem: Item from prepareCallHierarchy
+```
+
+#### Outgoing Calls
+
+Find all functions called by the given function.
+
+```
+Operation: outgoingCalls
+Parameters:
+  - callHierarchyItem: Item from prepareCallHierarchy
+```
+
+### Diagnostics
+
+#### File Diagnostics
+
+Get diagnostic messages (errors, warnings) for a file.
+
+```
+Operation: diagnostics
+Parameters:
+  - filePath: Path to the file
+```
+
+#### Workspace Diagnostics
+
+Get all diagnostic messages across the workspace.
+
+```
+Operation: workspaceDiagnostics
+Parameters:
+  - limit: Maximum results (optional)
+```
+
+### Code Actions
+
+#### Get Code Actions
+
+Get available code actions (quick fixes, refactorings) at a location.
+
+```
+Operation: codeActions
+Parameters:
+  - filePath: Path to the file
+  - line: Start line number (1-based)
+  - character: Start column number (1-based)
+  - endLine: End line number (optional, defaults to line)
+  - endCharacter: End column (optional, defaults to character)
+  - diagnostics: Diagnostics to get actions for (optional)
+  - codeActionKinds: Filter by action kind (optional)
+```
+
+Code action kinds:
+
+- `quickfix` - Quick fixes for errors/warnings
+- `refactor` - Refactoring operations
+- `refactor.extract` - Extract to function/variable
+- `refactor.inline` - Inline function/variable
+- `source` - Source code actions
+- `source.organizeImports` - Organize imports
+- `source.fixAll` - Fix all auto-fixable issues
+
+## Security
+
+LSP servers are only started in trusted workspaces by default. This is because language servers run with your user permissions and can execute code.
+
+### Trust Controls
+
+- **Trusted Workspace**: LSP servers start if configured
+- **Untrusted Workspace**: LSP servers won't start unless `trustRequired: false` is set in the server configuration
+
+To mark a workspace as trusted, use the `/trust` command or configure trusted folders in settings.
+
+### Per-Server Trust Override
+
+You can override trust requirements for specific servers in their configuration:
+
+```json
+{
+  "safe-server": {
+    "command": "safe-language-server",
+    "args": ["--stdio"],
+    "trustRequired": false,
+    "extensionToLanguage": {
+      ".safe": "safe"
+    }
+  }
+}
+```
+
+## Troubleshooting
+
+### Server Not Starting
+
+1. **Check if the server is installed**: Run the command manually to verify
+2. **Check the PATH**: Ensure the server binary is in your system PATH
+3. **Check workspace trust**: The workspace must be trusted for LSP
+4. **Check logs**: Look for error messages in the console output
+5. **Verify LSP is enabled**: Check that `.lsp.json` exists or `--lsp` flag is set
+
+### Slow Performance
+
+1. **Large projects**: Consider excluding `node_modules` and other large directories
+2. **Server timeout**: Increase `startupTimeout` in server configuration for slow servers
+
+### No Results
+
+1. **Server not ready**: The server may still be indexing
+2. **File not saved**: Save your file for the server to pick up changes
+3. **Wrong language**: Check if the correct server is running for your language
+
+### Debugging
+
+Enable debug logging to see LSP communication:
+
+```bash
+DEBUG=lsp* proto --lsp
+```
+
+Or check the LSP debugging guide at `packages/cli/LSP_DEBUGGING_GUIDE.md`.
+
+## Claude Code Compatibility
+
+Qwen Code supports Claude Code-style `.lsp.json` configuration files in the language-keyed format defined in the [Claude Code plugins reference](https://code.claude.com/docs/en/plugins-reference#lsp-servers). If you're migrating from Claude Code, use the language-as-key layout in your configuration.
+
+### Configuration Format
+
+The recommended format follows Claude Code's specification:
+
+```json
+{
+  "go": {
+    "command": "gopls",
+    "args": ["serve"],
+    "extensionToLanguage": {
+      ".go": "go"
+    }
+  }
+}
+```
+
+Claude Code LSP plugins can also supply `lspServers` in `plugin.json` (or a referenced `.lsp.json`). Qwen Code loads those configs when the extension is enabled, and they must use the same language-keyed format.
+
+## Best Practices
+
+1. **Install language servers globally**: This ensures they're available in all projects
+2. **Use project-specific settings**: Configure server options per project when needed via `.lsp.json`
+3. **Keep servers updated**: Update your language servers regularly for best results
+4. **Trust wisely**: Only trust workspaces from trusted sources
+
+## FAQ
+
+### Q: How do I enable LSP?
+
+Place a `.lsp.json` in your project root — LSP auto-enables. Or run `proto --lsp`, or set `general.lsp: true` in settings.
+
+### Q: How do I know which language servers are running?
+
+Use the `/lsp status` command to see all configured and running language servers.
+
+### Q: Can I use multiple language servers for the same file type?
+
+Yes, but only one will be used for each operation. The first server that returns results wins.
+
+### Q: Does LSP work in sandbox mode?
+
+LSP servers run outside the sandbox to access your code. They're subject to workspace trust controls.
+
+## SDK usage
+
+Enable LSP when using the [TypeScript SDK](../reference/sdk-api.md) by setting `lsp: true`:
+
+```typescript
+import { query, isLspDiagnosticEvent } from '@qwen-code/sdk';
+
+const conversation = query({
+  prompt: 'Fix all type errors in the auth module',
+  options: {
+    lsp: true,
+    permissionMode: 'auto-edit',
+  },
+});
+
+for await (const message of conversation) {
+  if (isLspDiagnosticEvent(message)) {
+    const { uri, diagnostics } = message.data;
+    console.log(`${diagnostics.length} diagnostics in ${uri}`);
+    for (const d of diagnostics) {
+      console.log(
+        `  [${d.severity}] ${d.message} (line ${d.range.start.line})`,
+      );
+    }
+  }
+}
+```
+
+The SDK passes `--lsp` to the CLI process. Language servers are configured via `.lsp.json` or installed LSP plugins, the same as CLI usage. The `SDKLspDiagnosticEvent` surfaces diagnostics in the message stream so your application can react to type errors, missing imports, and other issues.