remove log

.changeset/breezy-shrimps-begin.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-fix showing the ai core exisiting models when resource group field is empty (using the default resource group)

.changeset/chatty-books-give.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+add all qwen3 models support and add thinking mode options

.changeset/cool-comics-change.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Ollama: Use a filterable dropdown instead of radio selection

.changeset/cuddly-dingos-tap.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Fix issue on Account view where balance is fetched twice that cause janky UI

.changeset/cyan-bottles-battle.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Fixes an issue where thinking text from litellm was not being passed through to Cline thinking UI

.changeset/fluffy-toys-beam.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Fix Ollama connection issue to default endpoint at port 11434

.changeset/funny-ants-travel.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Optimized Cline for GPT-5 model family with an aligned system prompt

.changeset/heavy-dolls-cry.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Add search functionality to API provider dropdown

.changeset/hot-turtles-flash.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Remove disabled approve / reject buttons from UI.

.changeset/rare-oranges-flash.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Add "Use custom prompt" option to Ollama provider

.changeset/silver-trains-learn.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+adding support for streamable mcp server

.changeset/slimy-kids-sip.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Fix AutoApproveModal overflowing issue

.changeset/stale-balloons-scream.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-support orchestration mode for sap provider

.changeset/stale-peas-clap.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Migrate chatButtonClicked to Protobus

.changeset/sweet-fireants-develop.md

@@ -2,4 +2,4 @@
 "claude-dev": patch
 ---
 
-REfactoring Tool Executor
+Adding WalkThrough for Cline

.changeset/swift-ravens-lay.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Improve Gemini Rate Limit handling

.changeset/thick-poets-give.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+new AskSage models - Claude 4 Sonnet, Claude 4 Opus, GPT 4.1, Gemini 2.5 Pro

.changeset/weak-years-sin.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-fix: Support Anthropic Caching when using LiteLLM

.changeset/wicked-suns-cry.md

@@ -2,4 +2,4 @@
 "claude-dev": patch
 ---
 
-Dify.ai api integration
+Telemetry fix

.changeset/yellow-cycles-join.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Prompt changes for deep-planning in windows/powershell

.clinerules/cline-overview.md

@@ -716,7 +716,7 @@ The Controller class manages MCP servers through the McpHub service:
 class Controller {
   mcpHub?: McpHub
 
-  constructor(context: vscode.ExtensionContext, webviewProvider: WebviewProvider) {
+  constructor(context: vscode.ExtensionContext, outputChannel: vscode.OutputChannel, webviewProvider: WebviewProvider) {
     this.mcpHub = new McpHub(this)
   }
 

.clinerules/protobuf-development.md

@@ -1,89 +0,0 @@
-# Cline Protobuf Development Guide
-
-This guide outlines how to add new gRPC endpoints for communication between the webview (frontend) and the extension host (backend).
-
-## Overview
-
-Cline uses [Protobuf](https://protobuf.dev/) to define a strongly-typed API, ensuring efficient and type-safe communication. All definitions are in the `/proto` directory. The compiler and plugins are included as project dependencies, so no manual installation is needed.
-
-## Key Concepts & Best Practices
-
--   **File Structure**: Each feature domain should have its own `.proto` file (e.g., `account.proto`, `task.proto`).
--   **Message Design**:
-    -   For simple, single-value data, use the shared types in `proto/common.proto` (e.g., `StringRequest`, `Empty`, `Int64Request`). This promotes consistency.
-    -   For complex data structures, define custom messages within the feature's `.proto` file (see `task.proto` for examples like `NewTaskRequest`).
--   **Naming Conventions**:
-    -   Services: `PascalCaseService` (e.g., `AccountService`).
-    -   RPCs: `camelCase` (e.g., `accountEmailIdentified`).
-    -   Messages: `PascalCase` (e.g., `StringRequest`).
--   **Streaming**: For server-to-client streaming, use the `stream` keyword on the response type. See `subscribeToAuthCallback` in `account.proto` for an example.
-
----
-
-## 4-Step Development Workflow
-
-Here’s how to add a new RPC, using `scrollToSettings` as an example.
-
-### 1. Define the RPC in a `.proto` File
-
-Add your service method to the appropriate file in the `proto/` directory.
-
-**File: `proto/ui.proto`**
-```proto
-service UiService {
-  // ... other RPCs
-  // Scrolls to a specific settings section in the settings view
-  rpc scrollToSettings(StringRequest) returns (KeyValuePair);
-}
-```
-Here, we use the common `StringRequest` and `KeyValuePair` types.
-
-### 2. Compile Definitions
-
-After editing a `.proto` file, regenerate the TypeScript code. From the project root, run:
-```bash
-npm run protos
-```
-This command compiles all `.proto` files and outputs the generated code to `src/generated/` and `src/shared/`. Do not edit these generated files manually.
-
-### 3. Implement the Backend Handler
-
-Create the RPC implementation in the backend. Handlers are located in `src/core/controller/[service-name]/`.
-
-**File: `src/core/controller/ui/scrollToSettings.ts`**
-```typescript
-import { Controller } from ".."
-import { StringRequest, KeyValuePair } from "../../../shared/proto/common"
-
-/**
- * Executes a scroll to settings action
- * @param controller The controller instance
- * @param request The request containing the ID of the settings section to scroll to
- * @returns KeyValuePair with action and value fields for the UI to process
- */
-export async function scrollToSettings(controller: Controller, request: StringRequest): Promise<KeyValuePair> {
-	return KeyValuePair.create({
-		key: "scrollToSettings",
-		value: request.value || "",
-	})
-}
-```
-
-### 4. Call the RPC from the Webview
-
-Call the new RPC from a React component in `webview-ui/`. The generated client makes this simple.
-
-**File: `webview-ui/src/components/browser/BrowserSettingsMenu.tsx`** (Example)
-```tsx
-import { UiServiceClient } from "../../../services/grpc"
-import { StringRequest } from "../../../../shared/proto/common"
-
-// ... inside a React component
-const handleMenuClick = async () => {
-    try {
-        await UiServiceClient.scrollToSettings(StringRequest.create({ value: "browser" }))
-    } catch (error) {
-        console.error("Error scrolling to browser settings:", error)
-    }
-}
-```

.clinerules/workflows/git-branch-analysis.md

@@ -1,61 +0,0 @@
-# Git Diff Analysis Workflow
-
-## Objective
-Analyze the current branch's changes against main to provide informed insights and context for development decisions.
-
-## Step 1: Gather Git Information
-<important>Do not return any text or conversation other than what is necessary to run these commands</important>
-
-**Run the following command to get the latest changes (bash):**
-```bash
-B=$(for c in main master origin/main origin/master; do git rev-parse --verify -q "$c" >/dev/null && echo "$c" && break; done); B=${B:-HEAD}; r(){ git branch --show-current; printf "=== STATUS ===\n"; git status --porcelain | cat; printf "=== COMMIT MESSAGES ===\n"; git log "$B"..HEAD --oneline | cat; printf "=== CHANGED FILES ===\n"; git diff "$B" --name-only | cat; printf "=== FULL DIFF ===\n"; git diff "$B" | cat; }; L=$(r | wc -l); if [ "$L" -gt 500 ]; then r > cline-git-analysis.temp && echo "::OUTPUT_FILE=cline-git-analysis.temp"; else r; fi
-```
-
-```powershell
-$B=$null;foreach($c in 'main','master','origin/main','origin/master'){git rev-parse --verify -q $c *> $null;if($LASTEXITCODE -eq 0){$B=$c;break}};if(-not $B){$B='HEAD'};function r([string]$b){git rev-parse --abbrev-ref HEAD; '=== STATUS ==='; git status --porcelain | cat; '=== COMMIT MESSAGES ==='; git log "$b"..HEAD --oneline | cat; '=== CHANGED FILES ==='; git diff "$b" --name-only | cat; '=== FULL DIFF ==='; git diff "$b" | cat};$out=r $B|Out-String;$lines=($out -split "`r?`n").Count;if($lines -gt 500){$out|Set-Content -NoNewline cline-git-analysis.temp; '::OUTPUT_FILE=cline-git-analysis.temp'}else{$out}
-```
-
-## Step 2: Silent, Structured Analysis Phase
-- Analyze all git output without providing commentary or narration
-- Read the full diff to understand the scope and nature of changes
-- Identify patterns, architectural modifications, or potential impacts
-- Use `read_file` to examine any related files providing additional context on the changes you have observed
-
-## Step 3: Context Gathering
-- Analyze related code without providing commentary or narration
-- Read relevant related source files if needed for complete understanding
-- Check dependencies, imports, or cross-references spanning the changes
-- Understand the broader codebase context around modifications
-- This additional context gathering should include related backend code, as well as related ui/frontend code
-- You will typically need to analyze at least several files, potentially many, in order to fully complete this step
-- You should not continue reading additional context if you have exhausted more than 60% of your available context window
-- If you have exhausted less than 40% of your context window, you should continue reviewing additional context
-
-## Step 4: Ready for User Interaction
-**Only after completing the full analysis:**
-- Engage with the user based on comprehensive understanding
-- Provide insights about specific modifications and their impacts
-- If you are certain they exist, note potential breaking changes or compatibility issues
-- Answer questions with informed context from the complete change set and context gathering
-- If the user has not provided a question, or the question is insufficient to provide a quality response, ask brief (one sentence) clarifying questions.
-- Only offer recommendations if they are applicable to the user's request and relevant to the changes that you have observed 
-
-## Key Rules
-- **No prose or conversation during git research phase**
-- **No prose or conversation during context gathering phase**
-- **Complete all analysis before any user interaction**
-- **Use gathered information for all subsequent questions and insights**
-- **Focus on understanding the complete picture before discussing**
-
-## Optional: Additional Analysis Commands
-For deeper investigation when needed:
-
-```shell
-# Detailed commit history with author info
-git log main..HEAD --format="%h %s (%an)" | cat
-
-# Change statistics
-git diff main --stat | cat
-
-# Specific file type changes
-git diff main --name-only | grep -E '\.(ts|js|tsx|jsx|py|md)$' | cat

.clinerules/workflows/pr-review.md

@@ -219,9 +219,6 @@ EOF
 
 ## Basic PR Commands
 ```bash
-# Get current PR number
-gh pr view --json number -q .number
-
 # List open PRs
 gh pr list
 

.clinerules/workflows/writing-documentation.md

@@ -1,392 +0,0 @@
-# General writing guide
-
-# How I want you to write 
-
-I'm gonna write something technical.
-
-It's often less about the nitty-gritty details of the tech stuff and more about learning something new or getting a solution handed to me on a silver platter.
-
-Look, when I read, I want something out of it. So when I write, I gotta remember that my readers want something too. This whole piece? It's about cluing in anyone who writes for me, or wants me to write for them, on how I see this whole writing product thing.
-
-I'm gonna lay out a checklist of stuff I'd like to have. It'll make the whole writing gig a bit smoother, you know?
-
-## Crafting Compelling Titles
-
-I often come across titles like "How to do X with Y,Z technology." These don't excite me because X or Y are usually unfamiliar unless they're already well-known. Its rarely the dream to use X unless X is the dream. 
-
-My dream isn’t to use instructor, its to do something valueble with the data it extracts
-
-An effective title should:
-
-- Evoke an emotional response
-- Highlight someone's goal
-- Offer a dream or aspiration
-- Challenge or comment on a belief
-- Address someone's problems
-
-I believe it's more impactful to write about specific problems. If this approach works, you can replicate it across various scenarios rather than staying too general.
-
-- Time management for everyone can be a 15$ ebook
-- Time management for executives is a 2000$ workshop
-
-Aim for titles that answer questions you think everyone is asking, or address thoughts people have but can't quite articulate.
-
-Instead of "How I do something" or "How to do something," frame it from the reader's perspective with "How you can do something." This makes the title more engaging. Just make sure the difference is advisory if the content is subjective. “How I made a million dollars” might be more reasonable than “How to make a million dollars” since you are the subject and the goal might be to share your story in hopes of helping others.
-
-This approach ultimately trains the reader to have a stronger emotional connection to your content.
-
-- "How I do X"
-- "How You Can do X"
-
-Between these two titles, it's obvious which one resonates more emotionally.
-
-You can take it further by adding specific conditions. For instance, you could target a particular audience or set a timeframe:
-
-- How to set up Braintrust
-- How to set up Braintrust in 5 minutes
-
-## NO adjectiives
-
-I want you to almost always avoid adjectives and try to use evidence instead. Instead of saying "production ready," you can write something like "scaling this to 100 servers or 1 million documents per second." Numbers like that will tell you exactly what the specificity of your product is. If you have to use adjectives rather than evidence, you are probably making something up. 
-
-There's no reason to say something like "blazingly fast" unless those things are already known phrases.
-
-Instead, say "200 times faster" or "30% faster." A 30% improvement in recommendation system speed is insane.
-
-There's a 200 times performance improvement because we went from one programming language to another. It's just something that's a little bit more expected and understandable.
-
-Another test that I really like using recently is tracking whether or not the statements you make can be:
-
-- Visualized
-- Proven false
-- Said only by you
-
-If you can nail all three, the claim you make will be more likely to resonate with an audience because only you can say it.
-
-Earlier this year, I had an example where I embedded all of Wikipedia in 17 minutes with 20 bucks, and it got half a million views. All we posted was a video of me kicking off the job, and then you can see all the log lines go through. You see the number of containers go from 1 out of 50 to 50 out of 50.
-
-It was easy to visualize and could have been proven false by being unreproducible. Lastly, Modal is the only company that could do that in such an effortless way, which made it unique.
-
-## Keep It Digestible 
-    - Aim for 5-minute reads
-    - Write at a Grade 10 reading level
-    - Break up long paragraphs
-    - Use headers and bullet points
-
-## Make It Scannable
-    - Bold key points
-    - Use subheadings every 3-4 paragraphs
-    - Include plenty of white space
-    - Add relevant examples
-
-This structure works whether you're writing a tweet thread or a full blog post. The key is making complex ideas accessible.
-
-# Guide to Writing Cline Documentation
-
-## Some general principles for explaining features
-
-If you're talking about a feature, it's helpful to start with a human-readable explanations that cover what the feature is in simple terms. Skip jargon and explain it like you're talking to someone who's never seen it before. This sets the foundation for everything that follows.
-
-Combine location and usage into one flowing section. Tell users exactly where to find the feature and how to use it, but weave the instructions into natural prose with a good balance of bullet points, numbered lists, code examples (if applicable), mintlify components, and headers/subheaders. Users shouldn't have to jump between separate "where is it" and "how do I use it" sections.
-
-Show the feature in action with real examples like actual files, workflows, or code. Users need to see concrete implementations, not just abstract descriptions. This is where understanding turns into practical knowledge.
-
-When talking about a feature, include an inspiration section that sparks imagination. This section pushes people from understanding to action by showing them what becomes possible when they use this feature creatively. It's what separates good documentation from great documentation.
-
-## Writing Principles That Actually Work
-
-### Write for Action, Not Just Understanding
-
-Documentation should motivate users to try things. Instead of just explaining how something works, focus on what users can accomplish with it. The inspiration section is crucial - it's what transforms passive readers into active users.
-
-### Create a Natural Story Flow
-
-It should feel like a conversation that naturally progresses from "what is this?" to "how do I use it?" to "here's a real example" to "imagine what you could do with this." 
-
-### Show Real Examples, Not Toy Demos
-
-Provide actual workflow files, real code snippets, and concrete implementations that users can copy and adapt. Abstract examples don't help anyone - users want to see exactly what they'll be working with.
-
-### Keep It Scannable But Not Fragmented
-
-Write in prose that flows naturally when read completely, but structure it so users can quickly find specific information when they're troubleshooting. Avoid dense walls of text, but also avoid over-formatting with excessive bullet points and bold headers. There should be a nice visual heirarchy of balance between all elements, so you can quickly scan the page and find what you're looking for.
-
-## Language and Tone Guidelines
-
-Write clearly without dumbing things down. Use simple language when possible, but don't avoid technical terms that users need to know. Explain concepts in terms of what users can achieve rather than how the software works internally.
-
-Make your writing conversational and encouraging. Phrases like "you can also try" or "when that works" feel more natural than rigid instructional language. Help users feel confident about trying new things.
-
-Keep content concise and purposeful. Every sentence should either help users understand something or help them do something. If it doesn't serve one of those purposes, cut it.
-
-Build in context and reasoning. Users want to understand why they're doing something, not just what to do. This builds confidence and helps them troubleshoot when things don't work exactly as expected.
-
-## Practical Implementation
-
-Structure each feature page consistently with the four-section approach, but let the content flow naturally within that structure. Use visual assets like videos and screenshots to complement the written content - they often communicate more effectively than paragraphs of description.
-
-Link generously to related resources, examples, and deeper documentation. Users should never feel stuck or wonder where to go next. Maintain a repository of real examples that users can reference and adapt to their own needs.
-
-The goal is documentation that feels more like helpful guidance from an experienced colleague than a technical manual. Users should finish reading feeling excited about what they can accomplish, not just informed about what the feature does.
-
-## Balance Structure with Flexibility
-
-While they discuss having consistent documentation structure, there's also mention of making content feel less rigid and more natural. The writing should follow guidelines while still feeling conversational and engaging. 
-
-## Bad examples
-
-I personally hate this pattern of bullet point **Bold Text** colon and then more text:
-<bad_example_of_writing>
-#### macOS
-
-1. **Switch to bash**: Go to Cline Settings → Terminal → Default Terminal Profile → Select "bash"
-2. **Disable Oh-My-Zsh temporarily**: If using zsh, try `mv ~/.zshrc ~/.zshrc.backup` and restart VSCode
-3. **Set environment**: Add to your shell config: `export TERM=xterm-256color`
-
-#### Windows
-
-1. **Use PowerShell 7**: Install from Microsoft Store, then select it in Cline settings
-2. **Disable Windows ConPTY**: VSCode Settings → Terminal › Integrated: Windows Enable Conpty → Uncheck
-3. **Try Command Prompt**: Sometimes simpler is better - switch to cmd.exe
-
-#### Linux
-
-1. **Use bash**: Most reliable option - select in Cline settings
-2. **Check permissions**: Ensure VSCode has terminal access permissions
-3. **Disable custom prompts**: Comment out prompt customizations in `.bashrc`
-
-</bad_example_of_writing>
-
-We should instead strive to write beautiful docs that read well. We can use bullet points and numbered lists but it should read naturally and be delightful to look at hierachally when scanning through the doc. There should be a good balance between blocks of text, code snippets, paragraphs, numbered lists, and bullet points. When scanning the documentation visually, you should feel like you're adminiring a tasteful art piece.
-
-<good_example_of_writing>
-#### macOS
-
-The most common fix is switching to bash. Navigate to Cline Settings → Terminal → Default Terminal Profile and select "bash" from the dropdown.
-
-If you're still having issues, Oh-My-Zsh might be interfering with terminal integration. Try temporarily disabling it:
-- Run `mv ~/.zshrc ~/.zshrc.backup` 
-- Restart VSCode
-
-You can also add `export TERM=xterm-256color` to your shell configuration file to improve compatibility.
-
-#### Windows
-
-PowerShell 7 provides the most reliable experience. Install it from the Microsoft Store, then select it in your Cline settings.
-
-Still seeing problems? Try these solutions:
-- Disable Windows ConPTY: VSCode Settings → Terminal › Integrated: Windows Enable Conpty → uncheck
-- Switch to Command Prompt (cmd.exe) - sometimes simpler shells work better
-
-#### Linux
-
-Bash is your most dependable option. Select it in Cline settings if you haven't already.
-
-Check these common issues:
-- Ensure VSCode has terminal access permissions
-- Temporarily comment out custom prompt configurations in your `.bashrc`
-</good_example_of_writing>
-
-This is much more natural to read. Writing this way creates a conversational flow, and bullet points are used idiomatically.
-
-# Using Mintlify Components Idiomatically
-
-Mintlify's custom components can transform basic documentation into engaging, scannable content that users actually want to read. Here's how to use them effectively.
-
-## Visual Content with Frames
-
-Videos and images should be wrapped in `<Frame>` components rather than using raw HTML or markdown. This creates consistent styling and proper responsive behavior.
-
-For videos, embed them directly rather than linking externally. Users are much more likely to watch a 30-second demonstration than click through to another platform:
-
-```jsx
-<Frame>
-	<iframe
-		style={{ width: "100%", aspectRatio: "16/9" }}
-		src="https://www.youtube.com/embed/your-video-id"
-		title="Feature demonstration"
-		frameBorder="0"
-		allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
-		allowFullScreen
-	/>
-</Frame>
-```
-
-Screenshots work similarly - the frame provides visual polish and consistency:
-
-```jsx
-<Frame>
-	<img src="/path/to/screenshot.png" alt="Descriptive alt text" />
-</Frame>
-```
-
-## Cards for Navigation and Overview
-
-Cards excel at creating scannable overviews that link to detailed documentation. They're perfect for feature listings, getting started guides, or any section where users need to choose their path.
-
-Use the two-column layout for related features:
-
-```jsx
-<Columns cols={2}>
-  <Card title="Feature Name" icon="relevant-icon" href="/link/to/docs">
-    Brief description that explains what this feature does and why someone would use it.
-  </Card>
-  
-  <Card title="Related Feature" icon="another-icon" href="/another/link">
-    Another concise explanation that helps users understand the value proposition.
-  </Card>
-</Columns>
-```
-
-The key is writing card descriptions that are informative enough to help users decide whether to click through, but concise enough to scan quickly. Each card should answer "what does this do?" and "why would I need this?"
-
-## Tips and Notes for Context
-
-Use `<Tip>` components for helpful information that enhances the main content without cluttering it:
-
-```jsx
-<Tip>
-	Pro tip: You can combine multiple @ mentions in a single message to give Cline 
-	comprehensive context about your issue.
-</Tip>
-```
-
-`<Note>` components work well for important caveats or technical limitations:
-
-```jsx
-<Note>
-	Due to VS Code limitations, some features require specific settings to work properly.
-</Note>
-```
-
-`<Info>` is also cool:
-
-<Info>
-	**Quick Fix**: If you're experiencing terminal issues, try switching to a simpler shell like `bash` in the Cline settings.
-	This resolves 90% of terminal integration problems.
-</Info>
-
-**Never** fall into that awful **Bold Text** - description pattern that we specifically identified as bad writing. The content should flow naturally as connected thoughts rather than feeling like a templated AI response with forced formatting.
-
-
-## When to Use Bullet Points and Numbered Lists Strategically
-
-Bullet points serve functional purposes - use them for:
-
-**Sequential actions or troubleshooting steps** where users need to follow a specific order:
-1. Install the extension
-2. Restart VSCode  
-3. Check the settings panel
-
-**Lists of related options** where users need to choose one approach:
-- Try PowerShell 7 for the most reliable experience
-- Switch to Command Prompt if you're still having issues
-- Use WSL Bash for Linux compatibility
-
-**Quick reference items** that users might need to scan quickly when problem-solving.
-
-**Improving Visual Hierarchy** when there's a wall of text - that's a good time to introduce bullet points or numbered lists.
-
-Each bulleted item or numbered list should be a discrete action or piece of information that benefits from being visually separated. This is a key weapon you can employ when going for that artwork experience I mentioned earlier. 
-
-<good_example_of_bullet_points>
-## Finding and Configuring Terminal Settings
-
-You can access Cline's terminal settings by clicking the settings icon in the Cline sidebar, then navigating to the Terminal section. These settings control how Cline interacts with your system's terminal.
-
-- The **Default Terminal Profile** setting determines which shell Cline uses for executing commands. If you're experiencing issues, this is usually the first thing to change. I personally keep this set to `bash` on all my systems because it's the most reliable option, even though I use `zsh` for my regular terminal work.
-
-- **Shell Integration Timeout** controls how long Cline waits for the terminal to become ready. The default is 4 seconds, but if you have a heavy shell configuration (lots of plugins, slow startup scripts), you might need to increase this to 10 or even 15 seconds. I've found that WSL environments and SSH connections often need longer timeouts.
-
-- The **Enable Aggressive Terminal Reuse** setting determines whether Cline tries to reuse existing terminals even when they're not in the correct directory. When this causes problems (commands running in the wrong directory, virtual environment issues), disabling it creates more terminal instances but ensures each command runs in a clean state.
-
-- **Terminal Output Line Limit** sets how many lines of output Cline will read from commands. The default of 500 lines works for most cases, but you might need to adjust it. For verbose build outputs, increase it. For commands with progress bars that spam thousands of lines, decrease it to around 100 to avoid consuming too many tokens.
-</good_example_of_bullet_points>
-
-## Write Like a Human, Not an AI
-
-Keep it short and direct. If you can say something in fewer words, do it. Long explanations often confuse more than they help.
-
-Use normal sentence lengths. Mix short and long sentences naturally, like you would when talking to someone. Avoid those meandering compound sentences that go on forever.
-
-Cut the corporate speak. Instead of "utilize," say "use." Instead of "in order to," just say "to." Write like you're explaining something to a colleague, not drafting a press release.
-
-Don't over-explain obvious things. If users are reading documentation, they probably understand basic concepts. Respect their intelligence.
-
-## Never use em dashes or emojis
-
-That's pretty much it. Never use them. Only AI writes with em dashes or emojis.
-
-# Anthropomorphizing Cline
-
-When referring to Cline, always call him a "him" not an "it". 
-
-Bad example:
-- When Cline can’t execute commands or read their output, you lose access to one of its most powerful capabilities.
-
-Good Example:
-
-- When Cline can’t execute commands or read their output, you lose access to one of his most powerful capabilities.
-
-# Using "I" when sharing your workflow
-
-Adding a personal touch goes a long way. There are great examples in the docs currently where I use "I" to share how I personally use cline, from dev to dev. It's a great technique.
-
-# Crosslinking relevant documentation pages
-
-Make sure you crosslink when you're done writing the docs. If there are relevant docs, just link to them.
-
-# Brevity is the soul of wit
-
-Don't ramble if you don't need to. Use bullet points and numbered lists. Keep things easy to read.
-
-<bad_example>
-
-When Cline can't execute commands or read their output, you lose access to one of his most powerful capabilities. Terminal integration problems are frustrating, but they're usually fixable with a few simple changes.
-
-## The Most Common Problem: Shell Integration Issues
-
-If you're seeing "Shell integration unavailable" or Cline isn't getting command output, the issue is almost always your shell configuration. Complex shell setups with custom prompts, plugins, and fancy configurations can interfere with VSCode's terminal integration.
-
-**Switch to bash first.** This fixes the problem 90% of the time. Navigate to Cline Settings → Terminal → Default Terminal Profile and select "bash" from the dropdown. Restart VSCode after making this change.
-
-Still having issues? Try increasing the shell integration timeout. Go to Cline Settings → Terminal → Shell Integration Timeout and change it from 4 seconds to 10 seconds. Heavy shell configurations need more time to initialize properly.
-
-If commands are running in the wrong directories or you're seeing weird behavior, disable aggressive terminal reuse. In Cline Settings → Terminal, uncheck "Enable aggressive terminal reuse." This creates more terminal instances but ensures each command runs in a clean environment.
-
-
-</bad_exaxmple>
-
-The first part is total filler, useless to any serious developer. You can tell it's written by a non technical person that doesn't value clean, straightforward information. 
-
-<good_example>
-## Shell Integration Issues
-
-If you're seeing "Shell integration unavailable" or Cline can't read command output, your shell configuration is interfering with VSCode's terminal integration.
-
-**Switch to bash first.** Go to Cline Settings → Terminal → Default Terminal Profile and select "bash." This fixes 90% of problems.
-
-Still broken? Try these:
-- Increase shell integration timeout to 10 seconds in Cline Settings → Terminal
-- Disable "aggressive terminal reuse" if commands run in wrong directories
-- Restart VSCode after making changes
-</good_example>
-
-The good version cuts straight to the problem and solution. No hand-holding, no emotional language about frustration, just the facts: what's wrong, how to fix it, what to try next. Respects that developers want information, not sympathy.RetryClaude can make mistakes. Please double-check responses.
-
-ALWAYS consider your audience. And your audience is devs who don't want their time wasted. Give them the info. I cannot stress this enough. Use bullet points and numbered lists. Prose is good, but every word should actually mean something to the dev reading it.
-
-# Lastly, before you start writing docs
-
-1. Internalize these guidelines. I mean it. 
-
-2. Read `docs/docs.json` and get an understanding of the structure of the docs. This will come in handly at the end when you're doing a final pass so you can cross link to docs where relevant.
-
-3. Read some good examples that I personally wrote and am proud of:
-
-- docs/features/slash-commands/workflows.mdx
-- docs/features/slash-commands/new-task.mdx
-- docs/features/at-mentions/overview.mdx
-- docs/features/drag-and-drop.mdx
-
-4. If the user specifies any other instructions make sure you follow them.

.codespellrc

@@ -0,0 +1,6 @@
+[codespell]
+# Ref: https://github.com/codespell-project/codespell#using-a-config-file
+skip = .git*,*.svg,package-lock.json,*.css,.codespellrc,locales
+check-hidden = true
+ignore-regex = (\b(optIn|isTaller)\b|https://\S+)
+# ignore-words-list =

.eslintrc.json

@@ -0,0 +1,27 @@
+{
+	"root": true,
+	"parser": "@typescript-eslint/parser",
+	"parserOptions": {
+		"ecmaVersion": 6,
+		"sourceType": "module"
+	},
+	"plugins": ["@typescript-eslint", "eslint-rules"],
+	"rules": {
+		"@typescript-eslint/naming-convention": [
+			"warn",
+			{
+				"selector": "import",
+				"format": ["camelCase", "PascalCase"]
+			}
+		],
+		"@typescript-eslint/semi": "off",
+		"curly": "warn",
+		"eqeqeq": "warn",
+		"no-throw-literal": "warn",
+		"semi": "off",
+		"react-hooks/exhaustive-deps": "off",
+		"eslint-rules/no-protobuf-object-literals": "error",
+		"eslint-rules/no-grpc-client-object-literals": "error"
+	},
+	"ignorePatterns": ["out", "dist", "**/*.d.ts"]
+}

.github/CODEOWNERS

@@ -1,3 +1 @@
-/docs/
-/.github/   @saoudrizwan @dcbartlett
-/README.md  @saoudrizwan @nickbaumann98
+*       @saoudrizwan @ocasta181 @NightTrek @pashpashpash @dcbartlett @saito-sv @Garoth

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -5,7 +5,7 @@ body:
     - type: markdown
       attributes:
           value: |
-              **Important:** All bug reports must be reproducible using Claude 4 Sonnet. Cline uses complex prompts so less capable models may not work as expected.
+              **Important:** All bug reports must be reproducible using Claude 3.5 Sonnet. Cline uses complex prompts so less capable models may not work as expected.
     - type: textarea
       id: what-happened
       attributes:
@@ -24,7 +24,7 @@ body:
               2.
               3.
       validations:
-          required: false
+          required: true
     - type: textarea
       id: logs
       attributes:
@@ -39,19 +39,20 @@ body:
           placeholder: "e.g., cline:anthropic/claude-3.7-sonnet, gemini:gemini-2.5-pro-exp-03-25"
       validations:
           required: true
+    - type: input
+      id: operating-system
+      attributes:
+          label: Operating System
+          description: What operating system are you using?
+          placeholder: "e.g., Windows 11, macOS Sonoma, Ubuntu 22.04"
+      validations:
+          required: true
     - type: textarea
       id: system-info
       attributes:
-          label: System Information
-          description: What operating system and hardware are you using?
-          placeholder: |
-              Operating System: Windows 11, macOS Sonoma, Ubuntu 22.04, etc.
-              Hardware: CPU, GPU, RAM specifications if relevant
-              e.g.,
-              OS: Windows 11
-              CPU: Intel Core i7-11700K
-              GPU: NVIDIA GeForce RTX 3070
-              RAM: 32GB DDR4
+          label: System Info
+          description: What system information is relevant to the issue?
+          placeholder: "e.g., CPU: Intel Core i7-11700K, GPU: NVIDIA GeForce RTX 3070, RAM: 32GB DDR4"
       validations:
           required: true
     - type: input
@@ -62,3 +63,8 @@ body:
           placeholder: "e.g., 1.2.3"
       validations:
           required: true
+    - type: textarea
+      id: additional-context
+      attributes:
+          label: Additional context
+          description: Add any other context about the problem here, such as screenshots or related issues.

.github/ISSUE_TEMPLATE/config.yml

@@ -1,4 +1,4 @@
-blank_issues_enabled: false
+blank_issues_enabled: true
 contact_links:
     - name: ✨ Feature Request
       url: https://github.com/cline/cline/discussions/categories/feature-requests?discussions_q=is%3Aopen+category%3A%22Feature+Requests%22+sort%3Atop
@@ -6,3 +6,6 @@ contact_links:
     - name: 👋 Cline Discord
       url: https://discord.gg/cline
       about: Join our Discord community for discussions and support
+    - name: ❓ Other Questions?
+      url: https://x.com/sdrzn
+      about: Contact the developer on X @sdrzn for other inquiries

.github/pull_request_template.md

@@ -1,46 +1,10 @@
-<!--
-Thank you for contributing to Cline!
-
-⚠️ Important: Before submitting this PR, please ensure you have:
-- For feature requests: Created a discussion in our Feature Requests discussions board https://github.com/cline/cline/discussions/categories/feature-requests and received approval from core maintainers before implementation
-- For all changes: Link the associated issue/discussion in the "Related Issue" section below
-
-Limited exceptions:
-Small bug fixes, typo corrections, minor wording improvements, or simple type fixes that don't change functionality may be submitted directly without prior discussion.
-
-Why this requirement?
-We deeply appreciate all community contributions - they are essential to Cline's success! To ensure the best use of everyone's time and maintain project direction, we use our Feature Requests discussions board to gauge community interest and validate feature ideas before implementation begins. This helps us focus development efforts on features that will benefit the most users.
--->
-
-### Related Issue
-
-<!-- Replace XXXX with the issue number that this PR addresses -->
-**Issue:** #XXXX
-
 ### Description
 
-<!-- 
-Help reviewers understand your changes by making this PR readable and well-organized:
-
-- What problem does this PR solve?
-- Why were these changes introduced and what purpose do they serve?
-- For larger changes, provide context about your approach and reasoning
-
-Small PRs may need minimal description, but larger changes benefit from explaining where you're coming from. Much of this context can be in the linked issue above, so feel free to reference it rather than repeating everything here.
--->
+<!-- Describe your changes in detail. What problem does this PR solve? -->
 
 ### Test Procedure
 
-<!-- 
-Please walk us through your testing approach and thought process. This helps reviewers understand that you've thoroughly considered the impact of your changes:
-
-- How did you test this change?
-- What could potentially break and how did you verify it doesn't?
-- What existing functionality might be affected and how did you check it still works?
-- Why are you confident this is ready for merge?
-
-We're not looking for exhaustive documentation - just evidence that you've thought through the implications of your changes and tested accordingly.
--->
+<!-- How did you test this? Are you confident that it will not introduce bugs? If so, why? -->
 
 ### Type of Change
 
@@ -65,15 +29,7 @@ We're not looking for exhaustive documentation - just evidence that you've thoug
 
 ### Screenshots
 
-<!-- 
-Help reviewers quickly understand your changes:
-
-- **UI Changes**: Please include screenshots showing before/after states
-- **Complex Workflows**: Consider uploading a screen recording (video) if your changes involve multiple steps or state transitions
-- **Backend Changes**: Not required, but feel free to include terminal output or other evidence that demonstrates functionality
-
-This helps reviewers see what you've built without having to pull down and test your branch first.
--->
+<!-- For UI changes, add screenshots here -->
 
 ### Additional Notes
 

.github/workflows/codespell.yml

@@ -0,0 +1,28 @@
+# Codespell configuration is within .codespellrc
+---
+name: Codespell
+
+on:
+    push:
+        branches: [main]
+    pull_request:
+        branches: [main]
+
+permissions:
+    contents: read
+
+jobs:
+    codespell:
+        if: false
+        name: Check for spelling errors
+        runs-on: ubuntu-latest
+
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v4
+            - name: Annotate locations with typos
+              uses: codespell-project/codespell-problem-matcher@v1
+            - name: Codespell
+              uses: codespell-project/actions-codespell@v2
+              with:
+                  only_warn: 1

.github/workflows/e2e.yml

@@ -1,108 +0,0 @@
-name: E2E Tests
-
-on:
-    push:
-        branches:
-            - main
-    pull_request:
-        types: [opened, reopened, synchronize, ready_for_review]
-    workflow_dispatch:
-
-concurrency:
-    group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-    cancel-in-progress: true
-
-jobs:
-    matrix_prep:
-        runs-on: ubuntu-latest
-        outputs:
-            matrix: ${{ steps.set-matrix.outputs.matrix }}
-        steps:
-            - id: set-matrix
-              run: |
-                  echo 'matrix=[{"runner":"ubuntu"},{"runner":"windows"},{"runner":"macos"}]' >> $GITHUB_OUTPUT
-
-    e2e:
-        needs: matrix_prep
-        strategy:
-            fail-fast: false
-            matrix:
-                include: ${{ fromJson(needs.matrix_prep.outputs.matrix) }}
-        runs-on: ${{ matrix.runner }}-latest
-        timeout-minutes: 20
-        permissions:
-            id-token: write
-            contents: read
-        steps:
-            - uses: actions/checkout@v4
-            - name: Setup Node.js environment
-              uses: actions/setup-node@v4
-              with:
-                  node-version: 22
-
-            # Cache root dependencies - only reuse if package-lock.json exactly matches
-            - name: Cache root dependencies
-              uses: actions/cache@v4
-              id: root-cache
-              with:
-                  path: node_modules
-                  key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
-
-            # Cache webview-ui dependencies - only reuse if package-lock.json exactly matches
-            - name: Cache webview-ui dependencies
-              uses: actions/cache@v4
-              id: webview-cache
-              with:
-                  path: webview-ui/node_modules
-                  key: ${{ runner.os }}-npm-webview-${{ hashFiles('webview-ui/package-lock.json') }}
-
-            # Cache VS Code installation
-            - name: Cache VS Code
-              uses: actions/cache@v4
-              id: vscode-cache
-              with:
-                  path: .vscode-test
-                  key: vscode-${{ runner.os }}-stable-${{ hashFiles('.vscode-test.mjs', 'package.json') }}
-                  restore-keys: |
-                      vscode-${{ runner.os }}-stable-
-
-            # Cache Playwright browsers
-            - name: Cache Playwright browsers
-              uses: actions/cache@v4
-              id: playwright-cache
-              with:
-                  path: |
-                      ~/.cache/ms-playwright
-                      ~/Library/Caches/ms-playwright
-                      ~/AppData/Local/ms-playwright
-                  key: playwright-browsers-${{ runner.os }}-${{ hashFiles('package-lock.json') }}
-                  restore-keys: |
-                      playwright-browsers-${{ runner.os }}-
-
-            - name: Install root dependencies
-              if: steps.root-cache.outputs.cache-hit != 'true'
-              run: npm ci
-
-            - name: Install webview-ui dependencies
-              if: steps.webview-cache.outputs.cache-hit != 'true'
-              run: cd webview-ui && npm ci
-
-            - name: Install xvfb on Linux
-              if: matrix.runner == 'ubuntu'
-              run: sudo apt-get update && sudo apt-get install -y xvfb
-
-            # Run optimized E2E tests (eliminates redundant builds)
-            - name: Run E2E tests - Linux
-              if: matrix.runner == 'ubuntu'
-              run: xvfb-run -a npm run test:e2e:optimal
-
-            - name: Run E2E tests - Non-Linux
-              if: matrix.runner != 'ubuntu'
-              run: npm run test:e2e:optimal
-
-            - uses: actions/upload-artifact@v4
-              if: ${{ failure() }}
-              with:
-                  name: playwright-recordings-${{ matrix.runner }}
-                  path: |
-                      test-results/playwright/

.github/workflows/publish.yml

@@ -11,10 +11,6 @@ on:
                 options:
                     - pre-release
                     - release
-            tag:
-                description: "Enter existing tag to publish (e.g., v3.1.2)"
-                required: true
-                type: string
 
 permissions:
     contents: write
@@ -34,8 +30,6 @@ jobs:
 
         steps:
             - uses: actions/checkout@v4
-              with:
-                  ref: ${{ github.event.inputs.tag }}
 
             - name: Setup Node.js
               uses: actions/setup-node@v4
@@ -75,29 +69,22 @@ jobs:
                   VERSION=$(node -p "require('./package.json').version")
                   echo "version=$VERSION" >> $GITHUB_OUTPUT
 
-            - name: Validate Tag
-              id: validate_tag
+            - name: Create Git Tag
+              id: create_tag
               run: |
-                  TAG="${{ github.event.inputs.tag }}"
-                  echo "tag=$TAG" >> $GITHUB_OUTPUT
-                  echo "Using existing tag: $TAG"
-
-                  # Verify the tag exists
-                  if ! git rev-parse "$TAG" >/dev/null 2>&1; then
-                    echo "Error: Tag '$TAG' does not exist in the repository"
-                    exit 1
-                  fi
-
-                  echo "Tag '$TAG' validated successfully"
+                  VERSION=v${{ steps.get_version.outputs.version }}
+                  echo "tag=$VERSION" >> $GITHUB_OUTPUT
+                  echo "Tagging with $VERSION"
+                  git tag "$VERSION"
+                  git push origin "$VERSION"
 
             - name: Package and Publish Extension
               env:
                   VSCE_PAT: ${{ secrets.VSCE_PAT }}
                   OVSX_PAT: ${{ secrets.OVSX_PAT }}
-                  CLINE_ENVIRONMENT: production
               run: |
                   # Required to generate the .vsix
-                  vsce package  --allow-package-secrets sendgrid --out "cline-${{ steps.get_version.outputs.version }}.vsix"
+                  vsce package --out "cline-${{ steps.get_version.outputs.version }}.vsix"
 
                   if [ "${{ github.event.inputs.release-type }}" = "pre-release" ]; then
                     npm run publish:marketplace:prerelease
@@ -119,7 +106,7 @@ jobs:
             - name: Create GitHub Release
               uses: softprops/action-gh-release@v1
               with:
-                  tag_name: ${{ steps.validate_tag.outputs.tag }}
+                  tag_name: ${{ steps.create_tag.outputs.tag }}
                   files: "*.vsix"
                   # body: ${{ steps.changelog.outputs.content }}
                   generate_release_notes: true

.github/workflows/stale.yml

@@ -12,7 +12,7 @@ jobs:
             issues: write
             pull-requests: write
         steps:
-            - uses: actions/stale@v9
+            - uses: actions/stale@28ca103
               with:
                   days-before-issue-stale: 60
                   days-before-issue-close: 14

.github/workflows/test.yml

@@ -68,10 +68,6 @@ jobs:
               if: steps.webview-cache.outputs.cache-hit != 'true'
               run: cd webview-ui && npm ci
 
-            - name: Install xvfb on Linux
-              if: runner.os == 'Linux'
-              run: sudo apt-get update && sudo apt-get install -y xvfb
-              
             - name: Set up NPM on Windows
               if: runner.os == 'Windows'
               run: |
@@ -80,25 +76,26 @@ jobs:
             - name: Type Check
               run: npm run check-types
 
-            - name: Lint Check
+            - name: ESLint Check
               run: npm run lint
 
-            - name: Format Check
+            - name: Prettier / Format Check
               run: npm run format
 
             # Build the extension before running tests
             - name: Build Tests and Extension
               run: npm run pretest
 
-            - name: Unit Tests
-              run: npm run test:unit
+            # Unit Tests disabled due to module system conflicts between backend and webview-ui
+            # - name: Unit Tests
+            #   run: npm run test:unit
 
             # Run extension tests with coverage
-            - name: Extension Integration Tests with Coverage
+            - name: Extension Tests with Coverage
               id: extension_coverage
               continue-on-error: true
               run: |
-                  node ./scripts/test-ci.js 2>&1 | tee extension_coverage.txt
+                  node ./scripts/test-ci.js > extension_coverage.txt 2>&1
                   # Default the encoding to UTF-8 - It's not the default on Windows
                   PYTHONUTF8=1 PYTHONPATH=.github/scripts python -m coverage_check extract-coverage extension_coverage.txt --type=extension --github-output --verbose
 
@@ -110,7 +107,7 @@ jobs:
                   cd webview-ui
                   # Ensure coverage dependency is installed
                   npm install --no-save @vitest/coverage-v8
-                  npm run test:coverage 2>&1 | tee webview_coverage.txt
+                  npm run test:coverage > webview_coverage.txt 2>&1
                   cd ..
                   # Default the encoding to UTF-8 - It's not the default on Windows
                   PYTHONUTF8=1 PYTHONPATH=.github/scripts python -m coverage_check extract-coverage webview-ui/webview_coverage.txt --type=webview --github-output --verbose
@@ -125,19 +122,21 @@ jobs:
                   path: |
                       extension_coverage.txt
                       webview-ui/webview_coverage.txt
+                  retention-period: workflow # Artifacts are automatically deleted when the workflow completes
 
             # Set the check as failed if any of the tests failed
-            - name: Check for test failures
+            - name: Print test results and check for failures
               run: |
+                  echo "Extension Tests Result: ${{ steps.extension_coverage.outcome }}"
+                  cat extension_coverage.txt
+
+                  echo "Webview Tests Result: ${{ steps.webview_coverage.outcome }}"
+                  cat webview-ui/webview_coverage.txt
+
                   # Check if any of the test steps failed
                   # https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/accessing-contextual-information-about-workflow-runs#steps-context
-                  if [ "${{ steps.extension_coverage.outcome }}" != "success" ]; then
-                      echo "Extension Integration Tests failed, see previous step for test output."
-                  fi
-                  if [ "${{ steps.webview_coverage.outcome }}" != "success" ]; then
-                      echo "Webview Tests failed, see previous step for test output."
-                  fi
                   if [ "${{ steps.extension_coverage.outcome }}" != "success" ] || [ "${{ steps.webview_coverage.outcome }}" != "success" ]; then
+                      echo "Tests failed."
                       exit 1
                   fi
 

.gitignore

@@ -7,7 +7,6 @@ tmp
 *.vsix
 
 .DS_Store
-.idea
 
 pnpm-lock.yaml
 
@@ -15,9 +14,6 @@ pnpm-lock.yaml
 .venv
 .actrc
 
-webview-ui/src/**/*.js
-webview-ui/src/**/*.js.map
-
 # Ignore coverage directories and files
 coverage
 # But don't ignore the coverage scripts in .github/scripts/
@@ -25,13 +21,19 @@ coverage
 
 *evals.env
 
-## Generated files ##
-src/generated/
-src/shared/proto/
+# Generated proto files
+src/core/controller/*/methods.ts
+src/core/controller/*/index.ts
+src/core/controller/grpc-service-config.ts
+# Shared
+src/shared/proto/*.ts
+src/shared/proto/host/*.ts
+# Webview
 webview-ui/src/services/grpc-client.ts
-
-# E2E Tests
-test-results
-
-## CLI pre-release  ##
-/cli 
+# Standalone
+src/standalone/server-setup.ts
+src/standalone/services/host-grpc-client.ts
+# Host bridge
+hosts/vscode/*/methods.ts
+hosts/vscode/*/index.ts
+hosts/vscode/host-grpc-service-config.ts

.husky/pre-commit

@@ -1 +1,17 @@
-lint-staged --no-stash
+echo "Running pre-commit checks..."
+
+# Run ESLint
+echo "Running ESLint..."
+npm run lint || {
+    echo "❌ ESLint check failed. Please fix the errors and try committing again."
+    exit 1
+}
+
+# Run Prettier
+echo "Running Prettier..."
+npm run format || {
+    echo "❌ Prettier check failed. Run 'npm run format:fix' to automatically fix formatting issues."
+    exit 1
+}
+
+echo "✅ All checks passed!"

.mocharc.json

@@ -1,15 +1,6 @@
 {
-	"extension": [
-		"ts"
-	],
-	"spec": [
-		"src/**/__tests__/*.ts"
-	],
-	"require": [
-		"ts-node/register",
-		"source-map-support/register",
-		"./src/test/requires.ts"
-	],
-	"recursive": true,
-	"exit": true
+	"extension": ["ts"],
+	"spec": ["src/**/__tests__/*.ts", "eslint-rules/__tests__/**/*.test.ts"],
+	"require": ["ts-node/register", "source-map-support/register", "./src/test/requires.ts"],
+	"recursive": true
 }

.prettierignore

@@ -0,0 +1,7 @@
+dist/
+node_modules
+webview-ui/build/
+*.md
+package-lock.json
+src/core/prompts/system.ts
+src/core/prompts/model_prompts/claude4.ts

.prettierrc.json

@@ -0,0 +1,8 @@
+{
+	"tabWidth": 4,
+	"useTabs": true,
+	"printWidth": 130,
+	"semi": false,
+	"bracketSameLine": true,
+	"endOfLine": "lf"
+}

.vscode-test.mjs

@@ -2,7 +2,7 @@ import { defineConfig } from "@vscode/test-cli"
 import path from "path"
 
 export default defineConfig({
-	files: "{out/**/*.test.js,src/**/*.test.js,!src/test/e2e/**/*.test.js,!out/src/test/e2e/**/*.test.js}",
+	files: "{out/**/*.test.js,src/**/*.test.js}",
 	mocha: {
 		ui: "bdd",
 		timeout: 20000, // Maximum time (in ms) that a test can run before failing

.vscode/extensions.json

@@ -2,9 +2,9 @@
 	// See http://go.microsoft.com/fwlink/?LinkId=827846
 	// for the documentation about the extensions.json format
 	"recommendations": [
+		"dbaeumer.vscode-eslint",
 		"connor4312.esbuild-problem-matchers",
 		"ms-vscode.extension-test-runner",
-		"bradlc.vscode-tailwindcss",
-		"biomejs.biome"
+		"bradlc.vscode-tailwindcss"
 	]
 }

.vscode/launch.json

@@ -6,60 +6,15 @@
 	"version": "0.2.0",
 	"configurations": [
 		{
-			"name": "Run Extension (production)",
+			"name": "Run Extension",
 			"type": "extensionHost",
 			"request": "launch",
-			"args": [
-				"--extensionDevelopmentPath=${workspaceFolder}",
-				"--disable-workspace-trust",
-				"${workspaceFolder}"
-			],
-			"outFiles": [
-				"${workspaceFolder}/dist/**/*.js"
-			],
+			"args": ["--extensionDevelopmentPath=${workspaceFolder}", "--disable-workspace-trust", "${workspaceFolder}"],
+			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
 			"preLaunchTask": "${defaultBuildTask}",
 			"env": {
 				"IS_DEV": "true",
-				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
-				"CLINE_ENVIRONMENT": "production"
-			}
-		},
-		{
-			"name": "Run Extension (staging)",
-			"type": "extensionHost",
-			"request": "launch",
-			"args": [
-				"--extensionDevelopmentPath=${workspaceFolder}",
-				"--disable-workspace-trust",
-				"${workspaceFolder}"
-			],
-			"outFiles": [
-				"${workspaceFolder}/dist/**/*.js"
-			],
-			"preLaunchTask": "${defaultBuildTask}",
-			"env": {
-				"IS_DEV": "true",
-				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
-				"CLINE_ENVIRONMENT": "staging"
-			}
-		},
-		{
-			"name": "Run Extension (local)",
-			"type": "extensionHost",
-			"request": "launch",
-			"args": [
-				"--extensionDevelopmentPath=${workspaceFolder}",
-				"--disable-workspace-trust",
-				"${workspaceFolder}"
-			],
-			"outFiles": [
-				"${workspaceFolder}/dist/**/*.js"
-			],
-			"preLaunchTask": "${defaultBuildTask}",
-			"env": {
-				"IS_DEV": "true",
-				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
-				"CLINE_ENVIRONMENT": "local"
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}"
 			}
 		},
 		{
@@ -68,50 +23,38 @@
 			"request": "launch",
 			"runtimeExecutable": "${execPath}",
 			"args": [
-				"--user-data-dir=${workspaceFolder}/dist/tmp/user",
 				"--profile-temp",
-				"--sync=off",
+				"--sync",
+				"off",
 				"--disable-extensions",
 				"--extensionDevelopmentPath=${workspaceFolder}",
 				"${workspaceFolder}"
 			],
-			"outFiles": [
-				"${workspaceFolder}/dist/**/*.js"
-			],
-			"preLaunchTask": "clean-tmp-user",
+			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
+			"preLaunchTask": "clean-sandbox",
 			"internalConsoleOptions": "openOnSessionStart",
 			"postDebugTask": "stop",
 			"env": {
 				"IS_DEV": "true",
-				"TEMP_PROFILE": "true",
-				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
-				"CLINE_ENVIRONMENT": "production"
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}"
 			}
 		},
 		{
 			"type": "node",
 			"request": "launch",
-			"name": "Run cline-core service",
-			"skipFiles": [
-				"<node_internals>/**"
-			],
+			"name": "Run Standalone Extension",
+			"skipFiles": ["<node_internals>/**"],
 			"sourceMaps": true,
-			"resolveSourceMapLocations": [
-				"${workspaceFolder}/**",
-				"!**/node_modules/**"
-			],
+			"resolveSourceMapLocations": ["${workspaceFolder}/**", "!**/node_modules/**"],
 			"cwd": "${workspaceFolder}/dist-standalone",
-			"outFiles": [
-				"${workspaceFolder}/dist-standalone/**/*.js"
-			],
+			"outFiles": ["${workspaceFolder}/dist-standalone/**/*.js"],
 			"preLaunchTask": "compile-standalone",
 			"env": {
-				// Turns on grpc debug log.
-				//"GRPC_TRACE": "all",
-				//"GRPC_VERBOSITY": "DEBUG",
+				"GRPC_TRACE": "all",
+				"GRPC_VERBOSITY": "DEBUG",
 				"NODE_PATH": "${workspaceFolder}/dist-standalone/node_modules"
 			},
-			"program": "cline-core.js"
+			"program": "standalone.js"
 		}
 	]
 }

.vscode/settings.json

@@ -6,31 +6,8 @@
 	},
 	"search.exclude": {
 		"out": true, // set this to false to include "out" folder in search results
-		"dist": true, // set this to false to include "dist" folder in search results,
-		"node_modules": true,
-		"dist-standalone": true
+		"dist": true // set this to false to include "dist" folder in search results
 	},
 	// Turn off tsc task auto detection since we have the necessary tasks as npm scripts
-	"typescript.tsc.autoDetect": "off",
-	"typescript.preferences.quoteStyle": "double",
-	// Protobuf settings
-	"protoc": {
-		"options": [
-			"--proto_path=proto"
-		]
-	},
-	// Enable Lint and format using Biome
-	"biome.enabled": true,
-	"[typescript]": {
-		"editor.defaultFormatter": "biomejs.biome"
-	},
-	"[typescriptreact]": {
-		"editor.defaultFormatter": "biomejs.biome"
-	},
-	"[jsonc]": {
-		"editor.defaultFormatter": "biomejs.biome"
-	},
-	"[json]": {
-		"editor.defaultFormatter": "biomejs.biome"
-	}
+	"typescript.tsc.autoDetect": "off"
 }

.vscode/tasks.json

@@ -30,13 +30,7 @@
 		},
 		{
 			"label": "watch",
-			"dependsOn": [
-				"npm: protos",
-				"npm: build:webview",
-				"npm: dev:webview",
-				"npm: watch:tsc",
-				"npm: watch:esbuild"
-			],
+			"dependsOn": ["npm: protos", "npm: build:webview", "npm: dev:webview", "npm: watch:tsc", "npm: watch:esbuild"],
 			"presentation": {
 				"reveal": "always"
 			},
@@ -66,9 +60,7 @@
 			"problemMatcher": [],
 			"isBackground": true,
 			"label": "npm: build:webview",
-			"dependsOn": [
-				"npm: protos"
-			],
+			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -86,9 +78,7 @@
 			"problemMatcher": [],
 			"isBackground": true,
 			"label": "npm: build:webview:test",
-			"dependsOn": [
-				"npm: protos"
-			],
+			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -123,9 +113,7 @@
 			],
 			"isBackground": true,
 			"label": "npm: dev:webview",
-			"dependsOn": [
-				"npm: protos"
-			],
+			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -140,30 +128,10 @@
 			"type": "npm",
 			"script": "watch:esbuild",
 			"group": "build",
-			"problemMatcher": {
-				"pattern": [
-					{
-						"regexp": "^✘ \\[ERROR\\] (.*)$",
-						"message": 1
-					},
-					{
-						"regexp": "^\\s+(.*):(\\d+):(\\d+):$",
-						"file": 1,
-						"line": 2,
-						"column": 3
-					}
-				],
-				"background": {
-					"activeOnStart": true,
-					"beginsPattern": "^\\[watch\\] build started$",
-					"endsPattern": "^\\[watch\\] build finished$"
-				}
-			},
+			"problemMatcher": "$esbuild-watch",
 			"isBackground": true,
 			"label": "npm: watch:esbuild",
-			"dependsOn": [
-				"npm: protos"
-			],
+			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -178,30 +146,10 @@
 			"type": "npm",
 			"script": "watch:esbuild:test",
 			"group": "build",
-			"problemMatcher": {
-				"pattern": [
-					{
-						"regexp": "^✘ \\[ERROR\\] (.*)$",
-						"message": 1
-					},
-					{
-						"regexp": "^\\s+(.*):(\\d+):(\\d+):$",
-						"file": 1,
-						"line": 2,
-						"column": 3
-					}
-				],
-				"background": {
-					"activeOnStart": true,
-					"beginsPattern": "^\\[watch\\] build started$",
-					"endsPattern": "^\\[watch\\] build finished$"
-				}
-			},
+			"problemMatcher": "$esbuild-watch",
 			"isBackground": true,
 			"label": "npm: watch:esbuild:test",
-			"dependsOn": [
-				"npm: protos"
-			],
+			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -220,9 +168,7 @@
 			"problemMatcher": "$tsc-watch",
 			"isBackground": true,
 			"label": "npm: watch:tsc",
-			"dependsOn": [
-				"npm: protos"
-			],
+			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -233,9 +179,7 @@
 			"script": "watch-tests",
 			"problemMatcher": "$tsc-watch",
 			"isBackground": true,
-			"dependsOn": [
-				"npm: protos"
-			],
+			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"reveal": "always",
 				"group": "watchers"
@@ -244,11 +188,7 @@
 		},
 		{
 			"label": "tasks: watch-tests",
-			"dependsOn": [
-				"npm: protos",
-				"npm: watch",
-				"npm: watch-tests"
-			],
+			"dependsOn": ["npm: protos", "npm: watch", "npm: watch-tests"],
 			"problemMatcher": []
 		},
 		{
@@ -257,12 +197,10 @@
 			"type": "shell"
 		},
 		{
-			"label": "clean-tmp-user",
+			"label": "clean-sandbox",
 			"type": "shell",
-			"dependsOn": [
-				"watch"
-			],
-			"command": "rm -rf ${workspaceFolder}/dist/tmp/user && mkdir -p ${workspaceFolder}/dist/tmp/user"
+			"dependsOn": ["watch"],
+			"command": "rm -rf .vscode-dev"
 		}
 	],
 	"inputs": [

.vscodeignore

@@ -1,40 +1,24 @@
 # Default
 .vscode/**
 .vscode-test/**
-out/
-dist-standalone/
-node_modules/
+out/**
+node_modules/**
 src/**
-standalone/**
 .gitignore
 .yarnrc
 esbuild.js
 vsc-extension-quickstart.md
-tsconfig*.json
+**/tsconfig.json
 **/.eslintrc.json
 **/*.map
 **/*.ts
 **/.vscode-test.*
-eslint-rules/**
-.github/**
-.husky/**
 
 # Custom
-**/demo.gif
+demo.gif
 .nvmrc
 .gitattributes
 .prettierignore
-.husky/
-.github/
-eslint-rules/
-old_docs/
-evals/
-.changie.yaml
-.codespellrc
-.mocharc.json
-buf.yaml
-.changeset/
-.clinerules/
 
 # Ignore all webview-ui files except the build directory (https://github.com/microsoft/vscode-webview-ui-toolkit-samples/blob/main/frameworks/hello-world-react-cra/.vscodeignore)
 webview-ui/src/**
@@ -48,19 +32,17 @@ webview-ui/node_modules/**
 
 # Ignore docs
 docs/**
-old_docs/**
 
 # Fix issue where codicons don't get packaged (https://github.com/microsoft/vscode-extension-samples/issues/692)
 !node_modules/@vscode/codicons/dist/codicon.css
 !node_modules/@vscode/codicons/dist/codicon.ttf
 
+# Include KaTeX CSS and fonts for LaTeX rendering
+!webview-ui/node_modules/katex/dist/katex.min.css
+!webview-ui/node_modules/katex/dist/fonts/**
+
 # Include default themes JSON files used in getTheme
 !src/integrations/theme/default-themes/**
 
 # Include icons
 !assets/icons/**
-
-# Ignore E2E build files
-e2e-build.mjs
-e2e.vsix
-test-results/

CONTRIBUTING.md

@@ -10,74 +10,16 @@ Bug reports help make Cline better for everyone! Before creating a new issue, pl
      🔐 <b>Important:</b> If you discover a security vulnerability, please use the <a href="https://github.com/cline/cline/security/advisories/new">Github security tool to report it privately</a>.
 </blockquote>
 
-
-## Before Contributing
-
-All contributions must begin with a GitHub Issue, unless the change is for small bug fixes, typo corrections, minor wording improvements, or simple type fixes that don't change functionality.
-**For features and contributions**:
-- First check the [Feature Requests discussions board](https://github.com/cline/cline/discussions/categories/feature-requests) for similar ideas
-- If your idea is new, create a new feature request  
-- Wait for approval from core maintainers before starting implementation
-- Once approved, feel free to begin working on a PR with the help of our community!
-
-**PRs without approved issues may be closed.**
-
-
 ## Deciding What to Work On
 
 Looking for a good first contribution? Check out issues labeled ["good first issue"](https://github.com/cline/cline/labels/good%20first%20issue) or ["help wanted"](https://github.com/cline/cline/labels/help%20wanted). These are specifically curated for new contributors and areas where we'd love some help!
 
 We also welcome contributions to our [documentation](https://github.com/cline/cline/tree/main/docs)! Whether it's fixing typos, improving existing guides, or creating new educational content - we'd love to build a community-driven repository of resources that helps everyone get the most out of Cline. You can start by diving into `/docs` and looking for areas that need improvement.
 
+If you're planning to work on a bigger feature, please create a [feature request](https://github.com/cline/cline/discussions/categories/feature-requests?discussions_q=is%3Aopen+category%3A%22Feature+Requests%22+sort%3Atop) first so we can discuss whether it aligns with Cline's vision.
+
 ## Development Setup
 
-
-### Local Development Instructions
-
-1. Clone the repository _(Requires [git-lfs](https://git-lfs.com/))_:
-    ```bash
-    git clone https://github.com/cline/cline.git
-    ```
-2. Open the project in VSCode:
-    ```bash
-    code cline
-    ```
-3. Install the necessary dependencies for the extension and webview-gui:
-    ```bash
-    npm run install:all
-    ```
-4. Launch by pressing `F5` (or `Run`->`Start Debugging`) to open a new VSCode window with the extension loaded. (You may need to install the [esbuild problem matchers extension](https://marketplace.visualstudio.com/items?itemName=connor4312.esbuild-problem-matchers) if you run into issues building the project.)
-
-
-
-
-### Creating a Pull Request
-
-1. Before creating a PR, generate a changeset entry:
-    ```bash
-    npm run changeset
-    ```
-   This will prompt you for:
-   - Type of change (major, minor, patch)
-     - `major` → breaking changes (1.0.0 → 2.0.0)
-     - `minor` → new features (1.0.0 → 1.1.0)
-     - `patch` → bug fixes (1.0.0 → 1.0.1)
-   - Description of your changes
-
-2. Commit your changes and the generated `.changeset` file
-
-3. Push your branch and create a PR on GitHub. Our CI will:
-   - Run tests and checks
-   - Changesetbot will create a comment showing the version impact
-   - When merged to main, changesetbot will create a Version Packages PR
-   - When the Version Packages PR is merged, a new release will be published
-4. Testing
-    - Run `npm run test` to run tests locally. 
-    - Before submitting PR, run `npm run format:fix` to format your code
-    - Run `npm run test:ci` to run tests locally
-
-### Extension
-
 1. **VS Code Extensions**
 
     - When opening the project, VS Code will prompt you to install recommended extensions
@@ -87,7 +29,6 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
 2. **Local Development**
     - Run `npm run install:all` to install dependencies
     - Run `npm run test` to run tests locally
-    - Run → Start Debugging or `>Debug: Select and Start Debugging` and wait for a new VS Code instance to open
     - Before submitting PR, run `npm run format:fix` to format your code
 
 3. **Linux-specific Setup**
@@ -132,6 +73,8 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
       xvfb
     ```
 
+    - Run `npm run test:ci` to run tests locally
+
 ## Writing and Submitting Code
 
 Anyone can contribute code to Cline, but we ask that you follow these guidelines to ensure your contributions can be smoothly integrated:
@@ -147,7 +90,7 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
     - Run `npm run lint` to check code style
     - Run `npm run format` to automatically format code
     - All PRs must pass CI checks which include both linting and formatting
-    - Address any warnings or errors from linter before submitting
+    - Address any ESLint warnings or errors before submitting
     - Follow TypeScript best practices and maintain type safety
 
 3. **Testing**

README.md

@@ -32,7 +32,7 @@ English | <a href="https://github.com/cline/cline/blob/main/locales/es/README.md
 
 Meet Cline, an AI assistant that can use your **CLI** a**N**d **E**ditor.
 
-Thanks to [Claude Sonnet's agentic coding capabilities](https://www.anthropic.com/claude/sonnet), Cline can handle complex software development tasks step-by-step. With tools that let him create & edit files, explore large projects, use the browser, and execute terminal commands (after you grant permission), he can assist you in ways that go beyond code completion or tech support. Cline can even use the Model Context Protocol (MCP) to create new tools and extend his own capabilities. While autonomous AI scripts traditionally run in sandboxed environments, this extension provides a human-in-the-loop GUI to approve every file change and terminal command, providing a safe and accessible way to explore the potential of agentic AI.
+Thanks to [Claude 3.7 Sonnet's agentic coding capabilities](https://www.anthropic.com/claude/sonnet), Cline can handle complex software development tasks step-by-step. With tools that let him create & edit files, explore large projects, use the browser, and execute terminal commands (after you grant permission), he can assist you in ways that go beyond code completion or tech support. Cline can even use the Model Context Protocol (MCP) to create new tools and extend his own capabilities. While autonomous AI scripts traditionally run in sandboxed environments, this extension provides a human-in-the-loop GUI to approve every file change and terminal command, providing a safe and accessible way to explore the potential of agentic AI.
 
 1. Enter your task and add images to convert mockups into functional apps or fix bugs with screenshots.
 2. Cline starts by analyzing your file structure & source code ASTs, running regex searches, and reading relevant files to get up to speed in existing projects. By carefully managing what information is added to context, Cline can provide valuable assistance even for large, complex projects without overwhelming the context window.
@@ -51,7 +51,7 @@ Thanks to [Claude Sonnet's agentic coding capabilities](https://www.anthropic.c
 
 ### Use any API and Model
 
-Cline supports API providers like OpenRouter, Anthropic, OpenAI, Google Gemini, AWS Bedrock, Azure, GCP Vertex, Cerebras and Groq. You can also configure any OpenAI compatible API, or use a local model through LM Studio/Ollama. If you're using OpenRouter, the extension fetches their latest model list, allowing you to use the newest models as soon as they're available.
+Cline supports API providers like OpenRouter, Anthropic, OpenAI, Google Gemini, AWS Bedrock, Azure, GCP Vertex, and Cerebras. You can also configure any OpenAI compatible API, or use a local model through LM Studio/Ollama. If you're using OpenRouter, the extension fetches their latest model list, allowing you to use the newest models as soon as they're available.
 
 The extension also keeps track of total tokens and API usage cost for the entire task loop and individual requests, keeping you informed of spend every step of the way.
 
@@ -87,7 +87,7 @@ All changes made by Cline are recorded in your file's Timeline, providing an eas
 
 ### Use the Browser
 
-With Claude Sonnet's new [Computer Use](https://www.anthropic.com/news/3-5-models-and-computer-use) capability, Cline can launch a browser, click elements, type text, and scroll, capturing screenshots and console logs at each step. This allows for interactive debugging, end-to-end testing, and even general web use! This gives him autonomy to fixing visual bugs and runtime issues without you needing to handhold and copy-pasting error logs yourself.
+With Claude 3.5 Sonnet's new [Computer Use](https://www.anthropic.com/news/3-5-models-and-computer-use) capability, Cline can launch a browser, click elements, type text, and scroll, capturing screenshots and console logs at each step. This allows for interactive debugging, end-to-end testing, and even general web use! This gives him autonomy to fixing visual bugs and runtime issues without you needing to handhold and copy-pasting error logs yourself.
 
 Try asking Cline to "test the app", and watch as he runs a command like `npm run dev`, launches your locally running dev server in a browser, and performs a series of tests to confirm that everything works. [See a demo here.](https://x.com/sdrzn/status/1850880547825823989)
 
@@ -141,6 +141,50 @@ For example, when working with a local web server, you can use 'Restore Workspac
 
 To contribute to the project, start with our [Contributing Guide](CONTRIBUTING.md) to learn the basics. You can also join our [Discord](https://discord.gg/cline) to chat with other contributors in the `#contributors` channel. If you're looking for full-time work, check out our open positions on our [careers page](https://cline.bot/join-us)!
 
+<details>
+<summary>Local Development Instructions</summary>
+
+1. Clone the repository _(Requires [git-lfs](https://git-lfs.com/))_:
+    ```bash
+    git clone https://github.com/cline/cline.git
+    ```
+2. Open the project in VSCode:
+    ```bash
+    code cline
+    ```
+3. Install the necessary dependencies for the extension and webview-gui:
+    ```bash
+    npm run install:all
+    ```
+4. Launch by pressing `F5` (or `Run`->`Start Debugging`) to open a new VSCode window with the extension loaded. (You may need to install the [esbuild problem matchers extension](https://marketplace.visualstudio.com/items?itemName=connor4312.esbuild-problem-matchers) if you run into issues building the project.)
+
+</details>
+
+<details>
+<summary>Creating a Pull Request</summary>
+
+1. Before creating a PR, generate a changeset entry:
+    ```bash
+    npm run changeset
+    ```
+   This will prompt you for:
+   - Type of change (major, minor, patch)
+     - `major` → breaking changes (1.0.0 → 2.0.0)
+     - `minor` → new features (1.0.0 → 1.1.0)
+     - `patch` → bug fixes (1.0.0 → 1.0.1)
+   - Description of your changes
+
+2. Commit your changes and the generated `.changeset` file
+
+3. Push your branch and create a PR on GitHub. Our CI will:
+   - Run tests and checks
+   - Changesetbot will create a comment showing the version impact
+   - When merged to main, changesetbot will create a Version Packages PR
+   - When the Version Packages PR is merged, a new release will be published
+
+</details>
+
+
 ## License
 
 [Apache 2.0 © 2025 Cline Bot Inc.](./LICENSE)

biome.jsonc

@@ -1,159 +0,0 @@
-{
-	"$schema": "https://biomejs.dev/schemas/2.1.4/schema.json",
-	"vcs": {
-		"enabled": true,
-		"clientKind": "git",
-		"useIgnoreFile": true,
-		"defaultBranch": "main"
-	},
-	"assist": {
-		"enabled": true,
-		"actions": {
-			"source": {
-				"organizeImports": "on",
-				"useSortedAttributes": "on"
-			}
-		}
-	},
-	"linter": {
-		"enabled": true,
-		"domains": {
-			"react": "recommended"
-		},
-		// Ideally we would want to turn on all the rules that are currently off,
-		// keeping them off currently to make sure only changes on the migrations
-		// are included in the initial PR before we apply the format and lint changes.
-		// TODO: turn on all rules that are currently off if applicable.
-		// TODO: Remove --diagnostic-level=error from CI commands.
-		"rules": {
-			"recommended": true,
-			"correctness": {
-				"useExhaustiveDependencies": "off",
-				"noUndeclaredVariables": "off",
-				"noEmptyPattern": "off",
-				"useJsxKeyInIterable": "off",
-				"noInnerDeclarations": "off",
-				"useHookAtTopLevel": "off",
-				"useYield": "off",
-				"noConstructorReturn": "off",
-				"noInvalidPositionAtImportRule": "off",
-				"noSwitchDeclarations": "off",
-				"noUnusedImports": "error"
-			},
-			"a11y": "off",
-			"style": {
-				"useNodejsImportProtocol": "off",
-				"useImportType": "off",
-				"useBlockStatements": "warn",
-				"useNamingConvention": "off",
-				"useThrowOnlyError": "info",
-				"useConsistentArrayType": "off",
-				"noParameterAssign": "off",
-				"useAsConstAssertion": "off",
-				"useDefaultParameterLast": "off",
-				"noNonNullAssertion": "off",
-				"useEnumInitializers": "off",
-				"useSelfClosingElements": "off",
-				"useSingleVarDeclarator": "off",
-				"useNumberNamespace": "off",
-				"noInferrableTypes": "off",
-				"useTemplate": "off",
-				"noUselessElse": "off"
-			},
-			"suspicious": {
-				"noDoubleEquals": "warn",
-				"noImplicitAnyLet": "info",
-				"noThenProperty": "off",
-				"noAsyncPromiseExecutor": "off",
-				"noImportAssign": "off",
-				"noExplicitAny": "off",
-				"noControlCharactersInRegex": "off",
-				"noShadowRestrictedNames": "off",
-				"noArrayIndexKey": "info",
-				"noAssignInExpressions": "warn"
-			},
-			"complexity": {
-				"noUselessConstructor": "off",
-				"useOptionalChain": "off",
-				"noBannedTypes": "off",
-				"useLiteralKeys": "off",
-				"noUselessCatch": "off",
-				"noUselessSwitchCase": "off",
-				"noStaticOnlyClass": "off"
-			},
-			"security": {
-				"noDangerouslySetInnerHtml": "warn"
-			}
-		}
-	},
-	"formatter": {
-		"enabled": true,
-		"indentStyle": "tab",
-		"indentWidth": 4,
-		"lineWidth": 130,
-		"lineEnding": "lf",
-		"formatWithErrors": true
-	},
-	"javascript": {
-		"formatter": {
-			"semicolons": "asNeeded",
-			"arrowParentheses": "always",
-			"bracketSameLine": true,
-			"bracketSpacing": true,
-			"jsxQuoteStyle": "double",
-			"quoteProperties": "asNeeded",
-			"trailingCommas": "all"
-		}
-	},
-	"json": {
-		"formatter": {
-			"trailingCommas": "none",
-			"expand": "always"
-		}
-	},
-	"files": {
-		"includes": [
-			"**",
-			"!**/dist/**",
-			"!**/dist-*/**",
-			"!**/out/**",
-			"!**/evals/**",
-			"!**/playwright/**",
-			"!**/test-results/**",
-			"!**/node_modules/**",
-			"!**/webview-ui/build/**",
-			"!**/generated/**",
-			"!**/proto/**"
-		]
-	},
-	"plugins": [
-		"src/dev/grit/process-env.grit"
-	],
-	"overrides": [
-		{
-			"includes": [
-				"**",
-				"!**/hosts/vscode/**",
-				"!**/test/**",
-				"!src/extension.ts"
-			],
-			"plugins": [
-				"src/dev/grit/vscode-api.grit"
-			]
-		},
-		{
-			"includes": [
-				"**",
-				"!src/core/storage/state-migrations.ts",
-				"!src/core/storage/FileContextTracker.ts",
-				"!src/core/context/context-tracking/FileContextTracker.ts",
-				"!src/common.ts",
-				"!src/core/storage/utils/state-helpers.ts",
-				"!src/extension.ts"
-			],
-			"plugins": [
-				"src/dev/grit/use-cache-service.grit"
-			]
-		}
-	]
-}

buf.yaml

@@ -1,21 +0,0 @@
-version: v2
-modules:
-    - path: proto
-      name: cline/cline/lint
-
-lint:
-    use:
-        - STANDARD
-
-    except: # Add exceptions for current patterns that contradict STANDARD settings
-        - RPC_PASCAL_CASE # rpcs are camel case (start with lowercase)
-        - RPC_REQUEST_RESPONSE_UNIQUE # request messages are not unique.
-        - RPC_REQUEST_STANDARD_NAME # request messages dont all end with Request
-        - RPC_RESPONSE_STANDARD_NAME # response messages dont all end with Response
-        - PACKAGE_VERSION_SUFFIX # package name does not contain version.
-        - ENUM_VALUE_PREFIX # enum values dont start with the enum name.
-        - ENUM_ZERO_VALUE_SUFFIX # first value does not have to be UNSPECIFIED.
-
-# breaking:
-#   use:
-#     - WIRE_JSON # Detect changes that break the json wire format (this is the minimum recommended level.)

docs/docs.json

@@ -57,27 +57,19 @@
 			{
 				"group": "Getting Started",
 				"pages": [
-					"getting-started/what-is-cline",
-					"getting-started/model-selection-guide",
+					"getting-started/for-new-coders",
 					"getting-started/installing-cline",
-					"getting-started/installing-cline-jetbrains",
+					"getting-started/installing-dev-essentials",
+					"getting-started/model-selection-guide",
+					"getting-started/our-favorite-tech-stack",
 					"getting-started/task-management",
 					"getting-started/understanding-context-management",
-					{
-						"group": "For New Coders",
-						"pages": [
-							"getting-started/for-new-coders",
-							"getting-started/installing-dev-essentials"
-						]
-					}
+					"getting-started/what-is-cline"
 				]
 			},
 			{
 				"group": "Improving Your Prompting Skills",
-				"pages": [
-					"prompting/prompt-engineering-guide",
-					"prompting/cline-memory-bank"
-				]
+				"pages": ["prompting/prompt-engineering-guide", "prompting/cline-memory-bank"]
 			},
 			{
 				"group": "Features",
@@ -88,8 +80,6 @@
 					"features/drag-and-drop",
 					"features/plan-and-act",
 					"features/slash-commands/workflows",
-					"features/focus-chain",
-					"features/auto-compact",
 					"features/editing-messages",
 					{
 						"group": "@ Mentions",
@@ -108,8 +98,7 @@
 							"features/slash-commands/new-task",
 							"features/slash-commands/new-rule",
 							"features/slash-commands/smol",
-							"features/slash-commands/report-bug",
-							"features/slash-commands/deep-planning"
+							"features/slash-commands/report-bug"
 						]
 					},
 					{
@@ -157,32 +146,18 @@
 				"group": "Provider Configuration",
 				"pages": [
 					"provider-config/anthropic",
-					"provider-config/claude-code",
-					{
-						"group": "AWS Bedrock",
-						"pages": [
-							"provider-config/aws-bedrock/api-key",
-							"provider-config/aws-bedrock/iam-credentials",
-							"provider-config/aws-bedrock/cli-profile"
-						]
-					},
+					"provider-config/aws-bedrock-with-credentials-authentication",
+					"provider-config/aws-bedrock-with-profile-authentication",
 					"provider-config/gcp-vertex-ai",
 					"provider-config/litellm-and-cline-using-codestral",
 					"provider-config/vscode-language-model-api",
 					"provider-config/xai-grok",
 					"provider-config/mistral-ai",
 					"provider-config/deepseek",
-					"provider-config/groq",
-					"provider-config/cerebras",
-					"provider-config/doubao",
-					"provider-config/fireworks",
-					"provider-config/zai",
 					"provider-config/ollama",
 					"provider-config/openai",
 					"provider-config/openai-compatible",
 					"provider-config/openrouter",
-					"provider-config/sap-aicore",
-					"provider-config/vercel-ai-gateway",
 					"provider-config/requesty"
 				]
 			},
@@ -194,18 +169,9 @@
 					"running-models-locally/ollama"
 				]
 			},
-			{
-				"group": "Troubleshooting",
-				"pages": [
-					"troubleshooting/terminal-quick-fixes",
-					"troubleshooting/terminal-integration-guide"
-				]
-			},
 			{
 				"group": "More Info",
-				"pages": [
-					"more-info/telemetry"
-				]
+				"pages": ["more-info/telemetry"]
 			}
 		]
 	},
@@ -216,19 +182,10 @@
 			"discord": "https://discord.gg/cline"
 		}
 	},
-	"anchors": [
-		{
-			"name": "What is Cline",
-			"icon": "house",
-			"url": "getting-started/what-is-cline"
-		}
-	],
 	"search": {
 		"prompt": "Search Cline documentation..."
 	},
 	"contextual": {
-		"options": [
-			"copy"
-		]
+		"options": ["copy"]
 	}
 }

docs/enterprise-solutions/cloud-provider-integration.mdx

@@ -14,8 +14,6 @@ Certain scenarios may warrant using local models, including handling highly sens
 
 #### [IAM Security Best Practices](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) (For administrators)
 
-#### [AWS Bedrock setup for API Keys](/provider-config/aws-bedrock-with-apikey-authentication)
-
 #### [AWS Bedrock setup for Legacy IAM (AWS Credentials)](/provider-config/aws-bedrock-with-credentials-authentication)
 
 #### [AWS Bedrock setup for SSO token (AWS Profile)](/provider-config/aws-bedrock-with-profile-authentication)

docs/exploring-clines-tools/new-task-tool.mdx

@@ -120,7 +120,7 @@ Example of context window usage over 50% with a 200K context window:
 # Context Window Usage
 
 105,000 / 200,000 tokens (53%)
-Model: anthropic/claude-sonnet-4 (200K context window)
+Model: anthropic/claude-3.7-sonnet (200K context window)
 \`\`\`
 
 **IMPORTANT**: When you see context window usage at or above 50%, you MUST:

docs/features/at-mentions/terminal-mentions.mdx

@@ -58,16 +58,3 @@ When you use the terminal mention in your message, here's what happens behind th
 6. The AI can now "see" the complete terminal output with all formatting preserved
 
 This process happens automatically whenever you use the terminal mention, giving the AI access to your command results, error messages, and other terminal output without you having to copy it manually.
-
-## Troubleshooting Terminal Issues
-
-If you're experiencing issues with terminal mentions or terminal integration in general (such as "Shell Integration Unavailable" or commands not showing output), please refer to our comprehensive [Terminal Integration Troubleshooting Guide](/troubleshooting/terminal-integration-guide).
-
-Common issues include:
-
--   Terminal mentions not capturing output
--   "Shell Integration Unavailable" messages in Cline chat
--   Commands executing but output not visible to Cline
--   Terminal integration working inconsistently
-
-The troubleshooting guide provides platform-specific solutions and detailed configuration steps to resolve these issues.

docs/features/auto-compact.mdx

@@ -1,75 +0,0 @@
----
-title: "Automatic Context Summarization"
-sidebarTitle: "Auto Compact"
----
-
-When your conversation approaches the model's context window limit, Cline automatically summarizes it to free up space and keep working. 
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/condensing.png"
-		alt="Auto-compact feature condensing conversation context"
-	/>
-</Frame>
-
-## How It Works
-
-Cline monitors token usage during your conversation. When you're getting close to the limit, he:
-
-1. Creates a comprehensive summary of everything that's happened
-2. Preserves all the technical details, code changes, and decisions
-3. Replaces the conversation history with the summary
-4. Continues exactly where he left off
-
-You'll see a summarization tool call when this happens, showing the total cost like any other api call in the chat view.
-
-## Why This Matters
-
-Previously, Cline would truncate older messages when hitting context limits. This meant losing important context from earlier in the conversation.
-
-Now with summarization:
-- All technical decisions and code patterns are preserved
-- File changes and project context remain intact
-- Cline remembers everything he's done
-- You can work on much larger projects without interruption
-
-<Tip>
-Context Summarization synergizes beautifully with [Focus Chain](/features/focus-chain). When Focus Chain is enabled, todo lists persist across summarizations. This means Cline can work on long-horizon tasks that span multiple context windows while staying on track with the todo list guiding him through each reset.
-</Tip>
-
-## Technical Details
-
-The summarization happens through your configured API provider using the same model you're already using. It leverages prompt caching to minimize costs.
-
-1. Cline uses a [summarization prompt](https://github.com/cline/cline/blob/main/src/core/prompts/contextManagement.ts) to request a summary of the conversation.
-
-2. Once the summary is generated, Cline replaces the conversation history with a [continuation prompt](https://github.com/cline/cline/blob/main/src/core/prompts/contextManagement.ts#L69) that asks Cline to keep working and provides the summary as context.
-
-Different models have different context window thresholds for when auto-summarization kicks in. You can see how thresholds are determined in [context-window-utils.ts](https://github.com/cline/cline/blob/main/src/core/context/context-management/context-window-utils.ts). 
-
-## Cost Considerations
-
-Summarization leverages your existing prompt cache from the conversation, so it costs about the same as any other tool call.
-
-Since most input tokens are already cached, you're primarily paying for the summary generation (output tokens), making it very cost-effective.
-
-## Restoring Context with Checkpoints
-
-You can use [checkpoints](/features/checkpoints) to restore your task state from before a summarization occurred. This means you never truly lose context - you can always roll back to previous versions of your conversation. 
-
-<Note>
-  Editing a message before a summarization tool call will work similarly to a checkpoint, allowing you to restore the conversation to that point.
-</Note>
-
-## Next Generation Model Support
-
-Auto Compact uses advanced LLM-based summarization which we've found works significantly better for next-generation models. We currently support this feature for the following models:
-
-- **Claude 4 series**
-- **Gemini 2.5 series**
-- **GPT-5**
-- **Grok 4**
-
-<Note>
-When using other models, Cline automatically falls back to the standard rule-based context truncation method, even if Auto Compact is enabled in settings.
-</Note>

docs/features/cline-rules.mdx

@@ -11,19 +11,7 @@ You can create a rule by clicking the `+` button in the Rules tab. This will ope
 Once you save the file:
 
 -   Your rule will be stored in the `.clinerules/` directory in your project (if it's a Workspace Rule)
--   Or in the Global Rules directory (if it's a Global Rule):
-
-### Global Rules Directory Location
-
-The location of your Global Rules directory depends on your operating system:
-
-| Operating System | Default Location | Notes |
-|------------------|------------------|-------|
-| **Windows** | `Documents\Cline\Rules` | Uses system Documents folder |
-| **macOS** | `~/Documents/Cline/Rules` | Uses user Documents folder |
-| **Linux/WSL** | `~/Documents/Cline/Rules` | May fall back to `~/Cline/Rules` on some systems |
-
-> **Note for Linux/WSL users**: If you don't find your global rules in `~/Documents/Cline/Rules`, check `~/Cline/Rules` as the location may vary depending on your system configuration and whether the Documents directory exists.
+-   Or in the `Documents/Cline/Rules` directory (if it's a Global Rule).
 
 You can also have Cline create a rule for you by using the [`/newrule` slash command](/features/slash-commands/new-rule) in the chat.
 

docs/features/commands-and-shortcuts/terminal-integration.mdx

@@ -74,25 +74,8 @@ This approach ensures that all terminal output, including colors and formatting,
 
 -   **Select specific output when needed**: By default, the integration captures all terminal content, but you can also select specific lines before right-clicking to focus on just the relevant output.
 
--   **Combine terminal outputs with file mentions**: After sending terminal output to Cline, you can enhance your question by mentioning relevant files using the @ mentions feature.
+-   **Combine with file mentions**: After sending terminal output to Cline, you can enhance your question by mentioning relevant files using the @ mentions feature.
 
--   **Contextualize build & test outputs with the terminal**: Terminal integration is particularly useful for understanding complex build errors or test failures that span multiple lines.
+-   **Use for build and test output**: Terminal integration is particularly useful for understanding complex build errors or test failures that span multiple lines.
 
 Next time you're staring at a cryptic error message in your terminal, try using Cline's terminal integration instead of copying and pasting. You'll get more accurate help because Cline can see the complete terminal context with proper formatting.
-
-## Troubleshooting Terminal Issues
-
-If you're experiencing issues with terminal integration, such as "Shell Integration Unavailable" or commands not showing output, please refer to our comprehensive [Terminal Integration Troubleshooting Guide](/troubleshooting/terminal-integration-guide).
-
-The troubleshooting guide covers:
-
--   Common terminal integration issues and quick fixes
--   Platform-specific solutions for Windows, macOS, and Linux
--   Shell-specific configurations for zsh, bash, PowerShell, and more
--   Advanced debugging techniques
--   Terminal settings optimization
-
-<Tip>
-	**Quick Fix**: Most terminal issues can be resolved by switching to bash in the Cline settings and increasing the shell
-	integration timeout to 10 seconds.
-</Tip>

docs/features/drag-and-drop.mdx

@@ -5,28 +5,10 @@ sidebarTitle: "Drag & Drop"
 
 Dragging and dropping files into Cline is a quick way to add images, code, and other files to your conversations.
 
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/dran-n-drop.gif"
-		alt="Dragging and dropping files into Cline chat"
-	/>
-</Frame>
-
 <Note>Due to VS Code quirks, to drag and drop files into the Cline chat input, you need to hold `Shift` while dragging.</Note>
 
 Dragging and dropping workspace files into Cline will automatically create a [file mention](/features/at-mentions/file-mentions). This allows you to reference the file in your conversation without needing to type out the path.
 
-### Dragging from Finder/File Explorer
-
-You can drag files directly from your system's file manager into Cline:
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/drag-n-drop-finder.gif"
-		alt="Dragging files from Finder into Cline"
-	/>
-</Frame>
-
 ### Supported File Types
 
-Cline supports dragging external images, pdfs, csv, excel, and other text files from your file system, as well as files from your workspace.
+Cline supports dragging external images from your file system, as well as files from your workspace.

docs/features/focus-chain.mdx

@@ -1,303 +0,0 @@
----
-title: "Focus Chain"
-sidebarTitle: "Focus Chain"
----
-
-Focus Chain is a task management enhancement feature in Cline that provides automatic todo list management with real-time progress tracking throughout your tasks. 
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/2dos.gif"
-		alt="Focus Chain todo list management with real-time progress tracking"
-	/>
-</Frame>
-
-This enables Cline to work on long-horizon tasks, seamlessly managing the context sent to LLMs, and keeping Cline on track across many context window resets.
-
-<Tip>
-  Focus Chain works particularly well with Cline's [Deep Planning slash command](/features/slash-commands/deep-planning), providing seamless progress tracking for implementation tasks created through the [planning process](/features/plan-and-act).
-</Tip>
-
-## Key Features
-
-### Automatic Todo List Generation
-
-Cline analyzes your task and automatically creates a comprehensive todo list with:
-- Clear, actionable items in markdown checklist format
-- Logical breakdown of complex tasks into manageable steps
-- Real-time updates as work progresses
-
-### User-Editable Todo Lists
-
-Todo lists are stored as editable markdown files:
-- Direct editing through your preferred markdown editor
-- Automatic detection of changes you make
-- Seamless integration back into Cline's workflow
-- Quick access through the edit button in the task header
-
-### Visual Progress Tracking
-
-The task header displays clear progress indicators:
-- **Step counters** showing current progress (e.g., "3/8")
-- **Completed items** clearly marked with checkmarks
-- **Current work** highlighted with indicators
-- **Expandable view** to see the full todo list
-
-### Smart Reminder System
-
-Configurable reminders ensure todo lists stay current:
-- Default reminder every 6 messages (customizable 1-100)
-- Automatic prompts when switching from Plan Mode to Act Mode
-- User-triggered updates when todo lists are manually edited
-
-
-## Getting Started
-
-<Steps>
-  <Step title="Open Cline Settings">
-      - Click the gear icon in the Cline sidebar
-      - Navigate to the "Features" section
-  </Step>
-  <Step title="Enable Focus Chain">
-      - Check "Enable Focus Chain"
-      - Optionally adjust "Remind Cline Interval" (default: 6 messages)
-  </Step>
-  <Step title="Start a New Task">
-      - Begin a new task
-      - Cline will automatically start creating and managing todo lists
-  </Step>
-</Steps>
-
-| Setting | Default | Range | Description |
-|---------|---------|-------|-------------|
-| Enable Focus Chain | Disabled | On/Off | Enables enhanced task progress tracking |
-| Remind Cline Interval | 6 | 1-100 messages | How often Cline updates the todo list |
-
-## Usage Examples
-
-#### 1. Task Initiation
-
-When you start a new task with Focus Chain enabled:
-
-``` markdown User Request
-User: "Create a user authentication system for my React app"
-
-Cline: [Analyzes request and creates todo list]
-```
-
-#### 2. Todo List Created
-
-Cline creates a comprehensive plan for the task, stored in a markdown file:
-
-```markdown Todo List Created
-- [ ] Set up project structure
-- [ ] Install authentication dependencies
-- [ ] Create user registration component
-- [ ] Implement login functionality
-- [ ] Add password validation
-- [ ] Set up user database schema
-- [ ] Write authentication tests
-- [ ] Deploy to staging environment
-```
-
-#### 3. Progress Tracking
-
-As Cline works, the task header shows real-time progress:
-
-```markdown Todo List Header
-[3/8] Implement login functionality     ⌄
-```
-
-Click to expand and see the full list:
-
-```markdown Full Todo List
-✓ Set up project structure
-✓ Install authentication dependencies
-✓ Create user registration component
-○ Implement login functionality  ← Currently working
-○ Add password validation
-○ Set up user database schema
-○ Write authentication tests
-○ Deploy to staging environment
-```
-
-#### 4. User Editing
-
-Need to tweak the todo list? No problem.
-
-<Steps>
-  <Step title="Open the todo list">
-    Click the edit button in the expanded todo view
-  </Step>
-  <Step title="Edit the markdown file">
-    A markdown file opens in your editor:
-
-    ```markdown Editing Todo List
-    # Focus Chain Todo List for Task abc123
-
-    <!-- Edit this markdown file to update your focus chain todo list -->
-    <!-- Use - [ ] for incomplete items and - [x] for completed items -->
-
-    - [x] Set up project structure
-    - [x] Install authentication dependencies (e.g., Firebase Auth)
-    - [x] Create user registration component
-    - [ ] Implement login functionality
-    - [ ] Add password reset feature
-    - [ ] Set up protected routes
-    - [ ] Implement logout functionality
-    - [ ] Add user profile page
-    - [ ] Write authentication tests
-    - [ ] Deploy to staging environment
-
-    <!-- Save this file to update the task's todo list -->
-    ```
-  </Step>
-  <Step title="Make your changes">
-    Add, remove, or reorder items as needed
-  </Step>
-  <Step title="Save the file">
-    Cline automatically detects and uses your updates
-  </Step>
-</Steps>
-
-## File Structure
-
-### Todo List Storage
-
-Todo lists are stored as markdown files in your task directory:
-
-``` markdown
-<VSCode Global Storage>/
-  tasks/
-    <taskId>/
-      focus_chain_taskid_<taskId>.md
-      ... other task files
-```
-
-### Markdown Format
-
-Todo files use standard markdown checklist syntax:
-
-```markdown Example Todo Syntax
-# Focus Chain Todo List for Task abc123
-
-<!-- Edit this markdown file to update your focus chain todo list -->
-<!-- Use the format: - [ ] for incomplete items and - [x] for completed items -->
-
-- [x] Set up project structure
-- [x] Install authentication dependencies
-- [ ] Create user registration component
-- [ ] Implement login functionality
-- [ ] Add password validation
-- [ ] Set up user database schema
-- [ ] Write authentication tests
-- [ ] Deploy to staging environment
-
-<!-- Save this file and the todo list will be updated in the task -->
-```
-
-
-## Integration with Plan/Act Mode
-
-Focus Chain works seamlessly with Cline's [Plan/Act mode](/features/plan-and-act):
-
-- **Plan Mode**: Optional todo lists for presenting concrete steps
-- **Act Mode**: Automatic todo creation when switching from Plan Mode
-
-<Tip>
-  For complex projects, start in Plan Mode to discuss and refine your approach before switching to Act Mode for implementation.
-</Tip>
-
-## Best Practices
-
-<AccordionGroup>
-  <Accordion title="For Effective Todo Lists">
-    1. **Start with Clear Requests**
-      - Provide detailed initial task descriptions
-      - Include specific requirements and constraints
-      - Mention any preferred technologies or approaches
-
-    2. **Review Generated Lists**
-      - Check that Cline's breakdown aligns with your expectations
-      - Verify that all important steps are included
-      - Ensure the order makes sense for your project
-
-    3. **Edit When Needed**
-      - Add missing steps you identify
-      - Remove unnecessary items
-      - Reorder steps for better workflow
-      - Add more specific details to general items
-  </Accordion>
-  <Accordion title="For Complex Projects">
-    1. **Use Plan Mode First**
-      - Discuss the approach before implementation
-      - Refine requirements through conversation
-      - Switch to Act Mode when ready to begin work
-
-    2. **Break Down Large Tasks**
-      - Split complex projects into smaller, manageable tasks
-      - Create separate todo lists for different components
-      - Focus on one major area at a time
-
-    3. **Regular Reviews**
-      - Check progress periodically during long tasks
-      - Update todo lists as requirements evolve
-      - Communicate changes to Cline through edits
-  </Accordion>
-  <Accordion title="For Collaboration">
-    1. **Share Todo Files**
-      - Todo markdown files can be shared with team members
-      - Include in version control for project documentation
-      - Use as basis for project planning discussions
-
-    2. **Consistent Format**
-      - Follow the standard markdown checklist format
-      - Keep item descriptions clear and actionable
-      - Use consistent terminology across todo lists
-  </Accordion>
-</AccordionGroup>
-
-
-## Troubleshooting
-
-Having issues? Try these quick fixes:
-
-<AccordionGroup>
-  <Accordion title="Todo list not updating?">
-    - Check that Focus Chain is enabled in settings
-    - Focus Chain may not work as well with smaller, less capable models
-    - Ensure file permissions are correct in the task directory
-  </Accordion>
-  <Accordion title="Can't edit todo file?">
-    - Verify your editor supports markdown
-    - Check VSCode has write permissions for the directory
-  </Accordion>
-  <Accordion title="Progress not displaying?">
-    - Ensure todo items use correct syntax (`- [ ]` and `- [x]`)
-    - Verify the markdown file is properly formatted
-  </Accordion>
-</AccordionGroup>
-
-Still stuck? Use the [/reportbug](/features/slash-commands/report-bug) command in Cline to get help.
-
-## Technical Details (for the curious)
-
-<AccordionGroup>
-  <Accordion title="File Monitoring">
-    - Real-time file watching detects changes to todo markdown files
-    - Automatic synchronization between file edits and UI updates
-    - Graceful handling of file creation, modification, and deletion
-  </Accordion>
-  <Accordion title="Progress Calculation">
-    - Dynamic counting of completed vs. total todo items
-    - Support for both `- [x]` and `- [X]` completion syntax
-    - Unicode symbols (✓, ○) for enhanced visual display
-  </Accordion>
-  <Accordion title="Privacy Considerations">
-    - Todo lists stored locally in VSCode workspace
-    - No todo content transmitted to external services
-    - Usage telemetry (can be disabled in settings)
-  </Accordion>
-</AccordionGroup>
-
-Focus Chain turns Cline into your personal project manager, keeping you on track and your tasks organized. Give it a try on your next project!

docs/features/slash-commands/deep-planning.mdx

@@ -1,160 +0,0 @@
----
-title: "Deep Planning Command"
-sidebarTitle: "/deep-planning"
----
-
-`/deep-planning` transforms Cline into a meticulous architect who investigates your codebase, asks clarifying questions, and creates a comprehensive implementation plan before writing a single line of code. 
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/deep-planning.png"
-		alt="Deep Planning command in action showing investigation and planning process"
-	/>
-</Frame>
-
-When you use `/deep-planning`, Cline follows a four-step process that mirrors how senior developers approach complex features: thorough investigation, discussion & clarification of requirements, detailed planning, and structured task creation with progress tracking.
-
-## The Four-Step Process
-
-### Step 1: Silent Investigation
-
-Cline becomes a detective, silently exploring your codebase to understand its structure, patterns, and constraints. He examines source files, analyzes import patterns, discovers class hierarchies, and identifies technical debt markers. No commentary, no narration - just focused research.
-
-During this phase, Cline runs commands like:
-- Finding all class and function definitions across your codebase
-- Analyzing import patterns to understand dependencies
-- Discovering project structure and file organization
-- Identifying TODOs and technical debt
-
-### Step 2: Discussion and Questions
-
-Once Cline understands your codebase, he asks targeted questions that will shape the implementation. These aren't generic questions - they're specific to your project and the feature you're building.
-
-Questions might cover:
-- Clarifying ambiguous requirements
-- Choosing between equally valid implementation approaches
-- Confirming assumptions about system behavior
-- Understanding preferences for technical decisions
-
-### Step 3: Implementation Plan Document
-
-Cline creates a structured markdown document (`implementation_plan.md`) that serves as your implementation blueprint. This isn't a vague outline - it's a detailed specification with exact file paths, function signatures, and implementation order.
-
-The plan includes eight comprehensive sections:
-- **Overview**: The goal and high-level approach
-- **Types**: Complete type definitions and data structures
-- **Files**: Exact files to create, modify, or delete
-- **Functions**: New and modified functions with signatures
-- **Classes**: Class modifications and inheritance details
-- **Dependencies**: Package requirements and versions
-- **Testing**: Validation strategies and test requirements
-- **Implementation Order**: Step-by-step execution sequence
-
-### Step 4: Implementation Task Creation
-
-Cline creates a new task that references the plan document and includes trackable implementation steps. The task comes with specific commands to read each section of the plan, ensuring the implementing agent (whether that's you or Cline in Act Mode) can navigate the blueprint efficiently.
-
-<Tip>
-  Deep Planning works beautifully with [Focus Chain](/features/focus-chain). The implementation steps automatically become a todo list with real-time progress tracking, keeping complex projects organized and on track.
-</Tip>
-
-## Using Deep Planning
-
-Start a deep planning session by typing `/deep-planning` followed by your feature description:
-
-```
-/deep-planning Add user authentication with JWT tokens and role-based access control
-```
-
-Cline will begin his investigation immediately. You'll see him reading files and running commands to understand your codebase. Once he's gathered enough context, he'll engage you in discussion before creating the plan.
-
-## Example Workflow
-
-Here's how I use `/deep-planning` for a real feature:
-
-<Steps>
-  <Step title="Initiate Planning">
-    I type `/deep-planning implement a caching layer for API responses`
-  </Step>
-  <Step title="Silent Investigation">
-    Cline explores my codebase, examining:
-    - Current API structure and endpoints
-    - Existing data flow patterns
-    - Database queries and performance bottlenecks
-    - Configuration and environment setup
-  </Step>
-  <Step title="Targeted Discussion">
-    Cline asks me:
-    - "Should we use Redis or in-memory caching?"
-    - "What's the acceptable cache staleness for user data?"
-    - "Do you need cache invalidation webhooks?"
-  </Step>
-  <Step title="Plan Creation">
-    Cline generates `implementation_plan.md` with:
-    - Cache service class specifications
-    - Redis connection configuration
-    - Modified API endpoints with caching logic
-    - Cache key generation strategies
-    - TTL configurations for different data types
-  </Step>
-  <Step title="Task Generation">
-    Cline creates a new task with:
-    - Reference to the implementation plan
-    - Commands to read specific sections
-    - Trackable todo items for each implementation step
-    - Request to switch to Act Mode for execution
-  </Step>
-</Steps>
-
-## Integration with Plan/Act Mode
-
-Deep Planning is designed to work seamlessly with [Plan/Act Mode](/features/plan-and-act):
-
-- Use `/deep-planning` in Plan Mode for the investigation and planning phases
-- The generated task requests switching to Act Mode for implementation
-- Focus Chain automatically tracks progress through the implementation steps
-
-This separation ensures planning stays focused on architecture while implementation stays focused on execution.
-
-## Best Practices
-
-### When to Use Deep Planning
-
-Use `/deep-planning` for:
-- Features touching multiple parts of your codebase
-- Architectural changes requiring careful coordination
-- Complex integrations with external services
-- Refactoring efforts that need systematic execution
-- Any feature where you'd normally spend time whiteboarding
-
-### Making the Most of Investigation
-
-Let Cline complete his investigation thoroughly. The quality of the plan directly correlates with how well he understands your codebase. If you have specific areas he should examine, mention them in your initial request.
-
-### Reviewing the Plan
-
-Always review `implementation_plan.md` before starting implementation. The plan is comprehensive but not immutable - you can edit it directly if needed. Think of it as a collaborative document between you and Cline.
-
-### Tracking Progress
-
-With Focus Chain enabled, your implementation progress displays in the task header. Each completed step gets checked off automatically as Cline works through the plan, giving you real-time visibility into complex implementations.
-
-## Inspiration
-
-I use `/deep-planning` whenever I'm about to build something that would normally require a design document. Recent examples from my workflow:
-
-- **Migrating authentication systems**: Deep Planning mapped every endpoint, identified all authentication touchpoints, and created a migration plan that avoided breaking changes.
-
-- **Adding real-time features**: The plan covered WebSocket integration, event handling, state synchronization, and fallback mechanisms for disconnections.
-
-- **Database schema refactoring**: Cline identified all affected queries, created migration scripts, and planned the rollout to minimize downtime.
-
-- **API versioning implementation**: The plan detailed route changes, backward compatibility layers, deprecation notices, and client migration paths.
-
-The power of `/deep-planning` is that it forces thoughtful architecture before implementation. It's like having a senior developer review your approach before you write code, except that developer has perfect knowledge of your entire codebase.
-
-<Note>
-  Deep Planning requires models with strong reasoning capabilities. It works best with the latest generation of models, like GPT-5, Claude 4, Gemini 2.5, or Grok 4. Smaller models may struggle with the comprehensive analysis required.
-</Note>
-
-For simpler tasks that don't require extensive planning, consider using [/newtask](/features/slash-commands/new-task) to create focused tasks with context, or jump straight into implementation if the path forward is clear.

docs/getting-started/for-new-coders.mdx

@@ -3,9 +3,9 @@ title: "For New Coders"
 description: "Welcome to Cline, your AI-powered coding companion! This guide will help you quickly set up your development environment and begin your coding journey with ease."
 ---
 
-> **Tip:** If you're completely new to coding, take your time with each step. There's no rush — Cline is here to guide you!
+> 💡 **Tip:** If you're completely new to coding, take your time with each step. There's no rush — Cline is here to guide you!
 
-### Getting Started
+### 🚀 Getting Started
 
 Before you jump into coding, make sure you have these essentials ready:
 
@@ -15,9 +15,9 @@ A popular, free, and powerful code editor.
 
 -   [<u>Download VS Code</u>](https://code.visualstudio.com/)
 
-**Recommended YouTube Tutorial:** [<u>How to Install VS Code</u>](https://www.youtube.com/watch?v=MlIzFUI1QGA)
+📺 **Recommended YouTube Tutorial:** [<u>How to Install VS Code</u>](https://www.youtube.com/watch?v=MlIzFUI1QGA)
 
-> **Pro Tip:** Install VS Code in your Applications folder (macOS) or Program Files (Windows) for easy access from your dock or start menu.
+> ✅ **Pro Tip:** Install VS Code in your Applications folder (macOS) or Program Files (Windows) for easy access from your dock or start menu.
 
 #### 2. **Organize Your Projects**
 
@@ -31,7 +31,7 @@ Inside your `Cline` folder, structure projects clearly:
 -   `Documents/Cline/workout-app` _(e.g., for a fitness tracking app)_
 -   `Documents/Cline/portfolio-website` _(e.g., to showcase your work)_
 
-> **Tip:** Keeping your projects organized from the start will save you time and confusion later!
+> 💡 **Tip:** Keeping your projects organized from the start will save you time and confusion later!
 
 #### 3. **Install the Cline VS Code Extension**
 
@@ -39,9 +39,9 @@ Enhance your coding workflow by installing the Cline extension directly within V
 
 -   Get Started with Cline Extension Tutorial
 
-**Recommended YouTube Tutorial:** [<u>How To Install Extensions in VS Code</u>](https://www.youtube.com/watch?v=E7trgwZa-mk)
+📺 **Recommended YouTube Tutorial:** [<u>How To Install Extensions in VS Code</u>](https://www.youtube.com/watch?v=E7trgwZa-mk)
 
-> **Pro Tip:** After installing, reload VS Code to ensure the extension is activated properly.
+> ✅ **Pro Tip:** After installing, reload VS Code to ensure the extension is activated properly.
 
 #### 4. **Essential Development Tools**
 
@@ -51,9 +51,9 @@ Basic software required for coding efficiently:
 -   Node.js
 -   Git
 
-[<u>Follow our detailed guide on Installing Essential Development Tools with step-by-step help from Cline.</u>](https://docs.cline.bot/getting-started/installing-dev-essentials#installing-dev-essentials)
+👉 [<u>Follow our detailed guide on Installing Essential Development Tools with step-by-step help from Cline.</u>](https://docs.cline.bot/getting-started/installing-dev-essentials#installing-dev-essentials)
 
-**Recommended YouTube Tutorials for Manual Installation:**
+📺 **Recommended YouTube Tutorials for Manual Installation:**
 
 -   **For macOS:**
     -   [<u>Install Homebrew on Mac</u>](https://www.youtube.com/watch?v=hwGNgVbqasc)
@@ -63,6 +63,6 @@ Basic software required for coding efficiently:
     -   [<u>Install Git on Windows 10/11 (2024)</u>](https://www.youtube.com/watch?v=yjxv1HuRQy0)
     -   [<u>Install Node.js in Windows 10/11</u>](https://www.youtube.com/watch?v=uCgAuOYpJd0)
 
-> **Note:** If you run into permission issues during installation, try running your terminal or command prompt as an administrator.
+> ⚠️ **Note:** If you run into permission issues during installation, try running your terminal or command prompt as an administrator.
 
-You're all set! Dive in and start coding smarter and faster with **Cline**.
+🎉 You're all set! Dive in and start coding smarter and faster with **Cline**.

docs/getting-started/installing-cline-jetbrains.mdx

@@ -1,135 +0,0 @@
----
-title: "Installing Cline for JetBrains"
-description: "Get Cline running in your favorite JetBrains IDE with the same powerful AI assistance you know from VSCode."
----
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/jetbrains-logo.svg"
-		alt="JetBrains logo"
-		style={{ width: "200px", height: "auto", margin: "0 auto 20px auto", display: "block" }}
-	/>
-</Frame>
-
-Cline for JetBrains works almost identically to Cline in VSCode. All the core features work properly: diff editing, using tools, logging in with different providers, MCP servers, Cline rules and workflows, and more.
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/jetbrains-demo-hifi.gif"
-		alt="Cline running in JetBrains IDE showing AI assistance"
-	/>
-</Frame>
-
-<Note>Cline for JetBrains is currently in alpha. While all core features are functional, you may encounter occasional issues.</Note>
-
-## Installation
-
-Since Cline for JetBrains is currently in alpha, it's not yet available on the JetBrains Marketplace. You'll need to install it manually from a downloaded file:
-
-### Manual Installation from Disk
-
-1. **Download the Plugin:**
-   - Go to [https://plugins.jetbrains.com/plugin/28247-cline/versions/stable](https://plugins.jetbrains.com/plugin/28247-cline/versions/stable)
-   - Click **Download** to get the `.zip` file
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/cline-jetbrains-marketplace-download.png"
-		alt="JetBrains plugin marketplace showing Cline download page"
-	/>
-</Frame>
-
-2. **Install from Disk:**
-   - Open your JetBrains IDE
-   - Go to **IntelliJ IDEA** (or whichever IDE you are in) → **Settings**
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/cline-jetbrains-settings.png"
-		alt="JetBrains IDE settings dialog"
-	/>
-</Frame>
-
-   - Select **Plugins** from the left sidebar
-   - Click the gear icon ⚙️ and select **Install Plugin from Disk...**
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/cline-jetbrains-install-disk.png"
-		alt="JetBrains IDE settings showing Install Plugin from Disk option"
-	/>
-</Frame>
-
-   - Select the downloaded `.zip` file
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/cline-jetbrains-zip-file.png"
-		alt="File selection dialog showing Cline plugin zip file"
-	/>
-</Frame>
-
-   - Restart your IDE when prompted
-
-## Getting Started with Cline
-
-After installation, you'll find Cline in your IDE:
-
-1. **Open Cline:**
-   - Look for the Cline tool window (usually on the right side)
-   - Or go to **View** → **Tool Windows** → **Cline**
-
-2. **Sign In (optional, BYOK is also available):**
-   - Click **Sign In** in the Cline panel
-   - You'll be taken to [app.cline.bot](https://app.cline.bot) to create your account
-   - No credit card needed to get started with free credits
-
-3. **Start Coding:**
-   - Try this first prompt: "Hey Cline! Can you help me create a simple Hello World program in this project?"
-
-## Key Differences from VSCode
-
-While Cline for JetBrains includes all the same powerful features, there's one important difference to be aware of:
-
-**Terminal Integration:** The terminal inside JetBrains isn't integrated with Cline the same way it is in VSCode. Cline can execute commands, but the output will only appear in the webview if you expand the **Command Output** section.
-
-This means:
-- Commands still run successfully
-- You can see the output by clicking to expand Command Output in the chat
-- Terminal commands work the same way, just with a different display
-
-## What Works
-
-Everything else works exactly like VSCode:
-
-- **Diff Editing:** Cline can read, write, and edit files with the same precision
-- **Tool Usage:** All of Cline's tools (file operations, web browsing, etc.) work identically  
-- **API Providers:** Connect to Anthropic, OpenAI, local models, and more
-- **MCP Servers:** Full support for Model Context Protocol servers
-- **Cline Rules:** Custom instructions and workflows work the same way
-- **@ Mentions:** Reference files, folders, problems, and more
-- **Drag & Drop:** Add files and images to conversations
-
-## Tips for JetBrains Users
-
-- **Project Context:** Cline automatically understands your project structure, just like in VSCode
-- **Language Support:** Cline works with any language your JetBrains IDE supports
-- **Debugging Help:** Share error messages and stack traces directly in the chat
-- **Code Review:** Ask Cline to review your code changes before committing
-
-## Troubleshooting
-
-If you don't see the Cline tool window after installation:
-- Restart your IDE completely
-- Check **View** → **Tool Windows** → **Cline**
-- Ensure the plugin is enabled in **Settings** → **Plugins**
-
-Having other issues? Join our [Discord community](https://discord.gg/cline) for help from the team and other users.
-
-## Next Steps
-
-Now that you have Cline installed, you might want to:
-- Learn about [model selection](/getting-started/model-selection-guide) to choose the best AI provider
-- Explore [@ mentions](/features/at-mentions/overview) to reference files and context efficiently  
-- Set up [Cline rules](/features/cline-rules) for your specific workflow
-- Try [MCP servers](/mcp/mcp-overview) to extend Cline's capabilities

docs/getting-started/installing-cline.mdx

@@ -9,13 +9,13 @@ description: "Cline is a VS Code extension that brings AI-powered coding assista
 -   **VS Code Marketplace (Recommended):** Fastest method for standard VS Code and Cursor users.
 -   **Open VSX Registry:** For VS Code-compatible editors like VSCodium.
 
-### VS Code Marketplace: Step-by-Step Setup
+### 🛠️ VS Code Marketplace: Step-by-Step Setup
 
 Follow these steps to get Cline up and running:
 
 1.  **Open VS Code:** Launch the VS Code application.
 
-    > **Note:** If VS Code shows "Running extensions might...", click "Allow".
+    > ⚠️ **Note:** If VS Code shows "Running extensions might...", click "Allow".
 
 2.  **Open Your Cline Folder:** In VS Code, open the Cline folder you created in Documents.
 3.  **Navigate to Extensions:** Click on the Extensions icon in the Activity Bar on the side of VS Code (`Ctrl + Shift + X` or `Cmd + Shift + X`).
@@ -34,9 +34,9 @@ Follow these steps to get Cline up and running:
     - Or, use the command palette (`Ctrl/Cmd + Shift + P`) and type "Cline: Open In New Tab" for a better view.
 3. **Troubleshooting:** If you don't see the Cline icon, try restarting VS Code.
 
-> **Pro Tip:** You should see the Cline chat window appear in your VS Code editor!
+> ✅ **Pro Tip:** You should see the Cline chat window appear in your VS Code editor!
 
-### Open VSX Registry
+### 🌐 Open VSX Registry
 
 For VS Code-compatible editors without Marketplace access (like VSCodium and Windsurf):
 
@@ -46,7 +46,7 @@ For VS Code-compatible editors without Marketplace access (like VSCodium and Win
 4. Select "Cline" by saoudrizwan and click **Install**.
 5. Reload if prompted.
 
-### Creating Your Cline Account
+### 👤 Creating Your Cline Account
 
 Now that you have Cline installed, let's get you set up with your account:
 
@@ -61,7 +61,7 @@ Now that you have Cline installed, let's get you set up with your account:
     - Google Gemini 2.0 Flash
     - And more — all through your Cline account.
 
-### Your First Interaction with Cline
+### 💻 Your First Interaction with Cline
 
 You're ready to start building! Copy and paste this prompt into the Cline chat window:
 
@@ -69,15 +69,15 @@ You're ready to start building! Copy and paste this prompt into the Cline chat w
 Hey Cline! Could you help me create a new project folder called "hello-world" in my Cline directory and make a simple webpage that says "Hello World" in big blue text?
 ```
 
-> **Pro Tip:** Cline will help you create the project folder and set up your first webpage!
+> ✅ **Pro Tip:** Cline will help you create the project folder and set up your first webpage!
 
-### Tips for Working with Cline
+### 🧩 Tips for Working with Cline
 
 -   **Ask Questions:** If you're unsure about something, ask Cline!
 -   **Use Screenshots:** Cline can understand images — show him what you're working on.
 -   **Copy and Paste Errors:** Share error messages in the chat for solutions.
 -   **Speak Plainly:** Use your own words — Cline will translate them into code.
 
-### Still Struggling?
+### 🫂 Still Struggling?
 
 Join our Discord community and engage with our team and other Cline users directly.

docs/getting-started/installing-dev-essentials.mdx

@@ -6,7 +6,7 @@ description: >-
     guided way.
 ---
 
-### The Essential Tools
+### 🧰 The Essential Tools
 
 Here are the core tools you'll need for development:
 
@@ -17,9 +17,9 @@ Here are the core tools you'll need for development:
     -   Chocolatey for Windows
     -   apt/yum for Linux
 
-> **Tip:** These tools are the foundation of your developer toolkit. Installing them properly will set you up for success!
+> 💡 **Tip:** These tools are the foundation of your developer toolkit. Installing them properly will set you up for success!
 
-### Let Cline Install Everything
+### 🚀 Let Cline Install Everything
 
 Copy one of these prompts based on your operating system and paste it into **Cline**:
 
@@ -41,9 +41,9 @@ Hello Cline! I need help setting up my Windows PC for software development. Coul
 Hello Cline! I need help setting up my Linux system for software development. Could you please help me install the essential development tools like Node.js, Git, and any other core utilities that are commonly needed for coding? I'd like you to guide me through the process step-by-step.
 ```
 
-> **Pro Tip:** Cline will show you each command before running it. You stay in control the entire time!
+> ✅ **Pro Tip:** Cline will show you each command before running it. You stay in control the entire time!
 
-### What Will Happen
+### 🔍 What Will Happen
 
 Cline will guide you through the following steps:
 
@@ -52,9 +52,9 @@ Cline will guide you through the following steps:
 3. Showing you the exact command before it runs (you approve each step!)
 4. Verifying each installation is successful
 
-> **Note:** You might need to enter your computer's password for some installations. This is normal!
+> ⚠️ **Note:** You might need to enter your computer's password for some installations. This is normal!
 
-### Why These Tools Are Important
+### 💡 Why These Tools Are Important
 
 -   **Node.js & npm:**
     -   Build websites with frameworks like React or Next.js
@@ -68,15 +68,15 @@ Cline will guide you through the following steps:
     -   Quickly install and update development tools
     -   Keep your environment organized and up to date
 
-### Notes
+### 🧩 Notes
 
-> **Tip:** The installation process is interactive — Cline will guide you step by step!
+> 💡 **Tip:** The installation process is interactive — Cline will guide you step by step!
 
 -   All commands are shown to you for approval before they run.
 -   If you run into any issues, Cline will help troubleshoot them.
 -   You may need to enter your computer's password for certain steps.
 
-### Additional Tips for New Coders
+### 🧑‍💻 Additional Tips for New Coders
 
 #### Understanding the Terminal
 

docs/getting-started/model-selection-guide.mdx

@@ -1,79 +1,126 @@
 ---
 title: "Model Selection Guide"
-description: "Last updated: August 20, 2025."
+description: "Last updated: Feb 5, 2025."
 ---
 
-New models drop constantly, so this guide focuses on what's working well with Cline right now. We'll keep it updated as the landscape shifts.
+## Understanding Context Windows
 
-## Current Top Models
+Think of a context window as your AI assistant's working memory - similar to RAM in a computer. It determines how much information the model can "remember" and process at once during your conversation. This includes:
 
-| Model | Context Window | Input Price* | Output Price* | Best For |
-|-------|---------------|--------------|---------------|----------|
-| **Claude Sonnet 4** | 1M tokens | $3-6 | $15-22.50 | Reliable tool usage, complex codebases |
-| **Qwen3 Coder** | 256K tokens | $0.20 | $0.80 | Coding tasks, open source flexibility |
-| **Gemini 2.5 Pro** | 1M+ tokens | TBD | TBD | Large codebases, document analysis |
-| **GPT-5** | 400K tokens | $1.25 | $10 | Latest OpenAI tech, three modes |
+-   Your code files and conversations
+-   The assistant's responses
+-   Any documentation or additional context provided
 
-*Per million tokens
+Context windows are measured in tokens (roughly 3/4 of a word in English). Different models have different context window sizes:
 
-## Budget Options
+-   Claude 3.5 Sonnet: 200K tokens
+-   DeepSeek Models: 128K tokens
+-   Gemini Flash 2.0: 1M tokens
+-   Gemini 1.5 Pro: 2M tokens
 
-| Model | Context Window | Input Price* | Output Price* | Notes |
-|-------|---------------|--------------|---------------|-------|
-| **DeepSeek V3** | 128K tokens | $0.14 | $0.28 | Great value for daily coding |
-| **DeepSeek R1** | 128K tokens | $0.55 | $2.19 | Budget reasoning champion |
-| **Qwen3 32B** | 128K tokens | Varies | Varies | Open source, multiple providers |
-| **Z AI GLM 4.5** | 128K tokens | TBD | TBD | MIT licensed, hybrid reasoning |
+When you reach the limit of your context window, older information needs to be removed to make room for new information - just like clearing RAM to run new programs. This is why sometimes AI assistants might seem to "forget" earlier parts of your conversation.
 
-*Per million tokens
+Cline helps you manage this limitation with its Context Window Progress Bar, which shows:
 
+-   Input tokens (what you've sent to the model)
+-   Output tokens (what the model has generated)
+-   A visual representation of how much of your context window you've used
+-   The total capacity for your chosen model
 
-## Context Window Guide
+<Frame caption="Visual representation of the context window usage in Cline">
+	<img
+		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(11).png"
+		alt="Context window progress bar example"
+	/>
+</Frame>
 
-| Size | Word Count | Use Case |
-|------|------------|----------|
-| 32K tokens | ~24,000 words | Single files, small projects |
-| 128K tokens | ~96,000 words | Most coding projects |
-| 200K tokens | ~150,000 words | Large codebases |
-| 400K+ tokens | ~300,000+ words | Entire applications |
+This visibility helps you work more effectively with Cline by letting you know when you might need to start fresh or break tasks into smaller chunks.
 
-**Performance note**: Most models start dropping in quality around 400-500K tokens, even if they claim higher limits.
+### Model Comparison
 
-## Open Source vs Closed Source
+## LLM Model Comparison for Cline (Feb 2025)
 
-### Open Source Advantages
-- **Multiple providers** compete to host them
-- **Cheaper pricing** due to competition  
-- **Provider choice** - switch if one goes down
-- **Faster innovation** cycles
+| Model             | Input Cost\* | Output Cost\* | Context Window | Best For                            |
+| ----------------- | ------------ | ------------- | -------------- | ----------------------------------- |
+| Claude 3.5 Sonnet | $3.00        | $15.00        | 200K           | Best code implementation & tool use |
+| DeepSeek R1       | $0.55        | $2.19         | 128K           | Planning & reasoning champion       |
+| DeepSeek V3       | $0.14        | $0.28         | 128K           | Value code implementation           |
+| o3-mini           | $1.10        | $4.40         | 200K           | Flexible use, strong planning       |
+| Gemini Flash 2.0  | $0.00        | $0.00         | 1M             | Strong all-rounder                  |
+| Gemini 1.5 Pro    | $0.00        | $0.00         | 2M             | Large context processing            |
 
-### Open Source Models Available
-- **Qwen3 Coder** (Apache 2.0)
-- **Z AI GLM 4.5** (MIT)
-- **Kimi K2** (Open source)
-- **DeepSeek series** (Various licenses)
+\*Costs per million tokens
 
-## Quick Decision Matrix
+### Top Picks for 2025
 
-| If you want... | Use this |
-|----------------|----------|
-| Something that just works | Claude Sonnet 4 |
-| To save money | DeepSeek V3 or Qwen3 variants |
-| Huge context windows | Gemini 2.5 Pro or Claude Sonnet 4 |
-| Open source | Qwen3 Coder, Z AI GLM 4.5, or Kimi K2 |
-| Latest tech | GPT-5 |
-| Speed | Qwen3 Coder on Cerebras (fastest available) |
+1. **Claude 3.5 Sonnet**
+    - Best overall code implementation
+    - Most reliable tool usage
+    - Expensive but worth it for critical code
+2. **DeepSeek R1**
+    - Exceptional planning & reasoning
+    - Great value pricing
+3. **o3-mini**
+    - Strong for planning with adjustable reasoning
+    - Three reasoning modes for different needs
+    - Requires OpenAI Tier 3 API access
+    - 200K context window
+4. **DeepSeek V3**
+    - Reliable code implementation
+    - Great for daily coding
+    - Cost-effective for implementation
+5. **Gemini Flash 2.0**
+    - Massive 1M context window
+    - Improved speed and performance
+    - Good all-around capabilities
 
-## What Others Are Using
+### Best Models by Mode (Plan or Act)
 
-Check [OpenRouter's Cline usage stats](https://openrouter.ai/apps?url=https%3A%2F%2Fcline.bot%2F) to see real usage patterns from the community.
+#### Planning
 
-## Context Management
+1. **DeepSeek R1**
+    - Best reasoning capabilities in class
+    - Excellent at breaking down complex tasks
+    - Strong math/algorithm planning
+    - MoE architecture helps with reasoning
+2. **o3-mini (high reasoning)**
+    - Three reasoning levels:
+        - High: Complex planning
+        - Medium: Daily tasks
+        - Low: Quick ideas
+    - 200K context helps with large projects
+3. **Gemini Flash 2.0**
+    - Massive context window for complex planning
+    - Strong reasoning capabilities
+    - Good with multi-step tasks
 
-Cline automatically handles context limits with [auto-compact](/features/auto-compact). When you approach your model's limit, Cline summarizes the conversation to keep working. You don't need to micromanage this.
+#### Acting (coding)
 
-## The Bottom Line
+1. **Claude 3.5 Sonnet**
+    - Best code quality
+    - Most reliable with Cline tools
+    - Worth the premium for critical code
+2. **DeepSeek V3**
+    - Nearly Sonnet-level code quality
+    - Better API stability than R1
+    - Great for daily coding
+    - Strong tool usage
+3. **Gemini 1.5 Pro**
+    - 2M context window
+    - Good with complex codebases
+    - Reliable API
+    - Strong multi-file understanding
 
-Start with **Claude Sonnet 4** if you want reliability. Experiment with **open source options** once you're comfortable to find the best fit for your workflow and budget.
+### A Note on Local Models
 
-The landscape moves fast - these recommendations reflect what's working now, but keep an eye on new releases.
+While running models locally might seem appealing for cost savings, we currently don't recommend any local models for use with Cline. [Local models are significantly less reliable](https://docs.cline.bot/running-models-locally/read-me-first) at using Cline's essential tools and typically retain only 1-26% of the original model's capabilities. The full cloud version of DeepSeek-R1, for example, is 671B parameters - local versions are drastically simplified copies that struggle with complex tasks and tool usage. Even with high-end hardware (RTX 3070+, 32GB+ RAM), you'll experience slower responses, less reliable tool execution, and reduced capabilities. For the best development experience, we recommend sticking with the cloud models listed above.
+
+### Key Takeaways
+
+1. **Plan vs Act Matters**: Choose models based on task type
+2. **Real Performance > Benchmarks**: Focus on actual Cline performance
+3. **Mix & Match**: Use different models for planning and implementation
+4. **Cost vs Quality**: Premium models worth it for critical code
+5. **Keep Backups**: Have alternatives ready for API issues
+
+_\*Note: Based on real usage patterns and community feedback rather than just benchmarks. Your experience may vary. This is not an exhaustive list of all the models available for use within Cline._

docs/getting-started/our-favorite-tech-stack.mdx

@@ -0,0 +1,238 @@
+---
+title: "Our Favorite Tech Stack"
+description: "A curated list of our recommended technologies and tools for building modern web applications with Cline."
+---
+
+## Recommended Stack for New Cline Users (2025)
+
+### Your Complete Development Environment
+
+#### Development Tools
+
+-   **VS Code** - Your code editor, [download here](https://code.visualstudio.com/)
+-   **GitHub** - Where your code lives, [sign up here](https://github.com)
+
+#### Frontend
+
+-   **Next.js 14+** - React framework with App Router
+-   **Tailwind CSS** - Beautiful styling without writing CSS
+-   **TypeScript** - JavaScript, but safer and smarter
+
+#### Backend
+
+-   **Supabase** - Your complete backend solution, [sign up with GitHub](https://supabase.com)
+    -   PostgreSQL database
+    -   Authentication
+    -   File storage
+    -   Real-time updates
+
+#### Deployment
+
+-   **Vercel** - Where your app runs, [sign up with GitHub](https://vercel.com)
+    -   Automatic deployments from GitHub
+    -   Preview deployments for testing
+    -   Production-ready CDN
+
+#### AI Development
+
+Choose your AI assistant based on your needs:
+
+| Model             | Input Cost (per 1M tokens) | Output Cost (per 1M tokens) | Best For                       |
+| ----------------- | -------------------------- | --------------------------- | ------------------------------ |
+| Claude 3.5 Sonnet | $3.00                      | $15.00                      | Production apps, complex tasks |
+| DeepSeek R1       | $1.00                      | $3.00                       | Budget-conscious production    |
+| DeepSeek V3       | $0.14                      | $2.20                       | Budget-conscious development   |
+
+#### Free Tier Benefits
+
+**Vercel (Hobby)**
+
+-   100 GB data transfer/month
+-   100k serverless function invocations
+-   100 MB deployment size
+-   Automatic HTTPS & CI/CD
+
+**Supabase (Free)**
+
+-   500 MB database storage
+-   1 GB file storage
+-   50k monthly active users
+-   2M real-time messages/month
+
+**GitHub (Free)**
+
+-   Unlimited public repositories
+-   GitHub Actions CI/CD
+-   Project management tools
+-   Collaboration features
+
+### Getting Started
+
+1. Install the development essentials:
+    - Follow our [Development Essentials Installation Guide](https://docs.cline.bot/getting-started/installing-dev-essentials)
+2. Set up Cline's Memory Bank:
+    - Follow the [Memory Bank setup instructions](https://docs.cline.bot/prompting/cline-memory-bank)
+    - Create an empty `cline_docs` folder in your project root
+    - Create `projectBrief.md` in the `cline_docs` folder (see example below)
+    - Tell Cline to "initialize memory bank"
+3. Add our recommended stack configuration:
+    - Create `.clinerules` file (see template below)
+    - Let Cline handle the rest!
+
+#### Example Project Brief
+
+```markdown
+# Project Brief
+
+## Overview
+
+Building a [type of application] that will [main purpose].
+
+## Core Features
+
+-   Feature 1
+-   Feature 2
+-   Feature 3
+
+## Target Users
+
+[Describe who will use your application]
+
+## Technical Preferences (optional)
+
+-   Any specific technologies you want to use
+-   Any specific requirements or constraints
+```
+
+### .clinerules Template
+
+```markdown
+# Project Configuration
+
+## Tech Stack
+
+-   Next.js 14+ with App Router
+-   Tailwind CSS for styling
+-   Supabase for backend
+-   Vercel for deployment
+-   GitHub for version control
+
+## Project Structure
+
+/src
+/app # Next.js App Router pages
+/components # React components
+/lib # Utility functions
+/types # TypeScript types
+/supabase
+/migrations # SQL migration files
+/seed # Seed data files
+/public # Static assets
+
+## Database Migrations
+
+SQL files in /supabase/migrations should:
+
+-   Use sequential numbering: 001, 002, etc.
+-   Include descriptive names
+-   Be reviewed by Cline before execution
+    Example: 001_create_users_table.sql
+
+## Development Workflow
+
+-   Cline helps write and review code changes
+-   Vercel automatically deploys from main branch
+-   Database migrations reviewed by Cline before execution
+
+## Security
+
+DO NOT read or modify:
+
+-   .env files
+-   \*_/config/secrets._
+-   Any file containing API keys or credentials
+```
+
+### Learning Resources (2025)
+
+Want to learn more about the technologies we're using? Here are some great resources:
+
+#### Next.js and React
+
+-   [Official Learn Next.js Course](https://nextjs.org/learn) - Interactive tutorial
+-   [NextJS App Router: Modern Web Dev in 1 Hour](https://www.youtube.com/nextjs-modern) - Quick overview
+-   [Building Real-World Apps with Next.js](https://www.youtube.com/nextjs-real-world) - Practical examples
+
+#### Supabase
+
+-   [Supabase From Scratch](https://www.udemy.com/supabase-scratch) - Comprehensive course
+-   [Official Quickstart Guides](https://supabase.com/docs/guides/getting-started)
+-   [Real-Time Apps with Next.js and Supabase](https://www.newline.co/courses/supabase-nextjs)
+
+#### Tailwind CSS
+
+-   [Tailwind CSS Tutorial for Beginners](https://www.youtube.com/tailwind-2025)
+-   [Official Tailwind Documentation](https://tailwindcss.com/docs)
+-   Interactive course at [Scrimba Tailwind CSS Course](https://scrimba.com/learn/tailwind)
+
+### Other Things to Know
+
+#### Working with Git & GitHub
+
+Git helps you track changes in your code and collaborate with others. Here are the essential commands you'll use:
+
+**Daily Development**
+
+```bash
+# Save your changes (do this often!)
+git add .                                    # Stage all changed files
+git commit -m "Add login page"              # Save changes with a clear message
+
+# Share your changes
+git push origin main                        # Upload to GitHub
+```
+
+**Common Workflow**
+
+1.  **Start of day**: Get latest changes
+
+    ```bash
+    git pull origin main                     # Download latest code
+    ```
+
+2.  **During development**: Save work regularly
+
+    ```bash
+    git add .
+    git commit -m "Clear message about changes"
+    ```
+
+3.  **End of day**: Share your progress
+
+    ```bash
+    git push origin main                     # Upload to GitHub
+    ```
+
+**Best Practices**
+
+-   Commit often with clear messages
+-   Pull before starting new work
+-   Push completed work to share with others
+-   Use `.gitignore` to avoid committing sensitive files
+
+> **Tip**: Vercel automatically deploys when you push to main!
+
+#### Environment Variables
+
+-   Store secrets in `.env.local` for development
+-   Add them to Vercel project settings for production
+-   Never commit `.env` files to Git
+
+#### Getting Help
+
+1. Use `/help` in Cline chat for immediate assistance
+2. Check [Cline Documentation](https://docs.cline.bot)
+3. Join our [Discord Community](https://discord.gg/cline)
+4. Search GitHub issues for common problems
+
+Remember: Cline is here to help at every step. Just ask for guidance or clarification when needed!

docs/getting-started/understanding-context-management.mdx

@@ -3,7 +3,7 @@ title: "Context Management"
 description: "Context is key to getting the most out of Cline"
 ---
 
-> **Quick Reference**
+> 💡 **Quick Reference**
 >
 > -   Context = The information Cline knows about your project
 > -   Context Window = How much information Cline can hold at once
@@ -38,7 +38,7 @@ Cline actively builds context in two ways:
     - Guide focus areas
     - Share design thoughts and requirements
 
-**Key Point**: Cline isn't passive - it actively seeks to understand your project. You can either let it explore or guide its focus, especially in [Plan Mode](/features/plan-and-act).
+💡 **Key Point**: Cline isn't passive - it actively seeks to understand your project. You can either let it explore or guide its focus, especially in [Plan](https://docs.cline.bot/features/plan-and-act) mode.
 
 ### Context & Context Windows
 
@@ -53,13 +53,12 @@ Think of context like a whiteboard you and Cline share:
 -   **Context Window** is the size of the whiteboard itself:
     -   Measured in tokens (1 token ≈ 3/4 of an English word)
     -   Each model has a fixed size:
-        -   Claude Sonnet 4: 1,000,000 tokens
-        -   Qwen3 Coder: 256,000 tokens
-        -   Gemini 2.5 Pro: 1,000,000+ tokens
-        -   GPT-5: 400,000 tokens
-    -   When the whiteboard is full, Cline automatically summarizes the conversation to free up space
+        -   Claude 3.5 Sonnet: 200,000 tokens
+        -   DeepSeek: 64,000 tokens
+    -   When the whiteboard is full, you need to erase (clear context) to write more
+        -   [How Cline manages context under the hood](https://cline.bot/blog/understanding-the-new-context-window-progress-bar-in-cline)
 
-**Important**: Having a large context window doesn't mean you should fill it completely. Models start degrading around 400-500K tokens even if they claim higher limits. Just like a cluttered whiteboard, too much information can make it harder to focus on what's important.
+⚠️ **Important**: Having a large context window (like Claude's 200k tokens) doesn't mean you should fill it completely. Just like a cluttered whiteboard, too much information can make it harder to focus on what's important.
 
 ## Understanding the Context Window Progress Bar
 
@@ -77,7 +76,7 @@ Cline provides a visual way to monitor your context window usage through a progr
 -   ↑ shows input tokens (what you've sent to the LLM)
 -   ↓ shows output tokens (what the LLM has generated)
 -   The progress bar visualizes how much of your context window you've used
--   The total shows your model's maximum capacity (e.g., 1M for Claude Sonnet 4)
+-   The total shows your model's maximum capacity (e.g., 200k for Claude 3.5-Sonnet)
 
 ### When to Watch the Bar
 
@@ -86,33 +85,7 @@ Cline provides a visual way to monitor your context window usage through a progr
 -   Before starting complex tasks
 -   When Cline seems to lose context
 
-**Tip**: With [Auto Compact](/features/auto-compact), Cline can now handle long conversations automatically. When combined with [Focus Chain](/features/focus-chain), you can work on complex projects that span multiple context windows without losing progress.
-
-## Automatic Context Management
-
-Cline includes intelligent features to manage context automatically:
-
-### Default Settings You Should Keep On
-
-**Focus Chain** - Enabled by default in v3.25. Cline generates a todo list at task start and keeps it in context so the thread doesn't drift. You can edit the markdown to add or reorder steps and Cline will adapt. [Learn more about Focus Chain](/features/focus-chain).
-
-**Auto Compact** - Always on. As the context window reaches its limit, Cline creates a comprehensive summary, replaces the bloated history, and continues where it left off. Decisions, code changes, and state are preserved. [Learn more about Auto Compact](/features/auto-compact).
-
-## Advanced Context Tools
-
-When you need more control over context management:
-
-### Deep Planning (`/deep-planning`)
-For substantial features, refactors, or integrations. Cline investigates your codebase, asks targeted questions, then writes `implementation_plan.md`. It creates a fresh task with distilled, high-value context. [Learn more about Deep Planning](/features/slash-commands/deep-planning).
-
-### New Task (`/newtask`)
-At natural transition points, packages only what matters into a fresh task. Clean slate for implementation after research, or crisp handoff between teammates. [Learn more about New Task](/features/slash-commands/new-task).
-
-### Smol (`/smol`)
-Compress the conversation in place to keep momentum. Ideal during debugging or exploratory work when you don't want to break flow. [Learn more about Smol](/features/slash-commands/smol).
-
-### Memory Bank + .clinerules
-For non-trivial projects. The Memory Bank captures project knowledge as Markdown in your repo. `.clinerules` are version-controlled instructions that align Cline's behavior with your team. [Learn more about Memory Bank](/prompting/cline-memory-bank) and [Cline Rules](/features/cline-rules).
+💡 **Tip**: Consider starting a fresh session when usage reaches 70-80% to maintain optimal performance.
 
 ## Working with Context Files
 
@@ -120,12 +93,12 @@ Context files help maintain understanding across sessions. They serve as documen
 
 #### Approaches to Context Files
 
-1. **Evergreen Project Context (Memory Bank)**
+1. **Evergreen Project Context (i.e.** [**Memory Bank**](https://docs.cline.bot/prompting/cline-memory-bank)**)**
     - Living documentation that evolves with your project
     - Updated as architecture and patterns emerge
     - Example: The Memory Bank pattern maintains files like `techContext.md` and `systemPatterns.md`
     - Useful for long-running projects and teams
-2. **Task-Specific Context**
+2. **Task-Specific Context (i.e.** [**Structured Approach**](https://cline.bot/blog/building-advanced-software-with-cline-a-structured-approach)**)**
 
     - Created for specific implementation tasks
     - Document requirements, constraints, and decisions
@@ -178,19 +151,9 @@ Context files help maintain understanding across sessions. They serve as documen
     - Use Plan mode for complex discussions
     - Start fresh sessions when needed
 3. **Team Projects**
-    - Share common context files (consider using [.clinerules](/features/cline-rules) files in project roots)
+    - Share common context files (consider using [.clinerules](https://docs.cline.bot/features/cline-rules) files in project roots)
     - Document architectural decisions
     - Maintain consistent patterns
     - Keep documentation current
 
-## Bonus Context Tips
-
-- You can @ links and have the webpage's context added to Cline (docs, blogs, etc.)
-- Utilize MCP servers to pull in context from your external knowledge bases
-- Screenshots can be used as context for models that support image inputs
-
-## The Bottom Line
-
-Cline already does a lot of context work for you - [Focus Chain](/features/focus-chain), [Auto Compact](/features/auto-compact), and the planning flow are designed to keep the thread intact across long horizons. The goal is to help Cline maintain consistent understanding of your project across sessions.
-
-Remember: The goal is to keep only what matters in view, at every step.
+Remember: The goal is to help Cline maintain consistent understanding of your project across sessions.

docs/getting-started/what-is-cline.mdx

@@ -3,70 +3,6 @@ title: "What is Cline?"
 description: "An introduction to Cline, your AI-powered development assistant in VS Code."
 ---
 
-Cline is an open source AI coding agent that brings frontier AI models directly to your VS Code editor. Unlike autocomplete tools, Cline is a true coding agent that can understand entire codebases, plan complex changes, and execute multi-step tasks.
+Cline is an AI development assistant which integrates with Microsoft Visual Studio Code. It provides an interface between your IDE and LLMs facilitating code development, increasing productivity and lowering the barrier to entry for new coders. Depending on permissions, Cline can read/write files, execute commands, use your web browser, and expand its capabilities with Model Context Protocol servers.
 
-## Open Source AI Coding, Uncompromised
-
-Cline gives you direct, transparent access to frontier AI with no limits, no surprises, and no model ecosystem lock-in. See every decision. Choose any model. Control your costs.
-
-### Complete Transparency
-
-Watch in real-time as Cline reads files, considers approaches, and proposes changes. Every decision is visible, every edit reviewable before it's made. This isn't just "explainable AI" - it's complete transparency.
-
-### Your Models, Your Control
-
-Use Claude for complex reasoning, Gemini for massive contexts, or Qwen3 Coder for efficiency. Switch instantly as new models launch. Your API keys, your choice. No gatekeeping innovation.
-
-### Built for Real Engineering
-
-Cline can:
-- **Read and write files** across your entire codebase
-- **Execute terminal commands** and debug errors
-- **Plan complex features** before writing code
-- **Connect to external systems** through MCP servers
-- **Understand large codebases** with intelligent context management
-
-## Plan & Act Mode
-
-Cline explores your codebase and works with you to create comprehensive plans before writing a single line of code, ensuring it understands the full context of your project.
-
-**Plan Mode** for complex tasks - Cline explores, asks questions, and creates detailed implementation plans.
-
-**Act Mode** for execution - Cline implements the plan with full transparency and control.
-
-## Zero Trust by Design
-
-Your code never touches our servers. Cline runs entirely client-side with your API keys, making it the only option for enterprises with strict security requirements.
-
-**Open source** means your security team can review every line. See exactly how Cline works, what it sends to AI providers, and how decisions are made.
-
-## Key Features
-
-### Focus Chain
-Automatic todo list management with real-time progress tracking throughout your tasks. Keeps Cline on track across long projects.
-
-### Auto Compact
-When conversations get long, Cline automatically summarizes to preserve context while freeing up space to continue working.
-
-### Deep Planning
-For complex features, Cline investigates your codebase, asks clarifying questions, and creates comprehensive implementation plans.
-
-### MCP Integration
-Connect to databases, APIs, and documentation through the Model Context Protocol. Cline becomes your bridge to any external system.
-
-### .clinerules
-Define project-specific instructions that Cline follows including coding standards, architecture patterns, or team conventions.
-
-## Why Developers Choose Cline
-
-**100% Open Source** - Every line of code on GitHub. 48k+ stars from developers who've read it, improved it, and trust it with their work.
-
-**No Inference Games** - We don't profit from AI usage. While others limit context or route to cheaper models, we give you unrestricted access to any model's full capabilities.
-
-**Future-Proof by Design** - New model released? Use it immediately. Cline works with any AI provider, any model.
-
-**True Visibility** - See every file read, every decision considered, every token used.
-
-## Getting Started
-
-Ready to experience AI coding without limits? [Install Cline](/getting-started/installing-cline) and start with our [Model Selection Guide](/getting-started/model-selection-guide) to choose the right AI model for your needs.
+What makes Cline distinctive is its thoughtful approach to code generation and its extensive integration capabilities. Rather than simply generating code snippets, Cline collaborates with developers by planning solutions step-by-step, maintaining awareness of the entire development environment, and requiring explicit approval for all changes. It can understand large codebases, accelerate onboarding for new engineers, and connect with hundreds of tools through its Model Context Protocol Marketplace, enabling everything from streamlined project deployments to automated incident response—all through natural language commands.

docs/mcp/adding-mcp-servers-from-github.mdx

@@ -17,7 +17,6 @@ There are multiple places online to find MCP servers:
     -   [mcpservers.org](https://mcpservers.org/)
     -   [mcp.so](https://mcp.so/)
     -   [glama.ai/mcp/servers](https://glama.ai/mcp/servers)
-    -   [mcp.composio.dev](https://mcp.composio.dev/)
 
     These directories allow users to sort the servers by various criteria such as downloads, date, stars, and use case. Each entry provides information such as features, tools, and configuration instructions.
 

docs/more-info/telemetry.mdx

@@ -4,17 +4,17 @@ title: "Telemetry"
 
 ### Overview
 
-To help make Cline better for everyone, we collect usage data that helps us understand how developers are using our open-source AI coding agent. This feedback loop is crucial for improving Cline's capabilities and user experience.
+To help make Cline better for everyone, we collect anonymous usage data that helps us understand how developers are using our open-source AI coding agent. This feedback loop is crucial for improving Cline's capabilities and user experience.
 
-We use PostHog, an open-source analytics platform, for data collection and analysis. Our telemetry implementation is fully transparent - you can review the [source code](https://github.com/cline/cline/blob/main/src/services/posthog/telemetry/TelemetryService.ts) to see exactly what we track.
+We use PostHog, an open-source analytics platform, for data collection and analysis. Our telemetry implementation is fully transparent - you can review the [source code](https://github.com/cline/cline/blob/main/src/services/telemetry/TelemetryService.ts) to see exactly what we track.
 
 ### Tracking Policy
 
-Privacy is our priority. By default, all collected data is anonymized. If you log in with a Cline account, your telemetry data will be associated with your account to help us improve the product and provide better support when you encounter issues. Your code, prompts, and conversation content always remain private and are never collected.
+Privacy is our priority. All collected data is anonymized before being sent to PostHog, with no personally identifiable information (PII) included. Your code, prompts, and conversation content always remain private and are never collected.
 
 ### What We Track
 
-We collect basic usage data including:
+We collect basic anonymous usage data including:
 
 **Task Interactions:** When tasks start and finish, conversation flow (without content)\
 **Mode and Tool Usage:** Switches between plan/act modes, which tools are being used\
@@ -22,13 +22,13 @@ We collect basic usage data including:
 **System Context:** OS type and VS Code environment details\
 **UI Activity:** Navigation patterns and feature usage
 
-For complete transparency, you can inspect our [telemetry implementation](https://github.com/cline/cline/blob/main/src/services/posthog/telemetry/TelemetryService.ts) to see the exact events we track.
+For complete transparency, you can inspect our [telemetry implementation](https://github.com/cline/cline/blob/main/src/services/telemetry/TelemetryService.ts) to see the exact events we track.
 
 ### How to Opt Out
 
 Telemetry in Cline is entirely optional:
 
--   When you update or install our VS Code extension, you'll see a message about our telemetry
+-   When you update or install our VS Code extension, you'll see a message about our anonymous telemetry
 -   You can change your preference anytime in settings
 
 Cline also respects VS Code's global telemetry settings. If you've disabled telemetry at the VS Code level, Cline's telemetry will automatically be disabled as well.

docs/package.json

@@ -4,15 +4,13 @@
 	"main": "index.js",
 	"scripts": {
 		"test": "echo \"Error: no test specified\" && exit 1",
-		"dev": "mintlify dev",
-		"check": "mintlify broken-links",
-		"rename": "mintlify rename"
+		"dev": "mintlify dev"
 	},
 	"keywords": [],
 	"author": "",
 	"license": "ISC",
 	"description": "",
 	"dependencies": {
-		"mintlify": "^4.2.23"
+		"mintlify": "^4.0.538"
 	}
 }

docs/provider-config/anthropic.mdx

@@ -16,7 +16,6 @@ description: "Learn how to configure and use Anthropic Claude models with Cline.
 
 Cline supports the following Anthropic Claude models:
 
--   `claude-opus-4-1-20250805`
 -   `claude-opus-4-20250514`
 -   `claude-opus-4-20250514:thinking` (Extended Thinking variant)
 -   `claude-sonnet-4-20250514` (Recommended)

docs/provider-config/aws-bedrock-with-credentials-authentication.mdx

@@ -1,12 +1,11 @@
 ---
-title: "IAM Credentials"
-sidebarTitle: "IAM Credentials"
-description: "Set up AWS Bedrock with Cline using IAM Access Key and Secret Key credentials. Best for enterprise environments with established IAM policies."
+title: "AWS Bedrock"
+description: "Learn how to set up AWS Bedrock with Cline using credentials authentication. This guide covers AWS environment setup, regional access verification, and secure integration with the Cline VS Code extension."
 ---
 
 ### Overview
 
--   **AWS Bedrock:** A fully managed service that offers access to leading generative AI models (e.g., Anthropic Claude, Amazon Nova) through AWS.\
+-   **AWS Bedrock:** A fully managed service that offers access to leading generative AI models (e.g., Anthropic Claude, Amazon Titan) through AWS.\
     [Learn more about AWS Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html).
 -   **Cline:** A VS Code extension that acts as a coding assistant by integrating with AI models—empowering developers to generate code, debug, and analyze data.
 -   **Enterprise Focus:** This guide is tailored for organizations with established AWS environments (using IAM roles, AWS SSO, AWS Organizations, etc.) to ensure secure and compliant usage.
@@ -26,7 +25,7 @@ description: "Set up AWS Bedrock with Cline using IAM Access Key and Secret Key
 
 #### 1.2 Attach the Required Policies
 
-To ensure Cline can interact with AWS Bedrock, your IAM user or role needs specific permissions. While the `AmazonBedrockLimitedAccess` managed policy provides comprehensive access, for a more restricted and secure setup adhering to the principle of least privilege, the following minimal permissions are sufficient for Cline's core model invocation functionality:
+To ensure Cline can interact with AWS Bedrock, your IAM user or role needs specific permissions. While the `AmazonBedrockFullAccess` managed policy provides comprehensive access, for a more restricted and secure setup adhering to the principle of least privilege, the following minimal permissions are sufficient for Cline's core model invocation functionality:
 
 -   `bedrock:InvokeModel`
 -   `bedrock:InvokeModelWithResponseStream`
@@ -53,8 +52,8 @@ You can create a custom IAM policy with these permissions and attach it to your
 
 **Option 2: Using a Managed Policy (Simpler Initial Setup)**
 
--   Alternatively, you can attach the AWS managed policy **`AmazonBedrockLimitedAccess`**. This grants broader permissions, including the ability to list models, manage provisioning, and other Bedrock features. This might be simpler for initial setup or if you require these wider capabilities.
-    [View AmazonBedrockLimitedAccess Policy Details](https://docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html)
+-   Alternatively, you can attach the AWS managed policy **`AmazonBedrockFullAccess`**. This grants broader permissions, including the ability to list models, manage provisioning, and other Bedrock features. This might be simpler for initial setup or if you require these wider capabilities.
+    [View AmazonBedrockFullAccess Policy Details](https://docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html)
 
 **Important Considerations:**
 
@@ -72,8 +71,8 @@ You can create a custom IAM policy with these permissions and attach it to your
    AWS Bedrock is available in multiple regions (e.g., US East, Europe, Asia Pacific). Choose the region that meets your latency and compliance needs.\
    [AWS Global Infrastructure](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/)
 2. **Verify Model Access:**
-    - In the AWS Bedrock console, confirm that the models your team requires (e.g., Anthropic Claude, Amazon Nova) are marked as "Access granted."
-    - **Note:** Some advanced models might require an [Inference Profile](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html) if not available on-demand.
+    - In the AWS Bedrock console, confirm that the models your team requires (e.g., Anthropic Claude, Amazon Titan) are marked as "Access granted."
+    - **Note:** Some advanced models might require an [Inference Profile](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-prereq.html) if not available on-demand.
 
 #### 2.2 Set Up AWS Marketplace Subscriptions (if needed)
 
@@ -139,7 +138,7 @@ You can create a custom IAM policy with these permissions and attach it to your
 
 By following these steps, your enterprise team can securely integrate AWS Bedrock with the Cline VS Code extension to accelerate development:
 
-1. **Prepare Your AWS Environment:** Create or use a secure IAM role/user, attach the `AmazonBedrockLimitedAccess` policy, and ensure necessary permissions.
+1. **Prepare Your AWS Environment:** Create or use a secure IAM role/user, attach the `AmazonBedrockFullAccess` policy, and ensure necessary permissions.
 2. **Verify Region and Model Access:** Confirm that your selected region supports your required models and subscribe via AWS Marketplace if needed.
 3. **Configure Cline in VS Code:** Install and set up Cline with your AWS credentials and choose an appropriate model.
 4. **Implement Security and Monitoring:** Use best practices for IAM, network security, monitoring, and cost management.

docs/provider-config/aws-bedrock-with-profile-authentication.mdx

@@ -1,7 +1,6 @@
 ---
-title: "CLI Profile (SSO)"
-sidebarTitle: "CLI Profile (SSO)"
-description: "Configure AWS Bedrock to use AWS CLI profiles for authentication with Cline. Best for SSO/federated roles and secure enterprise access."
+title: "AWS Bedrock w/ Profile Authentication"
+description: "Learn how to configure AWS Bedrock to use AWS Profiles for authentication with Cline, focusing on SSO/Federated roles for secure access."
 ---
 
 ### Overview

docs/provider-config/aws-bedrock/api-key.mdx

@@ -1,136 +0,0 @@
----
-title: "API Key (Simple Setup)"
-sidebarTitle: "API Key"
-description: "Set up AWS Bedrock with Cline using Bedrock API Keys. Simplest setup for individual developers to access frontier models."
----
-
-### Overview
-
--   **AWS Bedrock:** A fully managed service that offers access to leading generative AI models (e.g., Anthropic Claude, Amazon Nova) through AWS.\
-    [Learn more about AWS Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html).
--   **Cline:** A VS Code extension that acts as a coding assistant by integrating with AI models—empowering developers to generate code, debug, and analyze data.
--   **Developer Focus:** This guide is tailored for individual developers that want to enable access to frontier models via AWS Bedrock with a simplified setup using API Keys.
-
----
-
-### Step 1: Prepare Your AWS Environment
-
-#### 1.1 Individual user setup - Create a Bedrock API Key
-
-For more detailed instructions check the [documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/api-keys.html).
-
-1. **Sign in to the AWS Management Console:**\
-   [AWS Console](https://aws.amazon.com/console/)
-2. **Access Bedrock Console:**
-    - [Bedrock Console](https://console.aws.amazon.com/bedrock)
-    - Create a new Long Lived API Key. This API Key will have by default the `AmazonBedrockLimitedAccess` IAM policy
-      [View AmazonBedrockLimitedAccess Policy Details](https://docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html)
-
-#### 1.2 Create or Modify the Policy
-
-To ensure Cline can interact with AWS Bedrock, your IAM user or role needs specific permissions. While the `AmazonBedrockLimitedAccess` managed policy provides comprehensive access, for a more restricted and secure setup adhering to the principle of least privilege, the following minimal permissions are sufficient for Cline's core model invocation functionality:
-
--   `bedrock:InvokeModel`
--   `bedrock:InvokeModelWithResponseStream`
--   `bedrock:CallWithBearerToken`
-
-You can create a custom IAM policy with these permissions and attach it to your IAM user or role.
-
-1.  In the AWS IAM console, create a new policy.
-2.  Use the JSON editor to add the following policy document:
-    ```json
-    {
-    	"Version": "2012-10-17",
-    	"Statement": [
-    		{
-    			"Effect": "Allow",
-    			"Action": ["bedrock:InvokeModel", "bedrock:InvokeModelWithResponseStream", "bedrock:CallWithBearerToken"],
-    			"Resource": "*" // For enhanced security, scope this to specific model ARNs if possible.
-    		}
-    	]
-    }
-    ```
-3.  Name the policy (e.g., `ClineBedrockInvokeAccess`) and attach it to the IAM user associated with the key you created. The IAM user and the API key have the same prefix.
-
-**Important Considerations:**
-
--   **Model Listing in Cline:** The minimal permissions (`bedrock:InvokeModel`, `bedrock:InvokeModelWithResponseStream`) are sufficient for Cline to _use_ a model if you specify the model ID directly in Cline's settings. If you rely on Cline to dynamically list available Bedrock models, you might need additional permissions like `bedrock:ListFoundationModels`.
--   **AWS Marketplace Subscriptions:** For third-party models (e.g., Anthropic Claude), the **`AmazonBedrockLimitedAccess`** policy grants you the necessary permissions to subscribe via the AWS Marketplace. There is no explicit access to be enabled. For Anthropic models you are still required to submit a First Time Use (FTU) form via the Console. If you get the following message in the Cline chat `[ERROR] Failed to process response: Model use case details have not been submitted for this account. Fill out the Anthropic use case details form before using the model.` then open the [Playground in the AWS Bedrock Console](https://console.aws.amazon.com/bedrock/home?#/text-generation-playground), select any Anthropic model and fill in the form (you might need to send a prompt first)
-
----
-
-### Step 2: Verify Regional and Model Access
-
-#### 2.1 Choose and Confirm a Region
-
-1. **Select a Region:**\
-   AWS Bedrock is available in multiple regions (e.g., US East, Europe, Asia Pacific). Choose the region that meets your latency and compliance needs.\
-   [AWS Global Infrastructure](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/)
-2. **Verify Model Access:**
-    - **Note:** Some models are only accessible via an [Inference Profile](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html). In such case check the box "Cross Region Inference".
-
----
-
-### Step 3: Configure the Cline VS Code Extension
-
-#### 3.1 Install and Open Cline
-
-1. **Install VS Code:**\
-   Download from the [VS Code website](https://code.visualstudio.com/).
-2. **Install the Cline Extension:**
-    - Open VS Code.
-    - Go to the Extensions Marketplace (`Ctrl+Shift+X` or `Cmd+Shift+X`).
-    - Search for **Cline** and install it.
-
-#### 3.2 Configure Cline Settings
-
-1. **Open Cline Settings:**
-    - Click on the settings ⚙️ to select your API Provider.
-2. **Select AWS Bedrock as the API Provider:**
-    - From the API Provider dropdown, choose **AWS Bedrock**.
-3. **Enter Your AWS API Key:**
-    - Input your **API Key**
-    - Specify the correct **AWS Region** (e.g., `us-east-1` or your enterprise-approved region).
-4. **Select a Model:**
-    - Choose an on-demand model (e.g., **anthropic.claude-3-5-sonnet-20241022-v2:0**).
-5. **Save and Test:**
-    - Click **Done/Save** to apply your settings.
-    - Test the integration by sending a simple prompt (e.g., "Generate a Python function to check if a number is prime.").
-
----
-
-### Step 4: Security, Monitoring, and Best Practices
-
-1. **Secure Access:**
-    - Prefer AWS SSO/federated roles over long-lived API Key when possible.
-    - [AWS IAM Best Practices](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html)
-2. **Enhance Network Security:**
-    - Consider setting up [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html) to securely connect to Bedrock.
-3. **Monitor and Log Activity:**
-    - Enable AWS CloudTrail to log Bedrock API calls.
-    - Use CloudWatch to monitor metrics like invocation count, latency, and token usage.
-    - Set up alerts for abnormal activity.
-4. **Handle Errors and Manage Costs:**
-    - Implement exponential backoff for throttling errors.
-    - Use AWS Cost Explorer and set billing alerts to track usage.\
-      [AWS Cost Management](https://docs.aws.amazon.com/cost-management/latest/userguide/what-is-aws-cost-management.html)
-5. **Regular Audits and Compliance:**
-    - Periodically review IAM roles and CloudTrail logs.
-    - Follow internal data privacy and governance policies.
-
----
-
-### Conclusion
-
-By following these steps, you can quickly integrate AWS Bedrock with the Cline VS Code extension to accelerate development:
-
-1. **Prepare Your AWS Environment:** Create a Bedrock API Key with the necessary permissions.
-2. **Verify Region and Model Access:** Confirm that your selected region supports your required models.
-3. **Configure Cline in VS Code:** Install and set up Cline with your AWS API Key and choose an appropriate model.
-4. **Implement Security and Monitoring:** Use best practices for IAM, network security, monitoring, and cost management.
-
-For further details, consult the [AWS Bedrock Documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html). Happy coding!
-
----
-
-_This guide will be updated as AWS Bedrock and Cline evolve. Always refer to the latest documentation and internal policies for up-to-date practices._

docs/provider-config/cerebras.mdx

@@ -1,96 +0,0 @@
----
-title: "Cerebras"
-description: "Learn how to configure and use Cerebras's ultra-fast inference with Cline. Experience up to 2,600 tokens per second with wafer-scale chip architecture and real-time reasoning models."
----
-
-Cerebras delivers the world's fastest AI inference through their revolutionary wafer-scale chip architecture. Unlike traditional GPUs that shuttle model weights from external memory, Cerebras stores entire models on-chip, eliminating bandwidth bottlenecks and achieving speeds up to 2,600 tokens per second—often 20x faster than GPUs.
-
-**Website:** [https://cloud.cerebras.ai/](https://cloud.cerebras.ai/)
-
-### Getting an API Key
-
-1.  **Sign Up/Sign In:** Go to [Cerebras Cloud](https://cloud.cerebras.ai/) and create an account or sign in.
-2.  **Navigate to API Keys:** Access the API keys section in your dashboard.
-3.  **Create a Key:** Generate a new API key. Give it a descriptive name (e.g., "Cline").
-4.  **Copy the Key:** Copy the API key immediately. Store it securely.
-
-### Supported Models
-
-Cline supports the following Cerebras models:
-
--   `qwen-3-coder-480b-free` (Free tier) - High-performance coding model at no cost
--   `qwen-3-coder-480b` - Flagship 480B parameter coding model
--   `qwen-3-235b-a22b-instruct-2507` - Advanced instruction-following model
--   `qwen-3-235b-a22b-thinking-2507` - Reasoning model with step-by-step thinking
--   `llama-3.3-70b` - Meta's Llama 3.3 model optimized for speed
--   `qwen-3-32b` - Compact yet powerful model for general tasks
-
-### Configuration in Cline
-
-1.  **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
-2.  **Select Provider:** Choose "Cerebras" from the "API Provider" dropdown.
-3.  **Enter API Key:** Paste your Cerebras API key into the "Cerebras API Key" field.
-4.  **Select Model:** Choose your desired model from the "Model" dropdown.
-5.  **(Optional) Custom Base URL:** Most users won't need to adjust this setting.
-
-### Cerebras's Wafer-Scale Advantage
-
-Cerebras has fundamentally reimagined AI hardware architecture to solve the inference speed problem:
-
-#### Wafer-Scale Architecture
-Traditional GPUs use separate chips for compute and memory, forcing them to constantly shuttle model weights back and forth. Cerebras built the world's largest AI chip—a wafer-scale engine that stores entire models on-chip. No external memory, no bandwidth bottlenecks, no waiting.
-
-#### Revolutionary Speed
-- **Up to 2,600 tokens per second** - often 20x faster than GPUs
-- **Single-second reasoning** - what used to take minutes now happens instantly
-- **Real-time applications** - reasoning models become practical for interactive use
-- **No bandwidth limits** - entire models stored on-chip eliminate memory bottlenecks
-
-#### The Cerebras Scaling Law
-Cerebras discovered that **faster inference enables smarter AI**. Modern reasoning models generate thousands of tokens as "internal monologue" before answering. On traditional hardware, this takes too long for real-time use. Cerebras makes reasoning models fast enough for everyday applications.
-
-#### Quality Without Compromise
-Unlike other speed optimizations that sacrifice accuracy, Cerebras maintains full model quality while delivering unprecedented speed. You get the intelligence of frontier models with the responsiveness of lightweight ones.
-
-Learn more about Cerebras's technology in their blog posts:
-- [The Cerebras Scaling Law: Faster Inference Is Smarter AI](https://www.cerebras.ai/blog/the-cerebras-scaling-law-faster-inference-is-smarter-ai)
-- [Introducing Cerebras Code](https://www.cerebras.ai/blog/introducing-cerebras-code)
-
-### Cerebras Code Plans
-
-Cerebras offers specialized plans for developers:
-
-#### Code Pro ($50/month)
-- Access to Qwen3-Coder with fast, high-context completions
-- Up to 24 million tokens per day
-- Ideal for indie developers and weekend projects
-- 3-4 hours of uninterrupted coding per day
-
-#### Code Max ($200/month)
-- Heavy coding workflow support
-- Up to 120 million tokens per day
-- Perfect for full-time development and multi-agent systems
-- No weekly limits, no IDE lock-in
-
-### Special Features
-
-#### Free Tier
-The `qwen-3-coder-480b-free` model provides access to high-performance inference at no cost—unique among speed-focused providers.
-
-#### Real-Time Reasoning
-Reasoning models like `qwen-3-235b-a22b-thinking-2507` can complete complex multi-step reasoning in under a second, making them practical for interactive development workflows.
-
-#### Coding Specialization
-Qwen3-Coder models are specifically optimized for programming tasks, delivering performance comparable to Claude Sonnet 4 and GPT-4.1 in coding benchmarks.
-
-#### No IDE Lock-In
-Works with any OpenAI-compatible tool—Cursor, Continue.dev, Cline, or any other editor that supports OpenAI endpoints.
-
-### Tips and Notes
-
--   **Speed Advantage:** Cerebras excels at making reasoning models practical for real-time use. Perfect for agentic workflows that require multiple LLM calls.
--   **Free Tier:** Start with the free model to experience Cerebras speed before upgrading to paid plans.
--   **Context Windows:** Models support context windows ranging from 64K to 128K tokens for including substantial code context.
--   **Rate Limits:** Generous rate limits designed for development workflows. Check your dashboard for current limits.
--   **Pricing:** Competitive pricing with significant speed advantages. Visit [Cerebras Cloud](https://cloud.cerebras.ai/) for current rates.
--   **Real-Time Applications:** Ideal for applications where AI response time matters—code generation, debugging, and interactive development.

docs/provider-config/claude-code.mdx

@@ -1,94 +0,0 @@
----
-title: "Claude Code"
-description: "Use your Claude Max or Pro subscription with Cline instead of paying per token. Learn how to set up and configure the Claude Code provider."
----
-
-**Website:** [https://docs.anthropic.com/en/docs/claude-code/setup](https://docs.anthropic.com/en/docs/claude-code/setup)
-
-The Claude Code provider lets you use your existing Claude subscription with Cline. If you have Claude Max or Pro, this means you can use Claude in Cline without paying extra API costs.
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/claude-code-use-opus.gif"
-		alt="Using the Claude Code provider in Cline with Opus model"
-	/>
-</Frame>
-
-## Setup
-
-First, you'll need to install and authenticate Claude Code on your system:
-
-1. **Install Claude Code**: Follow Anthropic's [official setup guide](https://docs.anthropic.com/en/docs/claude-code/setup) to install and authenticate the Claude CLI.
-
-2. **Configure in Cline**:
-    - Open Cline settings (⚙️ icon)
-    - Select **Claude Code** from the **API Provider** dropdown
-    - Set the path to your Claude CLI executable (usually just `claude` if it's in your PATH)
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/claude-code-setup.gif"
-		alt="Setting up the Claude Code provider in Cline"
-	/>
-</Frame>
-
-<br />
-
-<Accordion title="Windows Setup">
-	Anthropic introduced full support for Claude Code on Windows. Follow the [instructions on how to set up Claude Code
-	normally](#setup) and make sure you have the latest Claude Code and Cline versions.
-</Accordion>
-
-### Finding your Claude Code path
-
-If you're not sure where Claude Code is installed:
-
--   **macOS / Linux**: Run `which claude` in your terminal
--   **Windows (Command Prompt)**: Run `where claude`
--   **Windows (PowerShell)**: Run `Get-Command claude`
-
-## Supported Models
-
-The Claude Code provider supports these models:
-
--   `claude-sonnet-4-20250514` (Recommended)
--   `claude-opus-4-1-20250805`
--   `claude-opus-4-20250514`
--   `claude-3-7-sonnet-20250219`
--   `claude-3-5-sonnet-20241022`
--   `claude-3-5-haiku-20241022`
-
-## How it works
-
-When you use Claude Code with Cline, here's what happens behind the scenes:
-
-Cline wraps the Claude Code CLI to handle your requests. Each time you send a message, Cline starts a new `claude` process, sends your conversation, and streams the response back. The AI reasoning comes from Claude Code, but all the actual file editing, terminal commands, and other tools are handled by Cline.
-
-The main difference you'll notice is that responses don't stream character-by-character like other providers. Instead, Claude Code processes your full request before sending back the complete response.
-
-## Limitations
-
-There are a few things to keep in mind with Claude Code:
-
--   Images in your messages get converted to text placeholders since Claude Code doesn't support image uploads through the CLI
--   Prompt caching isn't available with this provider
--   Responses don't stream in real-time like other providers
-
-## Troubleshooting
-
-If you run into issues:
-
-**Authentication problems**: Make sure you're logged into Claude Code with your subscription account. Run `claude auth status` to check.
-
-**Path issues**: Double-check that the Claude CLI path in Cline's settings is correct. Try running `claude --version` in your terminal to verify it's working.
-
-**Still having trouble?** We're actively improving this integration. Report issues on our [GitHub](https://github.com/cline/cline/issues) or ask for help in our [Discord](https://discord.gg/cline).
-
-## Usage with subscriptions
-
-If you have a Claude Max subscription, your usage in Cline shows up as $0.00 in the billing interface since you're not paying additional API costs. Your usage still counts against your subscription limits, but you won't see per-token charges.
-
-For more details about using Claude Code with your subscription, check out Anthropic's documentation:
-
--   [Claude Code Setup Guide](https://docs.anthropic.com/en/docs/claude-code/setup)
--   [Using Claude Code with Pro/Max Plans](https://support.anthropic.com/en/articles/11145838-using-claude-code-with-your-pro-or-max-plan)

docs/provider-config/doubao.mdx

@@ -1,87 +0,0 @@
----
-title: "Doubao"
-description: "Learn how to configure and use ByteDance's Doubao AI models with Cline. Experience advanced reasoning, multimodal capabilities, and cost-effective inference with Chinese language optimization."
----
-
-Doubao is ByteDance's flagship AI model series, featuring innovative sparse Mixture-of-Experts (MoE) architecture that delivers performance equivalent to much larger models while maintaining cost efficiency. With over 13 million users and advanced multimodal capabilities, Doubao offers competitive alternatives to Western AI systems with particular strength in Chinese language processing.
-
-**Website:** [https://www.volcengine.com/](https://www.volcengine.com/)
-
-### Getting an API Key
-
-1.  **Sign Up/Sign In:** Visit the [Volcano Engine Console](https://console.volcengine.com/). Create an account or sign in.
-2.  **Navigate to Model Service:** Access the AI model service section in the console.
-3.  **Create API Key:** Generate a new API key for the Doubao service.
-4.  **Copy the Key:** Copy the API key immediately and store it securely. You may not be able to view it again.
-
-### Supported Models
-
-Cline supports the following Doubao models:
-
--   `doubao-seed-1-6-250615` (Default) - General purpose model with balanced performance
--   `doubao-seed-1-6-thinking-250715` - Enhanced reasoning model with step-by-step thinking
--   `doubao-seed-1-6-flash-250715` - Speed-optimized model for fast inference
-
-All models feature:
--   **128,000 token context window** for extensive document processing
--   **32,768 max output tokens** for comprehensive responses
--   **Image input support** for multimodal applications
--   **Prompt caching** with 80% discount on cached reads
-
-### Configuration in Cline
-
-1.  **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
-2.  **Select Provider:** Choose "Doubao" from the "API Provider" dropdown.
-3.  **Enter API Key:** Paste your Doubao API key into the "Doubao API Key" field.
-4.  **Select Model:** Choose your desired model from the "Model" dropdown.
-
-**Note:** Doubao uses the base URL `https://ark.cn-beijing.volces.com/api/v3` and servers are located in Beijing, China.
-
-### ByteDance's AI Innovation
-
-Doubao represents ByteDance's strategic entry into the AI model space with several key innovations:
-
-#### Sparse Mixture-of-Experts Architecture
-Doubao 1.5 Pro employs an innovative sparse MoE framework where 20 billion activated parameters deliver performance equivalent to a 140-billion-parameter dense model. This architecture significantly reduces operational costs while maintaining high performance standards.
-
-#### Extended Context Processing
-With context windows ranging from 32,000 to 256,000 tokens, Doubao excels at processing long-form content including legal documents, academic research, market reports, and creative content generation.
-
-#### Multimodal Excellence
-- **Advanced Visual Processing:** Enhanced visual reasoning, document recognition, and fine-grained information understanding
-- **Integrated Speech:** Seamless speech and text token integration with superior emotional continuity
-- **Document Analysis:** Comprehensive document summarization and content processing capabilities
-
-#### Chinese Language Optimization
-Doubao was specifically trained for Chinese language fluency and cultural relevance, providing significant advantages for Chinese-speaking users and applications requiring deep cultural context understanding.
-
-#### Cost Efficiency
-Doubao maintains pricing approximately **half the cost of comparable OpenAI offerings**, making advanced AI more accessible while establishing competitive market positioning.
-
-### Special Features
-
-#### Reasoning Models
-The `doubao-seed-1-6-thinking-250715` model offers enhanced reasoning capabilities with step-by-step thinking processes, making it ideal for complex problem-solving tasks.
-
-#### Multimodal Capabilities
-Unlike traditional cascaded approaches, Doubao integrates speech and text processing seamlessly, enabling more natural voice interactions and comprehensive document analysis.
-
-#### Prompt Caching
-All models support prompt caching with significant cost savings (80% discount on cached reads), making repeated queries more economical.
-
-#### ByteDance Ecosystem Integration
-Doubao integrates vertically with ByteDance properties including TikTok (Douyin), Toutiao, and Feishu, enabling seamless workflow integration across the ecosystem.
-
-### Performance and Benchmarks
-
-Doubao-1.5 Pro-AS1 Preview has demonstrated superior performance compared to OpenAI's O1-preview on specific benchmarks, including surpassing O1 models on AIME tests. The model continues to improve through reinforcement learning, with performance expected to enhance over time.
-
-### Tips and Notes
-
--   **Regional Advantage:** Optimized for Chinese language and cultural contexts, making it ideal for Chinese-speaking users and markets.
--   **Cost Effectiveness:** Approximately 50% lower cost than comparable Western AI models while maintaining competitive performance.
--   **Context Windows:** Large context windows (up to 256K tokens) enable processing of extensive documents and codebases.
--   **Multimodal Applications:** Strong visual and speech processing capabilities make it suitable for diverse multimedia applications.
--   **Server Location:** Servers located in Beijing, China - consider latency implications for global users.
--   **Ecosystem Benefits:** Integration with ByteDance services provides additional workflow advantages for users of TikTok, Toutiao, and Feishu.
--   **Pricing:** Check the Volcano Engine console for current pricing information and regional availability.

docs/provider-config/fireworks-ai.mdx

@@ -1,51 +0,0 @@
----
-title: "Fireworks AI"
-description: "Learn how to configure and use Fireworks AI models with Cline. Access high-performance open-source language models with fast, cost-effective APIs."
----
-
-Cline supports accessing models through the Fireworks AI platform, which offers fast, cost-effective access to a wide range of state-of-the-art open-source language models. Built for speed and reliability, Fireworks AI provides serverless deployment options with OpenAI-compatible APIs and context windows up to 256,000 tokens.
-
-**Website:** [https://fireworks.ai/](https://fireworks.ai/)
-
-### Getting an API Key
-
-1. **Sign Up/Sign In:** Go to [Fireworks AI](https://fireworks.ai/) and create an account or sign in.
-2. **Navigate to API Keys:** After logging in, go to the [API Keys page](https://app.fireworks.ai/settings/users/api-keys) in the account settings.
-3. **Create a Key:** Click "Create API key" and give your key a descriptive name (e.g., "Cline").
-4. **Copy the Key:** **Important:** Copy the API key _immediately_. You will not be able to see it again. Store it securely.
-
-### Supported Models
-
-Cline supports the following Fireworks AI models:
-
--   `accounts/fireworks/models/kimi-k2-instruct` (Default)
--   `accounts/fireworks/models/qwen3-235b-a22b-instruct-2507`
--   `accounts/fireworks/models/qwen3-coder-480b-a35b-instruct`
--   `accounts/fireworks/models/deepseek-r1-0528`
--   `accounts/fireworks/models/deepseek-v3`
-
-**Model Details:**
-
-| Model | Context Window | Best For | Pricing (per 1M tokens) |
-|-------|----------------|----------|-------------------------|
-| Kimi K2 | 128K | General tasks, agentic capabilities | \$0.60 input, \$2.50 output |
-| Qwen3 235B | 256K | Cost-effective general use | \$0.22 input, \$0.88 output |
-| Qwen3 Coder | 256K | Code generation and debugging | \$0.45 input, \$1.80 output |
-| DeepSeek R1 | 160K | Complex reasoning, function calling | \$3.00 input, \$8.00 output |
-| DeepSeek V3 | 128K | Strong general performance | \$0.90 input, \$0.90 output |
-
-### Configuration in Cline
-
-1. **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
-2. **Select Provider:** Choose "Fireworks AI" from the "API Provider" dropdown.
-3. **Enter API Key:** Paste your Fireworks AI API key into the "Fireworks AI API Key" field.
-4. **Select Model:** Choose your desired model from the "Model" dropdown. The default model is Kimi K2.
-
-### Tips and Notes
-
--   **Cost-Effective:** Fireworks AI offers significantly lower pricing than proprietary models while maintaining competitive performance.
--   **Large Context Windows:** Most models support 128K-256K tokens, suitable for processing large documents and maintaining extended conversations.
--   **OpenAI Compatibility:** The provider uses an OpenAI-compatible API format with streaming support and usage tracking.
--   **Rate Limits:** Fireworks AI has usage-based rate limits. Monitor your usage in the dashboard and consider upgrading your plan if needed.
--   **API Keys:** Stored locally on your machine for security.
--   **Pricing:** See the [Fireworks AI pricing page](https://fireworks.ai/pricing) for current rates. Prices shown are per million tokens.

docs/provider-config/fireworks.mdx

@@ -1,131 +0,0 @@
----
-title: "Fireworks AI"
-description: "Learn how to configure and use Fireworks AI's lightning-fast inference platform with Cline. Experience up to 4x faster inference speeds with optimized models and competitive pricing."
----
-
-Fireworks AI is a leading infrastructure platform for generative AI that focuses on delivering exceptional performance through optimized inference capabilities. With up to 4x faster inference speeds than alternative platforms and support for over 40 different AI models, Fireworks eliminates the operational complexity of running AI models at scale.
-
-**Website:** [https://fireworks.ai/](https://fireworks.ai/)
-
-### Getting an API Key
-
-1.  **Sign Up/Sign In:** Go to [Fireworks AI](https://fireworks.ai/) and create an account or sign in.
-2.  **Navigate to API Keys:** Access the API keys section in your dashboard.
-3.  **Create a Key:** Generate a new API key. Give it a descriptive name (e.g., "Cline").
-4.  **Copy the Key:** Copy the API key immediately. Store it securely.
-
-### Supported Models
-
-Fireworks AI supports a wide variety of models across different categories. Popular models include:
-
-**Text Generation Models:**
--   Llama 3.1 series (8B, 70B, 405B)
--   Mixtral 8x7B and 8x22B
--   Qwen 2.5 series
--   DeepSeek models with reasoning capabilities
--   Code Llama models for programming tasks
-
-**Vision Models:**
--   Llama 3.2 Vision models
--   Qwen 2-VL models
-
-**Embedding Models:**
--   Various text embedding models for semantic search
-
-The platform curates, optimizes, and deploys models with custom kernels and inference optimizations for maximum performance.
-
-### Configuration in Cline
-
-1.  **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
-2.  **Select Provider:** Choose "Fireworks" from the "API Provider" dropdown.
-3.  **Enter API Key:** Paste your Fireworks API key into the "Fireworks API Key" field.
-4.  **Enter Model ID:** Specify the model you want to use (e.g., "accounts/fireworks/models/llama-v3p1-70b-instruct").
-5.  **Configure Tokens:** Optionally set max completion tokens and context window size.
-
-### Fireworks AI's Performance Focus
-
-Fireworks AI's competitive advantages center on performance optimization and developer experience:
-
-#### Lightning-Fast Inference
-- **Up to 4x faster inference** than alternative platforms
-- **250% higher throughput** compared to open source inference engines
-- **50% faster speed** with significantly reduced latency
-- **6x lower cost** than HuggingFace Endpoints with 2.5x generation speed
-
-#### Advanced Optimization Technology
-- **Custom kernels** and inference optimizations increase throughput per GPU
-- **Multi-LoRA architecture** enables efficient resource sharing
-- **Hundreds of fine-tuned model variants** can run on shared base model infrastructure
-- **Asset-light model** focuses on optimization software rather than expensive GPU ownership
-
-#### Comprehensive Model Support
-- **40+ different AI models** curated and optimized for performance
-- **Multiple GPU types** supported: A100, H100, H200, B200, AMD MI300X
-- **Pay-per-GPU-second billing** with no extra charges for start-up times
-- **OpenAI API compatibility** for seamless integration
-
-### Pricing Structure
-
-Fireworks AI uses a usage-based pricing model with competitive rates:
-
-#### Text and Vision Models (2025)
-| Parameter Count | Price per 1M Input Tokens |
-|---|---|
-| Less than 4B parameters | $0.10 |
-| 4B - 16B parameters | $0.20 |
-| More than 16B parameters | $0.90 |
-| MoE 0B - 56B parameters | $0.50 |
-
-#### Fine-Tuning Services
-| Base Model Size | Price per 1M Training Tokens |
-|---|---|
-| Up to 16B parameters | $0.50 |
-| 16.1B - 80B parameters | $3.00 |
-| DeepSeek R1 / V3 | $10.00 |
-
-#### Dedicated Deployments
-| GPU Type | Price per Hour |
-|---|---|
-| A100 80GB | $2.90 |
-| H100 80GB | $5.80 |
-| H200 141GB | $6.99 |
-| B200 180GB | $11.99 |
-| AMD MI300X | $4.99 |
-
-### Special Features
-
-#### Fine-Tuning Capabilities
-Fireworks offers sophisticated fine-tuning services accessible through CLI interface, supporting JSON-formatted data from databases like MongoDB Atlas. Fine-tuned models cost the same as base models for inference.
-
-#### Developer Experience
-- **Browser playground** for direct model interaction
-- **REST API** with OpenAI compatibility
-- **Comprehensive cookbook** with ready-to-use recipes
-- **Multiple deployment options** from serverless to dedicated GPUs
-
-#### Enterprise Features
-- **HIPAA and SOC 2 Type II compliance** for regulated industries
-- **Self-serve onboarding** for developers
-- **Enterprise sales** for larger deployments
-- **Post-paid billing options** and Business tier
-
-#### Reasoning Model Support
-Advanced support for reasoning models with `<think>` tag processing and reasoning content extraction, making complex multi-step reasoning practical for real-time applications.
-
-### Performance Advantages
-
-Fireworks AI's optimization delivers measurable improvements:
-- **250% higher throughput** vs open source engines
-- **50% faster speed** with reduced latency
-- **6x cost reduction** compared to alternatives
-- **2.5x generation speed** improvement per request
-
-### Tips and Notes
-
--   **Model Selection:** Choose models based on your specific use case - smaller models for speed, larger models for complex reasoning.
--   **Performance Focus:** Fireworks excels at making AI inference fast and cost-effective through advanced optimizations.
--   **Fine-Tuning:** Leverage fine-tuning capabilities to improve model accuracy with your proprietary data.
--   **Compliance:** HIPAA and SOC 2 Type II compliance enables use in regulated industries.
--   **Pricing Model:** Usage-based pricing scales with your success rather than traditional seat-based models.
--   **Developer Resources:** Extensive documentation and cookbook recipes accelerate implementation.
--   **GPU Options:** Multiple GPU types available for dedicated deployments based on performance needs.

docs/provider-config/groq.mdx

@@ -1,80 +0,0 @@
----
-title: "Groq"
-description: "Learn how to configure and use Groq's lightning-fast inference with Cline. Access models from OpenAI, Meta, DeepSeek, and more on Groq's purpose-built LPU architecture."
----
-
-Groq provides ultra-fast AI inference through their custom LPU™ (Language Processing Unit) architecture, purpose-built for inference rather than adapted from training hardware. Groq hosts open-source models from various providers including OpenAI, Meta, DeepSeek, Moonshot AI, and others.
-
-**Website:** [https://groq.com/](https://groq.com/)
-
-### Getting an API Key
-
-1.  **Sign Up/Sign In:** Go to [Groq](https://groq.com/) and create an account or sign in.
-2.  **Navigate to Console:** Go to the [Groq Console](https://console.groq.com/) to access your dashboard.
-3.  **Create a Key:** Navigate to the API Keys section and create a new API key. Give your key a descriptive name (e.g., "Cline").
-4.  **Copy the Key:** Copy the API key immediately. You will not be able to see it again. Store it securely.
-
-### Supported Models
-
-Cline supports the following Groq models:
-
--   `llama-3.3-70b-versatile` (Meta) - Balanced performance with 131K context
--   `llama-3.1-8b-instant` (Meta) - Fast inference with 131K context  
--   `openai/gpt-oss-120b` (OpenAI) - Featured flagship model with 131K context
--   `openai/gpt-oss-20b` (OpenAI) - Featured compact model with 131K context
--   `moonshotai/kimi-k2-instruct` (Moonshot AI) - 1 trillion parameter model with prompt caching
--   `deepseek-r1-distill-llama-70b` (DeepSeek/Meta) - Reasoning-optimized model
--   `qwen/qwen3-32b` (Alibaba Cloud) - Enhanced for Q&A tasks
--   `meta-llama/llama-4-maverick-17b-128e-instruct` (Meta) - Latest Llama 4 variant
--   `meta-llama/llama-4-scout-17b-16e-instruct` (Meta) - Latest Llama 4 variant
-
-### Configuration in Cline
-
-1.  **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
-2.  **Select Provider:** Choose "Groq" from the "API Provider" dropdown.
-3.  **Enter API Key:** Paste your Groq API key into the "Groq API Key" field.
-4.  **Select Model:** Choose your desired model from the "Model" dropdown.
-
-### Groq's Speed Revolution
-
-Groq's LPU architecture delivers several key advantages over traditional GPU-based inference:
-
-#### LPU Architecture
-Unlike GPUs that are adapted from training workloads, Groq's LPU is purpose-built for inference. This eliminates architectural bottlenecks that create latency in traditional systems.
-
-#### Unmatched Speed
-- **Sub-millisecond latency** that stays consistent across traffic, regions, and workloads
-- **Static scheduling** with pre-computed execution graphs eliminates runtime coordination delays
-- **Tensor parallelism** optimized for low-latency single responses rather than high-throughput batching
-
-#### Quality Without Tradeoffs
-- **TruePoint numerics** reduce precision only in areas that don't affect accuracy
-- **100-bit intermediate accumulation** ensures lossless computation
-- **Strategic precision control** maintains quality while achieving 2-4× speedup over BF16
-
-#### Memory Architecture
-- **SRAM as primary storage** (not cache) with hundreds of megabytes on-chip
-- **Eliminates DRAM/HBM latency** that plagues traditional accelerators
-- **Enables true tensor parallelism** by splitting layers across multiple chips
-
-Learn more about Groq's technology in their [LPU architecture blog post](https://groq.com/blog/inside-the-lpu-deconstructing-groq-speed).
-
-### Special Features
-
-#### Prompt Caching
-The Kimi K2 model supports prompt caching, which can significantly reduce costs and latency for repeated prompts.
-
-#### Vision Support
-Select models support image inputs and vision capabilities. Check the model details in the Groq Console for specific capabilities.
-
-#### Reasoning Models
-Some models like DeepSeek variants offer enhanced reasoning capabilities with step-by-step thought processes.
-
-### Tips and Notes
-
--   **Model Selection:** Choose models based on your specific use case and performance requirements.
--   **Speed Advantage:** Groq excels at single-request latency rather than high-throughput batch processing.
--   **OSS Model Provider:** Groq hosts open-source models from multiple providers (OpenAI, Meta, DeepSeek, etc.) on their fast infrastructure.
--   **Context Windows:** Most models offer large context windows (up to 131K tokens) for including substantial code and context.
--   **Pricing:** Groq offers competitive pricing with their speed advantages. Check the [Groq Pricing](https://groq.com/pricing) page for current rates.
--   **Rate Limits:** Groq has generous rate limits, but check their documentation for current limits based on your usage tier.

docs/provider-config/openai-compatible.mdx

@@ -43,6 +43,7 @@ While the "OpenAI Compatible" provider type allows connecting to various endpoin
 -   `o1`
 -   `o1-preview`
 -   `o1-mini`
+-   `gpt-4.5-preview`
 -   `gpt-4o`
 -   `gpt-4o-mini`
 

docs/provider-config/openai.mdx

@@ -26,6 +26,7 @@ Cline is compatible with a variety of OpenAI models, including but not limited t
 -   `o1`
 -   `o1-preview`
 -   `o1-mini`
+-   `gpt-4.5-preview`
 -   `gpt-4o`
 -   `gpt-4o-mini`
 -   'gpt-4.1'

docs/provider-config/requesty.mdx

@@ -10,7 +10,7 @@ Cline supports accessing models through the [Requesty](https://www.requesty.ai/)
 ### Getting an API Key
 
 1.  **Sign Up/Sign In:** Go to the [Requesty website](https://www.requesty.ai/) and create an account or sign in.
-2.  **Get API Key:** You can get an API key from the [API Management](https://app.requesty.ai/api-keys) section of your Requesty dashboard.
+2.  **Get API Key:** You can get an API key from the [API Management](https://app.requesty.ai/manage-api) section of your Requesty dashboard.
 
 ### Supported Models
 
@@ -26,7 +26,7 @@ Requesty provides access to a wide range of models. Cline will automatically fet
 ### Tips and Notes
 
 -   **Optimizations**: Requesty offers a range of in-flight cost optimizations to lower your costs.
--   **Unified and simplified billing**: Unrestricted access to all providers and models, automatic balance top ups and more via a single [API key](https://app.requesty.ai/api-keys).
+-   **Unified and simplified billing**: Unrestricted access to all providers and models, automatic balance top ups and more via a single [API key](https://app.requesty.ai/manage-api).
 -   **Cost tracking**: Track cost per model, coding language, changed file, and more via the [Cost dashboard](https://app.requesty.ai/cost-management) or the [Requesty VS Code extension](https://marketplace.visualstudio.com/items?itemName=Requesty.requesty).
 -   **Stats and logs**: See your [coding stats dashboard](https://app.requesty.ai/usage-stats) or go through your [LLM interaction logs](https://app.requesty.ai/logs).
 -   **Fallback policies**: Keep your LLM working for you with fallback policies when providers are down.

docs/provider-config/sap-aicore.mdx

@@ -1,76 +0,0 @@
----
-title: "SAP AI Core"
-description: "Learn how to configure and use LLM models from Generative AI Hub in SAP AI Core with Cline."
----
-
-SAP AI Core and the generative AI hub help you to integrate LLMs and AI into new business processes in a cost-efficient manner.
-
-**Website:** [SAP Help Portal](https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/what-is-sap-ai-core)
-
-
-> 💡 **Information**
->
-> SAP AI Core, and Generative AI Hub, are offerings from SAP BTP.
-> You need an active SAP BTP contract and a existing subaccount with a SAP AI Core instance with the `extended` service plan (For more details about SAP AI Core service plans and their capabilities, see the [Service Plans documentation](https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/service-plans)) to perform these steps.
-
-### Getting a Service Binding
-
-1. **Access:** Go to your subaccount via [BTP Cloud Cockpit](cockpit.btp.cloud.sap/cockpit)
-2. **Create a Service Binding:** Go to "Instances and Subscriptions", select your SAP AI Core service instance and click on Service Bindings > Create.
-3. **Copy the Service Binding:** Copy the service binding values.
-
-### Supported Models
-
-SAP AI Core supports a large and growing number of models.
-Refer to the [Generative AI Hub Supported Models page](https://me.sap.com/notes/3437766) for the complete and up-to-date list.
-
-### Configuration in Cline
-
-1.  **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
-2.  **Select Provider:** Choose "SAP AI Core" from the "API Provider" dropdown.
-3.  **Enter Client Id:** Add the `.clientid` field from the service binding into the "AI Core Client Id" field.
-4.  **Enter Client Secret:** Add the `.clientsecret` field from the service binding into the "AI Core Client Secret" field.
-5.  **Enter Base URL:** Add the `.serviceurls.AI_API_URL` field from the service binding into the "AI Core Base URL" field.
-6.  **Enter Auth URL:** Add the `.url` field from the service binding into the "AI Core Auth URL" field.
-7.  **Enter Resource Group:** Add the resource group where you have your model deployments. See [Create a Deployment for a Generative AI Model](https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/create-deployment-for-generative-ai-model-in-sap-ai-core).
-8.  **Configure Orchestration Mode:** If you have an `extended` service plan, the "Orchestration Mode" checkbox will automatically appear.
-9.  **Select Model:** Choose your desired model from the "Model" dropdown.
-
-### Orchestration Mode vs Native API
-
-**Orchestration Mode:**
-- **Simplified usage:** Provides access to all available models without requiring individual deployments using the [Harmonized API](https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/harmonized-api)
-
-**Native API Mode:**
-- **Manual deployments:** Requires manual model deployment and management in your SAP AI Core service instance
-
-### Tips and Notes
-
-- **Service Plan Requirement:** You must have the SAP AI Core `extended` service plan to use LLMs with Cline. Other service plans do not provide access to Generative AI Hub.
-
-- **Orchestration Mode (Recommended):** Keep Orchestration Mode enabled for the simplest setup. It provides automatic access to all available models without requiring manual deployments.
-
-- **Native API Mode:** Only disable Orchestration Mode if you have specific requirements that necessitate direct AI Core API access or need features not supported by the orchestration mode.
-
-- **When using Native API Mode:**
-    -   **Model Selection:** The model dropdown displays models in two separate lists:
-        -   **Deployed Models:** These models are already deployed in your specified resource group and are ready to use immediately.
-        -   **Not Deployed Models:** These models don't have active deployments in your specified resource group. You won't be able to use these models until you create deployments for them in SAP AI Core.
-    -   **Creating Deployments:** To use a model that has not been deployed yet, you'll need to create a deployment in your SAP AI Core service instance. See [Create a Deployment for a Generative AI Model](https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/create-deployment-for-generative-ai-model-in-sap-ai-core) for instructions.
-
-#### Configuring Reasoning Effort for OpenAI Models
-
-When using OpenAI reasoning models (such as o1, o3, o3-mini, o4-mini) through SAP AI Core, you can control the reasoning effort to balance performance and cost:
-
-1. **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
-2. **Navigate to Features:** Go to the "Features" section in the settings.
-3. **Find OpenAI Reasoning Effort:** Locate the "OpenAI Reasoning Effort" setting.
-4. **Choose Effort Level:** Select between:
-   - **Low:** Faster responses with lower token usage, suitable for simpler tasks
-   - **Medium:** Balanced performance and token usage for most tasks
-   - **High:** More thorough analysis with higher token usage, better for complex reasoning tasks
-
-> 💡 **Note**
->
-> This setting only applies when using OpenAI reasoning models (o1, o3, o3-mini, o4-mini, gpt-5, etc.) deployed through SAP AI Core. Other models will ignore this setting.
-

docs/provider-config/vercel-ai-gateway.mdx

@@ -1,98 +0,0 @@
----
-title: "Vercel AI Gateway"
-description: "Use Vercel AI Gateway in Cline to reach 100+ models from one endpoint with routing, retries, and spend observability."
----
-
-Vercel AI Gateway gives you a single API to access models from many providers. You switch by model id without swapping SDKs or juggling multiple keys. Cline integrates directly so you can pick a Gateway model in the dropdown, use it like any other provider, and see token and cache usage in the stream.
-
-Useful links:
-- Team dashboard: https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai
-- Models catalog: https://vercel.com/ai-gateway/models
-- Docs: https://vercel.com/docs/ai-gateway
-
-## What you get
-
-- One endpoint for 100+ models with a single key
-- Automatic retries and fallbacks that you configure on the dashboard
-- Spend monitoring with requests by model, token counts, cache usage, latency percentiles, and cost
-- OpenAI-compatible surface so existing clients work
-
-## Getting an API Key
-
-1. Sign in at https://vercel.com
-2. Dashboard → AI Gateway → API Keys → Create key
-3. Copy the key
-
-For more on authentication and OIDC options, see https://vercel.com/docs/ai-gateway/authentication
-
-## Configuration in Cline
-
-1. Open Cline settings
-2. Select **Vercel AI Gateway** as the API Provider
-3. Paste your Gateway API Key
-4. Pick a model from the list. Cline fetches the catalog automatically. You can also paste an exact id
-
-Notes:
-- Model ids often follow `provider/model`. Copy the exact id from the catalog  
-  Examples:
-  - `openai/gpt-5`
-  - `anthropic/claude-sonnet-4`
-  - `google/gemini-2.5-pro`
-  - `groq/llama-3.1-70b`
-  - `deepseek/deepseek-v3`
-
-## Observability you can act on
-
-<Frame>
-  <img src="https://assets.vercel.com/image/upload/v1753121283/gateway-overhead-dark_zhqwwj.svg" alt="Vercel AI Gateway observability with requests by model, tokens, cache, latency, and cost." />
-</Frame>
-
-What to watch:
-- Requests by model - confirm routing and adoption
-- Tokens - input vs output, including reasoning if exposed
-- Cache - cached input and cache creation tokens
-- Latency - p75 duration and p75 time to first token
-- Cost - per project and per model
-
-Use it to:
-- Compare output tokens per request before and after a model change
-- Validate cache strategy by tracking cache reads and write creation
-- Catch TTFT regressions during experiments
-- Align budgets with real usage
-
-## Supported models
-
-The gateway supports a large and changing set of models. Cline pulls the list from the Gateway API and caches it locally. For the current catalog, see https://vercel.com/ai-gateway/models
-
-## Tips
-
-<Tip>
-Use separate gateway keys per environment (dev, staging, prod). It keeps dashboards clean and budgets isolated.
-</Tip>
-
-<Note>
-Pricing is pass-through at provider list price. Bring-your-own key has 0% markup. You still pay provider and processing fees.
-</Note>
-
-<Info>
-Vercel does not add rate limits. Upstream providers may. New accounts receive $5 credits every 30 days until the first payment.
-</Info>
-
-## Troubleshooting
-
-- 401 - send the Gateway key to the Gateway endpoint, not an upstream URL
-- 404 model - copy the exact id from the Vercel catalog
-- Slow first token - check p75 TTFT in the dashboard and try a model optimized for streaming
-- Cost spikes - break down by model in the dashboard and cap or route traffic
-
-## Inspiration
-
-- Multi-model evals - swap only the model id in Cline and compare latency and output tokens
-- Progressive rollout - route a small percent to a new model in the dashboard and ramp with metrics
-- Budget enforcement - set per-project limits without code changes
-
-## Crosslinks
-
-- OpenAI-Compatible setup: /provider-config/openai-compatible
-- Model Selection Guide: /getting-started/model-selection-guide
-- Understanding Context Management: /getting-started/understanding-context-management

docs/provider-config/zai.mdx

@@ -1,124 +0,0 @@
----
-title: "Z AI (Zhipu AI)"
-description: "Learn how to configure and use Z AI's GLM-4.5 models with Cline. Experience advanced hybrid reasoning, agentic capabilities, and open-source excellence with regional optimization."
----
-
-Z AI (formerly Zhipu AI) offers the groundbreaking GLM-4.5 series, featuring hybrid reasoning capabilities and agentic AI design. Released in July 2025, these models excel in unified reasoning, coding, and intelligent agent applications while maintaining open-source accessibility under MIT license.
-
-**Website:** [https://z.ai/model-api](https://z.ai/model-api) (International) | [https://open.bigmodel.cn/](https://open.bigmodel.cn/) (China)
-
-### Getting an API Key
-
-#### International Users
-1.  **Sign Up/Sign In:** Go to [https://z.ai/model-api](https://z.ai/model-api). Create an account or sign in.
-2.  **Navigate to API Keys:** Access your account dashboard and find the API keys section.
-3.  **Create a Key:** Generate a new API key for your application.
-4.  **Copy the Key:** Copy the API key immediately and store it securely.
-
-#### China Mainland Users
-1.  **Sign Up/Sign In:** Go to [https://open.bigmodel.cn/](https://open.bigmodel.cn/). Create an account or sign in.
-2.  **Navigate to API Keys:** Access your account dashboard and find the API keys section.
-3.  **Create a Key:** Generate a new API key for your application.
-4.  **Copy the Key:** Copy the API key immediately and store it securely.
-
-### Supported Models
-
-Z AI provides different model catalogs based on your selected region:
-
-#### GLM-4.5 Series
--   **GLM-4.5** - Flagship model with 355B total parameters, 32B active parameters
--   **GLM-4.5-Air** - Compact model with 106B total parameters, 12B active parameters
-
-#### GLM-4.5 Hybrid Reasoning Models
--   **GLM-4.5 (Thinking Mode)** - Advanced reasoning with step-by-step analysis
--   **GLM-4.5-Air (Thinking Mode)** - Efficient reasoning for mainstream hardware
-
-All models feature:
--   **128,000 token context window** for extensive document processing
--   **Mixture of Experts (MoE) architecture** for optimal performance
--   **Agent-native design** integrating reasoning, coding, and tool usage
--   **Open-source availability** under MIT license
-
-### Configuration in Cline
-
-1.  **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
-2.  **Select Provider:** Choose "Z AI" from the "API Provider" dropdown.
-3.  **Select Region:** Choose your region:
-    -   "International" for global access
-    -   "China" for mainland China access
-4.  **Enter API Key:** Paste your Z AI API key into the "Z AI API Key" field.
-5.  **Select Model:** Choose your desired model from the "Model" dropdown.
-
-### Z AI's Hybrid Intelligence
-
-Z AI's GLM-4.5 series introduces revolutionary capabilities that set it apart from conventional language models:
-
-#### Hybrid Reasoning Architecture
-GLM-4.5 operates in two distinct modes:
-- **Thinking Mode:** Designed for complex reasoning tasks and tool usage, engaging in deeper analytical processes
-- **Non-Thinking Mode:** Provides immediate responses for straightforward queries, optimizing efficiency
-
-This dual-mode architecture represents an "agent-native" design philosophy that adapts processing intensity based on query complexity.
-
-#### Exceptional Performance
-GLM-4.5 achieves a comprehensive score of **63.2** across 12 benchmarks spanning agentic tasks, reasoning, and coding challenges, securing **3rd place** among all proprietary and open-source models. GLM-4.5-Air maintains competitive performance with a score of **59.8** while delivering superior efficiency.
-
-#### Mixture of Experts Excellence
-The sophisticated MoE architecture optimizes performance while maintaining computational efficiency:
-- **GLM-4.5:** 355B total parameters with 32B active parameters
-- **GLM-4.5-Air:** 106B total parameters with 12B active parameters
-
-#### Extended Context Capabilities
-The 128,000-token context window enables comprehensive understanding of lengthy documents and codebases, with real-world testing confirming effective processing of nearly 2,000-line codebases while maintaining remarkable performance.
-
-#### Open-Source Leadership
-Released under MIT license, GLM-4.5 provides researchers and developers with access to state-of-the-art capabilities without proprietary restrictions, including base models, hybrid reasoning versions, and optimized FP8 variants.
-
-### Regional Optimization
-
-#### API Endpoints
-- **International:** Uses `https://api.z.ai/api/paas/v4`
-- **China:** Uses `https://open.bigmodel.cn/api/paas/v4`
-
-#### Model Availability
-The region setting determines both API endpoint and available models, with automatic filtering to ensure compatibility with your selected region.
-
-### Special Features
-
-#### Agentic Capabilities
-GLM-4.5's unified architecture makes it particularly suitable for complex intelligent agent applications requiring integrated reasoning, coding, and tool utilization capabilities.
-
-#### Comprehensive Benchmarking
-Performance evaluation encompasses:
-- **3 agentic task benchmarks**
-- **7 reasoning benchmarks** 
-- **2 coding benchmarks**
-
-This comprehensive assessment demonstrates versatility across diverse AI applications.
-
-#### Developer Integration
-Models support integration through multiple frameworks:
-- **transformers**
-- **vLLM**
-- **SGLang**
-
-Complete with dedicated model code, tool parser, and reasoning parser implementations.
-
-### Performance Comparisons
-
-#### vs Claude 4 Sonnet
-GLM-4.5 shows competitive performance in agentic coding and reasoning tasks, though Claude Sonnet 4 maintains advantages in coding success rates and autonomous multi-feature application development.
-
-#### vs GPT-4.5
-GLM-4.5 ranks competitively in reasoning and agent benchmarks, with GPT-4.5 generally leading in raw task accuracy on professional benchmarks like MMLU and AIME.
-
-### Tips and Notes
-
--   **Region Selection:** Choose the appropriate region for optimal performance and compliance with local regulations.
--   **Model Selection:** GLM-4.5 for maximum performance, GLM-4.5-Air for efficiency and mainstream hardware compatibility.
--   **Context Advantage:** Large 128K context window enables processing of substantial codebases and documents.
--   **Open Source Benefits:** MIT license enables both commercial use and secondary development.
--   **Agentic Applications:** Particularly strong for applications requiring reasoning, coding, and tool usage integration.
--   **Hybrid Reasoning:** Use Thinking Mode for complex problems, Non-Thinking Mode for simple queries.
--   **API Compatibility:** OpenAI-compatible API provides streaming responses and usage reporting.
--   **Framework Support:** Multiple integration options available for different deployment scenarios.

docs/troubleshooting/terminal-integration-guide.mdx

@@ -1,446 +0,0 @@
----
-title: "Terminal Integration Troubleshooting Guide"
-sidebarTitle: "Terminal Troubleshooting"
-description: "Complete guide to resolving terminal integration issues in Cline"
----
-
-This guide helps you resolve terminal integration issues in Cline. Terminal integration is crucial for Cline to execute commands and read their output, enabling it to understand errors, test results, and command responses.
-
-<Tip>
-	If you're experiencing terminal issues, try switching to a simpler shell like `bash` in the Cline settings, under "Terminal Settings"
-
-    This resolves most terminal integration problems.
-
-</Tip>
-
-## Quick Diagnosis Flowchart
-
-Follow this flowchart to quickly identify your issue:
-
-```mermaid
-graph TD
-    A[Terminal Issue] --> B{Can Cline execute commands?}
-    B -->|No| C[Shell Integration Unavailable]
-    B -->|Yes| D{Can Cline see the output?}
-    D -->|No| E[Output Capture Failed]
-    D -->|Yes| F{Is the output corrupted?}
-    F -->|Yes| G[Character Filtering Issue]
-    F -->|No| H{Does the command hang?}
-    H -->|Yes| I[Long-Running Command Issue]
-    H -->|No| J[Check Terminal Settings]
-
-    C --> K[Try Solution 1]
-    E --> L[Try Solution 2]
-    G --> M[Try Solution 3]
-    I --> N[Try Solution 4]
-
-    style A fill:#f9f,stroke:#333,stroke-width:2px
-    style K fill:#9f9,stroke:#333,stroke-width:2px
-    style L fill:#9f9,stroke:#333,stroke-width:2px
-    style M fill:#9f9,stroke:#333,stroke-width:2px
-    style N fill:#9f9,stroke:#333,stroke-width:2px
-```
-
-## Common Issues & Quick Solutions
-
-### 1. Shell Integration Unavailable
-
-**Symptoms:**
-
--   Message: "Shell Integration Unavailable"
--   Commands execute but Cline can't read output
--   Terminal works fine manually but not with Cline
-
-**Quick Solutions:**
-
-#### macOS
-
--   **Switch to bash**
-
-    1. Go to Cline Settings
-    2. Left-Click the **"Terminal Settings"** tab
-    3. Navigate to **"Default Terminal Profile"** and select **"bash"** from the drop-down menu
-
--   **Disable Oh-My-Zsh temporarily**:
-
-    1. If using zsh, enter `mv ~/.zshrc ~/.zshrc.backup` into the terminal
-    2. Restart VSCode
-
--   **Set environment**:
-    1.a For Zsh users, use one of the following Zsh commands to edit your shell profile:
-
-          - `nano ~/.zshrc`
-          - `vim ~/.zshrc`
-          - `code ~/.zshrc`
-
-    1.b For Bash users
-
-          - nano ~/.bash_profile
-
-    2. Add the following to your shell config: `export TERM=xterm-256color`
-    3. Save your configuration
-
-#### Windows
-
--   **Use PowerShell 7**
-
-    1. Install from Microsoft Store
-    2. Go to Cline Settings
-    3. Left-Click the **"Terminal Settings"** tab
-    4. Navigate to **"Default Terminal Profile"** and select **"PowerShell 7"** from the drop-down menu
-
--   **Disable Windows ConPTY**
-
-    1. Navigate to your VSCode Settings
-    2. Enter "Integrated: Windows Enable Conpty" into the Settings searchbar
-    3. Uncheck the option
-
--   **Try Command Prompt**
-    1. Go to Cline Settings
-    2. Left-Click the **"Terminal Settings"** tab
-    3. Navigate to **"Default Terminal Profile"** and select **"Command Prompt"** from the drop-down menu
-
-#### Linux
-
--   **Use bash**
-
-    1. Go to Cline Settings
-    2. Left-Click the **"Terminal Settings"** tab
-    3. Navigate to **"Default Terminal Profile"** and select **"bash"** from the drop-down menu
-
--   **Check permissions**
-
-    1. Ensure VSCode has terminal access permissions
-
--   **Disable custom prompts**
-    1. Comment out prompt customizations in `.bashrc`
-
-### 2. Command Output Not Visible
-
-**Symptoms:**
-
--   Cline states in chat: "[Command is running but producing no output]"
--   Commands complete but Cline doesn't see results
--   Commands work sometimes but not consistently
-
-**Solutions:**
-
--   **Increase Shell Integration Timeout**
-
-    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
-    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
-    3. Navigate to "Shell integration timeout (seconds)" and enter **"10"** into the text field
-
--   **Disable Terminal Reuse**
-
-    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
-    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
-    3. Look for **"Enable aggressive terminal reuse"**, and **uncheck** this option
-
--   **Check for interfering extensions**
-    1. Disable other terminal-related VSCode extensions
-
-### 3. Character Filtering Issues
-
-**Symptoms:**
-
--   Commas missing from output (JSON appears corrupted)
--   Special characters stripped from terminal output
--   Syntax errors that don't appear when running manually
-
-**Solution:**
-This is a known bug in output processing. Workarounds:
-
--   Recommend AI to use file output instead
-    1. Tell Cline in chat or Cline rules, to use `command > output.txt` before reading the file/s
-
-<Tip>
-	This family of issues is only partially solved in the latest Cline versions, so if you still face this, create a GitHub issue
-	if it is a persistent problem.
-</Tip>
-
-### 4. Long-Running Commands & Progress Bars
-
-**Symptoms:**
-
--   Docker builds never complete in Cline
--   Progress bars consume thousands of tokens
--   The Cline button "Proceed while running" doesn't work properly in chat
-
-<Tip>
-	This family of issues has been solved in latest Cline versions but if you still face any issues, then create a GitHub issue
-	for this.
-</Tip>
-
-## Terminal Settings Explained
-
-Access these in Cline by clicking the settings icon, and navigating to the "Terminal Settings" section:
-
-### Default Terminal Profile
-
--   **What it does**: Selects which shell Cline uses for commands
--   **When to change**: If experiencing shell integration issues with your default shell
--   **Recommended**: - macOS: bash (if zsh has issues) - Windows: PowerShell 7 - Linux: bash
-
-### Shell Integration Timeout
-
--   **What it does**: How long Cline waits for the terminal to be ready
--   **Default**: 4 seconds
--   **When to increase**:
-    -   Slow shell startup (heavy .zshrc/.bashrc)
-    -   WSL environments
-    -   SSH connections
--   **Recommended**: - Start with 10 seconds if having issues
-
-### Enable Aggressive Terminal Reuse
-
--   **What it does**: Reuses existing terminals even if not in the correct directory
--   **When to disable**:
-    -   Commands execute in wrong directory
-    -   Virtual environment issues
-    -   Terminal state corruption
--   **Trade-off**: - Disabling creates more terminals but ensures clean state
-
-### Terminal Output Line Limit
-
--   **What it does**: Limits how many lines Cline reads from terminal output
--   **Default**: 500 lines
--   **When to adjust**:
-    -   Increase for verbose build outputs
-    -   Decrease if hitting token limits
-    -   Set to 100 for commands with progress bars
-
-## Platform-Specific Solutions
-
-### macOS Issues
-
-#### Oh-My-Zsh Conflicts
-
-Oh-My-Zsh often interferes with shell integration. Solutions:
-
-1. Create a minimal `.zshrc` for VSCode:
-    ```bash
-    # ~/.zshrc-vscode
-    export TERM=xterm-256color
-    export PAGER=cat
-    # Minimal PATH and environment setup
-    ```
-2. Configure VSCode to use it:
-    ```json
-    {
-    	"terminal.integrated.env.osx": {
-    		"ZDOTDIR": "~/.zshrc-vscode"
-    	}
-    }
-    ```
-
-#### macOS 15+ Issues
-
-Recent macOS versions have stricter terminal permissions:
-
-1. System Preferences → Privacy & Security → Developer Tools
-2. Add Visual Studio Code
-3. Restart VSCode completely
-
-### Windows Issues
-
-If you're using Windows and still experiencing issues with shell integration after trying the previous steps, it's recommended you use Git Bash (or PowerShell).
-
-### Git Bash
-
-Git Bash is a terminal emulator that provides a Unix-like command line experience on Windows. To use Git Bash, you need to:
-
-1. Download and run the Git for Windows installer from [https://git-scm.com/downloads/win](https://git-scm.com/downloads/win)
-2. Quit and re-open VSCode
-3. Press `Ctrl + Shift + P` to open the Command Palette
-4. Type "Terminal: Select Default Profile" and choose it
-5. Select "Git Bash"
-
-### PowerShell
-
-If you'd still like to use PowerShell, make sure you're using an updated version (at least v7+).
-  - Check your current PowerShell version by running: `$PSVersionTable.PSVersion`
-  - If your version is below 7, [update PowerShell](https://learn.microsoft.com/en-us/powershell/scripting/whats-new/migrating-from-windows-powershell-51-to-powershell-7?view=powershell-7.4#installing-powershell-7).
-
-You may also need to adjust your PowerShell execution policy. By default, PowerShell restricts script execution for security reasons.
-
-#### Understanding PowerShell Execution Policies
-
-PowerShell uses execution policies to determine which scripts can run on your system. Here are the most common policies:
-
-- `Restricted`: No PowerShell scripts can run. This is the default setting.
-- `AllSigned`: All scripts, including local ones, must be signed by a trusted publisher.
-- `RemoteSigned`: Scripts created locally can run, but scripts downloaded from the internet must be signed.
-- `Unrestricted`: No restrictions. Any script can run, though you will be warned before running internet-downloaded scripts.
-
-For development work in VSCode, the `RemoteSigned` policy is generally recommended. It allows locally created scripts to run without restrictions while maintaining security for downloaded scripts. To learn more about PowerShell execution policies and understand the security implications of changing them, visit Microsoft's documentation: [About Execution Policies](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_execution_policies).
-
-#### Steps to Change the Execution Policy
-
-1. Open PowerShell as an Administrator: Press `Win + X` and select "Windows PowerShell (Administrator)" or "Windows Terminal (Administrator)".
-
-2. Check Current Execution Policy by running this command:
-     ```powershell
-     Get-ExecutionPolicy
-     ```
-   - If the output is already `RemoteSigned`, `Unrestricted`, or `Bypass`, you likely don't need to change your execution policy. These policies should allow shell integration to work.
-   - If the output is `Restricted` or `AllSigned`, you may need to change your policy to enable shell integration.
-
-3. Change the Execution Policy by running the following command:
-     ```powershell
-     Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
-     ```
-   - This sets the policy to `RemoteSigned` for the current user only, which is safer than changing it system-wide.
-
-4. Confirm the Change by typing `Y` and pressing Enter when prompted.
-
-5. Verify the Policy Change by running `Get-ExecutionPolicy` again to confirm the new setting.
-
-6. Restart VSCode and try the shell integration again.
-
-
-#### WSL Integration
-
-For WSL issues:
-
-1. Use WSL extension for VSCode
-2. Open folder in WSL: `code .` from WSL terminal
-3. Select "WSL Bash" as terminal profile in Cline
-
-#### Path Issues
-
-Windows path problems:
-
-1. Use forward slashes in Cline: `C:/Users/...`
-2. Quote paths with spaces: `"C:/Program Files/..."`
-3. Avoid `~` - use full paths
-
-### Linux/SSH/Container Issues
-
-#### SSH Connections
-
-For remote development:
-
-1. Install Cline on the remote machine, not locally
-2. Use SSH extension's integrated terminal
-3. Increase timeout to 15+ seconds
-
-#### Docker Containers
-
-When developing in containers:
-
-1. Install Cline in the container
-2. Use Dev Containers extension
-3. Ensure shell integration scripts are available
-
-## Shell-Specific Fixes
-
-### Zsh
-
-```bash
-# Add to ~/.zshrc
-export TERM=xterm-256color
-export PAGER=cat
-# Disable fancy prompts for VSCode
-if [[ "$TERM_PROGRAM" == "vscode" ]]; then
-    PS1="%n@%m %1~ %# "
-fi
-```
-
-### Bash
-
-```bash
-# Add to ~/.bashrc
-export TERM=xterm-256color
-export PAGER=cat
-# Simple prompt for VSCode
-if [[ "$TERM_PROGRAM" == "vscode" ]]; then
-    PS1='\u@\h:\w\$ '
-fi
-```
-
-### Fish
-
-```fish
-# Add to ~/.config/fish/config.fish
-set -x TERM xterm-256color
-set -x PAGER cat
-# Disable fancy features in VSCode
-if test "$TERM_PROGRAM" = "vscode"
-    function fish_prompt
-        echo (whoami)'@'(hostname)':'(pwd)'> '
-    end
-end
-```
-
-### PowerShell
-
-```powershell
-# Add to $PROFILE
-$env:PAGER = "cat"
-# Disable progress bars
-$ProgressPreference = 'SilentlyContinue'
-```
-
-## Advanced Troubleshooting
-
-### Debug Mode
-
-Enable terminal debugging to see what's happening:
-
-1. Open VSCode Command Palette (Cmd/Ctrl+Shift+P)
-2. Run: "Developer: Set Log Level..."
-3. Choose "Trace"
-4. Check Output panel → "Cline" for terminal logs
-
-### Manual Shell Integration Test
-
-Test if shell integration works at all:
-
-```bash
-# In VSCode terminal
-echo $TERM_PROGRAM  # Should show "vscode"
-echo $VSCODE_SHELL_INTEGRATION  # Should be "1"
-```
-
-## FAQ
-
-### Why does Cline create so many terminals?
-
-When shell integration fails, Cline can't reuse terminals safely (they might be running long processes). Enable shell integration or adjust the terminal reuse setting.
-
-### Can I use my custom shell (nushell, xonsh, etc.)?
-
-Cline officially supports bash, zsh, fish, and PowerShell. Custom shells may work but aren't guaranteed. Use bash as a fallback.
-
-### Why do some commands work but others don't?
-
-Commands that use interactive features (pagers, progress bars, curses) often fail. Set `PAGER=cat` and use non-interactive flags.
-
-### How do I know if shell integration is working?
-
-Working integration shows command output in Cline's chat. Failed integration shows "Shell Integration Unavailable" or "[Command is running but producing no output]".
-
-## Still Having Issues?
-
-If you've tried everything:
-
-1. **Collect Debug Info**:
-
-    ```bash
-    echo "Shell: $SHELL"
-    echo "Term: $TERM"
-    echo "VSCode: $TERM_PROGRAM"
-    which bash
-    bash --version
-    ```
-
-2. **Report the Issue**:
-    - Use `/reportbug` in Cline github issues
-    - Include your debug info
-    - Mention which solutions you tried
-
-<Tip>
-	Remember: Most terminal issues are resolved by switching to bash and increasing the timeout. Start there before trying complex
-	solutions.
-</Tip>

docs/troubleshooting/terminal-quick-fixes.mdx

@@ -1,51 +0,0 @@
----
-title: "Terminal Quick Fixes"
-sidebarTitle: "Terminal Quick Fixes"
-description: "Quick solutions for common terminal issues"
----
-
-**Here is a list of common fixes, starting with the most applicable:**
-
--   **Switch to bash** (solves most instances)
-
-    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
-    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
-    3. Navigate to **"Default Terminal Profile"** and select **"bash"** from the drop-down
-
--   **Increase timeout**
-
-    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
-    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
-    3. Navigate to "Shell integration timeout (seconds)" and enter **"10"** into the text field
-
--   **Disable terminal reuse**
-    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
-    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
-    3. Look for **"Enable aggressive terminal reuse"**, and **uncheck** this option
-
-## Platform-Specific Fixes
-
-### macOS + Oh-My-Zsh
-
-```bash
-# Create minimal config for VSCode
-echo 'export TERM=xterm-256color' > ~/.zshrc-vscode
-echo 'export PAGER=cat' >> ~/.zshrc-vscode
-```
-
-### Windows PowerShell
-
-```powershell
-# Run as Administrator
-Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
-```
-
-### WSL
-
--   Open folder from WSL: `code .`
--   Select **"WSL Bash"** in Cline settings, under **"Terminal Settings"**
--   Increase **"Shell integration timeout (seconds)"** to **15**
-
-## Full Guide
-
-For detailed troubleshooting, see the [Complete Terminal Troubleshooting Guide](/troubleshooting/terminal-integration-guide).

esbuild.js

@@ -1,15 +1,10 @@
-import fs from "node:fs"
-import path from "node:path"
-import { fileURLToPath } from "node:url"
-import * as esbuild from "esbuild"
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
+const esbuild = require("esbuild")
+const fs = require("fs")
+const path = require("path")
 
 const production = process.argv.includes("--production")
 const watch = process.argv.includes("--watch")
 const standalone = process.argv.includes("--standalone")
-const e2eBuild = process.argv.includes("--e2e-build")
 const destDir = standalone ? "dist-standalone" : "dist"
 
 /**
@@ -20,6 +15,7 @@ const aliasResolverPlugin = {
 	setup(build) {
 		const aliases = {
 			"@": path.resolve(__dirname, "src"),
+			"@api": path.resolve(__dirname, "src/api"),
 			"@core": path.resolve(__dirname, "src/core"),
 			"@integrations": path.resolve(__dirname, "src/integrations"),
 			"@services": path.resolve(__dirname, "src/services"),
@@ -129,9 +125,9 @@ const baseConfig = {
 	minify: production,
 	sourcemap: !production,
 	logLevel: "silent",
-	define: production
-		? { "import.meta.url": "_importMetaUrl", "process.env.IS_DEV": JSON.stringify(!production) }
-		: { "import.meta.url": "_importMetaUrl" },
+	define: {
+		"process.env.IS_DEV": JSON.stringify(!production),
+	},
 	tsconfig: path.resolve(__dirname, "tsconfig.json"),
 	plugins: [
 		copyWasmFiles,
@@ -142,9 +138,6 @@ const baseConfig = {
 	format: "cjs",
 	sourcesContent: false,
 	platform: "node",
-	banner: {
-		js: "const _importMetaUrl=require('url').pathToFileURL(__filename)",
-	},
 }
 
 // Extension-specific configuration
@@ -158,25 +151,15 @@ const extensionConfig = {
 // Standalone-specific configuration
 const standaloneConfig = {
 	...baseConfig,
-	entryPoints: ["src/standalone/cline-core.ts"],
-	outfile: `${destDir}/cline-core.js`,
+	entryPoints: ["src/standalone/standalone.ts"],
+	outfile: `${destDir}/standalone.js`,
 	// These gRPC protos need to load files from the module directory at runtime,
 	// so they cannot be bundled.
 	external: ["vscode", "@grpc/reflection", "grpc-health-check"],
 }
 
-// E2E build script configuration
-const e2eBuildConfig = {
-	...baseConfig,
-	entryPoints: ["src/test/e2e/utils/build.ts"],
-	outfile: `${destDir}/e2e-build.mjs`,
-	external: ["@vscode/test-electron", "execa"],
-	sourcemap: false,
-	plugins: [aliasResolverPlugin, esbuildProblemMatcherPlugin],
-}
-
 async function main() {
-	const config = standalone ? standaloneConfig : e2eBuild ? e2eBuildConfig : extensionConfig
+	const config = standalone ? standaloneConfig : extensionConfig
 	const extensionCtx = await esbuild.context(config)
 	if (watch) {
 		await extensionCtx.watch()

eslint-rules/__tests__/no-grpc-client-object-literals.test.ts

@@ -0,0 +1,174 @@
+const { RuleTester: GrpcRuleTester } = require("eslint")
+const grpcRule = require("../no-grpc-client-object-literals")
+
+const grpcRuleTester = new GrpcRuleTester({
+	parser: require.resolve("@typescript-eslint/parser"),
+	parserOptions: {
+		ecmaVersion: 2020,
+		sourceType: "module",
+		ecmaFeatures: {
+			jsx: true,
+		},
+	},
+})
+
+grpcRuleTester.run("no-grpc-client-object-literals", grpcRule, {
+	valid: [
+		// Valid case: Using .create() method with gRPC client
+		{
+			code: `
+                import { TogglePlanActModeRequest } from '@shared/proto/state';
+                import { StateServiceClient } from '../services/grpc-client';
+                
+                StateServiceClient.togglePlanActMode(
+                    TogglePlanActModeRequest.create({
+                        chatSettings: {
+                            mode: PlanActMode.PLAN,
+                            preferredLanguage: 'en',
+                        },
+                    })
+                );
+            `,
+		},
+		// Valid case: Using .fromPartial() method with gRPC client
+		{
+			code: `
+                import { TogglePlanActModeRequest, ChatSettings } from '@shared/proto/state';
+                import { StateServiceClient } from '../services/grpc-client';
+                
+                const chatSettings = ChatSettings.fromPartial({
+                    mode: PlanActMode.PLAN,
+                    preferredLanguage: 'en',
+                });
+                
+                StateServiceClient.togglePlanActMode(
+                    TogglePlanActModeRequest.create({
+                        chatSettings: chatSettings,
+                    })
+                );
+            `,
+		},
+		// Valid case: Regular function call with object literal (not a gRPC client)
+		{
+			code: `
+                function processData(data) {
+                    console.log(data);
+                }
+                
+                processData({
+                    id: 123,
+                    name: 'test',
+                });
+            `,
+		},
+		// Valid case: Using proper nested protobuf objects
+		{
+			code: `
+                import { TogglePlanActModeRequest, ChatSettings } from '@shared/proto/state';
+                import { StateServiceClient } from '../services/grpc-client';
+                
+                // Using proper nested protobuf objects
+                const chatSettings = ChatSettings.create({
+                    mode: 0,
+                    preferredLanguage: 'en',
+                });
+                
+                const request = TogglePlanActModeRequest.create({
+                    chatSettings: chatSettings,
+                });
+                
+                StateServiceClient.togglePlanActMode(request);
+            `,
+		},
+		// Valid case: Object literal in second parameter (should not be checked)
+		{
+			code: `
+                import { StateSubscribeRequest } from '@shared/proto/state';
+                import { StateServiceClient } from '../services/grpc-client';
+                
+                const request = StateSubscribeRequest.create({
+                    topics: ['apiConfig', 'tasks']
+                });
+                
+                // Second parameter is an object literal but should not trigger the rule
+                StateServiceClient.subscribe(request, {
+                    metadata: {
+                        userId: 123,
+                        sessionId: "abc-123"
+                    }
+                });
+            `,
+		},
+	],
+	invalid: [
+		// Invalid case: Using object literal directly with gRPC client
+		{
+			code: `
+                import { StateServiceClient } from '../services/grpc-client';
+                
+                StateServiceClient.togglePlanActMode({
+                    chatSettings: {
+                        mode: 0,
+                        preferredLanguage: 'en',
+                    },
+                });
+            `,
+			errors: [{ messageId: "useProtobufMethod" }],
+		},
+		// Invalid case: Using object literal with nested properties
+		{
+			code: `
+                import { ChatSettings } from '@shared/proto/state';
+                import { StateServiceClient } from '../services/grpc-client';
+                
+                const chatSettings = ChatSettings.create({
+                    mode: 0,
+                    preferredLanguage: 'en',
+                });
+                
+                StateServiceClient.togglePlanActMode({
+                    chatSettings: {
+                        mode: 1,
+                        preferredLanguage: 'fr',
+                    },
+                });
+            `,
+			errors: [{ messageId: "useProtobufMethod" }],
+		},
+		// Invalid case: Nested object literal in protobuf create method
+		{
+			code: `
+                import { TogglePlanActModeRequest, ChatSettings } from '@shared/proto/state';
+                import { StateServiceClient } from '../services/grpc-client';
+                
+                // Using nested object literal instead of ChatSettings.create()
+                const request = TogglePlanActModeRequest.create({
+                    chatSettings: {
+                        mode: 0,
+                        preferredLanguage: 'en',
+                    },
+                });
+                
+                StateServiceClient.togglePlanActMode(request);
+            `,
+			errors: [{ messageId: "useProtobufMethod" }],
+		},
+		// Invalid case: Object literal as first parameter to subscribe method
+		{
+			code: `
+                import { StateServiceClient } from '../services/grpc-client';
+                
+                // First parameter is an object literal, which should trigger the rule
+                StateServiceClient.subscribe({
+                    topics: ['apiConfig', 'tasks']
+                }, {
+                    metadata: {
+                        userId: 123,
+                        sessionId: "abc-123"
+                    }
+                });
+            `,
+			errors: [{ messageId: "useProtobufMethod" }],
+		},
+	],
+})

eslint-rules/__tests__/no-protobuf-object-literals.test.ts

@@ -0,0 +1,214 @@
+const { RuleTester } = require("eslint")
+const rule = require("../no-protobuf-object-literals")
+
+const ruleTester = new RuleTester({
+	parser: require.resolve("@typescript-eslint/parser"),
+	parserOptions: {
+		ecmaVersion: 2020,
+		sourceType: "module",
+		ecmaFeatures: {
+			jsx: true,
+		},
+	},
+})
+
+ruleTester.run("no-protobuf-object-literals", rule, {
+	valid: [
+		// Valid case: Using .create() method
+		{
+			code: `
+        import { State } from '@shared/proto/state';
+        
+        const state = State.create({
+          stateJson: '{"apiConfig":{"provider":"anthropic","model":"claude-3-haiku"}}'
+        });
+      `,
+		},
+		// Valid case: Using .fromPartial() method
+		{
+			code: `
+        import { ChatSettings } from '@shared/proto/state';
+        
+        const settings = ChatSettings.fromPartial({
+          mode: 0,
+          preferredLanguage: 'en',
+          openAiReasoningEffort: 'thorough'
+        });
+      `,
+		},
+		// Valid case: Object literal not used with protobuf type
+		{
+			code: `
+        interface MyInterface {
+          id: number;
+          name: string;
+        }
+        
+        const obj: MyInterface = {
+          id: 123,
+          name: 'test'
+        };
+      `,
+		},
+		// Valid case: Using object literal for non-protobuf import
+		{
+			code: `
+        import { SomeType } from '@some/other/package';
+
+        const obj: SomeType = {
+          id: 123,
+          name: 'test'
+        };
+      `,
+		},
+		// Valid case: Regular function call with object literal (should not be flagged)
+		{
+			code: `
+        import { State } from '@shared/proto/state';
+
+        // This should not be flagged because it's a regular function call
+        // not directly tied to a protobuf type
+        process({
+          id: 123,
+          name: 'test',
+          data: { nested: true }
+        });
+      `,
+		},
+	],
+	invalid: [
+		// Invalid case: Using object literal with imported protobuf type
+		{
+			code: `
+        import { State } from '@shared/proto/state';
+
+        const state: State = {
+          stateJson: '{"apiConfig":{"provider":"anthropic","model":"claude-3-haiku"}}'
+        };
+      `,
+			output: `
+        import { State } from '@shared/proto/state';
+
+        const state: State = State.create({
+          stateJson: '{"apiConfig":{"provider":"anthropic","model":"claude-3-haiku"}}'
+        });
+      `,
+			errors: [{ messageId: "useProtobufMethod" }],
+		},
+		// Invalid case: Using object literal with namespaced protobuf type
+		{
+			code: `
+        import * as stateProto from '@shared/proto/state';
+
+        const state: stateProto.State = {
+          stateJson: '{"apiConfig":{"provider":"anthropic","model":"claude-3-haiku"}}'
+        };
+      `,
+			output: `
+        import * as stateProto from '@shared/proto/state';
+
+        const state: stateProto.State = stateProto.State.create({
+          stateJson: '{"apiConfig":{"provider":"anthropic","model":"claude-3-haiku"}}'
+        });
+      `,
+			errors: [{ messageId: "useProtobufMethodGeneric" }],
+		},
+		// Invalid case: Using object literal in a return statement (with protobuf return type)
+		{
+			code: `
+        import { ChatSettings } from '@shared/proto/state';
+
+        function createSettings(): ChatSettings {
+          return {
+            mode: 0,
+            preferredLanguage: 'en',
+            openAiReasoningEffort: 'thorough'
+          };
+        }
+      `,
+			output: `
+        import { ChatSettings } from '@shared/proto/state';
+
+        function createSettings(): ChatSettings {
+          return ChatSettings.create({
+            mode: 0,
+            preferredLanguage: 'en',
+            openAiReasoningEffort: 'thorough'
+          });
+        }
+      `,
+			errors: [{ messageId: "useProtobufMethod" }],
+		},
+		// Invalid case: Using object literal in a function parameter (with protobuf types imported)
+		{
+			code: `
+        import { ChatContent } from '@shared/proto/state';
+
+        function processContent(content: ChatContent) {
+          // process the content
+        }
+
+        processContent({
+          message: 'Hello, this is a test message',
+          images: ['image1.png', 'image2.jpg'],
+          files: ['file1.txt', 'file2.pdf']
+        });
+      `,
+			output: `
+        import { ChatContent } from '@shared/proto/state';
+
+        function processContent(content: ChatContent) {
+          // process the content
+        }
+
+        processContent(ChatContent.create({
+          message: 'Hello, this is a test message',
+          images: ['image1.png', 'image2.jpg'],
+          files: ['file1.txt', 'file2.pdf']
+        }));
+      `,
+			errors: [{ messageId: "useProtobufMethodGeneric" }],
+		},
+		// Invalid case: Using object literal in assignment expression
+		{
+			code: `
+        import { State } from '@shared/proto/state';
+
+        let state: State;
+        state = {
+          stateJson: '{"apiConfig":{"provider":"anthropic","model":"claude-3-haiku"}}'
+        };
+      `,
+			output: `
+        import { State } from '@shared/proto/state';
+
+        let state: State;
+        state = State.create({
+          stateJson: '{"apiConfig":{"provider":"anthropic","model":"claude-3-haiku"}}'
+        });
+      `,
+			errors: [{ messageId: "useProtobufMethod" }],
+		},
+		// Test with custom protobufPackages option
+		{
+			code: `
+        import { CustomProto } from 'custom/proto/package';
+
+        const obj: CustomProto = {
+          field1: 'value',
+          field2: 123
+        };
+      `,
+			output: `
+        import { CustomProto } from 'custom/proto/package';
+
+        const obj: CustomProto = CustomProto.create({
+          field1: 'value',
+          field2: 123
+        });
+      `,
+			options: [{ protobufPackages: ["custom/proto"] }],
+			errors: [{ messageId: "useProtobufMethod" }],
+		},
+	],
+})

eslint-rules/index.js

@@ -0,0 +1,19 @@
+// eslint-rules/index.js
+const noProtobufObjectLiterals = require("./no-protobuf-object-literals")
+const noGrpcClientObjectLiterals = require("./no-grpc-client-object-literals")
+
+module.exports = {
+	rules: {
+		"no-protobuf-object-literals": noProtobufObjectLiterals,
+		"no-grpc-client-object-literals": noGrpcClientObjectLiterals,
+	},
+	configs: {
+		recommended: {
+			plugins: ["local"],
+			rules: {
+				"local/no-protobuf-object-literals": "error",
+				"local/no-grpc-client-object-literals": "error",
+			},
+		},
+	},
+}

eslint-rules/no-grpc-client-object-literals.js

@@ -0,0 +1,216 @@
+const { ESLintUtils } = require("@typescript-eslint/utils")
+
+const createRule = ESLintUtils.RuleCreator((name) => `https://cline.bot/eslint-rules/${name}`)
+
+module.exports = createRule({
+	name: "no-grpc-client-object-literals",
+	meta: {
+		type: "problem",
+		docs: {
+			description:
+				"Enforce using .create() or .fromPartial() for gRPC service client parameters instead of object literals",
+			recommended: "error",
+		},
+		messages: {
+			useProtobufMethod:
+				"Use the appropriate protobuf .create() or .fromPartial() method instead of " +
+				"object literal for gRPC client parameters.\n" +
+				"Found: {{code}}\n" +
+				"gRPC client methods should always receive properly created protobuf objects.",
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+
+	create(context) {
+		// Check if a name matches the gRPC service client pattern using regex
+		// Must start with an uppercase letter and end with ServiceClient
+		const isGrpcServiceClient = (name) => {
+			return typeof name === "string" && /^[A-Z].*ServiceClient$/.test(name)
+		}
+
+		const safeObjectExpressions = new Map() // Track object expressions in create/fromPartial calls
+
+		return {
+			// Skip object literals inside create() or fromPartial() method calls
+			CallExpression(node) {
+				if (
+					node.callee &&
+					node.callee.type === "MemberExpression" &&
+					(node.callee.property.name === "create" || node.callee.property.name === "fromPartial") &&
+					node.arguments.length > 0 &&
+					node.arguments[0].type === "ObjectExpression"
+				) {
+					// Track this object expression as being used with create/fromPartial
+					safeObjectExpressions.set(node.arguments[0], { isProblematic: false })
+				}
+			},
+
+			// Track create/fromPartial calls that contain nested object literals
+			"CallExpression[callee.type='MemberExpression'][callee.property.name=/^(create|fromPartial)$/]"(node) {
+				if (node.arguments.length > 0 && node.arguments[0].type === "ObjectExpression") {
+					// Track problematic nested object literals
+					const nestedObjectLiterals = new Map() // Map of object expressions to their containing property paths
+
+					// Search for nested object literals
+					const queue = [
+						...node.arguments[0].properties.map((prop) => ({
+							property: prop,
+							path: prop.key && prop.key.name ? prop.key.name : "unknown",
+						})),
+					]
+
+					while (queue.length > 0) {
+						const { property, path } = queue.shift()
+
+						// Skip spread elements
+						if (property.type !== "Property") continue
+
+						// If this is an object literal, mark it as problematic
+						if (property.value.type === "ObjectExpression") {
+							nestedObjectLiterals.set(property.value, path)
+
+							// Add nested properties to queue
+							queue.push(
+								...property.value.properties.map((prop) => ({
+									property: prop,
+									path: `${path}.${prop.key && prop.key.name ? prop.key.name : "unknown"}`,
+								})),
+							)
+						}
+					}
+
+					// For each problematic nested object, track it with its path
+					nestedObjectLiterals.forEach((path, objectExpr) => {
+						safeObjectExpressions.set(objectExpr, {
+							isProblematic: true,
+							path: path,
+							parentNode: node,
+						})
+					})
+				}
+			},
+
+			// Check calls to gRPC service clients
+			"CallExpression[callee.type='MemberExpression']"(node) {
+				// Get the object (left side) of the member expression
+				const callee = node.callee
+				if (callee.object && callee.object.type === "Identifier") {
+					const objectName = callee.object.name
+
+					// Check if this is a call to one of our gRPC service clients
+					if (isGrpcServiceClient(objectName)) {
+						// Only check the first argument of gRPC service client calls
+						if (node.arguments.length > 0) {
+							const arg = node.arguments[0] // Only check the first parameter
+							if (arg.type === "ObjectExpression" && !safeObjectExpressions.has(arg)) {
+								// This is an object literal being passed directly to a gRPC client
+								const sourceCode = context.getSourceCode()
+								const callText = sourceCode.getText(node).trim()
+
+								context.report({
+									node: arg,
+									messageId: "useProtobufMethod",
+									data: {
+										code: callText,
+									},
+								})
+							} else if (arg.type === "ObjectExpression") {
+								// Search for nested object literals that aren't protected
+								const queue = [...arg.properties]
+								while (queue.length > 0) {
+									const property = queue.shift()
+
+									// Skip spread elements
+									if (property.type !== "Property") continue
+
+									// Check value
+									if (
+										property.value.type === "ObjectExpression" &&
+										!safeObjectExpressions.has(property.value)
+									) {
+										// Found a nested object literal
+										const sourceCode = context.getSourceCode()
+										const propertyText = sourceCode.getText(property).trim()
+
+										context.report({
+											node: property.value,
+											messageId: "useProtobufMethod",
+											data: {
+												code: `${objectName}.${callee.property.name}(... ${propertyText} ...)`,
+											},
+										})
+									}
+
+									// Add any nested properties to the queue
+									if (property.value.type === "ObjectExpression") {
+										queue.push(...property.value.properties)
+									}
+								}
+							} else if (arg.type === "Identifier") {
+								// This is a variable - check if it references a problematic protobuf object
+								const varName = arg.name
+								const sourceCode = context.getSourceCode()
+								const scope = sourceCode.getScope(node)
+
+								// Find the variable declaration
+								const variable = scope.variables.find((v) => v.name === varName)
+								if (variable && variable.references && variable.references.length > 0) {
+									// Look for definitions
+									const def = variable.defs.find(
+										(d) => d.node && d.node.type === "VariableDeclarator" && d.node.init,
+									)
+
+									if (
+										def &&
+										def.node.init.type === "CallExpression" &&
+										def.node.init.callee.type === "MemberExpression" &&
+										(def.node.init.callee.property.name === "create" ||
+											def.node.init.callee.property.name === "fromPartial")
+									) {
+										// Flag if we find problematic nested object literals in this create/fromPartial call
+										const callText = sourceCode.getText(node).trim()
+										const initCallText = sourceCode.getText(def.node.init).trim()
+
+										// Check for nested object literals in init node
+										let foundNestedLiteral = false
+										if (
+											def.node.init.arguments.length > 0 &&
+											def.node.init.arguments[0].type === "ObjectExpression"
+										) {
+											// Find any nested object literals
+											const queue = [...def.node.init.arguments[0].properties]
+											while (queue.length > 0 && !foundNestedLiteral) {
+												const property = queue.shift()
+
+												// Skip spread elements
+												if (property.type !== "Property") continue
+
+												if (property.value.type === "ObjectExpression") {
+													foundNestedLiteral = true
+
+													context.report({
+														node,
+														messageId: "useProtobufMethod",
+														data: {
+															code: `${callText} - using request created with nested object literal at: ${property.key.name}`,
+														},
+													})
+												}
+
+												// Add any nested properties to the queue
+												if (property.value.type === "ObjectExpression") {
+													queue.push(...property.value.properties)
+												}
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			},
+		}
+	},
+})

eslint-rules/no-protobuf-object-literals.js

@@ -0,0 +1,556 @@
+const { ESLintUtils } = require("@typescript-eslint/utils")
+
+const createRule = ESLintUtils.RuleCreator((name) => `https://cline.bot/eslint-rules/${name}`)
+
+module.exports = createRule({
+	name: "no-protobuf-object-literals",
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforce using .create() or .fromPartial() for protobuf objects instead of object literals",
+			recommended: "error",
+		},
+		fixable: "code",
+		messages: {
+			useProtobufMethod:
+				"Use {{typeName}}.create() or {{typeName}}.fromPartial() instead of " +
+				"object literal for protobuf type from @shared/proto\n" +
+				"Found: {{code}}\n  Suggestion: " +
+				"{{typeName}}.create({{objectContent}})",
+			useProtobufMethodGeneric:
+				"Use .create() or .fromPartial() instead of object literal for protobuf " +
+				"type from @shared/proto\n  Found: {{code}}",
+		},
+		schema: [
+			{
+				type: "object",
+				properties: {
+					protobufPackages: {
+						type: "array",
+						items: { type: "string" },
+						default: ["shared/proto/"],
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+	},
+	defaultOptions: [{ protobufPackages: ["shared/proto/"] }],
+
+	create(context, [options]) {
+		const protobufPackages = options.protobufPackages
+		const protobufImports = new Set() // Set of imported protobuf types
+		const protobufNamespaceImports = new Set() // For namespace imports like "import * as proto"
+		const safeObjectExpressions = new Set() // Track object expressions in create/fromPartial calls
+
+		return {
+			// Skip object literals inside create() or fromPartial() method calls
+			CallExpression(node) {
+				if (
+					node.callee &&
+					node.callee.type === "MemberExpression" &&
+					(node.callee.property.name === "create" || node.callee.property.name === "fromPartial") &&
+					node.arguments.length > 0 &&
+					node.arguments[0].type === "ObjectExpression"
+				) {
+					// Track this object expression as being used with create/fromPartial
+					safeObjectExpressions.add(node.arguments[0])
+				}
+			},
+
+			// Track imports from protobuf packages
+			ImportDeclaration(node) {
+				const packageName = node.source.value
+
+				if (matchesProtobufPackage(packageName, protobufPackages)) {
+					// This is a protobuf package.
+					node.specifiers.forEach((spec) => {
+						if (spec.type === "ImportSpecifier") {
+							// import { MyRequest } from '@shared/proto'
+							protobufImports.add(spec.imported.name)
+						} else if (spec.type === "ImportNamespaceSpecifier") {
+							// import * as proto from '@shared/proto'
+							protobufNamespaceImports.add(spec.local.name)
+						}
+					})
+				}
+			},
+
+			// Check variable declarations with type annotations
+			"VariableDeclarator > ObjectExpression"(node) {
+				// Skip if this is inside a create/fromPartial call
+				if (safeObjectExpressions.has(node)) {
+					return
+				}
+
+				// Found object literal in variable declaration
+				const declarator = node.parent
+
+				if (declarator.id && declarator.id.typeAnnotation) {
+					const typeName = getTypeName(declarator.id.typeAnnotation.typeAnnotation)
+					if (typeName) {
+						// Check if it's a direct protobuf import
+						if (protobufImports.has(typeName)) {
+							//console.log('🚨 VIOLATION: Using object literal for protobuf type:', typeName);
+							const sourceCode = context.getSourceCode()
+							const declaratorText = sourceCode.getText(declarator)
+							const objectText = sourceCode.getText(node)
+
+							context.report({
+								node,
+								messageId: "useProtobufMethod",
+								data: {
+									typeName,
+									code: declaratorText,
+									objectContent: objectText,
+								},
+								fix(fixer) {
+									// Replace the object literal with Type.create() call
+									return fixer.replaceText(node, `${typeName}.create(${objectText})`)
+								},
+							})
+							return
+						}
+
+						// Check if it's a namespaced protobuf type (e.g., proto.MyRequest)
+						if (isNamespacedProtobufType(protobufNamespaceImports, typeName)) {
+							//console.log('🚨 VIOLATION: Using object literal for namespaced protobuf type:', typeName);
+							const sourceCode = context.getSourceCode()
+							const declaratorText = sourceCode.getText(declarator)
+							context.report({
+								node,
+								messageId: "useProtobufMethodGeneric",
+								data: { code: declaratorText },
+								fix(fixer) {
+									// For namespaced types, use the full type name to call create()
+									return fixer.replaceText(node, `${typeName}.create(${sourceCode.getText(node)})`)
+								},
+							})
+						}
+					}
+				}
+			},
+
+			// Check assignment expressions
+			"AssignmentExpression > ObjectExpression"(node) {
+				// Skip if this is inside a create/fromPartial call
+				if (safeObjectExpressions.has(node)) {
+					return
+				}
+
+				const assignment = node.parent
+
+				// For assignment to variables without inline type annotation
+				if (assignment.left && assignment.right === node) {
+					let typeName = null
+
+					// Check if there's a typeAnnotation directly on the left
+					if (assignment.left.typeAnnotation) {
+						typeName = getTypeName(assignment.left.typeAnnotation.typeAnnotation)
+					}
+					// Otherwise try to infer from the variable name if it's a simple identifier
+					else if (assignment.left.type === "Identifier") {
+						const varName = assignment.left.name
+						// Check variable declarations in the current scope
+						const sourceCode = context.getSourceCode()
+						const scope = sourceCode.getScope(node)
+						const variable = scope.variables.find((v) => v.name === varName)
+						if (variable && variable.defs.length > 0) {
+							const def = variable.defs[0]
+							if (def.node.id && def.node.id.typeAnnotation) {
+								typeName = getTypeName(def.node.id.typeAnnotation.typeAnnotation)
+							}
+						}
+					}
+
+					if (typeName && protobufImports.has(typeName)) {
+						//console.log('🚨 VIOLATION: Using object literal in assignment for protobuf type:', typeName);
+						const sourceCode = context.getSourceCode()
+						const assignmentText = sourceCode.getText(assignment.left) + " = "
+						const objectText = sourceCode.getText(node)
+
+						context.report({
+							node,
+							messageId: "useProtobufMethod",
+							data: {
+								typeName,
+								code: assignmentText + "{",
+								objectContent: objectText,
+							},
+							fix(fixer) {
+								// Replace the object literal with Type.create() call in assignments
+								return fixer.replaceText(node, `${typeName}.create(${objectText})`)
+							},
+						})
+					}
+				}
+			},
+
+			// Check return statements
+			"ReturnStatement > ObjectExpression"(node) {
+				// Skip if this is inside a create/fromPartial call
+				if (safeObjectExpressions.has(node)) {
+					return
+				}
+
+				// Find the parent function to get its return type
+				const functionNode = findParentFunction(node)
+				if (!functionNode) {
+					return
+				}
+
+				// Try to get the return type using our enhanced helper
+				const sourceCode = context.getSourceCode()
+				let returnTypeName = getFunctionReturnType(functionNode, sourceCode)
+
+				// For async functions with Promise<Type> return type, extract the inner type
+				if (returnTypeName && returnTypeName.startsWith("Promise<") && returnTypeName.endsWith(">")) {
+					returnTypeName = returnTypeName.slice(8, -1)
+				}
+
+				// Check if the return type is a protobuf type
+				if (returnTypeName) {
+					if (protobufImports.has(returnTypeName)) {
+						//console.log('🚨 VIOLATION: Return type is a protobuf type:', returnTypeName);
+						const sourceCode = context.getSourceCode()
+						const returnText = sourceCode.getText(node.parent)
+						context.report({
+							node,
+							messageId: "useProtobufMethod",
+							data: {
+								typeName: returnTypeName,
+								code: returnText,
+								objectContent: sourceCode.getText(node),
+							},
+							fix(fixer) {
+								// Replace the object literal with Type.create() call in return statements
+								return fixer.replaceText(node, `${returnTypeName}.create(${sourceCode.getText(node)})`)
+							},
+						})
+						return
+					}
+
+					// Check if it's a namespaced protobuf type
+					if (isNamespacedProtobufType(protobufNamespaceImports, returnTypeName)) {
+						const sourceCode = context.getSourceCode()
+						const returnText = sourceCode.getText(node.parent)
+						//console.log('🚨 VIOLATION: Return type is a namespaced protobuf type:', returnTypeName);
+						context.report({
+							node,
+							messageId: "useProtobufMethodGeneric",
+							data: { code: returnText },
+							fix(fixer) {
+								// For namespaced types in return statements, we need to extract the full type name
+								const objectCode = sourceCode.getText(node)
+								// Since we may not know the exact type, we'll use the more generic namespaced type
+								return fixer.replaceText(node, `${returnTypeName}.create(${objectCode})`)
+							},
+						})
+						return
+					}
+				}
+
+				// Final fallback - if there are any protobuf imports and the function signature
+				// mentions a return type that matches one of the imported types
+				const functionText = functionNode ? sourceCode.getText(functionNode) : ""
+
+				for (const protoType of protobufImports) {
+					// Use more precise regex to match return type patterns specifically
+					// Rather than just checking if the type name appears anywhere in the signature
+					const returnTypeRegex = new RegExp(
+						// Match arrow function return type
+						`=>\\s*:?\\s*${protoType}\\b|` +
+							// Match function declaration return type
+							`\\)\\s*:?\\s*${protoType}\\b|` +
+							// Match Promise return type
+							`\\)\\s*:?\\s*Promise<\\s*${protoType}\\s*>|` +
+							// Match function type in variable declaration
+							`:\\s*\\(.*\\)\\s*=>\\s*${protoType}\\b`,
+					)
+
+					if (returnTypeRegex.test(functionText)) {
+						const returnText = sourceCode.getText(node.parent)
+						//console.log('🚨 VIOLATION: regex matched protobuf type:', functionText);
+						context.report({
+							node,
+							messageId: "useProtobufMethod",
+							data: {
+								typeName: protoType,
+								code: returnText,
+								objectContent: sourceCode.getText(node),
+							},
+							fix(fixer) {
+								// Replace the object literal with Type.create() call
+								return fixer.replaceText(node, `${protoType}.create(${sourceCode.getText(node)})`)
+							},
+						})
+						return
+					}
+				}
+				// Check for namespace imports too
+				for (const namespace of protobufNamespaceImports) {
+					// Similar to above, but for namespaced types
+					const namespaceReturnTypeRegex = new RegExp(
+						// Match arrow function return type
+						`=>\\s*:?\\s*${namespace}\\.\\w+\\b|` +
+							// Match function declaration return type
+							`\\)\\s*:?\\s*${namespace}\\.\\w+\\b|` +
+							// Match Promise return type
+							`\\)\\s*:?\\s*Promise<\\s*${namespace}\\.\\w+\\s*>|` +
+							// Match function type in variable declaration
+							`:\\s*\\(.*\\)\\s*=>\\s*${namespace}\\.\\w+\\b`,
+					)
+
+					if (namespaceReturnTypeRegex.test(functionText)) {
+						const returnText = sourceCode.getText(node.parent)
+						//console.log('🚨 VIOLATION: regex matched namespaced protobuf type:', functionText, "namespace:", namespace);
+						context.report({
+							node,
+							messageId: "useProtobufMethodGeneric",
+							data: { code: returnText },
+							fix(fixer) {
+								// For namespaced types based on function signature patterns
+								// Extract the namespace and type from the function text using more precise patterns
+								const match = functionText.match(
+									new RegExp(
+										// Match return type patterns more precisely
+										`\\)\\s*:?\\s*(${namespace}\\.[\\w]+)\\b|` + // Function declaration
+											`=>\\s*:?\\s*(${namespace}\\.[\\w]+)\\b|` + // Arrow function
+											`Promise<\\s*(${namespace}\\.[\\w]+)\\s*>`, // Promise wrapped
+									),
+								)
+								if (match) {
+									const fullType = match[1] || match[2]
+									return fixer.replaceText(node, `${fullType}.create(${sourceCode.getText(node)})`)
+								}
+								// Fallback - we can't determine the exact type, but we know it's from the namespace
+								// Use a namespace-based approach
+								return fixer.replaceText(node, `${namespace}.create(${sourceCode.getText(node)})`)
+							},
+						})
+						return
+					}
+				}
+			},
+
+			// Check function call arguments (more selective approach)
+			"CallExpression > ObjectExpression"(node) {
+				// Skip if this is inside a create/fromPartial call
+				if (safeObjectExpressions.has(node)) {
+					return
+				}
+
+				// We need to be more selective to avoid false positives
+				// Only warn if:
+				// 1. The function is called on a protobuf namespace
+				// 2. The call argument has a type annotation that matches a protobuf type
+				// 3. The call is to a function that we know takes a protobuf type
+
+				// Check if it's a call on a protobuf namespace
+				if (
+					node.parent.callee &&
+					node.parent.callee.type === "MemberExpression" &&
+					node.parent.callee.object.type === "Identifier"
+				) {
+					const namespace = node.parent.callee.object.name
+					if (protobufNamespaceImports.has(namespace)) {
+						const sourceCode = context.getSourceCode()
+						const callText = sourceCode.getText(node.parent)
+						//console.log('🚨 VIOLATION: Check function call arguments object literal:', callText);
+						context.report({
+							node,
+							messageId: "useProtobufMethodGeneric",
+							data: { code: callText },
+							fix(fixer) {
+								// For calls on a protobuf namespace
+								const memberExpr = node.parent.callee
+								// Try to determine if this is calling a method that expects a specific type
+								const methodName = memberExpr.property.name
+
+								// If method name looks like 'create' + Type, we can infer the type
+								const possibleTypeName = methodName.replace(/^create/, "")
+
+								// Check if namespace has a type with this name
+								// Since we can't directly check at lint time, we'll use the namespace + inferred type
+								if (possibleTypeName && possibleTypeName !== methodName) {
+									return fixer.replaceText(
+										node,
+										`${namespace}.${possibleTypeName}.create(${sourceCode.getText(node)})`,
+									)
+								}
+
+								// Fallback - use a more generic approach with namespace
+								return fixer.replaceText(node, `${namespace}.create(${sourceCode.getText(node)})`)
+							},
+						})
+						return
+					}
+				}
+
+				// For regular function calls with object literals, check if there are protobuf imports
+				// and if the function might expect a protobuf type
+				if (node.parent.callee) {
+					// This is a more permissive check to catch cases like processContent({ ... })
+					// which might be passing a protobuf type
+					const sourceCode = context.getSourceCode()
+					const scope = sourceCode.getScope(node)
+
+					// Try to find the function definition
+					if (node.parent.callee.type === "Identifier") {
+						const functionName = node.parent.callee.name
+						const variable = scope.variables.find((v) => v.name === functionName)
+
+						// If we found the function and it has parameter type annotations
+						// that match protobuf types, flag it
+						if (variable && variable.defs.length > 0) {
+							const def = variable.defs[0]
+							if (def.node.params && node.parent.arguments.indexOf(node) < def.node.params.length) {
+								const param = def.node.params[node.parent.arguments.indexOf(node)]
+								if (param.typeAnnotation) {
+									const typeName = getTypeName(param.typeAnnotation.typeAnnotation)
+									if (
+										typeName &&
+										(protobufImports.has(typeName) ||
+											isNamespacedProtobufType(protobufNamespaceImports, typeName))
+									) {
+										const callText = sourceCode.getText(node.parent)
+										//console.log('🚨 VIOLATION: Function call arguments object literal:', callText);
+										context.report({
+											node,
+											messageId: "useProtobufMethodGeneric",
+											data: { code: callText },
+											fix(fixer) {
+												// For function calls with protobuf type parameters
+												return fixer.replaceText(node, `${typeName}.create(${sourceCode.getText(node)})`)
+											},
+										})
+										return
+									}
+								}
+							}
+						}
+					}
+				}
+			},
+		}
+	},
+})
+
+// Helper functions
+function getTypeName(typeAnnotation) {
+	if (!typeAnnotation) {
+		return null
+	}
+
+	if (typeAnnotation.type === "TSTypeReference") {
+		if (typeAnnotation.typeName.type === "Identifier") {
+			return typeAnnotation.typeName.name
+		} else if (typeAnnotation.typeName.type === "TSQualifiedName") {
+			// Handle namespaced types like proto.MyRequest
+			return `${typeAnnotation.typeName.left.name}.${typeAnnotation.typeName.right.name}`
+		}
+	}
+	return null
+}
+
+function matchesProtobufPackage(packageName, protobufPackages) {
+	return protobufPackages.some((protobufPackage) => {
+		// Remove leading and trailing @ and / from protobufPackage
+		const cleanedPackage = protobufPackage.replace(/^[@\/]/, "").replace(/[\/]$/, "")
+		const pattern = new RegExp(`(.*[@/]|)${escapeRegex(cleanedPackage)}[/].*`)
+		return pattern.test(packageName)
+	})
+}
+
+// Helper function to escape special regex characters
+function escapeRegex(string) {
+	return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+}
+
+// Helper to extract function return type more reliably
+function getFunctionReturnType(functionNode, sourceCode) {
+	// 1. Check explicit return type annotation
+	if (functionNode.returnType) {
+		return getTypeName(functionNode.returnType.typeAnnotation)
+	}
+
+	// 2. For variable declarations like const foo: (arg: Type) => ReturnType = ...
+	if (functionNode.parent && functionNode.parent.type === "VariableDeclarator") {
+		const declarator = functionNode.parent
+		if (declarator.id && declarator.id.typeAnnotation) {
+			const typeAnnotation = declarator.id.typeAnnotation.typeAnnotation
+
+			// Handle function type annotations
+			if (typeAnnotation.type === "TSFunctionType" && typeAnnotation.typeAnnotation) {
+				return getTypeName(typeAnnotation.typeAnnotation)
+			}
+
+			// Handle type references to function types
+			if (typeAnnotation.type === "TSTypeReference") {
+				// This might be a type like Promise<ReturnType>
+				if (
+					typeAnnotation.typeName.name === "Promise" &&
+					typeAnnotation.typeParameters &&
+					typeAnnotation.typeParameters.params.length > 0
+				) {
+					return getTypeName(typeAnnotation.typeParameters.params[0])
+				}
+			}
+		}
+	}
+
+	// 3. For class methods, check if it's part of an interface implementation
+	if (
+		functionNode.parent &&
+		functionNode.parent.type === "MethodDefinition" &&
+		functionNode.parent.parent &&
+		functionNode.parent.parent.type === "ClassBody"
+	) {
+		const className = getEnclosingClassName(functionNode)
+		const methodName = functionNode.parent.key.name
+
+		if (className && methodName) {
+			// Look for interface declarations in the scope
+			const scope = sourceCode.getScope(functionNode)
+			// This would require more complex scope analysis which is limited in ESLint
+			// For now, we'll return null and rely on other methods
+		}
+	}
+
+	return null
+}
+
+// Helper to get the class name for a method
+function getEnclosingClassName(node) {
+	let current = node.parent
+	while (current) {
+		if (current.type === "ClassDeclaration" && current.id) {
+			return current.id.name
+		}
+		current = current.parent
+	}
+	return null
+}
+function isNamespacedProtobufType(protobufNamespaceImports, typeName) {
+	if (!typeName.includes(".")) {
+		return false
+	}
+
+	const namespace = typeName.split(".")[0]
+	return protobufNamespaceImports.has(namespace)
+}
+
+function findParentFunction(node) {
+	let current = node.parent
+	while (current) {
+		if (
+			current.type === "FunctionDeclaration" ||
+			current.type === "FunctionExpression" ||
+			current.type === "ArrowFunctionExpression"
+		) {
+			return current
+		}
+		current = current.parent
+	}
+	return null
+}

eslint-rules/package.json

@@ -0,0 +1,31 @@
+{
+	"name": "eslint-plugin-eslint-rules",
+	"version": "1.0.0",
+	"description": "Custom ESLint rules for Cline",
+	"main": "index.js",
+	"scripts": {
+		"test": "mocha --no-config --require ts-node/register __tests__/**/*.test.ts"
+	},
+	"keywords": [
+		"eslint",
+		"eslintplugin"
+	],
+	"author": "Cline Bot Inc.",
+	"license": "Apache-2.0",
+	"dependencies": {
+		"@typescript-eslint/utils": "^8.33.0"
+	},
+	"devDependencies": {
+		"@types/eslint": "^8.0.0",
+		"@types/mocha": "^10.0.7",
+		"@types/node": "^20.0.0",
+		"@typescript-eslint/parser": "^7.14.1",
+		"eslint": "^8.57.0",
+		"mocha": "^10.0.0",
+		"ts-node": "^10.9.2",
+		"typescript": "^5.4.5"
+	},
+	"peerDependencies": {
+		"eslint": ">=8.0.0"
+	}
+}