update helpers

- Replace globalSetup/globalTeardown with Playwright projects configuration
- Rename setup.ts to global.setup.ts and teardown.ts to global.teardown.ts
- Convert ClineApiServerMock to use shared global server instance
- Add proper dependency management between setup, tests, and cleanup phases
- Improve server connection tracking and cleanup handling

.changeset/gorgeous-pugs-cover.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-Migrate settingsButtonClicked to protobus

.changeset/nasty-plums-run.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Fix Global Rules directory documentation for Linux/WSL systems

.changeset/nine-adults-play.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+DeepSeek R1 0528 support under Hugging Face

.changeset/olive-frogs-applaud.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+remove duplicate tool registration for claude4-experimental

.changeset/rare-fans-clean.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Add Huawei Cloud MaaS Provider

.changeset/smart-jobs-impress.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Fixed token counting when using VSCode LM API provider

.changeset/sweet-days-whisper.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+fix: only focus on editor panel that is visible and active to stop input field stealing issue

.changeset/thirty-spies-deliver.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Add Cerebras Qwen 3 235B instruct

.changeset/tiny-pants-train.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+trim input value for URL fields

.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, outputChannel: vscode.OutputChannel, webviewProvider: WebviewProvider) {
+  constructor(context: vscode.ExtensionContext, webviewProvider: WebviewProvider) {
     this.mcpHub = new McpHub(this)
   }
 

.clinerules/protobuf-development.md

@@ -0,0 +1,89 @@
+# 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

@@ -0,0 +1,75 @@
+# 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>
+
+**First, check the expected output size:**
+   ```shell
+   (git branch --show-current && echo "=== STATUS ===" && git status --porcelain | cat && echo "=== COMMIT MESSAGES ===" && git log main..HEAD --oneline | cat && echo "=== CHANGED FILES ===" && git diff main --name-only | cat && echo "=== FULL DIFF ===" && git diff main | cat) | wc -l
+   ```
+
+**If the expected line count is greater than 500 lines, use the file-based approach:**
+   ```shell
+   git branch --show-current > cline-git-analysis.temp && echo "=== STATUS ===" >> cline-git-analysis.temp && git status --porcelain >> cline-git-analysis.temp && echo "=== COMMIT MESSAGES ===" >> cline-git-analysis.temp && git log main..HEAD --oneline >> cline-git-analysis.temp && echo "=== CHANGED FILES ===" >> cline-git-analysis.temp && git diff main --name-only >> cline-git-analysis.temp && echo "=== FULL DIFF ===" >> cline-git-analysis.temp && git diff main >> cline-git-analysis.temp
+   ```
+
+   Then, read the file using the read_file tool. After you have read the file but before you proceed with subsequent steps, delete it:
+   ```shell
+   rm cline-git-analysis.temp
+   ```
+
+**If the expected line count is 500 lines or fewer, use the direct approach:**
+   ```shell
+   git branch --show-current && echo "=== STATUS ===" && git status --porcelain | cat && echo "=== COMMIT MESSAGES ===" && git log main..HEAD --oneline | cat && echo "=== CHANGED FILES ===" && git diff main --name-only | cat && echo "=== FULL DIFF ===" && git diff main | cat
+   ```
+
+<important>If using the direct approach, pipe outputs through `cat` to avoid interactive terminals. If the user's shell is not bash/zsh, adjust the command and chaining
+ syntax accordingly.</important>
+
+## 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/writing-documentation.md

@@ -0,0 +1,392 @@
+# 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.

.eslintrc.json

@@ -20,8 +20,14 @@
 		"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"
+		"eslint-rules/no-direct-vscode-api": "warn",
+		"no-restricted-syntax": [
+			"error",
+			{
+				"selector": "VariableDeclarator[id.type=\"ObjectPattern\"][init.object.name=\"process\"][init.property.name=\"env\"]",
+				"message": "Use process.env.VARIABLE_NAME directly instead of destructuring"
+			}
+		]
 	},
 	"ignorePatterns": ["out", "dist", "**/*.d.ts"]
 }

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -5,7 +5,7 @@ body:
     - type: markdown
       attributes:
           value: |
-              **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.
+              **Important:** All bug reports must be reproducible using Claude 4 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: true
+          required: false
     - type: textarea
       id: logs
       attributes:
@@ -39,20 +39,19 @@ 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 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"
+          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
       validations:
           required: true
     - type: input
@@ -63,8 +62,3 @@ 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: true
+blank_issues_enabled: false
 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,6 +6,3 @@ 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,10 +1,46 @@
+<!--
+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
 
-<!-- Describe your changes in detail. What problem does this PR solve? -->
+<!-- 
+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.
+-->
 
 ### Test Procedure
 
-<!-- How did you test this? Are you confident that it will not introduce bugs? If so, why? -->
+<!-- 
+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.
+-->
 
 ### Type of Change
 
@@ -29,7 +65,15 @@
 
 ### Screenshots
 
-<!-- For UI changes, add screenshots here -->
+<!-- 
+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.
+-->
 
 ### Additional Notes
 

.github/workflows/e2e.yml

@@ -0,0 +1,108 @@
+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,6 +11,10 @@ on:
                 options:
                     - pre-release
                     - release
+            tag:
+                description: "Enter existing tag to publish (e.g., v3.1.2)"
+                required: true
+                type: string
 
 permissions:
     contents: write
@@ -30,6 +34,8 @@ jobs:
 
         steps:
             - uses: actions/checkout@v4
+              with:
+                  ref: ${{ github.event.inputs.tag }}
 
             - name: Setup Node.js
               uses: actions/setup-node@v4
@@ -69,19 +75,26 @@ jobs:
                   VERSION=$(node -p "require('./package.json').version")
                   echo "version=$VERSION" >> $GITHUB_OUTPUT
 
-            - name: Create Git Tag
-              id: create_tag
+            - name: Validate Tag
+              id: validate_tag
               run: |
-                  VERSION=v${{ steps.get_version.outputs.version }}
-                  echo "tag=$VERSION" >> $GITHUB_OUTPUT
-                  echo "Tagging with $VERSION"
-                  git tag "$VERSION"
-                  git push origin "$VERSION"
+                  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"
 
             - 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 --out "cline-${{ steps.get_version.outputs.version }}.vsix"
@@ -106,7 +119,7 @@ jobs:
             - name: Create GitHub Release
               uses: softprops/action-gh-release@v1
               with:
-                  tag_name: ${{ steps.create_tag.outputs.tag }}
+                  tag_name: ${{ steps.validate_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@28ca103
+            - uses: actions/stale@v9
               with:
                   days-before-issue-stale: 60
                   days-before-issue-close: 14

.github/workflows/test.yml

@@ -68,6 +68,16 @@ 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: Install local modules on windows
+              if: runner.os == 'Windows' && steps.root-cache.outputs.cache-hit == 'true'
+              run: |
+                  npm install eslint-plugin-eslint-rules 
+                  cd webview-ui/ && npm install eslint-plugin-eslint-rules
+
             - name: Set up NPM on Windows
               if: runner.os == 'Windows'
               run: |

.gitignore

@@ -7,6 +7,7 @@ tmp
 *.vsix
 
 .DS_Store
+.idea
 
 pnpm-lock.yaml
 
@@ -14,6 +15,9 @@ 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/
@@ -21,19 +25,10 @@ coverage
 
 *evals.env
 
-# 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
+## Generated files ##
+src/generated/
+src/shared/proto/
 webview-ui/src/services/grpc-client.ts
-# 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
+
+# E2E Tests
+test-results

.husky/pre-commit

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

.prettierignore

@@ -5,3 +5,6 @@ webview-ui/build/
 package-lock.json
 src/core/prompts/system.ts
 src/core/prompts/model_prompts/claude4.ts
+evals/
+docs/
+out/

.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}",
+	files: "{out/**/*.test.js,src/**/*.test.js,!src/test/e2e/**/*.test.js,!out/src/test/e2e/**/*.test.js}",
 	mocha: {
 		ui: "bdd",
 		timeout: 20000, // Maximum time (in ms) that a test can run before failing

.vscode/launch.json

@@ -6,7 +6,7 @@
 	"version": "0.2.0",
 	"configurations": [
 		{
-			"name": "Run Extension",
+			"name": "Run Extension (production)",
 			"type": "extensionHost",
 			"request": "launch",
 			"args": ["--extensionDevelopmentPath=${workspaceFolder}", "--disable-workspace-trust", "${workspaceFolder}"],
@@ -14,7 +14,34 @@
 			"preLaunchTask": "${defaultBuildTask}",
 			"env": {
 				"IS_DEV": "true",
-				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}"
+				"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"
 			}
 		},
 		{
@@ -23,26 +50,28 @@
 			"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-sandbox",
+			"preLaunchTask": "clean-tmp-user",
 			"internalConsoleOptions": "openOnSessionStart",
 			"postDebugTask": "stop",
 			"env": {
 				"IS_DEV": "true",
-				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}"
+				"TEMP_PROFILE": "true",
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
+				"CLINE_ENVIRONMENT": "production"
 			}
 		},
 		{
 			"type": "node",
 			"request": "launch",
-			"name": "Run Standalone Extension",
+			"name": "Run cline-core service",
 			"skipFiles": ["<node_internals>/**"],
 			"sourceMaps": true,
 			"resolveSourceMapLocations": ["${workspaceFolder}/**", "!**/node_modules/**"],
@@ -50,11 +79,12 @@
 			"outFiles": ["${workspaceFolder}/dist-standalone/**/*.js"],
 			"preLaunchTask": "compile-standalone",
 			"env": {
-				"GRPC_TRACE": "all",
-				"GRPC_VERBOSITY": "DEBUG",
+				// Turns on grpc debug log.
+				//"GRPC_TRACE": "all",
+				//"GRPC_VERBOSITY": "DEBUG",
 				"NODE_PATH": "${workspaceFolder}/dist-standalone/node_modules"
 			},
-			"program": "standalone.js"
+			"program": "cline-core.js"
 		}
 	]
 }

.vscode/settings.json

@@ -9,5 +9,9 @@
 		"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.tsc.autoDetect": "off",
+	// Protobuf settings
+	"protoc": {
+		"options": ["--proto_path=proto"]
+	}
 }

.vscode/tasks.json

@@ -128,7 +128,25 @@
 			"type": "npm",
 			"script": "watch:esbuild",
 			"group": "build",
-			"problemMatcher": "$esbuild-watch",
+			"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$"
+				}
+			},
 			"isBackground": true,
 			"label": "npm: watch:esbuild",
 			"dependsOn": ["npm: protos"],
@@ -146,7 +164,25 @@
 			"type": "npm",
 			"script": "watch:esbuild:test",
 			"group": "build",
-			"problemMatcher": "$esbuild-watch",
+			"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$"
+				}
+			},
 			"isBackground": true,
 			"label": "npm: watch:esbuild:test",
 			"dependsOn": ["npm: protos"],
@@ -197,10 +233,10 @@
 			"type": "shell"
 		},
 		{
-			"label": "clean-sandbox",
+			"label": "clean-tmp-user",
 			"type": "shell",
 			"dependsOn": ["watch"],
-			"command": "rm -rf .vscode-dev"
+			"command": "rm -rf ${workspaceFolder}/dist/tmp/user && mkdir -p ${workspaceFolder}/dist/tmp/user"
 		}
 	],
 	"inputs": [

.vscodeignore

@@ -1,24 +1,40 @@
 # Default
 .vscode/**
 .vscode-test/**
-out/**
-node_modules/**
+out/
+dist-standalone/
+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/**
@@ -32,17 +48,19 @@ 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.js
+e2e.vsix
+test-results/

CONTRIBUTING.md

@@ -10,16 +10,74 @@ 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
@@ -29,6 +87,7 @@ If you're planning to work on a bigger feature, please create a [feature request
 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**
@@ -73,8 +132,6 @@ If you're planning to work on a bigger feature, please create a [feature request
       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:

README.md

@@ -30,7 +30,7 @@ English | <a href="https://github.com/cline/cline/blob/main/locales/es/README.md
 </table>
 </div>
 
-Meet Cline, an AI assistant that can use your **CLI** a**N**d **E**ditor.
+Meet Cline (pronounced /klaɪn/, like "Klein"), an AI assistant that can use your **CLI** a**N**d **E**ditor.
 
 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.
 
@@ -51,7 +51,7 @@ Thanks to [Claude 3.7 Sonnet's agentic coding capabilities](https://www.anthrop
 
 ### Use any API and Model
 
-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.
+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.
 
 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.
 
@@ -141,50 +141,6 @@ 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)

buf.yaml

@@ -0,0 +1,21 @@
+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

@@ -61,7 +61,6 @@
 					"getting-started/installing-cline",
 					"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",
 					"getting-started/what-is-cline"
@@ -146,6 +145,8 @@
 				"group": "Provider Configuration",
 				"pages": [
 					"provider-config/anthropic",
+					"provider-config/claude-code",
+					"provider-config/aws-bedrock-with-apikey-authentication",
 					"provider-config/aws-bedrock-with-credentials-authentication",
 					"provider-config/aws-bedrock-with-profile-authentication",
 					"provider-config/gcp-vertex-ai",
@@ -158,7 +159,8 @@
 					"provider-config/openai",
 					"provider-config/openai-compatible",
 					"provider-config/openrouter",
-					"provider-config/requesty"
+					"provider-config/requesty",
+					"provider-config/sap-aicore"
 				]
 			},
 			{
@@ -169,6 +171,10 @@
 					"running-models-locally/ollama"
 				]
 			},
+			{
+				"group": "Troubleshooting",
+				"pages": ["troubleshooting/terminal-quick-fixes", "troubleshooting/terminal-integration-guide"]
+			},
 			{
 				"group": "More Info",
 				"pages": ["more-info/telemetry"]

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

@@ -14,6 +14,8 @@ 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-3.7-sonnet (200K context window)
+Model: anthropic/claude-sonnet-4 (200K context window)
 \`\`\`
 
 **IMPORTANT**: When you see context window usage at or above 50%, you MUST:

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

@@ -58,3 +58,16 @@ 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/cline-rules.mdx

@@ -11,7 +11,19 @@ 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 `Documents/Cline/Rules` directory (if it's a Global 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.
 
 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,8 +74,25 @@ 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 with file mentions**: After sending terminal output to Cline, you can enhance your question by mentioning relevant files using the @ mentions feature.
+-   **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.
 
--   **Use for build and test output**: Terminal integration is particularly useful for understanding complex build errors or test failures that span multiple lines.
+-   **Contextualize build & test outputs with the terminal**: 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/getting-started/our-favorite-tech-stack.mdx

@@ -1,238 +0,0 @@
----
-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/mcp/adding-mcp-servers-from-github.mdx

@@ -17,6 +17,7 @@ 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 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.
+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.
 
-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.
+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.
 
 ### Tracking Policy
 
-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.
+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.
 
 ### What We Track
 
-We collect basic anonymous usage data including:
+We collect basic 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 anonymous 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/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/posthog/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 anonymous telemetry
+-   When you update or install our VS Code extension, you'll see a message about our 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,13 +4,15 @@
 	"main": "index.js",
 	"scripts": {
 		"test": "echo \"Error: no test specified\" && exit 1",
-		"dev": "mintlify dev"
+		"dev": "mintlify dev",
+		"check": "mintlify broken-links",
+		"rename": "mintlify rename"
 	},
 	"keywords": [],
 	"author": "",
 	"license": "ISC",
 	"description": "",
 	"dependencies": {
-		"mintlify": "^4.0.538"
+		"mintlify": "^4.2.23"
 	}
 }

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

@@ -0,0 +1,135 @@
+---
+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.\
+    [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, 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.
+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 credentials 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) and coordinate with your internal cloud team. 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/aws-bedrock-with-credentials-authentication.mdx

@@ -5,7 +5,7 @@ description: "Learn how to set up AWS Bedrock with Cline using credentials authe
 
 ### Overview
 
--   **AWS Bedrock:** A fully managed service that offers access to leading generative AI models (e.g., Anthropic Claude, Amazon Titan) through AWS.\
+-   **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.
 -   **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.
@@ -25,7 +25,7 @@ description: "Learn how to set up AWS Bedrock with Cline using credentials authe
 
 #### 1.2 Attach the Required Policies
 
-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:
+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`
@@ -52,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 **`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)
+-   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)
 
 **Important Considerations:**
 
@@ -71,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 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.
+    - 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.
 
 #### 2.2 Set Up AWS Marketplace Subscriptions (if needed)
 
@@ -138,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 `AmazonBedrockFullAccess` policy, and ensure necessary permissions.
+1. **Prepare Your AWS Environment:** Create or use a secure IAM role/user, attach the `AmazonBedrockLimitedAccess` 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/claude-code.mdx

@@ -0,0 +1,93 @@
+---
+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-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/sap-aicore.mdx

@@ -0,0 +1,39 @@
+---
+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)
+
+### Getting a Service Binding
+
+> 💡 **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 to perform these steps.
+
+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.  **Select Model:** Choose your desired model from the "Model" dropdown.
+
+### Tips and Notes
+
+-   **Model Selection:** SAP AI Core offers a wide range of models. You won't be able to use the model, even if selected, if a deployment doesn't exist in the provided resource group.

docs/troubleshooting/terminal-integration-guide.mdx

@@ -0,0 +1,446 @@
+---
+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

@@ -0,0 +1,51 @@
+---
+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.mjs

@@ -1,10 +1,15 @@
-const esbuild = require("esbuild")
-const fs = require("fs")
-const path = require("path")
+import fs from "node:fs"
+import * as esbuild from "esbuild"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
 
 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"
 
 /**
@@ -125,9 +130,9 @@ const baseConfig = {
 	minify: production,
 	sourcemap: !production,
 	logLevel: "silent",
-	define: {
-		"process.env.IS_DEV": JSON.stringify(!production),
-	},
+	define: production
+		? { "import.meta.url": "_importMetaUrl", "process.env.IS_DEV": JSON.stringify(!production) }
+		: { "import.meta.url": "_importMetaUrl" },
 	tsconfig: path.resolve(__dirname, "tsconfig.json"),
 	plugins: [
 		copyWasmFiles,
@@ -138,6 +143,9 @@ const baseConfig = {
 	format: "cjs",
 	sourcesContent: false,
 	platform: "node",
+	banner: {
+		js: "const _importMetaUrl=require('url').pathToFileURL(__filename)",
+	},
 }
 
 // Extension-specific configuration
@@ -151,15 +159,25 @@ const extensionConfig = {
 // Standalone-specific configuration
 const standaloneConfig = {
 	...baseConfig,
-	entryPoints: ["src/standalone/standalone.ts"],
-	outfile: `${destDir}/standalone.js`,
+	entryPoints: ["src/standalone/cline-core.ts"],
+	outfile: `${destDir}/cline-core.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.js`,
+	external: ["@vscode/test-electron", "execa"],
+	sourcemap: false,
+	plugins: [aliasResolverPlugin, esbuildProblemMatcherPlugin],
+}
+
 async function main() {
-	const config = standalone ? standaloneConfig : extensionConfig
+	const config = standalone ? standaloneConfig : e2eBuild ? e2eBuildConfig : extensionConfig
 	const extensionCtx = await esbuild.context(config)
 	if (watch) {
 		await extensionCtx.watch()

eslint-rules/__tests__/no-direct-vscode-api.test.ts

@@ -0,0 +1,123 @@
+const { RuleTester: DirectApiRuleTester } = require("eslint")
+const noDirectVscodeApiRule = require("../no-direct-vscode-api")
+
+const directApiRuleTester = new DirectApiRuleTester({
+	parser: require.resolve("@typescript-eslint/parser"),
+	parserOptions: {
+		ecmaVersion: 2020,
+		sourceType: "module",
+		ecmaFeatures: {
+			jsx: true,
+		},
+	},
+})
+
+directApiRuleTester.run("no-direct-vscode-api", noDirectVscodeApiRule, {
+	valid: [
+		// Should allow vscode.postMessage in grpc-client-base.ts
+		{
+			code: `vscode.postMessage({ type: "grpc_request", data: {} })`,
+			filename: "grpc-client-base.ts",
+		},
+		{
+			code: `vscode.postMessage({ type: "grpc_request_cancel" })`,
+			filename: "/path/to/grpc-client-base.ts",
+		},
+		// Should allow in exception directories
+		{
+			code: `vscode.workspace.workspaceFolders`,
+			filename: "/src/hosts/vscode/host-bridge.ts",
+		},
+		{
+			code: `vscode.workspace.fs.stat(uri)`,
+			filename: "/standalone/runtime-files/helpers.ts",
+		},
+		// Should allow other vscode API calls
+		{
+			code: `vscode.window.showInformationMessage("Hello")`,
+			filename: "test.ts",
+		},
+		// Should allow postMessage calls on other objects
+		{
+			code: `window.postMessage({ type: "test" }, "*")`,
+			filename: "test.ts",
+		},
+		// Should allow variables named vscode but not calling postMessage
+		{
+			code: `const vscode = { other: "method" }; vscode.other()`,
+			filename: "test.ts",
+		},
+	],
+	invalid: [
+		// Should disallow vscode.postMessage in regular files
+		{
+			code: `vscode.postMessage({ type: "test", data: {} })`,
+			filename: "test.ts",
+			errors: [
+				{
+					messageId: "useGrpcClient",
+				},
+			],
+		},
+		// Should disallow vscode.postMessage in components
+		{
+			code: `vscode.postMessage({ type: "apiConfiguration", apiConfiguration })`,
+			filename: "ApiOptions.tsx",
+			errors: [
+				{
+					messageId: "useGrpcClient",
+				},
+			],
+		},
+		// Should disallow vscode.postMessage in test files
+		{
+			code: `vscode.postMessage({ type: "newTask", text: message.text })`,
+			filename: "test.test.ts",
+			errors: [
+				{
+					messageId: "useGrpcClient",
+				},
+			],
+		},
+		// Should disallow property access for disallowed APIs
+		{
+			code: `const folders = vscode.workspace.workspaceFolders;`,
+			filename: "workspace.ts",
+			errors: [
+				{
+					messageId: "useHostBridge",
+				},
+			],
+		},
+		// Should disallow method calls for disallowed APIs
+		{
+			code: `const relativePath = vscode.workspace.asRelativePath(filePath);`,
+			filename: "path-utils.ts",
+			errors: [
+				{
+					messageId: "usePathUtils",
+				},
+			],
+		},
+		// Should disallow nested property access
+		{
+			code: `const stats = await vscode.workspace.fs.stat(uri);`,
+			filename: "file-utils.ts",
+			errors: [
+				{
+					messageId: "useFsUtils",
+				},
+			],
+		},
+		// Should disallow getting a workspace folder
+		{
+			code: `const folder = vscode.workspace.getWorkspaceFolder(uri);`,
+			filename: "path-helper.ts",
+			errors: [
+				{
+					messageId: "usePathUtils",
+				},
+			],
+		},
+	],
+})

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

@@ -1,174 +0,0 @@
-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

@@ -1,214 +0,0 @@
-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

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

eslint-rules/no-direct-vscode-api.js

@@ -0,0 +1,214 @@
+const { ESLintUtils } = require("@typescript-eslint/utils")
+const path = require("path")
+
+const createRule = ESLintUtils.RuleCreator((name) => `https://cline.bot/eslint-rules/${name}`)
+
+// Configuration of disallowed VSCode APIs and their recommended alternatives
+const disallowedApis = {
+	"vscode.postMessage": {
+		messageId: "useGrpcClient",
+	},
+	"vscode.workspace.fs.stat": {
+		messageId: "useFsUtils",
+	},
+	"vscode.workspace.fs.writeFile": {
+		messageId: "useFsUtils",
+	},
+	"vscode.workspace.workspaceFolders": {
+		messageId: "useHostBridgeWorkspace",
+	},
+	"vscode.workspace.asRelativePath": {
+		messageId: "usePathUtils",
+	},
+	"vscode.workspace.getWorkspaceFolder": {
+		messageId: "usePathUtils",
+	},
+	"vscode.window.showTextDocument": {
+		messageId: "useHostBridge",
+	},
+	"vscode.workspace.applyEdit": {
+		messageId: "useHostBridge",
+	},
+	"vscode.window.onDidChangeActiveTextEditor": {
+		messageId: "useHostBridge",
+	},
+	"vscode.env.openExternal": {
+		messageId: "useUtils",
+	},
+	// "vscode.window.showWarningMessage": {
+	// 	messageId: "useHostBridgeShowMessage",
+	// },
+	"vscode.window.showOpenDialog": {
+		messageId: "useHostBridgeShowMessage",
+	},
+	"vscode.window.showErrorMessage": {
+		messageId: "useHostBridgeShowMessage",
+	},
+	// "vscode.window.showInformationMessage": {
+	// 	messageId: "useHostBridgeShowMessage",
+	// },
+}
+
+module.exports = createRule({
+	name: "no-direct-vscode-api",
+	meta: {
+		type: "problem",
+		docs: {
+			description:
+				"Disallow direct VSCode API usage in favor of Cline's abstraction layers, except in src/hosts/vscode and standalone/runtime-files directories",
+			recommended: "error",
+		},
+		messages: {
+			useGrpcClient:
+				"Use gRPC service clients instead of vscode.postMessage().\n" +
+				"Example: AccountServiceClient.methodName(RequestType.create({...})) instead of vscode.postMessage({type: '...'}).\n" +
+				"Found: {{code}}",
+			useFsUtils:
+				"Use utilities in @/utils/fs instead of vscode.workspace.fs\n" +
+				"Example: import { isDirectory } from '@/utils/fs' or use the file system methods from the host bridge provider.\n" +
+				"Found: {{code}}",
+			usePathUtils:
+				"Use path utilities from @/utils/path instead of VSCode workspace path methods.\n" +
+				"This provides consistent path handling across different environments.\n" +
+				"Found: {{code}}",
+			useHostBridgeWorkspace:
+				"Use HostProvider.workspace.getWorkspacePaths({}) instead of vscode.workspace.workspaceFolders.\n" +
+				"This provides a consistent abstraction across VSCode and standalone environments.\n" +
+				"Found: {{code}}",
+			useHostBridgeShowMessage:
+				"Use HostProvider.window.showMessage instead of the vscode.window.showMessage.\n" +
+				"This provides a consistent abstraction across VSCode and standalone environments.\n" +
+				"Found: {{code}}",
+			useHostBridge:
+				"Use the host bridge instead of calling vscode APIs directly.\n" +
+				"This provides a consistent abstraction across VSCode and standalone environments.\n" +
+				"Found: {{code}}",
+			useUtils:
+				"Use utilities in @/utils instead of calling vscode APIs directly.\n" +
+				"This provides a consistent abstraction across VSCode and standalone environments.\n" +
+				"Found: {{code}}",
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+
+	create(context) {
+		// Pattern for checking memberExpressions like vscode.workspace.fs.stat
+		function checkMemberExpression(node) {
+			if (isExcluded(context.filename)) {
+				// Skip if this file is being excluded.
+				return
+			}
+
+			// For handling nested properties like vscode.workspace.fs.stat
+			function getFullPropertyPath(node) {
+				if (node.type !== "MemberExpression") {
+					return node.name || ""
+				}
+
+				const objectPart = getFullPropertyPath(node.object)
+				const propertyPart = node.property.name || ""
+
+				return objectPart ? `${objectPart}.${propertyPart}` : propertyPart
+			}
+
+			// Check if the expression matches one of our disallowed patterns
+			if (node.object && node.object.type === "Identifier" && node.object.name === "vscode") {
+				const fullPath = `vscode.${node.property.name}`
+				checkDisallowedApi(fullPath, node)
+			}
+			// Handle nested expressions like vscode.workspace.fs.stat
+			else if (node.object && node.object.type === "MemberExpression") {
+				const fullPath = getFullPropertyPath(node)
+
+				// Only proceed if it starts with vscode
+				if (fullPath.startsWith("vscode.")) {
+					checkDisallowedApi(fullPath, node)
+				}
+			}
+		}
+
+		// Check if an expression matches a disallowed API and report if it does
+		function checkDisallowedApi(expressionPath, node) {
+			// Check exact matches
+			if (disallowedApis[expressionPath]) {
+				reportViolation(expressionPath, node)
+				return
+			}
+
+			// Check prefix matches (for nested properties)
+			for (const disallowedApi in disallowedApis) {
+				// For direct property access like vscode.workspace.workspaceFolders
+				if (expressionPath === disallowedApi) {
+					reportViolation(disallowedApi, node)
+					return
+				}
+
+				// For method calls like vscode.workspace.asRelativePath(...)
+				if (expressionPath.startsWith(`${disallowedApi}.`) || expressionPath.startsWith(`${disallowedApi}(`)) {
+					reportViolation(disallowedApi, node)
+					return
+				}
+			}
+		}
+
+		// Report a violation with the appropriate message
+		function reportViolation(disallowedApi, node) {
+			const sourceCode = context.sourceCode
+			const config = disallowedApis[disallowedApi]
+
+			// For method calls, get the whole call expression
+			let reportNode = node
+			let parentNode = sourceCode.getAncestors(node).pop()
+			if (parentNode && parentNode.type === "CallExpression" && parentNode.callee === node) {
+				reportNode = parentNode
+			}
+
+			const callText = sourceCode.getText(reportNode).trim()
+
+			context.report({
+				node: reportNode,
+				messageId: config.messageId,
+				data: {
+					code: callText,
+				},
+			})
+		}
+
+		function isExcluded(filename) {
+			// Check if current file is in an exception directory or is grpc-client-base.ts
+			if (path.basename(filename) === "grpc-client-base.ts") {
+				return true
+			}
+			// Skip checking files in src/hosts/vscode or standalone/runtime-files
+			if (filename.includes("/src/hosts/vscode/")) {
+				return true
+			}
+			if (filename.includes("/standalone/runtime-files/")) {
+				return true
+			}
+			// Skip unit tests
+			if (filename.endsWith(".test.ts")) {
+				return true
+			}
+		}
+
+		return {
+			// Detect basic member expressions (e.g., vscode.postMessage)
+			MemberExpression(node) {
+				checkMemberExpression(node)
+			},
+
+			// Detect property access through destructuring
+			VariableDeclarator(node) {
+				// Skip if this file is in an exception directory or is grpc-client-base.ts
+				if (isExcluded(context.filename)) {
+					return
+				}
+
+				// Destructuring pattern checks removed as developers don't use the API this way
+				// They always use direct imports: import * as vscode from "vscode" and direct access: vscode.thing.foo
+			},
+		}
+	},
+})

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

@@ -1,216 +0,0 @@
-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

@@ -1,556 +0,0 @@
-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
-}

evals/.gitignore

@@ -1,3 +1,24 @@
 repositories
 
-results/evals.db
+results/evals.db
+
+diff-edits/cases/
+diff-edits/results/
+
+# Environment variables
+.env
+
+# backwards compatible
+diff_editing/test_cases/
+diff_editing/test_outputs/
+
+*.db
+*.db-wal
+*.db-shm
+
+.cache
+
+# Python bytecode cache
+*__pycache__/
+
+diff-edits/cases.zip

evals/README.md

@@ -17,6 +17,7 @@ The evaluation system consists of two main components:
 
 1. **Test Server**: Enhanced HTTP server in `src/services/test/TestServer.ts` that provides detailed task results
 2. **CLI Tool**: Command-line interface in `evals/cli/` for orchestrating evaluations
+3. **Diff Edit Benchmark**: Separate command using the CLI tool that runs a comprehensive diff editing benchmark suite on real world cases, along with a streamlit dashboard displaying the results. For more details, see the [Diff Edit Benchmark README](./diff-edits/README.md). Make sure you add a `evals/diff-edits/cases` folder with all the conversation jsons. 
 
 ## Directory Structure
 
@@ -40,6 +41,12 @@ cline-repo/
 │   │   │   └── utils/                # Utility functions
 │   │   ├── package.json
 │   │   └── tsconfig.json
+│   ├── diff-edits/                   # Diff editing evaluation suite
+│   │   ├── cases/                    # Test case JSON files
+│   │   ├── results/                  # Evaluation results
+│   │   ├── diff-apply/               # Diff application logic
+│   │   ├── parsing/                  # Assistant message parsing
+│   │   └── prompts/                  # System prompts
 │   ├── repositories/                 # Cloned benchmark repositories
 │   │   ├── exercism/                 # Modified Exercism (from pashpashpash/evals)
 │   │   ├── swe-bench/                # SWE-Bench repository
@@ -148,6 +155,192 @@ Freelance-style programming tasks from the SWELancer benchmark.
 
 Multi-file software engineering tasks from the Multi-SWE-Bench repository.
 
+## Diff Edit Evaluations
+
+The Cline Evaluation System includes a specialized suite for evaluating how well models can make precise edits to files using the `replace_in_file` tool.
+
+### Overview
+
+Diff edit evaluations test a model's ability to:
+
+1. Understand file content and identify specific sections to modify
+2. Generate correct SEARCH/REPLACE blocks for targeted edits
+3. Successfully apply changes without introducing errors
+
+### Directory Structure
+
+```
+diff-edits/
+├── cases/                  # Test case JSON files
+├── results/                # Evaluation results
+├── ClineWrapper.ts         # Wrapper for model interaction
+├── TestRunner.ts           # Main test execution logic
+├── types.ts                # Type definitions
+├── diff-apply/             # Diff application logic
+├── parsing/                # Assistant message parsing
+└── prompts/                # System prompts
+```
+
+### Creating Test Cases
+
+Test cases are defined as JSON files in the `diff-edits/cases/` directory. Each test case should include:
+
+```json
+{
+  "test_id": "example_test_1",
+  "messages": [
+    {
+      "role": "user",
+      "text": "Please fix the bug in this code...",
+      "images": []
+    },
+    {
+      "role": "assistant",
+      "text": "I'll help you fix that bug..."
+    }
+  ],
+  "file_contents": "// Original file content here\nfunction example() {\n  // Code with bug\n}",
+  "file_path": "src/example.js",
+  "system_prompt_details": {
+    "mcp_string": "",
+    "cwd_value": "/path/to/working/directory",
+    "browser_use": false,
+    "width": 900,
+    "height": 600,
+    "os_value": "macOS",
+    "shell_value": "/bin/zsh",
+    "home_value": "/Users/username",
+    "user_custom_instructions": ""
+  },
+  "original_diff_edit_tool_call_message": ""
+}
+```
+
+### Running Diff Edit Evaluations
+
+#### Single Model Evaluation
+
+```bash
+cd evals/cli
+node dist/index.js run-diff-eval --model-ids "anthropic/claude-3-5-sonnet-20241022"
+```
+
+#### Multi-Model Evaluation
+
+Compare multiple models in a single evaluation run:
+
+```bash
+# Compare Claude and Grok models
+node dist/index.js run-diff-eval \
+  --model-ids "anthropic/claude-3-5-sonnet-20241022,x-ai/grok-beta" \
+  --max-cases 10 \
+  --valid-attempts-per-case 3 \
+  --verbose
+
+# Compare multiple Claude variants
+node dist/index.js run-diff-eval \
+  --model-ids "anthropic/claude-3-5-sonnet-20241022,anthropic/claude-3-5-haiku-20241022,anthropic/claude-3-opus-20240229" \
+  --max-cases 5 \
+  --valid-attempts-per-case 2 \
+  --parallel
+```
+
+#### Options
+
+- `--model-ids`: Comma-separated list of model IDs to evaluate (required)
+- `--system-prompt-name`: System prompt to use (default: "basicSystemPrompt")
+- `--valid-attempts-per-case`: Number of attempts per test case per model (default: 1)
+- `--max-cases`: Maximum number of test cases to run (default: all available)
+- `--parsing-function`: Function to parse assistant messages (default: "parseAssistantMessageV2")
+- `--diff-edit-function`: Function to apply diffs (default: "constructNewFileContentV2")
+- `--test-path`: Path to test cases (default: diff-edits/cases)
+- `--thinking-budget`: Tokens allocated for thinking (default: 0)
+- `--parallel`: Run tests in parallel (flag)
+- `--replay`: Use pre-recorded LLM output (flag)
+- `--verbose`: Enable detailed logging (flag)
+
+#### Examples
+
+```bash
+# Quick test with 2 models, 4 cases, 2 attempts each
+node dist/index.js run-diff-eval \
+  --model-ids "anthropic/claude-3-5-sonnet-20241022,x-ai/grok-beta" \
+  --max-cases 4 \
+  --valid-attempts-per-case 2 \
+  --verbose
+
+# Comprehensive evaluation with parallel execution
+node dist/index.js run-diff-eval \
+  --model-ids "anthropic/claude-3-5-sonnet-20241022,anthropic/claude-3-5-haiku-20241022" \
+  --system-prompt-name claude4SystemPrompt \
+  --valid-attempts-per-case 5 \
+  --max-cases 20 \
+  --parallel \
+  --verbose
+```
+
+### Database Storage & Analytics
+
+All evaluation results are automatically stored in a SQLite database (`diff-edits/evals.db`) for advanced analytics and comparison. The database includes:
+
+- **System Prompts**: Versioned system prompt content with hashing for deduplication
+- **Processing Functions**: Versioned parsing and diff-edit function configurations
+- **Files**: Original and edited file content with content-based hashing
+- **Runs**: Evaluation run metadata and configuration
+- **Cases**: Individual test case information with context tokens
+- **Results**: Detailed results with timing, cost, and success metrics
+
+### Interactive Dashboard
+
+Launch the Streamlit dashboard to visualize and analyze evaluation results:
+
+```bash
+cd diff-edits/dashboard
+streamlit run app.py
+```
+
+The dashboard provides:
+
+- **Model Performance Comparison**: Side-by-side comparison of success rates, latency, and costs
+- **Interactive Charts**: Success rate trends, latency vs cost analysis, and performance metrics
+- **Detailed Drill-Down**: Individual result analysis with file content viewing
+- **Run Selection**: Browse and compare different evaluation runs
+- **Real-time Updates**: Automatically refreshes with new evaluation data
+
+#### Dashboard Features
+
+1. **Hero Section**: Overview of current run with key metrics
+2. **Model Cards**: Performance cards with grades and detailed metrics
+3. **Comparison Charts**: Interactive Plotly charts for visual analysis
+4. **Result Explorer**: Detailed view of individual test results including:
+   - Original and edited file content
+   - Raw model output
+   - Parsed tool calls
+   - Timing and cost metrics
+   - Error analysis
+
+#### Quick Start Dashboard
+
+```bash
+# Run a quick evaluation
+node cli/dist/index.js run-diff-eval \
+  --model-ids "anthropic/claude-3-5-sonnet-20241022,x-ai/grok-beta" \
+  --max-cases 4 \
+  --valid-attempts-per-case 2 \
+  --verbose
+
+# Launch dashboard to view results
+cd diff-edits/dashboard && streamlit run app.py
+```
+
+### Legacy Results
+
+For backward compatibility, results are also saved as JSON files in the `diff-edits/results/` directory. The JSON results include:
+- Success/failure status
+- Extracted tool calls
+- Diff edit content
+- Token usage and cost metrics
+
 ## Metrics
 
 The evaluation system collects the following metrics:

evals/cli/package.json

@@ -1,39 +0,0 @@
-{
-	"name": "cline-evaluation-cli",
-	"version": "0.1.0",
-	"description": "CLI tool for orchestrating Cline evaluations across multiple benchmarks",
-	"main": "dist/index.js",
-	"scripts": {
-		"build": "tsc",
-		"start": "node dist/index.js",
-		"dev": "ts-node src/index.ts",
-		"test": "echo \"Error: no test specified\" && exit 1"
-	},
-	"keywords": [
-		"cline",
-		"evaluation",
-		"benchmark"
-	],
-	"author": "",
-	"license": "MIT",
-	"dependencies": {
-		"better-sqlite3": "^8.0.0",
-		"chalk": "^4.1.2",
-		"commander": "^9.4.1",
-		"execa": "^5.1.1",
-		"node-fetch": "^2.7.0",
-		"ora": "^5.4.1",
-		"sqlite": "^4.1.2",
-		"uuid": "^9.0.0",
-		"yargs": "^17.6.2"
-	},
-	"devDependencies": {
-		"@types/better-sqlite3": "^7.6.3",
-		"@types/node": "^18.11.18",
-		"@types/node-fetch": "^2.6.12",
-		"@types/uuid": "^9.0.0",
-		"@types/yargs": "^17.0.19",
-		"ts-node": "^10.9.1",
-		"typescript": "^4.9.4"
-	}
-}

evals/cli/src/commands/runDiffEval.ts

@@ -0,0 +1,104 @@
+import execa from "execa"
+import chalk from "chalk"
+import path from "path"
+
+interface RunDiffEvalOptions {
+	modelIds: string
+	systemPromptName: string
+	validAttemptsPerCase: number
+	maxAttemptsPerCase?: number
+	parsingFunction: string
+	diffEditFunction: string
+	thinkingBudget: number
+	parallel: boolean
+	verbose: boolean
+	testPath: string
+	outputPath: string
+	replay: boolean
+	replayRunId?: string
+	diffApplyFile?: string
+	saveLocally: boolean
+	maxCases?: number
+}
+
+export async function runDiffEvalHandler(options: RunDiffEvalOptions) {
+	console.log(chalk.blue("Starting diff editing evaluation..."))
+
+	// Resolve the path to the TestRunner.ts script relative to the current file
+	const scriptPath = path.resolve(__dirname, "../../../diff-edits/TestRunner.ts")
+
+	// Construct the arguments array for the execa call
+	const args = [
+		"--model-ids",
+		options.modelIds,
+		"--system-prompt-name",
+		options.systemPromptName,
+		"--valid-attempts-per-case",
+		String(options.validAttemptsPerCase),
+		"--parsing-function",
+		options.parsingFunction,
+		"--diff-edit-function",
+		options.diffEditFunction,
+	]
+
+	// Conditionally add the optional arguments
+	if (options.testPath) {
+		args.push("--test-path", options.testPath)
+	}
+	if (options.outputPath) {
+		args.push("--output-path", options.outputPath)
+	}
+	if (options.thinkingBudget > 0) {
+		args.push("--thinking-budget", String(options.thinkingBudget))
+	}
+
+	if (options.parallel) {
+		args.push("--parallel")
+	}
+
+	if (options.replay) {
+		args.push("--replay")
+	}
+
+	if (options.replayRunId) {
+		args.push("--replay-run-id", options.replayRunId)
+	}
+
+	if (options.diffApplyFile) {
+		args.push("--diff-apply-file", options.diffApplyFile)
+	}
+
+	if (options.verbose) {
+		args.push("--verbose")
+	}
+
+	if (options.maxAttemptsPerCase) {
+		args.push("--max-attempts-per-case", String(options.maxAttemptsPerCase))
+	}
+
+	if (options.maxCases) {
+		args.push("--max-cases", String(options.maxCases))
+	}
+
+	if (options.saveLocally) {
+		args.push("--save-locally")
+	}
+
+	try {
+		console.log(chalk.gray(`Executing: npx tsx ${scriptPath} ${args.join(" ")}`))
+
+		// Execute the script as a child process
+		// We use 'inherit' to stream the stdout/stderr directly to the user's terminal
+		const subprocess = execa("npx", ["tsx", "--tsconfig", path.resolve(__dirname, "../../../tsconfig.json"), scriptPath, ...args], {
+			stdio: "inherit",
+		})
+
+		await subprocess
+
+		console.log(chalk.green("Diff editing evaluation completed successfully."))
+	} catch (error) {
+		console.error(chalk.red("An error occurred during the diff editing evaluation."))
+		// The 'inherit' stdio will have already printed the error details from the script
+		process.exit(1)
+	}
+}

evals/cli/src/index.ts

@@ -5,6 +5,7 @@ import { setupHandler } from "./commands/setup"
 import { runHandler } from "./commands/run"
 import { reportHandler } from "./commands/report"
 import { evalsEnvHandler } from "./commands/evals-env"
+import { runDiffEvalHandler } from "./commands/runDiffEval"
 
 // Create the CLI program
 const program = new Command()
@@ -77,6 +78,42 @@ program
 		}
 	})
 
+// Run-diff-eval command
+program
+	.command("run-diff-eval")
+	.description("Run the diff editing evaluation suite")
+	.option("--test-path <path>", "Path to the directory containing test case JSON files")
+	.option("--output-path <path>", "Path to the directory to save the test output JSON files")
+	.option("--model-ids <model_ids>", "Comma-separated list of model IDs to test")
+	.option("--system-prompt-name <name>", "The name of the system prompt to use", "basicSystemPrompt")
+	.option("-n, --valid-attempts-per-case <number>", "Number of valid attempts per test case per model (will retry until this many valid attempts are collected)", "1")
+	.option("--max-attempts-per-case <number>", "Maximum total attempts per test case (default: 10x valid attempts)")
+	.option("--max-cases <number>", "Maximum number of test cases to run (limits total cases loaded)")
+	.option("--parsing-function <name>", "The parsing function to use", "parseAssistantMessageV2")
+	.option("--diff-edit-function <name>", "The diff editing function to use", "constructNewFileContentV2")
+	.option("--thinking-budget <tokens>", "Set the thinking tokens budget", "0")
+	.option("--parallel", "Run tests in parallel", false)
+	.option("--replay", "Run evaluation from a pre-recorded LLM output, skipping the API call", false)
+	.option("--replay-run-id <run_id>", "The ID of the run to replay from the database")
+	.option("--diff-apply-file <filename>", "The name of the diff apply file to use for the replay")
+	.option("--save-locally", "Save results to local JSON files in addition to database", false)
+	.option("-v, --verbose", "Enable verbose logging", false)
+	.action(async (options) => {
+		try {
+			const fullOptions = {
+				...options,
+				validAttemptsPerCase: parseInt(options.validAttemptsPerCase, 10),
+				maxAttemptsPerCase: options.maxAttemptsPerCase ? parseInt(options.maxAttemptsPerCase, 10) : undefined,
+				thinkingBudget: parseInt(options.thinkingBudget, 10),
+				maxCases: options.maxCases ? parseInt(options.maxCases, 10) : undefined,
+			}
+			await runDiffEvalHandler(fullOptions)
+		} catch (error) {
+			console.error(chalk.red(`Error during diff eval run: ${error instanceof Error ? error.message : String(error)}`))
+			process.exit(1)
+		}
+	})
+
 // Parse command line arguments
 program.parse(process.argv)
 

evals/diff-edits/ClineWrapper.ts

@@ -0,0 +1,343 @@
+import { OpenRouterHandler } from "../../src/api/providers/openrouter"
+import { ApiHandlerOptions } from "../../src/shared/api"
+import { Anthropic } from "@anthropic-ai/sdk"
+
+import {
+	parseAssistantMessageV1,
+	parseAssistantMessageV2,
+	parseAssistantMessageV3,
+	AssistantMessageContent,
+} from "./parsing/parse-assistant-message-06-06-25" // "../../src/core/assistant-message"
+import { constructNewFileContent as constructNewFileContent_06_06_25 } from "./diff-apply/diff-06-06-25"
+import { constructNewFileContent as constructNewFileContent_06_23_25 } from "./diff-apply/diff-06-23-25"
+import { constructNewFileContent as constructNewFileContent_06_25_25 } from "./diff-apply/diff-06-25-25"
+import { constructNewFileContent as constructNewFileContent_06_26_25 } from "./diff-apply/diff-06-26-25"
+
+type ParseAssistantMessageFn = (message: string) => AssistantMessageContent[]
+type ConstructNewFileContentFn = (diff: string, original: string, strict: boolean) => Promise<string | any>
+
+const parsingFunctions: Record<string, ParseAssistantMessageFn> = {
+	parseAssistantMessageV1: parseAssistantMessageV1,
+	parseAssistantMessageV2: parseAssistantMessageV2,
+	parseAssistantMessageV3: parseAssistantMessageV3,
+}
+
+const diffEditingFunctions: Record<string, ConstructNewFileContentFn> = {
+	"diff-06-06-25": constructNewFileContent_06_06_25,
+	"diff-06-23-25": constructNewFileContent_06_23_25,
+	"diff-06-25-25": constructNewFileContent_06_25_25,
+	"diff-06-26-25": constructNewFileContent_06_26_25,
+}
+
+import { TestInput, TestResult, ExtractedToolCall } from "./types"
+import { log } from "./helpers"
+export { TestInput, TestResult, ExtractedToolCall }
+
+interface StreamResult {
+	assistantMessage: string
+	reasoningMessage: string
+	usage: {
+		inputTokens: number
+		outputTokens: number
+		cacheWriteTokens: number
+		cacheReadTokens: number
+		totalCost: number
+	}
+	timing?: {
+		timeToFirstTokenMs: number
+		timeToFirstEditMs?: number
+		totalRoundTripMs: number
+	}
+}
+
+/**
+ * Process the stream and return full response with timing data
+ */
+async function processStream(
+	handler: OpenRouterHandler,
+	systemPrompt: string,
+	messages: Anthropic.Messages.MessageParam[],
+): Promise<StreamResult> {
+	const startTime = Date.now()
+	const stream = handler.createMessage(systemPrompt, messages)
+
+	let assistantMessage = ""
+	let reasoningMessage = ""
+	let inputTokens = 0
+	let outputTokens = 0
+	let cacheWriteTokens = 0
+	let cacheReadTokens = 0
+	let totalCost = 0
+	
+	// Timing tracking
+	let timeToFirstTokenMs: number | null = null
+	let timeToFirstEditMs: number | null = null
+
+	for await (const chunk of stream) {
+		if (!chunk) {
+			continue
+		}
+
+		// Capture time to first token (any chunk type)
+		if (timeToFirstTokenMs === null) {
+			timeToFirstTokenMs = Date.now() - startTime
+		}
+
+		switch (chunk.type) {
+			case "usage":
+				inputTokens += chunk.inputTokens
+				outputTokens += chunk.outputTokens
+				cacheWriteTokens += chunk.cacheWriteTokens ?? 0
+				cacheReadTokens += chunk.cacheReadTokens ?? 0
+				if (chunk.totalCost) {
+					totalCost = chunk.totalCost
+				}
+				break
+			case "reasoning":
+				reasoningMessage += chunk.reasoning
+				break
+			case "text":
+				assistantMessage += chunk.text
+				
+				// Try to detect first tool call by parsing accumulated message
+				if (timeToFirstEditMs === null) {
+					try {
+						const parsed = parseAssistantMessageV2(assistantMessage)
+						const hasToolCall = parsed.some(block => block.type === "tool_use")
+						if (hasToolCall) {
+							timeToFirstEditMs = Date.now() - startTime
+						}
+					} catch {
+						// Parsing failed, continue accumulating
+					}
+				}
+				break
+		}
+	}
+
+	const totalRoundTripMs = Date.now() - startTime
+
+	return {
+		assistantMessage,
+		reasoningMessage,
+		usage: {
+			inputTokens,
+			outputTokens,
+			cacheWriteTokens,
+			cacheReadTokens,
+			totalCost,
+		},
+		timing: {
+			timeToFirstTokenMs: timeToFirstTokenMs || 0,
+			timeToFirstEditMs: timeToFirstEditMs || undefined,
+			totalRoundTripMs,
+		},
+	}
+}
+
+/**
+ * Main evaluation function:
+ * 1. create and process stream
+ * 2. extract any tool calls from the stream
+ * 3. if no diff edit, considered a failure (or rerun) - otherwise attempt to apply the diff edit
+ */
+export async function runSingleEvaluation(input: TestInput): Promise<TestResult> {
+	try {
+		// Extract parameters
+		const {
+			apiKey,
+			systemPrompt,
+			messages,
+			modelId,
+			originalFile,
+			originalFilePath,
+			parsingFunction,
+			diffEditFunction,
+			thinkingBudgetTokens,
+			originalDiffEditToolCallMessage,
+			diffApplyFile,
+		} = input
+
+		const requiredParams = {
+			systemPrompt,
+			messages,
+			modelId,
+			originalFile,
+			originalFilePath,
+			parsingFunction,
+			diffEditFunction,
+		}
+
+		const missingParams = Object.entries(requiredParams)
+			.filter(([, value]) => !value)
+			.map(([key]) => key)
+
+		if (missingParams.length > 0) {
+			return {
+				success: false,
+				error: "missing_required_parameters",
+				errorString: `Missing required parameters: ${missingParams.join(", ")}`,
+			}
+		}
+
+		const parseAssistantMessage = parsingFunctions[parsingFunction]
+		const constructNewFileContent = diffEditingFunctions[diffApplyFile || diffEditFunction]
+
+		if (!parseAssistantMessage || !constructNewFileContent) {
+			return {
+				success: false,
+				error: "invalid_functions",
+			}
+		}
+
+		const options: ApiHandlerOptions = {
+			openRouterApiKey: apiKey,
+			openRouterModelId: modelId,
+			thinkingBudgetTokens: thinkingBudgetTokens,
+			openRouterModelInfo: {
+				maxTokens: 10_000,
+				contextWindow: 1_000_000,
+				supportsImages: true,
+				supportsPromptCache: true, // may need to turn this on
+				inputPrice: 0,
+				outputPrice: 0,
+			},
+		}
+
+		// Get the output of streaming output of this llm call
+		let streamResult: StreamResult
+		if (originalDiffEditToolCallMessage !== undefined) {
+			// Replay mode: mock the stream result
+			streamResult = {
+				assistantMessage: originalDiffEditToolCallMessage,
+				reasoningMessage: "",
+				usage: { inputTokens: 0, outputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0, totalCost: 0 },
+			}
+		} else {
+			// Live mode: existing API call logic
+			try {
+				const openRouterHandler = new OpenRouterHandler(options)
+				streamResult = await processStream(openRouterHandler, systemPrompt, messages)
+			} catch (error: any) {
+				return {
+					success: false,
+					error: "llm_stream_error",
+					errorString: error.message || error.toString(),
+				}
+			}
+		}
+
+		// process the assistant message into its constituent tool calls & text blocks
+		const assistantContentBlocks: AssistantMessageContent[] = parseAssistantMessage(streamResult.assistantMessage)
+
+		const detectedToolCalls: ExtractedToolCall[] = []
+
+		for (const block of assistantContentBlocks) {
+			if (block.type === "tool_use") {
+				detectedToolCalls.push({
+					name: block.name,
+					input: block.params,
+				})
+			}
+		}
+
+		// check if there are any tool calls, if there are none then its a clear error
+		if (detectedToolCalls.length === 0) {
+			return {
+				success: false,
+				streamResult: streamResult,
+				toolCalls: detectedToolCalls,
+				error: "no_tool_calls",
+			}
+		}
+
+		// check that there is exactly one tool call, otherwise an error
+		if (detectedToolCalls.length > 1) {
+			return {
+				success: false,
+				streamResult: streamResult,
+				toolCalls: detectedToolCalls,
+				error: "multi_tool_calls",
+			}
+		}
+
+		// check that the tool call is diff edit tool call
+		if (detectedToolCalls[0].name !== "replace_in_file") {
+			return {
+				success: false,
+				streamResult: streamResult,
+				toolCalls: detectedToolCalls,
+				error: "wrong_tool_call",
+			}
+		}
+
+		const toolCall = detectedToolCalls[0]
+		const diffToolPath = toolCall.input.path
+		const diffToolContent = toolCall.input.diff
+
+		if (!diffToolPath || !diffToolContent) {
+			return {
+				success: false,
+				streamResult: streamResult,
+				toolCalls: detectedToolCalls,
+				error: "tool_call_params_undefined",
+			}
+		}
+
+		// check that we are editing the correct file path
+		log(input.isVerbose, `Expected file path: "${originalFilePath}"`)
+		log(input.isVerbose, `Actual file path used: "${diffToolPath}"`)
+		if (diffToolPath !== originalFilePath) {
+			log(input.isVerbose, `❌ File path mismatch detected!`)
+			// Enhanced logging:
+			if (streamResult?.assistantMessage) {
+				log(input.isVerbose, `   Full model output (assistantMessage):`)
+				log(input.isVerbose, `   -----------------------------------------`)
+				log(input.isVerbose, `   ${streamResult.assistantMessage}`)
+				log(input.isVerbose, `   -----------------------------------------`)
+			}
+			if (toolCall) {
+				log(input.isVerbose, `   Parsed tool call that caused mismatch:`)
+				log(input.isVerbose, `   ${JSON.stringify(toolCall, null, 2)}`)
+				log(input.isVerbose, `   -----------------------------------------`)
+			}
+			return {
+				success: false,
+				streamResult: streamResult,
+				toolCalls: detectedToolCalls,
+				error: "wrong_file_edited",
+			}
+		}
+
+		// checking if the diff edit succeeds, if it failed it will throw an error
+		let diffSuccess = true
+		let replacementData: any = undefined
+		try {
+			const result = await constructNewFileContent(diffToolContent, originalFile, true)
+			
+			// Check if result is an object with replacements (new format)
+			if (typeof result === 'object' && result !== null && 'replacements' in result) {
+				replacementData = result.replacements
+			}
+			// If it's just a string, diffSuccess stays true and replacementData stays undefined
+		} catch (error: any) {
+			diffSuccess = false
+			log(input.isVerbose, `ERROR: ${error}`)
+		}
+
+		return {
+			success: true,
+			streamResult: streamResult,
+			toolCalls: detectedToolCalls,
+			diffEdit: diffToolContent,
+			diffEditSuccess: diffSuccess,
+			replacementData: replacementData,
+		}
+	} catch (error: any) {
+		return {
+			success: false,
+			error: "other_error",
+			errorString: error.message || error.toString(),
+		}
+	}
+}

evals/diff-edits/README.md

@@ -0,0 +1,84 @@
+# A Note on Cline's Diff Evaluation Setup
+
+Hey there, this note explains what we're doing with Cline's diff evaluation (evals) system. It's all about checking how well various AI models (which users connect to Cline via their own API keys), prompts, and diffing tools can handle file changes.
+
+## What We're Trying to Figure Out
+
+The main idea here is to figure out which AI models (configured by users) are best at making `replace_in_file` tool calls that work correctly. This helps us understand model capabilities and also speeds up our own experiments with prompts and diffing algorithms to make Cline better over time. We want to know a few key things.
+
+First, can the model create diffs, which are just sets of SEARCH and REPLACE blocks, that apply cleanly to a file? This is what we call `diffEditSuccess`.
+
+Second, how do different LLMs, like Claude or Grok, stack up against each other when they try to make these diff edits? We use a standard set of real-world test cases for this.
+
+Third, do different system prompts, say our `basicSystemPrompt` versus the `claude4SystemPrompt`, change how well a model does at diff editing?
+
+Fourth, we're also looking at different ways to apply the diffs themselves. We have a few algorithms like `constructNewFileContentV1`, `V2`, and `V3`, and we want to see which ones are more robust when fed model-generated diffs.
+
+Fifth, we track how fast the model starts making an edit. The `timeToFirstEditMs` metric gives us a hint about how quickly a user would see changes happening in their editor.
+
+And finally, we keep an eye on how many tokens are used and what it costs for each model and each try. This helps us compare how efficient they are.
+
+Right now, these evals are mostly about whether the diff *applies* correctly. That means, do the SEARCH blocks find a match, and can the REPLACE blocks be put in without an error? We're not yet deeply analyzing if the change is valid code or matches what the user *wanted* semantically. That's a problem for another day, and will require a lot more scaffolding.
+
+## How We Run These Tests
+
+Two prerequisites:
+
+1. Make sure you have an `evals/.env` file with `OPENROUTER_API_KEY=<your-openrouter-key>` 
+
+2. Make sure you add a `evals/diff-edits/cases` folder with all the conversation jsons prior to running this. 
+
+
+Our testing strategy is based on replaying situations from actual user sessions where diff edits were tried.
+
+It starts with our test cases. Each one is a JSON file in `./cases` that has the conversation history that led to a diff edit, the original file content and its path, and the info needed to rebuild the system prompt from that original session.
+
+Then, for every test run, we set up a specific configuration. This includes which LLM we're testing, which system prompt it gets, which function we use to parse the model's raw output, and which function we use to actually apply the diff. Here's the command I've been using:
+
+```bash
+npm run diff-eval -- --model-ids "anthropic/claude-3-5-sonnet,x-ai/grok-3-beta,anthropic/claude-3.7-sonnet,anthropic/claude-sonnet-4,google/gemini-2.5-pro-preview,google/gemini-2.5-flash" --max-cases 5 --valid-attempts-per-case 5 --parallel --diff-edit-function diff-06-26-25 --verbose 
+```
+
+This will build the eval script, run it, and then open the streamlit dashboard to show the results.
+
+The `TestRunner.ts` script is the main coordinator. For each test case and setup, `ClineWrapper.ts` takes over and sends the conversation and system prompt to the LLM. We then watch the model's response as it streams in and parse it to find any tool calls.
+
+We're specifically looking for the model to make a single `replace_in_file` tool call. Multiple edits in one tool call are allowed, and recorded (in case you want to filter results by number of edits in a single tool call and compare success rate for that slice across different models/system prompts/etc). If it does, and it's for the correct file, we grab the diff content it produced. Then, the chosen diff application algorithm tries to apply that diff to the original file. We record whether this worked or not as `diffEditSuccess`.
+
+We record a bunch of data for every attempt into a database. This includes details about the model and prompt, token counts, costs, the raw output from the model, the parsed tool calls, whether it succeeded or failed, any error messages, and timing info. For a detailed explanation of the database schema, see [database.md](./database.md).
+
+A big part of this is how we handle "valid attempts," which I'll explain next.
+
+## Keeping it Fair with "Valid Attempts"
+
+LLMs can be unpredictable. If we replay an old scenario, a new model, or even the same model later, might do something completely different than what happened originally. It might call another tool or ask a question instead of trying a diff edit.
+
+Since we really want to test the *diff editing* part, we need a way to make sure we're comparing fairly. That's why we have this idea of "valid attempts."
+
+An attempt is "valid" for this benchmark if the model actually tries to do what we're interested in. This means two things. One, it must call the `replace_in_file` tool. Two, it must target the *same file path* that was targeted in the original recorded conversation for that test case.
+
+If the model does something else, like calling a different tool or picking the wrong file, we don't count that attempt against its diff editing score. Instead, we consider it an "invalid attempt" for *this specific benchmark* and simply re-run that test case with that model. We keep doing this until we've collected a set number of these "valid attempts."
+
+For example, if we ask for 5 valid attempts per test case, the system will keep re-rolling for that case until the model has tried to edit the correct file using the `replace_in_file` tool 5 times. Only then do we look at how many of those 5 valid attempts actually resulted in a successful diff application (`diffEditSuccess`).
+
+This way, if we're comparing two models and one gets a 10% success rate on its valid diff edit attempts, and another gets 90%, we have a much clearer picture of their actual diff-generating capabilities. It avoids muddying the waters with attempts where the model didn't even try to perform the specific action we're evaluating. This approach helps us isolate and measure the diff-editing skill more directly, despite the non-deterministic nature of these models.
+
+## Replays
+
+You can also use the replay argument to replay a previous benchmark run. This is super useful for iterating on our diffing algorithms without having to re-run expensive and time-consuming LLM calls.
+
+When you run an evaluation, every detail is stored in the database—including the raw, unmodified output from the model. The replay feature takes advantage of this by pulling that raw output and feeding it into a *different* diffing algorithm. This lets you isolate the performance of the diffing logic itself. We can see if a new algorithm is better at applying the exact same set of diffs that a model generated in a previous run.
+
+This process is blazingly fast and free, as it completely bypasses the need to make new API calls. It ensures a true apples-to-apples comparison between diffing strategies, since the model's output—the "ground truth" for the evaluation—remains identical.
+
+Here’s an example of how you would replay a previous run with a new diffing algorithm:
+
+```shell
+cd evals && npm run diff-eval -- --replay-run-id 9902189e-63a8-4210-a4fc-fe59e2eaf2c2 --diff-apply-file diff-06-23-25 --verbose
+```
+
+In this command:
+-   `--replay-run-id` specifies the original run we want to use as our ground truth.
+-   `--diff-apply-file` tells the script to use the new diffing logic from the `diff-06-23-25.ts` file.
+
+The script will then create a new run in the database that mirrors the original, but with the results of applying the new diffing algorithm. This allows for a direct comparison in the dashboard, helping us quickly see which of our diffing strategies is the most robust.

evals/diff-edits/dashboard/.streamlit/config.toml

@@ -0,0 +1,8 @@
+[theme]
+base="dark"
+
+[browser]
+gatherUsageStats = false
+
+[server]
+headless = true

evals/diff-edits/dashboard/README.md

@@ -0,0 +1,159 @@
+# 🚀 The Sickest Diff Edits Evaluation Dashboard Ever!
+
+A beautiful, modern Streamlit dashboard for visualizing and analyzing diff editing evaluation results with deep drill-down capabilities.
+
+## ✨ Features
+
+### 🎯 **Smart Model Comparison**
+- **Latest Run Focus**: Automatically loads and displays your most recent evaluation run
+- **Beautiful Performance Cards**: Each model gets a stunning card with performance grades (A+ to C)
+- **Best Performer Highlighting**: The top model gets special styling and a trophy 🏆
+- **Interactive Charts**: Success rate comparisons and latency vs cost analysis
+
+### 🔍 **Deep Drill-Down Analysis**
+- **Individual Result Inspection**: Click any model to see detailed results
+- **Side-by-Side File Views**: See original file content with line numbers
+- **Parsed Tool Call Analysis**: View exactly what the model tried to do
+- **Error Analysis**: Detailed error information for failed attempts
+- **Success Metrics**: Line changes, edit counts, and timing breakdowns
+
+### 🎨 **Aesthetic Design**
+- **Modern UI**: Custom CSS with Inter font, gradients, and shadows
+- **Responsive Layout**: Looks great on any screen size
+- **Color-Coded Performance**: Green for excellent, yellow for good, red for poor
+- **Smooth Animations**: Hover effects and transitions
+- **Professional Styling**: Clean, modern design that looks amazing
+
+### 📊 **Comprehensive Metrics**
+- **Success Rates**: Color-coded percentages with performance grades
+- **Timing Analysis**: First token, first edit, and round trip times
+- **Cost Tracking**: Per-result and total cost analysis
+- **Token Metrics**: Context tokens and completion tokens
+- **Edit Statistics**: Number of edits, lines added/deleted
+
+## 🚀 Quick Start
+
+1. **Install dependencies**:
+   ```bash
+   cd diff-edits/dashboard
+   pip install -r requirements.txt
+   ```
+
+2. **Launch the dashboard**:
+   ```bash
+   streamlit run app.py
+   ```
+   
+   Or use the convenient launch script:
+   ```bash
+   ./launch.sh
+   ```
+
+3. **Open your browser** to http://localhost:8501
+
+## 🎯 Dashboard Sections
+
+### **Hero Section**
+- Beautiful gradient header with run information
+- Key metrics overview (models tested, total results, success rate, cost)
+
+### **Model Performance Cards**
+- Each model displayed as a beautiful card
+- Large success rate display with color coding
+- Performance grade badges (A+, A, B+, B, C+, C)
+- Key metrics: latency, cost, results count, first token time
+- "Drill Down" button for detailed analysis
+
+### **Performance Analytics**
+- Interactive bar chart showing success rates
+- Scatter plot of latency vs cost with bubble sizes
+- Hover details and zoom capabilities
+
+### **Detailed Analysis (Drill-Down)**
+- Model-specific success rate, latency, and cost metrics
+- Individual result selector with status icons
+- Tabbed interface for different views:
+
+#### 📄 **File & Edits Tab**
+- **Side-by-side view**: Original file content with line numbers
+- **Edit analysis**: Success/failure status with detailed metrics
+- **Error display**: Clear error information for failed attempts
+- **Success metrics**: Lines added/deleted, number of edits
+- **Parsed tool calls**: JSON view of what the model attempted
+
+#### 🤖 **Raw Output Tab**
+- Complete raw model output in a code viewer
+- Monospace font for easy reading
+
+#### 🔧 **Parsed Tool Call Tab**
+- Pretty-printed JSON of parsed tool calls
+- Diff block visualization for replace_in_file calls
+- Error handling for malformed JSON
+
+#### 📊 **Metrics Tab**
+- Detailed timing metrics (first token, first edit, round trip)
+- Token and cost information
+- Context size and completion tokens
+
+## 🛠 **Technical Features**
+
+### **Smart Data Loading**
+- Automatic latest run detection
+- Efficient SQL queries with proper JOINs
+- Streamlit caching for performance
+- Error handling for missing data
+
+### **Interactive Navigation**
+- Session state management for drill-down views
+- Back button to return to overview
+- Smooth transitions between views
+
+### **Beautiful Styling**
+- Custom CSS with Google Fonts (Inter)
+- Gradient backgrounds and shadows
+- Hover effects and animations
+- Color-coded performance indicators
+- Professional card-based layout
+
+### **Responsive Design**
+- Works on desktop, tablet, and mobile
+- Flexible column layouts
+- Scalable text and metrics
+
+## 🎨 **Design Philosophy**
+
+This dashboard follows modern design principles:
+- **Clarity**: Information is easy to find and understand
+- **Beauty**: Visually appealing with professional styling
+- **Functionality**: Deep drill-down capabilities for detailed analysis
+- **Performance**: Fast loading with efficient data queries
+- **Usability**: Intuitive navigation and clear visual hierarchy
+
+## 📊 **Data Visualization**
+
+- **Plotly Charts**: Interactive, professional-looking visualizations
+- **Color Coding**: Consistent color scheme for performance levels
+- **Performance Badges**: A+ to C grading system
+- **Status Icons**: ✅ for success, ❌ for failure
+- **Metric Cards**: Clean, card-based metric display
+
+## 🔧 **Customization**
+
+The dashboard is highly customizable:
+- **CSS Styling**: Easy to modify colors, fonts, and layouts
+- **Performance Grades**: Adjustable thresholds for A/B/C grades
+- **Metrics Display**: Add or remove metrics as needed
+- **Chart Types**: Easily swap chart types or add new visualizations
+
+## 🚀 **Future Enhancements**
+
+Potential additions:
+- **Historical Trends**: Compare performance across multiple runs
+- **Export Functionality**: Download results as CSV/PDF
+- **Real-time Updates**: Auto-refresh for ongoing evaluations
+- **Custom Filters**: Filter by date range, model type, etc.
+- **Comparison Mode**: Side-by-side model comparisons
+
+---
+
+**This is the sickest eval dashboard ever!** 🔥 It combines beautiful design with powerful analysis capabilities, making it easy to understand model performance at a glance while providing deep drill-down capabilities for detailed investigation.

evals/diff-edits/dashboard/launch.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+
+# Diff Edits Evaluation Dashboard Launcher
+echo "🚀 Starting Diff Edits Evaluation Dashboard..."
+
+# Check if we're in the right directory
+if [ ! -f "app.py" ]; then
+    echo "❌ Error: app.py not found. Please run this script from the dashboard directory."
+    exit 1
+fi
+
+# Check if database exists
+if [ ! -f "../evals.db" ]; then
+    echo "⚠️  Warning: Database file ../evals.db not found."
+    echo "   Make sure you've run some evaluations first to populate the database."
+    echo "   You can run: node ../cli/dist/index.js run-diff-eval --model-id anthropic/claude-sonnet-4 --max-cases 1"
+    echo ""
+fi
+
+# Check if requirements are installed
+echo "📦 Checking Python dependencies..."
+if ! python -c "import streamlit, plotly, pandas" 2>/dev/null; then
+    echo "📥 Installing required packages..."
+    pip install -r requirements.txt
+fi
+
+echo "🌐 Launching Streamlit dashboard..."
+echo "   Dashboard will open in your browser at http://localhost:8501"
+echo "   Press Ctrl+C to stop the dashboard"
+echo ""
+
+# Launch Streamlit
+streamlit run app.py

evals/diff-edits/dashboard/pages/02_Bad_Cases.py

@@ -0,0 +1,183 @@
+import streamlit as st
+import pandas as pd
+import json
+import os # Need to import os for load_case_raw_data
+from utils import get_database_connection, guess_language_from_filepath # Absolute import
+
+st.set_page_config(
+    page_title="Case Health Inspector",
+    page_icon="🧑‍⚕️",
+    layout="wide"
+)
+
+st.title("Case Health Inspector")
+st.markdown("Identify test cases that are frequently problematic across different models and runs.")
+
+@st.cache_data
+def load_problematic_cases_summary():
+    conn = get_database_connection()
+    query = """
+    WITH case_attempts AS (
+        SELECT
+            c.task_id,
+            c.description AS case_description,
+            f_orig.filepath AS original_filepath, -- Get from files table
+            r.run_id,
+            r.model_id,
+            r.result_id,
+            (CASE WHEN (r.error_enum NOT IN (1, 6, 7) OR r.error_enum IS NULL) THEN 1 ELSE 0 END) AS is_valid_attempt,
+            (CASE WHEN (r.error_enum NOT IN (1, 6, 7) OR r.error_enum IS NULL) THEN r.succeeded ELSE NULL END) AS succeeded_on_valid
+        FROM cases c
+        JOIN results r ON c.case_id = r.case_id
+        LEFT JOIN files f_orig ON c.file_hash = f_orig.hash -- Join to get original filepath
+    ),
+    case_summary AS (
+        SELECT
+            task_id,
+            case_description,
+            original_filepath, -- This is now f_orig.filepath
+            COUNT(DISTINCT run_id) AS num_benchmark_runs,
+            COUNT(result_id) AS total_attempts,
+            SUM(is_valid_attempt) AS total_valid_attempts,
+            SUM(succeeded_on_valid) AS total_successful_valid_attempts
+        FROM case_attempts
+        GROUP BY task_id, case_description, original_filepath -- original_filepath is f_orig.filepath
+    )
+    SELECT
+        task_id,
+        case_description,
+        original_filepath, -- This is f_orig.filepath from case_summary
+        num_benchmark_runs,
+        total_attempts,
+        total_valid_attempts,
+        CAST(total_valid_attempts AS REAL) * 100.0 / total_attempts AS percent_valid_attempts,
+        CASE 
+            WHEN total_valid_attempts > 0 THEN CAST(total_successful_valid_attempts AS REAL) * 100.0 / total_valid_attempts
+            ELSE 0 
+        END AS success_rate_on_valid
+    FROM case_summary
+    ORDER BY percent_valid_attempts ASC, success_rate_on_valid ASC;
+    """
+    df = pd.read_sql_query(query, conn)
+    return df
+
+@st.cache_data
+def load_case_raw_data(task_id):
+    """Loads the original JSON data for a given task_id."""
+    # This assumes test cases are stored in ../cases relative to this script's parent (dashboard)
+    # So, ../../cases from this script's location (pages/02_Bad_Cases.py)
+    # Correct path from this script (pages/02_Bad_Cases.py) to cases/
+    # os.path.dirname(__file__) -> pages
+    # os.path.join(..., '..') -> dashboard
+    # os.path.join(..., '..', '..') -> diff-edits
+    # os.path.join(..., '..', '..', 'cases') -> diff-edits/cases
+    cases_dir = os.path.join(os.path.dirname(__file__), '..', '..', 'cases')
+    
+    # The task_id is usually the filename without .json
+    # However, some task_ids might have suffixes or be different.
+    # We need a robust way to find the file. For now, assume task_id is filename base.
+    # This might need adjustment if task_id format varies significantly from filename.
+    
+    # Try direct match first
+    potential_filename = f"{task_id}.json"
+    filepath = os.path.join(cases_dir, potential_filename)
+
+    if not os.path.exists(filepath):
+        # If direct match fails, list files and try to find one that starts with task_id
+        # This is a simple fallback, might need more robust matching if task_ids are complex
+        try:
+            for f_name in os.listdir(cases_dir):
+                if f_name.startswith(task_id) and f_name.endswith(".json"):
+                    filepath = os.path.join(cases_dir, f_name)
+                    break
+            else: # No break means no file found
+                 return None # File not found
+        except FileNotFoundError:
+            return None # Cases directory itself not found
+
+    if not os.path.exists(filepath): # Check again after potential find
+        return None
+
+    try:
+        with open(filepath, 'r') as f:
+            return json.load(f)
+    except Exception as e:
+        st.error(f"Error loading case file {filepath}: {e}")
+        return None
+
+def render_problematic_cases_page():
+    summary_df = load_problematic_cases_summary()
+
+    if summary_df.empty:
+        st.warning("No case summary data found. Run some evaluations first.")
+        return
+
+    st.markdown("### Cases Overview")
+    st.dataframe(summary_df.style.format({
+        "percent_valid_attempts": "{:.1f}%",
+        "success_rate_on_valid": "{:.1f}%"
+    }), use_container_width=True)
+
+    st.markdown("---")
+    st.markdown("### Case Drill Down")
+    
+    selected_task_id = st.selectbox(
+        "Select a Case ID (task_id) to inspect:",
+        options=[""] + summary_df['task_id'].tolist() # Add a blank option
+    )
+
+    if selected_task_id:
+        case_data = summary_df[summary_df['task_id'] == selected_task_id].iloc[0]
+        st.subheader(f"Details for Case: {case_data['task_id']}")
+        st.markdown(f"**Description:** {case_data['case_description']}")
+        st.markdown(f"**Original Filepath:** `{case_data['original_filepath']}`")
+        
+        raw_json_data = load_case_raw_data(selected_task_id)
+        if raw_json_data:
+            with st.expander("View Raw Case JSON Data", expanded=False):
+                st.json(raw_json_data)
+            
+            if 'file_contents' in raw_json_data and raw_json_data['file_contents']:
+                with st.expander("View Original File Content (from Case JSON)", expanded=True):
+                    # Prepare content for the copy button
+                    raw_content_for_copy = raw_json_data['file_contents']
+                    js_escaped_content = raw_content_for_copy.replace('\\', '\\\\') \
+                                                           .replace('`', '\\`') \
+                                                           .replace('\r\n', '\\n') \
+                                                           .replace('\n', '\\n') \
+                                                           .replace('\r', '\\n')
+                    button_id = f"copyBtnCase_{selected_task_id.replace('-', '_').replace('.', '_')}"
+                    copy_button_html = f"""
+                        <button id="{button_id}" onclick="copyCaseContentToClipboard(`{js_escaped_content}`, '{button_id}')" style="margin-bottom: 10px; padding: 5px 10px; border-radius: 5px; border: 1px solid #ccc; cursor: pointer;">Copy File Content</button>
+                        <script>
+                            if (!window.copyCaseContentToClipboard) {{
+                                window.copyCaseContentToClipboard = async function(text, buttonId) {{
+                                    try {{
+                                        await navigator.clipboard.writeText(text);
+                                        const button = document.getElementById(buttonId);
+                                        button.innerText = 'Copied!';
+                                        setTimeout(() => {{ button.innerText = 'Copy File Content'; }}, 2000);
+                                    }} catch (err) {{ console.error('Failed to copy: ', err); const button = document.getElementById(buttonId); button.innerText = 'Copy Failed!'; setTimeout(() => {{ button.innerText = 'Copy File Content'; }}, 2000); }}
+                                }}
+                            }}
+                        </script>
+                        """
+                    st.components.v1.html(copy_button_html, height=50)
+
+                    # Prepare content for st.code
+                    content_for_display = raw_json_data['file_contents']
+                    content_for_display = content_for_display.replace('\\\\r\\\\n', '\r\n').replace('\\\\n', '\n')
+                    content_for_display = content_for_display.replace('\\r\\n', '\r\n').replace('\\n', '\n')
+                    
+                    language = guess_language_from_filepath(case_data['original_filepath'])
+                    st.code(content_for_display, language=language, line_numbers=False)
+            else:
+                st.warning("Original file content not found in case JSON.")
+        else:
+            st.error(f"Could not load raw JSON data for case: {selected_task_id}")
+        
+        # Placeholder for more detailed stats (per-model performance on this case, error breakdown)
+        st.markdown("*(Further per-model statistics and error breakdowns for this case can be added here.)*")
+
+if __name__ == "__main__":
+    render_problematic_cases_page()

evals/diff-edits/dashboard/requirements.txt

@@ -0,0 +1,4 @@
+streamlit>=1.28.0
+plotly>=5.17.0
+pandas>=2.0.0
+numpy>=1.24.0

evals/diff-edits/dashboard/utils.py

@@ -0,0 +1,51 @@
+import streamlit as st
+import sqlite3
+import pandas as pd
+import os
+
+@st.cache_resource
+def get_database_connection():
+    # Assuming the script is run from the dashboard directory,
+    # evals.db is two levels up from there.
+    # __file__ is utils.py, its dirname is dashboard.
+    # os.path.dirname(__file__) -> dashboard/
+    # os.path.join(..., '..') -> diff-edits/
+    # os.path.join(..., '..', 'evals.db') -> diff-edits/evals.db
+    db_path = os.path.join(os.path.dirname(__file__), '..', 'evals.db')
+    if not os.path.exists(db_path):
+        st.error(f"Database not found. Expected at: {os.path.abspath(db_path)}")
+        st.stop()
+    return sqlite3.connect(db_path, check_same_thread=False)
+
+def guess_language_from_filepath(filepath):
+    """Guess the language for syntax highlighting from filepath."""
+    if not filepath or pd.isna(filepath):
+        return None
+    
+    extension_map = {
+        '.py': 'python',
+        '.js': 'javascript',
+        '.ts': 'typescript',
+        '.java': 'java',
+        '.cs': 'csharp',
+        '.cpp': 'cpp',
+        '.c': 'c',
+        '.html': 'html',
+        '.css': 'css',
+        '.json': 'json',
+        '.sql': 'sql',
+        '.md': 'markdown',
+        '.rb': 'ruby',
+        '.php': 'php',
+        '.go': 'go',
+        '.rs': 'rust',
+        '.swift': 'swift',
+        '.kt': 'kotlin',
+        '.sh': 'bash',
+        '.yaml': 'yaml',
+        '.yml': 'yaml',
+        '.xml': 'xml',
+    }
+    
+    _, ext = os.path.splitext(str(filepath)) # Ensure filepath is string
+    return extension_map.get(ext.lower(), None)

evals/diff-edits/database.md

@@ -0,0 +1,96 @@
+# Diff Edit Evaluation Database Schema
+
+This document provides an overview of the SQLite database schema used for the diff edit evaluation suite. The database is designed to capture every aspect of the evaluation runs in a structured way, allowing for detailed, multi-dimensional analysis and ensuring full reproducibility of our findings.
+
+## Data Model Overview
+
+The database is composed of several interconnected tables that work together to provide a comprehensive picture of each evaluation. The core of the model revolves around `runs`, `cases`, and `results`.
+
+### `runs`
+
+A `run` represents a single, top-level execution of the evaluation script (e.g., one invocation of `npm run diff-eval`). It serves as the main container for a complete benchmark session.
+
+-   **Purpose**: To group all the results from a single benchmark execution, allowing for high-level comparison between different runs over time.
+-   **Key Columns**:
+    -   `run_id`: A unique identifier for the entire run.
+    -   `description`: A human-readable summary of the run's configuration (e.g., which models were tested, how many cases, etc.).
+    -   `system_prompt_hash`: A foreign key that links this run to the specific system prompt that was used, ensuring we can track performance changes based on prompt modifications.
+
+### `cases`
+
+A `case` represents a single test scenario that is presented to a model. It corresponds to one of the JSON files in the `cases/` directory and links that static definition to a specific benchmark `run`.
+
+-   **Purpose**: To track the individual test scenarios within a given run.
+-   **Key Columns**:
+    -   `case_id`: A unique identifier for the case *within* a specific run.
+    -   `run_id`: A foreign key linking back to the parent `run`.
+    -   `task_id`: The original, persistent identifier for the test case (typically from the JSON filename).
+    -   `file_hash`: A foreign key linking to the original, un-edited file content for this case.
+
+### `results`
+
+This is the most granular and important table in the database. A `result` represents the outcome of a single attempt by a specific model on a specific case.
+
+-   **Purpose**: To store the detailed outcome of every single model attempt, providing the raw data for all quantitative and qualitative analysis.
+-   **Key Columns**:
+    -   `result_id`: The primary key for the result.
+    -   `run_id`, `case_id`, `model_id`, `processing_functions_hash`: A set of foreign keys that precisely situate this result within the context of a specific run, case, model, and set of helper functions.
+    -   `succeeded`: A boolean indicating if the generated diff was applied successfully.
+    -   `error_enum`: A numeric code representing the specific type of error if the attempt failed (e.g., `1` for `no_tool_calls`, `7` for `wrong_file_edited`).
+    -   `num_edits`, `num_lines_deleted`, `num_lines_added`: Quantitative metrics about the structure of the generated diff.
+    -   `time_to_first_token_ms`, `time_to_first_edit_ms`, `time_round_trip_ms`: High-precision timing data to measure model latency.
+    -   `cost_usd`, `completion_tokens`: Cost and token usage metrics for efficiency analysis.
+    -   `raw_model_output`, `file_edited_hash`, `parsed_tool_call_json`: The rich, qualitative data. This includes the model's full, raw response and the parsed tool calls, which are invaluable for debugging and understanding the model's reasoning.
+
+---
+
+## Supporting Tables
+
+The following tables store versioned, deduplicated content to ensure data integrity and efficiency.
+
+### `system_prompts`
+
+-   **Purpose**: Stores the versioned content of the system prompts used in evaluations.
+-   **Key Columns**:
+    -   `hash`: A unique hash of the prompt's content, which acts as the primary key. This prevents duplicate storage of the same prompt.
+    -   `name`: A human-readable name for the prompt (e.g., `basicSystemPrompt`, `claude4SystemPrompt`).
+    -   `content`: The full text of the system prompt.
+
+### `processing_functions`
+
+-   **Purpose**: Stores the versioned combinations of parsing and diff-editing functions.
+-   **Key Columns**:
+    -   `hash`: A unique hash of the function combination name.
+    -   `name`: A human-readable name (e.g., `parseV2-diffV2`).
+    -   `parsing_function`: The name of the function used to parse the model's output.
+    -   `diff_edit_function`: The name of the function used to apply the diff.
+
+### `files`
+
+-   **Purpose**: Stores the content of all files involved in the tests, including the original source files and the diffs generated by the models.
+-   **Key Columns**:
+    -   `hash`: A content-based hash of the file, ensuring that identical files are only stored once.
+    -   `filepath`: The original path of the file.
+    -   `content`: The full content of the file.
+
+## The Bigger Picture
+
+This relational schema provides a powerful foundation for sophisticated analysis. It moves beyond simple pass/fail metrics and allows us to explore the nuanced interactions between models, prompts, and the code they operate on. With this database, we can answer critical questions like:
+
+-   "How does prompt engineering affect not just success rate, but also latency and cost?"
+-   "Are certain models more prone to specific types of errors (e.g., hallucinating file paths vs. failing to call a tool)?"
+-   "Which of our internal diffing algorithms is the most robust against a wide range of model-generated edits?"
+
+Ultimately, this data model enables us to move from simply *measuring* performance to truly *understanding* it, providing the insights needed to build more capable and reliable AI engineering systems.
+
+---
+
+## Viewing the Full Schema
+
+To see the most up-to-date and detailed schema for the database, you can use the `sqlite3` command-line tool. From the `evals/diff-edits` directory, run the following command:
+
+```bash
+sqlite3 evals.db .schema
+```
+
+This will print the complete `CREATE TABLE` statements for all tables in the database, providing a definitive reference for the database structure.

evals/diff-edits/database/client.ts

@@ -0,0 +1,135 @@
+import Database from 'better-sqlite3';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+
+export class DatabaseClient {
+  private static instance: DatabaseClient;
+  private db: Database.Database;
+  private dbPath: string;
+
+  private constructor() {
+    // Get database path from environment or use default
+    this.dbPath = process.env.DIFF_EVALS_DB_PATH || path.join(__dirname, '../evals.db');
+    
+    // Ensure directory exists
+    const dbDir = path.dirname(this.dbPath);
+    if (!fs.existsSync(dbDir)) {
+      fs.mkdirSync(dbDir, { recursive: true });
+    }
+
+    // Initialize database connection
+    this.db = new Database(this.dbPath);
+    
+    // Enable WAL mode for concurrent access
+    this.db.pragma('journal_mode = WAL');
+    
+    // Enable foreign key constraints
+    this.db.pragma('foreign_keys = ON');
+    
+    // Initialize schema if needed
+    this.initializeSchema();
+  }
+
+  static getInstance(): DatabaseClient {
+    if (!DatabaseClient.instance) {
+      DatabaseClient.instance = new DatabaseClient();
+    }
+    return DatabaseClient.instance;
+  }
+
+  private initializeSchema(): void {
+    // Check if tables exist by trying to query one of them
+    try {
+      this.db.prepare('SELECT COUNT(*) FROM system_prompts LIMIT 1').get();
+      // If we get here, tables exist
+      return;
+    } catch (error) {
+      // Tables don't exist, create them
+      console.log('Initializing database schema...');
+      this.createTables();
+    }
+  }
+
+  private createTables(): void {
+    const schemaPath = path.join(__dirname, 'schema.sql');
+    const schema = fs.readFileSync(schemaPath, 'utf8');
+    
+    // Execute the entire schema as one block
+    this.db.transaction(() => {
+      this.db.exec(schema);
+    })();
+
+    console.log('Database schema initialized successfully');
+  }
+
+  getDatabase(): Database.Database {
+    return this.db;
+  }
+
+  getDatabasePath(): string {
+    return this.dbPath;
+  }
+
+  // Utility method to generate SHA-256 hash
+  static generateHash(content: string): string {
+    return crypto.createHash('sha256').update(content).digest('hex');
+  }
+
+  // Utility method to generate UUID-like ID
+  static generateId(): string {
+    return crypto.randomUUID();
+  }
+
+  // Transaction wrapper
+  transaction<T>(fn: () => T): T {
+    return this.db.transaction(fn)();
+  }
+
+  // Close database connection (for cleanup)
+  close(): void {
+    if (this.db) {
+      this.db.close();
+    }
+  }
+
+  // Get database info
+  getInfo(): { path: string; size: number; tables: string[] } {
+    const stats = fs.statSync(this.dbPath);
+    const tables = this.db
+      .prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
+      .all()
+      .map((row: any) => row.name);
+
+    return {
+      path: this.dbPath,
+      size: stats.size,
+      tables
+    };
+  }
+
+  // Vacuum database (cleanup and optimize)
+  vacuum(): void {
+    this.db.exec('VACUUM');
+  }
+
+  // Get database statistics
+  getStats(): { [tableName: string]: number } {
+    const tables = ['system_prompts', 'processing_functions', 'files', 'runs', 'cases', 'results'];
+    const stats: { [tableName: string]: number } = {};
+
+    for (const table of tables) {
+      try {
+        const result = this.db.prepare(`SELECT COUNT(*) as count FROM ${table}`).get() as { count: number };
+        stats[table] = result.count;
+      } catch (error) {
+        stats[table] = 0;
+      }
+    }
+
+    return stats;
+  }
+}
+
+// Export singleton instance getter
+export const getDatabase = () => DatabaseClient.getInstance();

evals/diff-edits/database/index.ts

@@ -0,0 +1,23 @@
+// Main database module exports
+export { DatabaseClient, getDatabase } from './client';
+export * from './types';
+export * from './operations';
+export * from './queries';
+
+// Re-export commonly used functions for convenience
+export {
+  upsertSystemPrompt,
+  upsertProcessingFunctions,
+  upsertFile,
+  createBenchmarkRun,
+  createCase,
+  insertResult,
+  getRunStats
+} from './operations';
+
+export {
+  getSuccessRatesByModel,
+  getModelComparisons,
+  getDatabaseSummary,
+  getErrorDistribution
+} from './queries';

evals/diff-edits/database/operations.ts

@@ -0,0 +1,348 @@
+import { DatabaseClient } from './client';
+import {
+  SystemPrompt,
+  ProcessingFunctions,
+  FileRecord,
+  BenchmarkRun,
+  Case,
+  Result,
+  CreateSystemPromptInput,
+  CreateProcessingFunctionsInput,
+  CreateFileInput,
+  CreateBenchmarkRunInput,
+  CreateCaseInput,
+  CreateResultInput
+} from './types';
+
+const db = DatabaseClient.getInstance();
+
+// System Prompts Operations
+export async function upsertSystemPrompt(input: CreateSystemPromptInput): Promise<string> {
+  const hash = DatabaseClient.generateHash(input.content);
+  
+  const stmt = db.getDatabase().prepare(`
+    INSERT OR IGNORE INTO system_prompts (hash, name, content)
+    VALUES (?, ?, ?)
+  `);
+  
+  stmt.run(hash, input.name, input.content);
+  return hash;
+}
+
+export async function getSystemPromptByHash(hash: string): Promise<SystemPrompt | null> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT * FROM system_prompts WHERE hash = ?
+  `);
+  
+  const result = stmt.get(hash) as SystemPrompt | undefined;
+  return result || null;
+}
+
+// Processing Functions Operations
+export async function upsertProcessingFunctions(input: CreateProcessingFunctionsInput): Promise<string> {
+  const hash = DatabaseClient.generateHash(input.parsing_function + input.diff_edit_function);
+  
+  const stmt = db.getDatabase().prepare(`
+    INSERT OR IGNORE INTO processing_functions (hash, name, parsing_function, diff_edit_function)
+    VALUES (?, ?, ?, ?)
+  `);
+  
+  stmt.run(hash, input.name, input.parsing_function, input.diff_edit_function);
+  return hash;
+}
+
+export async function getProcessingFunctionsByHash(hash: string): Promise<ProcessingFunctions | null> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT * FROM processing_functions WHERE hash = ?
+  `);
+  
+  const result = stmt.get(hash) as ProcessingFunctions | undefined;
+  return result || null;
+}
+
+// Files Operations
+export async function upsertFile(input: CreateFileInput): Promise<string> {
+  const hash = DatabaseClient.generateHash(input.content);
+  
+  const stmt = db.getDatabase().prepare(`
+    INSERT OR IGNORE INTO files (hash, filepath, content, tokens)
+    VALUES (?, ?, ?, ?)
+  `);
+  
+  stmt.run(hash, input.filepath, input.content, input.tokens || null);
+  return hash;
+}
+
+export async function getFileByHash(hash: string): Promise<FileRecord | null> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT * FROM files WHERE hash = ?
+  `);
+  
+  const result = stmt.get(hash) as FileRecord | undefined;
+  return result || null;
+}
+
+// Benchmark Runs Operations
+export async function createBenchmarkRun(input: CreateBenchmarkRunInput): Promise<string> {
+  const runId = DatabaseClient.generateId();
+  
+  const stmt = db.getDatabase().prepare(`
+    INSERT INTO runs (run_id, description, system_prompt_hash)
+    VALUES (?, ?, ?)
+  `);
+  
+  stmt.run(runId, input.description || null, input.system_prompt_hash);
+  return runId;
+}
+
+export async function getBenchmarkRun(runId: string): Promise<BenchmarkRun | null> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT * FROM runs WHERE run_id = ?
+  `);
+  
+  const result = stmt.get(runId) as BenchmarkRun | undefined;
+  return result || null;
+}
+
+export async function getAllBenchmarkRuns(): Promise<BenchmarkRun[]> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT * FROM runs ORDER BY created_at DESC
+  `);
+  
+  return stmt.all() as BenchmarkRun[];
+}
+
+// Cases Operations
+export async function createCase(input: CreateCaseInput): Promise<string> {
+  const caseId = DatabaseClient.generateId();
+  
+  const stmt = db.getDatabase().prepare(`
+    INSERT INTO cases (case_id, run_id, description, system_prompt_hash, task_id, tokens_in_context, file_hash)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+  
+  stmt.run(
+    caseId,
+    input.run_id,
+    input.description,
+    input.system_prompt_hash,
+    input.task_id,
+    input.tokens_in_context,
+    input.file_hash || null
+  );
+  
+  return caseId;
+}
+
+export async function getCasesByRun(runId: string): Promise<Case[]> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT * FROM cases WHERE run_id = ? ORDER BY created_at
+  `);
+  
+  return stmt.all(runId) as Case[];
+}
+
+export async function getCaseById(caseId: string): Promise<Case | null> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT * FROM cases WHERE case_id = ?
+  `);
+  
+  const result = stmt.get(caseId) as Case | undefined;
+  return result || null;
+}
+
+// Results Operations
+export async function insertResult(input: CreateResultInput): Promise<string> {
+  const resultId = DatabaseClient.generateId();
+  
+  const stmt = db.getDatabase().prepare(`
+    INSERT INTO results (
+      result_id, run_id, case_id, model_id, processing_functions_hash,
+      succeeded, error_enum, num_edits, num_lines_deleted, num_lines_added,
+      time_to_first_token_ms, time_to_first_edit_ms, time_round_trip_ms,
+      cost_usd, completion_tokens, raw_model_output, file_edited_hash,
+      parsed_tool_call_json
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  
+  stmt.run(
+    resultId,
+    input.run_id,
+    input.case_id,
+    input.model_id,
+    input.processing_functions_hash,
+    input.succeeded ? 1 : 0, // Convert boolean to integer
+    input.error_enum || null,
+    input.num_edits || null,
+    input.num_lines_deleted || null,
+    input.num_lines_added || null,
+    input.time_to_first_token_ms || null,
+    input.time_to_first_edit_ms || null,
+    input.time_round_trip_ms || null,
+    input.cost_usd || null,
+    input.completion_tokens || null,
+    input.raw_model_output || null,
+    input.file_edited_hash || null,
+    input.parsed_tool_call_json || null
+  );
+  
+  return resultId;
+}
+
+export async function getResultsByRun(runId: string): Promise<Result[]> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT * FROM results WHERE run_id = ? ORDER BY created_at
+  `);
+  
+  return stmt.all(runId) as Result[];
+}
+
+export async function getResultsByCase(caseId: string): Promise<Result[]> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT * FROM results WHERE case_id = ? ORDER BY created_at
+  `);
+  
+  return stmt.all(caseId) as Result[];
+}
+
+export async function getResultById(resultId: string): Promise<Result | null> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT * FROM results WHERE result_id = ?
+  `);
+  
+  const result = stmt.get(resultId) as Result | undefined;
+  return result || null;
+}
+
+// Batch operations for performance
+export async function insertResultsBatch(inputs: CreateResultInput[]): Promise<string[]> {
+  const stmt = db.getDatabase().prepare(`
+    INSERT INTO results (
+      result_id, run_id, case_id, model_id, processing_functions_hash,
+      succeeded, error_enum, num_edits, num_lines_deleted, num_lines_added,
+      time_to_first_token_ms, time_to_first_edit_ms, time_round_trip_ms,
+      cost_usd, completion_tokens, raw_model_output, file_edited_hash,
+      parsed_tool_call_json
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  
+  return db.transaction(() => {
+    const resultIds: string[] = [];
+    
+    for (const input of inputs) {
+      const resultId = DatabaseClient.generateId();
+      
+      stmt.run(
+        resultId,
+        input.run_id,
+        input.case_id,
+        input.model_id,
+        input.processing_functions_hash,
+        input.succeeded ? 1 : 0, // Convert boolean to integer
+        input.error_enum || null,
+        input.num_edits || null,
+        input.num_lines_deleted || null,
+        input.num_lines_added || null,
+        input.time_to_first_token_ms || null,
+        input.time_to_first_edit_ms || null,
+        input.time_round_trip_ms || null,
+        input.cost_usd || null,
+        input.completion_tokens || null,
+        input.raw_model_output || null,
+        input.file_edited_hash || null,
+        input.parsed_tool_call_json || null
+      );
+      
+      resultIds.push(resultId);
+    }
+    
+    return resultIds;
+  });
+}
+
+export async function createCasesBatch(inputs: CreateCaseInput[]): Promise<string[]> {
+  const stmt = db.getDatabase().prepare(`
+    INSERT INTO cases (case_id, run_id, description, system_prompt_hash, task_id, tokens_in_context)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+  
+  return db.transaction(() => {
+    const caseIds: string[] = [];
+    
+    for (const input of inputs) {
+      const caseId = DatabaseClient.generateId();
+      
+      stmt.run(
+        caseId,
+        input.run_id,
+        input.description,
+        input.system_prompt_hash,
+        input.task_id,
+        input.tokens_in_context
+      );
+      
+      caseIds.push(caseId);
+    }
+    
+    return caseIds;
+  });
+}
+
+// Utility functions
+export async function getRunStats(runId: string): Promise<{
+  total_cases: number;
+  total_results: number;
+  success_rate: number;
+  avg_cost: number;
+  avg_latency: number;
+}> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT 
+      COUNT(DISTINCT c.case_id) as total_cases,
+      COUNT(r.result_id) as total_results,
+      AVG(CASE WHEN r.succeeded THEN 1.0 ELSE 0.0 END) as success_rate,
+      AVG(r.cost_usd) as avg_cost,
+      AVG(r.time_round_trip_ms) as avg_latency
+    FROM cases c
+    LEFT JOIN results r ON c.case_id = r.case_id
+    WHERE c.run_id = ?
+  `);
+  
+  const result = stmt.get(runId) as any;
+  return {
+    total_cases: result.total_cases || 0,
+    total_results: result.total_results || 0,
+    success_rate: result.success_rate || 0,
+    avg_cost: result.avg_cost || 0,
+    avg_latency: result.avg_latency || 0
+  };
+}
+
+// Count valid attempts for a specific case and model
+export async function getValidAttemptCount(caseId: string, modelId: string): Promise<number> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT COUNT(*) as count
+    FROM results 
+    WHERE case_id = ? 
+      AND model_id = ?
+      AND error_enum NOT IN (1, 6, 7)  -- Exclude: no_tool_calls, wrong_tool_call, wrong_file_edited
+  `);
+  
+  const result = stmt.get(caseId, modelId) as { count: number };
+  return result.count;
+}
+
+// Get valid results for a specific case and model (for analysis)
+export async function getValidResults(caseId: string, modelId: string, limit?: number): Promise<Result[]> {
+  const limitClause = limit ? `LIMIT ${limit}` : '';
+  const stmt = db.getDatabase().prepare(`
+    SELECT * FROM results 
+    WHERE case_id = ? 
+      AND model_id = ?
+      AND error_enum NOT IN (1, 6, 7)  -- Only valid attempts
+    ORDER BY created_at
+    ${limitClause}
+  `);
+  
+  return stmt.all(caseId, modelId) as Result[];
+}

evals/diff-edits/database/queries.ts

@@ -0,0 +1,309 @@
+import { DatabaseClient } from './client';
+import {
+  ModelSuccessRate,
+  ModelLatency,
+  CostAnalysis,
+  ErrorDistribution,
+  FailedCase,
+  PerformanceTrend,
+  ModelComparison
+} from './types';
+
+const db = DatabaseClient.getInstance();
+
+// Performance analysis queries
+export async function getSuccessRatesByModel(): Promise<ModelSuccessRate[]> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT 
+      model_id,
+      COUNT(*) as total_runs,
+      SUM(CASE WHEN succeeded THEN 1 ELSE 0 END) as successful_runs,
+      ROUND(AVG(CASE WHEN succeeded THEN 1.0 ELSE 0.0 END) * 100, 2) as success_rate
+    FROM results
+    WHERE error_enum NOT IN (1, 6, 7) OR error_enum IS NULL  -- Exclude: no_tool_calls, wrong_tool_call, wrong_file_edited
+    GROUP BY model_id
+    ORDER BY success_rate DESC, total_runs DESC
+  `);
+  
+  return stmt.all() as ModelSuccessRate[];
+}
+
+export async function getAverageLatencyByModel(): Promise<ModelLatency[]> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT 
+      model_id,
+      ROUND(AVG(time_to_first_token_ms), 2) as avg_time_to_first_token_ms,
+      ROUND(AVG(time_to_first_edit_ms), 2) as avg_time_to_first_edit_ms,
+      ROUND(AVG(time_round_trip_ms), 2) as avg_time_round_trip_ms
+    FROM results
+    WHERE time_to_first_token_ms IS NOT NULL
+    GROUP BY model_id
+    ORDER BY avg_time_round_trip_ms ASC
+  `);
+  
+  return stmt.all() as ModelLatency[];
+}
+
+export async function getCostAnalysisByRun(): Promise<CostAnalysis[]> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT 
+      run_id,
+      model_id,
+      ROUND(SUM(cost_usd), 4) as total_cost_usd,
+      ROUND(AVG(cost_usd), 4) as avg_cost_per_case,
+      SUM(completion_tokens) as total_completion_tokens
+    FROM results
+    WHERE cost_usd IS NOT NULL
+    GROUP BY run_id, model_id
+    ORDER BY total_cost_usd DESC
+  `);
+  
+  return stmt.all() as CostAnalysis[];
+}
+
+// Error analysis queries
+export async function getErrorDistribution(): Promise<ErrorDistribution[]> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT 
+      error_enum,
+      COUNT(*) as count,
+      ROUND(COUNT(*) * 100.0 / (SELECT COUNT(*) FROM results WHERE succeeded = 0), 2) as percentage
+    FROM results
+    WHERE succeeded = 0 AND error_enum IS NOT NULL
+    GROUP BY error_enum
+    ORDER BY count DESC
+  `);
+  
+  return stmt.all() as ErrorDistribution[];
+}
+
+export async function getFailedCasesByError(errorEnum?: number): Promise<FailedCase[]> {
+  let query = `
+    SELECT 
+      r.case_id,
+      r.model_id,
+      r.error_enum,
+      c.description,
+      r.raw_model_output
+    FROM results r
+    JOIN cases c ON r.case_id = c.case_id
+    WHERE r.succeeded = 0
+  `;
+  
+  const params: any[] = [];
+  if (errorEnum !== undefined) {
+    query += ` AND r.error_enum = ?`;
+    params.push(errorEnum);
+  }
+  
+  query += ` ORDER BY r.created_at DESC LIMIT 100`;
+  
+  const stmt = db.getDatabase().prepare(query);
+  return stmt.all(...params) as FailedCase[];
+}
+
+// Trend analysis queries
+export async function getPerformanceTrends(days: number = 30): Promise<PerformanceTrend[]> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT 
+      DATE(r.created_at) as date,
+      r.model_id,
+      ROUND(AVG(CASE WHEN r.succeeded THEN 1.0 ELSE 0.0 END) * 100, 2) as success_rate,
+      ROUND(AVG(r.time_round_trip_ms), 2) as avg_latency_ms,
+      ROUND(AVG(r.cost_usd), 4) as avg_cost_usd
+    FROM results r
+    WHERE r.created_at >= datetime('now', '-' || ? || ' days')
+      AND (r.error_enum NOT IN (1, 6, 7) OR r.error_enum IS NULL)  -- Exclude: no_tool_calls, wrong_tool_call, wrong_file_edited
+    GROUP BY DATE(r.created_at), r.model_id
+    ORDER BY date DESC, model_id
+  `);
+  
+  return stmt.all(days) as PerformanceTrend[];
+}
+
+export async function getModelComparisons(): Promise<ModelComparison[]> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT 
+      model_id,
+      ROUND(AVG(CASE WHEN succeeded THEN 1.0 ELSE 0.0 END) * 100, 2) as success_rate,
+      ROUND(AVG(time_round_trip_ms), 2) as avg_latency_ms,
+      ROUND(AVG(cost_usd), 4) as avg_cost_usd,
+      COUNT(*) as total_runs
+    FROM results
+    WHERE error_enum NOT IN (1, 6, 7) OR error_enum IS NULL  -- Exclude: no_tool_calls, wrong_tool_call, wrong_file_edited
+    GROUP BY model_id
+    HAVING total_runs >= 10
+    ORDER BY success_rate DESC, avg_latency_ms ASC
+  `);
+  
+  return stmt.all() as ModelComparison[];
+}
+
+// Advanced analysis queries
+export async function getTopPerformingCases(limit: number = 10): Promise<Array<{
+  case_id: string;
+  description: string;
+  success_rate: number;
+  avg_latency_ms: number;
+  total_runs: number;
+}>> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT 
+      c.case_id,
+      c.description,
+      ROUND(AVG(CASE WHEN r.succeeded THEN 1.0 ELSE 0.0 END) * 100, 2) as success_rate,
+      ROUND(AVG(r.time_round_trip_ms), 2) as avg_latency_ms,
+      COUNT(r.result_id) as total_runs
+    FROM cases c
+    JOIN results r ON c.case_id = r.case_id
+    WHERE r.error_enum NOT IN (1, 6, 7) OR r.error_enum IS NULL  -- Exclude: no_tool_calls, wrong_tool_call, wrong_file_edited
+    GROUP BY c.case_id, c.description
+    HAVING total_runs >= 5
+    ORDER BY success_rate DESC, avg_latency_ms ASC
+    LIMIT ?
+  `);
+  
+  return stmt.all(limit) as Array<{
+    case_id: string;
+    description: string;
+    success_rate: number;
+    avg_latency_ms: number;
+    total_runs: number;
+  }>;
+}
+
+export async function getWorstPerformingCases(limit: number = 10): Promise<Array<{
+  case_id: string;
+  description: string;
+  success_rate: number;
+  avg_latency_ms: number;
+  total_runs: number;
+}>> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT 
+      c.case_id,
+      c.description,
+      ROUND(AVG(CASE WHEN r.succeeded THEN 1.0 ELSE 0.0 END) * 100, 2) as success_rate,
+      ROUND(AVG(r.time_round_trip_ms), 2) as avg_latency_ms,
+      COUNT(r.result_id) as total_runs
+    FROM cases c
+    JOIN results r ON c.case_id = r.case_id
+    WHERE r.error_enum NOT IN (1, 6, 7) OR r.error_enum IS NULL  -- Exclude: no_tool_calls, wrong_tool_call, wrong_file_edited
+    GROUP BY c.case_id, c.description
+    HAVING total_runs >= 5
+    ORDER BY success_rate ASC, avg_latency_ms DESC
+    LIMIT ?
+  `);
+  
+  return stmt.all(limit) as Array<{
+    case_id: string;
+    description: string;
+    success_rate: number;
+    avg_latency_ms: number;
+    total_runs: number;
+  }>;
+}
+
+export async function getModelPerformanceByTimeOfDay(): Promise<Array<{
+  model_id: string;
+  hour: number;
+  success_rate: number;
+  avg_latency_ms: number;
+  total_runs: number;
+}>> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT 
+      model_id,
+      CAST(strftime('%H', created_at) AS INTEGER) as hour,
+      ROUND(AVG(CASE WHEN succeeded THEN 1.0 ELSE 0.0 END) * 100, 2) as success_rate,
+      ROUND(AVG(time_round_trip_ms), 2) as avg_latency_ms,
+      COUNT(*) as total_runs
+    FROM results
+    GROUP BY model_id, hour
+    HAVING total_runs >= 5
+    ORDER BY model_id, hour
+  `);
+  
+  return stmt.all() as Array<{
+    model_id: string;
+    hour: number;
+    success_rate: number;
+    avg_latency_ms: number;
+    total_runs: number;
+  }>;
+}
+
+export async function getRunComparison(runId1: string, runId2: string): Promise<{
+  run1: { run_id: string; success_rate: number; avg_latency_ms: number; avg_cost_usd: number; total_cases: number };
+  run2: { run_id: string; success_rate: number; avg_latency_ms: number; avg_cost_usd: number; total_cases: number };
+}> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT 
+      run_id,
+      ROUND(AVG(CASE WHEN succeeded THEN 1.0 ELSE 0.0 END) * 100, 2) as success_rate,
+      ROUND(AVG(time_round_trip_ms), 2) as avg_latency_ms,
+      ROUND(AVG(cost_usd), 4) as avg_cost_usd,
+      COUNT(DISTINCT case_id) as total_cases
+    FROM results
+    WHERE run_id IN (?, ?)
+    GROUP BY run_id
+  `);
+  
+  const results = stmt.all(runId1, runId2) as Array<{
+    run_id: string;
+    success_rate: number;
+    avg_latency_ms: number;
+    avg_cost_usd: number;
+    total_cases: number;
+  }>;
+  
+  const run1 = results.find(r => r.run_id === runId1);
+  const run2 = results.find(r => r.run_id === runId2);
+  
+  if (!run1 || !run2) {
+    throw new Error('One or both runs not found');
+  }
+  
+  return { run1, run2 };
+}
+
+// Summary statistics
+export async function getDatabaseSummary(): Promise<{
+  total_runs: number;
+  total_cases: number;
+  total_results: number;
+  valid_results: number;
+  unique_models: number;
+  overall_success_rate: number;
+  date_range: { earliest: string; latest: string };
+}> {
+  const stmt = db.getDatabase().prepare(`
+    SELECT 
+      (SELECT COUNT(*) FROM runs) as total_runs,
+      (SELECT COUNT(*) FROM cases) as total_cases,
+      (SELECT COUNT(*) FROM results) as total_results,
+      (SELECT COUNT(*) FROM results WHERE error_enum NOT IN (1, 6, 7) OR error_enum IS NULL) as valid_results,
+      (SELECT COUNT(DISTINCT model_id) FROM results) as unique_models,
+      (SELECT ROUND(AVG(CASE WHEN succeeded THEN 1.0 ELSE 0.0 END) * 100, 2) 
+       FROM results 
+       WHERE error_enum NOT IN (1, 6, 7) OR error_enum IS NULL) as overall_success_rate,
+      (SELECT MIN(created_at) FROM results) as earliest,
+      (SELECT MAX(created_at) FROM results) as latest
+    FROM results
+    LIMIT 1
+  `);
+  
+  const result = stmt.get() as any;
+  return {
+    total_runs: result.total_runs || 0,
+    total_cases: result.total_cases || 0,
+    total_results: result.total_results || 0,
+    valid_results: result.valid_results || 0,
+    unique_models: result.unique_models || 0,
+    overall_success_rate: result.overall_success_rate || 0,
+    date_range: {
+      earliest: result.earliest || '',
+      latest: result.latest || ''
+    }
+  };
+}

evals/diff-edits/database/schema.sql

@@ -0,0 +1,78 @@
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE system_prompts (
+    hash TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    content TEXT NOT NULL,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE processing_functions (
+    hash TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    parsing_function TEXT NOT NULL,
+    diff_edit_function TEXT NOT NULL,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE files (
+    hash TEXT PRIMARY KEY,
+    filepath TEXT NOT NULL,
+    content TEXT NOT NULL,
+    tokens INTEGER,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE runs (
+    run_id TEXT PRIMARY KEY,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    description TEXT,
+    system_prompt_hash TEXT NOT NULL,
+    FOREIGN KEY (system_prompt_hash) REFERENCES system_prompts(hash)
+);
+
+CREATE TABLE cases (
+    case_id TEXT PRIMARY KEY,
+    run_id TEXT NOT NULL,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    description TEXT NOT NULL,
+    system_prompt_hash TEXT NOT NULL,
+    task_id TEXT NOT NULL,
+    tokens_in_context INTEGER,
+    file_hash TEXT,
+    FOREIGN KEY (run_id) REFERENCES runs(run_id),
+    FOREIGN KEY (system_prompt_hash) REFERENCES system_prompts(hash),
+    FOREIGN KEY (file_hash) REFERENCES files(hash)
+);
+
+CREATE TABLE results (
+    result_id TEXT PRIMARY KEY,
+    run_id TEXT NOT NULL,
+    case_id TEXT NOT NULL,
+    model_id TEXT NOT NULL,
+    processing_functions_hash TEXT NOT NULL,
+    succeeded BOOLEAN NOT NULL,
+    error_enum INTEGER,
+    num_edits INTEGER,
+    num_lines_deleted INTEGER,
+    num_lines_added INTEGER,
+    time_to_first_token_ms INTEGER,
+    time_to_first_edit_ms INTEGER,
+    time_round_trip_ms INTEGER,
+    cost_usd REAL,
+    completion_tokens INTEGER,
+    raw_model_output TEXT,
+    file_edited_hash TEXT,
+    parsed_tool_call_json TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (run_id) REFERENCES runs(run_id),
+    FOREIGN KEY (case_id) REFERENCES cases(case_id),
+    FOREIGN KEY (processing_functions_hash) REFERENCES processing_functions(hash)
+);
+
+CREATE INDEX idx_results_run_model ON results(run_id, model_id);
+CREATE INDEX idx_results_case_model ON results(case_id, model_id);
+CREATE INDEX idx_results_success ON results(succeeded);
+CREATE INDEX idx_cases_run ON cases(run_id);
+CREATE INDEX idx_results_created_at ON results(created_at);
+CREATE INDEX idx_runs_created_at ON runs(created_at);

evals/diff-edits/database/test.ts

@@ -0,0 +1,53 @@
+// Simple test to verify database functionality
+import { getDatabase } from './client';
+import { upsertSystemPrompt, createBenchmarkRun, getDatabaseSummary } from './index';
+
+async function testDatabase() {
+  console.log('Testing database functionality...');
+  
+  try {
+    // Test database connection
+    const db = getDatabase();
+    console.log('✓ Database connection established');
+    console.log('Database path:', db.getDatabasePath());
+    
+    // Test database info
+    const info = db.getInfo();
+    console.log('✓ Database info:', info);
+    
+    // Test database stats
+    const stats = db.getStats();
+    console.log('✓ Database stats:', stats);
+    
+    // Test system prompt creation
+    const systemPromptHash = await upsertSystemPrompt({
+      name: 'test-prompt',
+      content: 'This is a test system prompt for database verification.'
+    });
+    console.log('✓ System prompt created with hash:', systemPromptHash);
+    
+    // Test benchmark run creation
+    const runId = await createBenchmarkRun({
+      description: 'Test run for database verification',
+      system_prompt_hash: systemPromptHash
+    });
+    console.log('✓ Benchmark run created with ID:', runId);
+    
+    // Test database summary
+    const summary = await getDatabaseSummary();
+    console.log('✓ Database summary:', summary);
+    
+    console.log('\n🎉 All database tests passed!');
+    
+  } catch (error) {
+    console.error('❌ Database test failed:', error);
+    process.exit(1);
+  }
+}
+
+// Run test if this file is executed directly
+if (require.main === module) {
+  testDatabase();
+}
+
+export { testDatabase };

evals/diff-edits/database/types.ts

@@ -0,0 +1,169 @@
+// Database type definitions for diff-edits evaluation system
+
+export interface SystemPrompt {
+  hash: string;
+  name: string;
+  content: string;
+  created_at: string;
+}
+
+export interface ProcessingFunctions {
+  hash: string;
+  name: string;
+  parsing_function: string;
+  diff_edit_function: string;
+  created_at: string;
+}
+
+export interface FileRecord {
+  hash: string;
+  filepath: string;
+  content: string;
+  tokens?: number;
+  created_at: string;
+}
+
+export interface BenchmarkRun {
+  run_id: string;
+  created_at: string;
+  description?: string;
+  system_prompt_hash: string;
+}
+
+export interface Case {
+	case_id: string
+	run_id: string
+	created_at: string
+	description: string
+	system_prompt_hash: string
+	task_id: string
+	tokens_in_context: number
+	file_hash?: string
+}
+
+export interface Result {
+  result_id: string;
+  run_id: string;
+  case_id: string;
+  model_id: string;
+  processing_functions_hash: string;
+  succeeded: boolean;
+  error_enum?: number;
+  num_edits?: number;
+  num_lines_deleted?: number;
+  num_lines_added?: number;
+  time_to_first_token_ms?: number;
+  time_to_first_edit_ms?: number;
+  time_round_trip_ms?: number;
+  cost_usd?: number;
+  completion_tokens?: number;
+  raw_model_output?: string;
+  file_edited_hash?: string;
+  parsed_tool_call_json?: string;
+  created_at: string;
+}
+
+// Input types for creating records
+export interface CreateSystemPromptInput {
+  name: string;
+  content: string;
+}
+
+export interface CreateProcessingFunctionsInput {
+  name: string;
+  parsing_function: string;
+  diff_edit_function: string;
+}
+
+export interface CreateFileInput {
+  filepath: string;
+  content: string;
+  tokens?: number;
+}
+
+export interface CreateBenchmarkRunInput {
+  description?: string;
+  system_prompt_hash: string;
+}
+
+export interface CreateCaseInput {
+  run_id: string;
+  description: string;
+  system_prompt_hash: string;
+  task_id: string;
+  tokens_in_context: number;
+  file_hash?: string;
+}
+
+export interface CreateResultInput {
+  run_id: string;
+  case_id: string;
+  model_id: string;
+  processing_functions_hash: string;
+  succeeded: boolean;
+  error_enum?: number;
+  num_edits?: number;
+  num_lines_deleted?: number;
+  num_lines_added?: number;
+  time_to_first_token_ms?: number;
+  time_to_first_edit_ms?: number;
+  time_round_trip_ms?: number;
+  cost_usd?: number;
+  completion_tokens?: number;
+  raw_model_output?: string;
+  file_edited_hash?: string;
+  parsed_tool_call_json?: string;
+}
+
+// Analysis result types
+export interface ModelSuccessRate {
+  model_id: string;
+  total_runs: number;
+  successful_runs: number;
+  success_rate: number;
+}
+
+export interface ModelLatency {
+  model_id: string;
+  avg_time_to_first_token_ms: number;
+  avg_time_to_first_edit_ms: number;
+  avg_time_round_trip_ms: number;
+}
+
+export interface CostAnalysis {
+  run_id: string;
+  model_id: string;
+  total_cost_usd: number;
+  avg_cost_per_case: number;
+  total_completion_tokens: number;
+}
+
+export interface ErrorDistribution {
+  error_enum: number;
+  count: number;
+  percentage: number;
+}
+
+export interface FailedCase {
+  case_id: string;
+  model_id: string;
+  error_enum: number;
+  description: string;
+  raw_model_output?: string;
+}
+
+export interface PerformanceTrend {
+  date: string;
+  model_id: string;
+  success_rate: number;
+  avg_latency_ms: number;
+  avg_cost_usd: number;
+}
+
+export interface ModelComparison {
+  model_id: string;
+  success_rate: number;
+  avg_latency_ms: number;
+  avg_cost_usd: number;
+  total_runs: number;
+}

evals/diff-edits/diff-apply/diff-06-06-25.ts

@@ -0,0 +1,729 @@
+const SEARCH_BLOCK_START = "------- SEARCH"
+const SEARCH_BLOCK_END = "======="
+const REPLACE_BLOCK_END = "+++++++ REPLACE"
+
+const SEARCH_BLOCK_CHAR = "-"
+const REPLACE_BLOCK_CHAR = "+"
+
+/**
+ * Attempts a line-trimmed fallback match for the given search content in the original content.
+ * It tries to match `searchContent` lines against a block of lines in `originalContent` starting
+ * from `lastProcessedIndex`. Lines are matched by trimming leading/trailing whitespace and ensuring
+ * they are identical afterwards.
+ *
+ * Returns [matchIndexStart, matchIndexEnd] if found, or false if not found.
+ */
+function lineTrimmedFallbackMatch(originalContent: string, searchContent: string, startIndex: number): [number, number] | false {
+	// Split both contents into lines
+	const originalLines = originalContent.split("\n")
+	const searchLines = searchContent.split("\n")
+
+	// Trim trailing empty line if exists (from the trailing \n in searchContent)
+	if (searchLines[searchLines.length - 1] === "") {
+		searchLines.pop()
+	}
+
+	// Find the line number where startIndex falls
+	let startLineNum = 0
+	let currentIndex = 0
+	while (currentIndex < startIndex && startLineNum < originalLines.length) {
+		currentIndex += originalLines[startLineNum].length + 1 // +1 for \n
+		startLineNum++
+	}
+
+	// For each possible starting position in original content
+	for (let i = startLineNum; i <= originalLines.length - searchLines.length; i++) {
+		let matches = true
+
+		// Try to match all search lines from this position
+		for (let j = 0; j < searchLines.length; j++) {
+			const originalTrimmed = originalLines[i + j].trim()
+			const searchTrimmed = searchLines[j].trim()
+
+			if (originalTrimmed !== searchTrimmed) {
+				matches = false
+				break
+			}
+		}
+
+		// If we found a match, calculate the exact character positions
+		if (matches) {
+			// Find start character index
+			let matchStartIndex = 0
+			for (let k = 0; k < i; k++) {
+				matchStartIndex += originalLines[k].length + 1 // +1 for \n
+			}
+
+			// Find end character index
+			let matchEndIndex = matchStartIndex
+			for (let k = 0; k < searchLines.length; k++) {
+				matchEndIndex += originalLines[i + k].length + 1 // +1 for \n
+			}
+
+			return [matchStartIndex, matchEndIndex]
+		}
+	}
+
+	return false
+}
+
+/**
+ * Attempts to match blocks of code by using the first and last lines as anchors.
+ * This is a third-tier fallback strategy that helps match blocks where we can identify
+ * the correct location by matching the beginning and end, even if the exact content
+ * differs slightly.
+ *
+ * The matching strategy:
+ * 1. Only attempts to match blocks of 3 or more lines to avoid false positives
+ * 2. Extracts from the search content:
+ *    - First line as the "start anchor"
+ *    - Last line as the "end anchor"
+ * 3. For each position in the original content:
+ *    - Checks if the next line matches the start anchor
+ *    - If it does, jumps ahead by the search block size
+ *    - Checks if that line matches the end anchor
+ *    - All comparisons are done after trimming whitespace
+ *
+ * This approach is particularly useful for matching blocks of code where:
+ * - The exact content might have minor differences
+ * - The beginning and end of the block are distinctive enough to serve as anchors
+ * - The overall structure (number of lines) remains the same
+ *
+ * @param originalContent - The full content of the original file
+ * @param searchContent - The content we're trying to find in the original file
+ * @param startIndex - The character index in originalContent where to start searching
+ * @returns A tuple of [startIndex, endIndex] if a match is found, false otherwise
+ */
+function blockAnchorFallbackMatch(originalContent: string, searchContent: string, startIndex: number): [number, number] | false {
+	const originalLines = originalContent.split("\n")
+	const searchLines = searchContent.split("\n")
+
+	// Only use this approach for blocks of 3+ lines
+	if (searchLines.length < 3) {
+		return false
+	}
+
+	// Trim trailing empty line if exists
+	if (searchLines[searchLines.length - 1] === "") {
+		searchLines.pop()
+	}
+
+	const firstLineSearch = searchLines[0].trim()
+	const lastLineSearch = searchLines[searchLines.length - 1].trim()
+	const searchBlockSize = searchLines.length
+
+	// Find the line number where startIndex falls
+	let startLineNum = 0
+	let currentIndex = 0
+	while (currentIndex < startIndex && startLineNum < originalLines.length) {
+		currentIndex += originalLines[startLineNum].length + 1
+		startLineNum++
+	}
+
+	// Look for matching start and end anchors
+	for (let i = startLineNum; i <= originalLines.length - searchBlockSize; i++) {
+		// Check if first line matches
+		if (originalLines[i].trim() !== firstLineSearch) {
+			continue
+		}
+
+		// Check if last line matches at the expected position
+		if (originalLines[i + searchBlockSize - 1].trim() !== lastLineSearch) {
+			continue
+		}
+
+		// Calculate exact character positions
+		let matchStartIndex = 0
+		for (let k = 0; k < i; k++) {
+			matchStartIndex += originalLines[k].length + 1
+		}
+
+		let matchEndIndex = matchStartIndex
+		for (let k = 0; k < searchBlockSize; k++) {
+			matchEndIndex += originalLines[i + k].length + 1
+		}
+
+		return [matchStartIndex, matchEndIndex]
+	}
+
+	return false
+}
+
+/**
+ * This function reconstructs the file content by applying a streamed diff (in a
+ * specialized SEARCH/REPLACE block format) to the original file content. It is designed
+ * to handle both incremental updates and the final resulting file after all chunks have
+ * been processed.
+ *
+ * The diff format is a custom structure that uses three markers to define changes:
+ *
+ *   ------- SEARCH
+ *   [Exact content to find in the original file]
+ *   =======
+ *   [Content to replace with]
+ *   +++++++ REPLACE
+ *
+ * Behavior and Assumptions:
+ * 1. The file is processed chunk-by-chunk. Each chunk of `diffContent` may contain
+ *    partial or complete SEARCH/REPLACE blocks. By calling this function with each
+ *    incremental chunk (with `isFinal` indicating the last chunk), the final reconstructed
+ *    file content is produced.
+ *
+ * 2. Matching Strategy (in order of attempt):
+ *    a. Exact Match: First attempts to find the exact SEARCH block text in the original file
+ *    b. Line-Trimmed Match: Falls back to line-by-line comparison ignoring leading/trailing whitespace
+ *    c. Block Anchor Match: For blocks of 3+ lines, tries to match using first/last lines as anchors
+ *    If all matching strategies fail, an error is thrown.
+ *
+ * 3. Empty SEARCH Section:
+ *    - If SEARCH is empty and the original file is empty, this indicates creating a new file
+ *      (pure insertion).
+ *    - If SEARCH is empty and the original file is not empty, this indicates a complete
+ *      file replacement (the entire original content is considered matched and replaced).
+ *
+ * 4. Applying Changes:
+ *    - Before encountering the "=======" marker, lines are accumulated as search content.
+ *    - After "=======" and before ">>>>>>> REPLACE", lines are accumulated as replacement content.
+ *    - Once the block is complete (">>>>>>> REPLACE"), the matched section in the original
+ *      file is replaced with the accumulated replacement lines, and the position in the original
+ *      file is advanced.
+ *
+ * 5. Incremental Output:
+ *    - As soon as the match location is found and we are in the REPLACE section, each new
+ *      replacement line is appended to the result so that partial updates can be viewed
+ *      incrementally.
+ *
+ * 6. Partial Markers:
+ *    - If the final line of the chunk looks like it might be part of a marker but is not one
+ *      of the known markers, it is removed. This prevents incomplete or partial markers
+ *      from corrupting the output.
+ *
+ * 7. Finalization:
+ *    - Once all chunks have been processed (when `isFinal` is true), any remaining original
+ *      content after the last replaced section is appended to the result.
+ *    - Trailing newlines are not forcibly added. The code tries to output exactly what is specified.
+ *
+ * Errors:
+ * - If the search block cannot be matched using any of the available matching strategies,
+ *   an error is thrown.
+ */
+export async function constructNewFileContent(
+	diffContent: string,
+	originalContent: string,
+	isFinal: boolean,
+	version: "v1" | "v2" = "v1",
+): Promise<string> {
+	const constructor = constructNewFileContentVersionMapping[version]
+	if (!constructor) {
+		throw new Error(`Invalid version '${version}' for file content constructor`)
+	}
+	return constructor(diffContent, originalContent, isFinal)
+}
+
+const constructNewFileContentVersionMapping: Record<
+	string,
+	(diffContent: string, originalContent: string, isFinal: boolean) => Promise<string>
+> = {
+	v1: constructNewFileContentV1,
+	v2: constructNewFileContentV2,
+} as const
+
+/**
+ * @deprecated
+ */
+async function constructNewFileContentV1(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
+	let result = ""
+	let lastProcessedIndex = 0
+
+	let currentSearchContent = ""
+	let currentReplaceContent = ""
+	let inSearch = false
+	let inReplace = false
+
+	let searchMatchIndex = -1
+	let searchEndIndex = -1
+
+	let lines = diffContent.split("\n")
+
+	// If the last line looks like a partial marker but isn't recognized,
+	// remove it because it might be incomplete.
+	const lastLine = lines[lines.length - 1]
+	if (
+		lines.length > 0 &&
+		(lastLine.startsWith(SEARCH_BLOCK_CHAR) || lastLine.startsWith("=") || lastLine.startsWith(REPLACE_BLOCK_CHAR)) &&
+		lastLine !== SEARCH_BLOCK_START &&
+		lastLine !== SEARCH_BLOCK_END &&
+		lastLine !== REPLACE_BLOCK_END
+	) {
+		lines.pop()
+	}
+
+	for (const line of lines) {
+		if (line === SEARCH_BLOCK_START) {
+			inSearch = true
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			continue
+		}
+
+		if (line === SEARCH_BLOCK_END) {
+			inSearch = false
+			inReplace = true
+
+			// Remove trailing linebreak for adding the === marker
+			// if (currentSearchContent.endsWith("\r\n")) {
+			// 	currentSearchContent = currentSearchContent.slice(0, -2)
+			// } else if (currentSearchContent.endsWith("\n")) {
+			// 	currentSearchContent = currentSearchContent.slice(0, -1)
+			// }
+
+			if (!currentSearchContent) {
+				// Empty search block
+				if (originalContent.length === 0) {
+					// New file scenario: nothing to match, just start inserting
+					searchMatchIndex = 0
+					searchEndIndex = 0
+				} else {
+					// Complete file replacement scenario: treat the entire file as matched
+					searchMatchIndex = 0
+					searchEndIndex = originalContent.length
+				}
+			} else {
+				// Add check for inefficient full-file search
+				// if (currentSearchContent.trim() === originalContent.trim()) {
+				// 	throw new Error(
+				// 		"The SEARCH block contains the entire file content. Please either:\n" +
+				// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
+				// 			"2. Make focused changes to specific parts of the file that need modification.",
+				// 	)
+				// }
+
+				// Exact search match scenario
+				const exactIndex = originalContent.indexOf(currentSearchContent, lastProcessedIndex)
+				if (exactIndex !== -1) {
+					searchMatchIndex = exactIndex
+					searchEndIndex = exactIndex + currentSearchContent.length
+				} else {
+					// Attempt fallback line-trimmed matching
+					const lineMatch = lineTrimmedFallbackMatch(originalContent, currentSearchContent, lastProcessedIndex)
+					if (lineMatch) {
+						;[searchMatchIndex, searchEndIndex] = lineMatch
+					} else {
+						// Try block anchor fallback for larger blocks
+						const blockMatch = blockAnchorFallbackMatch(originalContent, currentSearchContent, lastProcessedIndex)
+						if (blockMatch) {
+							;[searchMatchIndex, searchEndIndex] = blockMatch
+						} else {
+							throw new Error(
+								`The SEARCH block:\n${currentSearchContent.trimEnd()}\n...does not match anything in the file or was searched out of order in the provided blocks.`,
+							)
+						}
+					}
+				}
+			}
+
+			// Output everything up to the match location
+			result += originalContent.slice(lastProcessedIndex, searchMatchIndex)
+			continue
+		}
+
+		if (line === REPLACE_BLOCK_END) {
+			// Finished one replace block
+
+			// // Remove the artificially added linebreak in the last line of the REPLACE block
+			// if (result.endsWith("\r\n")) {
+			// 	result = result.slice(0, -2)
+			// } else if (result.endsWith("\n")) {
+			// 	result = result.slice(0, -1)
+			// }
+
+			// Advance lastProcessedIndex to after the matched section
+			lastProcessedIndex = searchEndIndex
+
+			// Reset for next block
+			inSearch = false
+			inReplace = false
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			searchMatchIndex = -1
+			searchEndIndex = -1
+			continue
+		}
+
+		// Accumulate content for search or replace
+		// (currentReplaceContent is not being used for anything right now since we directly append to result.)
+		// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
+		// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
+		if (inSearch) {
+			currentSearchContent += line + "\n"
+		} else if (inReplace) {
+			currentReplaceContent += line + "\n"
+			// Output replacement lines immediately if we know the insertion point
+			if (searchMatchIndex !== -1) {
+				result += line + "\n"
+			}
+		}
+	}
+
+	// If this is the final chunk, append any remaining original content
+	if (isFinal && lastProcessedIndex < originalContent.length) {
+		result += originalContent.slice(lastProcessedIndex)
+	}
+
+	return result
+}
+
+enum ProcessingState {
+	Idle = 0,
+	StateSearch = 1 << 0,
+	StateReplace = 1 << 1,
+}
+
+class NewFileContentConstructor {
+	private originalContent: string
+	private isFinal: boolean
+	private state: number
+	private pendingNonStandardLines: string[]
+	private result: string
+	private lastProcessedIndex: number
+	private currentSearchContent: string
+	private currentReplaceContent: string
+	private searchMatchIndex: number
+	private searchEndIndex: number
+
+	constructor(originalContent: string, isFinal: boolean) {
+		this.originalContent = originalContent
+		this.isFinal = isFinal
+		this.pendingNonStandardLines = []
+		this.result = ""
+		this.lastProcessedIndex = 0
+		this.state = ProcessingState.Idle
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+		this.searchMatchIndex = -1
+		this.searchEndIndex = -1
+	}
+
+	private resetForNextBlock() {
+		// Reset for next block
+		this.state = ProcessingState.Idle
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+		this.searchMatchIndex = -1
+		this.searchEndIndex = -1
+	}
+
+	private findLastMatchingLineIndex(regx: RegExp, lineLimit: number) {
+		for (let i = lineLimit; i > 0; ) {
+			i--
+			if (this.pendingNonStandardLines[i].match(regx)) {
+				return i
+			}
+		}
+		return -1
+	}
+
+	private updateProcessingState(newState: ProcessingState) {
+		const isValidTransition =
+			(this.state === ProcessingState.Idle && newState === ProcessingState.StateSearch) ||
+			(this.state === ProcessingState.StateSearch && newState === ProcessingState.StateReplace)
+
+		if (!isValidTransition) {
+			throw new Error(
+				`Invalid state transition.\n` +
+					"Valid transitions are:\n" +
+					"- Idle → StateSearch\n" +
+					"- StateSearch → StateReplace",
+			)
+		}
+
+		this.state |= newState
+	}
+
+	private isStateActive(state: ProcessingState): boolean {
+		return (this.state & state) === state
+	}
+
+	private activateReplaceState() {
+		this.updateProcessingState(ProcessingState.StateReplace)
+	}
+
+	private activateSearchState() {
+		this.updateProcessingState(ProcessingState.StateSearch)
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+	}
+
+	private isSearchingActive(): boolean {
+		return this.isStateActive(ProcessingState.StateSearch)
+	}
+
+	private isReplacingActive(): boolean {
+		return this.isStateActive(ProcessingState.StateReplace)
+	}
+
+	private hasPendingNonStandardLines(pendingNonStandardLineLimit: number): boolean {
+		return this.pendingNonStandardLines.length - pendingNonStandardLineLimit < this.pendingNonStandardLines.length
+	}
+
+	public processLine(line: string) {
+		this.internalProcessLine(line, true, this.pendingNonStandardLines.length)
+	}
+
+	public getResult() {
+		// If this is the final chunk, append any remaining original content
+		if (this.isFinal && this.lastProcessedIndex < this.originalContent.length) {
+			this.result += this.originalContent.slice(this.lastProcessedIndex)
+		}
+		if (this.isFinal && this.state !== ProcessingState.Idle) {
+			throw new Error("File processing incomplete - SEARCH/REPLACE operations still active during finalization")
+		}
+		return this.result
+	}
+
+	private internalProcessLine(
+		line: string,
+		canWritependingNonStandardLines: boolean,
+		pendingNonStandardLineLimit: number,
+	): number {
+		let removeLineCount = 0
+		if (line === SEARCH_BLOCK_START) {
+			removeLineCount = this.trimPendingNonStandardTrailingEmptyLines(pendingNonStandardLineLimit)
+			if (removeLineCount > 0) {
+				pendingNonStandardLineLimit = pendingNonStandardLineLimit - removeLineCount
+			}
+			if (this.hasPendingNonStandardLines(pendingNonStandardLineLimit)) {
+				this.tryFixSearchReplaceBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.activateSearchState()
+		} else if (line === SEARCH_BLOCK_END) {
+			// 校验非标内容
+			if (!this.isSearchingActive()) {
+				this.tryFixSearchBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.activateReplaceState()
+			this.beforeReplace()
+		} else if (line === REPLACE_BLOCK_END) {
+			if (!this.isReplacingActive()) {
+				this.tryFixReplaceBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.lastProcessedIndex = this.searchEndIndex
+			this.resetForNextBlock()
+		} else {
+			// Accumulate content for search or replace
+			// (currentReplaceContent is not being used for anything right now since we directly append to result.)
+			// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
+			// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
+			if (this.isReplacingActive()) {
+				this.currentReplaceContent += line + "\n"
+				// Output replacement lines immediately if we know the insertion point
+				if (this.searchMatchIndex !== -1) {
+					this.result += line + "\n"
+				}
+			} else if (this.isSearchingActive()) {
+				this.currentSearchContent += line + "\n"
+			} else {
+				let appendToPendingNonStandardLines = canWritependingNonStandardLines
+				if (appendToPendingNonStandardLines) {
+					// 处理非标内容
+					this.pendingNonStandardLines.push(line)
+				}
+			}
+		}
+		return removeLineCount
+	}
+
+	private beforeReplace() {
+		// Remove trailing linebreak for adding the === marker
+		// if (currentSearchContent.endsWith("\r\n")) {
+		// 	currentSearchContent = currentSearchContent.slice(0, -2)
+		// } else if (currentSearchContent.endsWith("\n")) {
+		// 	currentSearchContent = currentSearchContent.slice(0, -1)
+		// }
+
+		if (!this.currentSearchContent) {
+			// Empty search block
+			if (this.originalContent.length === 0) {
+				// New file scenario: nothing to match, just start inserting
+				this.searchMatchIndex = 0
+				this.searchEndIndex = 0
+			} else {
+				// Complete file replacement scenario: treat the entire file as matched
+				this.searchMatchIndex = 0
+				this.searchEndIndex = this.originalContent.length
+			}
+		} else {
+			// Add check for inefficient full-file search
+			// if (currentSearchContent.trim() === originalContent.trim()) {
+			// 	throw new Error(
+			// 		"The SEARCH block contains the entire file content. Please either:\n" +
+			// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
+			// 			"2. Make focused changes to specific parts of the file that need modification.",
+			// 	)
+			// }
+			// Exact search match scenario
+			const exactIndex = this.originalContent.indexOf(this.currentSearchContent, this.lastProcessedIndex)
+			if (exactIndex !== -1) {
+				this.searchMatchIndex = exactIndex
+				this.searchEndIndex = exactIndex + this.currentSearchContent.length
+			} else {
+				// Attempt fallback line-trimmed matching
+				const lineMatch = lineTrimmedFallbackMatch(
+					this.originalContent,
+					this.currentSearchContent,
+					this.lastProcessedIndex,
+				)
+				if (lineMatch) {
+					;[this.searchMatchIndex, this.searchEndIndex] = lineMatch
+				} else {
+					// Try block anchor fallback for larger blocks
+					const blockMatch = blockAnchorFallbackMatch(
+						this.originalContent,
+						this.currentSearchContent,
+						this.lastProcessedIndex,
+					)
+					if (blockMatch) {
+						;[this.searchMatchIndex, this.searchEndIndex] = blockMatch
+					} else {
+						throw new Error(
+							`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...does not match anything in the file.`,
+						)
+					}
+				}
+			}
+		}
+		if (this.searchMatchIndex < this.lastProcessedIndex) {
+			throw new Error(
+				`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...matched an incorrect content in the file.`,
+			)
+		}
+		// Output everything up to the match location
+		this.result += this.originalContent.slice(this.lastProcessedIndex, this.searchMatchIndex)
+	}
+
+	private tryFixSearchBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error("Invalid SEARCH/REPLACE block structure - no lines available to process")
+		}
+		let searchTagRegexp = /^[-]{3,} SEARCH$/
+		const searchTagIndex = this.findLastMatchingLineIndex(searchTagRegexp, lineLimit)
+		if (searchTagIndex !== -1) {
+			let fixLines = this.pendingNonStandardLines.slice(searchTagIndex, lineLimit)
+			fixLines[0] = SEARCH_BLOCK_START
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, searchTagIndex)
+			}
+		} else {
+			throw new Error(
+				`Invalid REPLACE marker detected - could not find matching SEARCH block starting from line ${searchTagIndex + 1}`,
+			)
+		}
+		return removeLineCount
+	}
+
+	private tryFixReplaceBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error()
+		}
+		let replaceBeginTagRegexp = /^[=]{3,}$/
+		const replaceBeginTagIndex = this.findLastMatchingLineIndex(replaceBeginTagRegexp, lineLimit)
+		if (replaceBeginTagIndex !== -1) {
+			// // 校验非标内容
+			// if (!this.isSearchingActive()) {
+			// 	removeLineCount += this.tryFixSearchBlock(replaceBeginTagIndex)
+			// }
+			let fixLines = this.pendingNonStandardLines.slice(replaceBeginTagIndex - removeLineCount, lineLimit - removeLineCount)
+			fixLines[0] = SEARCH_BLOCK_END
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, replaceBeginTagIndex - removeLineCount)
+			}
+		} else {
+			throw new Error(`Malformed REPLACE block - missing valid separator after line ${replaceBeginTagIndex + 1}`)
+		}
+		return removeLineCount
+	}
+
+	private tryFixSearchReplaceBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error()
+		}
+
+		let replaceEndTagRegexp = /^[+]{3,} REPLACE$/
+		const replaceEndTagIndex = this.findLastMatchingLineIndex(replaceEndTagRegexp, lineLimit)
+		const likeReplaceEndTag = replaceEndTagIndex === lineLimit - 1
+		if (likeReplaceEndTag) {
+			// // 校验非标内容
+			// if (!this.isReplacingActive()) {
+			// 	removeLineCount += this.tryFixReplaceBlock(replaceEndTagIndex)
+			// }
+			let fixLines = this.pendingNonStandardLines.slice(replaceEndTagIndex - removeLineCount, lineLimit - removeLineCount)
+			fixLines[fixLines.length - 1] = REPLACE_BLOCK_END
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, replaceEndTagIndex - removeLineCount)
+			}
+		} else {
+			throw new Error("Malformed SEARCH/REPLACE block structure: Missing valid closing REPLACE marker")
+		}
+		return removeLineCount
+	}
+
+	/**
+	 * Removes trailing empty lines from the pendingNonStandardLines array
+	 * @param lineLimit - The index to start checking from (exclusive).
+	 *                    Removes empty lines from lineLimit-1 backwards.
+	 * @returns The number of empty lines removed
+	 */
+	private trimPendingNonStandardTrailingEmptyLines(lineLimit: number): number {
+		let removedCount = 0
+		let i = Math.min(lineLimit, this.pendingNonStandardLines.length) - 1
+
+		while (i >= 0 && this.pendingNonStandardLines[i].trim() === "") {
+			this.pendingNonStandardLines.pop()
+			removedCount++
+			i--
+		}
+
+		return removedCount
+	}
+}
+
+export async function constructNewFileContentV2(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
+	let newFileContentConstructor = new NewFileContentConstructor(originalContent, isFinal)
+
+	let lines = diffContent.split("\n")
+
+	// If the last line looks like a partial marker but isn't recognized,
+	// remove it because it might be incomplete.
+	const lastLine = lines[lines.length - 1]
+	if (
+		lines.length > 0 &&
+		(lastLine.startsWith(SEARCH_BLOCK_CHAR) || lastLine.startsWith("=") || lastLine.startsWith(REPLACE_BLOCK_CHAR)) &&
+		lastLine !== SEARCH_BLOCK_START &&
+		lastLine !== SEARCH_BLOCK_END &&
+		lastLine !== REPLACE_BLOCK_END
+	) {
+		lines.pop()
+	}
+
+	for (const line of lines) {
+		newFileContentConstructor.processLine(line)
+	}
+
+	let result = newFileContentConstructor.getResult()
+	return result
+}

evals/diff-edits/diff-apply/diff-06-23-25.ts

@@ -0,0 +1,827 @@
+const SEARCH_BLOCK_START = "------- SEARCH"
+const SEARCH_BLOCK_END = "======="
+const REPLACE_BLOCK_END = "+++++++ REPLACE"
+
+const SEARCH_BLOCK_CHAR = "-"
+const REPLACE_BLOCK_CHAR = "+"
+const LEGACY_SEARCH_BLOCK_CHAR = "<"
+const LEGACY_REPLACE_BLOCK_CHAR = ">"
+
+// Replace the exact string constants with flexible regex patterns
+const SEARCH_BLOCK_START_REGEX = /^[-]{3,} SEARCH$/
+const SEARCH_BLOCK_END_REGEX = /^[=]{3,}$/
+const REPLACE_BLOCK_END_REGEX = /^[+]{3,} REPLACE$/
+const LEGACY_SEARCH_BLOCK_START_REGEX = /^[<]{3,} SEARCH$/
+const LEGACY_REPLACE_BLOCK_END_REGEX = /^[>]{3,} REPLACE$/
+
+// Helper functions to check if a line matches the flexible patterns
+function isSearchBlockStart(line: string): boolean {
+	return SEARCH_BLOCK_START_REGEX.test(line) || LEGACY_SEARCH_BLOCK_START_REGEX.test(line)
+}
+
+function isSearchBlockEnd(line: string): boolean {
+	return SEARCH_BLOCK_END_REGEX.test(line)
+}
+
+function isReplaceBlockEnd(line: string): boolean {
+	return REPLACE_BLOCK_END_REGEX.test(line) || LEGACY_REPLACE_BLOCK_END_REGEX.test(line)
+}
+
+/**
+ * Attempts a line-trimmed fallback match for the given search content in the original content.
+ * It tries to match `searchContent` lines against a block of lines in `originalContent` starting
+ * from `lastProcessedIndex`. Lines are matched by trimming leading/trailing whitespace and ensuring
+ * they are identical afterwards.
+ *
+ * Returns [matchIndexStart, matchIndexEnd] if found, or false if not found.
+ */
+function lineTrimmedFallbackMatch(originalContent: string, searchContent: string, startIndex: number): [number, number] | false {
+	// Split both contents into lines
+	const originalLines = originalContent.split("\n")
+	const searchLines = searchContent.split("\n")
+
+	// Trim trailing empty line if exists (from the trailing \n in searchContent)
+	if (searchLines[searchLines.length - 1] === "") {
+		searchLines.pop()
+	}
+
+	// Find the line number where startIndex falls
+	let startLineNum = 0
+	let currentIndex = 0
+	while (currentIndex < startIndex && startLineNum < originalLines.length) {
+		currentIndex += originalLines[startLineNum].length + 1 // +1 for \n
+		startLineNum++
+	}
+
+	// For each possible starting position in original content
+	for (let i = startLineNum; i <= originalLines.length - searchLines.length; i++) {
+		let matches = true
+
+		// Try to match all search lines from this position
+		for (let j = 0; j < searchLines.length; j++) {
+			const originalTrimmed = originalLines[i + j].trim()
+			const searchTrimmed = searchLines[j].trim()
+
+			if (originalTrimmed !== searchTrimmed) {
+				matches = false
+				break
+			}
+		}
+
+		// If we found a match, calculate the exact character positions
+		if (matches) {
+			// Find start character index
+			let matchStartIndex = 0
+			for (let k = 0; k < i; k++) {
+				matchStartIndex += originalLines[k].length + 1 // +1 for \n
+			}
+
+			// Find end character index
+			let matchEndIndex = matchStartIndex
+			for (let k = 0; k < searchLines.length; k++) {
+				matchEndIndex += originalLines[i + k].length + 1 // +1 for \n
+			}
+
+			return [matchStartIndex, matchEndIndex]
+		}
+	}
+
+	return false
+}
+
+/**
+ * Attempts to match blocks of code by using the first and last lines as anchors.
+ * This is a third-tier fallback strategy that helps match blocks where we can identify
+ * the correct location by matching the beginning and end, even if the exact content
+ * differs slightly.
+ *
+ * The matching strategy:
+ * 1. Only attempts to match blocks of 3 or more lines to avoid false positives
+ * 2. Extracts from the search content:
+ *    - First line as the "start anchor"
+ *    - Last line as the "end anchor"
+ * 3. For each position in the original content:
+ *    - Checks if the next line matches the start anchor
+ *    - If it does, jumps ahead by the search block size
+ *    - Checks if that line matches the end anchor
+ *    - All comparisons are done after trimming whitespace
+ *
+ * This approach is particularly useful for matching blocks of code where:
+ * - The exact content might have minor differences
+ * - The beginning and end of the block are distinctive enough to serve as anchors
+ * - The overall structure (number of lines) remains the same
+ *
+ * @param originalContent - The full content of the original file
+ * @param searchContent - The content we're trying to find in the original file
+ * @param startIndex - The character index in originalContent where to start searching
+ * @returns A tuple of [startIndex, endIndex] if a match is found, false otherwise
+ */
+function blockAnchorFallbackMatch(originalContent: string, searchContent: string, startIndex: number): [number, number] | false {
+	const originalLines = originalContent.split("\n")
+	const searchLines = searchContent.split("\n")
+
+	// Only use this approach for blocks of 3+ lines
+	if (searchLines.length < 3) {
+		return false
+	}
+
+	// Trim trailing empty line if exists
+	if (searchLines[searchLines.length - 1] === "") {
+		searchLines.pop()
+	}
+
+	const firstLineSearch = searchLines[0].trim()
+	const lastLineSearch = searchLines[searchLines.length - 1].trim()
+	const searchBlockSize = searchLines.length
+
+	// Find the line number where startIndex falls
+	let startLineNum = 0
+	let currentIndex = 0
+	while (currentIndex < startIndex && startLineNum < originalLines.length) {
+		currentIndex += originalLines[startLineNum].length + 1
+		startLineNum++
+	}
+
+	// Look for matching start and end anchors
+	for (let i = startLineNum; i <= originalLines.length - searchBlockSize; i++) {
+		// Check if first line matches
+		if (originalLines[i].trim() !== firstLineSearch) {
+			continue
+		}
+
+		// Check if last line matches at the expected position
+		if (originalLines[i + searchBlockSize - 1].trim() !== lastLineSearch) {
+			continue
+		}
+
+		// Calculate exact character positions
+		let matchStartIndex = 0
+		for (let k = 0; k < i; k++) {
+			matchStartIndex += originalLines[k].length + 1
+		}
+
+		let matchEndIndex = matchStartIndex
+		for (let k = 0; k < searchBlockSize; k++) {
+			matchEndIndex += originalLines[i + k].length + 1
+		}
+
+		return [matchStartIndex, matchEndIndex]
+	}
+
+	return false
+}
+
+/**
+ * This function reconstructs the file content by applying a streamed diff (in a
+ * specialized SEARCH/REPLACE block format) to the original file content. It is designed
+ * to handle both incremental updates and the final resulting file after all chunks have
+ * been processed.
+ *
+ * The diff format is a custom structure that uses three markers to define changes:
+ *
+ *   ------- SEARCH
+ *   [Exact content to find in the original file]
+ *   =======
+ *   [Content to replace with]
+ *   +++++++ REPLACE
+ *
+ * Behavior and Assumptions:
+ * 1. The file is processed chunk-by-chunk. Each chunk of `diffContent` may contain
+ *    partial or complete SEARCH/REPLACE blocks. By calling this function with each
+ *    incremental chunk (with `isFinal` indicating the last chunk), the final reconstructed
+ *    file content is produced.
+ *
+ * 2. Matching Strategy (in order of attempt):
+ *    a. Exact Match: First attempts to find the exact SEARCH block text in the original file
+ *    b. Line-Trimmed Match: Falls back to line-by-line comparison ignoring leading/trailing whitespace
+ *    c. Block Anchor Match: For blocks of 3+ lines, tries to match using first/last lines as anchors
+ *    If all matching strategies fail, an error is thrown.
+ *
+ * 3. Empty SEARCH Section:
+ *    - If SEARCH is empty and the original file is empty, this indicates creating a new file
+ *      (pure insertion).
+ *    - If SEARCH is empty and the original file is not empty, this indicates a complete
+ *      file replacement (the entire original content is considered matched and replaced).
+ *
+ * 4. Applying Changes:
+ *    - Before encountering the "=======" marker, lines are accumulated as search content.
+ *    - After "=======" and before ">>>>>>> REPLACE", lines are accumulated as replacement content.
+ *    - Once the block is complete (">>>>>>> REPLACE"), the matched section in the original
+ *      file is replaced with the accumulated replacement lines, and the position in the original
+ *      file is advanced.
+ *
+ * 5. Incremental Output:
+ *    - As soon as the match location is found and we are in the REPLACE section, each new
+ *      replacement line is appended to the result so that partial updates can be viewed
+ *      incrementally.
+ *
+ * 6. Partial Markers:
+ *    - If the final line of the chunk looks like it might be part of a marker but is not one
+ *      of the known markers, it is removed. This prevents incomplete or partial markers
+ *      from corrupting the output.
+ *
+ * 7. Finalization:
+ *    - Once all chunks have been processed (when `isFinal` is true), any remaining original
+ *      content after the last replaced section is appended to the result.
+ *    - Trailing newlines are not forcibly added. The code tries to output exactly what is specified.
+ *
+ * Errors:
+ * - If the search block cannot be matched using any of the available matching strategies,
+ *   an error is thrown.
+ */
+export async function constructNewFileContent(
+	diffContent: string,
+	originalContent: string,
+	isFinal: boolean,
+	version: "v1" | "v2" = "v1",
+): Promise<string> {
+	const constructor = constructNewFileContentVersionMapping[version]
+	if (!constructor) {
+		throw new Error(`Invalid version '${version}' for file content constructor`)
+	}
+	return constructor(diffContent, originalContent, isFinal)
+}
+
+const constructNewFileContentVersionMapping: Record<
+	string,
+	(diffContent: string, originalContent: string, isFinal: boolean) => Promise<string>
+> = {
+	v1: constructNewFileContentV1,
+	v2: constructNewFileContentV2,
+} as const
+
+async function constructNewFileContentV1(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
+	let result = ""
+	let lastProcessedIndex = 0
+
+	let currentSearchContent = ""
+	let currentReplaceContent = ""
+	let inSearch = false
+	let inReplace = false
+
+	let searchMatchIndex = -1
+	let searchEndIndex = -1
+
+	// Track all replacements to handle out-of-order edits
+	let replacements: Array<{ start: number; end: number; content: string }> = []
+	let pendingOutOfOrderReplacement = false
+
+	let lines = diffContent.split("\n")
+
+	// If the last line looks like a partial marker but isn't recognized,
+	// remove it because it might be incomplete.
+	const lastLine = lines[lines.length - 1]
+	if (
+		lines.length > 0 &&
+		(lastLine.startsWith(SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith("=") ||
+			lastLine.startsWith(REPLACE_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_REPLACE_BLOCK_CHAR)) &&
+		!isSearchBlockStart(lastLine) &&
+		!isSearchBlockEnd(lastLine) &&
+		!isReplaceBlockEnd(lastLine)
+	) {
+		lines.pop()
+	}
+
+	for (const line of lines) {
+		if (isSearchBlockStart(line)) {
+			inSearch = true
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			continue
+		}
+
+		if (isSearchBlockEnd(line)) {
+			inSearch = false
+			inReplace = true
+
+			// Remove trailing linebreak for adding the === marker
+			// if (currentSearchContent.endsWith("\r\n")) {
+			// 	currentSearchContent = currentSearchContent.slice(0, -2)
+			// } else if (currentSearchContent.endsWith("\n")) {
+			// 	currentSearchContent = currentSearchContent.slice(0, -1)
+			// }
+
+			if (!currentSearchContent) {
+				// Empty search block
+				if (originalContent.length === 0) {
+					// New file scenario: nothing to match, just start inserting
+					searchMatchIndex = 0
+					searchEndIndex = 0
+				} else {
+					// ERROR: Empty search block with non-empty file indicates malformed SEARCH marker
+					throw new Error(
+						"Empty SEARCH block detected with non-empty file. This usually indicates a malformed SEARCH marker.\n" +
+							"Please ensure your SEARCH marker follows the correct format:\n" +
+							"- Use '------- SEARCH' (7+ dashes + space + SEARCH)\n",
+					)
+				}
+			} else {
+				// Add check for inefficient full-file search
+				// if (currentSearchContent.trim() === originalContent.trim()) {
+				// 	throw new Error(
+				// 		"The SEARCH block contains the entire file content. Please either:\n" +
+				// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
+				// 			"2. Make focused changes to specific parts of the file that need modification.",
+				// 	)
+				// }
+
+				// Exact search match scenario
+				const exactIndex = originalContent.indexOf(currentSearchContent, lastProcessedIndex)
+				if (exactIndex !== -1) {
+					searchMatchIndex = exactIndex
+					searchEndIndex = exactIndex + currentSearchContent.length
+				} else {
+					// Attempt fallback line-trimmed matching
+					const lineMatch = lineTrimmedFallbackMatch(originalContent, currentSearchContent, lastProcessedIndex)
+					if (lineMatch) {
+						;[searchMatchIndex, searchEndIndex] = lineMatch
+					} else {
+						// Try block anchor fallback for larger blocks
+						const blockMatch = blockAnchorFallbackMatch(originalContent, currentSearchContent, lastProcessedIndex)
+						if (blockMatch) {
+							;[searchMatchIndex, searchEndIndex] = blockMatch
+						} else {
+							// Last resort: search the entire file from the beginning
+							const fullFileIndex = originalContent.indexOf(currentSearchContent, 0)
+							if (fullFileIndex !== -1) {
+								// Found in the file - could be out of order
+								searchMatchIndex = fullFileIndex
+								searchEndIndex = fullFileIndex + currentSearchContent.length
+								if (searchMatchIndex < lastProcessedIndex) {
+									pendingOutOfOrderReplacement = true
+								}
+							} else {
+								throw new Error(
+									`The SEARCH block:\n${currentSearchContent.trimEnd()}\n...does not match anything in the file.`,
+								)
+							}
+						}
+					}
+				}
+			}
+
+			// Check if this is an out-of-order replacement
+			if (searchMatchIndex < lastProcessedIndex) {
+				pendingOutOfOrderReplacement = true
+			}
+
+			// For in-order replacements, output everything up to the match location
+			if (!pendingOutOfOrderReplacement) {
+				result += originalContent.slice(lastProcessedIndex, searchMatchIndex)
+			}
+			continue
+		}
+
+		if (isReplaceBlockEnd(line)) {
+			// Finished one replace block
+
+			// Store this replacement
+			replacements.push({
+				start: searchMatchIndex,
+				end: searchEndIndex,
+				content: currentReplaceContent,
+			})
+
+			// If this was an in-order replacement, advance lastProcessedIndex
+			if (!pendingOutOfOrderReplacement) {
+				lastProcessedIndex = searchEndIndex
+			}
+
+			// Reset for next block
+			inSearch = false
+			inReplace = false
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			searchMatchIndex = -1
+			searchEndIndex = -1
+			pendingOutOfOrderReplacement = false
+			continue
+		}
+
+		// Accumulate content for search or replace
+		// (currentReplaceContent is not being used for anything right now since we directly append to result.)
+		// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
+		// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
+		if (inSearch) {
+			currentSearchContent += line + "\n"
+		} else if (inReplace) {
+			currentReplaceContent += line + "\n"
+			// Only output replacement lines immediately for in-order replacements
+			if (searchMatchIndex !== -1 && !pendingOutOfOrderReplacement) {
+				result += line + "\n"
+			}
+		}
+	}
+
+	// If this is the final chunk, we need to apply all replacements and build the final result
+	if (isFinal) {
+		// Handle the case where we're still in replace mode when processing ends
+		// and this is the final chunk - treat it as if we encountered the REPLACE marker
+		if (inReplace && searchMatchIndex !== -1) {
+			// Store this replacement
+			replacements.push({
+				start: searchMatchIndex,
+				end: searchEndIndex,
+				content: currentReplaceContent,
+			})
+
+			// If this was an in-order replacement, advance lastProcessedIndex
+			if (!pendingOutOfOrderReplacement) {
+				lastProcessedIndex = searchEndIndex
+			}
+
+			// Reset state
+			inSearch = false
+			inReplace = false
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			searchMatchIndex = -1
+			searchEndIndex = -1
+			pendingOutOfOrderReplacement = false
+		}
+		// end of handling missing replace marker
+
+		// Sort replacements by start position
+		replacements.sort((a, b) => a.start - b.start)
+
+		// Rebuild the entire result by applying all replacements
+		result = ""
+		let currentPos = 0
+
+		for (const replacement of replacements) {
+			// Add original content up to this replacement
+			result += originalContent.slice(currentPos, replacement.start)
+			// Add the replacement content
+			result += replacement.content
+			// Move position to after the replaced section
+			currentPos = replacement.end
+		}
+
+		// Add any remaining original content
+		result += originalContent.slice(currentPos)
+	}
+
+	return result
+}
+
+enum ProcessingState {
+	Idle = 0,
+	StateSearch = 1 << 0,
+	StateReplace = 1 << 1,
+}
+
+class NewFileContentConstructor {
+	private originalContent: string
+	private isFinal: boolean
+	private state: number
+	private pendingNonStandardLines: string[]
+	private result: string
+	private lastProcessedIndex: number
+	private currentSearchContent: string
+	private currentReplaceContent: string
+	private searchMatchIndex: number
+	private searchEndIndex: number
+
+	constructor(originalContent: string, isFinal: boolean) {
+		this.originalContent = originalContent
+		this.isFinal = isFinal
+		this.pendingNonStandardLines = []
+		this.result = ""
+		this.lastProcessedIndex = 0
+		this.state = ProcessingState.Idle
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+		this.searchMatchIndex = -1
+		this.searchEndIndex = -1
+	}
+
+	private resetForNextBlock() {
+		// Reset for next block
+		this.state = ProcessingState.Idle
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+		this.searchMatchIndex = -1
+		this.searchEndIndex = -1
+	}
+
+	private findLastMatchingLineIndex(regx: RegExp, lineLimit: number) {
+		for (let i = lineLimit; i > 0; ) {
+			i--
+			if (this.pendingNonStandardLines[i].match(regx)) {
+				return i
+			}
+		}
+		return -1
+	}
+
+	private updateProcessingState(newState: ProcessingState) {
+		const isValidTransition =
+			(this.state === ProcessingState.Idle && newState === ProcessingState.StateSearch) ||
+			(this.state === ProcessingState.StateSearch && newState === ProcessingState.StateReplace)
+
+		if (!isValidTransition) {
+			throw new Error(
+				`Invalid state transition.\n` +
+					"Valid transitions are:\n" +
+					"- Idle → StateSearch\n" +
+					"- StateSearch → StateReplace",
+			)
+		}
+
+		this.state |= newState
+	}
+
+	private isStateActive(state: ProcessingState): boolean {
+		return (this.state & state) === state
+	}
+
+	private activateReplaceState() {
+		this.updateProcessingState(ProcessingState.StateReplace)
+	}
+
+	private activateSearchState() {
+		this.updateProcessingState(ProcessingState.StateSearch)
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+	}
+
+	private isSearchingActive(): boolean {
+		return this.isStateActive(ProcessingState.StateSearch)
+	}
+
+	private isReplacingActive(): boolean {
+		return this.isStateActive(ProcessingState.StateReplace)
+	}
+
+	private hasPendingNonStandardLines(pendingNonStandardLineLimit: number): boolean {
+		return this.pendingNonStandardLines.length - pendingNonStandardLineLimit < this.pendingNonStandardLines.length
+	}
+
+	public processLine(line: string) {
+		this.internalProcessLine(line, true, this.pendingNonStandardLines.length)
+	}
+
+	public getResult() {
+		// If this is the final chunk, append any remaining original content
+		if (this.isFinal && this.lastProcessedIndex < this.originalContent.length) {
+			this.result += this.originalContent.slice(this.lastProcessedIndex)
+		}
+		if (this.isFinal && this.state !== ProcessingState.Idle) {
+			throw new Error("File processing incomplete - SEARCH/REPLACE operations still active during finalization")
+		}
+		return this.result
+	}
+
+	private internalProcessLine(
+		line: string,
+		canWritependingNonStandardLines: boolean,
+		pendingNonStandardLineLimit: number,
+	): number {
+		let removeLineCount = 0
+		if (isSearchBlockStart(line)) {
+			removeLineCount = this.trimPendingNonStandardTrailingEmptyLines(pendingNonStandardLineLimit)
+			if (removeLineCount > 0) {
+				pendingNonStandardLineLimit = pendingNonStandardLineLimit - removeLineCount
+			}
+			if (this.hasPendingNonStandardLines(pendingNonStandardLineLimit)) {
+				this.tryFixSearchReplaceBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.activateSearchState()
+		} else if (isSearchBlockEnd(line)) {
+			// 校验非标内容
+			if (!this.isSearchingActive()) {
+				this.tryFixSearchBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.activateReplaceState()
+			this.beforeReplace()
+		} else if (isReplaceBlockEnd(line)) {
+			if (!this.isReplacingActive()) {
+				this.tryFixReplaceBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.lastProcessedIndex = this.searchEndIndex
+			this.resetForNextBlock()
+		} else {
+			// Accumulate content for search or replace
+			// (currentReplaceContent is not being used for anything right now since we directly append to result.)
+			// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
+			// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
+			if (this.isReplacingActive()) {
+				this.currentReplaceContent += line + "\n"
+				// Output replacement lines immediately if we know the insertion point
+				if (this.searchMatchIndex !== -1) {
+					this.result += line + "\n"
+				}
+			} else if (this.isSearchingActive()) {
+				this.currentSearchContent += line + "\n"
+			} else {
+				let appendToPendingNonStandardLines = canWritependingNonStandardLines
+				if (appendToPendingNonStandardLines) {
+					// 处理非标内容
+					this.pendingNonStandardLines.push(line)
+				}
+			}
+		}
+		return removeLineCount
+	}
+
+	private beforeReplace() {
+		// Remove trailing linebreak for adding the === marker
+		// if (currentSearchContent.endsWith("\r\n")) {
+		// 	currentSearchContent = currentSearchContent.slice(0, -2)
+		// } else if (currentSearchContent.endsWith("\n")) {
+		// 	currentSearchContent = currentSearchContent.slice(0, -1)
+		// }
+
+		if (!this.currentSearchContent) {
+			// Empty search block
+			if (this.originalContent.length === 0) {
+				// New file scenario: nothing to match, just start inserting
+				this.searchMatchIndex = 0
+				this.searchEndIndex = 0
+			} else {
+				// Complete file replacement scenario: treat the entire file as matched
+				this.searchMatchIndex = 0
+				this.searchEndIndex = this.originalContent.length
+			}
+		} else {
+			// Add check for inefficient full-file search
+			// if (currentSearchContent.trim() === originalContent.trim()) {
+			// 	throw new Error(
+			// 		"The SEARCH block contains the entire file content. Please either:\n" +
+			// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
+			// 			"2. Make focused changes to specific parts of the file that need modification.",
+			// 	)
+			// }
+			// Exact search match scenario
+			const exactIndex = this.originalContent.indexOf(this.currentSearchContent, this.lastProcessedIndex)
+			if (exactIndex !== -1) {
+				this.searchMatchIndex = exactIndex
+				this.searchEndIndex = exactIndex + this.currentSearchContent.length
+			} else {
+				// Attempt fallback line-trimmed matching
+				const lineMatch = lineTrimmedFallbackMatch(
+					this.originalContent,
+					this.currentSearchContent,
+					this.lastProcessedIndex,
+				)
+				if (lineMatch) {
+					;[this.searchMatchIndex, this.searchEndIndex] = lineMatch
+				} else {
+					// Try block anchor fallback for larger blocks
+					const blockMatch = blockAnchorFallbackMatch(
+						this.originalContent,
+						this.currentSearchContent,
+						this.lastProcessedIndex,
+					)
+					if (blockMatch) {
+						;[this.searchMatchIndex, this.searchEndIndex] = blockMatch
+					} else {
+						throw new Error(
+							`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...does not match anything in the file.`,
+						)
+					}
+				}
+			}
+		}
+		if (this.searchMatchIndex < this.lastProcessedIndex) {
+			throw new Error(
+				`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...matched an incorrect content in the file.`,
+			)
+		}
+		// Output everything up to the match location
+		this.result += this.originalContent.slice(this.lastProcessedIndex, this.searchMatchIndex)
+	}
+
+	private tryFixSearchBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error("Invalid SEARCH/REPLACE block structure - no lines available to process")
+		}
+		let searchTagRegexp = /^([-]{3,}|[<]{3,}) SEARCH$/
+		const searchTagIndex = this.findLastMatchingLineIndex(searchTagRegexp, lineLimit)
+		if (searchTagIndex !== -1) {
+			let fixLines = this.pendingNonStandardLines.slice(searchTagIndex, lineLimit)
+			fixLines[0] = SEARCH_BLOCK_START
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, searchTagIndex)
+			}
+		} else {
+			throw new Error(
+				`Invalid REPLACE marker detected - could not find matching SEARCH block starting from line ${searchTagIndex + 1}`,
+			)
+		}
+		return removeLineCount
+	}
+
+	private tryFixReplaceBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error()
+		}
+		let replaceBeginTagRegexp = /^[=]{3,}$/
+		const replaceBeginTagIndex = this.findLastMatchingLineIndex(replaceBeginTagRegexp, lineLimit)
+		if (replaceBeginTagIndex !== -1) {
+			// // 校验非标内容
+			// if (!this.isSearchingActive()) {
+			// 	removeLineCount += this.tryFixSearchBlock(replaceBeginTagIndex)
+			// }
+			let fixLines = this.pendingNonStandardLines.slice(replaceBeginTagIndex - removeLineCount, lineLimit - removeLineCount)
+			fixLines[0] = SEARCH_BLOCK_END
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, replaceBeginTagIndex - removeLineCount)
+			}
+		} else {
+			throw new Error(`Malformed REPLACE block - missing valid separator after line ${replaceBeginTagIndex + 1}`)
+		}
+		return removeLineCount
+	}
+
+	private tryFixSearchReplaceBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error()
+		}
+
+		let replaceEndTagRegexp = /^([+]{3,}|[>]{3,}) REPLACE$/
+		const replaceEndTagIndex = this.findLastMatchingLineIndex(replaceEndTagRegexp, lineLimit)
+		const likeReplaceEndTag = replaceEndTagIndex === lineLimit - 1
+		if (likeReplaceEndTag) {
+			// // 校验非标内容
+			// if (!this.isReplacingActive()) {
+			// 	removeLineCount += this.tryFixReplaceBlock(replaceEndTagIndex)
+			// }
+			let fixLines = this.pendingNonStandardLines.slice(replaceEndTagIndex - removeLineCount, lineLimit - removeLineCount)
+			fixLines[fixLines.length - 1] = REPLACE_BLOCK_END
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, replaceEndTagIndex - removeLineCount)
+			}
+		} else {
+			throw new Error("Malformed SEARCH/REPLACE block structure: Missing valid closing REPLACE marker")
+		}
+		return removeLineCount
+	}
+
+	/**
+	 * Removes trailing empty lines from the pendingNonStandardLines array
+	 * @param lineLimit - The index to start checking from (exclusive).
+	 *                    Removes empty lines from lineLimit-1 backwards.
+	 * @returns The number of empty lines removed
+	 */
+	private trimPendingNonStandardTrailingEmptyLines(lineLimit: number): number {
+		let removedCount = 0
+		let i = Math.min(lineLimit, this.pendingNonStandardLines.length) - 1
+
+		while (i >= 0 && this.pendingNonStandardLines[i].trim() === "") {
+			this.pendingNonStandardLines.pop()
+			removedCount++
+			i--
+		}
+
+		return removedCount
+	}
+}
+
+export async function constructNewFileContentV2(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
+	let newFileContentConstructor = new NewFileContentConstructor(originalContent, isFinal)
+
+	let lines = diffContent.split("\n")
+
+	// If the last line looks like a partial marker but isn't recognized,
+	// remove it because it might be incomplete.
+	const lastLine = lines[lines.length - 1]
+	if (
+		lines.length > 0 &&
+		(lastLine.startsWith(SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith("=") ||
+			lastLine.startsWith(REPLACE_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_REPLACE_BLOCK_CHAR)) &&
+		lastLine !== SEARCH_BLOCK_START &&
+		lastLine !== SEARCH_BLOCK_END &&
+		lastLine !== REPLACE_BLOCK_END
+	) {
+		lines.pop()
+	}
+
+	for (const line of lines) {
+		newFileContentConstructor.processLine(line)
+	}
+
+	let result = newFileContentConstructor.getResult()
+	return result
+}

evals/diff-edits/diff-apply/diff-06-25-25.ts

@@ -0,0 +1,829 @@
+const SEARCH_BLOCK_START = "------- SEARCH"
+const SEARCH_BLOCK_END = "======="
+const REPLACE_BLOCK_END = "+++++++ REPLACE"
+
+const SEARCH_BLOCK_CHAR = "-"
+const REPLACE_BLOCK_CHAR = "+"
+const LEGACY_SEARCH_BLOCK_CHAR = "<"
+const LEGACY_REPLACE_BLOCK_CHAR = ">"
+
+// Replace the exact string constants with flexible regex patterns
+const SEARCH_BLOCK_START_REGEX = /^[-]{3,} SEARCH>?$/
+const LEGACY_SEARCH_BLOCK_START_REGEX = /^[<]{3,} SEARCH>?$/
+
+const SEARCH_BLOCK_END_REGEX = /^[=]{3,}$/
+
+const REPLACE_BLOCK_END_REGEX = /^[+]{3,} REPLACE>?$/
+const LEGACY_REPLACE_BLOCK_END_REGEX = /^[>]{3,} REPLACE>?$/
+
+// Helper functions to check if a line matches the flexible patterns
+function isSearchBlockStart(line: string): boolean {
+	return SEARCH_BLOCK_START_REGEX.test(line) || LEGACY_SEARCH_BLOCK_START_REGEX.test(line)
+}
+
+function isSearchBlockEnd(line: string): boolean {
+	return SEARCH_BLOCK_END_REGEX.test(line)
+}
+
+function isReplaceBlockEnd(line: string): boolean {
+	return REPLACE_BLOCK_END_REGEX.test(line) || LEGACY_REPLACE_BLOCK_END_REGEX.test(line)
+}
+
+/**
+ * Attempts a line-trimmed fallback match for the given search content in the original content.
+ * It tries to match `searchContent` lines against a block of lines in `originalContent` starting
+ * from `lastProcessedIndex`. Lines are matched by trimming leading/trailing whitespace and ensuring
+ * they are identical afterwards.
+ *
+ * Returns [matchIndexStart, matchIndexEnd] if found, or false if not found.
+ */
+function lineTrimmedFallbackMatch(originalContent: string, searchContent: string, startIndex: number): [number, number] | false {
+	// Split both contents into lines
+	const originalLines = originalContent.split("\n")
+	const searchLines = searchContent.split("\n")
+
+	// Trim trailing empty line if exists (from the trailing \n in searchContent)
+	if (searchLines[searchLines.length - 1] === "") {
+		searchLines.pop()
+	}
+
+	// Find the line number where startIndex falls
+	let startLineNum = 0
+	let currentIndex = 0
+	while (currentIndex < startIndex && startLineNum < originalLines.length) {
+		currentIndex += originalLines[startLineNum].length + 1 // +1 for \n
+		startLineNum++
+	}
+
+	// For each possible starting position in original content
+	for (let i = startLineNum; i <= originalLines.length - searchLines.length; i++) {
+		let matches = true
+
+		// Try to match all search lines from this position
+		for (let j = 0; j < searchLines.length; j++) {
+			const originalTrimmed = originalLines[i + j].trim()
+			const searchTrimmed = searchLines[j].trim()
+
+			if (originalTrimmed !== searchTrimmed) {
+				matches = false
+				break
+			}
+		}
+
+		// If we found a match, calculate the exact character positions
+		if (matches) {
+			// Find start character index
+			let matchStartIndex = 0
+			for (let k = 0; k < i; k++) {
+				matchStartIndex += originalLines[k].length + 1 // +1 for \n
+			}
+
+			// Find end character index
+			let matchEndIndex = matchStartIndex
+			for (let k = 0; k < searchLines.length; k++) {
+				matchEndIndex += originalLines[i + k].length + 1 // +1 for \n
+			}
+
+			return [matchStartIndex, matchEndIndex]
+		}
+	}
+
+	return false
+}
+
+/**
+ * Attempts to match blocks of code by using the first and last lines as anchors.
+ * This is a third-tier fallback strategy that helps match blocks where we can identify
+ * the correct location by matching the beginning and end, even if the exact content
+ * differs slightly.
+ *
+ * The matching strategy:
+ * 1. Only attempts to match blocks of 3 or more lines to avoid false positives
+ * 2. Extracts from the search content:
+ *    - First line as the "start anchor"
+ *    - Last line as the "end anchor"
+ * 3. For each position in the original content:
+ *    - Checks if the next line matches the start anchor
+ *    - If it does, jumps ahead by the search block size
+ *    - Checks if that line matches the end anchor
+ *    - All comparisons are done after trimming whitespace
+ *
+ * This approach is particularly useful for matching blocks of code where:
+ * - The exact content might have minor differences
+ * - The beginning and end of the block are distinctive enough to serve as anchors
+ * - The overall structure (number of lines) remains the same
+ *
+ * @param originalContent - The full content of the original file
+ * @param searchContent - The content we're trying to find in the original file
+ * @param startIndex - The character index in originalContent where to start searching
+ * @returns A tuple of [startIndex, endIndex] if a match is found, false otherwise
+ */
+function blockAnchorFallbackMatch(originalContent: string, searchContent: string, startIndex: number): [number, number] | false {
+	const originalLines = originalContent.split("\n")
+	const searchLines = searchContent.split("\n")
+
+	// Only use this approach for blocks of 3+ lines
+	if (searchLines.length < 3) {
+		return false
+	}
+
+	// Trim trailing empty line if exists
+	if (searchLines[searchLines.length - 1] === "") {
+		searchLines.pop()
+	}
+
+	const firstLineSearch = searchLines[0].trim()
+	const lastLineSearch = searchLines[searchLines.length - 1].trim()
+	const searchBlockSize = searchLines.length
+
+	// Find the line number where startIndex falls
+	let startLineNum = 0
+	let currentIndex = 0
+	while (currentIndex < startIndex && startLineNum < originalLines.length) {
+		currentIndex += originalLines[startLineNum].length + 1
+		startLineNum++
+	}
+
+	// Look for matching start and end anchors
+	for (let i = startLineNum; i <= originalLines.length - searchBlockSize; i++) {
+		// Check if first line matches
+		if (originalLines[i].trim() !== firstLineSearch) {
+			continue
+		}
+
+		// Check if last line matches at the expected position
+		if (originalLines[i + searchBlockSize - 1].trim() !== lastLineSearch) {
+			continue
+		}
+
+		// Calculate exact character positions
+		let matchStartIndex = 0
+		for (let k = 0; k < i; k++) {
+			matchStartIndex += originalLines[k].length + 1
+		}
+
+		let matchEndIndex = matchStartIndex
+		for (let k = 0; k < searchBlockSize; k++) {
+			matchEndIndex += originalLines[i + k].length + 1
+		}
+
+		return [matchStartIndex, matchEndIndex]
+	}
+
+	return false
+}
+
+/**
+ * This function reconstructs the file content by applying a streamed diff (in a
+ * specialized SEARCH/REPLACE block format) to the original file content. It is designed
+ * to handle both incremental updates and the final resulting file after all chunks have
+ * been processed.
+ *
+ * The diff format is a custom structure that uses three markers to define changes:
+ *
+ *   ------- SEARCH
+ *   [Exact content to find in the original file]
+ *   =======
+ *   [Content to replace with]
+ *   +++++++ REPLACE
+ *
+ * Behavior and Assumptions:
+ * 1. The file is processed chunk-by-chunk. Each chunk of `diffContent` may contain
+ *    partial or complete SEARCH/REPLACE blocks. By calling this function with each
+ *    incremental chunk (with `isFinal` indicating the last chunk), the final reconstructed
+ *    file content is produced.
+ *
+ * 2. Matching Strategy (in order of attempt):
+ *    a. Exact Match: First attempts to find the exact SEARCH block text in the original file
+ *    b. Line-Trimmed Match: Falls back to line-by-line comparison ignoring leading/trailing whitespace
+ *    c. Block Anchor Match: For blocks of 3+ lines, tries to match using first/last lines as anchors
+ *    If all matching strategies fail, an error is thrown.
+ *
+ * 3. Empty SEARCH Section:
+ *    - If SEARCH is empty and the original file is empty, this indicates creating a new file
+ *      (pure insertion).
+ *    - If SEARCH is empty and the original file is not empty, this indicates a complete
+ *      file replacement (the entire original content is considered matched and replaced).
+ *
+ * 4. Applying Changes:
+ *    - Before encountering the "=======" marker, lines are accumulated as search content.
+ *    - After "=======" and before ">>>>>>> REPLACE", lines are accumulated as replacement content.
+ *    - Once the block is complete (">>>>>>> REPLACE"), the matched section in the original
+ *      file is replaced with the accumulated replacement lines, and the position in the original
+ *      file is advanced.
+ *
+ * 5. Incremental Output:
+ *    - As soon as the match location is found and we are in the REPLACE section, each new
+ *      replacement line is appended to the result so that partial updates can be viewed
+ *      incrementally.
+ *
+ * 6. Partial Markers:
+ *    - If the final line of the chunk looks like it might be part of a marker but is not one
+ *      of the known markers, it is removed. This prevents incomplete or partial markers
+ *      from corrupting the output.
+ *
+ * 7. Finalization:
+ *    - Once all chunks have been processed (when `isFinal` is true), any remaining original
+ *      content after the last replaced section is appended to the result.
+ *    - Trailing newlines are not forcibly added. The code tries to output exactly what is specified.
+ *
+ * Errors:
+ * - If the search block cannot be matched using any of the available matching strategies,
+ *   an error is thrown.
+ */
+export async function constructNewFileContent(
+	diffContent: string,
+	originalContent: string,
+	isFinal: boolean,
+	version: "v1" | "v2" = "v1",
+): Promise<string> {
+	const constructor = constructNewFileContentVersionMapping[version]
+	if (!constructor) {
+		throw new Error(`Invalid version '${version}' for file content constructor`)
+	}
+	return constructor(diffContent, originalContent, isFinal)
+}
+
+const constructNewFileContentVersionMapping: Record<
+	string,
+	(diffContent: string, originalContent: string, isFinal: boolean) => Promise<string>
+> = {
+	v1: constructNewFileContentV1,
+	v2: constructNewFileContentV2,
+} as const
+
+async function constructNewFileContentV1(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
+	let result = ""
+	let lastProcessedIndex = 0
+
+	let currentSearchContent = ""
+	let currentReplaceContent = ""
+	let inSearch = false
+	let inReplace = false
+
+	let searchMatchIndex = -1
+	let searchEndIndex = -1
+
+	// Track all replacements to handle out-of-order edits
+	let replacements: Array<{ start: number; end: number; content: string }> = []
+	let pendingOutOfOrderReplacement = false
+
+	let lines = diffContent.split("\n")
+
+	// If the last line looks like a partial marker but isn't recognized,
+	// remove it because it might be incomplete.
+	const lastLine = lines[lines.length - 1]
+	if (
+		lines.length > 0 &&
+		(lastLine.startsWith(SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith("=") ||
+			lastLine.startsWith(REPLACE_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_REPLACE_BLOCK_CHAR)) &&
+		!isSearchBlockStart(lastLine) &&
+		!isSearchBlockEnd(lastLine) &&
+		!isReplaceBlockEnd(lastLine)
+	) {
+		lines.pop()
+	}
+
+	for (const line of lines) {
+		if (isSearchBlockStart(line)) {
+			inSearch = true
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			continue
+		}
+
+		if (isSearchBlockEnd(line)) {
+			inSearch = false
+			inReplace = true
+
+			// Remove trailing linebreak for adding the === marker
+			// if (currentSearchContent.endsWith("\r\n")) {
+			// 	currentSearchContent = currentSearchContent.slice(0, -2)
+			// } else if (currentSearchContent.endsWith("\n")) {
+			// 	currentSearchContent = currentSearchContent.slice(0, -1)
+			// }
+
+			if (!currentSearchContent) {
+				// Empty search block
+				if (originalContent.length === 0) {
+					// New file scenario: nothing to match, just start inserting
+					searchMatchIndex = 0
+					searchEndIndex = 0
+				} else {
+					// ERROR: Empty search block with non-empty file indicates malformed SEARCH marker
+					throw new Error(
+						"Empty SEARCH block detected with non-empty file. This usually indicates a malformed SEARCH marker.\n" +
+							"Please ensure your SEARCH marker follows the correct format:\n" +
+							"- Use '------- SEARCH' (7+ dashes + space + SEARCH)\n",
+					)
+				}
+			} else {
+				// Add check for inefficient full-file search
+				// if (currentSearchContent.trim() === originalContent.trim()) {
+				// 	throw new Error(
+				// 		"The SEARCH block contains the entire file content. Please either:\n" +
+				// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
+				// 			"2. Make focused changes to specific parts of the file that need modification.",
+				// 	)
+				// }
+
+				// Exact search match scenario
+				const exactIndex = originalContent.indexOf(currentSearchContent, lastProcessedIndex)
+				if (exactIndex !== -1) {
+					searchMatchIndex = exactIndex
+					searchEndIndex = exactIndex + currentSearchContent.length
+				} else {
+					// Attempt fallback line-trimmed matching
+					const lineMatch = lineTrimmedFallbackMatch(originalContent, currentSearchContent, lastProcessedIndex)
+					if (lineMatch) {
+						;[searchMatchIndex, searchEndIndex] = lineMatch
+					} else {
+						// Try block anchor fallback for larger blocks
+						const blockMatch = blockAnchorFallbackMatch(originalContent, currentSearchContent, lastProcessedIndex)
+						if (blockMatch) {
+							;[searchMatchIndex, searchEndIndex] = blockMatch
+						} else {
+							// Last resort: search the entire file from the beginning
+							const fullFileIndex = originalContent.indexOf(currentSearchContent, 0)
+							if (fullFileIndex !== -1) {
+								// Found in the file - could be out of order
+								searchMatchIndex = fullFileIndex
+								searchEndIndex = fullFileIndex + currentSearchContent.length
+								if (searchMatchIndex < lastProcessedIndex) {
+									pendingOutOfOrderReplacement = true
+								}
+							} else {
+								throw new Error(
+									`The SEARCH block:\n${currentSearchContent.trimEnd()}\n...does not match anything in the file.`,
+								)
+							}
+						}
+					}
+				}
+			}
+
+			// Check if this is an out-of-order replacement
+			if (searchMatchIndex < lastProcessedIndex) {
+				pendingOutOfOrderReplacement = true
+			}
+
+			// For in-order replacements, output everything up to the match location
+			if (!pendingOutOfOrderReplacement) {
+				result += originalContent.slice(lastProcessedIndex, searchMatchIndex)
+			}
+			continue
+		}
+
+		if (isReplaceBlockEnd(line)) {
+			// Finished one replace block
+
+			// Store this replacement
+			replacements.push({
+				start: searchMatchIndex,
+				end: searchEndIndex,
+				content: currentReplaceContent,
+			})
+
+			// If this was an in-order replacement, advance lastProcessedIndex
+			if (!pendingOutOfOrderReplacement) {
+				lastProcessedIndex = searchEndIndex
+			}
+
+			// Reset for next block
+			inSearch = false
+			inReplace = false
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			searchMatchIndex = -1
+			searchEndIndex = -1
+			pendingOutOfOrderReplacement = false
+			continue
+		}
+
+		// Accumulate content for search or replace
+		// (currentReplaceContent is not being used for anything right now since we directly append to result.)
+		// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
+		// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
+		if (inSearch) {
+			currentSearchContent += line + "\n"
+		} else if (inReplace) {
+			currentReplaceContent += line + "\n"
+			// Only output replacement lines immediately for in-order replacements
+			if (searchMatchIndex !== -1 && !pendingOutOfOrderReplacement) {
+				result += line + "\n"
+			}
+		}
+	}
+
+	// If this is the final chunk, we need to apply all replacements and build the final result
+	if (isFinal) {
+		// Handle the case where we're still in replace mode when processing ends
+		// and this is the final chunk - treat it as if we encountered the REPLACE marker
+		if (inReplace && searchMatchIndex !== -1) {
+			// Store this replacement
+			replacements.push({
+				start: searchMatchIndex,
+				end: searchEndIndex,
+				content: currentReplaceContent,
+			})
+
+			// If this was an in-order replacement, advance lastProcessedIndex
+			if (!pendingOutOfOrderReplacement) {
+				lastProcessedIndex = searchEndIndex
+			}
+
+			// Reset state
+			inSearch = false
+			inReplace = false
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			searchMatchIndex = -1
+			searchEndIndex = -1
+			pendingOutOfOrderReplacement = false
+		}
+		// end of handling missing replace marker
+
+		// Sort replacements by start position
+		replacements.sort((a, b) => a.start - b.start)
+
+		// Rebuild the entire result by applying all replacements
+		result = ""
+		let currentPos = 0
+
+		for (const replacement of replacements) {
+			// Add original content up to this replacement
+			result += originalContent.slice(currentPos, replacement.start)
+			// Add the replacement content
+			result += replacement.content
+			// Move position to after the replaced section
+			currentPos = replacement.end
+		}
+
+		// Add any remaining original content
+		result += originalContent.slice(currentPos)
+	}
+
+	return result
+}
+
+enum ProcessingState {
+	Idle = 0,
+	StateSearch = 1 << 0,
+	StateReplace = 1 << 1,
+}
+
+class NewFileContentConstructor {
+	private originalContent: string
+	private isFinal: boolean
+	private state: number
+	private pendingNonStandardLines: string[]
+	private result: string
+	private lastProcessedIndex: number
+	private currentSearchContent: string
+	private currentReplaceContent: string
+	private searchMatchIndex: number
+	private searchEndIndex: number
+
+	constructor(originalContent: string, isFinal: boolean) {
+		this.originalContent = originalContent
+		this.isFinal = isFinal
+		this.pendingNonStandardLines = []
+		this.result = ""
+		this.lastProcessedIndex = 0
+		this.state = ProcessingState.Idle
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+		this.searchMatchIndex = -1
+		this.searchEndIndex = -1
+	}
+
+	private resetForNextBlock() {
+		// Reset for next block
+		this.state = ProcessingState.Idle
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+		this.searchMatchIndex = -1
+		this.searchEndIndex = -1
+	}
+
+	private findLastMatchingLineIndex(regx: RegExp, lineLimit: number) {
+		for (let i = lineLimit; i > 0; ) {
+			i--
+			if (this.pendingNonStandardLines[i].match(regx)) {
+				return i
+			}
+		}
+		return -1
+	}
+
+	private updateProcessingState(newState: ProcessingState) {
+		const isValidTransition =
+			(this.state === ProcessingState.Idle && newState === ProcessingState.StateSearch) ||
+			(this.state === ProcessingState.StateSearch && newState === ProcessingState.StateReplace)
+
+		if (!isValidTransition) {
+			throw new Error(
+				`Invalid state transition.\n` +
+					"Valid transitions are:\n" +
+					"- Idle → StateSearch\n" +
+					"- StateSearch → StateReplace",
+			)
+		}
+
+		this.state |= newState
+	}
+
+	private isStateActive(state: ProcessingState): boolean {
+		return (this.state & state) === state
+	}
+
+	private activateReplaceState() {
+		this.updateProcessingState(ProcessingState.StateReplace)
+	}
+
+	private activateSearchState() {
+		this.updateProcessingState(ProcessingState.StateSearch)
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+	}
+
+	private isSearchingActive(): boolean {
+		return this.isStateActive(ProcessingState.StateSearch)
+	}
+
+	private isReplacingActive(): boolean {
+		return this.isStateActive(ProcessingState.StateReplace)
+	}
+
+	private hasPendingNonStandardLines(pendingNonStandardLineLimit: number): boolean {
+		return this.pendingNonStandardLines.length - pendingNonStandardLineLimit < this.pendingNonStandardLines.length
+	}
+
+	public processLine(line: string) {
+		this.internalProcessLine(line, true, this.pendingNonStandardLines.length)
+	}
+
+	public getResult() {
+		// If this is the final chunk, append any remaining original content
+		if (this.isFinal && this.lastProcessedIndex < this.originalContent.length) {
+			this.result += this.originalContent.slice(this.lastProcessedIndex)
+		}
+		if (this.isFinal && this.state !== ProcessingState.Idle) {
+			throw new Error("File processing incomplete - SEARCH/REPLACE operations still active during finalization")
+		}
+		return this.result
+	}
+
+	private internalProcessLine(
+		line: string,
+		canWritependingNonStandardLines: boolean,
+		pendingNonStandardLineLimit: number,
+	): number {
+		let removeLineCount = 0
+		if (isSearchBlockStart(line)) {
+			removeLineCount = this.trimPendingNonStandardTrailingEmptyLines(pendingNonStandardLineLimit)
+			if (removeLineCount > 0) {
+				pendingNonStandardLineLimit = pendingNonStandardLineLimit - removeLineCount
+			}
+			if (this.hasPendingNonStandardLines(pendingNonStandardLineLimit)) {
+				this.tryFixSearchReplaceBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.activateSearchState()
+		} else if (isSearchBlockEnd(line)) {
+			// 校验非标内容
+			if (!this.isSearchingActive()) {
+				this.tryFixSearchBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.activateReplaceState()
+			this.beforeReplace()
+		} else if (isReplaceBlockEnd(line)) {
+			if (!this.isReplacingActive()) {
+				this.tryFixReplaceBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.lastProcessedIndex = this.searchEndIndex
+			this.resetForNextBlock()
+		} else {
+			// Accumulate content for search or replace
+			// (currentReplaceContent is not being used for anything right now since we directly append to result.)
+			// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
+			// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
+			if (this.isReplacingActive()) {
+				this.currentReplaceContent += line + "\n"
+				// Output replacement lines immediately if we know the insertion point
+				if (this.searchMatchIndex !== -1) {
+					this.result += line + "\n"
+				}
+			} else if (this.isSearchingActive()) {
+				this.currentSearchContent += line + "\n"
+			} else {
+				let appendToPendingNonStandardLines = canWritependingNonStandardLines
+				if (appendToPendingNonStandardLines) {
+					// 处理非标内容
+					this.pendingNonStandardLines.push(line)
+				}
+			}
+		}
+		return removeLineCount
+	}
+
+	private beforeReplace() {
+		// Remove trailing linebreak for adding the === marker
+		// if (currentSearchContent.endsWith("\r\n")) {
+		// 	currentSearchContent = currentSearchContent.slice(0, -2)
+		// } else if (currentSearchContent.endsWith("\n")) {
+		// 	currentSearchContent = currentSearchContent.slice(0, -1)
+		// }
+
+		if (!this.currentSearchContent) {
+			// Empty search block
+			if (this.originalContent.length === 0) {
+				// New file scenario: nothing to match, just start inserting
+				this.searchMatchIndex = 0
+				this.searchEndIndex = 0
+			} else {
+				// Complete file replacement scenario: treat the entire file as matched
+				this.searchMatchIndex = 0
+				this.searchEndIndex = this.originalContent.length
+			}
+		} else {
+			// Add check for inefficient full-file search
+			// if (currentSearchContent.trim() === originalContent.trim()) {
+			// 	throw new Error(
+			// 		"The SEARCH block contains the entire file content. Please either:\n" +
+			// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
+			// 			"2. Make focused changes to specific parts of the file that need modification.",
+			// 	)
+			// }
+			// Exact search match scenario
+			const exactIndex = this.originalContent.indexOf(this.currentSearchContent, this.lastProcessedIndex)
+			if (exactIndex !== -1) {
+				this.searchMatchIndex = exactIndex
+				this.searchEndIndex = exactIndex + this.currentSearchContent.length
+			} else {
+				// Attempt fallback line-trimmed matching
+				const lineMatch = lineTrimmedFallbackMatch(
+					this.originalContent,
+					this.currentSearchContent,
+					this.lastProcessedIndex,
+				)
+				if (lineMatch) {
+					;[this.searchMatchIndex, this.searchEndIndex] = lineMatch
+				} else {
+					// Try block anchor fallback for larger blocks
+					const blockMatch = blockAnchorFallbackMatch(
+						this.originalContent,
+						this.currentSearchContent,
+						this.lastProcessedIndex,
+					)
+					if (blockMatch) {
+						;[this.searchMatchIndex, this.searchEndIndex] = blockMatch
+					} else {
+						throw new Error(
+							`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...does not match anything in the file.`,
+						)
+					}
+				}
+			}
+		}
+		if (this.searchMatchIndex < this.lastProcessedIndex) {
+			throw new Error(
+				`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...matched an incorrect content in the file.`,
+			)
+		}
+		// Output everything up to the match location
+		this.result += this.originalContent.slice(this.lastProcessedIndex, this.searchMatchIndex)
+	}
+
+	private tryFixSearchBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error("Invalid SEARCH/REPLACE block structure - no lines available to process")
+		}
+		let searchTagRegexp = /^([-]{3,}|[<]{3,}) SEARCH$/
+		const searchTagIndex = this.findLastMatchingLineIndex(searchTagRegexp, lineLimit)
+		if (searchTagIndex !== -1) {
+			let fixLines = this.pendingNonStandardLines.slice(searchTagIndex, lineLimit)
+			fixLines[0] = SEARCH_BLOCK_START
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, searchTagIndex)
+			}
+		} else {
+			throw new Error(
+				`Invalid REPLACE marker detected - could not find matching SEARCH block starting from line ${searchTagIndex + 1}`,
+			)
+		}
+		return removeLineCount
+	}
+
+	private tryFixReplaceBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error()
+		}
+		let replaceBeginTagRegexp = /^[=]{3,}$/
+		const replaceBeginTagIndex = this.findLastMatchingLineIndex(replaceBeginTagRegexp, lineLimit)
+		if (replaceBeginTagIndex !== -1) {
+			// // 校验非标内容
+			// if (!this.isSearchingActive()) {
+			// 	removeLineCount += this.tryFixSearchBlock(replaceBeginTagIndex)
+			// }
+			let fixLines = this.pendingNonStandardLines.slice(replaceBeginTagIndex - removeLineCount, lineLimit - removeLineCount)
+			fixLines[0] = SEARCH_BLOCK_END
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, replaceBeginTagIndex - removeLineCount)
+			}
+		} else {
+			throw new Error(`Malformed REPLACE block - missing valid separator after line ${replaceBeginTagIndex + 1}`)
+		}
+		return removeLineCount
+	}
+
+	private tryFixSearchReplaceBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error()
+		}
+
+		let replaceEndTagRegexp = /^([+]{3,}|[>]{3,}) REPLACE$/
+		const replaceEndTagIndex = this.findLastMatchingLineIndex(replaceEndTagRegexp, lineLimit)
+		const likeReplaceEndTag = replaceEndTagIndex === lineLimit - 1
+		if (likeReplaceEndTag) {
+			// // 校验非标内容
+			// if (!this.isReplacingActive()) {
+			// 	removeLineCount += this.tryFixReplaceBlock(replaceEndTagIndex)
+			// }
+			let fixLines = this.pendingNonStandardLines.slice(replaceEndTagIndex - removeLineCount, lineLimit - removeLineCount)
+			fixLines[fixLines.length - 1] = REPLACE_BLOCK_END
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, replaceEndTagIndex - removeLineCount)
+			}
+		} else {
+			throw new Error("Malformed SEARCH/REPLACE block structure: Missing valid closing REPLACE marker")
+		}
+		return removeLineCount
+	}
+
+	/**
+	 * Removes trailing empty lines from the pendingNonStandardLines array
+	 * @param lineLimit - The index to start checking from (exclusive).
+	 *                    Removes empty lines from lineLimit-1 backwards.
+	 * @returns The number of empty lines removed
+	 */
+	private trimPendingNonStandardTrailingEmptyLines(lineLimit: number): number {
+		let removedCount = 0
+		let i = Math.min(lineLimit, this.pendingNonStandardLines.length) - 1
+
+		while (i >= 0 && this.pendingNonStandardLines[i].trim() === "") {
+			this.pendingNonStandardLines.pop()
+			removedCount++
+			i--
+		}
+
+		return removedCount
+	}
+}
+
+export async function constructNewFileContentV2(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
+	let newFileContentConstructor = new NewFileContentConstructor(originalContent, isFinal)
+
+	let lines = diffContent.split("\n")
+
+	// If the last line looks like a partial marker but isn't recognized,
+	// remove it because it might be incomplete.
+	const lastLine = lines[lines.length - 1]
+	if (
+		lines.length > 0 &&
+		(lastLine.startsWith(SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith("=") ||
+			lastLine.startsWith(REPLACE_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_REPLACE_BLOCK_CHAR)) &&
+		lastLine !== SEARCH_BLOCK_START &&
+		lastLine !== SEARCH_BLOCK_END &&
+		lastLine !== REPLACE_BLOCK_END
+	) {
+		lines.pop()
+	}
+
+	for (const line of lines) {
+		newFileContentConstructor.processLine(line)
+	}
+
+	let result = newFileContentConstructor.getResult()
+	return result
+}

evals/diff-edits/diff-apply/diff-06-26-25.ts

@@ -0,0 +1,960 @@
+const SEARCH_BLOCK_START = "------- SEARCH"
+const SEARCH_BLOCK_END = "======="
+const REPLACE_BLOCK_END = "+++++++ REPLACE"
+
+const SEARCH_BLOCK_CHAR = "-"
+const REPLACE_BLOCK_CHAR = "+"
+const LEGACY_SEARCH_BLOCK_CHAR = "<"
+const LEGACY_REPLACE_BLOCK_CHAR = ">"
+
+// Replace the exact string constants with flexible regex patterns
+const SEARCH_BLOCK_START_REGEX = /^[-]{3,} SEARCH>?$/
+const LEGACY_SEARCH_BLOCK_START_REGEX = /^[<]{3,} SEARCH>?$/
+
+const SEARCH_BLOCK_END_REGEX = /^[=]{3,}$/
+
+const REPLACE_BLOCK_END_REGEX = /^[+]{3,} REPLACE>?$/
+const LEGACY_REPLACE_BLOCK_END_REGEX = /^[>]{3,} REPLACE>?$/
+
+// Similarity thresholds for block anchor fallback matching
+const SINGLE_CANDIDATE_SIMILARITY_THRESHOLD = 0.0
+const MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD = 0.0
+
+/**
+ * Levenshtein distance algorithm implementation
+ */
+function levenshtein(a: string, b: string): number {
+	// Handle empty strings
+	if (a === "" || b === "") {
+		return Math.max(a.length, b.length)
+	}
+	const matrix = Array.from({ length: a.length + 1 }, (_, i) =>
+		Array.from({ length: b.length + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)),
+	)
+
+	for (let i = 1; i <= a.length; i++) {
+		for (let j = 1; j <= b.length; j++) {
+			const cost = a[i - 1] === b[j - 1] ? 0 : 1
+			matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost)
+		}
+	}
+	return matrix[a.length][b.length]
+}
+
+// Helper functions to check if a line matches the flexible patterns
+function isSearchBlockStart(line: string): boolean {
+	return SEARCH_BLOCK_START_REGEX.test(line) || LEGACY_SEARCH_BLOCK_START_REGEX.test(line)
+}
+
+function isSearchBlockEnd(line: string): boolean {
+	return SEARCH_BLOCK_END_REGEX.test(line)
+}
+
+function isReplaceBlockEnd(line: string): boolean {
+	return REPLACE_BLOCK_END_REGEX.test(line) || LEGACY_REPLACE_BLOCK_END_REGEX.test(line)
+}
+
+/**
+ * Attempts a line-trimmed fallback match for the given search content in the original content.
+ * It tries to match `searchContent` lines against a block of lines in `originalContent` starting
+ * from `lastProcessedIndex`. Lines are matched by trimming leading/trailing whitespace and ensuring
+ * they are identical afterwards.
+ *
+ * Returns [matchIndexStart, matchIndexEnd] if found, or false if not found.
+ */
+function lineTrimmedFallbackMatch(originalContent: string, searchContent: string, startIndex: number): [number, number] | false {
+	// Split both contents into lines
+	const originalLines = originalContent.split("\n")
+	const searchLines = searchContent.split("\n")
+
+	// Trim trailing empty line if exists (from the trailing \n in searchContent)
+	if (searchLines[searchLines.length - 1] === "") {
+		searchLines.pop()
+	}
+
+	// Find the line number where startIndex falls
+	let startLineNum = 0
+	let currentIndex = 0
+	while (currentIndex < startIndex && startLineNum < originalLines.length) {
+		currentIndex += originalLines[startLineNum].length + 1 // +1 for \n
+		startLineNum++
+	}
+
+	// For each possible starting position in original content
+	for (let i = startLineNum; i <= originalLines.length - searchLines.length; i++) {
+		let matches = true
+
+		// Try to match all search lines from this position
+		for (let j = 0; j < searchLines.length; j++) {
+			const originalTrimmed = originalLines[i + j].trim()
+			const searchTrimmed = searchLines[j].trim()
+
+			if (originalTrimmed !== searchTrimmed) {
+				matches = false
+				break
+			}
+		}
+
+		// If we found a match, calculate the exact character positions
+		if (matches) {
+			// Find start character index
+			let matchStartIndex = 0
+			for (let k = 0; k < i; k++) {
+				matchStartIndex += originalLines[k].length + 1 // +1 for \n
+			}
+
+			// Find end character index
+			let matchEndIndex = matchStartIndex
+			for (let k = 0; k < searchLines.length; k++) {
+				matchEndIndex += originalLines[i + k].length + 1 // +1 for \n
+			}
+
+			return [matchStartIndex, matchEndIndex]
+		}
+	}
+
+	return false
+}
+
+/**
+ * Attempts to match blocks of code by using the first and last lines as anchors,
+ * with similarity checking to prevent false positives.
+ * This is a third-tier fallback strategy that helps match blocks where we can identify
+ * the correct location by matching the beginning and end, even if the exact content
+ * differs slightly.
+ *
+ * The matching strategy:
+ * 1. Only attempts to match blocks of 3 or more lines to avoid false positives
+ * 2. Extracts from the search content:
+ *    - First line as the "start anchor"
+ *    - Last line as the "end anchor"
+ * 3. Collects all candidate positions where both anchors match
+ * 4. Uses levenshtein distance to calculate similarity of middle lines
+ * 5. Returns match only if similarity meets threshold requirements
+ *
+ * This approach is particularly useful for matching blocks of code where:
+ * - The exact content might have minor differences
+ * - The beginning and end of the block are distinctive enough to serve as anchors
+ * - The overall structure (number of lines) remains the same
+ * - The middle content is reasonably similar (prevents false positives)
+ *
+ * @param originalContent - The full content of the original file
+ * @param searchContent - The content we're trying to find in the original file
+ * @param startIndex - The character index in originalContent where to start searching
+ * @returns A tuple of [startIndex, endIndex] if a match is found, false otherwise
+ */
+function blockAnchorFallbackMatch(originalContent: string, searchContent: string, startIndex: number): [number, number, number] | false {
+	const originalLines = originalContent.split("\n")
+	const searchLines = searchContent.split("\n")
+
+	// Only use this approach for blocks of 3+ lines
+	if (searchLines.length < 3) {
+		return false
+	}
+
+	// Trim trailing empty line if exists
+	if (searchLines[searchLines.length - 1] === "") {
+		searchLines.pop()
+	}
+
+	const firstLineSearch = searchLines[0].trim()
+	const lastLineSearch = searchLines[searchLines.length - 1].trim()
+	const searchBlockSize = searchLines.length
+
+	// Find the line number where startIndex falls
+	let startLineNum = 0
+	let currentIndex = 0
+	while (currentIndex < startIndex && startLineNum < originalLines.length) {
+		currentIndex += originalLines[startLineNum].length + 1
+		startLineNum++
+	}
+
+	// Collect all candidate positions
+	const candidates: number[] = []
+	for (let i = startLineNum; i <= originalLines.length - searchBlockSize; i++) {
+		if (originalLines[i].trim() === firstLineSearch && originalLines[i + searchBlockSize - 1].trim() === lastLineSearch) {
+			candidates.push(i)
+		}
+	}
+
+	// Return immediately if no candidates
+	if (candidates.length === 0) {
+		return false
+	}
+
+	// Handle single candidate scenario (using relaxed threshold)
+	if (candidates.length === 1) {
+		const i = candidates[0]
+		let similarity = 0
+		let linesToCheck = searchBlockSize - 2
+
+		for (let j = 1; j < searchBlockSize - 1; j++) {
+			const originalLine = originalLines[i + j].trim()
+			const searchLine = searchLines[j].trim()
+			const maxLen = Math.max(originalLine.length, searchLine.length)
+			if (maxLen === 0) {
+				continue
+			}
+			const distance = levenshtein(originalLine, searchLine)
+			similarity += (1 - distance / maxLen) / linesToCheck
+
+			// Exit early when threshold is reached
+			if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+				break
+			}
+		}
+
+		if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+			let matchStartIndex = 0
+			for (let k = 0; k < i; k++) {
+				matchStartIndex += originalLines[k].length + 1
+			}
+			let matchEndIndex = matchStartIndex
+			for (let k = 0; k < searchBlockSize; k++) {
+				matchEndIndex += originalLines[i + k].length + 1
+			}
+			return [matchStartIndex, matchEndIndex, similarity]
+		}
+		return false
+	}
+
+	// Calculate similarity for multiple candidates
+	let bestMatchIndex = -1
+	let maxSimilarity = -1
+
+	for (const i of candidates) {
+		let similarity = 0
+		for (let j = 1; j < searchBlockSize - 1; j++) {
+			const originalLine = originalLines[i + j].trim()
+			const searchLine = searchLines[j].trim()
+			const maxLen = Math.max(originalLine.length, searchLine.length)
+			if (maxLen === 0) {
+				continue
+			}
+			const distance = levenshtein(originalLine, searchLine)
+			similarity += 1 - distance / maxLen
+		}
+		similarity /= searchBlockSize - 2 // Average similarity
+
+		if (similarity > maxSimilarity) {
+			maxSimilarity = similarity
+			bestMatchIndex = i
+		}
+	}
+
+	// Threshold judgment
+	if (maxSimilarity >= MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD) {
+		const i = bestMatchIndex
+		let matchStartIndex = 0
+		for (let k = 0; k < i; k++) {
+			matchStartIndex += originalLines[k].length + 1
+		}
+		let matchEndIndex = matchStartIndex
+		for (let k = 0; k < searchBlockSize; k++) {
+			matchEndIndex += originalLines[i + k].length + 1
+		}
+		return [matchStartIndex, matchEndIndex, maxSimilarity]
+	}
+
+	return false
+}
+
+/**
+ * This function reconstructs the file content by applying a streamed diff (in a
+ * specialized SEARCH/REPLACE block format) to the original file content. It is designed
+ * to handle both incremental updates and the final resulting file after all chunks have
+ * been processed.
+ *
+ * The diff format is a custom structure that uses three markers to define changes:
+ *
+ *   ------- SEARCH
+ *   [Exact content to find in the original file]
+ *   =======
+ *   [Content to replace with]
+ *   +++++++ REPLACE
+ *
+ * Behavior and Assumptions:
+ * 1. The file is processed chunk-by-chunk. Each chunk of `diffContent` may contain
+ *    partial or complete SEARCH/REPLACE blocks. By calling this function with each
+ *    incremental chunk (with `isFinal` indicating the last chunk), the final reconstructed
+ *    file content is produced.
+ *
+ * 2. Matching Strategy (in order of attempt):
+ *    a. Exact Match: First attempts to find the exact SEARCH block text in the original file
+ *    b. Line-Trimmed Match: Falls back to line-by-line comparison ignoring leading/trailing whitespace
+ *    c. Block Anchor Match: For blocks of 3+ lines, tries to match using first/last lines as anchors
+ *    If all matching strategies fail, an error is thrown.
+ *
+ * 3. Empty SEARCH Section:
+ *    - If SEARCH is empty and the original file is empty, this indicates creating a new file
+ *      (pure insertion).
+ *    - If SEARCH is empty and the original file is not empty, this indicates a complete
+ *      file replacement (the entire original content is considered matched and replaced).
+ *
+ * 4. Applying Changes:
+ *    - Before encountering the "=======" marker, lines are accumulated as search content.
+ *    - After "=======" and before ">>>>>>> REPLACE", lines are accumulated as replacement content.
+ *    - Once the block is complete (">>>>>>> REPLACE"), the matched section in the original
+ *      file is replaced with the accumulated replacement lines, and the position in the original
+ *      file is advanced.
+ *
+ * 5. Incremental Output:
+ *    - As soon as the match location is found and we are in the REPLACE section, each new
+ *      replacement line is appended to the result so that partial updates can be viewed
+ *      incrementally.
+ *
+ * 6. Partial Markers:
+ *    - If the final line of the chunk looks like it might be part of a marker but is not one
+ *      of the known markers, it is removed. This prevents incomplete or partial markers
+ *      from corrupting the output.
+ *
+ * 7. Finalization:
+ *    - Once all chunks have been processed (when `isFinal` is true), any remaining original
+ *      content after the last replaced section is appended to the result.
+ *    - Trailing newlines are not forcibly added. The code tries to output exactly what is specified.
+ *
+ * Errors:
+ * - If the search block cannot be matched using any of the available matching strategies,
+ *   an error is thrown.
+ */
+export async function constructNewFileContent(
+	diffContent: string,
+	originalContent: string,
+	isFinal: boolean,
+	version: "v1" | "v2" = "v1",
+): Promise<any> {
+	const constructor = constructNewFileContentVersionMapping[version]
+	if (!constructor) {
+		throw new Error(`Invalid version '${version}' for file content constructor`)
+	}
+	return constructor(diffContent, originalContent, isFinal)
+}
+
+const constructNewFileContentVersionMapping: Record<
+	string,
+	(diffContent: string, originalContent: string, isFinal: boolean) => Promise<any>
+> = {
+	v1: constructNewFileContentV1,
+	v2: constructNewFileContentV2,
+} as const
+
+async function constructNewFileContentV1(diffContent: string, originalContent: string, isFinal: boolean): Promise<{
+	content: string;
+	replacements: Array<{ 
+		start: number; 
+		end: number; 
+		content: string;
+		method: string;
+		similarity: number;
+		searchContent: string;
+		matchedText: string;
+	}>;
+}> {
+	let result = ""
+	let lastProcessedIndex = 0
+
+	let currentSearchContent = ""
+	let currentReplaceContent = ""
+	let inSearch = false
+	let inReplace = false
+
+	let searchMatchIndex = -1
+	let searchEndIndex = -1
+	let matchMethod = ""
+	let similarityScore = -1.0
+
+	// Track all replacements to handle out-of-order edits
+	let replacements: Array<{ 
+		start: number; 
+		end: number; 
+		content: string;
+		method: string;
+		similarity: number;
+		searchContent: string;
+		matchedText: string;
+	}> = []
+	let pendingOutOfOrderReplacement = false
+
+	let lines = diffContent.split("\n")
+
+	// If the last line looks like a partial marker but isn't recognized,
+	// remove it because it might be incomplete.
+	const lastLine = lines[lines.length - 1]
+	if (
+		lines.length > 0 &&
+		(lastLine.startsWith(SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith("=") ||
+			lastLine.startsWith(REPLACE_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_REPLACE_BLOCK_CHAR)) &&
+		!isSearchBlockStart(lastLine) &&
+		!isSearchBlockEnd(lastLine) &&
+		!isReplaceBlockEnd(lastLine)
+	) {
+		lines.pop()
+	}
+
+	for (const line of lines) {
+		if (isSearchBlockStart(line)) {
+			inSearch = true
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			continue
+		}
+
+		if (isSearchBlockEnd(line)) {
+			inSearch = false
+			inReplace = true
+
+			// Remove trailing linebreak for adding the === marker
+			// if (currentSearchContent.endsWith("\r\n")) {
+			// 	currentSearchContent = currentSearchContent.slice(0, -2)
+			// } else if (currentSearchContent.endsWith("\n")) {
+			// 	currentSearchContent = currentSearchContent.slice(0, -1)
+			// }
+
+			if (!currentSearchContent) {
+				// Empty search block
+				if (originalContent.length === 0) {
+					// New file scenario: nothing to match, just start inserting
+					searchMatchIndex = 0
+					searchEndIndex = 0
+					matchMethod = "empty_new_file"
+				} else {
+					// ERROR: Empty search block with non-empty file indicates malformed SEARCH marker
+					throw new Error(
+						"Empty SEARCH block detected with non-empty file. This usually indicates a malformed SEARCH marker.\n" +
+							"Please ensure your SEARCH marker follows the correct format:\n" +
+							"- Use '------- SEARCH' (7+ dashes + space + SEARCH)\n",
+					)
+				}
+			} else {
+				// Add check for inefficient full-file search
+				// if (currentSearchContent.trim() === originalContent.trim()) {
+				// 	throw new Error(
+				// 		"The SEARCH block contains the entire file content. Please either:\n" +
+				// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
+				// 			"2. Make focused changes to specific parts of the file that need modification.",
+				// 	)
+				// }
+
+				// Exact search match scenario
+				const exactIndex = originalContent.indexOf(currentSearchContent, lastProcessedIndex)
+				if (exactIndex !== -1) {
+					searchMatchIndex = exactIndex
+					searchEndIndex = exactIndex + currentSearchContent.length
+					matchMethod = "exact_match"
+				} else {
+					// Attempt fallback line-trimmed matching
+					const lineMatch = lineTrimmedFallbackMatch(originalContent, currentSearchContent, lastProcessedIndex)
+					if (lineMatch) {
+						;[searchMatchIndex, searchEndIndex] = lineMatch
+						matchMethod = "line_trimmed_fallback"
+					} else {
+						// Try block anchor fallback for larger blocks
+						const blockMatch = blockAnchorFallbackMatch(originalContent, currentSearchContent, lastProcessedIndex)
+						if (blockMatch) {
+							;[searchMatchIndex, searchEndIndex, similarityScore] = blockMatch
+							matchMethod = "block_anchor_fallback"
+						} else {
+							// Last resort: search the entire file from the beginning
+							const fullFileIndex = originalContent.indexOf(currentSearchContent, 0)
+							if (fullFileIndex !== -1) {
+								// Found in the file - could be out of order
+								searchMatchIndex = fullFileIndex
+								searchEndIndex = fullFileIndex + currentSearchContent.length
+								matchMethod = "full_file_search"
+								if (searchMatchIndex < lastProcessedIndex) {
+									pendingOutOfOrderReplacement = true
+								}
+							} else {
+								throw new Error(
+									`The SEARCH block:\n${currentSearchContent.trimEnd()}\n...does not match anything in the file.`,
+								)
+							}
+						}
+					}
+				}
+			}
+
+			// Check if this is an out-of-order replacement
+			if (searchMatchIndex < lastProcessedIndex) {
+				pendingOutOfOrderReplacement = true
+			}
+
+			// For in-order replacements, output everything up to the match location
+			if (!pendingOutOfOrderReplacement) {
+				result += originalContent.slice(lastProcessedIndex, searchMatchIndex)
+			}
+			continue
+		}
+
+		if (isReplaceBlockEnd(line)) {
+			// Finished one replace block
+
+			if (searchMatchIndex === -1) {
+				throw new Error(
+					`The SEARCH block:\n${currentSearchContent.trimEnd()}\n...is malformatted.`,
+				)
+			}
+
+			// Store this replacement
+			replacements.push({
+				start: searchMatchIndex,
+				end: searchEndIndex,
+				content: currentReplaceContent,
+				method: matchMethod,
+				similarity: similarityScore,
+				searchContent: currentSearchContent,
+				matchedText: originalContent.slice(searchMatchIndex, searchEndIndex),
+			})
+
+			// If this was an in-order replacement, advance lastProcessedIndex
+			if (!pendingOutOfOrderReplacement) {
+				lastProcessedIndex = searchEndIndex
+			}
+
+			// Reset for next block
+			inSearch = false
+			inReplace = false
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			searchMatchIndex = -1
+			searchEndIndex = -1
+			similarityScore = -1.0
+			pendingOutOfOrderReplacement = false
+			continue
+		}
+
+		// Accumulate content for search or replace
+		// (currentReplaceContent is not being used for anything right now since we directly append to result.)
+		// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
+		// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
+		if (inSearch) {
+			currentSearchContent += line + "\n"
+		} else if (inReplace) {
+			currentReplaceContent += line + "\n"
+			// Only output replacement lines immediately for in-order replacements
+			if (searchMatchIndex !== -1 && !pendingOutOfOrderReplacement) {
+				result += line + "\n"
+			}
+		}
+	}
+
+	// If this is the final chunk, we need to apply all replacements and build the final result
+	if (isFinal) {
+		// Handle the case where we're still in replace mode when processing ends
+		// and this is the final chunk - treat it as if we encountered the REPLACE marker
+		if (inReplace && searchMatchIndex !== -1) {
+			// Store this replacement
+			replacements.push({
+				start: searchMatchIndex,
+				end: searchEndIndex,
+				content: currentReplaceContent,
+				method: matchMethod,
+				similarity: similarityScore,
+				searchContent: currentSearchContent,
+				matchedText: originalContent.slice(searchMatchIndex, searchEndIndex),
+			})
+
+			// If this was an in-order replacement, advance lastProcessedIndex
+			if (!pendingOutOfOrderReplacement) {
+				lastProcessedIndex = searchEndIndex
+			}
+
+			// Reset state
+			inSearch = false
+			inReplace = false
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			searchMatchIndex = -1
+			searchEndIndex = -1
+			pendingOutOfOrderReplacement = false
+		}
+		// end of handling missing replace marker
+
+		// Sort replacements by start position
+		replacements.sort((a, b) => a.start - b.start)
+
+		// Rebuild the entire result by applying all replacements
+		result = ""
+		let currentPos = 0
+
+		for (const replacement of replacements) {
+			// Add original content up to this replacement
+			result += originalContent.slice(currentPos, replacement.start)
+			// Add the replacement content
+			result += replacement.content
+			// Move position to after the replaced section
+			currentPos = replacement.end
+		}
+
+		// Add any remaining original content
+		result += originalContent.slice(currentPos)
+	}
+
+	// For testing - return debug info
+	return {
+		content: result,
+		replacements: replacements
+	}
+}
+
+enum ProcessingState {
+	Idle = 0,
+	StateSearch = 1 << 0,
+	StateReplace = 1 << 1,
+}
+
+class NewFileContentConstructor {
+	private originalContent: string
+	private isFinal: boolean
+	private state: number
+	private pendingNonStandardLines: string[]
+	private result: string
+	private lastProcessedIndex: number
+	private currentSearchContent: string
+	private currentReplaceContent: string
+	private searchMatchIndex: number
+	private searchEndIndex: number
+
+	constructor(originalContent: string, isFinal: boolean) {
+		this.originalContent = originalContent
+		this.isFinal = isFinal
+		this.pendingNonStandardLines = []
+		this.result = ""
+		this.lastProcessedIndex = 0
+		this.state = ProcessingState.Idle
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+		this.searchMatchIndex = -1
+		this.searchEndIndex = -1
+	}
+
+	private resetForNextBlock() {
+		// Reset for next block
+		this.state = ProcessingState.Idle
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+		this.searchMatchIndex = -1
+		this.searchEndIndex = -1
+	}
+
+	private findLastMatchingLineIndex(regx: RegExp, lineLimit: number) {
+		for (let i = lineLimit; i > 0; ) {
+			i--
+			if (this.pendingNonStandardLines[i].match(regx)) {
+				return i
+			}
+		}
+		return -1
+	}
+
+	private updateProcessingState(newState: ProcessingState) {
+		const isValidTransition =
+			(this.state === ProcessingState.Idle && newState === ProcessingState.StateSearch) ||
+			(this.state === ProcessingState.StateSearch && newState === ProcessingState.StateReplace)
+
+		if (!isValidTransition) {
+			throw new Error(
+				`Invalid state transition.\n` +
+					"Valid transitions are:\n" +
+					"- Idle → StateSearch\n" +
+					"- StateSearch → StateReplace",
+			)
+		}
+
+		this.state |= newState
+	}
+
+	private isStateActive(state: ProcessingState): boolean {
+		return (this.state & state) === state
+	}
+
+	private activateReplaceState() {
+		this.updateProcessingState(ProcessingState.StateReplace)
+	}
+
+	private activateSearchState() {
+		this.updateProcessingState(ProcessingState.StateSearch)
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+	}
+
+	private isSearchingActive(): boolean {
+		return this.isStateActive(ProcessingState.StateSearch)
+	}
+
+	private isReplacingActive(): boolean {
+		return this.isStateActive(ProcessingState.StateReplace)
+	}
+
+	private hasPendingNonStandardLines(pendingNonStandardLineLimit: number): boolean {
+		return this.pendingNonStandardLines.length - pendingNonStandardLineLimit < this.pendingNonStandardLines.length
+	}
+
+	public processLine(line: string) {
+		this.internalProcessLine(line, true, this.pendingNonStandardLines.length)
+	}
+
+	public getResult() {
+		// If this is the final chunk, append any remaining original content
+		if (this.isFinal && this.lastProcessedIndex < this.originalContent.length) {
+			this.result += this.originalContent.slice(this.lastProcessedIndex)
+		}
+		if (this.isFinal && this.state !== ProcessingState.Idle) {
+			throw new Error("File processing incomplete - SEARCH/REPLACE operations still active during finalization")
+		}
+		return this.result
+	}
+
+	private internalProcessLine(
+		line: string,
+		canWritependingNonStandardLines: boolean,
+		pendingNonStandardLineLimit: number,
+	): number {
+		let removeLineCount = 0
+		if (isSearchBlockStart(line)) {
+			removeLineCount = this.trimPendingNonStandardTrailingEmptyLines(pendingNonStandardLineLimit)
+			if (removeLineCount > 0) {
+				pendingNonStandardLineLimit = pendingNonStandardLineLimit - removeLineCount
+			}
+			if (this.hasPendingNonStandardLines(pendingNonStandardLineLimit)) {
+				this.tryFixSearchReplaceBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.activateSearchState()
+		} else if (isSearchBlockEnd(line)) {
+			// 校验非标内容
+			if (!this.isSearchingActive()) {
+				this.tryFixSearchBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.activateReplaceState()
+			this.beforeReplace()
+		} else if (isReplaceBlockEnd(line)) {
+			if (!this.isReplacingActive()) {
+				this.tryFixReplaceBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.lastProcessedIndex = this.searchEndIndex
+			this.resetForNextBlock()
+		} else {
+			// Accumulate content for search or replace
+			// (currentReplaceContent is not being used for anything right now since we directly append to result.)
+			// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
+			// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
+			if (this.isReplacingActive()) {
+				this.currentReplaceContent += line + "\n"
+				// Output replacement lines immediately if we know the insertion point
+				if (this.searchMatchIndex !== -1) {
+					this.result += line + "\n"
+				}
+			} else if (this.isSearchingActive()) {
+				this.currentSearchContent += line + "\n"
+			} else {
+				let appendToPendingNonStandardLines = canWritependingNonStandardLines
+				if (appendToPendingNonStandardLines) {
+					// 处理非标内容
+					this.pendingNonStandardLines.push(line)
+				}
+			}
+		}
+		return removeLineCount
+	}
+
+	private beforeReplace() {
+		// Remove trailing linebreak for adding the === marker
+		// if (currentSearchContent.endsWith("\r\n")) {
+		// 	currentSearchContent = currentSearchContent.slice(0, -2)
+		// } else if (currentSearchContent.endsWith("\n")) {
+		// 	currentSearchContent = currentSearchContent.slice(0, -1)
+		// }
+
+		if (!this.currentSearchContent) {
+			// Empty search block
+			if (this.originalContent.length === 0) {
+				// New file scenario: nothing to match, just start inserting
+				this.searchMatchIndex = 0
+				this.searchEndIndex = 0
+			} else {
+				// Complete file replacement scenario: treat the entire file as matched
+				this.searchMatchIndex = 0
+				this.searchEndIndex = this.originalContent.length
+			}
+		} else {
+			// Add check for inefficient full-file search
+			// if (currentSearchContent.trim() === originalContent.trim()) {
+			// 	throw new Error(
+			// 		"The SEARCH block contains the entire file content. Please either:\n" +
+			// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
+			// 			"2. Make focused changes to specific parts of the file that need modification.",
+			// 	)
+			// }
+			// Exact search match scenario
+			const exactIndex = this.originalContent.indexOf(this.currentSearchContent, this.lastProcessedIndex)
+			if (exactIndex !== -1) {
+				this.searchMatchIndex = exactIndex
+				this.searchEndIndex = exactIndex + this.currentSearchContent.length
+			} else {
+				// Attempt fallback line-trimmed matching
+				const lineMatch = lineTrimmedFallbackMatch(
+					this.originalContent,
+					this.currentSearchContent,
+					this.lastProcessedIndex,
+				)
+				if (lineMatch) {
+					;[this.searchMatchIndex, this.searchEndIndex] = lineMatch
+				} else {
+					// Try block anchor fallback for larger blocks
+					const blockMatch = blockAnchorFallbackMatch(
+						this.originalContent,
+						this.currentSearchContent,
+						this.lastProcessedIndex,
+					)
+					if (blockMatch) {
+						;[this.searchMatchIndex, this.searchEndIndex, /* ignore similarity */] = blockMatch
+					} else {
+						throw new Error(
+							`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...does not match anything in the file.`,
+						)
+					}
+				}
+			}
+		}
+		if (this.searchMatchIndex < this.lastProcessedIndex) {
+			throw new Error(
+				`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...matched an incorrect content in the file.`,
+			)
+		}
+		// Output everything up to the match location
+		this.result += this.originalContent.slice(this.lastProcessedIndex, this.searchMatchIndex)
+	}
+
+	private tryFixSearchBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error("Invalid SEARCH/REPLACE block structure - no lines available to process")
+		}
+		let searchTagRegexp = /^([-]{3,}|[<]{3,}) SEARCH$/
+		const searchTagIndex = this.findLastMatchingLineIndex(searchTagRegexp, lineLimit)
+		if (searchTagIndex !== -1) {
+			let fixLines = this.pendingNonStandardLines.slice(searchTagIndex, lineLimit)
+			fixLines[0] = SEARCH_BLOCK_START
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, searchTagIndex)
+			}
+		} else {
+			throw new Error(
+				`Invalid REPLACE marker detected - could not find matching SEARCH block starting from line ${searchTagIndex + 1}`,
+			)
+		}
+		return removeLineCount
+	}
+
+	private tryFixReplaceBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error()
+		}
+		let replaceBeginTagRegexp = /^[=]{3,}$/
+		const replaceBeginTagIndex = this.findLastMatchingLineIndex(replaceBeginTagRegexp, lineLimit)
+		if (replaceBeginTagIndex !== -1) {
+			// // 校验非标内容
+			// if (!this.isSearchingActive()) {
+			// 	removeLineCount += this.tryFixSearchBlock(replaceBeginTagIndex)
+			// }
+			let fixLines = this.pendingNonStandardLines.slice(replaceBeginTagIndex - removeLineCount, lineLimit - removeLineCount)
+			fixLines[0] = SEARCH_BLOCK_END
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, replaceBeginTagIndex - removeLineCount)
+			}
+		} else {
+			throw new Error(`Malformed REPLACE block - missing valid separator after line ${replaceBeginTagIndex + 1}`)
+		}
+		return removeLineCount
+	}
+
+	private tryFixSearchReplaceBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error()
+		}
+
+		let replaceEndTagRegexp = /^([+]{3,}|[>]{3,}) REPLACE$/
+		const replaceEndTagIndex = this.findLastMatchingLineIndex(replaceEndTagRegexp, lineLimit)
+		const likeReplaceEndTag = replaceEndTagIndex === lineLimit - 1
+		if (likeReplaceEndTag) {
+			// // 校验非标内容
+			// if (!this.isReplacingActive()) {
+			// 	removeLineCount += this.tryFixReplaceBlock(replaceEndTagIndex)
+			// }
+			let fixLines = this.pendingNonStandardLines.slice(replaceEndTagIndex - removeLineCount, lineLimit - removeLineCount)
+			fixLines[fixLines.length - 1] = REPLACE_BLOCK_END
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, replaceEndTagIndex - removeLineCount)
+			}
+		} else {
+			throw new Error("Malformed SEARCH/REPLACE block structure: Missing valid closing REPLACE marker")
+		}
+		return removeLineCount
+	}
+
+	/**
+	 * Removes trailing empty lines from the pendingNonStandardLines array
+	 * @param lineLimit - The index to start checking from (exclusive).
+	 *                    Removes empty lines from lineLimit-1 backwards.
+	 * @returns The number of empty lines removed
+	 */
+	private trimPendingNonStandardTrailingEmptyLines(lineLimit: number): number {
+		let removedCount = 0
+		let i = Math.min(lineLimit, this.pendingNonStandardLines.length) - 1
+
+		while (i >= 0 && this.pendingNonStandardLines[i].trim() === "") {
+			this.pendingNonStandardLines.pop()
+			removedCount++
+			i--
+		}
+
+		return removedCount
+	}
+}
+
+export async function constructNewFileContentV2(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
+	let newFileContentConstructor = new NewFileContentConstructor(originalContent, isFinal)
+
+	let lines = diffContent.split("\n")
+
+	// If the last line looks like a partial marker but isn't recognized,
+	// remove it because it might be incomplete.
+	const lastLine = lines[lines.length - 1]
+	if (
+		lines.length > 0 &&
+		(lastLine.startsWith(SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith("=") ||
+			lastLine.startsWith(REPLACE_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_REPLACE_BLOCK_CHAR)) &&
+		lastLine !== SEARCH_BLOCK_START &&
+		lastLine !== SEARCH_BLOCK_END &&
+		lastLine !== REPLACE_BLOCK_END
+	) {
+		lines.pop()
+	}
+
+	for (const line of lines) {
+		newFileContentConstructor.processLine(line)
+	}
+
+	let result = newFileContentConstructor.getResult()
+	return result
+}

evals/diff-edits/helpers.ts

@@ -0,0 +1,31 @@
+import { Anthropic } from "@anthropic-ai/sdk"
+
+const formatImagesIntoBlocks = (images?: string[]): Anthropic.ImageBlockParam[] => {
+	return images
+		? images.map((dataUrl) => {
+				// data:image/png;base64,base64string
+				const [rest, base64] = dataUrl.split(",")
+				const mimeType = rest.split(":")[1].split(";")[0]
+				return {
+					type: "image",
+					source: {
+						type: "base64",
+						media_type: mimeType,
+						data: base64,
+					},
+				} as Anthropic.ImageBlockParam
+			})
+		: []
+}
+
+export const formatResponse = {
+	imageBlocks: (images?: string[]): Anthropic.ImageBlockParam[] => {
+		return formatImagesIntoBlocks(images)
+	},
+}
+
+export function log(isVerbose: boolean, message: string) {
+	if (isVerbose) {
+		console.log(message)
+	}
+}

evals/diff-edits/openRouterModelsHelper.ts

@@ -0,0 +1,98 @@
+import axios from "axios";
+import path from "path";
+import fs from "fs/promises";
+
+// Minimal type for what we need from OpenRouter model info in evals
+export interface EvalOpenRouterModelInfo {
+    id: string;
+    contextWindow: number;
+    inputPrice?: number; // Price per million tokens
+    outputPrice?: number; // Price per million tokens
+    // Add any other fields if they become necessary for evals
+}
+
+function logHelper(isVerbose: boolean, message: string) {
+    if (isVerbose) {
+        console.log(`[OpenRouterModelsHelper] ${message}`);
+    }
+}
+
+/**
+ * Ensures the cache directory exists within evals and returns its path
+ */
+async function ensureEvalCacheDirectoryExists(): Promise<string> {
+    // Cache directory within evals, e.g., evals/.cache/
+    const cacheDir = path.join(__dirname, "..", ".cache");
+    await fs.mkdir(cacheDir, { recursive: true });
+    return cacheDir;
+}
+
+/**
+ * Fetches, parses, and caches OpenRouter model data.
+ * Tries to read from a local cache first.
+ * @param isVerbose Enable verbose logging
+ * @returns A record of model IDs to their info.
+ */
+export async function loadOpenRouterModelData(isVerbose: boolean = false): Promise<Record<string, EvalOpenRouterModelInfo>> {
+    const cacheDir = await ensureEvalCacheDirectoryExists();
+    const cacheFilePath = path.join(cacheDir, "openRouterModels.json");
+    let models: Record<string, EvalOpenRouterModelInfo> = {};
+
+    try {
+        const stats = await fs.stat(cacheFilePath).catch(() => null);
+        // Use cache if less than 24 hours old
+        if (stats && (Date.now() - stats.mtimeMs < 24 * 60 * 60 * 1000)) {
+            logHelper(isVerbose, "Using cached OpenRouter model data.");
+            const fileContents = await fs.readFile(cacheFilePath, "utf8");
+            models = JSON.parse(fileContents);
+            if (Object.keys(models).length > 0) {
+                return models;
+            }
+            logHelper(isVerbose, "Cache was empty or invalid, fetching fresh data.");
+        } else if (stats) {
+            logHelper(isVerbose, "Cached OpenRouter model data is stale, fetching fresh data.");
+        } else {
+            logHelper(isVerbose, "No cached OpenRouter model data found, fetching fresh data.");
+        }
+    } catch (e) {
+        logHelper(isVerbose, `Error accessing cache, fetching fresh data: ${e}`);
+    }
+
+    try {
+        const response = await axios.get("https://openrouter.ai/api/v1/models");
+        if (response.data?.data) {
+            const rawModels = response.data.data;
+            const parsedModels: Record<string, EvalOpenRouterModelInfo> = {};
+            const parsePrice = (price: any) => price ? parseFloat(price) * 1_000_000 : undefined;
+
+            for (const rawModel of rawModels) {
+                parsedModels[rawModel.id] = {
+                    id: rawModel.id,
+                    contextWindow: rawModel.context_length ?? 0,
+                    inputPrice: parsePrice(rawModel.pricing?.prompt),
+                    outputPrice: parsePrice(rawModel.pricing?.completion),
+                };
+            }
+            await fs.writeFile(cacheFilePath, JSON.stringify(parsedModels, null, 2));
+            logHelper(isVerbose, `Fetched and cached ${Object.keys(parsedModels).length} OpenRouter models.`);
+            return parsedModels;
+        } else {
+            logHelper(isVerbose, "Invalid response structure from OpenRouter API.");
+        }
+    } catch (error) {
+        logHelper(isVerbose, `Error fetching OpenRouter models: ${error}. Attempting to use stale cache if available.`);
+        // Attempt to read stale cache as a last resort if fetching failed
+        try {
+            const fileContents = await fs.readFile(cacheFilePath, "utf8");
+            models = JSON.parse(fileContents);
+            if (Object.keys(models).length > 0) {
+                logHelper(isVerbose, "Successfully loaded stale cache after fetch failure.");
+                return models;
+            }
+        } catch (cacheError) {
+            logHelper(isVerbose, `Failed to read stale cache: ${cacheError}. Proceeding without OpenRouter model data.`);
+        }
+    }
+    // Return empty if all attempts fail, so the caller can decide how to handle it
+    return {};
+}

evals/diff-edits/prompts/basicSystemPrompt-06-06-25.ts

@@ -0,0 +1,615 @@
+/**
+ * Use all standard prompt values to construct prompt
+ */
+export const basicSystemPrompt = (
+	cwdFormatted: string,
+	supportsBrowserUse: boolean,
+	browserWidth: number,
+	browserHeight: number,
+	os: string,
+	shell: string,
+	homeFormatted: string,
+	mcpHubString: string,
+	userCustomInstructions: string,
+) => {
+	return `You are Cline, a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.
+
+====
+
+TOOL USE
+
+You have access to a set of tools that are executed upon the user's approval. You can use one tool per message, and will receive the result of that tool use in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.
+
+# Tool Use Formatting
+
+Tool use is formatted using XML-style tags. The tool name is enclosed in opening and closing tags, and each parameter is similarly enclosed within its own set of tags. Here's the structure:
+
+<tool_name>
+<parameter1_name>value1</parameter1_name>
+<parameter2_name>value2</parameter2_name>
+...
+</tool_name>
+
+For example:
+
+<read_file>
+<path>src/main.js</path>
+</read_file>
+
+Always adhere to this format for the tool use to ensure proper parsing and execution.
+
+# Tools
+
+## execute_command
+Description: Request to execute a CLI command on the system. Use this when you need to perform system operations or run specific commands to accomplish any step in the user's task. You must tailor your command to the user's system and provide a clear explanation of what the command does. For command chaining, use the appropriate chaining syntax for the user's shell. Prefer to execute complex CLI commands over creating executable scripts, as they are more flexible and easier to run. Commands will be executed in the current working directory: ${cwdFormatted}
+Parameters:
+- command: (required) The CLI command to execute. This should be valid for the current operating system. Ensure the command is properly formatted and does not contain any harmful instructions.
+- requires_approval: (required) A boolean indicating whether this command requires explicit user approval before execution in case the user has auto-approve mode enabled. Set to 'true' for potentially impactful operations like installing/uninstalling packages, deleting/overwriting files, system configuration changes, network operations, or any commands that could have unintended side effects. Set to 'false' for safe operations like reading files/directories, running development servers, building projects, and other non-destructive operations.
+Usage:
+<execute_command>
+<command>Your command here</command>
+<requires_approval>true or false</requires_approval>
+</execute_command>
+
+## read_file
+Description: Request to read the contents of a file at the specified path. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. Automatically extracts raw text from PDF and DOCX files. May not be suitable for other types of binary files, as it returns the raw content as a string.
+Parameters:
+- path: (required) The path of the file to read (relative to the current working directory ${cwdFormatted})
+Usage:
+<read_file>
+<path>File path here</path>
+</read_file>
+
+## write_to_file
+Description: Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file.
+Parameters:
+- path: (required) The path of the file to write to (relative to the current working directory ${cwdFormatted})
+- content: (required) The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified.
+Usage:
+<write_to_file>
+<path>File path here</path>
+<content>
+Your file content here
+</content>
+</write_to_file>
+
+## replace_in_file
+Description: Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.
+Parameters:
+- path: (required) The path of the file to modify (relative to the current working directory ${cwdFormatted})
+- diff: (required) One or more SEARCH/REPLACE blocks following this exact format:
+  \`\`\`
+  ------- SEARCH
+  [exact content to find]
+  =======
+  [new content to replace with]
+  +++++++ REPLACE
+  \`\`\`
+  Critical rules:
+  1. SEARCH content must match the associated file section to find EXACTLY:
+     * Match character-for-character including whitespace, indentation, line endings
+     * Include all comments, docstrings, etc.
+  2. SEARCH/REPLACE blocks will ONLY replace the first match occurrence.
+     * Including multiple unique SEARCH/REPLACE blocks if you need to make multiple changes.
+     * Include *just* enough lines in each SEARCH section to uniquely match each set of lines that need to change.
+     * When using multiple SEARCH/REPLACE blocks, list them in the order they appear in the file.
+  3. Keep SEARCH/REPLACE blocks concise:
+     * Break large SEARCH/REPLACE blocks into a series of smaller blocks that each change a small portion of the file.
+     * Include just the changing lines, and a few surrounding lines if needed for uniqueness.
+     * Do not include long runs of unchanging lines in SEARCH/REPLACE blocks.
+     * Each line must be complete. Never truncate lines mid-way through as this can cause matching failures.
+  4. Special operations:
+     * To move code: Use two SEARCH/REPLACE blocks (one to delete from original + one to insert at new location)
+     * To delete code: Use empty REPLACE section
+Usage:
+<replace_in_file>
+<path>File path here</path>
+<diff>
+Search and replace blocks here
+</diff> 
+</replace_in_file>
+
+
+## search_files
+Description: Request to perform a regex search across files in a specified directory, providing context-rich results. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context.
+Parameters:
+- path: (required) The path of the directory to search in (relative to the current working directory ${cwdFormatted}). This directory will be recursively searched.
+- regex: (required) The regular expression pattern to search for. Uses Rust regex syntax.
+- file_pattern: (optional) Glob pattern to filter files (e.g., '*.ts' for TypeScript files). If not provided, it will search all files (*).
+Usage:
+<search_files>
+<path>Directory path here</path>
+<regex>Your regex pattern here</regex>
+<file_pattern>file pattern here (optional)</file_pattern>
+</search_files>
+
+## list_files
+Description: Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.
+Parameters:
+- path: (required) The path of the directory to list contents for (relative to the current working directory ${cwdFormatted})
+- recursive: (optional) Whether to list files recursively. Use true for recursive listing, false or omit for top-level only.
+Usage:
+<list_files>
+<path>Directory path here</path>
+<recursive>true or false (optional)</recursive>
+</list_files>
+
+## list_code_definition_names
+Description: Request to list definition names (classes, functions, methods, etc.) used in source code files at the top level of the specified directory. This tool provides insights into the codebase structure and important constructs, encapsulating high-level concepts and relationships that are crucial for understanding the overall architecture.
+Parameters:
+- path: (required) The path of the directory (relative to the current working directory ${cwdFormatted}) to list top level source code definitions for.
+Usage:
+<list_code_definition_names>
+<path>Directory path here</path>
+</list_code_definition_names>${
+		supportsBrowserUse
+			? `
+
+## browser_action
+Description: Request to interact with a Puppeteer-controlled browser. Every action, except \`close\`, will be responded to with a screenshot of the browser's current state, along with any new console logs. You may only perform one browser action per message, and wait for the user's response including a screenshot and logs to determine the next action.
+- The sequence of actions **must always start with** launching the browser at a URL, and **must always end with** closing the browser. If you need to visit a new URL that is not possible to navigate to from the current webpage, you must first close the browser, then launch again at the new URL.
+- While the browser is active, only the \`browser_action\` tool can be used. No other tools should be called during this time. You may proceed to use other tools only after closing the browser. For example if you run into an error and need to fix a file, you must close the browser, then use other tools to make the necessary changes, then re-launch the browser to verify the result.
+- The browser window has a resolution of **${browserWidth}x${browserHeight}** pixels. When performing any click actions, ensure the coordinates are within this resolution range.
+- Before clicking on any elements such as icons, links, or buttons, you must consult the provided screenshot of the page to determine the coordinates of the element. The click should be targeted at the **center of the element**, not on its edges.
+Parameters:
+- action: (required) The action to perform. The available actions are:
+    * launch: Launch a new Puppeteer-controlled browser instance at the specified URL. This **must always be the first action**.
+        - Use with the \`url\` parameter to provide the URL.
+        - Ensure the URL is valid and includes the appropriate protocol (e.g. http://localhost:3000/page, file:///path/to/file.html, etc.)
+    * click: Click at a specific x,y coordinate.
+        - Use with the \`coordinate\` parameter to specify the location.
+        - Always click in the center of an element (icon, button, link, etc.) based on coordinates derived from a screenshot.
+    * type: Type a string of text on the keyboard. You might use this after clicking on a text field to input text.
+        - Use with the \`text\` parameter to provide the string to type.
+    * scroll_down: Scroll down the page by one page height.
+    * scroll_up: Scroll up the page by one page height.
+    * close: Close the Puppeteer-controlled browser instance. This **must always be the final browser action**.
+        - Example: \`<action>close</action>\`
+- url: (optional) Use this for providing the URL for the \`launch\` action.
+    * Example: <url>https://example.com</url>
+- coordinate: (optional) The X and Y coordinates for the \`click\` action. Coordinates should be within the **${browserWidth}x${browserHeight}** resolution.
+    * Example: <coordinate>450,300</coordinate>
+- text: (optional) Use this for providing the text for the \`type\` action.
+    * Example: <text>Hello, world!</text>
+Usage:
+<browser_action>
+<action>Action to perform (e.g., launch, click, type, scroll_down, scroll_up, close)</action>
+<url>URL to launch the browser at (optional)</url>
+<coordinate>x,y coordinates (optional)</coordinate>
+<text>Text to type (optional)</text>
+</browser_action>`
+			: ""
+	}
+
+## use_mcp_tool
+Description: Request to use a tool provided by a connected MCP server. Each MCP server can provide multiple tools with different capabilities. Tools have defined input schemas that specify required and optional parameters.
+Parameters:
+- server_name: (required) The name of the MCP server providing the tool
+- tool_name: (required) The name of the tool to execute
+- arguments: (required) A JSON object containing the tool's input parameters, following the tool's input schema
+Usage:
+<use_mcp_tool>
+<server_name>server name here</server_name>
+<tool_name>tool name here</tool_name>
+<arguments>
+{
+  "param1": "value1",
+  "param2": "value2"
+}
+</arguments>
+</use_mcp_tool>
+
+## access_mcp_resource
+Description: Request to access a resource provided by a connected MCP server. Resources represent data sources that can be used as context, such as files, API responses, or system information.
+Parameters:
+- server_name: (required) The name of the MCP server providing the resource
+- uri: (required) The URI identifying the specific resource to access
+Usage:
+<access_mcp_resource>
+<server_name>server name here</server_name>
+<uri>resource URI here</uri>
+</access_mcp_resource>
+
+## ask_followup_question
+Description: Ask the user a question to gather additional information needed to complete the task. This tool should be used when you encounter ambiguities, need clarification, or require more details to proceed effectively. It allows for interactive problem-solving by enabling direct communication with the user. Use this tool judiciously to maintain a balance between gathering necessary information and avoiding excessive back-and-forth.
+Parameters:
+- question: (required) The question to ask the user. This should be a clear, specific question that addresses the information you need.
+- options: (optional) An array of 2-5 options for the user to choose from. Each option should be a string describing a possible answer. You may not always need to provide options, but it may be helpful in many cases where it can save the user from having to type out a response manually. IMPORTANT: NEVER include an option to toggle to Act mode, as this would be something you need to direct the user to do manually themselves if needed.
+Usage:
+<ask_followup_question>
+<question>Your question here</question>
+<options>
+Array of options here (optional), e.g. ["Option 1", "Option 2", "Option 3"]
+</options>
+</ask_followup_question>
+
+## attempt_completion
+Description: After each tool use, the user will respond with the result of that tool use, i.e. if it succeeded or failed, along with any reasons for failure. Once you've received the results of tool uses and can confirm that the task is complete, use this tool to present the result of your work to the user. Optionally you may provide a CLI command to showcase the result of your work. The user may respond with feedback if they are not satisfied with the result, which you can use to make improvements and try again.
+IMPORTANT NOTE: This tool CANNOT be used until you've confirmed from the user that any previous tool uses were successful. Failure to do so will result in code corruption and system failure. Before using this tool, you must ask yourself in <thinking></thinking> tags if you've confirmed from the user that any previous tool uses were successful. If not, then DO NOT use this tool.
+Parameters:
+- result: (required) The result of the task. Formulate this result in a way that is final and does not require further input from the user. Don't end your result with questions or offers for further assistance.
+- command: (optional) A CLI command to execute to show a live demo of the result to the user. For example, use \`open index.html\` to display a created html website, or \`open localhost:3000\` to display a locally running development server. But DO NOT use commands like \`echo\` or \`cat\` that merely print text. This command should be valid for the current operating system. Ensure the command is properly formatted and does not contain any harmful instructions.
+Usage:
+<attempt_completion>
+<result>
+Your final result description here
+</result>
+<command>Command to demonstrate result (optional)</command>
+</attempt_completion>
+
+## new_task
+Description: Request to create a new task with preloaded context covering the conversation with the user up to this point and key information for continuing with the new task. With this tool, you will create a detailed summary of the conversation so far, paying close attention to the user's explicit requests and your previous actions, with a focus on the most relevant information required for the new task.
+Among other important areas of focus, this summary should be thorough in capturing technical details, code patterns, and architectural decisions that would be essential for continuing with the new task. The user will be presented with a preview of your generated context and can choose to create a new task or keep chatting in the current conversation. The user may choose to start a new task at any point.
+Parameters:
+- Context: (required) The context to preload the new task with. If applicable based on the current task, this should include:
+  1. Current Work: Describe in detail what was being worked on prior to this request to create a new task. Pay special attention to the more recent messages / conversation.
+  2. Key Technical Concepts: List all important technical concepts, technologies, coding conventions, and frameworks discussed, which might be relevant for the new task.
+  3. Relevant Files and Code: If applicable, enumerate specific files and code sections examined, modified, or created for the task continuation. Pay special attention to the most recent messages and changes.
+  4. Problem Solving: Document problems solved thus far and any ongoing troubleshooting efforts.
+  5. Pending Tasks and Next Steps: Outline all pending tasks that you have explicitly been asked to work on, as well as list the next steps you will take for all outstanding work, if applicable. Include code snippets where they add clarity. For any next steps, include direct quotes from the most recent conversation showing exactly what task you were working on and where you left off. This should be verbatim to ensure there's no information loss in context between tasks. It's important to be detailed here.
+Usage:
+<new_task>
+<context>context to preload new task with</context>
+</new_task>
+
+## plan_mode_respond
+Description: Respond to the user's inquiry in an effort to plan a solution to the user's task. This tool should be used when you need to provide a response to a question or statement from the user about how you plan to accomplish the task. This tool is only available in PLAN MODE. The environment_details will specify the current mode, if it is not PLAN MODE then you should not use this tool. Depending on the user's message, you may ask questions to get clarification about the user's request, architect a solution to the task, and to brainstorm ideas with the user. For example, if the user's task is to create a website, you may start by asking some clarifying questions, then present a detailed plan for how you will accomplish the task given the context, and perhaps engage in a back and forth to finalize the details before the user switches you to ACT MODE to implement the solution.
+Parameters:
+- response: (required) The response to provide to the user. Do not try to use tools in this parameter, this is simply a chat response. (You MUST use the response parameter, do not simply place the response text directly within <plan_mode_respond> tags.)
+Usage:
+<plan_mode_respond>
+<response>Your response here</response>
+</plan_mode_respond>
+
+## load_mcp_documentation
+Description: Load documentation about creating MCP servers. This tool should be used when the user requests to create or install an MCP server (the user may ask you something along the lines of "add a tool" that does some function, in other words to create an MCP server that provides tools and resources that may connect to external APIs for example. You have the ability to create an MCP server and add it to a configuration file that will then expose the tools and resources for you to use with \`use_mcp_tool\` and \`access_mcp_resource\`). The documentation provides detailed information about the MCP server creation process, including setup instructions, best practices, and examples.
+Parameters: None
+Usage:
+<load_mcp_documentation>
+</load_mcp_documentation>
+
+# Tool Use Examples
+
+## Example 1: Requesting to execute a command
+
+<execute_command>
+<command>npm run dev</command>
+<requires_approval>false</requires_approval>
+</execute_command>
+
+## Example 2: Requesting to create a new file
+
+<write_to_file>
+<path>src/frontend-config.json</path>
+<content>
+{
+  "apiEndpoint": "https://api.example.com",
+  "theme": {
+    "primaryColor": "#007bff",
+    "secondaryColor": "#6c757d",
+    "fontFamily": "Arial, sans-serif"
+  },
+  "features": {
+    "darkMode": true,
+    "notifications": true,
+    "analytics": false
+  },
+  "version": "1.0.0"
+}
+</content>
+</write_to_file>
+
+## Example 3: Creating a new task
+
+<new_task>
+<context>
+1. Current Work:
+   [Detailed description]
+
+2. Key Technical Concepts:
+   - [Concept 1]
+   - [Concept 2]
+   - [...]
+
+3. Relevant Files and Code:
+   - [File Name 1]
+      - [Summary of why this file is important]
+      - [Summary of the changes made to this file, if any]
+      - [Important Code Snippet]
+   - [File Name 2]
+      - [Important Code Snippet]
+   - [...]
+
+4. Problem Solving:
+   [Detailed description]
+
+5. Pending Tasks and Next Steps:
+   - [Task 1 details & next steps]
+   - [Task 2 details & next steps]
+   - [...]
+</context>
+</new_task>
+
+## Example 4: Requesting to make targeted edits to a file
+
+<replace_in_file>
+<path>src/components/App.tsx</path>
+<diff>
+------- SEARCH
+import React from 'react';
+=======
+import React, { useState } from 'react';
++++++++ REPLACE
+
+------- SEARCH
+function handleSubmit() {
+  saveData();
+  setLoading(false);
+}
+
+=======
++++++++ REPLACE
+
+------- SEARCH
+return (
+  <div>
+=======
+function handleSubmit() {
+  saveData();
+  setLoading(false);
+}
+
+return (
+  <div>
++++++++ REPLACE
+</diff>
+</replace_in_file>
+
+
+## Example 5: Requesting to use an MCP tool
+
+<use_mcp_tool>
+<server_name>weather-server</server_name>
+<tool_name>get_forecast</tool_name>
+<arguments>
+{
+  "city": "San Francisco",
+  "days": 5
+}
+</arguments>
+</use_mcp_tool>
+
+## Example 6: Another example of using an MCP tool (where the server name is a unique identifier such as a URL)
+
+<use_mcp_tool>
+<server_name>github.com/modelcontextprotocol/servers/tree/main/src/github</server_name>
+<tool_name>create_issue</tool_name>
+<arguments>
+{
+  "owner": "octocat",
+  "repo": "hello-world",
+  "title": "Found a bug",
+  "body": "I'm having a problem with this.",
+  "labels": ["bug", "help wanted"],
+  "assignees": ["octocat"]
+}
+</arguments>
+</use_mcp_tool>
+
+# Tool Use Guidelines
+
+1. In <thinking> tags, assess what information you already have and what information you need to proceed with the task.
+2. Choose the most appropriate tool based on the task and the tool descriptions provided. Assess if you need additional information to proceed, and which of the available tools would be most effective for gathering this information. For example using the list_files tool is more effective than running a command like \`ls\` in the terminal. It's critical that you think about each available tool and use the one that best fits the current step in the task.
+3. If multiple actions are needed, use one tool at a time per message to accomplish the task iteratively, with each tool use being informed by the result of the previous tool use. Do not assume the outcome of any tool use. Each step must be informed by the previous step's result.
+4. Formulate your tool use using the XML format specified for each tool.
+5. After each tool use, the user will respond with the result of that tool use. This result will provide you with the necessary information to continue your task or make further decisions. This response may include:
+  - Information about whether the tool succeeded or failed, along with any reasons for failure.
+  - Linter errors that may have arisen due to the changes you made, which you'll need to address.
+  - New terminal output in reaction to the changes, which you may need to consider or act upon.
+  - Any other relevant feedback or information related to the tool use.
+6. ALWAYS wait for user confirmation after each tool use before proceeding. Never assume the success of a tool use without explicit confirmation of the result from the user.
+
+It is crucial to proceed step-by-step, waiting for the user's message after each tool use before moving forward with the task. This approach allows you to:
+1. Confirm the success of each step before proceeding.
+2. Address any issues or errors that arise immediately.
+3. Adapt your approach based on new information or unexpected results.
+4. Ensure that each action builds correctly on the previous ones.
+
+By waiting for and carefully considering the user's response after each tool use, you can react accordingly and make informed decisions about how to proceed with the task. This iterative process helps ensure the overall success and accuracy of your work.
+
+====
+
+MCP SERVERS
+
+The Model Context Protocol (MCP) enables communication between the system and locally running MCP servers that provide additional tools and resources to extend your capabilities.
+
+# Connected MCP Servers
+
+When a server is connected, you can use the server's tools via the \`use_mcp_tool\` tool, and access the server's resources via the \`access_mcp_resource\` tool.
+
+${mcpHubString}
+
+====
+
+EDITING FILES
+
+You have access to two tools for working with files: **write_to_file** and **replace_in_file**. Understanding their roles and selecting the right one for the job will help ensure efficient and accurate modifications.
+
+# write_to_file
+
+## Purpose
+
+- Create a new file, or overwrite the entire contents of an existing file.
+
+## When to Use
+
+- Initial file creation, such as when scaffolding a new project.  
+- Overwriting large boilerplate files where you want to replace the entire content at once.
+- When the complexity or number of changes would make replace_in_file unwieldy or error-prone.
+- When you need to completely restructure a file's content or change its fundamental organization.
+
+## Important Considerations
+
+- Using write_to_file requires providing the file's complete final content.  
+- If you only need to make small changes to an existing file, consider using replace_in_file instead to avoid unnecessarily rewriting the entire file.
+- While write_to_file should not be your default choice, don't hesitate to use it when the situation truly calls for it.
+
+# replace_in_file
+
+## Purpose
+
+- Make targeted edits to specific parts of an existing file without overwriting the entire file.
+
+## When to Use
+
+- Small, localized changes like updating a few lines, function implementations, changing variable names, modifying a section of text, etc.
+- Targeted improvements where only specific portions of the file's content needs to be altered.
+- Especially useful for long files where much of the file will remain unchanged.
+
+## Advantages
+
+- More efficient for minor edits, since you don't need to supply the entire file content.  
+- Reduces the chance of errors that can occur when overwriting large files.
+
+# Choosing the Appropriate Tool
+
+- **Default to replace_in_file** for most changes. It's the safer, more precise option that minimizes potential issues.
+- **Use write_to_file** when:
+  - Creating new files
+  - The changes are so extensive that using replace_in_file would be more complex or risky
+  - You need to completely reorganize or restructure a file
+  - The file is relatively small and the changes affect most of its content
+  - You're generating boilerplate or template files
+
+# Auto-formatting Considerations
+
+- After using either write_to_file or replace_in_file, the user's editor may automatically format the file
+- This auto-formatting may modify the file contents, for example:
+  - Breaking single lines into multiple lines
+  - Adjusting indentation to match project style (e.g. 2 spaces vs 4 spaces vs tabs)
+  - Converting single quotes to double quotes (or vice versa based on project preferences)
+  - Organizing imports (e.g. sorting, grouping by type)
+  - Adding/removing trailing commas in objects and arrays
+  - Enforcing consistent brace style (e.g. same-line vs new-line)
+  - Standardizing semicolon usage (adding or removing based on style)
+- The write_to_file and replace_in_file tool responses will include the final state of the file after any auto-formatting
+- Use this final state as your reference point for any subsequent edits. This is ESPECIALLY important when crafting SEARCH blocks for replace_in_file which require the content to match what's in the file exactly.
+
+# Workflow Tips
+
+1. Before editing, assess the scope of your changes and decide which tool to use.
+2. For targeted edits, apply replace_in_file with carefully crafted SEARCH/REPLACE blocks. If you need multiple changes, you can stack multiple SEARCH/REPLACE blocks within a single replace_in_file call.
+3. For major overhauls or initial file creation, rely on write_to_file.
+4. Once the file has been edited with either write_to_file or replace_in_file, the system will provide you with the final state of the modified file. Use this updated content as the reference point for any subsequent SEARCH/REPLACE operations, since it reflects any auto-formatting or user-applied changes.
+By thoughtfully selecting between write_to_file and replace_in_file, you can make your file editing process smoother, safer, and more efficient.
+
+====
+ 
+ACT MODE V.S. PLAN MODE
+
+In each user message, the environment_details will specify the current mode. There are two modes:
+
+- ACT MODE: In this mode, you have access to all tools EXCEPT the plan_mode_respond tool.
+ - In ACT MODE, you use tools to accomplish the user's task. Once you've completed the user's task, you use the attempt_completion tool to present the result of the task to the user.
+- PLAN MODE: In this special mode, you have access to the plan_mode_respond tool.
+ - In PLAN MODE, the goal is to gather information and get context to create a detailed plan for accomplishing the task, which the user will review and approve before they switch you to ACT MODE to implement the solution.
+ - In PLAN MODE, when you need to converse with the user or present a plan, you should use the plan_mode_respond tool to deliver your response directly, rather than using <thinking> tags to analyze when to respond. Do not talk about using plan_mode_respond - just use it directly to share your thoughts and provide helpful answers.
+
+## What is PLAN MODE?
+
+- While you are usually in ACT MODE, the user may switch to PLAN MODE in order to have a back and forth with you to plan how to best accomplish the task. 
+- When starting in PLAN MODE, depending on the user's request, you may need to do some information gathering e.g. using read_file or search_files to get more context about the task. You may also ask the user clarifying questions to get a better understanding of the task. You may return mermaid diagrams to visually display your understanding.
+- Once you've gained more context about the user's request, you should architect a detailed plan for how you will accomplish the task. Returning mermaid diagrams may be helpful here as well.
+- Then you might ask the user if they are pleased with this plan, or if they would like to make any changes. Think of this as a brainstorming session where you can discuss the task and plan the best way to accomplish it.
+- If at any point a mermaid diagram would make your plan clearer to help the user quickly see the structure, you are encouraged to include a Mermaid code block in the response. (Note: if you use colors in your mermaid diagrams, be sure to use high contrast colors so the text is readable.)
+- Finally once it seems like you've reached a good plan, ask the user to switch you back to ACT MODE to implement the solution.
+
+====
+ 
+CAPABILITIES
+
+- You have access to tools that let you execute CLI commands on the user's computer, list files, view source code definitions, regex search${
+		supportsBrowserUse ? ", use the browser" : ""
+	}, read and edit files, and ask follow-up questions. These tools help you effectively accomplish a wide range of tasks, such as writing code, making edits or improvements to existing files, understanding the current state of a project, performing system operations, and much more.
+- When the user initially gives you a task, a recursive list of all filepaths in the current working directory ('${cwdFormatted}') will be included in environment_details. This provides an overview of the project's file structure, offering key insights into the project from directory/file names (how developers conceptualize and organize their code) and file extensions (the language used). This can also guide decision-making on which files to explore further. If you need to further explore directories such as outside the current working directory, you can use the list_files tool. If you pass 'true' for the recursive parameter, it will list files recursively. Otherwise, it will list files at the top level, which is better suited for generic directories where you don't necessarily need the nested structure, like the Desktop.
+- You can use search_files to perform regex searches across files in a specified directory, outputting context-rich results that include surrounding lines. This is particularly useful for understanding code patterns, finding specific implementations, or identifying areas that need refactoring.
+- You can use the list_code_definition_names tool to get an overview of source code definitions for all files at the top level of a specified directory. This can be particularly useful when you need to understand the broader context and relationships between certain parts of the code. You may need to call this tool multiple times to understand various parts of the codebase related to the task.
+	- For example, when asked to make edits or improvements you might analyze the file structure in the initial environment_details to get an overview of the project, then use list_code_definition_names to get further insight using source code definitions for files located in relevant directories, then read_file to examine the contents of relevant files, analyze the code and suggest improvements or make necessary edits, then use the replace_in_file tool to implement changes. If you refactored code that could affect other parts of the codebase, you could use search_files to ensure you update other files as needed.
+- You can use the execute_command tool to run commands on the user's computer whenever you feel it can help accomplish the user's task. When you need to execute a CLI command, you must provide a clear explanation of what the command does. Prefer to execute complex CLI commands over creating executable scripts, since they are more flexible and easier to run. Interactive and long-running commands are allowed, since the commands are run in the user's VSCode terminal. The user may keep commands running in the background and you will be kept updated on their status along the way. Each command you execute is run in a new terminal instance.${
+		supportsBrowserUse
+			? "\n- You can use the browser_action tool to interact with websites (including html files and locally running development servers) through a Puppeteer-controlled browser when you feel it is necessary in accomplishing the user's task. This tool is particularly useful for web development tasks as it allows you to launch a browser, navigate to pages, interact with elements through clicks and keyboard input, and capture the results through screenshots and console logs. This tool may be useful at key stages of web development tasks-such as after implementing new features, making substantial changes, when troubleshooting issues, or to verify the result of your work. You can analyze the provided screenshots to ensure correct rendering or identify errors, and review console logs for runtime issues.\n	- For example, if asked to add a component to a react website, you might create the necessary files, use execute_command to run the site locally, then use browser_action to launch the browser, navigate to the local server, and verify the component renders & functions correctly before closing the browser."
+			: ""
+	}
+- You have access to MCP servers that may provide additional tools and resources. Each server may provide different capabilities that you can use to accomplish tasks more effectively.
+- You can use LaTeX syntax in your responses to render mathematical expressions
+
+====
+
+RULES
+
+- Your current working directory is: ${cwdFormatted}
+- You cannot \`cd\` into a different directory to complete a task. You are stuck operating from '${cwdFormatted}', so be sure to pass in the correct 'path' parameter when using tools that require a path.
+- Do not use the ~ character or $HOME to refer to the home directory.
+- Before using the execute_command tool, you must first think about the SYSTEM INFORMATION context provided to understand the user's environment and tailor your commands to ensure they are compatible with their system. You must also consider if the command you need to run should be executed in a specific directory outside of the current working directory '${cwdFormatted}', and if so prepend with \`cd\`'ing into that directory && then executing the command (as one command since you are stuck operating from '${cwdFormatted}'). For example, if you needed to run \`npm install\` in a project outside of '${cwdFormatted}', you would need to prepend with a \`cd\` i.e. pseudocode for this would be \`cd (path to project) && (command, in this case npm install)\`.
+- When using the search_files tool, craft your regex patterns carefully to balance specificity and flexibility. Based on the user's task you may use it to find code patterns, TODO comments, function definitions, or any text-based information across the project. The results include context, so analyze the surrounding code to better understand the matches. Leverage the search_files tool in combination with other tools for more comprehensive analysis. For example, use it to find specific code patterns, then use read_file to examine the full context of interesting matches before using replace_in_file to make informed changes.
+- When creating a new project (such as an app, website, or any software project), organize all new files within a dedicated project directory unless the user specifies otherwise. Use appropriate file paths when creating files, as the write_to_file tool will automatically create any necessary directories. Structure the project logically, adhering to best practices for the specific type of project being created. Unless otherwise specified, new projects should be easily run without additional setup, for example most projects can be built in HTML, CSS, and JavaScript - which you can open in a browser.
+- Be sure to consider the type of project (e.g. Python, JavaScript, web application) when determining the appropriate structure and files to include. Also consider what files may be most relevant to accomplishing the task, for example looking at a project's manifest file would help you understand the project's dependencies, which you could incorporate into any code you write.
+- When making changes to code, always consider the context in which the code is being used. Ensure that your changes are compatible with the existing codebase and that they follow the project's coding standards and best practices.
+- When you want to modify a file, use the replace_in_file or write_to_file tool directly with the desired changes. You do not need to display the changes before using the tool.
+- Do not ask for more information than necessary. Use the tools provided to accomplish the user's request efficiently and effectively. When you've completed your task, you must use the attempt_completion tool to present the result to the user. The user may provide feedback, which you can use to make improvements and try again.
+- You are only allowed to ask the user questions using the ask_followup_question tool. Use this tool only when you need additional details to complete a task, and be sure to use a clear and concise question that will help you move forward with the task. However if you can use the available tools to avoid having to ask the user questions, you should do so. For example, if the user mentions a file that may be in an outside directory like the Desktop, you should use the list_files tool to list the files in the Desktop and check if the file they are talking about is there, rather than asking the user to provide the file path themselves.
+- When executing commands, if you don't see the expected output, assume the terminal executed the command successfully and proceed with the task. The user's terminal may be unable to stream the output back properly. If you absolutely need to see the actual terminal output, use the ask_followup_question tool to request the user to copy and paste it back to you.
+- The user may provide a file's contents directly in their message, in which case you shouldn't use the read_file tool to get the file contents again since you already have it.
+- Your goal is to try to accomplish the user's task, NOT engage in a back and forth conversation.${
+		supportsBrowserUse
+			? `\n- The user may ask generic non-development tasks, such as "what\'s the latest news" or "look up the weather in San Diego", in which case you might use the browser_action tool to complete the task if it makes sense to do so, rather than trying to create a website or using curl to answer the question. However, if an available MCP server tool or resource can be used instead, you should prefer to use it over browser_action.`
+			: ""
+	}
+- NEVER end attempt_completion result with a question or request to engage in further conversation! Formulate the end of your result in a way that is final and does not require further input from the user.
+- You are STRICTLY FORBIDDEN from starting your messages with "Great", "Certainly", "Okay", "Sure". You should NOT be conversational in your responses, but rather direct and to the point. For example you should NOT say "Great, I've updated the CSS" but instead something like "I've updated the CSS". It is important you be clear and technical in your messages.
+- When presented with images, utilize your vision capabilities to thoroughly examine them and extract meaningful information. Incorporate these insights into your thought process as you accomplish the user's task.
+- At the end of each user message, you will automatically receive environment_details. This information is not written by the user themselves, but is auto-generated to provide potentially relevant context about the project structure and environment. While this information can be valuable for understanding the project context, do not treat it as a direct part of the user's request or response. Use it to inform your actions and decisions, but don't assume the user is explicitly asking about or referring to this information unless they clearly do so in their message. When using environment_details, explain your actions clearly to ensure the user understands, as they may not be aware of these details.
+- Before executing commands, check the "Actively Running Terminals" section in environment_details. If present, consider how these active processes might impact your task. For example, if a local development server is already running, you wouldn't need to start it again. If no active terminals are listed, proceed with command execution as normal.
+- When using the replace_in_file tool, you must include complete lines in your SEARCH blocks, not partial lines. The system requires exact line matches and cannot match partial lines. For example, if you want to match a line containing "const x = 5;", your SEARCH block must include the entire line, not just "x = 5" or other fragments.
+- When using the replace_in_file tool, if you use multiple SEARCH/REPLACE blocks, list them in the order they appear in the file. For example if you need to make changes to both line 10 and line 50, first include the SEARCH/REPLACE block for line 10, followed by the SEARCH/REPLACE block for line 50.
+- When using the replace_in_file tool, Do NOT add extra characters to the markers (e.g., ------- SEARCH> is INVALID). Do NOT forget to use the closing +++++++ REPLACE marker. Do NOT modify the marker format in any way. Malformed XML will cause complete tool failure and break the entire editing process.
+- It is critical you wait for the user's response after each tool use, in order to confirm the success of the tool use. For example, if asked to make a todo app, you would create a file, wait for the user's response it was created successfully, then create another file if needed, wait for the user's response it was created successfully, etc.${
+		supportsBrowserUse
+			? " Then if you want to test your work, you might use browser_action to launch the site, wait for the user's response confirming the site was launched along with a screenshot, then perhaps e.g., click a button to test functionality if needed, wait for the user's response confirming the button was clicked along with a screenshot of the new state, before finally closing the browser."
+			: ""
+	}
+- MCP operations should be used one at a time, similar to other tool usage. Wait for confirmation of success before proceeding with additional operations.
+
+====
+
+SYSTEM INFORMATION
+
+Operating System: ${os}
+Default Shell: ${shell}
+Home Directory: ${homeFormatted}
+Current Working Directory: ${cwdFormatted}
+
+====
+
+OBJECTIVE
+
+You accomplish a given task iteratively, breaking it down into clear steps and working through them methodically.
+
+1. Analyze the user's task and set clear, achievable goals to accomplish it. Prioritize these goals in a logical order.
+2. Work through these goals sequentially, utilizing available tools one at a time as necessary. Each goal should correspond to a distinct step in your problem-solving process. You will be informed on the work completed and what's remaining as you go.
+3. Remember, you have extensive capabilities with access to a wide range of tools that can be used in powerful and clever ways as necessary to accomplish each goal. Before calling a tool, do some analysis within <thinking></thinking> tags. First, analyze the file structure provided in environment_details to gain context and insights for proceeding effectively. Then, think about which of the provided tools is the most relevant tool to accomplish the user's task. Next, go through each of the required parameters of the relevant tool and determine if the user has directly provided or given enough information to infer a value. When deciding if the parameter can be inferred, carefully consider all the context to see if it supports a specific value. If all of the required parameters are present or can be reasonably inferred, close the thinking tag and proceed with the tool use. BUT, if one of the values for a required parameter is missing, DO NOT invoke the tool (not even with fillers for the missing params) and instead, ask the user to provide the missing parameters using the ask_followup_question tool. DO NOT ask for more information on optional parameters if it is not provided.
+4. Once you've completed the user's task, you must use the attempt_completion tool to present the result of the task to the user. You may also provide a CLI command to showcase the result of your task; this can be particularly useful for web development tasks, where you can run e.g. \`open index.html\` to show the website you've built.
+5. The user may provide feedback, which you can use to make improvements and try again. But DO NOT continue in pointless back and forth conversations, i.e. don't end your responses with questions or offers for further assistance.
+${
+	userCustomInstructions
+		? `\n
+====
+
+USER'S CUSTOM INSTRUCTIONS
+
+The following additional instructions are provided by the user, and should be followed to the best of your ability without interfering with the TOOL USE guidelines.
+
+${userCustomInstructions}`
+		: ""
+}`
+}

evals/diff-edits/prompts/claude4SystemPrompt-06-06-25.ts

@@ -0,0 +1,640 @@
+/**
+ * Use all standard prompt values to construct prompt
+ */
+export const claude4SystemPrompt = (
+	cwdFormatted: string,
+	supportsBrowserUse: boolean,
+	browserWidth: number,
+	browserHeight: number,
+	os: string,
+	shell: string,
+	homeFormatted: string,
+	mcpHubString: string,
+	userCustomInstructions: string,
+) => {
+	return `You are Cline, a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.
+
+====
+
+TOOL USE
+
+You have access to a set of tools that are executed upon the user's approval. You can use one tool per message, and will receive the result of that tool use in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.
+
+# Tool Use Formatting
+
+Tool use is formatted using XML-style tags. The tool name is enclosed in opening and closing tags, and each parameter is similarly enclosed within its own set of tags. Here's the structure:
+
+<tool_name>
+<parameter1_name>value1</parameter1_name>
+<parameter2_name>value2</parameter2_name>
+...
+</tool_name>
+
+For example:
+
+<read_file>
+<path>src/main.js</path>
+</read_file>
+
+Always adhere to this format for the tool use to ensure proper parsing and execution.
+
+# Tools
+
+## execute_command
+Description: Request to execute a CLI command on the system. Use this when you need to perform system operations or run specific commands to accomplish any step in the user's task. You must tailor your command to the user's system and provide a clear explanation of what the command does. For command chaining, use the appropriate chaining syntax for the user's shell. Prefer to execute complex CLI commands over creating executable scripts, as they are more flexible and easier to run. Commands will be executed in the current working directory: ${cwdFormatted}
+Parameters:
+- command: (required) The CLI command to execute. This should be valid for the current operating system. Ensure the command is properly formatted and does not contain any harmful instructions.
+- requires_approval: (required) A boolean indicating whether this command requires explicit user approval before execution in case the user has auto-approve mode enabled. Set to 'true' for potentially impactful operations like installing/uninstalling packages, deleting/overwriting files, system configuration changes, network operations, or any commands that could have unintended side effects. Set to 'false' for safe operations like reading files/directories, running development servers, building projects, and other non-destructive operations.
+Usage:
+<execute_command>
+<command>Your command here</command>
+<requires_approval>true or false</requires_approval>
+</execute_command>
+
+## read_file
+Description: Request to read the contents of a file at the specified path. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. Automatically extracts raw text from PDF and DOCX files. May not be suitable for other types of binary files, as it returns the raw content as a string.
+Parameters:
+- path: (required) The path of the file to read (relative to the current working directory ${cwdFormatted})
+Usage:
+<read_file>
+<path>File path here</path>
+</read_file>
+
+## write_to_file
+Description: Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file.
+Parameters:
+- path: (required) The path of the file to write to (relative to the current working directory ${cwdFormatted})
+- content: (required) The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified.
+Usage:
+<write_to_file>
+<path>File path here</path>
+<content>
+Your file content here
+</content>
+</write_to_file>
+
+## replace_in_file
+Description: Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.
+Parameters:
+- path: (required) The path of the file to modify (relative to the current working directory ${cwdFormatted})
+- diff: (required) One or more SEARCH/REPLACE blocks following this exact format:
+  \`\`\`
+  ------- SEARCH
+  [exact content to find]
+  =======
+  [new content to replace with]
+  +++++++ REPLACE
+  \`\`\`
+  Critical rules:
+  1. SEARCH content must match the associated file section to find EXACTLY:
+     * Match character-for-character including whitespace, indentation, line endings
+     * Include all comments, docstrings, etc.
+  2. SEARCH/REPLACE blocks will ONLY replace the first match occurrence.
+     * Including multiple unique SEARCH/REPLACE blocks if you need to make multiple changes.
+     * Include *just* enough lines in each SEARCH section to uniquely match each set of lines that need to change.
+     * When using multiple SEARCH/REPLACE blocks, list them in the order they appear in the file.
+  3. Keep SEARCH/REPLACE blocks concise:
+     * Break large SEARCH/REPLACE blocks into a series of smaller blocks that each change a small portion of the file.
+     * Include just the changing lines, and a few surrounding lines if needed for uniqueness.
+     * Do not include long runs of unchanging lines in SEARCH/REPLACE blocks.
+     * Each line must be complete. Never truncate lines mid-way through as this can cause matching failures.
+  4. Special operations:
+     * To move code: Use two SEARCH/REPLACE blocks (one to delete from original + one to insert at new location)
+     * To delete code: Use empty REPLACE section
+Usage:
+<replace_in_file>
+<path>File path here</path>
+<diff>
+Search and replace blocks here
+</diff> 
+</replace_in_file>
+
+## list_files
+Description: Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.
+Parameters:
+- path: (required) The path of the directory to list contents for (relative to the current working directory ${cwdFormatted})
+- recursive: (optional) Whether to list files recursively. Use true for recursive listing, false or omit for top-level only.
+Usage:
+<list_files>
+<path>Directory path here</path>
+<recursive>true or false (optional)</recursive>
+</list_files>
+
+## list_code_definition_names
+Description: Request to list definition names (classes, functions, methods, etc.) used in source code files at the top level of the specified directory. This tool provides insights into the codebase structure and important constructs, encapsulating high-level concepts and relationships that are crucial for understanding the overall architecture.
+Parameters:
+- path: (required) The path of the directory (relative to the current working directory ${cwdFormatted}) to list top level source code definitions for.
+Usage:
+<list_code_definition_names>
+<path>Directory path here</path>
+</list_code_definition_names>${
+		supportsBrowserUse
+			? `
+
+## browser_action
+Description: Request to interact with a Puppeteer-controlled browser. Every action, except \`close\`, will be responded to with a screenshot of the browser's current state, along with any new console logs. You may only perform one browser action per message, and wait for the user's response including a screenshot and logs to determine the next action.
+- The sequence of actions **must always start with** launching the browser at a URL, and **must always end with** closing the browser. If you need to visit a new URL that is not possible to navigate to from the current webpage, you must first close the browser, then launch again at the new URL.
+- While the browser is active, only the \`browser_action\` tool can be used. No other tools should be called during this time. You may proceed to use other tools only after closing the browser. For example if you run into an error and need to fix a file, you must close the browser, then use other tools to make the necessary changes, then re-launch the browser to verify the result.
+- The browser window has a resolution of **${browserWidth}x${browserHeight}** pixels. When performing any click actions, ensure the coordinates are within this resolution range.
+- Before clicking on any elements such as icons, links, or buttons, you must consult the provided screenshot of the page to determine the coordinates of the element. The click should be targeted at the **center of the element**, not on its edges.
+Parameters:
+- action: (required) The action to perform. The available actions are:
+    * launch: Launch a new Puppeteer-controlled browser instance at the specified URL. This **must always be the first action**.
+        - Use with the \`url\` parameter to provide the URL.
+        - Ensure the URL is valid and includes the appropriate protocol (e.g. http://localhost:3000/page, file:///path/to/file.html, etc.)
+    * click: Click at a specific x,y coordinate.
+        - Use with the \`coordinate\` parameter to specify the location.
+        - Always click in the center of an element (icon, button, link, etc.) based on coordinates derived from a screenshot.
+    * type: Type a string of text on the keyboard. You might use this after clicking on a text field to input text.
+        - Use with the \`text\` parameter to provide the string to type.
+    * scroll_down: Scroll down the page by one page height.
+    * scroll_up: Scroll up the page by one page height.
+    * close: Close the Puppeteer-controlled browser instance. This **must always be the final browser action**.
+        - Example: \`<action>close</action>\`
+- url: (optional) Use this for providing the URL for the \`launch\` action.
+    * Example: <url>https://example.com</url>
+- coordinate: (optional) The X and Y coordinates for the \`click\` action. Coordinates should be within the **${browserWidth}x${browserHeight}** resolution.
+    * Example: <coordinate>450,300</coordinate>
+- text: (optional) Use this for providing the text for the \`type\` action.
+    * Example: <text>Hello, world!</text>
+Usage:
+<browser_action>
+<action>Action to perform (e.g., launch, click, type, scroll_down, scroll_up, close)</action>
+<url>URL to launch the browser at (optional)</url>
+<coordinate>x,y coordinates (optional)</coordinate>
+<text>Text to type (optional)</text>
+</browser_action>`
+			: ""
+	}
+
+## web_fetch
+Description: Fetches content from a specified URL and processes into markdown
+- Takes a URL as input
+- Fetches the URL content, converts HTML to markdown
+- Use this tool when you need to retrieve and analyze web content
+- IMPORTANT: If an MCP-provided web fetch tool is available, prefer using that tool instead of this one, as it may have fewer restrictions.
+- The URL must be a fully-formed valid URL
+- HTTP URLs will be automatically upgraded to HTTPS
+- This tool is read-only and does not modify any files
+Parameters:
+- url: (required) The URL to fetch content from
+Usage:
+<web_fetch>
+<url>https://example.com/docs</url>
+</web_fetch>
+
+
+## use_mcp_tool
+Description: Request to use a tool provided by a connected MCP server. Each MCP server can provide multiple tools with different capabilities. Tools have defined input schemas that specify required and optional parameters.
+Parameters:
+- server_name: (required) The name of the MCP server providing the tool
+- tool_name: (required) The name of the tool to execute
+- arguments: (required) A JSON object containing the tool's input parameters, following the tool's input schema
+Usage:
+<use_mcp_tool>
+<server_name>server name here</server_name>
+<tool_name>tool name here</tool_name>
+<arguments>
+{
+  "param1": "value1",
+  "param2": "value2"
+}
+</arguments>
+</use_mcp_tool>
+
+## access_mcp_resource
+Description: Request to access a resource provided by a connected MCP server. Resources represent data sources that can be used as context, such as files, API responses, or system information.
+Parameters:
+- server_name: (required) The name of the MCP server providing the resource
+- uri: (required) The URI identifying the specific resource to access
+Usage:
+<access_mcp_resource>
+<server_name>server name here</server_name>
+<uri>resource URI here</uri>
+</access_mcp_resource>
+
+## search_files
+Description: Request to perform a regex search across files in a specified directory, providing context-rich results. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context. IMPORTANT NOTE: Use this tool sparingly, and opt to explore the codebase using the \`list_files\` and \`read_file\` tools instead.
+Parameters:
+- path: (required) The path of the directory to search in (relative to the current working directory ${cwdFormatted}). This directory will be recursively searched.
+- regex: (required) The regular expression pattern to search for. Uses Rust regex syntax.
+- file_pattern: (optional) Glob pattern to filter files (e.g., '*.ts' for TypeScript files). If not provided, it will search all files (*).
+Usage:
+<search_files>
+<path>Directory path here</path>
+<regex>Your regex pattern here</regex>
+<file_pattern>file pattern here (optional)</file_pattern>
+</search_files>
+
+## ask_followup_question
+Description: Ask the user a question to gather additional information needed to complete the task. This tool should be used when you encounter ambiguities, need clarification, or require more details to proceed effectively. It allows for interactive problem-solving by enabling direct communication with the user. Use this tool judiciously to maintain a balance between gathering necessary information and avoiding excessive back-and-forth.
+Parameters:
+- question: (required) The question to ask the user. This should be a clear, specific question that addresses the information you need.
+- options: (optional) An array of 2-5 options for the user to choose from. Each option should be a string describing a possible answer. You may not always need to provide options, but it may be helpful in many cases where it can save the user from having to type out a response manually. IMPORTANT: NEVER include an option to toggle to Act mode, as this would be something you need to direct the user to do manually themselves if needed.
+Usage:
+<ask_followup_question>
+<question>Your question here</question>
+<options>
+Array of options here (optional), e.g. ["Option 1", "Option 2", "Option 3"]
+</options>
+</ask_followup_question>
+
+## attempt_completion
+Description: After each tool use, the user will respond with the result of that tool use, i.e. if it succeeded or failed, along with any reasons for failure. Once you've received the results of tool uses and can confirm that the task is complete, use this tool to present the result of your work to the user. Optionally you may provide a CLI command to showcase the result of your work. The user may respond with feedback if they are not satisfied with the result, which you can use to make improvements and try again.
+IMPORTANT NOTE: This tool CANNOT be used until you've confirmed from the user that any previous tool uses were successful. Failure to do so will result in code corruption and system failure. Before using this tool, you must ask yourself in <thinking></thinking> tags if you've confirmed from the user that any previous tool uses were successful. If not, then DO NOT use this tool.
+Parameters:
+- result: (required) The result of the task. Formulate this result in a way that is final and does not require further input from the user. Don't end your result with questions or offers for further assistance.
+- command: (optional) A CLI command to execute to show a live demo of the result to the user. For example, use \`open index.html\` to display a created html website, or \`open localhost:3000\` to display a locally running development server. But DO NOT use commands like \`echo\` or \`cat\` that merely print text. This command should be valid for the current operating system. Ensure the command is properly formatted and does not contain any harmful instructions.
+Usage:
+<attempt_completion>
+<result>
+Your final result description here
+</result>
+<command>Command to demonstrate result (optional)</command>
+</attempt_completion>
+
+## new_task
+Description: Request to create a new task with preloaded context covering the conversation with the user up to this point and key information for continuing with the new task. With this tool, you will create a detailed summary of the conversation so far, paying close attention to the user's explicit requests and your previous actions, with a focus on the most relevant information required for the new task.
+Among other important areas of focus, this summary should be thorough in capturing technical details, code patterns, and architectural decisions that would be essential for continuing with the new task. The user will be presented with a preview of your generated context and can choose to create a new task or keep chatting in the current conversation. The user may choose to start a new task at any point.
+Parameters:
+- Context: (required) The context to preload the new task with. If applicable based on the current task, this should include:
+  1. Current Work: Describe in detail what was being worked on prior to this request to create a new task. Pay special attention to the more recent messages / conversation.
+  2. Key Technical Concepts: List all important technical concepts, technologies, coding conventions, and frameworks discussed, which might be relevant for the new task.
+  3. Relevant Files and Code: If applicable, enumerate specific files and code sections examined, modified, or created for the task continuation. Pay special attention to the most recent messages and changes.
+  4. Problem Solving: Document problems solved thus far and any ongoing troubleshooting efforts.
+  5. Pending Tasks and Next Steps: Outline all pending tasks that you have explicitly been asked to work on, as well as list the next steps you will take for all outstanding work, if applicable. Include code snippets where they add clarity. For any next steps, include direct quotes from the most recent conversation showing exactly what task you were working on and where you left off. This should be verbatim to ensure there's no information loss in context between tasks. It's important to be detailed here.
+Usage:
+<new_task>
+<context>context to preload new task with</context>
+</new_task>
+
+## plan_mode_respond
+Description: Respond to the user's inquiry in an effort to plan a solution to the user's task. This tool should be used when you need to provide a response to a question or statement from the user about how you plan to accomplish the task. This tool is only available in PLAN MODE. The environment_details will specify the current mode, if it is not PLAN MODE then you should not use this tool. Depending on the user's message, you may ask questions to get clarification about the user's request, architect a solution to the task, and to brainstorm ideas with the user. For example, if the user's task is to create a website, you may start by asking some clarifying questions, then present a detailed plan for how you will accomplish the task given the context, and perhaps engage in a back and forth to finalize the details before the user switches you to ACT MODE to implement the solution. IMPORTANT NOTE: You should NOT ask for permission to read files or explore the repo. Just do that proactively. This tool should only be used when you've already gathered enough information to make a plan, or if you have a question for the user.
+Parameters:
+- response: (required) The response to provide to the user. Do not try to use tools in this parameter, this is simply a chat response. (You MUST use the response parameter, do not simply place the response text directly within <plan_mode_respond> tags.)
+Usage:
+<plan_mode_respond>
+<response>Your response here</response>
+</plan_mode_respond>
+
+## load_mcp_documentation
+Description: Load documentation about creating MCP servers. This tool should be used when the user requests to create or install an MCP server (the user may ask you something along the lines of "add a tool" that does some function, in other words to create an MCP server that provides tools and resources that may connect to external APIs for example. You have the ability to create an MCP server and add it to a configuration file that will then expose the tools and resources for you to use with \`use_mcp_tool\` and \`access_mcp_resource\`). The documentation provides detailed information about the MCP server creation process, including setup instructions, best practices, and examples.
+Parameters: None
+Usage:
+<load_mcp_documentation>
+</load_mcp_documentation>
+
+# Tool Use Examples
+
+## Example 1: Requesting to execute a command
+
+<execute_command>
+<command>npm run dev</command>
+<requires_approval>false</requires_approval>
+</execute_command>
+
+## Example 2: Requesting to create a new file
+
+<write_to_file>
+<path>src/frontend-config.json</path>
+<content>
+{
+  "apiEndpoint": "https://api.example.com",
+  "theme": {
+    "primaryColor": "#007bff",
+    "secondaryColor": "#6c757d",
+    "fontFamily": "Arial, sans-serif"
+  },
+  "features": {
+    "darkMode": true,
+    "notifications": true,
+    "analytics": false
+  },
+  "version": "1.0.0"
+}
+</content>
+</write_to_file>
+
+## Example 3: Creating a new task
+
+<new_task>
+<context>
+1. Current Work:
+   [Detailed description]
+
+2. Key Technical Concepts:
+   - [Concept 1]
+   - [Concept 2]
+   - [...]
+
+3. Relevant Files and Code:
+   - [File Name 1]
+      - [Summary of why this file is important]
+      - [Summary of the changes made to this file, if any]
+      - [Important Code Snippet]
+   - [File Name 2]
+      - [Important Code Snippet]
+   - [...]
+
+4. Problem Solving:
+   [Detailed description]
+
+5. Pending Tasks and Next Steps:
+   - [Task 1 details & next steps]
+   - [Task 2 details & next steps]
+   - [...]
+</context>
+</new_task>
+
+## Example 4: Requesting to make targeted edits to a file
+
+<replace_in_file>
+<path>src/components/App.tsx</path>
+<diff>
+------- SEARCH
+import React from 'react';
+=======
+import React, { useState } from 'react';
++++++++ REPLACE
+
+------- SEARCH
+function handleSubmit() {
+  saveData();
+  setLoading(false);
+}
+
+=======
++++++++ REPLACE
+
+------- SEARCH
+return (
+  <div>
+=======
+function handleSubmit() {
+  saveData();
+  setLoading(false);
+}
+
+return (
+  <div>
++++++++ REPLACE
+</diff>
+</replace_in_file>
+
+
+## Example 5: Requesting to use an MCP tool
+
+<use_mcp_tool>
+<server_name>weather-server</server_name>
+<tool_name>get_forecast</tool_name>
+<arguments>
+{
+  "city": "San Francisco",
+  "days": 5
+}
+</arguments>
+</use_mcp_tool>
+
+## Example 6: Another example of using an MCP tool (where the server name is a unique identifier such as a URL)
+
+<use_mcp_tool>
+<server_name>github.com/modelcontextprotocol/servers/tree/main/src/github</server_name>
+<tool_name>create_issue</tool_name>
+<arguments>
+{
+  "owner": "octocat",
+  "repo": "hello-world",
+  "title": "Found a bug",
+  "body": "I'm having a problem with this.",
+  "labels": ["bug", "help wanted"],
+  "assignees": ["octocat"]
+}
+</arguments>
+</use_mcp_tool>
+
+# Tool Use Guidelines
+
+1. In <thinking> tags, assess what information you already have and what information you need to proceed with the task.
+2. Choose the most appropriate tool based on the task and the tool descriptions provided. Assess if you need additional information to proceed, and which of the available tools would be most effective for gathering this information. For example using the list_files tool is more effective than running a command like \`ls\` in the terminal. It's critical that you think about each available tool and use the one that best fits the current step in the task.
+3. If multiple actions are needed, use one tool at a time per message to accomplish the task iteratively, with each tool use being informed by the result of the previous tool use. Do not assume the outcome of any tool use. Each step must be informed by the previous step's result.
+4. Formulate your tool use using the XML format specified for each tool.
+5. After each tool use, the user will respond with the result of that tool use. This result will provide you with the necessary information to continue your task or make further decisions. This response may include:
+  - Information about whether the tool succeeded or failed, along with any reasons for failure.
+  - Linter errors that may have arisen due to the changes you made, which you'll need to address.
+  - New terminal output in reaction to the changes, which you may need to consider or act upon.
+  - Any other relevant feedback or information related to the tool use.
+6. ALWAYS wait for user confirmation after each tool use before proceeding. Never assume the success of a tool use without explicit confirmation of the result from the user.
+
+It is crucial to proceed step-by-step, waiting for the user's message after each tool use before moving forward with the task. This approach allows you to:
+1. Confirm the success of each step before proceeding.
+2. Address any issues or errors that arise immediately.
+3. Adapt your approach based on new information or unexpected results.
+4. Ensure that each action builds correctly on the previous ones.
+
+By waiting for and carefully considering the user's response after each tool use, you can react accordingly and make informed decisions about how to proceed with the task. This iterative process helps ensure the overall success and accuracy of your work.
+
+====
+
+MCP SERVERS
+
+The Model Context Protocol (MCP) enables communication between the system and locally running MCP servers that provide additional tools and resources to extend your capabilities.
+
+# Connected MCP Servers
+
+When a server is connected, you can use the server's tools via the \`use_mcp_tool\` tool, and access the server's resources via the \`access_mcp_resource\` tool.
+
+${mcpHubString}
+
+====
+
+EDITING FILES
+
+You have access to two tools for working with files: **write_to_file** and **replace_in_file**. Understanding their roles and selecting the right one for the job will help ensure efficient and accurate modifications.
+
+# write_to_file
+
+## Purpose
+
+- Create a new file, or overwrite the entire contents of an existing file.
+
+## When to Use
+
+- Initial file creation, such as when scaffolding a new project.  
+- Overwriting large boilerplate files where you want to replace the entire content at once.
+- When the complexity or number of changes would make replace_in_file unwieldy or error-prone.
+- When you need to completely restructure a file's content or change its fundamental organization.
+
+## Important Considerations
+
+- Using write_to_file requires providing the file's complete final content.  
+- If you only need to make small changes to an existing file, consider using replace_in_file instead to avoid unnecessarily rewriting the entire file.
+- While write_to_file should not be your default choice, don't hesitate to use it when the situation truly calls for it.
+
+# replace_in_file
+
+## Purpose
+
+- Make targeted edits to specific parts of an existing file without overwriting the entire file.
+
+## When to Use
+
+- Small, localized changes like updating a few lines, function implementations, changing variable names, modifying a section of text, etc.
+- Targeted improvements where only specific portions of the file's content needs to be altered.
+- Especially useful for long files where much of the file will remain unchanged.
+
+## Advantages
+
+- More efficient for minor edits, since you don't need to supply the entire file content.  
+- Reduces the chance of errors that can occur when overwriting large files.
+
+# Choosing the Appropriate Tool
+
+- **Default to replace_in_file** for most changes. It's the safer, more precise option that minimizes potential issues.
+- **Use write_to_file** when:
+  - Creating new files
+  - The changes are so extensive that using replace_in_file would be more complex or risky
+  - You need to completely reorganize or restructure a file
+  - The file is relatively small and the changes affect most of its content
+  - You're generating boilerplate or template files
+
+# Auto-formatting Considerations
+
+- After using either write_to_file or replace_in_file, the user's editor may automatically format the file
+- This auto-formatting may modify the file contents, for example:
+  - Breaking single lines into multiple lines
+  - Adjusting indentation to match project style (e.g. 2 spaces vs 4 spaces vs tabs)
+  - Converting single quotes to double quotes (or vice versa based on project preferences)
+  - Organizing imports (e.g. sorting, grouping by type)
+  - Adding/removing trailing commas in objects and arrays
+  - Enforcing consistent brace style (e.g. same-line vs new-line)
+  - Standardizing semicolon usage (adding or removing based on style)
+- The write_to_file and replace_in_file tool responses will include the final state of the file after any auto-formatting
+- Use this final state as your reference point for any subsequent edits. This is ESPECIALLY important when crafting SEARCH blocks for replace_in_file which require the content to match what's in the file exactly.
+
+# Workflow Tips
+
+1. Before editing, assess the scope of your changes and decide which tool to use.
+2. For targeted edits, apply replace_in_file with carefully crafted SEARCH/REPLACE blocks. If you need multiple changes, you can stack multiple SEARCH/REPLACE blocks within a single replace_in_file call.
+3. For major overhauls or initial file creation, rely on write_to_file.
+4. Once the file has been edited with either write_to_file or replace_in_file, the system will provide you with the final state of the modified file. Use this updated content as the reference point for any subsequent SEARCH/REPLACE operations, since it reflects any auto-formatting or user-applied changes.
+By thoughtfully selecting between write_to_file and replace_in_file, you can make your file editing process smoother, safer, and more efficient.
+
+====
+ 
+ACT MODE V.S. PLAN MODE
+
+In each user message, the environment_details will specify the current mode. There are two modes:
+
+- ACT MODE: In this mode, you have access to all tools EXCEPT the plan_mode_respond tool.
+ - In ACT MODE, you use tools to accomplish the user's task. Once you've completed the user's task, you use the attempt_completion tool to present the result of the task to the user.
+- PLAN MODE: In this special mode, you have access to the plan_mode_respond tool.
+ - In PLAN MODE, the goal is to gather information and get context to create a detailed plan for accomplishing the task, which the user will review and approve before they switch you to ACT MODE to implement the solution.
+ - In PLAN MODE, when you need to converse with the user or present a plan, you should use the plan_mode_respond tool to deliver your response directly, rather than using <thinking> tags to analyze when to respond. Do not talk about using plan_mode_respond - just use it directly to share your thoughts and provide helpful answers.
+
+## What is PLAN MODE?
+
+- While you are usually in ACT MODE, the user may switch to PLAN MODE in order to have a back and forth with you to plan how to best accomplish the task. 
+- When starting in PLAN MODE, depending on the user's request, you may need to do some information gathering e.g. using read_file or search_files to get more context about the task. You may also ask the user clarifying questions to get a better understanding of the task. You may return mermaid diagrams to visually display your understanding.
+- Once you've gained more context about the user's request, you should architect a detailed plan for how you will accomplish the task. Returning mermaid diagrams may be helpful here as well.
+- Then you might ask the user if they are pleased with this plan, or if they would like to make any changes. Think of this as a brainstorming session where you can discuss the task and plan the best way to accomplish it.
+- If at any point a mermaid diagram would make your plan clearer to help the user quickly see the structure, you are encouraged to include a Mermaid code block in the response. (Note: if you use colors in your mermaid diagrams, be sure to use high contrast colors so the text is readable.)
+- Finally once it seems like you've reached a good plan, ask the user to switch you back to ACT MODE to implement the solution.
+
+====
+ 
+CAPABILITIES
+
+- You have access to tools that let you execute CLI commands on the user's computer, list files, view source code definitions, regex search${
+		supportsBrowserUse ? ", use the browser" : ""
+	}, read and edit files, and ask follow-up questions. These tools help you effectively accomplish a wide range of tasks, such as writing code, making edits or improvements to existing files, understanding the current state of a project, performing system operations, and much more.
+- When the user initially gives you a task, a recursive list of all filepaths in the current working directory ('${cwdFormatted}') will be included in environment_details. This provides an overview of the project's file structure, offering key insights into the project from directory/file names (how developers conceptualize and organize their code) and file extensions (the language used). This can also guide decision-making on which files to explore further. If you need to further explore directories such as outside the current working directory, you can use the list_files tool. If you pass 'true' for the recursive parameter, it will list files recursively. Otherwise, it will list files at the top level, which is better suited for generic directories where you don't necessarily need the nested structure, like the Desktop.
+- You can use search_files to perform regex searches across files in a specified directory, outputting context-rich results that include surrounding lines. This is particularly useful for understanding code patterns, finding specific implementations, or identifying areas that need refactoring.
+- You can use the list_code_definition_names tool to get an overview of source code definitions for all files at the top level of a specified directory. This can be particularly useful when you need to understand the broader context and relationships between certain parts of the code. You may need to call this tool multiple times to understand various parts of the codebase related to the task.
+    - For example, when asked to make edits or improvements you might analyze the file structure in the initial environment_details to get an overview of the project, then use list_code_definition_names to get further insight using source code definitions for files located in relevant directories, then read_file to examine the contents of relevant files, analyze the code and suggest improvements or make necessary edits, then use the replace_in_file tool to implement changes. If you refactored code that could affect other parts of the codebase, you could use search_files to ensure you update other files as needed.
+- You can use the execute_command tool to run commands on the user's computer whenever you feel it can help accomplish the user's task. When you need to execute a CLI command, you must provide a clear explanation of what the command does. Prefer to execute complex CLI commands over creating executable scripts, since they are more flexible and easier to run. Interactive and long-running commands are allowed, since the commands are run in the user's VSCode terminal. The user may keep commands running in the background and you will be kept updated on their status along the way. Each command you execute is run in a new terminal instance.${
+		supportsBrowserUse
+			? "\n- You can use the browser_action tool to interact with websites (including html files and locally running development servers) through a Puppeteer-controlled browser when you feel it is necessary in accomplishing the user's task. This tool is particularly useful for web development tasks as it allows you to launch a browser, navigate to pages, interact with elements through clicks and keyboard input, and capture the results through screenshots and console logs. This tool may be useful at key stages of web development tasks-such as after implementing new features, making substantial changes, when troubleshooting issues, or to verify the result of your work. You can analyze the provided screenshots to ensure correct rendering or identify errors, and review console logs for runtime issues.\n	- For example, if asked to add a component to a react website, you might create the necessary files, use execute_command to run the site locally, then use browser_action to launch the browser, navigate to the local server, and verify the component renders & functions correctly before closing the browser."
+			: ""
+	}
+- You have access to MCP servers that may provide additional tools and resources. Each server may provide different capabilities that you can use to accomplish tasks more effectively.
+- You can use LaTeX syntax in your responses to render mathematical expressions
+
+====
+
+If the user asks for help or wants to give feedback inform them of the following: 
+- To give feedback, users should report the issue using the /reportbug slash command in the chat. 
+
+When the user directly asks about Cline (eg 'can Cline do...', 'does Cline have...') or asks in second person (eg 'are you able...', 'can you do...'), first use the web_fetch tool to gather information to answer the question from Cline docs at https://docs.cline.bot.
+  - The available sub-pages are \`getting-started\` (Intro for new coders, installing Cline and dev essentials), \`model-selection\` (Model Selection Guide, Custom Model Configs, Bedrock, Vertex, Codestral, LM Studio, Ollama), \`features\` (Auto approve, Checkpoints, Cline rules, Drag & Drop, Plan & Act, Workflows, etc), \`task-management\` (Task and Context Management in Cline), \`prompt-engineering\` (Improving your prompting skills, Prompt Engineering Guide), \`cline-tools\` (Cline Tools Reference Guide, New Task Tool, Remote Browser Support, Slash Commands), \`mcp\` (MCP Overview, Adding/Configuring Servers, Transport Mechanisms, MCP Dev Protocol), \`enterprise\` (Cloud provider integration, Security concerns, Custom instructions), \`more-info\` (Telemetry and other reference content)
+  - Example: https://docs.cline.bot/features/auto-approve
+
+====
+
+RULES
+
+- Your current working directory is: ${cwdFormatted}
+- You cannot \`cd\` into a different directory to complete a task. You are stuck operating from '${cwdFormatted}', so be sure to pass in the correct 'path' parameter when using tools that require a path.
+- Do not use the ~ character or $HOME to refer to the home directory.
+- Before using the execute_command tool, you must first think about the SYSTEM INFORMATION context provided to understand the user's environment and tailor your commands to ensure they are compatible with their system. You must also consider if the command you need to run should be executed in a specific directory outside of the current working directory '${cwdFormatted}', and if so prepend with \`cd\`'ing into that directory && then executing the command (as one command since you are stuck operating from '${cwdFormatted}'). For example, if you needed to run \`npm install\` in a project outside of '${cwdFormatted}', you would need to prepend with a \`cd\` i.e. pseudocode for this would be \`cd (path to project) && (command, in this case npm install)\`.
+- When using the search_files tool, craft your regex patterns carefully to balance specificity and flexibility. Based on the user's task you may use it to find code patterns, TODO comments, function definitions, or any text-based information across the project. The results include context, so analyze the surrounding code to better understand the matches. Leverage the search_files tool in combination with other tools for more comprehensive analysis. For example, use it to find specific code patterns, then use read_file to examine the full context of interesting matches before using replace_in_file to make informed changes.
+- When creating a new project (such as an app, website, or any software project), organize all new files within a dedicated project directory unless the user specifies otherwise. Use appropriate file paths when creating files, as the write_to_file tool will automatically create any necessary directories. Structure the project logically, adhering to best practices for the specific type of project being created. Unless otherwise specified, new projects should be easily run without additional setup, for example most projects can be built in HTML, CSS, and JavaScript - which you can open in a browser.
+- Be sure to consider the type of project (e.g. Python, JavaScript, web application) when determining the appropriate structure and files to include. Also consider what files may be most relevant to accomplishing the task, for example looking at a project's manifest file would help you understand the project's dependencies, which you could incorporate into any code you write.
+- When making changes to code, always consider the context in which the code is being used. Ensure that your changes are compatible with the existing codebase and that they follow the project's coding standards and best practices.
+- When you want to modify a file, use the replace_in_file or write_to_file tool directly with the desired changes. You do not need to display the changes before using the tool.
+- Do not ask for more information than necessary. Use the tools provided to accomplish the user's request efficiently and effectively. When you've completed your task, you must use the attempt_completion tool to present the result to the user. The user may provide feedback, which you can use to make improvements and try again.
+- You are only allowed to ask the user questions using the ask_followup_question tool. Use this tool only when you need additional details to complete a task, and be sure to use a clear and concise question that will help you move forward with the task. However if you can use the available tools to avoid having to ask the user questions, you should do so. For example, if the user mentions a file that may be in an outside directory like the Desktop, you should use the list_files tool to list the files in the Desktop and check if the file they are talking about is there, rather than asking the user to provide the file path themselves.
+- When executing commands, if you don't see the expected output, assume the terminal executed the command successfully and proceed with the task. The user's terminal may be unable to stream the output back properly. If you absolutely need to see the actual terminal output, use the ask_followup_question tool to request the user to copy and paste it back to you.
+- The user may provide a file's contents directly in their message, in which case you shouldn't use the read_file tool to get the file contents again since you already have it.
+- Your goal is to try to accomplish the user's task, NOT engage in a back and forth conversation.${
+		supportsBrowserUse
+			? `\n- The user may ask generic non-development tasks, such as "what\'s the latest news" or "look up the weather in San Diego", in which case you might use the browser_action tool to complete the task if it makes sense to do so, rather than trying to create a website or using curl to answer the question. However, if an available MCP server tool or resource can be used instead, you should prefer to use it over browser_action.`
+			: ""
+	}
+- NEVER end attempt_completion result with a question or request to engage in further conversation! Formulate the end of your result in a way that is final and does not require further input from the user.
+- You are STRICTLY FORBIDDEN from starting your messages with "Great", "Certainly", "Okay", "Sure". You should NOT be conversational in your responses, but rather direct and to the point. For example you should NOT say "Great, I've updated the CSS" but instead something like "I've updated the CSS". It is important you be clear and technical in your messages.
+- When presented with images, utilize your vision capabilities to thoroughly examine them and extract meaningful information. Incorporate these insights into your thought process as you accomplish the user's task.
+- At the end of each user message, you will automatically receive environment_details. This information is not written by the user themselves, but is auto-generated to provide potentially relevant context about the project structure and environment. While this information can be valuable for understanding the project context, do not treat it as a direct part of the user's request or response. Use it to inform your actions and decisions, but don't assume the user is explicitly asking about or referring to this information unless they clearly do so in their message. When using environment_details, explain your actions clearly to ensure the user understands, as they may not be aware of these details.
+- Before executing commands, check the "Actively Running Terminals" section in environment_details. If present, consider how these active processes might impact your task. For example, if a local development server is already running, you wouldn't need to start it again. If no active terminals are listed, proceed with command execution as normal.
+- When using the replace_in_file tool, you must include complete lines in your SEARCH blocks, not partial lines. The system requires exact line matches and cannot match partial lines. For example, if you want to match a line containing "const x = 5;", your SEARCH block must include the entire line, not just "x = 5" or other fragments.
+- When using the replace_in_file tool, if you use multiple SEARCH/REPLACE blocks, list them in the order they appear in the file. For example if you need to make changes to both line 10 and line 50, first include the SEARCH/REPLACE block for line 10, followed by the SEARCH/REPLACE block for line 50.
+- When using the replace_in_file tool, Do NOT add extra characters to the markers (e.g., ------- SEARCH> is INVALID). Do NOT forget to use the closing +++++++ REPLACE marker. Do NOT modify the marker format in any way. Malformed XML will cause complete tool failure and break the entire editing process.
+- It is critical you wait for the user's response after each tool use, in order to confirm the success of the tool use. For example, if asked to make a todo app, you would create a file, wait for the user's response it was created successfully, then create another file if needed, wait for the user's response it was created successfully, etc.${
+		supportsBrowserUse
+			? " Then if you want to test your work, you might use browser_action to launch the site, wait for the user's response confirming the site was launched along with a screenshot, then perhaps e.g., click a button to test functionality if needed, wait for the user's response confirming the button was clicked along with a screenshot of the new state, before finally closing the browser."
+			: ""
+	}
+- MCP operations should be used one at a time, similar to other tool usage. Wait for confirmation of success before proceeding with additional operations.
+
+====
+
+SYSTEM INFORMATION
+
+Operating System: ${os}
+Default Shell: ${shell}
+Home Directory: ${homeFormatted}
+Current Working Directory: ${cwdFormatted}
+
+====
+
+OBJECTIVE
+
+You accomplish a given task iteratively, breaking it down into clear steps and working through them methodically.
+
+1. Analyze the user's task and set clear, achievable goals to accomplish it. Prioritize these goals in a logical order.
+2. Work through these goals sequentially, utilizing available tools one at a time as necessary. Each goal should correspond to a distinct step in your problem-solving process. You will be informed on the work completed and what's remaining as you go.
+3. Remember, you have extensive capabilities with access to a wide range of tools that can be used in powerful and clever ways as necessary to accomplish each goal. Before calling a tool, do some analysis within <thinking></thinking> tags. First, analyze the file structure provided in environment_details to gain context and insights for proceeding effectively. Then, think about which of the provided tools is the most relevant tool to accomplish the user's task. Next, go through each of the required parameters of the relevant tool and determine if the user has directly provided or given enough information to infer a value. When deciding if the parameter can be inferred, carefully consider all the context to see if it supports a specific value. If all of the required parameters are present or can be reasonably inferred, close the thinking tag and proceed with the tool use. BUT, if one of the values for a required parameter is missing, DO NOT invoke the tool (not even with fillers for the missing params) and instead, ask the user to provide the missing parameters using the ask_followup_question tool. DO NOT ask for more information on optional parameters if it is not provided.
+4. Once you've completed the user's task, you must use the attempt_completion tool to present the result of the task to the user. You may also provide a CLI command to showcase the result of your task; this can be particularly useful for web development tasks, where you can run e.g. \`open index.html\` to show the website you've built.
+5. The user may provide feedback, which you can use to make improvements and try again. But DO NOT continue in pointless back and forth conversations, i.e. don't end your responses with questions or offers for further assistance.
+${
+	userCustomInstructions
+		? `\n
+====
+
+USER'S CUSTOM INSTRUCTIONS
+
+The following additional instructions are provided by the user, and should be followed to the best of your ability without interfering with the TOOL USE guidelines.
+
+${userCustomInstructions}`
+		: ""
+}`
+}

evals/diff-edits/run_and_open_dashboard.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+# Get the directory of this script to make paths robust
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+# The 'evals' directory is the parent of the script's directory
+EVALS_DIR=$(dirname "$SCRIPT_DIR")
+
+# Navigate to the evals directory to ensure npm commands run correctly
+cd "$EVALS_DIR"
+
+# Re-install dependencies and build the CLI
+echo "Ensuring dependencies are up to date and building CLI..."
+npm install && npm run build:cli
+
+# Check if the build was successful before proceeding
+if [ $? -ne 0 ]; then
+    echo "CLI build failed. Aborting evaluation."
+    exit 1
+fi
+
+# Run the evaluation script, passing all arguments from the command line
+echo "Running evaluation..."
+node ./cli/dist/index.js run-diff-eval "$@"
+
+# Check the exit code of the evaluation script
+if [ $? -eq 0 ]; then
+  # If the script succeeded, open the dashboard in the background
+  echo "Evaluation complete. Starting dashboard..."
+  (cd "$SCRIPT_DIR/dashboard" && streamlit run app.py &)
+else
+  # If the script failed, print an error message and exit
+  echo "Evaluation failed. Dashboard will not be started."
+  exit 1
+fi

evals/diff-edits/types.ts

@@ -0,0 +1,108 @@
+import { Anthropic } from "@anthropic-ai/sdk"
+import { ToolUseName, ToolParamName } from "../../src/core/assistant-message"
+
+export interface InputMessage {
+	role: "user" | "assistant"
+	text: string
+	images?: string[]
+}
+
+export interface ProcessedTestCase {
+	test_id: string
+	messages: Anthropic.Messages.MessageParam[]
+	file_contents: string
+	file_path: string
+	system_prompt_details: SystemPromptDetails
+	original_diff_edit_tool_call_message: string
+}
+
+export interface TestCase {
+	test_id: string
+	messages: InputMessage[]
+	file_contents: string
+	file_path: string
+	system_prompt_details: SystemPromptDetails
+	original_diff_edit_tool_call_message: string
+}
+
+export interface TestConfig {
+	model_id: string
+	system_prompt_name: string
+	number_of_runs: number
+	max_attempts_per_case: number
+	parsing_function: string
+	diff_edit_function: string
+	thinking_tokens_budget: number
+	replay: boolean
+	diff_apply_file?: string
+}
+
+export interface SystemPromptDetails {
+	mcp_string: string
+	cwd_value: string
+	browser_use: boolean
+	width: number
+	height: number
+	os_value: string
+	shell_value: string
+	home_value: string
+	user_custom_instructions: string
+}
+
+export type ConstructSystemPromptFn = (
+	cwdFormatted: string,
+	supportsBrowserUse: boolean,
+	browserWidth: number,
+	browserHeight: number,
+	os: string,
+	shell: string,
+	homeFormatted: string,
+	mcpHubString: string,
+	userCustomInstructions: string,
+) => string
+
+export interface TestResult {
+	success: boolean
+	streamResult?: {
+		assistantMessage: string
+		reasoningMessage: string
+		usage: {
+			inputTokens: number
+			outputTokens: number
+			cacheWriteTokens: number
+			cacheReadTokens: number
+			totalCost: number
+		}
+		timing?: {
+			timeToFirstTokenMs: number
+			timeToFirstEditMs?: number
+			totalRoundTripMs: number
+		}
+	}
+	diffEdit?: string
+	toolCalls?: ExtractedToolCall[]
+	diffEditSuccess?: boolean
+	replacementData?: any
+	error?: string
+	errorString?: string
+}
+
+export interface ExtractedToolCall {
+	name: ToolUseName
+	input: Partial<Record<ToolParamName, string>>
+}
+
+export interface TestInput {
+	apiKey?: string
+	systemPrompt: string
+	messages: Anthropic.Messages.MessageParam[]
+	modelId: string
+	originalFile: string
+	originalFilePath: string
+	parsingFunction: string
+	diffEditFunction: string
+	thinkingBudgetTokens: number
+	originalDiffEditToolCallMessage?: string
+	diffApplyFile?: string
+	isVerbose: boolean
+}

evals/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "cline-evals",
+  "version": "0.1.0",
+  "description": "Evaluation scripts and tools for Cline",
+  "main": "cli/dist/index.js",
+  "scripts": {
+    "build:cli": "cd cli && tsc",
+    "start:cli": "cd cli && node dist/index.js",
+    "dev:cli": "cd cli && ts-node src/index.ts",
+    "diff-eval": "./diff-edits/run_and_open_dashboard.sh",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "cline",
+    "evaluation",
+    "benchmark",
+    "diff-edits"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.8.2",
+    "better-sqlite3": "^11.10.0",
+    "chalk": "^4.1.2",
+    "dotenv": "^16.5.0",
+    "commander": "^9.4.1",
+    "execa": "^5.1.1",
+    "node-fetch": "^2.7.0",
+    "ora": "^5.4.1",
+    "sqlite": "^4.1.2",
+    "tiktoken": "^1.0.21",
+    "uuid": "^9.0.0",
+    "yargs": "^17.6.2"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.3",
+    "@types/node": "^18.11.18",
+    "@types/node-fetch": "^2.6.12",
+    "@types/uuid": "^9.0.0",
+    "@types/yargs": "^17.0.19",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.4"
+  }
+}

evals/tsconfig.json

@@ -0,0 +1,6 @@
+{
+	"extends": "../tsconfig.json",
+	"compilerOptions": {
+		"baseUrl": ".."
+	}
+}

hosts/vscode/host-grpc-handler.ts

@@ -1,197 +0,0 @@
-import { v4 as uuidv4 } from "uuid"
-import { hostServiceHandlers } from "./host-grpc-service-config"
-import { GrpcRequestRegistry } from "../../src/core/controller/grpc-request-registry"
-
-/**
- * Type definition for a streaming response handler
- */
-export type StreamingResponseHandler = (response: any, isLast?: boolean, sequenceNumber?: number) => Promise<void>
-
-// Registry to track active gRPC requests and their cleanup functions
-const requestRegistry = new GrpcRequestRegistry()
-
-/**
- * Callback interface for streaming requests
- */
-export interface StreamingCallbacks<T = any> {
-	onResponse: (response: T) => void
-	onError?: (error: Error) => void
-	onComplete?: () => void
-}
-
-/**
- * Handles gRPC requests from the webview
- */
-export class GrpcHandler {
-	constructor() {}
-
-	/**
-	 * Handle a gRPC request from the webview
-	 * @param service The service name
-	 * @param method The method name
-	 * @param message The request message
-	 * @param requestId The request ID for response correlation
-	 * @param streamingCallbacks Optional callbacks for streaming responses
-	 * @returns For unary requests: the response message or error. For streaming requests: a cancel function.
-	 */
-	async handleRequest<T = any>(
-		service: string,
-		method: string,
-		message: any,
-		requestId: string,
-		streamingCallbacks?: StreamingCallbacks<T>,
-	): Promise<
-		| {
-				message?: any
-				error?: string
-				request_id: string
-		  }
-		| (() => void)
-	> {
-		// If streaming callbacks are provided, handle as a streaming request
-		if (streamingCallbacks) {
-			let completionCalled = false
-
-			// Create a response handler that will call the client's callbacks
-			const responseHandler: StreamingResponseHandler = async (response, isLast = false, sequenceNumber) => {
-				try {
-					// Call the client's onResponse callback with the response
-					streamingCallbacks.onResponse(response)
-
-					// If this is the last response, call the onComplete callback
-					if (isLast && streamingCallbacks.onComplete && !completionCalled) {
-						completionCalled = true
-						streamingCallbacks.onComplete()
-					}
-				} catch (error) {
-					// If there's an error in the callback, call the onError callback
-					if (streamingCallbacks.onError) {
-						streamingCallbacks.onError(error instanceof Error ? error : new Error(String(error)))
-					}
-				}
-			}
-
-			// Register the response handler with the registry
-			requestRegistry.registerRequest(
-				requestId,
-				() => {
-					console.log(`[DEBUG] Cleaning up streaming request: ${requestId}`)
-					if (streamingCallbacks.onComplete && !completionCalled) {
-						completionCalled = true
-						streamingCallbacks.onComplete()
-					}
-				},
-				{ type: "streaming_request", service, method },
-				responseHandler,
-			)
-
-			// Call the streaming handler directly
-			console.log(`[DEBUG] Streaming gRPC host call to ${service}.${method} req:${requestId}`)
-			try {
-				await this.handleStreamingRequest(service, method, message, requestId)
-			} catch (error) {
-				if (streamingCallbacks.onError) {
-					streamingCallbacks.onError(error instanceof Error ? error : new Error(String(error)))
-				}
-			}
-
-			// Return a function to cancel the stream
-			return () => {
-				console.log(`[DEBUG] Cancelling streaming request: ${requestId}`)
-				this.cancelRequest(requestId)
-			}
-		}
-
-		// Handle as a unary request
-		try {
-			// Get the service handler from the config
-			const serviceConfig = hostServiceHandlers[service]
-			if (!serviceConfig) {
-				throw new Error(`Unknown service: ${service}`)
-			}
-
-			// Handle unary request
-			return {
-				message: await serviceConfig.requestHandler(method, message),
-				request_id: requestId,
-			}
-		} catch (error) {
-			return {
-				error: error instanceof Error ? error.message : String(error),
-				request_id: requestId,
-			}
-		}
-	}
-
-	/**
-	 * Cancel a gRPC request
-	 * @param requestId The request ID to cancel
-	 * @returns True if the request was found and cancelled, false otherwise
-	 */
-	public async cancelRequest(requestId: string): Promise<boolean> {
-		const cancelled = requestRegistry.cancelRequest(requestId)
-
-		if (cancelled) {
-			// Get the registered response handler from the registry
-			const requestInfo = requestRegistry.getRequestInfo(requestId)
-			if (requestInfo && requestInfo.responseStream) {
-				try {
-					// Send cancellation confirmation using the registered response handler
-					await requestInfo.responseStream(
-						{ cancelled: true },
-						true, // Mark as last message
-					)
-				} catch (e) {
-					console.error(`Error sending cancellation response for ${requestId}:`, e)
-				}
-			}
-		} else {
-			console.log(`[DEBUG] Request not found for cancellation: ${requestId}`)
-		}
-
-		return cancelled
-	}
-
-	/**
-	 * Handle a streaming gRPC request
-	 * @param service The service name
-	 * @param method The method name
-	 * @param message The request message
-	 * @param requestId The request ID for response correlation
-	 */
-	private async handleStreamingRequest(service: string, method: string, message: any, requestId: string): Promise<void> {
-		// Get the service handler from the config
-		const serviceConfig = hostServiceHandlers[service]
-		if (!serviceConfig) {
-			throw new Error(`Unknown service: ${service}`)
-		}
-
-		// Check if the service supports streaming
-		if (!serviceConfig.streamingHandler) {
-			throw new Error(`Service ${service} does not support streaming`)
-		}
-
-		// Get the registered response handler from the registry
-		const requestInfo = requestRegistry.getRequestInfo(requestId)
-		if (!requestInfo || !requestInfo.responseStream) {
-			throw new Error(`No response handler registered for request: ${requestId}`)
-		}
-
-		// Use the registered response handler
-		const responseStream = requestInfo.responseStream
-
-		// Handle streaming request and pass the requestId to all streaming handlers
-		await serviceConfig.streamingHandler(method, message, responseStream, requestId)
-
-		// Don't send a final message here - the stream should stay open for future updates
-		// The stream will be closed when the client disconnects or when the service explicitly ends it
-	}
-}
-
-/**
- * Get the request registry instance
- * This allows other parts of the code to access the registry
- */
-export function getRequestRegistry(): GrpcRequestRegistry {
-	return requestRegistry
-}

hosts/vscode/uri/file.ts

@@ -1,20 +0,0 @@
-import * as vscode from "vscode"
-import { Uri } from "../../../src/shared/proto/host/uri"
-import { StringRequest } from "../../../src/shared/proto/common"
-
-/**
- * Creates a file URI from a file path
- * @param request The request containing the file path
- * @returns A URI object representing the file
- */
-export async function file(request: StringRequest): Promise<Uri> {
-	const uri = vscode.Uri.file(request.value)
-	return Uri.create({
-		scheme: uri.scheme,
-		authority: uri.authority,
-		path: uri.path,
-		query: uri.query,
-		fragment: uri.fragment,
-		fsPath: uri.fsPath,
-	})
-}

hosts/vscode/uri/joinPath.ts

@@ -1,28 +0,0 @@
-import * as vscode from "vscode"
-import { JoinPathRequest, Uri } from "../../../src/shared/proto/host/uri"
-
-/**
- * Joins a URI with additional path segments
- * @param request The request containing the base URI and path segments
- * @returns A new URI with the path segments joined
- */
-export async function joinPath(request: JoinPathRequest): Promise<Uri> {
-	// Convert proto Uri to vscode.Uri
-	if (!request.base) {
-		throw new Error("Base URI is required")
-	}
-	const baseUri = vscode.Uri.parse(`${request.base.scheme}://${request.base.authority}${request.base.path}`)
-
-	// Join paths
-	const result = vscode.Uri.joinPath(baseUri, ...request.pathSegments)
-
-	// Convert back to proto Uri
-	return Uri.create({
-		scheme: result.scheme,
-		authority: result.authority,
-		path: result.path,
-		query: result.query,
-		fragment: result.fragment,
-		fsPath: result.fsPath,
-	})
-}

hosts/vscode/uri/parse.ts

@@ -1,20 +0,0 @@
-import * as vscode from "vscode"
-import { Uri } from "../../../src/shared/proto/host/uri"
-import { StringRequest } from "../../../src/shared/proto/common"
-
-/**
- * Parses a string URI into a Uri object
- * @param request The request containing the URI string
- * @returns A URI object representing the parsed URI
- */
-export async function parse(request: StringRequest): Promise<Uri> {
-	const uri = vscode.Uri.parse(request.value)
-	return Uri.create({
-		scheme: uri.scheme,
-		authority: uri.authority,
-		path: uri.path,
-		query: uri.query,
-		fragment: uri.fragment,
-		fsPath: uri.fsPath,
-	})
-}