Merge branch 'main' of https://github.com/RooVetGit/Roo-Cline into feature/pupeteer-updates

.eslintrc.json

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

.github/workflows/npm-publish.yml

@@ -31,8 +31,9 @@ jobs:
           git config user.name github-actions
           git config user.email github-actions@github.com
       - run: |
+          npm install -g vsce
           npm run co:login
-          latest_published_version=$(npm show @roo-dev/roo-cline version)
+          latest_published_version=$(npm show roo-cline version)
           current_package_version=$(node -p "require('./package.json').version")
           echo "Latest published version: $latest_published_version"
           echo "Current package version: $current_package_version"
@@ -40,6 +41,9 @@ jobs:
             echo "Latest version is already published to NPM"
           else
             npm install
+            cd webview-ui
+            npm install
+            cd ..
             npm run vsix
             npm publish
             echo "Successfully published to NPM"

.prettierignore

@@ -1,4 +1,5 @@
 dist/
 node_modules
 webview-ui/build/
-CHANGELOG.md
+CHANGELOG.md
+package-lock.json

.prettierrc.json

@@ -3,5 +3,5 @@
 	"useTabs": true,
 	"printWidth": 120,
 	"semi": false,
-	"jsxBracketSameLine": true
-}
+	"bracketSameLine": true
+}

.vscode-test.mjs

@@ -1,5 +1,5 @@
-import { defineConfig } from '@vscode/test-cli';
+import { defineConfig } from "@vscode/test-cli"
 
 export default defineConfig({
-	files: 'out/test/**/*.test.js',
-});
+	files: "out/test/**/*.test.js",
+})

.vscode/extensions.json

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

.vscode/launch.json

@@ -9,12 +9,8 @@
 			"name": "Run Extension",
 			"type": "extensionHost",
 			"request": "launch",
-			"args": [
-				"--extensionDevelopmentPath=${workspaceFolder}"
-			],
-			"outFiles": [
-				"${workspaceFolder}/dist/**/*.js"
-			],
+			"args": ["--extensionDevelopmentPath=${workspaceFolder}"],
+			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
 			"preLaunchTask": "${defaultBuildTask}"
 		}
 	]

.vscode/settings.json

@@ -1,13 +1,13 @@
 // Place your settings in this file to overwrite default and user settings.
 {
-    "files.exclude": {
-        "out": false, // set this to true to hide the "out" folder with the compiled JS files
-        "dist": false // set this to true to hide the "dist" folder with the compiled JS files
-    },
-    "search.exclude": {
-        "out": true, // set this to false to include "out" folder in search results
-        "dist": true // set this to false to include "dist" folder in search results
-    },
-    // Turn off tsc task auto detection since we have the necessary tasks as npm scripts
-    "typescript.tsc.autoDetect": "off"
-}
+	"files.exclude": {
+		"out": false, // set this to true to hide the "out" folder with the compiled JS files
+		"dist": false // set this to true to hide the "dist" folder with the compiled JS files
+	},
+	"search.exclude": {
+		"out": true, // set this to false to include "out" folder in search results
+		"dist": true // set this to false to include "dist" folder in search results
+	},
+	// Turn off tsc task auto detection since we have the necessary tasks as npm scripts
+	"typescript.tsc.autoDetect": "off"
+}

.vscode/tasks.json

@@ -4,56 +4,52 @@
 	"version": "2.0.0",
 	"tasks": [
 		{
-            "label": "watch",
-            "dependsOn": [
-                "npm: build:webview",
-                "npm: watch:tsc",
-                "npm: watch:esbuild"
-            ],
-            "presentation": {
-                "reveal": "never"
-            },
-            "group": {
-                "kind": "build",
-                "isDefault": true
-            }
-        },
-        {
-            "type": "npm",
-            "script": "build:webview",
-            "group": "build",
-            "problemMatcher": [],
-            "isBackground": true,
-            "label": "npm: build:webview",
-            "presentation": {
-                "group": "watch",
-                "reveal": "never"
-            }
-        },
-        {
-            "type": "npm",
-            "script": "watch:esbuild",
-            "group": "build",
-            "problemMatcher": "$esbuild-watch",
-            "isBackground": true,
-            "label": "npm: watch:esbuild",
-            "presentation": {
-                "group": "watch",
-                "reveal": "never"
-            }
-        },
+			"label": "watch",
+			"dependsOn": ["npm: build:webview", "npm: watch:tsc", "npm: watch:esbuild"],
+			"presentation": {
+				"reveal": "never"
+			},
+			"group": {
+				"kind": "build",
+				"isDefault": true
+			}
+		},
 		{
-            "type": "npm",
-            "script": "watch:tsc",
-            "group": "build",
-            "problemMatcher": "$tsc-watch",
-            "isBackground": true,
-            "label": "npm: watch:tsc",
-            "presentation": {
-                "group": "watch",
-                "reveal": "never"
-            }
-        },
+			"type": "npm",
+			"script": "build:webview",
+			"group": "build",
+			"problemMatcher": [],
+			"isBackground": true,
+			"label": "npm: build:webview",
+			"presentation": {
+				"group": "watch",
+				"reveal": "never"
+			}
+		},
+		{
+			"type": "npm",
+			"script": "watch:esbuild",
+			"group": "build",
+			"problemMatcher": "$esbuild-watch",
+			"isBackground": true,
+			"label": "npm: watch:esbuild",
+			"presentation": {
+				"group": "watch",
+				"reveal": "never"
+			}
+		},
+		{
+			"type": "npm",
+			"script": "watch:tsc",
+			"group": "build",
+			"problemMatcher": "$tsc-watch",
+			"isBackground": true,
+			"label": "npm: watch:tsc",
+			"presentation": {
+				"group": "watch",
+				"reveal": "never"
+			}
+		},
 		{
 			"type": "npm",
 			"script": "watch-tests",
@@ -67,10 +63,7 @@
 		},
 		{
 			"label": "tasks: watch-tests",
-			"dependsOn": [
-				"npm: watch",
-				"npm: watch-tests"
-			],
+			"dependsOn": ["npm: watch", "npm: watch-tests"],
 			"problemMatcher": []
 		}
 	]

cli/README.md

@@ -0,0 +1,110 @@
+# Cline CLI
+
+A command-line interface for Cline, powered by Deno.
+
+## Installation
+
+1. Make sure you have [Deno](https://deno.land/) installed
+2. Install the CLI globally:
+   ```bash
+   cd cli
+   deno task install
+   ```
+
+If you get a PATH warning during installation, add Deno's bin directory to your PATH:
+```bash
+echo 'export PATH="$HOME/.deno/bin:$PATH"' >> ~/.bashrc  # or ~/.zshrc
+source ~/.bashrc  # or ~/.zshrc
+```
+
+## Usage
+
+```bash
+cline <task> [options]
+```
+
+### Security Model
+
+The CLI implements several security measures:
+
+1. File Operations:
+   - Read/write access limited to working directory (--allow-read=., --allow-write=.)
+   - Prevents access to files outside the project
+
+2. Command Execution:
+   - Strict allowlist of safe commands:
+     * npm (install, run, test, build)
+     * git (status, add, commit, push, pull, clone, checkout, branch)
+     * deno (run, test, fmt, lint, check, compile, bundle)
+     * ls (-l, -a, -la, -lh)
+     * cat, echo
+   - Interactive prompts for non-allowlisted commands:
+     * y - Run once
+     * n - Cancel execution
+     * always - Remember for session
+   - Clear warnings and command details shown
+   - Session-based memory for approved commands
+
+3. Required Permissions:
+   - --allow-read=. - Read files in working directory
+   - --allow-write=. - Write files in working directory
+   - --allow-run - Execute allowlisted commands
+   - --allow-net - Make API calls
+   - --allow-env - Access environment variables
+
+### Options
+
+- `-m, --model <model>` - LLM model to use (default: "anthropic/claude-3.5-sonnet")
+- `-k, --key <key>` - OpenRouter API key (required, or set OPENROUTER_API_KEY env var)
+- `-h, --help` - Display help for command
+
+### Examples
+
+Analyze code:
+```bash
+export OPENROUTER_API_KEY=sk-or-v1-...
+cline "Analyze this codebase"
+```
+
+Create files:
+```bash
+cline "Create a React component"
+```
+
+Run allowed command:
+```bash
+cline "Run npm install"
+```
+
+Run non-allowlisted command (will prompt for decision):
+```bash
+cline "Run yarn install"
+# Responds with:
+# Warning: Command not in allowlist
+# Command: yarn install
+# Do you want to run this command? (y/n/always)
+```
+
+## Development
+
+The CLI is built with Deno. Available tasks:
+
+```bash
+# Run in development mode
+deno task dev "your task here"
+
+# Install globally
+deno task install
+
+# Type check the code
+deno task check
+```
+
+### Security Features
+
+- File operations restricted to working directory
+- Command execution controlled by allowlist
+- Interactive prompts for unknown commands
+- Session-based command approval
+- Clear warnings and command details
+- Permission validation at runtime

cli/api/mod.ts

@@ -0,0 +1,10 @@
+import type { ApiConfiguration, ApiHandler } from "../types.d.ts";
+import { OpenRouterHandler } from "./providers/openrouter.ts";
+
+// Re-export the ApiHandler interface
+export type { ApiHandler };
+
+export function buildApiHandler(configuration: ApiConfiguration): ApiHandler {
+  const { apiKey, model } = configuration;
+  return new OpenRouterHandler({ apiKey, model });
+}

cli/api/providers/openrouter.ts

@@ -0,0 +1,147 @@
+import type { ApiStream, ModelInfo, Message, TextBlock } from "../../types.d.ts";
+
+interface OpenRouterOptions {
+  model: string;
+  apiKey: string;
+}
+
+export class OpenRouterHandler {
+  private apiKey: string;
+  private model: string;
+
+  constructor(options: OpenRouterOptions) {
+    this.apiKey = options.apiKey;
+    this.model = options.model;
+  }
+
+  async *createMessage(systemPrompt: string, messages: Message[]): ApiStream {
+    try {
+      // Convert our messages to OpenRouter format
+      const openRouterMessages = [
+        { role: "system", content: systemPrompt },
+        ...messages.map(msg => ({
+          role: msg.role,
+          content: Array.isArray(msg.content)
+            ? msg.content.map(c => c.text).join("\n")
+            : msg.content
+        }))
+      ];
+
+      const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json",
+          "HTTP-Referer": "https://github.com/mattvr/roo-cline",
+          "X-Title": "Cline CLI"
+        },
+        body: JSON.stringify({
+          model: this.model,
+          messages: openRouterMessages,
+          stream: true,
+          temperature: 0.7,
+          max_tokens: 4096
+        })
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => null);
+        throw new Error(`OpenRouter API error: ${response.statusText}${errorData ? ` - ${JSON.stringify(errorData)}` : ""}`);
+      }
+
+      if (!response.body) {
+        throw new Error("No response body received");
+      }
+
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let content = "";
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        // Add new chunk to buffer and split into lines
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        
+        // Process all complete lines
+        buffer = lines.pop() || ""; // Keep the last incomplete line in buffer
+        
+        for (const line of lines) {
+          if (line.trim() === "") continue;
+          if (line === "data: [DONE]") continue;
+          
+          if (line.startsWith("data: ")) {
+            try {
+              const data = JSON.parse(line.slice(6));
+              if (data.choices?.[0]?.delta?.content) {
+                const text = data.choices[0].delta.content;
+                content += text;
+                yield { type: "text", text };
+              }
+            } catch (e) {
+              // Ignore parse errors for incomplete chunks
+              continue;
+            }
+          }
+        }
+      }
+
+      // Process any remaining content in buffer
+      if (buffer.trim() && buffer.startsWith("data: ")) {
+        try {
+          const data = JSON.parse(buffer.slice(6));
+          if (data.choices?.[0]?.delta?.content) {
+            const text = data.choices[0].delta.content;
+            content += text;
+            yield { type: "text", text };
+          }
+        } catch (e) {
+          // Ignore parse errors for final incomplete chunk
+        }
+      }
+
+      // Estimate token usage (4 chars per token is a rough estimate)
+      const inputText = systemPrompt + messages.reduce((acc, msg) => 
+        acc + (typeof msg.content === "string" ? 
+          msg.content : 
+          msg.content.reduce((a, b) => a + b.text, "")), "");
+
+      const inputTokens = Math.ceil(inputText.length / 4);
+      const outputTokens = Math.ceil(content.length / 4);
+
+      yield {
+        type: "usage",
+        inputTokens,
+        outputTokens,
+        totalCost: this.calculateCost(inputTokens, outputTokens)
+      };
+
+    } catch (error) {
+      console.error("Error in OpenRouter API call:", error);
+      throw error;
+    }
+  }
+
+  getModel(): { id: string; info: ModelInfo } {
+    return {
+      id: this.model,
+      info: {
+        contextWindow: 128000, // This varies by model
+        supportsComputerUse: true,
+        inputPricePerToken: 0.000002, // Approximate, varies by model
+        outputPricePerToken: 0.000002
+      }
+    };
+  }
+
+  private calculateCost(inputTokens: number, outputTokens: number): number {
+    const { inputPricePerToken, outputPricePerToken } = this.getModel().info;
+    return (
+      (inputTokens * (inputPricePerToken || 0)) +
+      (outputTokens * (outputPricePerToken || 0))
+    );
+  }
+}

cli/core/StandaloneAgent.ts

@@ -0,0 +1,164 @@
+import { blue, red, yellow } from "../deps.ts";
+import { ApiHandler } from "../api/mod.ts";
+import { executeCommand, readFile, writeFile, searchFiles, listFiles, listCodeDefinitions } from "../tools/mod.ts";
+import type { Message, TextBlock, ToolResult } from "../types.d.ts";
+
+interface AgentConfig {
+  api: ApiHandler;
+  systemPrompt: string;
+  workingDir: string;
+}
+
+export class StandaloneAgent {
+  private api: ApiHandler;
+  private systemPrompt: string;
+  private workingDir: string;
+  private conversationHistory: Message[] = [];
+
+  constructor(config: AgentConfig) {
+    this.api = config.api;
+    this.systemPrompt = config.systemPrompt;
+    this.workingDir = config.workingDir;
+  }
+
+  async runTask(task: string): Promise<void> {
+    this.conversationHistory.push({
+      role: "user",
+      content: [{ type: "text", text: `<task>\n${task}\n</task>` }]
+    });
+
+    let isTaskComplete = false;
+    const encoder = new TextEncoder();
+    
+    while (!isTaskComplete) {
+      const stream = this.api.createMessage(this.systemPrompt, this.conversationHistory);
+      let assistantMessage = "";
+      
+      console.log(blue("Thinking..."));
+      for await (const chunk of stream) {
+        if (chunk.type === "text") {
+          assistantMessage += chunk.text;
+          await Deno.stdout.write(encoder.encode(chunk.text));
+        }
+      }
+
+      this.conversationHistory.push({
+        role: "assistant",
+        content: [{ type: "text", text: assistantMessage }]
+      });
+
+      const toolResults = await this.executeTools(assistantMessage);
+      
+      if (toolResults.length > 0) {
+        this.conversationHistory.push({
+          role: "user",
+          content: toolResults.map(result => ({
+            type: "text",
+            text: `[${result.tool}] Result:${result.output}`
+          })) as TextBlock[]
+        });
+      } else {
+        if (assistantMessage.includes("<attempt_completion>")) {
+          isTaskComplete = true;
+        } else {
+          this.conversationHistory.push({
+            role: "user",
+            content: [{
+              type: "text",
+              text: "You must either use available tools to accomplish the task or call attempt_completion when the task is complete."
+            }]
+          });
+        }
+      }
+    }
+  }
+
+  private async executeTools(message: string): Promise<ToolResult[]> {
+    const results: ToolResult[] = [];
+    const toolRegex = /<(\w+)>\s*([\s\S]*?)\s*<\/\1>/g;
+    let match;
+    
+    while ((match = toolRegex.exec(message)) !== null) {
+      const [_, toolName, paramsXml] = match;
+      const params: Record<string, string> = {};
+      const paramRegex = /<(\w+)>\s*([\s\S]*?)\s*<\/\1>/g;
+      let paramMatch;
+      
+      while ((paramMatch = paramRegex.exec(paramsXml)) !== null) {
+        const [__, paramName, paramValue] = paramMatch;
+        params[paramName] = paramValue.trim();
+      }
+
+      let output: string;
+      try {
+        console.log(yellow(`\nExecuting: ${this.getToolDescription(toolName, params)}`));
+        
+        switch (toolName) {
+          case "execute_command":
+            output = await executeCommand(params.command);
+            break;
+          case "read_file":
+            output = await readFile(this.workingDir, params.path);
+            break;
+          case "write_to_file":
+            output = await writeFile(this.workingDir, params.path, params.content);
+            break;
+          case "search_files":
+            output = await searchFiles(this.workingDir, params.path, params.regex, params.file_pattern);
+            break;
+          case "list_files":
+            output = await listFiles(this.workingDir, params.path, params.recursive === "true");
+            break;
+          case "list_code_definition_names":
+            output = await listCodeDefinitions(this.workingDir, params.path);
+            break;
+          case "attempt_completion":
+            return results;
+          default:
+            console.warn(red(`Unknown tool: ${toolName}`));
+            continue;
+        }
+
+        results.push({
+          tool: toolName,
+          params,
+          output: output || "(No output)"
+        });
+
+        break;
+      } catch (error) {
+        const errorMessage = `Error executing ${toolName}: ${error instanceof Error ? error.message : String(error)}`;
+        console.error(red(errorMessage));
+        results.push({
+          tool: toolName,
+          params,
+          output: errorMessage
+        });
+        break;
+      }
+    }
+
+    return results;
+  }
+
+  private getToolDescription(toolName: string, params: Record<string, string>): string {
+    switch (toolName) {
+      case "execute_command":
+        return `Running command: ${params.command}`;
+      case "read_file":
+        return `Reading file: ${params.path}`;
+      case "write_to_file":
+        return `Writing to file: ${params.path}`;
+      case "search_files":
+        return `Searching for "${params.regex}" in ${params.path}`;
+      case "list_files":
+        return `Listing files in ${params.path}`;
+      case "list_code_definition_names":
+        return `Analyzing code in ${params.path}`;
+      case "attempt_completion":
+        return "Completing task";
+      default:
+        return toolName;
+    }
+  }
+}

cli/core/prompts.ts

@@ -0,0 +1,120 @@
+import { join } from "https://deno.land/std@0.220.1/path/mod.ts";
+
+export const SYSTEM_PROMPT = async (cwd: string): Promise<string> => {
+    let rulesContent = "";
+    
+    // Load and combine rules from configuration files
+    const ruleFiles = ['.clinerules', '.cursorrules'];
+    for (const file of ruleFiles) {
+        const rulePath = join(cwd, file);
+        try {
+            const stat = await Deno.stat(rulePath);
+            if (stat.isFile) {
+                const content = await Deno.readTextFile(rulePath);
+                if (content.trim()) {
+                    rulesContent += `\n# Rules from ${file}:\n${content.trim()}\n\n`;
+                }
+            }
+        } catch (err) {
+            // Only ignore ENOENT (file not found) errors
+            if (!(err instanceof Deno.errors.NotFound)) {
+                throw err;
+            }
+        }
+    }
+
+    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 tools that are executed upon approval. Use one tool per message and wait for the result before proceeding. Each tool must be used with proper XML-style formatting:
+
+<tool_name>
+<parameter1_name>value1</parameter1_name>
+<parameter2_name>value2</parameter2_name>
+</tool_name>
+
+# Available Tools
+
+## execute_command
+Description: Execute a CLI command on the system. Commands run in the current working directory: ${cwd}
+Parameters:
+- command: (required) The command to execute. Must be valid for the current OS.
+Usage:
+<execute_command>
+<command>command to run</command>
+</execute_command>
+
+## read_file
+Description: Read contents of a file. Supports text files and automatically extracts content from PDFs/DOCXs.
+Parameters:
+- path: (required) Path to file (relative to ${cwd})
+Usage:
+<read_file>
+<path>path to file</path>
+</read_file>
+
+## write_to_file
+Description: Write content to a file. Creates directories as needed. Will overwrite existing files.
+Parameters:
+- path: (required) Path to write to (relative to ${cwd})
+- content: (required) Complete file content. Must include ALL parts, even unchanged sections.
+Usage:
+<write_to_file>
+<path>path to file</path>
+<content>complete file content</content>
+</write_to_file>
+
+## search_files
+Description: Search files using regex patterns. Shows matches with surrounding context.
+Parameters:
+- path: (required) Directory to search (relative to ${cwd})
+- regex: (required) Rust regex pattern to search for
+- file_pattern: (optional) Glob pattern to filter files (e.g. "*.ts")
+Usage:
+<search_files>
+<path>directory to search</path>
+<regex>pattern to search</regex>
+<file_pattern>optional file pattern</file_pattern>
+</search_files>
+
+## list_code_definition_names
+Description: List code definitions (classes, functions, etc.) in source files.
+Parameters:
+- path: (required) Directory to analyze (relative to ${cwd})
+Usage:
+<list_code_definition_names>
+<path>directory to analyze</path>
+</list_code_definition_names>
+
+## attempt_completion
+Description: Signal task completion and present results.
+Parameters:
+- result: (required) Description of completed work
+- command: (optional) Command to demonstrate result
+Usage:
+<attempt_completion>
+<result>description of completed work</result>
+<command>optional demo command</command>
+</attempt_completion>
+
+# Guidelines
+
+1. Use one tool at a time and wait for results
+2. Provide complete file content when using write_to_file
+3. Be direct and technical in responses
+4. Present final results using attempt_completion
+5. Do not make assumptions about command success
+6. Do not make up commands that don't exist
+
+# Rules
+
+- Current working directory is: ${cwd}
+- Cannot cd to different directories
+- Must wait for confirmation after each tool use
+- Must provide complete file content when writing files
+- Be direct and technical, not conversational
+- Do not end messages with questions${rulesContent}`;
+};

cli/deno.d.ts

@@ -0,0 +1,40 @@
+declare namespace Deno {
+  export const args: string[];
+  export function exit(code?: number): never;
+  export const env: {
+    get(key: string): string | undefined;
+  };
+  export function cwd(): string;
+  export function readTextFile(path: string): Promise<string>;
+  export function writeTextFile(path: string, data: string): Promise<void>;
+  export function mkdir(path: string, options?: { recursive?: boolean }): Promise<void>;
+  export function readDir(path: string): AsyncIterable<{
+    name: string;
+    isFile: boolean;
+    isDirectory: boolean;
+  }>;
+  export function stat(path: string): Promise<{
+    isFile: boolean;
+    isDirectory: boolean;
+  }>;
+  export class Command {
+    constructor(cmd: string, options?: {
+      args?: string[];
+      stdout?: "piped";
+      stderr?: "piped";
+    });
+    output(): Promise<{
+      stdout: Uint8Array;
+      stderr: Uint8Array;
+    }>;
+  }
+  export const permissions: {
+    query(desc: { name: string; path?: string }): Promise<{ state: "granted" | "denied" }>;
+  };
+  export const errors: {
+    PermissionDenied: typeof Error;
+  };
+  export const stdout: {
+    write(data: Uint8Array): Promise<number>;
+  };
+}

cli/deno.jsonc

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "strict": true,
+    "lib": ["deno.ns", "dom"]
+  },
+  "tasks": {
+    "start": "deno run --allow-read=. mod.ts",
+    "dev": "deno run --allow-read=. mod.ts",
+    "install": "deno install --allow-read --allow-write --allow-net --allow-env --allow-run --global --name cline mod.ts",
+    "check": "deno check mod.ts"
+  }
+}

cli/deno.lock

@@ -0,0 +1,87 @@
+{
+  "version": "4",
+  "remote": {
+    "https://deno.land/std@0.220.1/assert/assert.ts": "bec068b2fccdd434c138a555b19a2c2393b71dfaada02b7d568a01541e67cdc5",
+    "https://deno.land/std@0.220.1/assert/assert_exists.ts": "24a7bf965e634f909242cd09fbaf38bde6b791128ece08e33ab08586a7cc55c9",
+    "https://deno.land/std@0.220.1/assert/assertion_error.ts": "9f689a101ee586c4ce92f52fa7ddd362e86434ffdf1f848e45987dc7689976b8",
+    "https://deno.land/std@0.220.1/flags/mod.ts": "9f13f3a49c54618277ac49195af934f1c7d235731bcf80fd33b8b234e6839ce9",
+    "https://deno.land/std@0.220.1/fmt/colors.ts": "d239d84620b921ea520125d778947881f62c50e78deef2657073840b8af9559a",
+    "https://deno.land/std@0.220.1/path/_common/assert_path.ts": "dbdd757a465b690b2cc72fc5fb7698c51507dec6bfafce4ca500c46b76ff7bd8",
+    "https://deno.land/std@0.220.1/path/_common/basename.ts": "569744855bc8445f3a56087fd2aed56bdad39da971a8d92b138c9913aecc5fa2",
+    "https://deno.land/std@0.220.1/path/_common/common.ts": "ef73c2860694775fe8ffcbcdd387f9f97c7a656febf0daa8c73b56f4d8a7bd4c",
+    "https://deno.land/std@0.220.1/path/_common/constants.ts": "dc5f8057159f4b48cd304eb3027e42f1148cf4df1fb4240774d3492b5d12ac0c",
+    "https://deno.land/std@0.220.1/path/_common/dirname.ts": "684df4aa71a04bbcc346c692c8485594fc8a90b9408dfbc26ff32cf3e0c98cc8",
+    "https://deno.land/std@0.220.1/path/_common/format.ts": "92500e91ea5de21c97f5fe91e178bae62af524b72d5fcd246d6d60ae4bcada8b",
+    "https://deno.land/std@0.220.1/path/_common/from_file_url.ts": "d672bdeebc11bf80e99bf266f886c70963107bdd31134c4e249eef51133ceccf",
+    "https://deno.land/std@0.220.1/path/_common/glob_to_reg_exp.ts": "6cac16d5c2dc23af7d66348a7ce430e5de4e70b0eede074bdbcf4903f4374d8d",
+    "https://deno.land/std@0.220.1/path/_common/normalize.ts": "684df4aa71a04bbcc346c692c8485594fc8a90b9408dfbc26ff32cf3e0c98cc8",
+    "https://deno.land/std@0.220.1/path/_common/normalize_string.ts": "33edef773c2a8e242761f731adeb2bd6d683e9c69e4e3d0092985bede74f4ac3",
+    "https://deno.land/std@0.220.1/path/_common/relative.ts": "faa2753d9b32320ed4ada0733261e3357c186e5705678d9dd08b97527deae607",
+    "https://deno.land/std@0.220.1/path/_common/strip_trailing_separators.ts": "7024a93447efcdcfeaa9339a98fa63ef9d53de363f1fbe9858970f1bba02655a",
+    "https://deno.land/std@0.220.1/path/_common/to_file_url.ts": "7f76adbc83ece1bba173e6e98a27c647712cab773d3f8cbe0398b74afc817883",
+    "https://deno.land/std@0.220.1/path/_interface.ts": "a1419fcf45c0ceb8acdccc94394e3e94f99e18cfd32d509aab514c8841799600",
+    "https://deno.land/std@0.220.1/path/_os.ts": "8fb9b90fb6b753bd8c77cfd8a33c2ff6c5f5bc185f50de8ca4ac6a05710b2c15",
+    "https://deno.land/std@0.220.1/path/basename.ts": "5d341aadb7ada266e2280561692c165771d071c98746fcb66da928870cd47668",
+    "https://deno.land/std@0.220.1/path/common.ts": "03e52e22882402c986fe97ca3b5bb4263c2aa811c515ce84584b23bac4cc2643",
+    "https://deno.land/std@0.220.1/path/constants.ts": "0c206169ca104938ede9da48ac952de288f23343304a1c3cb6ec7625e7325f36",
+    "https://deno.land/std@0.220.1/path/dirname.ts": "85bd955bf31d62c9aafdd7ff561c4b5fb587d11a9a5a45e2b01aedffa4238a7c",
+    "https://deno.land/std@0.220.1/path/extname.ts": "593303db8ae8c865cbd9ceec6e55d4b9ac5410c1e276bfd3131916591b954441",
+    "https://deno.land/std@0.220.1/path/format.ts": "42a2f3201343df77061207e6aaf78c95bafce7f711dcb7fe1e5840311c505778",
+    "https://deno.land/std@0.220.1/path/from_file_url.ts": "911833ae4fd10a1c84f6271f36151ab785955849117dc48c6e43b929504ee069",
+    "https://deno.land/std@0.220.1/path/glob_to_regexp.ts": "7f30f0a21439cadfdae1be1bf370880b415e676097fda584a63ce319053b5972",
+    "https://deno.land/std@0.220.1/path/is_absolute.ts": "4791afc8bfd0c87f0526eaa616b0d16e7b3ab6a65b62942e50eac68de4ef67d7",
+    "https://deno.land/std@0.220.1/path/is_glob.ts": "a65f6195d3058c3050ab905705891b412ff942a292bcbaa1a807a74439a14141",
+    "https://deno.land/std@0.220.1/path/join.ts": "ae2ec5ca44c7e84a235fd532e4a0116bfb1f2368b394db1c4fb75e3c0f26a33a",
+    "https://deno.land/std@0.220.1/path/join_globs.ts": "5b3bf248b93247194f94fa6947b612ab9d3abd571ca8386cf7789038545e54a0",
+    "https://deno.land/std@0.220.1/path/mod.ts": "2821a1bb3a4148a0ffe79c92aa41aa9319fef73c6d6f5178f52b2c720d3eb02d",
+    "https://deno.land/std@0.220.1/path/normalize.ts": "4155743ccceeed319b350c1e62e931600272fad8ad00c417b91df093867a8352",
+    "https://deno.land/std@0.220.1/path/normalize_glob.ts": "cc89a77a7d3b1d01053b9dcd59462b75482b11e9068ae6c754b5cf5d794b374f",
+    "https://deno.land/std@0.220.1/path/parse.ts": "65e8e285f1a63b714e19ef24b68f56e76934c3df0b6e65fd440d3991f4f8aefb",
+    "https://deno.land/std@0.220.1/path/posix/_util.ts": "1e3937da30f080bfc99fe45d7ed23c47dd8585c5e473b2d771380d3a6937cf9d",
+    "https://deno.land/std@0.220.1/path/posix/basename.ts": "d2fa5fbbb1c5a3ab8b9326458a8d4ceac77580961b3739cd5bfd1d3541a3e5f0",
+    "https://deno.land/std@0.220.1/path/posix/common.ts": "26f60ccc8b2cac3e1613000c23ac5a7d392715d479e5be413473a37903a2b5d4",
+    "https://deno.land/std@0.220.1/path/posix/constants.ts": "93481efb98cdffa4c719c22a0182b994e5a6aed3047e1962f6c2c75b7592bef1",
+    "https://deno.land/std@0.220.1/path/posix/dirname.ts": "76cd348ffe92345711409f88d4d8561d8645353ac215c8e9c80140069bf42f00",
+    "https://deno.land/std@0.220.1/path/posix/extname.ts": "e398c1d9d1908d3756a7ed94199fcd169e79466dd88feffd2f47ce0abf9d61d2",
+    "https://deno.land/std@0.220.1/path/posix/format.ts": "185e9ee2091a42dd39e2a3b8e4925370ee8407572cee1ae52838aed96310c5c1",
+    "https://deno.land/std@0.220.1/path/posix/from_file_url.ts": "951aee3a2c46fd0ed488899d024c6352b59154c70552e90885ed0c2ab699bc40",
+    "https://deno.land/std@0.220.1/path/posix/glob_to_regexp.ts": "76f012fcdb22c04b633f536c0b9644d100861bea36e9da56a94b9c589a742e8f",
+    "https://deno.land/std@0.220.1/path/posix/is_absolute.ts": "cebe561ad0ae294f0ce0365a1879dcfca8abd872821519b4fcc8d8967f888ede",
+    "https://deno.land/std@0.220.1/path/posix/is_glob.ts": "8a8b08c08bf731acf2c1232218f1f45a11131bc01de81e5f803450a5914434b9",
+    "https://deno.land/std@0.220.1/path/posix/join.ts": "7fc2cb3716aa1b863e990baf30b101d768db479e70b7313b4866a088db016f63",
+    "https://deno.land/std@0.220.1/path/posix/join_globs.ts": "a9475b44645feddceb484ee0498e456f4add112e181cb94042cdc6d47d1cdd25",
+    "https://deno.land/std@0.220.1/path/posix/mod.ts": "2301fc1c54a28b349e20656f68a85f75befa0ee9b6cd75bfac3da5aca9c3f604",
+    "https://deno.land/std@0.220.1/path/posix/normalize.ts": "baeb49816a8299f90a0237d214cef46f00ba3e95c0d2ceb74205a6a584b58a91",
+    "https://deno.land/std@0.220.1/path/posix/normalize_glob.ts": "9c87a829b6c0f445d03b3ecadc14492e2864c3ebb966f4cea41e98326e4435c6",
+    "https://deno.land/std@0.220.1/path/posix/parse.ts": "0b1fc4cb890dbb699ec1d2c232d274843b4a7142e1ad976b69fe51c954eb6080",
+    "https://deno.land/std@0.220.1/path/posix/relative.ts": "3907d6eda41f0ff723d336125a1ad4349112cd4d48f693859980314d5b9da31c",
+    "https://deno.land/std@0.220.1/path/posix/resolve.ts": "08b699cfeee10cb6857ccab38fa4b2ec703b0ea33e8e69964f29d02a2d5257cf",
+    "https://deno.land/std@0.220.1/path/posix/to_file_url.ts": "7aa752ba66a35049e0e4a4be5a0a31ac6b645257d2e031142abb1854de250aaf",
+    "https://deno.land/std@0.220.1/path/posix/to_namespaced_path.ts": "28b216b3c76f892a4dca9734ff1cc0045d135532bfd9c435ae4858bfa5a2ebf0",
+    "https://deno.land/std@0.220.1/path/relative.ts": "ab739d727180ed8727e34ed71d976912461d98e2b76de3d3de834c1066667add",
+    "https://deno.land/std@0.220.1/path/resolve.ts": "a6f977bdb4272e79d8d0ed4333e3d71367cc3926acf15ac271f1d059c8494d8d",
+    "https://deno.land/std@0.220.1/path/to_file_url.ts": "88f049b769bce411e2d2db5bd9e6fd9a185a5fbd6b9f5ad8f52bef517c4ece1b",
+    "https://deno.land/std@0.220.1/path/to_namespaced_path.ts": "b706a4103b104cfadc09600a5f838c2ba94dbcdb642344557122dda444526e40",
+    "https://deno.land/std@0.220.1/path/windows/_util.ts": "d5f47363e5293fced22c984550d5e70e98e266cc3f31769e1710511803d04808",
+    "https://deno.land/std@0.220.1/path/windows/basename.ts": "e2dbf31d1d6385bfab1ce38c333aa290b6d7ae9e0ecb8234a654e583cf22f8fe",
+    "https://deno.land/std@0.220.1/path/windows/common.ts": "26f60ccc8b2cac3e1613000c23ac5a7d392715d479e5be413473a37903a2b5d4",
+    "https://deno.land/std@0.220.1/path/windows/constants.ts": "5afaac0a1f67b68b0a380a4ef391bf59feb55856aa8c60dfc01bd3b6abb813f5",
+    "https://deno.land/std@0.220.1/path/windows/dirname.ts": "33e421be5a5558a1346a48e74c330b8e560be7424ed7684ea03c12c21b627bc9",
+    "https://deno.land/std@0.220.1/path/windows/extname.ts": "165a61b00d781257fda1e9606a48c78b06815385e7d703232548dbfc95346bef",
+    "https://deno.land/std@0.220.1/path/windows/format.ts": "bbb5ecf379305b472b1082cd2fdc010e44a0020030414974d6029be9ad52aeb6",
+    "https://deno.land/std@0.220.1/path/windows/from_file_url.ts": "ced2d587b6dff18f963f269d745c4a599cf82b0c4007356bd957cb4cb52efc01",
+    "https://deno.land/std@0.220.1/path/windows/glob_to_regexp.ts": "e45f1f89bf3fc36f94ab7b3b9d0026729829fabc486c77f414caebef3b7304f8",
+    "https://deno.land/std@0.220.1/path/windows/is_absolute.ts": "4a8f6853f8598cf91a835f41abed42112cebab09478b072e4beb00ec81f8ca8a",
+    "https://deno.land/std@0.220.1/path/windows/is_glob.ts": "8a8b08c08bf731acf2c1232218f1f45a11131bc01de81e5f803450a5914434b9",
+    "https://deno.land/std@0.220.1/path/windows/join.ts": "8d03530ab89195185103b7da9dfc6327af13eabdcd44c7c63e42e27808f50ecf",
+    "https://deno.land/std@0.220.1/path/windows/join_globs.ts": "a9475b44645feddceb484ee0498e456f4add112e181cb94042cdc6d47d1cdd25",
+    "https://deno.land/std@0.220.1/path/windows/mod.ts": "2301fc1c54a28b349e20656f68a85f75befa0ee9b6cd75bfac3da5aca9c3f604",
+    "https://deno.land/std@0.220.1/path/windows/normalize.ts": "78126170ab917f0ca355a9af9e65ad6bfa5be14d574c5fb09bb1920f52577780",
+    "https://deno.land/std@0.220.1/path/windows/normalize_glob.ts": "9c87a829b6c0f445d03b3ecadc14492e2864c3ebb966f4cea41e98326e4435c6",
+    "https://deno.land/std@0.220.1/path/windows/parse.ts": "dbdfe2bc6db482d755b5f63f7207cd019240fcac02ad2efa582adf67ff10553a",
+    "https://deno.land/std@0.220.1/path/windows/relative.ts": "3e1abc7977ee6cc0db2730d1f9cb38be87b0ce4806759d271a70e4997fc638d7",
+    "https://deno.land/std@0.220.1/path/windows/resolve.ts": "8dae1dadfed9d46ff46cc337c9525c0c7d959fb400a6308f34595c45bdca1972",
+    "https://deno.land/std@0.220.1/path/windows/to_file_url.ts": "40e560ee4854fe5a3d4d12976cef2f4e8914125c81b11f1108e127934ced502e",
+    "https://deno.land/std@0.220.1/path/windows/to_namespaced_path.ts": "4ffa4fb6fae321448d5fe810b3ca741d84df4d7897e61ee29be961a6aac89a4c"
+  }
+}

cli/deps.ts

@@ -0,0 +1,21 @@
+// Re-export standard library dependencies
+export { parse } from "https://deno.land/std@0.220.1/flags/mod.ts";
+export {
+  blue,
+  red,
+  gray,
+  yellow,
+  bold,
+} from "https://deno.land/std@0.220.1/fmt/colors.ts";
+export {
+  join,
+  dirname,
+} from "https://deno.land/std@0.220.1/path/mod.ts";
+
+// Export types
+export type {
+  ApiHandler,
+  AgentConfig,
+  OperationMode,
+  ToolResponse,
+} from "./types.d.ts";

cli/mod.ts

@@ -0,0 +1,123 @@
+#!/usr/bin/env -S deno run --allow-read=. --allow-write=. --allow-run --allow-net --allow-env
+
+import { parse } from "./deps.ts";
+import { blue, red, gray, yellow, bold } from "./deps.ts";
+import { buildApiHandler } from "./api/mod.ts";
+import { StandaloneAgent } from "./core/StandaloneAgent.ts";
+import { SYSTEM_PROMPT } from "./core/prompts.ts";
+import type { ApiHandler, AgentConfig } from "./types.d.ts";
+
+// Parse command line arguments
+const args = parse(Deno.args, {
+  string: ["model", "key"],
+  boolean: ["help"],
+  alias: {
+    m: "model",
+    k: "key",
+    h: "help"
+  },
+  default: {
+    model: "anthropic/claude-3.5-sonnet"
+  },
+});
+
+if (args.help || Deno.args.length === 0) {
+  console.log(blue("\nCline - AI Coding Assistant\n"));
+  
+  console.log("Usage:");
+  console.log("  cline <task> [options]\n");
+
+  console.log("Required Permissions:");
+  console.log("  --allow-read=.     Read files in working directory");
+  console.log("  --allow-write=.    Write files in working directory");
+  console.log("  --allow-run        Execute commands (with interactive prompts)\n");
+  console.log("  --allow-net        Make API calls");
+  console.log("  --allow-env        Access environment variables\n");
+
+  console.log("Pre-approved Commands:");
+  console.log("  npm   - Package management (install, run, test, build)");
+  console.log("  git   - Version control (status, add, commit, push, pull, clone)");
+  console.log("  deno  - Deno runtime (run, test, fmt, lint, check)");
+  console.log("  ls    - List directory contents");
+  console.log("  cat   - Show file contents");
+  console.log("  echo  - Print text");
+  console.log("  find  - Search for files");
+  console.log("\nOther commands will prompt for confirmation before execution.\n");
+
+  console.log("Options:");
+  console.log("  -m, --model <model>  LLM model to use (default: \"anthropic/claude-3.5-sonnet\")");
+  console.log("  -k, --key <key>      OpenRouter API key (or set OPENROUTER_API_KEY env var)");
+  console.log("  -h, --help           Display help for command\n");
+  
+  console.log("Examples:");
+  console.log(gray("  # Run pre-approved command"));
+  console.log("  cline \"Run npm install\"\n");
+  
+  console.log(gray("  # Run command that requires confirmation"));
+  console.log("  cline \"Run yarn install\"\n");
+  
+  Deno.exit(0);
+}
+
+// Verify required permissions
+const requiredPermissions = [
+  { name: "read", path: "." },
+  { name: "write", path: "." },
+  { name: "run" },
+  { name: "net" },
+  { name: "env" }
+] as const;
+
+for (const permission of requiredPermissions) {
+  const status = await Deno.permissions.query(permission);
+  if (status.state !== "granted") {
+    console.error(red(`Error: Missing required permission`));
+    console.error(yellow(`Hint: Run with the following permissions:`));
+    console.error(yellow(`  deno run ${requiredPermissions.map(p => 
+      "path" in p ? `--allow-${p.name}=${p.path}` : `--allow-${p.name}`
+    ).join(" ")} cli/mod.ts ...\n`));
+    Deno.exit(1);
+  }
+}
+
+const task = args._[0] as string;
+const apiKey = args.key || Deno.env.get("OPENROUTER_API_KEY");
+
+if (!apiKey) {
+  console.error(red("Error: OpenRouter API key is required. Set it with --key or OPENROUTER_API_KEY env var"));
+  console.error(yellow("Get your API key from: https://openrouter.ai/keys"));
+  Deno.exit(1);
+}
+
+try {
+  const workingDir = Deno.cwd();
+
+  // Initialize API handler
+  const apiHandler = buildApiHandler({
+    model: args.model,
+    apiKey
+  });
+
+  // Create agent instance
+  const agent = new StandaloneAgent({
+    api: apiHandler,
+    systemPrompt: await SYSTEM_PROMPT(workingDir),
+    workingDir
+  });
+
+  // Run the task
+  console.log(blue(`\nStarting task: ${bold(task)}`));
+  console.log(gray(`Working directory: ${workingDir}`));
+  console.log(gray(`Model: ${args.model}`));
+  console.log(gray("---\n"));
+
+  await agent.runTask(task);
+
+} catch (error) {
+  if (error instanceof Error) {
+    console.error(red(`\nError: ${error.message}`));
+  } else {
+    console.error(red("\nAn unknown error occurred"));
+  }
+  Deno.exit(1);
+}

cli/tools/mod.ts

@@ -0,0 +1,225 @@
+/// <reference lib="deno.ns" />
+import { join, dirname } from "https://deno.land/std@0.220.1/path/mod.ts";
+import { red, yellow, green } from "https://deno.land/std@0.220.1/fmt/colors.ts";
+import type { ToolResponse } from "../types.d.ts";
+
+interface CommandConfig {
+  desc: string;
+  args: readonly string[];
+}
+
+// Define allowed commands and their descriptions
+const ALLOWED_COMMANDS: Record<string, CommandConfig> = {
+  'npm': {
+    desc: "Node package manager",
+    args: ["install", "run", "test", "build"]
+  },
+  'git': {
+    desc: "Version control",
+    args: ["status", "add", "commit", "push", "pull", "clone", "checkout", "branch"]
+  },
+  'deno': {
+    desc: "Deno runtime",
+    args: ["run", "test", "fmt", "lint", "check", "compile", "bundle"]
+  },
+  'ls': {
+    desc: "List directory contents",
+    args: ["-l", "-a", "-la", "-lh"]
+  },
+  'cat': {
+    desc: "Show file contents",
+    args: []
+  },
+  'echo': {
+    desc: "Print text",
+    args: []
+  }
+};
+
+// Track commands that have been allowed for this session
+const alwaysAllowedCommands = new Set<string>();
+
+function isCommandAllowed(command: string): boolean {
+  // Split command into parts
+  const parts = command.trim().split(/\s+/);
+  if (parts.length === 0) return false;
+
+  // Get base command
+  const baseCmd = parts[0];
+  if (!(baseCmd in ALLOWED_COMMANDS)) return false;
+
+  // If command has arguments, check if they're allowed
+  if (parts.length > 1 && ALLOWED_COMMANDS[baseCmd].args.length > 0) {
+    const arg = parts[1];
+    return ALLOWED_COMMANDS[baseCmd].args.includes(arg);
+  }
+
+  return true;
+}
+
+async function promptForCommand(command: string): Promise<boolean> {
+  // Check if command has been previously allowed
+  if (alwaysAllowedCommands.has(command)) {
+    console.log(yellow("\nWarning: Running previously allowed command:"), red(command));
+    return true;
+  }
+
+  console.log(yellow("\nWarning: Command not in allowlist"));
+  console.log("Command:", red(command));
+  console.log("\nAllowed commands:");
+  Object.entries(ALLOWED_COMMANDS).forEach(([cmd, { desc, args }]) => {
+    console.log(`  ${green(cmd)}: ${desc}`);
+    if (args.length) {
+      console.log(`    Arguments: ${args.join(", ")}`);
+    }
+  });
+
+  const answer = prompt("\nDo you want to run this command? (y/n/always) ");
+  if (answer?.toLowerCase() === 'always') {
+    alwaysAllowedCommands.add(command);
+    return true;
+  }
+  return answer?.toLowerCase() === 'y';
+}
+
+export async function executeCommand(command: string): Promise<ToolResponse> {
+  try {
+    // Check if command is allowed
+    if (!isCommandAllowed(command)) {
+      // Prompt user for confirmation
+      const shouldRun = await promptForCommand(command);
+      if (!shouldRun) {
+        return "Command execution cancelled by user";
+      }
+      console.log(yellow("\nProceeding with command execution..."));
+    }
+
+    const process = new Deno.Command("sh", {
+      args: ["-c", command],
+      stdout: "piped",
+      stderr: "piped",
+    });
+    const { stdout, stderr } = await process.output();
+    const decoder = new TextDecoder();
+    return decoder.decode(stdout) + (stderr.length ? `\nStderr:\n${decoder.decode(stderr)}` : "");
+  } catch (error) {
+    return `Error executing command: ${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+
+export async function readFile(workingDir: string, relativePath: string): Promise<ToolResponse> {
+  try {
+    const fullPath = join(workingDir, relativePath);
+    const content = await Deno.readTextFile(fullPath);
+    return content;
+  } catch (error) {
+    return `Error reading file: ${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+
+export async function writeFile(workingDir: string, relativePath: string, content: string): Promise<ToolResponse> {
+  try {
+    const fullPath = join(workingDir, relativePath);
+    await Deno.mkdir(dirname(fullPath), { recursive: true });
+    await Deno.writeTextFile(fullPath, content);
+    return `Successfully wrote to ${relativePath}`;
+  } catch (error) {
+    return `Error writing file: ${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+
+export async function searchFiles(
+  workingDir: string, 
+  searchPath: string, 
+  regex: string, 
+  filePattern?: string
+): Promise<ToolResponse> {
+  try {
+    const fullPath = join(workingDir, searchPath);
+    const results: string[] = [];
+    
+    const regexObj = new RegExp(regex, "g");
+    const patternObj = filePattern ? new RegExp(filePattern) : null;
+    
+    for await (const entry of Deno.readDir(fullPath)) {
+      if (entry.isFile && (!patternObj || patternObj.test(entry.name))) {
+        const filePath = join(fullPath, entry.name);
+        const content = await Deno.readTextFile(filePath);
+        const matches = content.match(regexObj);
+        if (matches) {
+          results.push(`File: ${entry.name}\nMatches:\n${matches.join("\n")}\n`);
+        }
+      }
+    }
+    
+    return results.join("\n") || "No matches found";
+  } catch (error) {
+    return `Error searching files: ${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+
+export async function listFiles(workingDir: string, relativePath: string, recursive: boolean): Promise<ToolResponse> {
+  try {
+    const fullPath = join(workingDir, relativePath);
+    const files: string[] = [];
+
+    async function* walkDir(dir: string): AsyncGenerator<string> {
+      for await (const entry of Deno.readDir(dir)) {
+        const entryPath = join(dir, entry.name);
+        if (entry.isFile) {
+          yield entryPath.replace(fullPath + "/", "");
+        } else if (recursive && entry.isDirectory) {
+          yield* walkDir(entryPath);
+        }
+      }
+    }
+
+    for await (const file of walkDir(fullPath)) {
+      files.push(file);
+    }
+
+    return files.join("\n") || "No files found";
+  } catch (error) {
+    return `Error listing files: ${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+
+export async function listCodeDefinitions(workingDir: string, relativePath: string): Promise<ToolResponse> {
+  try {
+    const fullPath = join(workingDir, relativePath);
+    const content = await Deno.readTextFile(fullPath);
+    
+    // Basic regex patterns for common code definitions
+    const patterns = {
+      function: /(?:function|const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?:=\s*(?:function|\([^)]*\)\s*=>)|[({])/g,
+      class: /class\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g,
+      method: /(?:async\s+)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\([^)]*\)\s*{/g,
+    };
+    
+    const definitions: Record<string, string[]> = {
+      functions: [],
+      classes: [],
+      methods: [],
+    };
+    
+    let match;
+    
+    while ((match = patterns.function.exec(content)) !== null) {
+      definitions.functions.push(match[1]);
+    }
+    
+    while ((match = patterns.class.exec(content)) !== null) {
+      definitions.classes.push(match[1]);
+    }
+    
+    while ((match = patterns.method.exec(content)) !== null) {
+      definitions.methods.push(match[1]);
+    }
+    
+    return Object.entries(definitions)
+      .map(([type, names]) => `${type}:\n${names.join("\n")}`)
+      .join("\n\n");
+  } catch (error) {
+    return `Error listing code definitions: ${error instanceof Error ? error.message : String(error)}`;
+  }
+}

cli/types.d.ts

@@ -0,0 +1,43 @@
+export interface ApiHandler {
+  sendMessage(message: string): Promise<string>;
+  createMessage(systemPrompt: string, history: Message[]): AsyncIterable<MessageChunk>;
+}
+
+export interface AgentConfig {
+  api: ApiHandler;
+  systemPrompt: string;
+  workingDir: string;
+  debug?: boolean;
+}
+
+export type ToolResponse = string;
+
+export interface Message {
+  role: "user" | "assistant";
+  content: TextBlock[];
+}
+
+export interface TextBlock {
+  type: "text";
+  text: string;
+}
+
+export interface ToolResult {
+  tool: string;
+  params: Record<string, string>;
+  output: string;
+}
+
+export interface MessageChunk {
+  type: "text";
+  text: string;
+}
+
+export interface UsageBlock {
+  type: "usage";
+  usage: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}

package.json

@@ -111,6 +111,15 @@
           "when": "view == claude-dev.SidebarProvider"
         }
       ]
+    },
+    "configuration": {
+      "properties": {
+        "cline.alwaysAllowBrowser": {
+          "type": "boolean",
+          "default": false,
+          "description": "Always allow browser actions without requiring confirmation"
+        }
+      }
     }
   },
   "scripts": {
@@ -189,9 +198,5 @@
     "turndown": "^7.2.0",
     "vsce": "^2.15.0",
     "web-tree-sitter": "^0.22.6"
-  },
-  "files": [
-    "bin/roo-cline-2.0.2.vsix",
-    "assets/icons/icon_Roo.png"
-  ]
+  }
 }

src/api/providers/anthropic.ts

@@ -36,7 +36,7 @@ export class AnthropicHandler implements ApiHandler {
 				*/
 				const userMsgIndices = messages.reduce(
 					(acc, msg, index) => (msg.role === "user" ? [...acc, index] : acc),
-					[] as number[]
+					[] as number[],
 				)
 				const lastUserMsgIndex = userMsgIndices[userMsgIndices.length - 1] ?? -1
 				const secondLastMsgUserIndex = userMsgIndices[userMsgIndices.length - 2] ?? -1
@@ -58,12 +58,12 @@ export class AnthropicHandler implements ApiHandler {
 														text: message.content,
 														cache_control: { type: "ephemeral" },
 													},
-											  ]
+												]
 											: message.content.map((content, contentIndex) =>
 													contentIndex === message.content.length - 1
 														? { ...content, cache_control: { type: "ephemeral" } }
-														: content
-											  ),
+														: content,
+												),
 								}
 							}
 							return message
@@ -88,7 +88,7 @@ export class AnthropicHandler implements ApiHandler {
 							default:
 								return undefined
 						}
-					})()
+					})(),
 				)
 				break
 			}

src/api/providers/lmstudio.ts

@@ -42,7 +42,7 @@ export class LmStudioHandler implements ApiHandler {
 		} catch (error) {
 			// LM Studio doesn't return an error code/body for now
 			throw new Error(
-				"Please check the LM Studio developer logs to debug what went wrong. You may need to load the model with a larger context length to work with Cline's prompts."
+				"Please check the LM Studio developer logs to debug what went wrong. You may need to load the model with a larger context length to work with Cline's prompts.",
 			)
 		}
 	}

src/api/transform/gemini-format.ts

@@ -19,7 +19,7 @@ export function convertAnthropicContentToGemini(
 				| Anthropic.Messages.ImageBlockParam
 				| Anthropic.Messages.ToolUseBlockParam
 				| Anthropic.Messages.ToolResultBlockParam
-		  >
+		  >,
 ): Part[] {
 	if (typeof content === "string") {
 		return [{ text: content } as TextPart]
@@ -83,7 +83,7 @@ export function convertAnthropicContentToGemini(
 										data: part.source.data,
 										mimeType: part.source.media_type,
 									},
-								} as InlineDataPart)
+								}) as InlineDataPart,
 						),
 					]
 				}
@@ -113,7 +113,7 @@ export function convertAnthropicToolToGemini(tool: Anthropic.Messages.Tool): Fun
 						type: (value as any).type.toUpperCase(),
 						description: (value as any).description || "",
 					},
-				])
+				]),
 			),
 			required: (tool.input_schema.required as string[]) || [],
 		},
@@ -133,7 +133,7 @@ export function unescapeGeminiContent(content: string) {
 }
 
 export function convertGeminiResponseToAnthropic(
-	response: EnhancedGenerateContentResponse
+	response: EnhancedGenerateContentResponse,
 ): Anthropic.Messages.Message {
 	const content: Anthropic.Messages.ContentBlock[] = []
 

src/api/transform/o1-format.ts

@@ -167,7 +167,7 @@ I've analyzed the project structure, but I need more information to proceed. Let
 
 export function convertToO1Messages(
 	openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[],
-	systemPrompt: string
+	systemPrompt: string,
 ): OpenAI.Chat.ChatCompletionMessageParam[] {
 	const toolsReplaced = openAiMessages.reduce((acc, message) => {
 		if (message.role === "tool") {
@@ -360,7 +360,7 @@ function validateToolInput(toolName: string, tool_input: Record<string, string>)
 
 // Convert OpenAI response to Anthropic format
 export function convertO1ResponseToAnthropicMessage(
-	completion: OpenAI.Chat.Completions.ChatCompletion
+	completion: OpenAI.Chat.Completions.ChatCompletion,
 ): Anthropic.Messages.Message {
 	const openAiMessage = completion.choices[0].message
 	const { normalText, toolCalls } = parseAIResponse(openAiMessage.content || "")
@@ -405,7 +405,7 @@ export function convertO1ResponseToAnthropicMessage(
 					name: toolCall.tool,
 					input: toolCall.tool_input,
 				}
-			})
+			}),
 		)
 	}
 

src/api/transform/openai-format.ts

@@ -2,7 +2,7 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
 
 export function convertToOpenAiMessages(
-	anthropicMessages: Anthropic.Messages.MessageParam[]
+	anthropicMessages: Anthropic.Messages.MessageParam[],
 ): OpenAI.Chat.ChatCompletionMessageParam[] {
 	const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = []
 
@@ -31,7 +31,7 @@ export function convertToOpenAiMessages(
 						} // user cannot send tool_use messages
 						return acc
 					},
-					{ nonToolMessages: [], toolMessages: [] }
+					{ nonToolMessages: [], toolMessages: [] },
 				)
 
 				// Process tool result messages FIRST since they must follow the tool use messages
@@ -105,7 +105,7 @@ export function convertToOpenAiMessages(
 						} // assistant cannot send tool_result messages
 						return acc
 					},
-					{ nonToolMessages: [], toolMessages: [] }
+					{ nonToolMessages: [], toolMessages: [] },
 				)
 
 				// Process non-tool messages
@@ -147,7 +147,7 @@ export function convertToOpenAiMessages(
 
 // Convert OpenAI response to Anthropic format
 export function convertToAnthropicMessage(
-	completion: OpenAI.Chat.Completions.ChatCompletion
+	completion: OpenAI.Chat.Completions.ChatCompletion,
 ): Anthropic.Messages.Message {
 	const openAiMessage = completion.choices[0].message
 	const anthropicMessage: Anthropic.Messages.Message = {
@@ -196,7 +196,7 @@ export function convertToAnthropicMessage(
 					name: toolCall.function.name,
 					input: parsedInput,
 				}
-			})
+			}),
 		)
 	}
 	return anthropicMessage

src/core/Cline.ts

@@ -78,6 +78,7 @@ export class Cline {
 	alwaysAllowReadOnly: boolean
 	alwaysAllowWrite: boolean
 	alwaysAllowExecute: boolean
+	alwaysAllowBrowser: boolean
 
 	apiConversationHistory: Anthropic.MessageParam[] = []
 	clineMessages: ClineMessage[] = []
@@ -110,9 +111,10 @@ export class Cline {
 		alwaysAllowReadOnly?: boolean,
 		alwaysAllowWrite?: boolean,
 		alwaysAllowExecute?: boolean,
+		alwaysAllowBrowser?: boolean,
 		task?: string,
 		images?: string[],
-		historyItem?: HistoryItem
+		historyItem?: HistoryItem,
 	) {
 		this.providerRef = new WeakRef(provider)
 		this.api = buildApiHandler(apiConfiguration)
@@ -124,6 +126,7 @@ export class Cline {
 		this.alwaysAllowReadOnly = alwaysAllowReadOnly ?? false
 		this.alwaysAllowWrite = alwaysAllowWrite ?? false
 		this.alwaysAllowExecute = alwaysAllowExecute ?? false		
+		this.alwaysAllowBrowser = alwaysAllowBrowser ?? false
 
 		if (historyItem) {
 			this.taskId = historyItem.id
@@ -233,7 +236,7 @@ export class Cline {
 				this.clineMessages[
 					findLastIndex(
 						this.clineMessages,
-						(m) => !(m.ask === "resume_task" || m.ask === "resume_completed_task")
+						(m) => !(m.ask === "resume_task" || m.ask === "resume_completed_task"),
 					)
 				]
 			await this.providerRef.deref()?.updateTaskHistory({
@@ -257,7 +260,7 @@ export class Cline {
 	async ask(
 		type: ClineAsk,
 		text?: string,
-		partial?: boolean
+		partial?: boolean,
 	): Promise<{ response: ClineAskResponse; text?: string; images?: string[] }> {
 		// If this Cline instance was aborted by the provider, then the only thing keeping us alive is a promise still running in the background, in which case we don't want to send its result to the webview as it is attached to a new instance of Cline now. So we can safely ignore the result of any active promises, and this class will be deallocated. (Although we set Cline = undefined in provider, that simply removes the reference to this instance, but the instance is still alive until this promise resolves or rejects.)
 		if (this.abort) {
@@ -418,7 +421,7 @@ export class Cline {
 			"error",
 			`Cline tried to use ${toolName}${
 				relPath ? ` for '${relPath.toPosix()}'` : ""
-			} without value for required parameter '${paramName}'. Retrying...`
+			} without value for required parameter '${paramName}'. Retrying...`,
 		)
 		return formatResponse.toolError(formatResponse.missingToolParameterError(paramName))
 	}
@@ -450,7 +453,7 @@ export class Cline {
 		// Remove any resume messages that may have been added before
 		const lastRelevantMessageIndex = findLastIndex(
 			modifiedClineMessages,
-			(m) => !(m.ask === "resume_task" || m.ask === "resume_completed_task")
+			(m) => !(m.ask === "resume_task" || m.ask === "resume_completed_task"),
 		)
 		if (lastRelevantMessageIndex !== -1) {
 			modifiedClineMessages.splice(lastRelevantMessageIndex + 1)
@@ -459,7 +462,7 @@ export class Cline {
 		// since we don't use api_req_finished anymore, we need to check if the last api_req_started has a cost value, if it doesn't and no cancellation reason to present, then we remove it since it indicates an api request without any partial content streamed
 		const lastApiReqStartedIndex = findLastIndex(
 			modifiedClineMessages,
-			(m) => m.type === "say" && m.say === "api_req_started"
+			(m) => m.type === "say" && m.say === "api_req_started",
 		)
 		if (lastApiReqStartedIndex !== -1) {
 			const lastApiReqStarted = modifiedClineMessages[lastApiReqStartedIndex]
@@ -564,7 +567,7 @@ export class Cline {
 
 				if (hasToolUse) {
 					const toolUseBlocks = content.filter(
-						(block) => block.type === "tool_use"
+						(block) => block.type === "tool_use",
 					) as Anthropic.Messages.ToolUseBlock[]
 					const toolResponses: Anthropic.ToolResultBlockParam[] = toolUseBlocks.map((block) => ({
 						type: "tool_result",
@@ -590,17 +593,17 @@ export class Cline {
 							: [{ type: "text", text: previousAssistantMessage.content }]
 
 					const toolUseBlocks = assistantContent.filter(
-						(block) => block.type === "tool_use"
+						(block) => block.type === "tool_use",
 					) as Anthropic.Messages.ToolUseBlock[]
 
 					if (toolUseBlocks.length > 0) {
 						const existingToolResults = existingUserContent.filter(
-							(block) => block.type === "tool_result"
+							(block) => block.type === "tool_result",
 						) as Anthropic.ToolResultBlockParam[]
 
 						const missingToolResponses: Anthropic.ToolResultBlockParam[] = toolUseBlocks
 							.filter(
-								(toolUse) => !existingToolResults.some((result) => result.tool_use_id === toolUse.id)
+								(toolUse) => !existingToolResults.some((result) => result.tool_use_id === toolUse.id),
 							)
 							.map((toolUse) => ({
 								type: "tool_result",
@@ -770,7 +773,7 @@ export class Cline {
 					`Command is still running in the user's terminal.${
 						result.length > 0 ? `\nHere's the output so far:\n${result}` : ""
 					}\n\nThe user provided the following feedback:\n<feedback>\n${userFeedback.text}\n</feedback>`,
-					userFeedback.images
+					userFeedback.images,
 				),
 			]
 		}
@@ -795,7 +798,7 @@ export class Cline {
 			const previousRequest = this.clineMessages[previousApiReqIndex]
 			if (previousRequest && previousRequest.text) {
 				const { tokensIn, tokensOut, cacheWrites, cacheReads }: ClineApiReqInfo = JSON.parse(
-					previousRequest.text
+					previousRequest.text,
 				)
 				const totalTokens = (tokensIn || 0) + (tokensOut || 0) + (cacheWrites || 0) + (cacheReads || 0)
 				const contextWindow = this.api.getModel().info.contextWindow || 128_000
@@ -818,7 +821,7 @@ export class Cline {
 			// note that this api_req_failed ask is unique in that we only present this option if the api hasn't streamed any content yet (ie it fails on the first chunk due), as it would allow them to hit a retry button. However if the api failed mid-stream, it could be in any arbitrary state where some tools may have executed, so that error is handled differently and requires cancelling the task entirely.
 			const { response } = await this.ask(
 				"api_req_failed",
-				error.message ?? JSON.stringify(serializeError(error), null, 2)
+				error.message ?? JSON.stringify(serializeError(error), null, 2),
 			)
 			if (response !== "yesButtonClicked") {
 				// this will never happen since if noButtonClicked, we will clear current task, aborting this instance
@@ -870,7 +873,7 @@ export class Cline {
 					// (have to do this for partial and complete since sending content in thinking tags to markdown renderer will automatically be removed)
 					// Remove end substrings of <thinking or </thinking (below xml parsing is only for opening tags)
 					// (this is done with the xml parsing below now, but keeping here for reference)
-					// content = content.replace(/<\/?t(?:h(?:i(?:n(?:k(?:i(?:n(?:g)?)?)?)?)?$/, "")
+					// content = content.replace(/<\/?t(?:h(?:i(?:n(?:k(?:i(?:n(?:g)?)?)?)?$/, "")
 					// Remove all instances of <thinking> (with optional line break after) and </thinking> (with optional line break before)
 					// - Needs to be separate since we dont want to remove the line break before the first tag
 					// - Needs to happen before the xml parsing below
@@ -981,7 +984,7 @@ export class Cline {
 						if (response === "messageResponse") {
 							await this.say("user_feedback", text, images)
 							pushToolResult(
-								formatResponse.toolResult(formatResponse.toolDeniedWithFeedback(text), images)
+								formatResponse.toolResult(formatResponse.toolDeniedWithFeedback(text), images),
 							)
 							// this.userMessageContent.push({
 							// 	type: "text",
@@ -1014,7 +1017,7 @@ export class Cline {
 					const errorString = `Error ${action}: ${JSON.stringify(serializeError(error))}`
 					await this.say(
 						"error",
-						`Error ${action}:\n${error.message ?? JSON.stringify(serializeError(error), null, 2)}`
+						`Error ${action}:\n${error.message ?? JSON.stringify(serializeError(error), null, 2)}`,
 					)
 					// this.toolResults.push({
 					// 	type: "tool_result",
@@ -1040,7 +1043,7 @@ export class Cline {
 							.split("")
 							.map((char) => `(?:${char})?`)
 							.join("")}$`,
-						"g"
+						"g",
 					)
 					return text.replace(tagRegex, "")
 				}
@@ -1152,8 +1155,8 @@ export class Cline {
 										? formatResponse.createPrettyPatch(
 												relPath,
 												this.diffViewProvider.originalContent,
-												newContent
-										  )
+												newContent,
+											)
 										: undefined,
 								} satisfies ClineSayTool)
 								const didApprove = this.alwaysAllowWrite || (await askApproval("tool", completeMessage))
@@ -1171,7 +1174,7 @@ export class Cline {
 											tool: fileExists ? "editedExistingFile" : "newFileCreated",
 											path: getReadablePath(cwd, relPath),
 											diff: userEdits,
-										} satisfies ClineSayTool)
+										} satisfies ClineSayTool),
 									)
 									pushToolResult(
 										`The user made the following updates to your content:\n\n${userEdits}\n\n` +
@@ -1181,11 +1184,11 @@ export class Cline {
 											`1. You do not need to re-write the file with these changes, as they have already been applied.\n` +
 											`2. Proceed with the task using this updated file content as the new baseline.\n` +
 											`3. If the user's edits have addressed part of the task or changed the requirements, adjust your approach accordingly.` +
-											`${newProblemsMessage}`
+											`${newProblemsMessage}`,
 									)
 								} else {
 									pushToolResult(
-										`The content was successfully saved to ${relPath.toPosix()}.${newProblemsMessage}`
+										`The content was successfully saved to ${relPath.toPosix()}.${newProblemsMessage}`,
 									)
 								}
 								await this.diffViewProvider.reset()
@@ -1317,7 +1320,7 @@ export class Cline {
 								if (!relDirPath) {
 									this.consecutiveMistakeCount++
 									pushToolResult(
-										await this.sayAndCreateMissingParamError("list_code_definition_names", "path")
+										await this.sayAndCreateMissingParamError("list_code_definition_names", "path"),
 									)
 									break
 								}
@@ -1419,11 +1422,24 @@ export class Cline {
 						try {
 							if (block.partial) {
 								if (action === "launch") {
-									await this.ask(
-										"browser_action_launch",
-										removeClosingTag("url", url),
-										block.partial
-									).catch(() => {})
+									if (this.alwaysAllowBrowser) {
+										await this.say(
+											"browser_action",
+											JSON.stringify({
+												action: action as BrowserAction,
+												coordinate: undefined,
+												text: undefined
+											} satisfies ClineSayBrowserAction),
+											undefined,
+											block.partial
+										)
+									} else {
+										await this.ask(
+											"browser_action_launch",
+											removeClosingTag("url", url),
+											block.partial
+										).catch(() => {})
+									}
 								} else {
 									await this.say(
 										"browser_action",
@@ -1433,7 +1449,7 @@ export class Cline {
 											text: removeClosingTag("text", text),
 										} satisfies ClineSayBrowserAction),
 										undefined,
-										block.partial
+										block.partial,
 									)
 								}
 								break
@@ -1595,7 +1611,7 @@ export class Cline {
 								if (!command) {
 									this.consecutiveMistakeCount++
 									pushToolResult(
-										await this.sayAndCreateMissingParamError("execute_command", "command")
+										await this.sayAndCreateMissingParamError("execute_command", "command"),
 									)
 									break
 								}
@@ -1624,14 +1640,14 @@ export class Cline {
 						try {
 							if (block.partial) {
 								await this.ask("followup", removeClosingTag("question", question), block.partial).catch(
-									() => {}
+									() => {},
 								)
 								break
 							} else {
 								if (!question) {
 									this.consecutiveMistakeCount++
 									pushToolResult(
-										await this.sayAndCreateMissingParamError("ask_followup_question", "question")
+										await this.sayAndCreateMissingParamError("ask_followup_question", "question"),
 									)
 									break
 								}
@@ -1682,7 +1698,7 @@ export class Cline {
 										await this.ask(
 											"command",
 											removeClosingTag("command", command),
-											block.partial
+											block.partial,
 										).catch(() => {})
 									} else {
 										// last message is completion_result
@@ -1691,12 +1707,12 @@ export class Cline {
 											"completion_result",
 											removeClosingTag("result", result),
 											undefined,
-											false
+											false,
 										)
 										await this.ask(
 											"command",
 											removeClosingTag("command", command),
-											block.partial
+											block.partial,
 										).catch(() => {})
 									}
 								} else {
@@ -1705,7 +1721,7 @@ export class Cline {
 										"completion_result",
 										removeClosingTag("result", result),
 										undefined,
-										block.partial
+										block.partial,
 									)
 								}
 								break
@@ -1713,7 +1729,7 @@ export class Cline {
 								if (!result) {
 									this.consecutiveMistakeCount++
 									pushToolResult(
-										await this.sayAndCreateMissingParamError("attempt_completion", "result")
+										await this.sayAndCreateMissingParamError("attempt_completion", "result"),
 									)
 									break
 								}
@@ -1814,7 +1830,7 @@ export class Cline {
 
 	async recursivelyMakeClineRequests(
 		userContent: UserContent,
-		includeFileDetails: boolean = false
+		includeFileDetails: boolean = false,
 	): Promise<boolean> {
 		if (this.abort) {
 			throw new Error("Cline instance aborted")
@@ -1825,7 +1841,7 @@ export class Cline {
 				"mistake_limit_reached",
 				this.api.getModel().id.includes("claude")
 					? `This may indicate a failure in his thought process or inability to use a tool properly, which can be mitigated with some user guidance (e.g. "Try breaking down the task into smaller steps").`
-					: "Cline uses complex prompts and iterative task execution that may be challenging for less capable models. For best results, it's recommended to use Claude 3.5 Sonnet for its advanced agentic coding capabilities."
+					: "Cline uses complex prompts and iterative task execution that may be challenging for less capable models. For best results, it's recommended to use Claude 3.5 Sonnet for its advanced agentic coding capabilities.",
 			)
 			if (response === "messageResponse") {
 				userContent.push(
@@ -1835,7 +1851,7 @@ export class Cline {
 							text: formatResponse.tooManyMistakes(text),
 						} as Anthropic.Messages.TextBlockParam,
 						...formatResponse.imageBlocks(images),
-					]
+					],
 				)
 			}
 			this.consecutiveMistakeCount = 0
@@ -1851,7 +1867,7 @@ export class Cline {
 			JSON.stringify({
 				request:
 					userContent.map((block) => formatContentBlockToMarkdown(block)).join("\n\n") + "\n\nLoading...",
-			})
+			}),
 		)
 
 		const [parsedUserContent, environmentDetails] = await this.loadContext(userContent, includeFileDetails)
@@ -1893,7 +1909,7 @@ export class Cline {
 							inputTokens,
 							outputTokens,
 							cacheWriteTokens,
-							cacheReadTokens
+							cacheReadTokens,
 						),
 					cancelReason,
 					streamingFailedMessage,
@@ -2007,7 +2023,7 @@ export class Cline {
 					this.abortTask() // if the stream failed, there's various states the task could be in (i.e. could have streamed some tools the user may have executed), so we just resort to replicating a cancel task
 					await abortStream(
 						"streaming_failed",
-						error.message ?? JSON.stringify(serializeError(error), null, 2)
+						error.message ?? JSON.stringify(serializeError(error), null, 2),
 					)
 					const history = await this.providerRef.deref()?.getTaskWithId(this.taskId)
 					if (history) {
@@ -2074,7 +2090,7 @@ export class Cline {
 				// if there's no assistant_responses, that means we got no text or tool_use content blocks from API which we should assume is an error
 				await this.say(
 					"error",
-					"Unexpected API Response: The language model did not provide any assistant messages. This may indicate an issue with the API or the model's output."
+					"Unexpected API Response: The language model did not provide any assistant messages. This may indicate an issue with the API or the model's output.",
 				)
 				await this.addToApiConversationHistory({
 					role: "assistant",
@@ -2120,7 +2136,7 @@ export class Cline {
 										}
 									}
 									return contentBlock
-								})
+								}),
 							)
 							return {
 								...block,
@@ -2129,7 +2145,7 @@ export class Cline {
 						}
 					}
 					return block
-				})
+				}),
 			),
 			this.getEnvironmentDetails(includeFileDetails),
 		])

src/core/__tests__/Cline.test.ts

@@ -239,12 +239,14 @@ describe('Cline', () => {
                 undefined, // alwaysAllowReadOnly
                 undefined, // alwaysAllowWrite
                 undefined, // alwaysAllowExecute
+                undefined, // alwaysAllowBrowser
                 'test task'
             );
 
             expect(cline.alwaysAllowReadOnly).toBe(false);
             expect(cline.alwaysAllowWrite).toBe(false);
             expect(cline.alwaysAllowExecute).toBe(false);
+            expect(cline.alwaysAllowBrowser).toBe(false);
         });
 
         it('should respect provided settings', () => {
@@ -255,12 +257,14 @@ describe('Cline', () => {
                 true,  // alwaysAllowReadOnly
                 true,  // alwaysAllowWrite
                 true,  // alwaysAllowExecute
+                true,  // alwaysAllowBrowser
                 'test task'
             );
 
             expect(cline.alwaysAllowReadOnly).toBe(true);
             expect(cline.alwaysAllowWrite).toBe(true);
             expect(cline.alwaysAllowExecute).toBe(true);
+            expect(cline.alwaysAllowBrowser).toBe(true);
             expect(cline.customInstructions).toBe('custom instructions');
         });
 
@@ -285,6 +289,7 @@ describe('Cline', () => {
                 false,
                 false,
                 false,
+                false,
                 'test task'
             );
         });
@@ -297,6 +302,7 @@ describe('Cline', () => {
                 false,
                 true,  // alwaysAllowWrite
                 false,
+                false,
                 'test task'
             );
 
@@ -312,6 +318,7 @@ describe('Cline', () => {
                 false,
                 false,  // alwaysAllowWrite
                 false,
+                false,
                 'test task'
             );
 
@@ -350,6 +357,7 @@ describe('Cline', () => {
                 false,      // alwaysAllowReadOnly
                 false,      // alwaysAllowWrite
                 false,      // alwaysAllowExecute
+                false,      // alwaysAllowBrowser
                 'test task' // task
             )
 

src/core/mentions/index.ts

@@ -150,7 +150,7 @@ async function getFileOrFolderContent(mentionPath: string, cwd: string): Promise
 							} catch (error) {
 								return undefined
 							}
-						})()
+						})(),
 					)
 				} else if (entry.isDirectory()) {
 					folderContent += `${linePrefix}${entry.name}/\n`
@@ -174,7 +174,7 @@ function getWorkspaceProblems(cwd: string): string {
 	const result = diagnosticsToProblemsString(
 		diagnostics,
 		[vscode.DiagnosticSeverity.Error, vscode.DiagnosticSeverity.Warning],
-		cwd
+		cwd,
 	)
 	if (!result) {
 		return "No errors or warnings detected."

src/core/prompts/responses.ts

@@ -30,7 +30,7 @@ Otherwise, if you have not completed the task and do not need additional informa
 
 	toolResult: (
 		text: string,
-		images?: string[]
+		images?: string[],
 	): string | Array<Anthropic.TextBlockParam | Anthropic.ImageBlockParam> => {
 		if (images && images.length > 0) {
 			const textBlock: Anthropic.TextBlockParam = { type: "text", text }
@@ -76,7 +76,7 @@ Otherwise, if you have not completed the task and do not need additional informa
 			})
 		if (didHitLimit) {
 			return `${sorted.join(
-				"\n"
+				"\n",
 			)}\n\n(File list truncated. Use list_files on specific subdirectories if you need to explore further.)`
 		} else if (sorted.length === 0 || (sorted.length === 1 && sorted[0] === "")) {
 			return "No files found."
@@ -105,7 +105,7 @@ const formatImagesIntoBlocks = (images?: string[]): Anthropic.ImageBlockParam[]
 					type: "image",
 					source: { type: "base64", media_type: mimeType, data: base64 },
 				} as Anthropic.ImageBlockParam
-		  })
+			})
 		: []
 }
 

src/core/prompts/system.ts

@@ -6,7 +6,7 @@ import path from 'path'
 
 export const SYSTEM_PROMPT = async (
 	cwd: string,
-	supportsComputerUse: boolean
+	supportsComputerUse: boolean,
 ) => `You are Cline, a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.
 
 ====

src/core/sliding-window/index.ts

@@ -9,7 +9,7 @@ Therefore, this function should only be called when absolutely necessary to fit
 context limits, not as a continuous process.
 */
 export function truncateHalfConversation(
-	messages: Anthropic.Messages.MessageParam[]
+	messages: Anthropic.Messages.MessageParam[],
 ): Anthropic.Messages.MessageParam[] {
 	// API expects messages to be in user-assistant order, and tool use messages must be followed by tool results. We need to maintain this structure while truncating.
 

src/core/webview/ClineProvider.ts

@@ -48,6 +48,7 @@ type GlobalStateKey =
 	| "alwaysAllowReadOnly"
 	| "alwaysAllowWrite"
 	| "alwaysAllowExecute"
+	| "alwaysAllowBrowser"
 	| "taskHistory"
 	| "openAiBaseUrl"
 	| "openAiModelId"
@@ -76,7 +77,10 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 	private workspaceTracker?: WorkspaceTracker
 	private latestAnnouncementId = "oct-28-2024" // update to some unique identifier when we add a new announcement
 
-	constructor(readonly context: vscode.ExtensionContext, private readonly outputChannel: vscode.OutputChannel) {
+	constructor(
+		readonly context: vscode.ExtensionContext,
+		private readonly outputChannel: vscode.OutputChannel,
+	) {
 		this.outputChannel.appendLine("ClineProvider instantiated")
 		ClineProvider.activeInstances.add(this)
 		this.workspaceTracker = new WorkspaceTracker(this)
@@ -112,7 +116,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 	}
 
 	resolveWebviewView(
-		webviewView: vscode.WebviewView | vscode.WebviewPanel
+		webviewView: vscode.WebviewView | vscode.WebviewPanel,
 		//context: vscode.WebviewViewResolveContext<unknown>, used to recreate a deallocated webview, but we don't need this since we use retainContextWhenHidden
 		//token: vscode.CancellationToken
 	): void | Thenable<void> {
@@ -145,7 +149,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 					}
 				},
 				null,
-				this.disposables
+				this.disposables,
 			)
 		} else if ("onDidChangeVisibility" in webviewView) {
 			// sidebar
@@ -156,7 +160,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 					}
 				},
 				null,
-				this.disposables
+				this.disposables,
 			)
 		}
 
@@ -167,7 +171,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 				await this.dispose()
 			},
 			null,
-			this.disposables
+			this.disposables,
 		)
 
 		// Listen for when color changes
@@ -179,7 +183,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 				}
 			},
 			null,
-			this.disposables
+			this.disposables,
 		)
 
 		// if the extension is starting a new session, clear previous task state
@@ -189,14 +193,40 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 	}
 
 	async initClineWithTask(task?: string, images?: string[]) {
-		await this.clearTask() // ensures that an exising task doesn't exist before starting a new one, although this shouldn't be possible since user must clear task before starting a new one
-		const { apiConfiguration, customInstructions, alwaysAllowReadOnly, alwaysAllowWrite, alwaysAllowExecute } = await this.getState()
-		this.cline = new Cline(this, apiConfiguration, customInstructions, alwaysAllowReadOnly, alwaysAllowWrite, alwaysAllowExecute, task, images)
+		await this.clearTask()
+		const { 
+			apiConfiguration, 
+			customInstructions, 
+			alwaysAllowReadOnly, 
+			alwaysAllowWrite, 
+			alwaysAllowExecute,
+			alwaysAllowBrowser 
+		} = await this.getState()
+		
+		this.cline = new Cline(
+			this, 
+			apiConfiguration, 
+			customInstructions, 
+			alwaysAllowReadOnly, 
+			alwaysAllowWrite, 
+			alwaysAllowExecute,
+			alwaysAllowBrowser,
+			task, 
+			images
+		)
 	}
 
 	async initClineWithHistoryItem(historyItem: HistoryItem) {
 		await this.clearTask()
-		const { apiConfiguration, customInstructions, alwaysAllowReadOnly, alwaysAllowWrite, alwaysAllowExecute } = await this.getState()
+		const { 
+			apiConfiguration, 
+			customInstructions, 
+			alwaysAllowReadOnly, 
+			alwaysAllowWrite, 
+			alwaysAllowExecute,
+			alwaysAllowBrowser 
+		} = await this.getState()
+		
 		this.cline = new Cline(
 			this,
 			apiConfiguration,
@@ -204,9 +234,10 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			alwaysAllowReadOnly,
 			alwaysAllowWrite,
 			alwaysAllowExecute,
+			alwaysAllowBrowser,
 			undefined,
 			undefined,
-			historyItem
+			historyItem,
 		)
 	}
 
@@ -310,7 +341,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 						this.postStateToWebview()
 						this.workspaceTracker?.initializeFilePaths() // don't await
 						getTheme().then((theme) =>
-							this.postMessageToWebview({ type: "theme", text: JSON.stringify(theme) })
+							this.postMessageToWebview({ type: "theme", text: JSON.stringify(theme) }),
 						)
 						// post last cached models in case the call to endpoint fails
 						this.readOpenRouterModels().then((openRouterModels) => {
@@ -328,7 +359,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 								if (apiConfiguration.openRouterModelId) {
 									await this.updateGlobalState(
 										"openRouterModelInfo",
-										openRouterModels[apiConfiguration.openRouterModelId]
+										openRouterModels[apiConfiguration.openRouterModelId],
 									)
 									await this.postStateToWebview()
 								}
@@ -499,13 +530,20 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 							// await this.postStateToWebview() // new Cline instance will post state when it's ready. having this here sent an empty messages array to webview leading to virtuoso having to reload the entire list
 						}
 
+						break
+					case "alwaysAllowBrowser":
+						await this.updateGlobalState("alwaysAllowBrowser", message.bool ?? undefined)
+						if (this.cline) {
+							this.cline.alwaysAllowBrowser = message.bool ?? false
+						}
+						await this.postStateToWebview()
 						break
 					// Add more switch case statements here as more webview message commands
 					// are created within the webview context (i.e. inside media/main.js)
 				}
 			},
 			null,
-			this.disposables
+			this.disposables,
 		)
 	}
 
@@ -591,7 +629,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 	async readOpenRouterModels(): Promise<Record<string, ModelInfo> | undefined> {
 		const openRouterModelsFilePath = path.join(
 			await this.ensureCacheDirectoryExists(),
-			GlobalFileNames.openRouterModels
+			GlobalFileNames.openRouterModels,
 		)
 		const fileExists = await fileExistsAtPath(openRouterModelsFilePath)
 		if (fileExists) {
@@ -604,7 +642,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 	async refreshOpenRouterModels() {
 		const openRouterModelsFilePath = path.join(
 			await this.ensureCacheDirectoryExists(),
-			GlobalFileNames.openRouterModels
+			GlobalFileNames.openRouterModels,
 		)
 
 		let models: Record<string, ModelInfo> = {}
@@ -785,7 +823,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 
 	async deleteTaskFromState(id: string) {
 		// Remove the task from history
-		const taskHistory = ((await this.getGlobalState("taskHistory")) as HistoryItem[] | undefined) || []
+		const taskHistory = ((await this.getGlobalState("taskHistory")) as HistoryItem[]) || []
 		const updatedTaskHistory = taskHistory.filter((task) => task.id !== id)
 		await this.updateGlobalState("taskHistory", updatedTaskHistory)
 
@@ -799,8 +837,17 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 	}
 
 	async getStateToPostToWebview() {
-		const { apiConfiguration, lastShownAnnouncementId, customInstructions, alwaysAllowReadOnly, alwaysAllowWrite, alwaysAllowExecute, taskHistory } =
-			await this.getState()
+		const { 
+			apiConfiguration, 
+			lastShownAnnouncementId, 
+			customInstructions, 
+			alwaysAllowReadOnly, 
+			alwaysAllowWrite, 
+			alwaysAllowExecute,
+			alwaysAllowBrowser, 
+			taskHistory 
+		} = await this.getState()
+		
 		return {
 			version: this.context.extension?.packageJSON?.version ?? "",
 			apiConfiguration,
@@ -808,9 +855,12 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			alwaysAllowReadOnly: alwaysAllowReadOnly ?? false,
 			alwaysAllowWrite: alwaysAllowWrite ?? false,
 			alwaysAllowExecute: alwaysAllowExecute ?? false,
+			alwaysAllowBrowser: alwaysAllowBrowser ?? false,
 			uriScheme: vscode.env.uriScheme,
 			clineMessages: this.cline?.clineMessages || [],
-			taskHistory: (taskHistory || []).filter((item) => item.ts && item.task).sort((a, b) => b.ts - a.ts),
+			taskHistory: (taskHistory || [])
+				.filter((item) => item.ts && item.task)
+				.sort((a, b) => b.ts - a.ts),
 			shouldShowAnnouncement: lastShownAnnouncementId !== this.latestAnnouncementId,
 		}
 	}
@@ -898,6 +948,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			alwaysAllowWrite,
 			alwaysAllowExecute,
 			taskHistory,
+			alwaysAllowBrowser,
 		] = await Promise.all([
 			this.getGlobalState("apiProvider") as Promise<ApiProvider | undefined>,
 			this.getGlobalState("apiModelId") as Promise<string | undefined>,
@@ -929,6 +980,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			this.getGlobalState("alwaysAllowWrite") as Promise<boolean | undefined>,
 			this.getGlobalState("alwaysAllowExecute") as Promise<boolean | undefined>,
 			this.getGlobalState("taskHistory") as Promise<HistoryItem[] | undefined>,
+			this.getGlobalState("alwaysAllowBrowser") as Promise<boolean | undefined>,
 		])
 
 		let apiProvider: ApiProvider
@@ -977,6 +1029,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			alwaysAllowReadOnly: alwaysAllowReadOnly ?? false,
 			alwaysAllowWrite: alwaysAllowWrite ?? false,
 			alwaysAllowExecute: alwaysAllowExecute ?? false,
+			alwaysAllowBrowser: alwaysAllowBrowser ?? false,
 			taskHistory,
 		}
 	}

src/exports/index.ts

@@ -25,13 +25,13 @@ export function createClineAPI(outputChannel: vscode.OutputChannel, sidebarProvi
 				images: images,
 			})
 			outputChannel.appendLine(
-				`Task started with message: ${task ? `"${task}"` : "undefined"} and ${images?.length || 0} image(s)`
+				`Task started with message: ${task ? `"${task}"` : "undefined"} and ${images?.length || 0} image(s)`,
 			)
 		},
 
 		sendMessage: async (message?: string, images?: string[]) => {
 			outputChannel.appendLine(
-				`Sending message: ${message ? `"${message}"` : "undefined"} with ${images?.length || 0} image(s)`
+				`Sending message: ${message ? `"${message}"` : "undefined"} with ${images?.length || 0} image(s)`,
 			)
 			await sidebarProvider.postMessageToWebview({
 				type: "invoke",

src/extension.ts

@@ -31,7 +31,7 @@ export function activate(context: vscode.ExtensionContext) {
 	context.subscriptions.push(
 		vscode.window.registerWebviewViewProvider(ClineProvider.sideBarId, sidebarProvider, {
 			webviewOptions: { retainContextWhenHidden: true },
-		})
+		}),
 	)
 
 	context.subscriptions.push(
@@ -40,7 +40,7 @@ export function activate(context: vscode.ExtensionContext) {
 			await sidebarProvider.clearTask()
 			await sidebarProvider.postStateToWebview()
 			await sidebarProvider.postMessageToWebview({ type: "action", action: "chatButtonClicked" })
-		})
+		}),
 	)
 
 	const openClineInNewTab = async () => {
@@ -83,13 +83,13 @@ export function activate(context: vscode.ExtensionContext) {
 		vscode.commands.registerCommand("cline.settingsButtonClicked", () => {
 			//vscode.window.showInformationMessage(message)
 			sidebarProvider.postMessageToWebview({ type: "action", action: "settingsButtonClicked" })
-		})
+		}),
 	)
 
 	context.subscriptions.push(
 		vscode.commands.registerCommand("cline.historyButtonClicked", () => {
 			sidebarProvider.postMessageToWebview({ type: "action", action: "historyButtonClicked" })
-		})
+		}),
 	)
 
 	/*
@@ -105,7 +105,7 @@ export function activate(context: vscode.ExtensionContext) {
 		}
 	})()
 	context.subscriptions.push(
-		vscode.workspace.registerTextDocumentContentProvider(DIFF_VIEW_URI_SCHEME, diffContentProvider)
+		vscode.workspace.registerTextDocumentContentProvider(DIFF_VIEW_URI_SCHEME, diffContentProvider),
 	)
 
 	// URI Handler

src/integrations/diagnostics/index.ts

@@ -4,7 +4,7 @@ import deepEqual from "fast-deep-equal"
 
 export function getNewDiagnostics(
 	oldDiagnostics: [vscode.Uri, vscode.Diagnostic[]][],
-	newDiagnostics: [vscode.Uri, vscode.Diagnostic[]][]
+	newDiagnostics: [vscode.Uri, vscode.Diagnostic[]][],
 ): [vscode.Uri, vscode.Diagnostic[]][] {
 	const newProblems: [vscode.Uri, vscode.Diagnostic[]][] = []
 	const oldMap = new Map(oldDiagnostics)
@@ -73,7 +73,7 @@ export function getNewDiagnostics(
 export function diagnosticsToProblemsString(
 	diagnostics: [vscode.Uri, vscode.Diagnostic[]][],
 	severities: vscode.DiagnosticSeverity[],
-	cwd: string
+	cwd: string,
 ): string {
 	let result = ""
 	for (const [uri, fileDiagnostics] of diagnostics) {

src/integrations/editor/DecorationController.ts

@@ -65,8 +65,8 @@ export class DecorationController {
 			this.ranges.push(
 				new vscode.Range(
 					new vscode.Position(line + 1, 0),
-					new vscode.Position(totalLines - 1, Number.MAX_SAFE_INTEGER)
-				)
+					new vscode.Position(totalLines - 1, Number.MAX_SAFE_INTEGER),
+				),
 			)
 		}
 

src/integrations/editor/DiffViewProvider.ts

@@ -34,7 +34,7 @@ export class DiffViewProvider {
 		// if the file is already open, ensure it's not dirty before getting its contents
 		if (fileExists) {
 			const existingDocument = vscode.workspace.textDocuments.find((doc) =>
-				arePathsEqual(doc.uri.fsPath, absolutePath)
+				arePathsEqual(doc.uri.fsPath, absolutePath),
 			)
 			if (existingDocument && existingDocument.isDirty) {
 				await existingDocument.save()
@@ -62,7 +62,7 @@ export class DiffViewProvider {
 			.map((tg) => tg.tabs)
 			.flat()
 			.filter(
-				(tab) => tab.input instanceof vscode.TabInputText && arePathsEqual(tab.input.uri.fsPath, absolutePath)
+				(tab) => tab.input instanceof vscode.TabInputText && arePathsEqual(tab.input.uri.fsPath, absolutePath),
 			)
 		for (const tab of tabs) {
 			if (!tab.isDirty) {
@@ -179,7 +179,7 @@ export class DiffViewProvider {
 			[
 				vscode.DiagnosticSeverity.Error, // only including errors since warnings can be distracting (if user wants to fix warnings they can use the @problems mention)
 			],
-			this.cwd
+			this.cwd,
 		) // will be empty string if no errors
 		const newProblemsMessage =
 			newProblems.length > 0 ? `\n\nNew problems detected after saving the file:\n${newProblems}` : ""
@@ -194,7 +194,7 @@ export class DiffViewProvider {
 			const userEdits = formatResponse.createPrettyPatch(
 				this.relPath.toPosix(),
 				normalizedNewContent,
-				normalizedEditedContent
+				normalizedEditedContent,
 			)
 			return { newProblemsMessage, userEdits, finalContent: normalizedEditedContent }
 		} else {
@@ -227,7 +227,7 @@ export class DiffViewProvider {
 			const edit = new vscode.WorkspaceEdit()
 			const fullRange = new vscode.Range(
 				updatedDocument.positionAt(0),
-				updatedDocument.positionAt(updatedDocument.getText().length)
+				updatedDocument.positionAt(updatedDocument.getText().length),
 			)
 			edit.replace(updatedDocument.uri, fullRange, this.originalContent ?? "")
 			// Apply the edit and save, since contents shouldnt have changed this wont show in local history unless of course the user made changes and saved during the edit
@@ -251,7 +251,8 @@ export class DiffViewProvider {
 			.flatMap((tg) => tg.tabs)
 			.filter(
 				(tab) =>
-					tab.input instanceof vscode.TabInputTextDiff && tab.input?.original?.scheme === DIFF_VIEW_URI_SCHEME
+					tab.input instanceof vscode.TabInputTextDiff &&
+					tab.input?.original?.scheme === DIFF_VIEW_URI_SCHEME,
 			)
 		for (const tab of tabs) {
 			// trying to close dirty views results in save popup
@@ -273,7 +274,7 @@ export class DiffViewProvider {
 				(tab) =>
 					tab.input instanceof vscode.TabInputTextDiff &&
 					tab.input?.original?.scheme === DIFF_VIEW_URI_SCHEME &&
-					arePathsEqual(tab.input.modified.fsPath, uri.fsPath)
+					arePathsEqual(tab.input.modified.fsPath, uri.fsPath),
 			)
 		if (diffTab && diffTab.input instanceof vscode.TabInputTextDiff) {
 			const editor = await vscode.window.showTextDocument(diffTab.input.modified)
@@ -295,7 +296,7 @@ export class DiffViewProvider {
 					query: Buffer.from(this.originalContent ?? "").toString("base64"),
 				}),
 				uri,
-				`${fileName}: ${fileExists ? "Original ↔ Cline's Changes" : "New File"} (Editable)`
+				`${fileName}: ${fileExists ? "Original ↔ Cline's Changes" : "New File"} (Editable)`,
 			)
 			// This may happen on very slow machines ie project idx
 			setTimeout(() => {
@@ -310,7 +311,7 @@ export class DiffViewProvider {
 			const scrollLine = line + 4
 			this.activeDiffEditor.revealRange(
 				new vscode.Range(scrollLine, 0, scrollLine, 0),
-				vscode.TextEditorRevealType.InCenter
+				vscode.TextEditorRevealType.InCenter,
 			)
 		}
 	}
@@ -327,7 +328,7 @@ export class DiffViewProvider {
 				// Found the first diff, scroll to it
 				this.activeDiffEditor.revealRange(
 					new vscode.Range(lineCount, 0, lineCount, 0),
-					vscode.TextEditorRevealType.InCenter
+					vscode.TextEditorRevealType.InCenter,
 				)
 				return
 			}

src/integrations/editor/detect-omission.ts

@@ -43,14 +43,14 @@ export function showOmissionWarning(originalFileContent: string, newFileContent:
 		vscode.window
 			.showWarningMessage(
 				"Potential code truncation detected. This happens when the AI reaches its max output limit.",
-				"Follow this guide to fix the issue"
+				"Follow this guide to fix the issue",
 			)
 			.then((selection) => {
 				if (selection === "Follow this guide to fix the issue") {
 					vscode.env.openExternal(
 						vscode.Uri.parse(
-							"https://github.com/cline/cline/wiki/Troubleshooting-%E2%80%90-Cline-Deleting-Code-with-%22Rest-of-Code-Here%22-Comments"
-						)
+							"https://github.com/cline/cline/wiki/Troubleshooting-%E2%80%90-Cline-Deleting-Code-with-%22Rest-of-Code-Here%22-Comments",
+						),
 					)
 				}
 			})

src/integrations/misc/export-markdown.ts

@@ -46,7 +46,7 @@ export function formatContentBlockToMarkdown(
 		| Anthropic.TextBlockParam
 		| Anthropic.ImageBlockParam
 		| Anthropic.ToolUseBlockParam
-		| Anthropic.ToolResultBlockParam
+		| Anthropic.ToolResultBlockParam,
 	// messages: Anthropic.MessageParam[]
 ): string {
 	switch (block.type) {

src/integrations/misc/open-file.ts

@@ -28,12 +28,13 @@ export async function openFile(absolutePath: string) {
 		try {
 			for (const group of vscode.window.tabGroups.all) {
 				const existingTab = group.tabs.find(
-					(tab) => tab.input instanceof vscode.TabInputText && arePathsEqual(tab.input.uri.fsPath, uri.fsPath)
+					(tab) =>
+						tab.input instanceof vscode.TabInputText && arePathsEqual(tab.input.uri.fsPath, uri.fsPath),
 				)
 				if (existingTab) {
 					const activeColumn = vscode.window.activeTextEditor?.viewColumn
 					const tabColumn = vscode.window.tabGroups.all.find((group) =>
-						group.tabs.includes(existingTab)
+						group.tabs.includes(existingTab),
 					)?.viewColumn
 					if (activeColumn && activeColumn !== tabColumn && !existingTab.isDirty) {
 						await vscode.window.tabGroups.close(existingTab)

src/integrations/misc/process-images.ts

@@ -25,7 +25,7 @@ export async function selectImages(): Promise<string[]> {
 			const mimeType = getMimeType(imagePath)
 			const dataUrl = `data:${mimeType};base64,${base64}`
 			return dataUrl
-		})
+		}),
 	)
 }
 

src/integrations/terminal/TerminalManager.ts

@@ -75,7 +75,7 @@ declare module "vscode" {
 		onDidStartTerminalShellExecution?: (
 			listener: (e: any) => any,
 			thisArgs?: any,
-			disposables?: vscode.Disposable[]
+			disposables?: vscode.Disposable[],
 		) => vscode.Disposable
 	}
 }

src/integrations/terminal/TerminalProcess.ts

@@ -54,7 +54,7 @@ export class TerminalProcess extends EventEmitter<TerminalProcessEvents> {
 					/* ddateb15026-6a64-40db-b21f-2a621a9830f0]633;CTue Sep 17 06:37:04 EDT 2024 % ]633;D;0]633;P;Cwd=/Users/saoud/Repositories/test */
 					// Gets output between ]633;C (command start) and ]633;D (command end)
 					const outputBetweenSequences = this.removeLastLineArtifacts(
-						data.match(/\]633;C([\s\S]*?)\]633;D/)?.[1] || ""
+						data.match(/\]633;C([\s\S]*?)\]633;D/)?.[1] || "",
 					).trim()
 
 					// Once we've retrieved any potential output between sequences, we can remove everything up to end of the last sequence
@@ -142,7 +142,7 @@ export class TerminalProcess extends EventEmitter<TerminalProcessEvents> {
 					() => {
 						this.isHot = false
 					},
-					isCompiling ? PROCESS_HOT_TIMEOUT_COMPILING : PROCESS_HOT_TIMEOUT_NORMAL
+					isCompiling ? PROCESS_HOT_TIMEOUT_COMPILING : PROCESS_HOT_TIMEOUT_NORMAL,
 				)
 
 				// For non-immediately returning commands we want to show loading spinner right away but this wouldnt happen until it emits a line break, so as soon as we get any output we emit "" to let webview know to show spinner
@@ -240,7 +240,7 @@ export type TerminalProcessResultPromise = TerminalProcess & Promise<void>
 export function mergePromise(process: TerminalProcess, promise: Promise<void>): TerminalProcessResultPromise {
 	const nativePromisePrototype = (async () => {})().constructor.prototype
 	const descriptors = ["then", "catch", "finally"].map(
-		(property) => [property, Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)] as const
+		(property) => [property, Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)] as const,
 	)
 	for (const [property, descriptor] of descriptors) {
 		if (descriptor) {

src/integrations/theme/default-themes/dark_modern.json

@@ -1,128 +1,128 @@
 {
-  "$schema": "vscode://schemas/color-theme",
-  "name": "Default Dark Modern",
-  "include": "./dark_plus.json",
-  "colors": {
-    "activityBar.activeBorder": "#0078D4",
-    "activityBar.background": "#181818",
-    "activityBar.border": "#2B2B2B",
-    "activityBar.foreground": "#D7D7D7",
-    "activityBar.inactiveForeground": "#868686",
-    "activityBarBadge.background": "#0078D4",
-    "activityBarBadge.foreground": "#FFFFFF",
-    "badge.background": "#616161",
-    "badge.foreground": "#F8F8F8",
-    "button.background": "#0078D4",
-    "button.border": "#FFFFFF12",
-    "button.foreground": "#FFFFFF",
-    "button.hoverBackground": "#026EC1",
-    "button.secondaryBackground": "#313131",
-    "button.secondaryForeground": "#CCCCCC",
-    "button.secondaryHoverBackground": "#3C3C3C",
-    "chat.slashCommandBackground": "#34414B",
-    "chat.slashCommandForeground": "#40A6FF",
-    "checkbox.background": "#313131",
-    "checkbox.border": "#3C3C3C",
-    "debugToolBar.background": "#181818",
-    "descriptionForeground": "#9D9D9D",
-    "dropdown.background": "#313131",
-    "dropdown.border": "#3C3C3C",
-    "dropdown.foreground": "#CCCCCC",
-    "dropdown.listBackground": "#1F1F1F",
-    "editor.background": "#1F1F1F",
-    "editor.findMatchBackground": "#9E6A03",
-    "editor.foreground": "#CCCCCC",
-    "editorGroup.border": "#FFFFFF17",
-    "editorGroupHeader.tabsBackground": "#181818",
-    "editorGroupHeader.tabsBorder": "#2B2B2B",
-    "editorGutter.addedBackground": "#2EA043",
-    "editorGutter.deletedBackground": "#F85149",
-    "editorGutter.modifiedBackground": "#0078D4",
-    "editorLineNumber.activeForeground": "#CCCCCC",
-    "editorLineNumber.foreground": "#6E7681",
-    "editorOverviewRuler.border": "#010409",
-    "editorWidget.background": "#202020",
-    "errorForeground": "#F85149",
-    "focusBorder": "#0078D4",
-    "foreground": "#CCCCCC",
-    "icon.foreground": "#CCCCCC",
-    "input.background": "#313131",
-    "input.border": "#3C3C3C",
-    "input.foreground": "#CCCCCC",
-    "input.placeholderForeground": "#989898",
-    "inputOption.activeBackground": "#2489DB82",
-    "inputOption.activeBorder": "#2488DB",
-    "keybindingLabel.foreground": "#CCCCCC",
-    "menu.background": "#1F1F1F",
-    "notificationCenterHeader.background": "#1F1F1F",
-    "notificationCenterHeader.foreground": "#CCCCCC",
-    "notifications.background": "#1F1F1F",
-    "notifications.border": "#2B2B2B",
-    "notifications.foreground": "#CCCCCC",
-    "panel.background": "#181818",
-    "panel.border": "#2B2B2B",
-    "panelInput.border": "#2B2B2B",
-    "panelTitle.activeBorder": "#0078D4",
-    "panelTitle.activeForeground": "#CCCCCC",
-    "panelTitle.inactiveForeground": "#9D9D9D",
-    "peekViewEditor.background": "#1F1F1F",
-    "peekViewEditor.matchHighlightBackground": "#BB800966",
-    "peekViewResult.background": "#1F1F1F",
-    "peekViewResult.matchHighlightBackground": "#BB800966",
-    "pickerGroup.border": "#3C3C3C",
-    "progressBar.background": "#0078D4",
-    "quickInput.background": "#222222",
-    "quickInput.foreground": "#CCCCCC",
-    "settings.dropdownBackground": "#313131",
-    "settings.dropdownBorder": "#3C3C3C",
-    "settings.headerForeground": "#FFFFFF",
-    "settings.modifiedItemIndicator": "#BB800966",
-    "sideBar.background": "#181818",
-    "sideBar.border": "#2B2B2B",
-    "sideBar.foreground": "#CCCCCC",
-    "sideBarSectionHeader.background": "#181818",
-    "sideBarSectionHeader.border": "#2B2B2B",
-    "sideBarSectionHeader.foreground": "#CCCCCC",
-    "sideBarTitle.foreground": "#CCCCCC",
-    "statusBar.background": "#181818",
-    "statusBar.border": "#2B2B2B",
-    "statusBar.debuggingBackground": "#0078D4",
-    "statusBar.debuggingForeground": "#FFFFFF",
-    "statusBar.focusBorder": "#0078D4",
-    "statusBar.foreground": "#CCCCCC",
-    "statusBar.noFolderBackground": "#1F1F1F",
-    "statusBarItem.focusBorder": "#0078D4",
-    "statusBarItem.prominentBackground": "#6E768166",
-    "statusBarItem.remoteBackground": "#0078D4",
-    "statusBarItem.remoteForeground": "#FFFFFF",
-    "tab.activeBackground": "#1F1F1F",
-    "tab.activeBorder": "#1F1F1F",
-    "tab.activeBorderTop": "#0078D4",
-    "tab.activeForeground": "#FFFFFF",
-    "tab.border": "#2B2B2B",
-    "tab.hoverBackground": "#1F1F1F",
-    "tab.inactiveBackground": "#181818",
-    "tab.inactiveForeground": "#9D9D9D",
-    "tab.unfocusedActiveBorder": "#1F1F1F",
-    "tab.unfocusedActiveBorderTop": "#2B2B2B",
-    "tab.unfocusedHoverBackground": "#1F1F1F",
-    "terminal.foreground": "#CCCCCC",
-    "terminal.tab.activeBorder": "#0078D4",
-    "textBlockQuote.background": "#2B2B2B",
-    "textBlockQuote.border": "#616161",
-    "textCodeBlock.background": "#2B2B2B",
-    "textLink.activeForeground": "#4daafc",
-    "textLink.foreground": "#4daafc",
-    "textPreformat.foreground": "#D0D0D0",
-    "textPreformat.background": "#3C3C3C",
-    "textSeparator.foreground": "#21262D",
-    "titleBar.activeBackground": "#181818",
-    "titleBar.activeForeground": "#CCCCCC",
-    "titleBar.border": "#2B2B2B",
-    "titleBar.inactiveBackground": "#1F1F1F",
-    "titleBar.inactiveForeground": "#9D9D9D",
-    "welcomePage.tileBackground": "#2B2B2B",
-    "welcomePage.progress.foreground": "#0078D4",
-    "widget.border": "#313131"
-  }
+	"$schema": "vscode://schemas/color-theme",
+	"name": "Default Dark Modern",
+	"include": "./dark_plus.json",
+	"colors": {
+		"activityBar.activeBorder": "#0078D4",
+		"activityBar.background": "#181818",
+		"activityBar.border": "#2B2B2B",
+		"activityBar.foreground": "#D7D7D7",
+		"activityBar.inactiveForeground": "#868686",
+		"activityBarBadge.background": "#0078D4",
+		"activityBarBadge.foreground": "#FFFFFF",
+		"badge.background": "#616161",
+		"badge.foreground": "#F8F8F8",
+		"button.background": "#0078D4",
+		"button.border": "#FFFFFF12",
+		"button.foreground": "#FFFFFF",
+		"button.hoverBackground": "#026EC1",
+		"button.secondaryBackground": "#313131",
+		"button.secondaryForeground": "#CCCCCC",
+		"button.secondaryHoverBackground": "#3C3C3C",
+		"chat.slashCommandBackground": "#34414B",
+		"chat.slashCommandForeground": "#40A6FF",
+		"checkbox.background": "#313131",
+		"checkbox.border": "#3C3C3C",
+		"debugToolBar.background": "#181818",
+		"descriptionForeground": "#9D9D9D",
+		"dropdown.background": "#313131",
+		"dropdown.border": "#3C3C3C",
+		"dropdown.foreground": "#CCCCCC",
+		"dropdown.listBackground": "#1F1F1F",
+		"editor.background": "#1F1F1F",
+		"editor.findMatchBackground": "#9E6A03",
+		"editor.foreground": "#CCCCCC",
+		"editorGroup.border": "#FFFFFF17",
+		"editorGroupHeader.tabsBackground": "#181818",
+		"editorGroupHeader.tabsBorder": "#2B2B2B",
+		"editorGutter.addedBackground": "#2EA043",
+		"editorGutter.deletedBackground": "#F85149",
+		"editorGutter.modifiedBackground": "#0078D4",
+		"editorLineNumber.activeForeground": "#CCCCCC",
+		"editorLineNumber.foreground": "#6E7681",
+		"editorOverviewRuler.border": "#010409",
+		"editorWidget.background": "#202020",
+		"errorForeground": "#F85149",
+		"focusBorder": "#0078D4",
+		"foreground": "#CCCCCC",
+		"icon.foreground": "#CCCCCC",
+		"input.background": "#313131",
+		"input.border": "#3C3C3C",
+		"input.foreground": "#CCCCCC",
+		"input.placeholderForeground": "#989898",
+		"inputOption.activeBackground": "#2489DB82",
+		"inputOption.activeBorder": "#2488DB",
+		"keybindingLabel.foreground": "#CCCCCC",
+		"menu.background": "#1F1F1F",
+		"notificationCenterHeader.background": "#1F1F1F",
+		"notificationCenterHeader.foreground": "#CCCCCC",
+		"notifications.background": "#1F1F1F",
+		"notifications.border": "#2B2B2B",
+		"notifications.foreground": "#CCCCCC",
+		"panel.background": "#181818",
+		"panel.border": "#2B2B2B",
+		"panelInput.border": "#2B2B2B",
+		"panelTitle.activeBorder": "#0078D4",
+		"panelTitle.activeForeground": "#CCCCCC",
+		"panelTitle.inactiveForeground": "#9D9D9D",
+		"peekViewEditor.background": "#1F1F1F",
+		"peekViewEditor.matchHighlightBackground": "#BB800966",
+		"peekViewResult.background": "#1F1F1F",
+		"peekViewResult.matchHighlightBackground": "#BB800966",
+		"pickerGroup.border": "#3C3C3C",
+		"progressBar.background": "#0078D4",
+		"quickInput.background": "#222222",
+		"quickInput.foreground": "#CCCCCC",
+		"settings.dropdownBackground": "#313131",
+		"settings.dropdownBorder": "#3C3C3C",
+		"settings.headerForeground": "#FFFFFF",
+		"settings.modifiedItemIndicator": "#BB800966",
+		"sideBar.background": "#181818",
+		"sideBar.border": "#2B2B2B",
+		"sideBar.foreground": "#CCCCCC",
+		"sideBarSectionHeader.background": "#181818",
+		"sideBarSectionHeader.border": "#2B2B2B",
+		"sideBarSectionHeader.foreground": "#CCCCCC",
+		"sideBarTitle.foreground": "#CCCCCC",
+		"statusBar.background": "#181818",
+		"statusBar.border": "#2B2B2B",
+		"statusBar.debuggingBackground": "#0078D4",
+		"statusBar.debuggingForeground": "#FFFFFF",
+		"statusBar.focusBorder": "#0078D4",
+		"statusBar.foreground": "#CCCCCC",
+		"statusBar.noFolderBackground": "#1F1F1F",
+		"statusBarItem.focusBorder": "#0078D4",
+		"statusBarItem.prominentBackground": "#6E768166",
+		"statusBarItem.remoteBackground": "#0078D4",
+		"statusBarItem.remoteForeground": "#FFFFFF",
+		"tab.activeBackground": "#1F1F1F",
+		"tab.activeBorder": "#1F1F1F",
+		"tab.activeBorderTop": "#0078D4",
+		"tab.activeForeground": "#FFFFFF",
+		"tab.border": "#2B2B2B",
+		"tab.hoverBackground": "#1F1F1F",
+		"tab.inactiveBackground": "#181818",
+		"tab.inactiveForeground": "#9D9D9D",
+		"tab.unfocusedActiveBorder": "#1F1F1F",
+		"tab.unfocusedActiveBorderTop": "#2B2B2B",
+		"tab.unfocusedHoverBackground": "#1F1F1F",
+		"terminal.foreground": "#CCCCCC",
+		"terminal.tab.activeBorder": "#0078D4",
+		"textBlockQuote.background": "#2B2B2B",
+		"textBlockQuote.border": "#616161",
+		"textCodeBlock.background": "#2B2B2B",
+		"textLink.activeForeground": "#4daafc",
+		"textLink.foreground": "#4daafc",
+		"textPreformat.foreground": "#D0D0D0",
+		"textPreformat.background": "#3C3C3C",
+		"textSeparator.foreground": "#21262D",
+		"titleBar.activeBackground": "#181818",
+		"titleBar.activeForeground": "#CCCCCC",
+		"titleBar.border": "#2B2B2B",
+		"titleBar.inactiveBackground": "#1F1F1F",
+		"titleBar.inactiveForeground": "#9D9D9D",
+		"welcomePage.tileBackground": "#2B2B2B",
+		"welcomePage.progress.foreground": "#0078D4",
+		"widget.border": "#313131"
+	}
 }

src/integrations/theme/default-themes/dark_plus.json

@@ -1,193 +1,193 @@
 {
-  "$schema": "vscode://schemas/color-theme",
-  "name": "Dark+",
-  "include": "./dark_vs.json",
-  "tokenColors": [
-    {
-      "name": "Function declarations",
-      "scope": [
-        "entity.name.function",
-        "support.function",
-        "support.constant.handlebars",
-        "source.powershell variable.other.member",
-        "entity.name.operator.custom-literal"
-      ],
-      "settings": {
-        "foreground": "#DCDCAA"
-      }
-    },
-    {
-      "name": "Types declaration and references",
-      "scope": [
-        "support.class",
-        "support.type",
-        "entity.name.type",
-        "entity.name.namespace",
-        "entity.other.attribute",
-        "entity.name.scope-resolution",
-        "entity.name.class",
-        "storage.type.numeric.go",
-        "storage.type.byte.go",
-        "storage.type.boolean.go",
-        "storage.type.string.go",
-        "storage.type.uintptr.go",
-        "storage.type.error.go",
-        "storage.type.rune.go",
-        "storage.type.cs",
-        "storage.type.generic.cs",
-        "storage.type.modifier.cs",
-        "storage.type.variable.cs",
-        "storage.type.annotation.java",
-        "storage.type.generic.java",
-        "storage.type.java",
-        "storage.type.object.array.java",
-        "storage.type.primitive.array.java",
-        "storage.type.primitive.java",
-        "storage.type.token.java",
-        "storage.type.groovy",
-        "storage.type.annotation.groovy",
-        "storage.type.parameters.groovy",
-        "storage.type.generic.groovy",
-        "storage.type.object.array.groovy",
-        "storage.type.primitive.array.groovy",
-        "storage.type.primitive.groovy"
-      ],
-      "settings": {
-        "foreground": "#4EC9B0"
-      }
-    },
-    {
-      "name": "Types declaration and references, TS grammar specific",
-      "scope": [
-        "meta.type.cast.expr",
-        "meta.type.new.expr",
-        "support.constant.math",
-        "support.constant.dom",
-        "support.constant.json",
-        "entity.other.inherited-class"
-      ],
-      "settings": {
-        "foreground": "#4EC9B0"
-      }
-    },
-    {
-      "name": "Control flow / Special keywords",
-      "scope": [
-        "keyword.control",
-        "source.cpp keyword.operator.new",
-        "keyword.operator.delete",
-        "keyword.other.using",
-        "keyword.other.directive.using",
-        "keyword.other.operator",
-        "entity.name.operator"
-      ],
-      "settings": {
-        "foreground": "#C586C0"
-      }
-    },
-    {
-      "name": "Variable and parameter name",
-      "scope": [
-        "variable",
-        "meta.definition.variable.name",
-        "support.variable",
-        "entity.name.variable",
-        "constant.other.placeholder"
-      ],
-      "settings": {
-        "foreground": "#9CDCFE"
-      }
-    },
-    {
-      "name": "Constants and enums",
-      "scope": ["variable.other.constant", "variable.other.enummember"],
-      "settings": {
-        "foreground": "#4FC1FF"
-      }
-    },
-    {
-      "name": "Object keys, TS grammar specific",
-      "scope": ["meta.object-literal.key"],
-      "settings": {
-        "foreground": "#9CDCFE"
-      }
-    },
-    {
-      "name": "CSS property value",
-      "scope": [
-        "support.constant.property-value",
-        "support.constant.font-name",
-        "support.constant.media-type",
-        "support.constant.media",
-        "constant.other.color.rgb-value",
-        "constant.other.rgb-value",
-        "support.constant.color"
-      ],
-      "settings": {
-        "foreground": "#CE9178"
-      }
-    },
-    {
-      "name": "Regular expression groups",
-      "scope": [
-        "punctuation.definition.group.regexp",
-        "punctuation.definition.group.assertion.regexp",
-        "punctuation.definition.character-class.regexp",
-        "punctuation.character.set.begin.regexp",
-        "punctuation.character.set.end.regexp",
-        "keyword.operator.negation.regexp",
-        "support.other.parenthesis.regexp"
-      ],
-      "settings": {
-        "foreground": "#CE9178"
-      }
-    },
-    {
-      "scope": [
-        "constant.character.character-class.regexp",
-        "constant.other.character-class.set.regexp",
-        "constant.other.character-class.regexp",
-        "constant.character.set.regexp"
-      ],
-      "settings": {
-        "foreground": "#d16969"
-      }
-    },
-    {
-      "scope": ["keyword.operator.or.regexp", "keyword.control.anchor.regexp"],
-      "settings": {
-        "foreground": "#DCDCAA"
-      }
-    },
-    {
-      "scope": "keyword.operator.quantifier.regexp",
-      "settings": {
-        "foreground": "#d7ba7d"
-      }
-    },
-    {
-      "scope": ["constant.character", "constant.other.option"],
-      "settings": {
-        "foreground": "#569cd6"
-      }
-    },
-    {
-      "scope": "constant.character.escape",
-      "settings": {
-        "foreground": "#d7ba7d"
-      }
-    },
-    {
-      "scope": "entity.name.label",
-      "settings": {
-        "foreground": "#C8C8C8"
-      }
-    }
-  ],
-  "semanticTokenColors": {
-    "newOperator": "#C586C0",
-    "stringLiteral": "#ce9178",
-    "customLiteral": "#DCDCAA",
-    "numberLiteral": "#b5cea8"
-  }
+	"$schema": "vscode://schemas/color-theme",
+	"name": "Dark+",
+	"include": "./dark_vs.json",
+	"tokenColors": [
+		{
+			"name": "Function declarations",
+			"scope": [
+				"entity.name.function",
+				"support.function",
+				"support.constant.handlebars",
+				"source.powershell variable.other.member",
+				"entity.name.operator.custom-literal"
+			],
+			"settings": {
+				"foreground": "#DCDCAA"
+			}
+		},
+		{
+			"name": "Types declaration and references",
+			"scope": [
+				"support.class",
+				"support.type",
+				"entity.name.type",
+				"entity.name.namespace",
+				"entity.other.attribute",
+				"entity.name.scope-resolution",
+				"entity.name.class",
+				"storage.type.numeric.go",
+				"storage.type.byte.go",
+				"storage.type.boolean.go",
+				"storage.type.string.go",
+				"storage.type.uintptr.go",
+				"storage.type.error.go",
+				"storage.type.rune.go",
+				"storage.type.cs",
+				"storage.type.generic.cs",
+				"storage.type.modifier.cs",
+				"storage.type.variable.cs",
+				"storage.type.annotation.java",
+				"storage.type.generic.java",
+				"storage.type.java",
+				"storage.type.object.array.java",
+				"storage.type.primitive.array.java",
+				"storage.type.primitive.java",
+				"storage.type.token.java",
+				"storage.type.groovy",
+				"storage.type.annotation.groovy",
+				"storage.type.parameters.groovy",
+				"storage.type.generic.groovy",
+				"storage.type.object.array.groovy",
+				"storage.type.primitive.array.groovy",
+				"storage.type.primitive.groovy"
+			],
+			"settings": {
+				"foreground": "#4EC9B0"
+			}
+		},
+		{
+			"name": "Types declaration and references, TS grammar specific",
+			"scope": [
+				"meta.type.cast.expr",
+				"meta.type.new.expr",
+				"support.constant.math",
+				"support.constant.dom",
+				"support.constant.json",
+				"entity.other.inherited-class"
+			],
+			"settings": {
+				"foreground": "#4EC9B0"
+			}
+		},
+		{
+			"name": "Control flow / Special keywords",
+			"scope": [
+				"keyword.control",
+				"source.cpp keyword.operator.new",
+				"keyword.operator.delete",
+				"keyword.other.using",
+				"keyword.other.directive.using",
+				"keyword.other.operator",
+				"entity.name.operator"
+			],
+			"settings": {
+				"foreground": "#C586C0"
+			}
+		},
+		{
+			"name": "Variable and parameter name",
+			"scope": [
+				"variable",
+				"meta.definition.variable.name",
+				"support.variable",
+				"entity.name.variable",
+				"constant.other.placeholder"
+			],
+			"settings": {
+				"foreground": "#9CDCFE"
+			}
+		},
+		{
+			"name": "Constants and enums",
+			"scope": ["variable.other.constant", "variable.other.enummember"],
+			"settings": {
+				"foreground": "#4FC1FF"
+			}
+		},
+		{
+			"name": "Object keys, TS grammar specific",
+			"scope": ["meta.object-literal.key"],
+			"settings": {
+				"foreground": "#9CDCFE"
+			}
+		},
+		{
+			"name": "CSS property value",
+			"scope": [
+				"support.constant.property-value",
+				"support.constant.font-name",
+				"support.constant.media-type",
+				"support.constant.media",
+				"constant.other.color.rgb-value",
+				"constant.other.rgb-value",
+				"support.constant.color"
+			],
+			"settings": {
+				"foreground": "#CE9178"
+			}
+		},
+		{
+			"name": "Regular expression groups",
+			"scope": [
+				"punctuation.definition.group.regexp",
+				"punctuation.definition.group.assertion.regexp",
+				"punctuation.definition.character-class.regexp",
+				"punctuation.character.set.begin.regexp",
+				"punctuation.character.set.end.regexp",
+				"keyword.operator.negation.regexp",
+				"support.other.parenthesis.regexp"
+			],
+			"settings": {
+				"foreground": "#CE9178"
+			}
+		},
+		{
+			"scope": [
+				"constant.character.character-class.regexp",
+				"constant.other.character-class.set.regexp",
+				"constant.other.character-class.regexp",
+				"constant.character.set.regexp"
+			],
+			"settings": {
+				"foreground": "#d16969"
+			}
+		},
+		{
+			"scope": ["keyword.operator.or.regexp", "keyword.control.anchor.regexp"],
+			"settings": {
+				"foreground": "#DCDCAA"
+			}
+		},
+		{
+			"scope": "keyword.operator.quantifier.regexp",
+			"settings": {
+				"foreground": "#d7ba7d"
+			}
+		},
+		{
+			"scope": ["constant.character", "constant.other.option"],
+			"settings": {
+				"foreground": "#569cd6"
+			}
+		},
+		{
+			"scope": "constant.character.escape",
+			"settings": {
+				"foreground": "#d7ba7d"
+			}
+		},
+		{
+			"scope": "entity.name.label",
+			"settings": {
+				"foreground": "#C8C8C8"
+			}
+		}
+	],
+	"semanticTokenColors": {
+		"newOperator": "#C586C0",
+		"stringLiteral": "#ce9178",
+		"customLiteral": "#DCDCAA",
+		"numberLiteral": "#b5cea8"
+	}
 }

src/integrations/theme/default-themes/dark_vs.json

@@ -1,394 +1,391 @@
 {
-  "$schema": "vscode://schemas/color-theme",
-  "name": "Dark (Visual Studio)",
-  "colors": {
-    "checkbox.border": "#6B6B6B",
-    "editor.background": "#1E1E1E",
-    "editor.foreground": "#D4D4D4",
-    "editor.inactiveSelectionBackground": "#3A3D41",
-    "editorIndentGuide.background1": "#404040",
-    "editorIndentGuide.activeBackground1": "#707070",
-    "editor.selectionHighlightBackground": "#ADD6FF26",
-    "list.dropBackground": "#383B3D",
-    "activityBarBadge.background": "#007ACC",
-    "sideBarTitle.foreground": "#BBBBBB",
-    "input.placeholderForeground": "#A6A6A6",
-    "menu.background": "#252526",
-    "menu.foreground": "#CCCCCC",
-    "menu.separatorBackground": "#454545",
-    "menu.border": "#454545",
-    "statusBarItem.remoteForeground": "#FFF",
-    "statusBarItem.remoteBackground": "#16825D",
-    "ports.iconRunningProcessForeground": "#369432",
-    "sideBarSectionHeader.background": "#0000",
-    "sideBarSectionHeader.border": "#ccc3",
-    "tab.lastPinnedBorder": "#ccc3",
-    "list.activeSelectionIconForeground": "#FFF",
-    "terminal.inactiveSelectionBackground": "#3A3D41",
-    "widget.border": "#303031",
-    "actionBar.toggledBackground": "#383a49"
-  },
-  "tokenColors": [
-    {
-      "scope": [
-        "meta.embedded",
-        "source.groovy.embedded",
-        "string meta.image.inline.markdown",
-        "variable.legacy.builtin.python"
-      ],
-      "settings": {
-        "foreground": "#D4D4D4"
-      }
-    },
-    {
-      "scope": "emphasis",
-      "settings": {
-        "fontStyle": "italic"
-      }
-    },
-    {
-      "scope": "strong",
-      "settings": {
-        "fontStyle": "bold"
-      }
-    },
-    {
-      "scope": "header",
-      "settings": {
-        "foreground": "#000080"
-      }
-    },
-    {
-      "scope": "comment",
-      "settings": {
-        "foreground": "#6A9955"
-      }
-    },
-    {
-      "scope": "constant.language",
-      "settings": {
-        "foreground": "#569cd6"
-      }
-    },
-    {
-      "scope": [
-        "constant.numeric",
-        "variable.other.enummember",
-        "keyword.operator.plus.exponent",
-        "keyword.operator.minus.exponent"
-      ],
-      "settings": {
-        "foreground": "#b5cea8"
-      }
-    },
-    {
-      "scope": "constant.regexp",
-      "settings": {
-        "foreground": "#646695"
-      }
-    },
-    {
-      "scope": "entity.name.tag",
-      "settings": {
-        "foreground": "#569cd6"
-      }
-    },
-    {
-      "scope": ["entity.name.tag.css", "entity.name.tag.less"],
-      "settings": {
-        "foreground": "#d7ba7d"
-      }
-    },
-    {
-      "scope": "entity.other.attribute-name",
-      "settings": {
-        "foreground": "#9cdcfe"
-      }
-    },
-    {
-      "scope": [
-        "entity.other.attribute-name.class.css",
-        "source.css entity.other.attribute-name.class",
-        "entity.other.attribute-name.id.css",
-        "entity.other.attribute-name.parent-selector.css",
-        "entity.other.attribute-name.parent.less",
-        "source.css entity.other.attribute-name.pseudo-class",
-        "entity.other.attribute-name.pseudo-element.css",
-        "source.css.less entity.other.attribute-name.id",
-        "entity.other.attribute-name.scss"
-      ],
-      "settings": {
-        "foreground": "#d7ba7d"
-      }
-    },
-    {
-      "scope": "invalid",
-      "settings": {
-        "foreground": "#f44747"
-      }
-    },
-    {
-      "scope": "markup.underline",
-      "settings": {
-        "fontStyle": "underline"
-      }
-    },
-    {
-      "scope": "markup.bold",
-      "settings": {
-        "fontStyle": "bold",
-        "foreground": "#569cd6"
-      }
-    },
-    {
-      "scope": "markup.heading",
-      "settings": {
-        "fontStyle": "bold",
-        "foreground": "#569cd6"
-      }
-    },
-    {
-      "scope": "markup.italic",
-      "settings": {
-        "fontStyle": "italic"
-      }
-    },
-    {
-      "scope": "markup.strikethrough",
-      "settings": {
-        "fontStyle": "strikethrough"
-      }
-    },
-    {
-      "scope": "markup.inserted",
-      "settings": {
-        "foreground": "#b5cea8"
-      }
-    },
-    {
-      "scope": "markup.deleted",
-      "settings": {
-        "foreground": "#ce9178"
-      }
-    },
-    {
-      "scope": "markup.changed",
-      "settings": {
-        "foreground": "#569cd6"
-      }
-    },
-    {
-      "scope": "punctuation.definition.quote.begin.markdown",
-      "settings": {
-        "foreground": "#6A9955"
-      }
-    },
-    {
-      "scope": "punctuation.definition.list.begin.markdown",
-      "settings": {
-        "foreground": "#6796e6"
-      }
-    },
-    {
-      "scope": "markup.inline.raw",
-      "settings": {
-        "foreground": "#ce9178"
-      }
-    },
-    {
-      "name": "brackets of XML/HTML tags",
-      "scope": "punctuation.definition.tag",
-      "settings": {
-        "foreground": "#808080"
-      }
-    },
-    {
-      "scope": ["meta.preprocessor", "entity.name.function.preprocessor"],
-      "settings": {
-        "foreground": "#569cd6"
-      }
-    },
-    {
-      "scope": "meta.preprocessor.string",
-      "settings": {
-        "foreground": "#ce9178"
-      }
-    },
-    {
-      "scope": "meta.preprocessor.numeric",
-      "settings": {
-        "foreground": "#b5cea8"
-      }
-    },
-    {
-      "scope": "meta.structure.dictionary.key.python",
-      "settings": {
-        "foreground": "#9cdcfe"
-      }
-    },
-    {
-      "scope": "meta.diff.header",
-      "settings": {
-        "foreground": "#569cd6"
-      }
-    },
-    {
-      "scope": "storage",
-      "settings": {
-        "foreground": "#569cd6"
-      }
-    },
-    {
-      "scope": "storage.type",
-      "settings": {
-        "foreground": "#569cd6"
-      }
-    },
-    {
-      "scope": ["storage.modifier", "keyword.operator.noexcept"],
-      "settings": {
-        "foreground": "#569cd6"
-      }
-    },
-    {
-      "scope": ["string", "meta.embedded.assembly"],
-      "settings": {
-        "foreground": "#ce9178"
-      }
-    },
-    {
-      "scope": "string.tag",
-      "settings": {
-        "foreground": "#ce9178"
-      }
-    },
-    {
-      "scope": "string.value",
-      "settings": {
-        "foreground": "#ce9178"
-      }
-    },
-    {
-      "scope": "string.regexp",
-      "settings": {
-        "foreground": "#d16969"
-      }
-    },
-    {
-      "name": "String interpolation",
-      "scope": [
-        "punctuation.definition.template-expression.begin",
-        "punctuation.definition.template-expression.end",
-        "punctuation.section.embedded"
-      ],
-      "settings": {
-        "foreground": "#569cd6"
-      }
-    },
-    {
-      "name": "Reset JavaScript string interpolation expression",
-      "scope": ["meta.template.expression"],
-      "settings": {
-        "foreground": "#d4d4d4"
-      }
-    },
-    {
-      "scope": [
-        "support.type.vendored.property-name",
-        "support.type.property-name",
-        "source.css variable",
-        "source.coffee.embedded"
-      ],
-      "settings": {
-        "foreground": "#9cdcfe"
-      }
-    },
-    {
-      "scope": "keyword",
-      "settings": {
-        "foreground": "#569cd6"
-      }
-    },
-    {
-      "scope": "keyword.control",
-      "settings": {
-        "foreground": "#569cd6"
-      }
-    },
-    {
-      "scope": "keyword.operator",
-      "settings": {
-        "foreground": "#d4d4d4"
-      }
-    },
-    {
-      "scope": [
-        "keyword.operator.new",
-        "keyword.operator.expression",
-        "keyword.operator.cast",
-        "keyword.operator.sizeof",
-        "keyword.operator.alignof",
-        "keyword.operator.typeid",
-        "keyword.operator.alignas",
-        "keyword.operator.instanceof",
-        "keyword.operator.logical.python",
-        "keyword.operator.wordlike"
-      ],
-      "settings": {
-        "foreground": "#569cd6"
-      }
-    },
-    {
-      "scope": "keyword.other.unit",
-      "settings": {
-        "foreground": "#b5cea8"
-      }
-    },
-    {
-      "scope": [
-        "punctuation.section.embedded.begin.php",
-        "punctuation.section.embedded.end.php"
-      ],
-      "settings": {
-        "foreground": "#569cd6"
-      }
-    },
-    {
-      "scope": "support.function.git-rebase",
-      "settings": {
-        "foreground": "#9cdcfe"
-      }
-    },
-    {
-      "scope": "constant.sha.git-rebase",
-      "settings": {
-        "foreground": "#b5cea8"
-      }
-    },
-    {
-      "name": "coloring of the Java import and package identifiers",
-      "scope": [
-        "storage.modifier.import.java",
-        "variable.language.wildcard.java",
-        "storage.modifier.package.java"
-      ],
-      "settings": {
-        "foreground": "#d4d4d4"
-      }
-    },
-    {
-      "name": "this.self",
-      "scope": "variable.language",
-      "settings": {
-        "foreground": "#569cd6"
-      }
-    }
-  ],
-  "semanticHighlighting": true,
-  "semanticTokenColors": {
-    "newOperator": "#d4d4d4",
-    "stringLiteral": "#ce9178",
-    "customLiteral": "#D4D4D4",
-    "numberLiteral": "#b5cea8"
-  }
+	"$schema": "vscode://schemas/color-theme",
+	"name": "Dark (Visual Studio)",
+	"colors": {
+		"checkbox.border": "#6B6B6B",
+		"editor.background": "#1E1E1E",
+		"editor.foreground": "#D4D4D4",
+		"editor.inactiveSelectionBackground": "#3A3D41",
+		"editorIndentGuide.background1": "#404040",
+		"editorIndentGuide.activeBackground1": "#707070",
+		"editor.selectionHighlightBackground": "#ADD6FF26",
+		"list.dropBackground": "#383B3D",
+		"activityBarBadge.background": "#007ACC",
+		"sideBarTitle.foreground": "#BBBBBB",
+		"input.placeholderForeground": "#A6A6A6",
+		"menu.background": "#252526",
+		"menu.foreground": "#CCCCCC",
+		"menu.separatorBackground": "#454545",
+		"menu.border": "#454545",
+		"statusBarItem.remoteForeground": "#FFF",
+		"statusBarItem.remoteBackground": "#16825D",
+		"ports.iconRunningProcessForeground": "#369432",
+		"sideBarSectionHeader.background": "#0000",
+		"sideBarSectionHeader.border": "#ccc3",
+		"tab.lastPinnedBorder": "#ccc3",
+		"list.activeSelectionIconForeground": "#FFF",
+		"terminal.inactiveSelectionBackground": "#3A3D41",
+		"widget.border": "#303031",
+		"actionBar.toggledBackground": "#383a49"
+	},
+	"tokenColors": [
+		{
+			"scope": [
+				"meta.embedded",
+				"source.groovy.embedded",
+				"string meta.image.inline.markdown",
+				"variable.legacy.builtin.python"
+			],
+			"settings": {
+				"foreground": "#D4D4D4"
+			}
+		},
+		{
+			"scope": "emphasis",
+			"settings": {
+				"fontStyle": "italic"
+			}
+		},
+		{
+			"scope": "strong",
+			"settings": {
+				"fontStyle": "bold"
+			}
+		},
+		{
+			"scope": "header",
+			"settings": {
+				"foreground": "#000080"
+			}
+		},
+		{
+			"scope": "comment",
+			"settings": {
+				"foreground": "#6A9955"
+			}
+		},
+		{
+			"scope": "constant.language",
+			"settings": {
+				"foreground": "#569cd6"
+			}
+		},
+		{
+			"scope": [
+				"constant.numeric",
+				"variable.other.enummember",
+				"keyword.operator.plus.exponent",
+				"keyword.operator.minus.exponent"
+			],
+			"settings": {
+				"foreground": "#b5cea8"
+			}
+		},
+		{
+			"scope": "constant.regexp",
+			"settings": {
+				"foreground": "#646695"
+			}
+		},
+		{
+			"scope": "entity.name.tag",
+			"settings": {
+				"foreground": "#569cd6"
+			}
+		},
+		{
+			"scope": ["entity.name.tag.css", "entity.name.tag.less"],
+			"settings": {
+				"foreground": "#d7ba7d"
+			}
+		},
+		{
+			"scope": "entity.other.attribute-name",
+			"settings": {
+				"foreground": "#9cdcfe"
+			}
+		},
+		{
+			"scope": [
+				"entity.other.attribute-name.class.css",
+				"source.css entity.other.attribute-name.class",
+				"entity.other.attribute-name.id.css",
+				"entity.other.attribute-name.parent-selector.css",
+				"entity.other.attribute-name.parent.less",
+				"source.css entity.other.attribute-name.pseudo-class",
+				"entity.other.attribute-name.pseudo-element.css",
+				"source.css.less entity.other.attribute-name.id",
+				"entity.other.attribute-name.scss"
+			],
+			"settings": {
+				"foreground": "#d7ba7d"
+			}
+		},
+		{
+			"scope": "invalid",
+			"settings": {
+				"foreground": "#f44747"
+			}
+		},
+		{
+			"scope": "markup.underline",
+			"settings": {
+				"fontStyle": "underline"
+			}
+		},
+		{
+			"scope": "markup.bold",
+			"settings": {
+				"fontStyle": "bold",
+				"foreground": "#569cd6"
+			}
+		},
+		{
+			"scope": "markup.heading",
+			"settings": {
+				"fontStyle": "bold",
+				"foreground": "#569cd6"
+			}
+		},
+		{
+			"scope": "markup.italic",
+			"settings": {
+				"fontStyle": "italic"
+			}
+		},
+		{
+			"scope": "markup.strikethrough",
+			"settings": {
+				"fontStyle": "strikethrough"
+			}
+		},
+		{
+			"scope": "markup.inserted",
+			"settings": {
+				"foreground": "#b5cea8"
+			}
+		},
+		{
+			"scope": "markup.deleted",
+			"settings": {
+				"foreground": "#ce9178"
+			}
+		},
+		{
+			"scope": "markup.changed",
+			"settings": {
+				"foreground": "#569cd6"
+			}
+		},
+		{
+			"scope": "punctuation.definition.quote.begin.markdown",
+			"settings": {
+				"foreground": "#6A9955"
+			}
+		},
+		{
+			"scope": "punctuation.definition.list.begin.markdown",
+			"settings": {
+				"foreground": "#6796e6"
+			}
+		},
+		{
+			"scope": "markup.inline.raw",
+			"settings": {
+				"foreground": "#ce9178"
+			}
+		},
+		{
+			"name": "brackets of XML/HTML tags",
+			"scope": "punctuation.definition.tag",
+			"settings": {
+				"foreground": "#808080"
+			}
+		},
+		{
+			"scope": ["meta.preprocessor", "entity.name.function.preprocessor"],
+			"settings": {
+				"foreground": "#569cd6"
+			}
+		},
+		{
+			"scope": "meta.preprocessor.string",
+			"settings": {
+				"foreground": "#ce9178"
+			}
+		},
+		{
+			"scope": "meta.preprocessor.numeric",
+			"settings": {
+				"foreground": "#b5cea8"
+			}
+		},
+		{
+			"scope": "meta.structure.dictionary.key.python",
+			"settings": {
+				"foreground": "#9cdcfe"
+			}
+		},
+		{
+			"scope": "meta.diff.header",
+			"settings": {
+				"foreground": "#569cd6"
+			}
+		},
+		{
+			"scope": "storage",
+			"settings": {
+				"foreground": "#569cd6"
+			}
+		},
+		{
+			"scope": "storage.type",
+			"settings": {
+				"foreground": "#569cd6"
+			}
+		},
+		{
+			"scope": ["storage.modifier", "keyword.operator.noexcept"],
+			"settings": {
+				"foreground": "#569cd6"
+			}
+		},
+		{
+			"scope": ["string", "meta.embedded.assembly"],
+			"settings": {
+				"foreground": "#ce9178"
+			}
+		},
+		{
+			"scope": "string.tag",
+			"settings": {
+				"foreground": "#ce9178"
+			}
+		},
+		{
+			"scope": "string.value",
+			"settings": {
+				"foreground": "#ce9178"
+			}
+		},
+		{
+			"scope": "string.regexp",
+			"settings": {
+				"foreground": "#d16969"
+			}
+		},
+		{
+			"name": "String interpolation",
+			"scope": [
+				"punctuation.definition.template-expression.begin",
+				"punctuation.definition.template-expression.end",
+				"punctuation.section.embedded"
+			],
+			"settings": {
+				"foreground": "#569cd6"
+			}
+		},
+		{
+			"name": "Reset JavaScript string interpolation expression",
+			"scope": ["meta.template.expression"],
+			"settings": {
+				"foreground": "#d4d4d4"
+			}
+		},
+		{
+			"scope": [
+				"support.type.vendored.property-name",
+				"support.type.property-name",
+				"source.css variable",
+				"source.coffee.embedded"
+			],
+			"settings": {
+				"foreground": "#9cdcfe"
+			}
+		},
+		{
+			"scope": "keyword",
+			"settings": {
+				"foreground": "#569cd6"
+			}
+		},
+		{
+			"scope": "keyword.control",
+			"settings": {
+				"foreground": "#569cd6"
+			}
+		},
+		{
+			"scope": "keyword.operator",
+			"settings": {
+				"foreground": "#d4d4d4"
+			}
+		},
+		{
+			"scope": [
+				"keyword.operator.new",
+				"keyword.operator.expression",
+				"keyword.operator.cast",
+				"keyword.operator.sizeof",
+				"keyword.operator.alignof",
+				"keyword.operator.typeid",
+				"keyword.operator.alignas",
+				"keyword.operator.instanceof",
+				"keyword.operator.logical.python",
+				"keyword.operator.wordlike"
+			],
+			"settings": {
+				"foreground": "#569cd6"
+			}
+		},
+		{
+			"scope": "keyword.other.unit",
+			"settings": {
+				"foreground": "#b5cea8"
+			}
+		},
+		{
+			"scope": ["punctuation.section.embedded.begin.php", "punctuation.section.embedded.end.php"],
+			"settings": {
+				"foreground": "#569cd6"
+			}
+		},
+		{
+			"scope": "support.function.git-rebase",
+			"settings": {
+				"foreground": "#9cdcfe"
+			}
+		},
+		{
+			"scope": "constant.sha.git-rebase",
+			"settings": {
+				"foreground": "#b5cea8"
+			}
+		},
+		{
+			"name": "coloring of the Java import and package identifiers",
+			"scope": [
+				"storage.modifier.import.java",
+				"variable.language.wildcard.java",
+				"storage.modifier.package.java"
+			],
+			"settings": {
+				"foreground": "#d4d4d4"
+			}
+		},
+		{
+			"name": "this.self",
+			"scope": "variable.language",
+			"settings": {
+				"foreground": "#569cd6"
+			}
+		}
+	],
+	"semanticHighlighting": true,
+	"semanticTokenColors": {
+		"newOperator": "#d4d4d4",
+		"stringLiteral": "#ce9178",
+		"customLiteral": "#D4D4D4",
+		"numberLiteral": "#b5cea8"
+	}
 }

src/integrations/theme/default-themes/hc_black.json

@@ -86,10 +86,7 @@
 			}
 		},
 		{
-			"scope": [
-				"entity.name.tag.css",
-				"entity.name.tag.less"
-			],
+			"scope": ["entity.name.tag.css", "entity.name.tag.less"],
 			"settings": {
 				"foreground": "#d7ba7d"
 			}
@@ -173,9 +170,7 @@
 		},
 		{
 			"name": "brackets of XML/HTML tags",
-			"scope": [
-				"punctuation.definition.tag"
-			],
+			"scope": ["punctuation.definition.tag"],
 			"settings": {
 				"foreground": "#808080"
 			}
@@ -259,9 +254,7 @@
 		},
 		{
 			"name": "Reset JavaScript string interpolation expression",
-			"scope": [
-				"meta.template.expression"
-			],
+			"scope": ["meta.template.expression"],
 			"settings": {
 				"foreground": "#ffffff"
 			}
@@ -417,20 +410,14 @@
 		},
 		{
 			"name": "Variable and parameter name",
-			"scope": [
-				"variable",
-				"meta.definition.variable.name",
-				"support.variable"
-			],
+			"scope": ["variable", "meta.definition.variable.name", "support.variable"],
 			"settings": {
 				"foreground": "#9CDCFE"
 			}
 		},
 		{
 			"name": "Object keys, TS grammar specific",
-			"scope": [
-				"meta.object-literal.key"
-			],
+			"scope": ["meta.object-literal.key"],
 			"settings": {
 				"foreground": "#9CDCFE"
 			}

src/integrations/theme/default-themes/hc_light.json

@@ -3,11 +3,7 @@
 	"name": "Light High Contrast",
 	"tokenColors": [
 		{
-			"scope": [
-				"meta.embedded",
-				"source.groovy.embedded",
-				"variable.legacy.builtin.python"
-			],
+			"scope": ["meta.embedded", "source.groovy.embedded", "variable.legacy.builtin.python"],
 			"settings": {
 				"foreground": "#292929"
 			}
@@ -150,10 +146,7 @@
 			}
 		},
 		{
-			"scope": [
-				"punctuation.definition.quote.begin.markdown",
-				"punctuation.definition.list.begin.markdown"
-			],
+			"scope": ["punctuation.definition.quote.begin.markdown", "punctuation.definition.list.begin.markdown"],
 			"settings": {
 				"foreground": "#0451A5"
 			}
@@ -335,10 +328,7 @@
 			}
 		},
 		{
-			"scope": [
-				"punctuation.section.embedded.begin.php",
-				"punctuation.section.embedded.end.php"
-			],
+			"scope": ["punctuation.section.embedded.begin.php", "punctuation.section.embedded.end.php"],
 			"settings": {
 				"foreground": "#0F4A85"
 			}

src/integrations/theme/default-themes/light_modern.json

@@ -1,145 +1,145 @@
 {
-  "$schema": "vscode://schemas/color-theme",
-  "name": "Default Light Modern",
-  "include": "./light_plus.json",
-  "colors": {
-    "activityBar.activeBorder": "#005FB8",
-    "activityBar.background": "#F8F8F8",
-    "activityBar.border": "#E5E5E5",
-    "activityBar.foreground": "#1F1F1F",
-    "activityBar.inactiveForeground": "#616161",
-    "activityBarBadge.background": "#005FB8",
-    "activityBarBadge.foreground": "#FFFFFF",
-    "badge.background": "#CCCCCC",
-    "badge.foreground": "#3B3B3B",
-    "button.background": "#005FB8",
-    "button.border": "#0000001a",
-    "button.foreground": "#FFFFFF",
-    "button.hoverBackground": "#0258A8",
-    "button.secondaryBackground": "#E5E5E5",
-    "button.secondaryForeground": "#3B3B3B",
-    "button.secondaryHoverBackground": "#CCCCCC",
-    "chat.slashCommandBackground": "#D2ECFF",
-    "chat.slashCommandForeground": "#306CA2",
-    "checkbox.background": "#F8F8F8",
-    "checkbox.border": "#CECECE",
-    "descriptionForeground": "#3B3B3B",
-    "dropdown.background": "#FFFFFF",
-    "dropdown.border": "#CECECE",
-    "dropdown.foreground": "#3B3B3B",
-    "dropdown.listBackground": "#FFFFFF",
-    "editor.background": "#FFFFFF",
-    "editor.foreground": "#3B3B3B",
-    "editor.inactiveSelectionBackground": "#E5EBF1",
-    "editor.selectionHighlightBackground": "#ADD6FF80",
-    "editorGroup.border": "#E5E5E5",
-    "editorGroupHeader.tabsBackground": "#F8F8F8",
-    "editorGroupHeader.tabsBorder": "#E5E5E5",
-    "editorGutter.addedBackground": "#2EA043",
-    "editorGutter.deletedBackground": "#F85149",
-    "editorGutter.modifiedBackground": "#005FB8",
-    "editorIndentGuide.background1": "#D3D3D3",
-    "editorLineNumber.activeForeground": "#171184",
-    "editorLineNumber.foreground": "#6E7681",
-    "editorOverviewRuler.border": "#E5E5E5",
-    "editorSuggestWidget.background": "#F8F8F8",
-    "editorWidget.background": "#F8F8F8",
-    "errorForeground": "#F85149",
-    "focusBorder": "#005FB8",
-    "foreground": "#3B3B3B",
-    "icon.foreground": "#3B3B3B",
-    "input.background": "#FFFFFF",
-    "input.border": "#CECECE",
-    "input.foreground": "#3B3B3B",
-    "input.placeholderForeground": "#767676",
-    "inputOption.activeBackground": "#BED6ED",
-    "inputOption.activeBorder": "#005FB8",
-    "inputOption.activeForeground": "#000000",
-    "keybindingLabel.foreground": "#3B3B3B",
-    "list.activeSelectionBackground": "#E8E8E8",
-    "list.activeSelectionForeground": "#000000",
-    "list.activeSelectionIconForeground": "#000000",
-    "list.hoverBackground": "#F2F2F2",
-    "list.focusAndSelectionOutline": "#005FB8",
-    "menu.border": "#CECECE",
-    "notebook.cellBorderColor": "#E5E5E5",
-    "notebook.selectedCellBackground": "#C8DDF150",
-    "notificationCenterHeader.background": "#FFFFFF",
-    "notificationCenterHeader.foreground": "#3B3B3B",
-    "notifications.background": "#FFFFFF",
-    "notifications.border": "#E5E5E5",
-    "notifications.foreground": "#3B3B3B",
-    "panel.background": "#F8F8F8",
-    "panel.border": "#E5E5E5",
-    "panelInput.border": "#E5E5E5",
-    "panelTitle.activeBorder": "#005FB8",
-    "panelTitle.activeForeground": "#3B3B3B",
-    "panelTitle.inactiveForeground": "#3B3B3B",
-    "peekViewEditor.matchHighlightBackground": "#BB800966",
-    "peekViewResult.background": "#FFFFFF",
-    "peekViewResult.matchHighlightBackground": "#BB800966",
-    "pickerGroup.border": "#E5E5E5",
-    "pickerGroup.foreground": "#8B949E",
-    "ports.iconRunningProcessForeground": "#369432",
-    "progressBar.background": "#005FB8",
-    "quickInput.background": "#F8F8F8",
-    "quickInput.foreground": "#3B3B3B",
-    "searchEditor.textInputBorder": "#CECECE",
-    "settings.dropdownBackground": "#FFFFFF",
-    "settings.dropdownBorder": "#CECECE",
-    "settings.headerForeground": "#1F1F1F",
-    "settings.modifiedItemIndicator": "#BB800966",
-    "settings.numberInputBorder": "#CECECE",
-    "settings.textInputBorder": "#CECECE",
-    "sideBar.background": "#F8F8F8",
-    "sideBar.border": "#E5E5E5",
-    "sideBar.foreground": "#3B3B3B",
-    "sideBarSectionHeader.background": "#F8F8F8",
-    "sideBarSectionHeader.border": "#E5E5E5",
-    "sideBarSectionHeader.foreground": "#3B3B3B",
-    "sideBarTitle.foreground": "#3B3B3B",
-    "statusBar.background": "#F8F8F8",
-    "statusBar.foreground": "#3B3B3B",
-    "statusBar.border": "#E5E5E5",
-    "statusBar.debuggingBackground": "#FD716C",
-    "statusBar.debuggingForeground": "#000000",
-    "statusBar.focusBorder": "#005FB8",
-    "statusBar.noFolderBackground": "#F8F8F8",
-    "statusBarItem.errorBackground": "#C72E0F",
-    "statusBarItem.focusBorder": "#005FB8",
-    "statusBarItem.prominentBackground": "#6E768166",
-    "statusBarItem.remoteBackground": "#005FB8",
-    "statusBarItem.remoteForeground": "#FFFFFF",
-    "tab.activeBackground": "#FFFFFF",
-    "tab.activeBorder": "#F8F8F8",
-    "tab.activeBorderTop": "#005FB8",
-    "tab.activeForeground": "#3B3B3B",
-    "tab.border": "#E5E5E5",
-    "tab.hoverBackground": "#FFFFFF",
-    "tab.inactiveBackground": "#F8F8F8",
-    "tab.inactiveForeground": "#868686",
-    "tab.lastPinnedBorder": "#D4D4D4",
-    "tab.unfocusedActiveBorder": "#F8F8F8",
-    "tab.unfocusedActiveBorderTop": "#E5E5E5",
-    "tab.unfocusedHoverBackground": "#F8F8F8",
-    "terminalCursor.foreground": "#005FB8",
-    "terminal.foreground": "#3B3B3B",
-    "terminal.inactiveSelectionBackground": "#E5EBF1",
-    "terminal.tab.activeBorder": "#005FB8",
-    "textBlockQuote.background": "#F8F8F8",
-    "textBlockQuote.border": "#E5E5E5",
-    "textCodeBlock.background": "#F8F8F8",
-    "textLink.activeForeground": "#005FB8",
-    "textLink.foreground": "#005FB8",
-    "textPreformat.foreground": "#3B3B3B",
-    "textPreformat.background": "#0000001F",
-    "textSeparator.foreground": "#21262D",
-    "titleBar.activeBackground": "#F8F8F8",
-    "titleBar.activeForeground": "#1E1E1E",
-    "titleBar.border": "#E5E5E5",
-    "titleBar.inactiveBackground": "#F8F8F8",
-    "titleBar.inactiveForeground": "#8B949E",
-    "welcomePage.tileBackground": "#F3F3F3",
-    "widget.border": "#E5E5E5"
-  }
+	"$schema": "vscode://schemas/color-theme",
+	"name": "Default Light Modern",
+	"include": "./light_plus.json",
+	"colors": {
+		"activityBar.activeBorder": "#005FB8",
+		"activityBar.background": "#F8F8F8",
+		"activityBar.border": "#E5E5E5",
+		"activityBar.foreground": "#1F1F1F",
+		"activityBar.inactiveForeground": "#616161",
+		"activityBarBadge.background": "#005FB8",
+		"activityBarBadge.foreground": "#FFFFFF",
+		"badge.background": "#CCCCCC",
+		"badge.foreground": "#3B3B3B",
+		"button.background": "#005FB8",
+		"button.border": "#0000001a",
+		"button.foreground": "#FFFFFF",
+		"button.hoverBackground": "#0258A8",
+		"button.secondaryBackground": "#E5E5E5",
+		"button.secondaryForeground": "#3B3B3B",
+		"button.secondaryHoverBackground": "#CCCCCC",
+		"chat.slashCommandBackground": "#D2ECFF",
+		"chat.slashCommandForeground": "#306CA2",
+		"checkbox.background": "#F8F8F8",
+		"checkbox.border": "#CECECE",
+		"descriptionForeground": "#3B3B3B",
+		"dropdown.background": "#FFFFFF",
+		"dropdown.border": "#CECECE",
+		"dropdown.foreground": "#3B3B3B",
+		"dropdown.listBackground": "#FFFFFF",
+		"editor.background": "#FFFFFF",
+		"editor.foreground": "#3B3B3B",
+		"editor.inactiveSelectionBackground": "#E5EBF1",
+		"editor.selectionHighlightBackground": "#ADD6FF80",
+		"editorGroup.border": "#E5E5E5",
+		"editorGroupHeader.tabsBackground": "#F8F8F8",
+		"editorGroupHeader.tabsBorder": "#E5E5E5",
+		"editorGutter.addedBackground": "#2EA043",
+		"editorGutter.deletedBackground": "#F85149",
+		"editorGutter.modifiedBackground": "#005FB8",
+		"editorIndentGuide.background1": "#D3D3D3",
+		"editorLineNumber.activeForeground": "#171184",
+		"editorLineNumber.foreground": "#6E7681",
+		"editorOverviewRuler.border": "#E5E5E5",
+		"editorSuggestWidget.background": "#F8F8F8",
+		"editorWidget.background": "#F8F8F8",
+		"errorForeground": "#F85149",
+		"focusBorder": "#005FB8",
+		"foreground": "#3B3B3B",
+		"icon.foreground": "#3B3B3B",
+		"input.background": "#FFFFFF",
+		"input.border": "#CECECE",
+		"input.foreground": "#3B3B3B",
+		"input.placeholderForeground": "#767676",
+		"inputOption.activeBackground": "#BED6ED",
+		"inputOption.activeBorder": "#005FB8",
+		"inputOption.activeForeground": "#000000",
+		"keybindingLabel.foreground": "#3B3B3B",
+		"list.activeSelectionBackground": "#E8E8E8",
+		"list.activeSelectionForeground": "#000000",
+		"list.activeSelectionIconForeground": "#000000",
+		"list.hoverBackground": "#F2F2F2",
+		"list.focusAndSelectionOutline": "#005FB8",
+		"menu.border": "#CECECE",
+		"notebook.cellBorderColor": "#E5E5E5",
+		"notebook.selectedCellBackground": "#C8DDF150",
+		"notificationCenterHeader.background": "#FFFFFF",
+		"notificationCenterHeader.foreground": "#3B3B3B",
+		"notifications.background": "#FFFFFF",
+		"notifications.border": "#E5E5E5",
+		"notifications.foreground": "#3B3B3B",
+		"panel.background": "#F8F8F8",
+		"panel.border": "#E5E5E5",
+		"panelInput.border": "#E5E5E5",
+		"panelTitle.activeBorder": "#005FB8",
+		"panelTitle.activeForeground": "#3B3B3B",
+		"panelTitle.inactiveForeground": "#3B3B3B",
+		"peekViewEditor.matchHighlightBackground": "#BB800966",
+		"peekViewResult.background": "#FFFFFF",
+		"peekViewResult.matchHighlightBackground": "#BB800966",
+		"pickerGroup.border": "#E5E5E5",
+		"pickerGroup.foreground": "#8B949E",
+		"ports.iconRunningProcessForeground": "#369432",
+		"progressBar.background": "#005FB8",
+		"quickInput.background": "#F8F8F8",
+		"quickInput.foreground": "#3B3B3B",
+		"searchEditor.textInputBorder": "#CECECE",
+		"settings.dropdownBackground": "#FFFFFF",
+		"settings.dropdownBorder": "#CECECE",
+		"settings.headerForeground": "#1F1F1F",
+		"settings.modifiedItemIndicator": "#BB800966",
+		"settings.numberInputBorder": "#CECECE",
+		"settings.textInputBorder": "#CECECE",
+		"sideBar.background": "#F8F8F8",
+		"sideBar.border": "#E5E5E5",
+		"sideBar.foreground": "#3B3B3B",
+		"sideBarSectionHeader.background": "#F8F8F8",
+		"sideBarSectionHeader.border": "#E5E5E5",
+		"sideBarSectionHeader.foreground": "#3B3B3B",
+		"sideBarTitle.foreground": "#3B3B3B",
+		"statusBar.background": "#F8F8F8",
+		"statusBar.foreground": "#3B3B3B",
+		"statusBar.border": "#E5E5E5",
+		"statusBar.debuggingBackground": "#FD716C",
+		"statusBar.debuggingForeground": "#000000",
+		"statusBar.focusBorder": "#005FB8",
+		"statusBar.noFolderBackground": "#F8F8F8",
+		"statusBarItem.errorBackground": "#C72E0F",
+		"statusBarItem.focusBorder": "#005FB8",
+		"statusBarItem.prominentBackground": "#6E768166",
+		"statusBarItem.remoteBackground": "#005FB8",
+		"statusBarItem.remoteForeground": "#FFFFFF",
+		"tab.activeBackground": "#FFFFFF",
+		"tab.activeBorder": "#F8F8F8",
+		"tab.activeBorderTop": "#005FB8",
+		"tab.activeForeground": "#3B3B3B",
+		"tab.border": "#E5E5E5",
+		"tab.hoverBackground": "#FFFFFF",
+		"tab.inactiveBackground": "#F8F8F8",
+		"tab.inactiveForeground": "#868686",
+		"tab.lastPinnedBorder": "#D4D4D4",
+		"tab.unfocusedActiveBorder": "#F8F8F8",
+		"tab.unfocusedActiveBorderTop": "#E5E5E5",
+		"tab.unfocusedHoverBackground": "#F8F8F8",
+		"terminalCursor.foreground": "#005FB8",
+		"terminal.foreground": "#3B3B3B",
+		"terminal.inactiveSelectionBackground": "#E5EBF1",
+		"terminal.tab.activeBorder": "#005FB8",
+		"textBlockQuote.background": "#F8F8F8",
+		"textBlockQuote.border": "#E5E5E5",
+		"textCodeBlock.background": "#F8F8F8",
+		"textLink.activeForeground": "#005FB8",
+		"textLink.foreground": "#005FB8",
+		"textPreformat.foreground": "#3B3B3B",
+		"textPreformat.background": "#0000001F",
+		"textSeparator.foreground": "#21262D",
+		"titleBar.activeBackground": "#F8F8F8",
+		"titleBar.activeForeground": "#1E1E1E",
+		"titleBar.border": "#E5E5E5",
+		"titleBar.inactiveBackground": "#F8F8F8",
+		"titleBar.inactiveForeground": "#8B949E",
+		"welcomePage.tileBackground": "#F3F3F3",
+		"widget.border": "#E5E5E5"
+	}
 }

src/integrations/theme/default-themes/light_plus.json

@@ -1,194 +1,194 @@
 {
-  "$schema": "vscode://schemas/color-theme",
-  "name": "Light+",
-  "include": "./light_vs.json",
-  "tokenColors": [
-    {
-      "name": "Function declarations",
-      "scope": [
-        "entity.name.function",
-        "support.function",
-        "support.constant.handlebars",
-        "source.powershell variable.other.member",
-        "entity.name.operator.custom-literal"
-      ],
-      "settings": {
-        "foreground": "#795E26"
-      }
-    },
-    {
-      "name": "Types declaration and references",
-      "scope": [
-        "support.class",
-        "support.type",
-        "entity.name.type",
-        "entity.name.namespace",
-        "entity.other.attribute",
-        "entity.name.scope-resolution",
-        "entity.name.class",
-        "storage.type.numeric.go",
-        "storage.type.byte.go",
-        "storage.type.boolean.go",
-        "storage.type.string.go",
-        "storage.type.uintptr.go",
-        "storage.type.error.go",
-        "storage.type.rune.go",
-        "storage.type.cs",
-        "storage.type.generic.cs",
-        "storage.type.modifier.cs",
-        "storage.type.variable.cs",
-        "storage.type.annotation.java",
-        "storage.type.generic.java",
-        "storage.type.java",
-        "storage.type.object.array.java",
-        "storage.type.primitive.array.java",
-        "storage.type.primitive.java",
-        "storage.type.token.java",
-        "storage.type.groovy",
-        "storage.type.annotation.groovy",
-        "storage.type.parameters.groovy",
-        "storage.type.generic.groovy",
-        "storage.type.object.array.groovy",
-        "storage.type.primitive.array.groovy",
-        "storage.type.primitive.groovy"
-      ],
-      "settings": {
-        "foreground": "#267f99"
-      }
-    },
-    {
-      "name": "Types declaration and references, TS grammar specific",
-      "scope": [
-        "meta.type.cast.expr",
-        "meta.type.new.expr",
-        "support.constant.math",
-        "support.constant.dom",
-        "support.constant.json",
-        "entity.other.inherited-class"
-      ],
-      "settings": {
-        "foreground": "#267f99"
-      }
-    },
-    {
-      "name": "Control flow / Special keywords",
-      "scope": [
-        "keyword.control",
-        "source.cpp keyword.operator.new",
-        "source.cpp keyword.operator.delete",
-        "keyword.other.using",
-        "keyword.other.directive.using",
-        "keyword.other.operator",
-        "entity.name.operator"
-      ],
-      "settings": {
-        "foreground": "#AF00DB"
-      }
-    },
-    {
-      "name": "Variable and parameter name",
-      "scope": [
-        "variable",
-        "meta.definition.variable.name",
-        "support.variable",
-        "entity.name.variable",
-        "constant.other.placeholder"
-      ],
-      "settings": {
-        "foreground": "#001080"
-      }
-    },
-    {
-      "name": "Constants and enums",
-      "scope": ["variable.other.constant", "variable.other.enummember"],
-      "settings": {
-        "foreground": "#0070C1"
-      }
-    },
-    {
-      "name": "Object keys, TS grammar specific",
-      "scope": ["meta.object-literal.key"],
-      "settings": {
-        "foreground": "#001080"
-      }
-    },
-    {
-      "name": "CSS property value",
-      "scope": [
-        "support.constant.property-value",
-        "support.constant.font-name",
-        "support.constant.media-type",
-        "support.constant.media",
-        "constant.other.color.rgb-value",
-        "constant.other.rgb-value",
-        "support.constant.color"
-      ],
-      "settings": {
-        "foreground": "#0451a5"
-      }
-    },
-    {
-      "name": "Regular expression groups",
-      "scope": [
-        "punctuation.definition.group.regexp",
-        "punctuation.definition.group.assertion.regexp",
-        "punctuation.definition.character-class.regexp",
-        "punctuation.character.set.begin.regexp",
-        "punctuation.character.set.end.regexp",
-        "keyword.operator.negation.regexp",
-        "support.other.parenthesis.regexp"
-      ],
-      "settings": {
-        "foreground": "#d16969"
-      }
-    },
-    {
-      "scope": [
-        "constant.character.character-class.regexp",
-        "constant.other.character-class.set.regexp",
-        "constant.other.character-class.regexp",
-        "constant.character.set.regexp"
-      ],
-      "settings": {
-        "foreground": "#811f3f"
-      }
-    },
-    {
-      "scope": "keyword.operator.quantifier.regexp",
-      "settings": {
-        "foreground": "#000000"
-      }
-    },
-    {
-      "scope": ["keyword.operator.or.regexp", "keyword.control.anchor.regexp"],
-      "settings": {
-        "foreground": "#EE0000"
-      }
-    },
-    {
-      "scope": ["constant.character", "constant.other.option"],
-      "settings": {
-        "foreground": "#0000ff"
-      }
-    },
-    {
-      "scope": "constant.character.escape",
-      "settings": {
-        "foreground": "#EE0000"
-      }
-    },
-    {
-      "scope": "entity.name.label",
-      "settings": {
-        "foreground": "#000000"
-      }
-    }
-  ],
-  "semanticHighlighting": true,
-  "semanticTokenColors": {
-    "newOperator": "#AF00DB",
-    "stringLiteral": "#a31515",
-    "customLiteral": "#795E26",
-    "numberLiteral": "#098658"
-  }
+	"$schema": "vscode://schemas/color-theme",
+	"name": "Light+",
+	"include": "./light_vs.json",
+	"tokenColors": [
+		{
+			"name": "Function declarations",
+			"scope": [
+				"entity.name.function",
+				"support.function",
+				"support.constant.handlebars",
+				"source.powershell variable.other.member",
+				"entity.name.operator.custom-literal"
+			],
+			"settings": {
+				"foreground": "#795E26"
+			}
+		},
+		{
+			"name": "Types declaration and references",
+			"scope": [
+				"support.class",
+				"support.type",
+				"entity.name.type",
+				"entity.name.namespace",
+				"entity.other.attribute",
+				"entity.name.scope-resolution",
+				"entity.name.class",
+				"storage.type.numeric.go",
+				"storage.type.byte.go",
+				"storage.type.boolean.go",
+				"storage.type.string.go",
+				"storage.type.uintptr.go",
+				"storage.type.error.go",
+				"storage.type.rune.go",
+				"storage.type.cs",
+				"storage.type.generic.cs",
+				"storage.type.modifier.cs",
+				"storage.type.variable.cs",
+				"storage.type.annotation.java",
+				"storage.type.generic.java",
+				"storage.type.java",
+				"storage.type.object.array.java",
+				"storage.type.primitive.array.java",
+				"storage.type.primitive.java",
+				"storage.type.token.java",
+				"storage.type.groovy",
+				"storage.type.annotation.groovy",
+				"storage.type.parameters.groovy",
+				"storage.type.generic.groovy",
+				"storage.type.object.array.groovy",
+				"storage.type.primitive.array.groovy",
+				"storage.type.primitive.groovy"
+			],
+			"settings": {
+				"foreground": "#267f99"
+			}
+		},
+		{
+			"name": "Types declaration and references, TS grammar specific",
+			"scope": [
+				"meta.type.cast.expr",
+				"meta.type.new.expr",
+				"support.constant.math",
+				"support.constant.dom",
+				"support.constant.json",
+				"entity.other.inherited-class"
+			],
+			"settings": {
+				"foreground": "#267f99"
+			}
+		},
+		{
+			"name": "Control flow / Special keywords",
+			"scope": [
+				"keyword.control",
+				"source.cpp keyword.operator.new",
+				"source.cpp keyword.operator.delete",
+				"keyword.other.using",
+				"keyword.other.directive.using",
+				"keyword.other.operator",
+				"entity.name.operator"
+			],
+			"settings": {
+				"foreground": "#AF00DB"
+			}
+		},
+		{
+			"name": "Variable and parameter name",
+			"scope": [
+				"variable",
+				"meta.definition.variable.name",
+				"support.variable",
+				"entity.name.variable",
+				"constant.other.placeholder"
+			],
+			"settings": {
+				"foreground": "#001080"
+			}
+		},
+		{
+			"name": "Constants and enums",
+			"scope": ["variable.other.constant", "variable.other.enummember"],
+			"settings": {
+				"foreground": "#0070C1"
+			}
+		},
+		{
+			"name": "Object keys, TS grammar specific",
+			"scope": ["meta.object-literal.key"],
+			"settings": {
+				"foreground": "#001080"
+			}
+		},
+		{
+			"name": "CSS property value",
+			"scope": [
+				"support.constant.property-value",
+				"support.constant.font-name",
+				"support.constant.media-type",
+				"support.constant.media",
+				"constant.other.color.rgb-value",
+				"constant.other.rgb-value",
+				"support.constant.color"
+			],
+			"settings": {
+				"foreground": "#0451a5"
+			}
+		},
+		{
+			"name": "Regular expression groups",
+			"scope": [
+				"punctuation.definition.group.regexp",
+				"punctuation.definition.group.assertion.regexp",
+				"punctuation.definition.character-class.regexp",
+				"punctuation.character.set.begin.regexp",
+				"punctuation.character.set.end.regexp",
+				"keyword.operator.negation.regexp",
+				"support.other.parenthesis.regexp"
+			],
+			"settings": {
+				"foreground": "#d16969"
+			}
+		},
+		{
+			"scope": [
+				"constant.character.character-class.regexp",
+				"constant.other.character-class.set.regexp",
+				"constant.other.character-class.regexp",
+				"constant.character.set.regexp"
+			],
+			"settings": {
+				"foreground": "#811f3f"
+			}
+		},
+		{
+			"scope": "keyword.operator.quantifier.regexp",
+			"settings": {
+				"foreground": "#000000"
+			}
+		},
+		{
+			"scope": ["keyword.operator.or.regexp", "keyword.control.anchor.regexp"],
+			"settings": {
+				"foreground": "#EE0000"
+			}
+		},
+		{
+			"scope": ["constant.character", "constant.other.option"],
+			"settings": {
+				"foreground": "#0000ff"
+			}
+		},
+		{
+			"scope": "constant.character.escape",
+			"settings": {
+				"foreground": "#EE0000"
+			}
+		},
+		{
+			"scope": "entity.name.label",
+			"settings": {
+				"foreground": "#000000"
+			}
+		}
+	],
+	"semanticHighlighting": true,
+	"semanticTokenColors": {
+		"newOperator": "#AF00DB",
+		"stringLiteral": "#a31515",
+		"customLiteral": "#795E26",
+		"numberLiteral": "#098658"
+	}
 }

src/integrations/theme/default-themes/light_vs.json

@@ -1,422 +1,416 @@
 {
-  "$schema": "vscode://schemas/color-theme",
-  "name": "Light (Visual Studio)",
-  "colors": {
-    "checkbox.border": "#919191",
-    "editor.background": "#FFFFFF",
-    "editor.foreground": "#000000",
-    "editor.inactiveSelectionBackground": "#E5EBF1",
-    "editorIndentGuide.background1": "#D3D3D3",
-    "editorIndentGuide.activeBackground1": "#939393",
-    "editor.selectionHighlightBackground": "#ADD6FF80",
-    "editorSuggestWidget.background": "#F3F3F3",
-    "activityBarBadge.background": "#007ACC",
-    "sideBarTitle.foreground": "#6F6F6F",
-    "list.hoverBackground": "#E8E8E8",
-    "menu.border": "#D4D4D4",
-    "input.placeholderForeground": "#767676",
-    "searchEditor.textInputBorder": "#CECECE",
-    "settings.textInputBorder": "#CECECE",
-    "settings.numberInputBorder": "#CECECE",
-    "statusBarItem.remoteForeground": "#FFF",
-    "statusBarItem.remoteBackground": "#16825D",
-    "ports.iconRunningProcessForeground": "#369432",
-    "sideBarSectionHeader.background": "#0000",
-    "sideBarSectionHeader.border": "#61616130",
-    "tab.lastPinnedBorder": "#61616130",
-    "notebook.cellBorderColor": "#E8E8E8",
-    "notebook.selectedCellBackground": "#c8ddf150",
-    "statusBarItem.errorBackground": "#c72e0f",
-    "list.activeSelectionIconForeground": "#FFF",
-    "list.focusAndSelectionOutline": "#90C2F9",
-    "terminal.inactiveSelectionBackground": "#E5EBF1",
-    "widget.border": "#d4d4d4",
-    "actionBar.toggledBackground": "#dddddd",
-    "diffEditor.unchangedRegionBackground": "#f8f8f8"
-  },
-  "tokenColors": [
-    {
-      "scope": [
-        "meta.embedded",
-        "source.groovy.embedded",
-        "string meta.image.inline.markdown",
-        "variable.legacy.builtin.python"
-      ],
-      "settings": {
-        "foreground": "#000000ff"
-      }
-    },
-    {
-      "scope": "emphasis",
-      "settings": {
-        "fontStyle": "italic"
-      }
-    },
-    {
-      "scope": "strong",
-      "settings": {
-        "fontStyle": "bold"
-      }
-    },
-    {
-      "scope": "meta.diff.header",
-      "settings": {
-        "foreground": "#000080"
-      }
-    },
-    {
-      "scope": "comment",
-      "settings": {
-        "foreground": "#008000"
-      }
-    },
-    {
-      "scope": "constant.language",
-      "settings": {
-        "foreground": "#0000ff"
-      }
-    },
-    {
-      "scope": [
-        "constant.numeric",
-        "variable.other.enummember",
-        "keyword.operator.plus.exponent",
-        "keyword.operator.minus.exponent"
-      ],
-      "settings": {
-        "foreground": "#098658"
-      }
-    },
-    {
-      "scope": "constant.regexp",
-      "settings": {
-        "foreground": "#811f3f"
-      }
-    },
-    {
-      "name": "css tags in selectors, xml tags",
-      "scope": "entity.name.tag",
-      "settings": {
-        "foreground": "#800000"
-      }
-    },
-    {
-      "scope": "entity.name.selector",
-      "settings": {
-        "foreground": "#800000"
-      }
-    },
-    {
-      "scope": "entity.other.attribute-name",
-      "settings": {
-        "foreground": "#e50000"
-      }
-    },
-    {
-      "scope": [
-        "entity.other.attribute-name.class.css",
-        "source.css entity.other.attribute-name.class",
-        "entity.other.attribute-name.id.css",
-        "entity.other.attribute-name.parent-selector.css",
-        "entity.other.attribute-name.parent.less",
-        "source.css entity.other.attribute-name.pseudo-class",
-        "entity.other.attribute-name.pseudo-element.css",
-        "source.css.less entity.other.attribute-name.id",
-        "entity.other.attribute-name.scss"
-      ],
-      "settings": {
-        "foreground": "#800000"
-      }
-    },
-    {
-      "scope": "invalid",
-      "settings": {
-        "foreground": "#cd3131"
-      }
-    },
-    {
-      "scope": "markup.underline",
-      "settings": {
-        "fontStyle": "underline"
-      }
-    },
-    {
-      "scope": "markup.bold",
-      "settings": {
-        "fontStyle": "bold",
-        "foreground": "#000080"
-      }
-    },
-    {
-      "scope": "markup.heading",
-      "settings": {
-        "fontStyle": "bold",
-        "foreground": "#800000"
-      }
-    },
-    {
-      "scope": "markup.italic",
-      "settings": {
-        "fontStyle": "italic"
-      }
-    },
-    {
-      "scope": "markup.strikethrough",
-      "settings": {
-        "fontStyle": "strikethrough"
-      }
-    },
-    {
-      "scope": "markup.inserted",
-      "settings": {
-        "foreground": "#098658"
-      }
-    },
-    {
-      "scope": "markup.deleted",
-      "settings": {
-        "foreground": "#a31515"
-      }
-    },
-    {
-      "scope": "markup.changed",
-      "settings": {
-        "foreground": "#0451a5"
-      }
-    },
-    {
-      "scope": [
-        "punctuation.definition.quote.begin.markdown",
-        "punctuation.definition.list.begin.markdown"
-      ],
-      "settings": {
-        "foreground": "#0451a5"
-      }
-    },
-    {
-      "scope": "markup.inline.raw",
-      "settings": {
-        "foreground": "#800000"
-      }
-    },
-    {
-      "name": "brackets of XML/HTML tags",
-      "scope": "punctuation.definition.tag",
-      "settings": {
-        "foreground": "#800000"
-      }
-    },
-    {
-      "scope": ["meta.preprocessor", "entity.name.function.preprocessor"],
-      "settings": {
-        "foreground": "#0000ff"
-      }
-    },
-    {
-      "scope": "meta.preprocessor.string",
-      "settings": {
-        "foreground": "#a31515"
-      }
-    },
-    {
-      "scope": "meta.preprocessor.numeric",
-      "settings": {
-        "foreground": "#098658"
-      }
-    },
-    {
-      "scope": "meta.structure.dictionary.key.python",
-      "settings": {
-        "foreground": "#0451a5"
-      }
-    },
-    {
-      "scope": "storage",
-      "settings": {
-        "foreground": "#0000ff"
-      }
-    },
-    {
-      "scope": "storage.type",
-      "settings": {
-        "foreground": "#0000ff"
-      }
-    },
-    {
-      "scope": ["storage.modifier", "keyword.operator.noexcept"],
-      "settings": {
-        "foreground": "#0000ff"
-      }
-    },
-    {
-      "scope": ["string", "meta.embedded.assembly"],
-      "settings": {
-        "foreground": "#a31515"
-      }
-    },
-    {
-      "scope": [
-        "string.comment.buffered.block.pug",
-        "string.quoted.pug",
-        "string.interpolated.pug",
-        "string.unquoted.plain.in.yaml",
-        "string.unquoted.plain.out.yaml",
-        "string.unquoted.block.yaml",
-        "string.quoted.single.yaml",
-        "string.quoted.double.xml",
-        "string.quoted.single.xml",
-        "string.unquoted.cdata.xml",
-        "string.quoted.double.html",
-        "string.quoted.single.html",
-        "string.unquoted.html",
-        "string.quoted.single.handlebars",
-        "string.quoted.double.handlebars"
-      ],
-      "settings": {
-        "foreground": "#0000ff"
-      }
-    },
-    {
-      "scope": "string.regexp",
-      "settings": {
-        "foreground": "#811f3f"
-      }
-    },
-    {
-      "name": "String interpolation",
-      "scope": [
-        "punctuation.definition.template-expression.begin",
-        "punctuation.definition.template-expression.end",
-        "punctuation.section.embedded"
-      ],
-      "settings": {
-        "foreground": "#0000ff"
-      }
-    },
-    {
-      "name": "Reset JavaScript string interpolation expression",
-      "scope": ["meta.template.expression"],
-      "settings": {
-        "foreground": "#000000"
-      }
-    },
-    {
-      "scope": [
-        "support.constant.property-value",
-        "support.constant.font-name",
-        "support.constant.media-type",
-        "support.constant.media",
-        "constant.other.color.rgb-value",
-        "constant.other.rgb-value",
-        "support.constant.color"
-      ],
-      "settings": {
-        "foreground": "#0451a5"
-      }
-    },
-    {
-      "scope": [
-        "support.type.vendored.property-name",
-        "support.type.property-name",
-        "source.css variable",
-        "source.coffee.embedded"
-      ],
-      "settings": {
-        "foreground": "#e50000"
-      }
-    },
-    {
-      "scope": ["support.type.property-name.json"],
-      "settings": {
-        "foreground": "#0451a5"
-      }
-    },
-    {
-      "scope": "keyword",
-      "settings": {
-        "foreground": "#0000ff"
-      }
-    },
-    {
-      "scope": "keyword.control",
-      "settings": {
-        "foreground": "#0000ff"
-      }
-    },
-    {
-      "scope": "keyword.operator",
-      "settings": {
-        "foreground": "#000000"
-      }
-    },
-    {
-      "scope": [
-        "keyword.operator.new",
-        "keyword.operator.expression",
-        "keyword.operator.cast",
-        "keyword.operator.sizeof",
-        "keyword.operator.alignof",
-        "keyword.operator.typeid",
-        "keyword.operator.alignas",
-        "keyword.operator.instanceof",
-        "keyword.operator.logical.python",
-        "keyword.operator.wordlike"
-      ],
-      "settings": {
-        "foreground": "#0000ff"
-      }
-    },
-    {
-      "scope": "keyword.other.unit",
-      "settings": {
-        "foreground": "#098658"
-      }
-    },
-    {
-      "scope": [
-        "punctuation.section.embedded.begin.php",
-        "punctuation.section.embedded.end.php"
-      ],
-      "settings": {
-        "foreground": "#800000"
-      }
-    },
-    {
-      "scope": "support.function.git-rebase",
-      "settings": {
-        "foreground": "#0451a5"
-      }
-    },
-    {
-      "scope": "constant.sha.git-rebase",
-      "settings": {
-        "foreground": "#098658"
-      }
-    },
-    {
-      "name": "coloring of the Java import and package identifiers",
-      "scope": [
-        "storage.modifier.import.java",
-        "variable.language.wildcard.java",
-        "storage.modifier.package.java"
-      ],
-      "settings": {
-        "foreground": "#000000"
-      }
-    },
-    {
-      "name": "this.self",
-      "scope": "variable.language",
-      "settings": {
-        "foreground": "#0000ff"
-      }
-    }
-  ],
-  "semanticHighlighting": true,
-  "semanticTokenColors": {
-    "newOperator": "#0000ff",
-    "stringLiteral": "#a31515",
-    "customLiteral": "#000000",
-    "numberLiteral": "#098658"
-  }
+	"$schema": "vscode://schemas/color-theme",
+	"name": "Light (Visual Studio)",
+	"colors": {
+		"checkbox.border": "#919191",
+		"editor.background": "#FFFFFF",
+		"editor.foreground": "#000000",
+		"editor.inactiveSelectionBackground": "#E5EBF1",
+		"editorIndentGuide.background1": "#D3D3D3",
+		"editorIndentGuide.activeBackground1": "#939393",
+		"editor.selectionHighlightBackground": "#ADD6FF80",
+		"editorSuggestWidget.background": "#F3F3F3",
+		"activityBarBadge.background": "#007ACC",
+		"sideBarTitle.foreground": "#6F6F6F",
+		"list.hoverBackground": "#E8E8E8",
+		"menu.border": "#D4D4D4",
+		"input.placeholderForeground": "#767676",
+		"searchEditor.textInputBorder": "#CECECE",
+		"settings.textInputBorder": "#CECECE",
+		"settings.numberInputBorder": "#CECECE",
+		"statusBarItem.remoteForeground": "#FFF",
+		"statusBarItem.remoteBackground": "#16825D",
+		"ports.iconRunningProcessForeground": "#369432",
+		"sideBarSectionHeader.background": "#0000",
+		"sideBarSectionHeader.border": "#61616130",
+		"tab.lastPinnedBorder": "#61616130",
+		"notebook.cellBorderColor": "#E8E8E8",
+		"notebook.selectedCellBackground": "#c8ddf150",
+		"statusBarItem.errorBackground": "#c72e0f",
+		"list.activeSelectionIconForeground": "#FFF",
+		"list.focusAndSelectionOutline": "#90C2F9",
+		"terminal.inactiveSelectionBackground": "#E5EBF1",
+		"widget.border": "#d4d4d4",
+		"actionBar.toggledBackground": "#dddddd",
+		"diffEditor.unchangedRegionBackground": "#f8f8f8"
+	},
+	"tokenColors": [
+		{
+			"scope": [
+				"meta.embedded",
+				"source.groovy.embedded",
+				"string meta.image.inline.markdown",
+				"variable.legacy.builtin.python"
+			],
+			"settings": {
+				"foreground": "#000000ff"
+			}
+		},
+		{
+			"scope": "emphasis",
+			"settings": {
+				"fontStyle": "italic"
+			}
+		},
+		{
+			"scope": "strong",
+			"settings": {
+				"fontStyle": "bold"
+			}
+		},
+		{
+			"scope": "meta.diff.header",
+			"settings": {
+				"foreground": "#000080"
+			}
+		},
+		{
+			"scope": "comment",
+			"settings": {
+				"foreground": "#008000"
+			}
+		},
+		{
+			"scope": "constant.language",
+			"settings": {
+				"foreground": "#0000ff"
+			}
+		},
+		{
+			"scope": [
+				"constant.numeric",
+				"variable.other.enummember",
+				"keyword.operator.plus.exponent",
+				"keyword.operator.minus.exponent"
+			],
+			"settings": {
+				"foreground": "#098658"
+			}
+		},
+		{
+			"scope": "constant.regexp",
+			"settings": {
+				"foreground": "#811f3f"
+			}
+		},
+		{
+			"name": "css tags in selectors, xml tags",
+			"scope": "entity.name.tag",
+			"settings": {
+				"foreground": "#800000"
+			}
+		},
+		{
+			"scope": "entity.name.selector",
+			"settings": {
+				"foreground": "#800000"
+			}
+		},
+		{
+			"scope": "entity.other.attribute-name",
+			"settings": {
+				"foreground": "#e50000"
+			}
+		},
+		{
+			"scope": [
+				"entity.other.attribute-name.class.css",
+				"source.css entity.other.attribute-name.class",
+				"entity.other.attribute-name.id.css",
+				"entity.other.attribute-name.parent-selector.css",
+				"entity.other.attribute-name.parent.less",
+				"source.css entity.other.attribute-name.pseudo-class",
+				"entity.other.attribute-name.pseudo-element.css",
+				"source.css.less entity.other.attribute-name.id",
+				"entity.other.attribute-name.scss"
+			],
+			"settings": {
+				"foreground": "#800000"
+			}
+		},
+		{
+			"scope": "invalid",
+			"settings": {
+				"foreground": "#cd3131"
+			}
+		},
+		{
+			"scope": "markup.underline",
+			"settings": {
+				"fontStyle": "underline"
+			}
+		},
+		{
+			"scope": "markup.bold",
+			"settings": {
+				"fontStyle": "bold",
+				"foreground": "#000080"
+			}
+		},
+		{
+			"scope": "markup.heading",
+			"settings": {
+				"fontStyle": "bold",
+				"foreground": "#800000"
+			}
+		},
+		{
+			"scope": "markup.italic",
+			"settings": {
+				"fontStyle": "italic"
+			}
+		},
+		{
+			"scope": "markup.strikethrough",
+			"settings": {
+				"fontStyle": "strikethrough"
+			}
+		},
+		{
+			"scope": "markup.inserted",
+			"settings": {
+				"foreground": "#098658"
+			}
+		},
+		{
+			"scope": "markup.deleted",
+			"settings": {
+				"foreground": "#a31515"
+			}
+		},
+		{
+			"scope": "markup.changed",
+			"settings": {
+				"foreground": "#0451a5"
+			}
+		},
+		{
+			"scope": ["punctuation.definition.quote.begin.markdown", "punctuation.definition.list.begin.markdown"],
+			"settings": {
+				"foreground": "#0451a5"
+			}
+		},
+		{
+			"scope": "markup.inline.raw",
+			"settings": {
+				"foreground": "#800000"
+			}
+		},
+		{
+			"name": "brackets of XML/HTML tags",
+			"scope": "punctuation.definition.tag",
+			"settings": {
+				"foreground": "#800000"
+			}
+		},
+		{
+			"scope": ["meta.preprocessor", "entity.name.function.preprocessor"],
+			"settings": {
+				"foreground": "#0000ff"
+			}
+		},
+		{
+			"scope": "meta.preprocessor.string",
+			"settings": {
+				"foreground": "#a31515"
+			}
+		},
+		{
+			"scope": "meta.preprocessor.numeric",
+			"settings": {
+				"foreground": "#098658"
+			}
+		},
+		{
+			"scope": "meta.structure.dictionary.key.python",
+			"settings": {
+				"foreground": "#0451a5"
+			}
+		},
+		{
+			"scope": "storage",
+			"settings": {
+				"foreground": "#0000ff"
+			}
+		},
+		{
+			"scope": "storage.type",
+			"settings": {
+				"foreground": "#0000ff"
+			}
+		},
+		{
+			"scope": ["storage.modifier", "keyword.operator.noexcept"],
+			"settings": {
+				"foreground": "#0000ff"
+			}
+		},
+		{
+			"scope": ["string", "meta.embedded.assembly"],
+			"settings": {
+				"foreground": "#a31515"
+			}
+		},
+		{
+			"scope": [
+				"string.comment.buffered.block.pug",
+				"string.quoted.pug",
+				"string.interpolated.pug",
+				"string.unquoted.plain.in.yaml",
+				"string.unquoted.plain.out.yaml",
+				"string.unquoted.block.yaml",
+				"string.quoted.single.yaml",
+				"string.quoted.double.xml",
+				"string.quoted.single.xml",
+				"string.unquoted.cdata.xml",
+				"string.quoted.double.html",
+				"string.quoted.single.html",
+				"string.unquoted.html",
+				"string.quoted.single.handlebars",
+				"string.quoted.double.handlebars"
+			],
+			"settings": {
+				"foreground": "#0000ff"
+			}
+		},
+		{
+			"scope": "string.regexp",
+			"settings": {
+				"foreground": "#811f3f"
+			}
+		},
+		{
+			"name": "String interpolation",
+			"scope": [
+				"punctuation.definition.template-expression.begin",
+				"punctuation.definition.template-expression.end",
+				"punctuation.section.embedded"
+			],
+			"settings": {
+				"foreground": "#0000ff"
+			}
+		},
+		{
+			"name": "Reset JavaScript string interpolation expression",
+			"scope": ["meta.template.expression"],
+			"settings": {
+				"foreground": "#000000"
+			}
+		},
+		{
+			"scope": [
+				"support.constant.property-value",
+				"support.constant.font-name",
+				"support.constant.media-type",
+				"support.constant.media",
+				"constant.other.color.rgb-value",
+				"constant.other.rgb-value",
+				"support.constant.color"
+			],
+			"settings": {
+				"foreground": "#0451a5"
+			}
+		},
+		{
+			"scope": [
+				"support.type.vendored.property-name",
+				"support.type.property-name",
+				"source.css variable",
+				"source.coffee.embedded"
+			],
+			"settings": {
+				"foreground": "#e50000"
+			}
+		},
+		{
+			"scope": ["support.type.property-name.json"],
+			"settings": {
+				"foreground": "#0451a5"
+			}
+		},
+		{
+			"scope": "keyword",
+			"settings": {
+				"foreground": "#0000ff"
+			}
+		},
+		{
+			"scope": "keyword.control",
+			"settings": {
+				"foreground": "#0000ff"
+			}
+		},
+		{
+			"scope": "keyword.operator",
+			"settings": {
+				"foreground": "#000000"
+			}
+		},
+		{
+			"scope": [
+				"keyword.operator.new",
+				"keyword.operator.expression",
+				"keyword.operator.cast",
+				"keyword.operator.sizeof",
+				"keyword.operator.alignof",
+				"keyword.operator.typeid",
+				"keyword.operator.alignas",
+				"keyword.operator.instanceof",
+				"keyword.operator.logical.python",
+				"keyword.operator.wordlike"
+			],
+			"settings": {
+				"foreground": "#0000ff"
+			}
+		},
+		{
+			"scope": "keyword.other.unit",
+			"settings": {
+				"foreground": "#098658"
+			}
+		},
+		{
+			"scope": ["punctuation.section.embedded.begin.php", "punctuation.section.embedded.end.php"],
+			"settings": {
+				"foreground": "#800000"
+			}
+		},
+		{
+			"scope": "support.function.git-rebase",
+			"settings": {
+				"foreground": "#0451a5"
+			}
+		},
+		{
+			"scope": "constant.sha.git-rebase",
+			"settings": {
+				"foreground": "#098658"
+			}
+		},
+		{
+			"name": "coloring of the Java import and package identifiers",
+			"scope": [
+				"storage.modifier.import.java",
+				"variable.language.wildcard.java",
+				"storage.modifier.package.java"
+			],
+			"settings": {
+				"foreground": "#000000"
+			}
+		},
+		{
+			"name": "this.self",
+			"scope": "variable.language",
+			"settings": {
+				"foreground": "#0000ff"
+			}
+		}
+	],
+	"semanticHighlighting": true,
+	"semanticTokenColors": {
+		"newOperator": "#0000ff",
+		"stringLiteral": "#a31515",
+		"customLiteral": "#000000",
+		"numberLiteral": "#098658"
+	}
 }

src/integrations/theme/getTheme.ts

@@ -55,7 +55,7 @@ export async function getTheme() {
 			const filename = `${defaultThemes[colorTheme]}.json`
 			currentTheme = await fs.readFile(
 				path.join(getExtensionUri().fsPath, "src", "integrations", "theme", "default-themes", filename),
-				"utf-8"
+				"utf-8",
 			)
 		}
 
@@ -65,7 +65,7 @@ export async function getTheme() {
 		if (parsed.include) {
 			const includeThemeString = await fs.readFile(
 				path.join(getExtensionUri().fsPath, "src", "integrations", "theme", "default-themes", parsed.include),
-				"utf-8"
+				"utf-8",
 			)
 			const includeTheme = parseThemeString(includeThemeString)
 			parsed = mergeJson(parsed, includeTheme)
@@ -77,8 +77,8 @@ export async function getTheme() {
 			["vs", "hc-black"].includes(converted.base)
 				? converted.base
 				: colorTheme.includes("Light")
-				? "vs"
-				: "vs-dark"
+					? "vs"
+					: "vs-dark"
 		) as any
 
 		return converted
@@ -93,7 +93,7 @@ export function mergeJson(
 	first: JsonObject,
 	second: JsonObject,
 	mergeBehavior?: "merge" | "overwrite",
-	mergeKeys?: { [key: string]: (a: any, b: any) => boolean }
+	mergeKeys?: { [key: string]: (a: any, b: any) => boolean },
 ): any {
 	const copyOfFirst = JSON.parse(JSON.stringify(first))
 

src/integrations/workspace/WorkspaceTracker.ts

@@ -52,7 +52,7 @@ class WorkspaceTracker {
 		await Promise.all(
 			event.files.map(async (file) => {
 				await this.addFilePath(file.fsPath)
-			})
+			}),
 		)
 		this.workspaceDidUpdate()
 	}
@@ -64,7 +64,7 @@ class WorkspaceTracker {
 				if (await this.removeFilePath(file.fsPath)) {
 					updated = true
 				}
-			})
+			}),
 		)
 		if (updated) {
 			this.workspaceDidUpdate()
@@ -76,7 +76,7 @@ class WorkspaceTracker {
 			event.files.map(async (file) => {
 				await this.removeFilePath(file.oldUri.fsPath)
 				await this.addFilePath(file.newUri.fsPath)
-			})
+			}),
 		)
 		this.workspaceDidUpdate()
 	}

src/services/browser/BrowserSession.ts

@@ -195,7 +195,7 @@ export class BrowserSession {
 	async doAction(action: (page: Page) => Promise<void>): Promise<BrowserActionResult> {
 		if (!this.page) {
 			throw new Error(
-				"Browser is not launched. Please launch a browser session first."
+				"Browser is not launched. This may occur if the browser was automatically closed by a non-`browser_action` tool.",
 			)
 		}
 

src/services/ripgrep/index.ts

@@ -126,7 +126,7 @@ export async function regexSearchFiles(
 	cwd: string,
 	directoryPath: string,
 	regex: string,
-	filePattern?: string
+	filePattern?: string,
 ): Promise<string> {
 	const vscodeAppRoot = vscode.env.appRoot
 	const rgPath = await getBinPath(vscodeAppRoot)

src/shared/ExtensionMessage.ts

@@ -35,6 +35,7 @@ export interface ExtensionState {
 	alwaysAllowReadOnly?: boolean
 	alwaysAllowWrite?: boolean
 	alwaysAllowExecute?: boolean
+	alwaysAllowBrowser?: boolean
 	uriScheme?: string
 	clineMessages: ClineMessage[]
 	taskHistory: HistoryItem[]

src/shared/WebviewMessage.ts

@@ -25,6 +25,7 @@ export interface WebviewMessage {
 		| "openMention"
 		| "cancelTask"
 		| "refreshOpenRouterModels"
+		| "alwaysAllowBrowser"
 	text?: string
 	askResponse?: ClineAskResponse
 	apiConfiguration?: ApiConfiguration

src/test/extension.test.ts

@@ -1,15 +1,15 @@
-import * as assert from 'assert';
+import * as assert from "assert"
 
 // You can import and use all API from the 'vscode' module
 // as well as import your extension to test it
-import * as vscode from 'vscode';
+import * as vscode from "vscode"
 // import * as myExtension from '../../extension';
 
-suite('Extension Test Suite', () => {
-	vscode.window.showInformationMessage('Start all tests.');
+suite("Extension Test Suite", () => {
+	vscode.window.showInformationMessage("Start all tests.")
 
-	test('Sample test', () => {
-		assert.strictEqual(-1, [1, 2, 3].indexOf(5));
-		assert.strictEqual(-1, [1, 2, 3].indexOf(0));
-	});
-});
+	test("Sample test", () => {
+		assert.strictEqual(-1, [1, 2, 3].indexOf(5))
+		assert.strictEqual(-1, [1, 2, 3].indexOf(0))
+	})
+})

src/utils/cost.ts

@@ -5,7 +5,7 @@ export function calculateApiCost(
 	inputTokens: number,
 	outputTokens: number,
 	cacheCreationInputTokens?: number,
-	cacheReadInputTokens?: number
+	cacheReadInputTokens?: number,
 ): number {
 	const modelCacheWritesPrice = modelInfo.cacheWritesPrice
 	let cacheWritesCost = 0

webview-ui/package.json

@@ -1,57 +1,57 @@
 {
-  "name": "webview-ui",
-  "version": "0.1.0",
-  "private": true,
-  "dependencies": {
-    "@testing-library/jest-dom": "^5.17.0",
-    "@testing-library/react": "^13.4.0",
-    "@testing-library/user-event": "^13.5.0",
-    "@types/jest": "^27.5.2",
-    "@types/node": "^16.18.101",
-    "@types/react": "^18.3.3",
-    "@types/react-dom": "^18.3.0",
-    "@vscode/webview-ui-toolkit": "^1.4.0",
-    "debounce": "^2.1.1",
-    "fast-deep-equal": "^3.1.3",
-    "fuse.js": "^7.0.0",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "react-remark": "^2.1.0",
-    "react-scripts": "5.0.1",
-    "react-textarea-autosize": "^8.5.3",
-    "react-use": "^17.5.1",
-    "react-virtuoso": "^4.7.13",
-    "rehype-highlight": "^7.0.0",
-    "rewire": "^7.0.0",
-    "styled-components": "^6.1.13",
-    "typescript": "^4.9.5",
-    "web-vitals": "^2.1.4"
-  },
-  "scripts": {
-    "start": "react-scripts start",
-    "build": "node ./scripts/build-react-no-split.js",
-    "test": "react-scripts test",
-    "eject": "react-scripts eject"
-  },
-  "eslintConfig": {
-    "extends": [
-      "react-app",
-      "react-app/jest"
-    ]
-  },
-  "browserslist": {
-    "production": [
-      ">0.2%",
-      "not dead",
-      "not op_mini all"
-    ],
-    "development": [
-      "last 1 chrome version",
-      "last 1 firefox version",
-      "last 1 safari version"
-    ]
-  },
-  "devDependencies": {
-    "@types/vscode-webview": "^1.57.5"
-  }
+	"name": "webview-ui",
+	"version": "0.1.0",
+	"private": true,
+	"dependencies": {
+		"@testing-library/jest-dom": "^5.17.0",
+		"@testing-library/react": "^13.4.0",
+		"@testing-library/user-event": "^13.5.0",
+		"@types/jest": "^27.5.2",
+		"@types/node": "^16.18.101",
+		"@types/react": "^18.3.3",
+		"@types/react-dom": "^18.3.0",
+		"@vscode/webview-ui-toolkit": "^1.4.0",
+		"debounce": "^2.1.1",
+		"fast-deep-equal": "^3.1.3",
+		"fuse.js": "^7.0.0",
+		"react": "^18.3.1",
+		"react-dom": "^18.3.1",
+		"react-remark": "^2.1.0",
+		"react-scripts": "5.0.1",
+		"react-textarea-autosize": "^8.5.3",
+		"react-use": "^17.5.1",
+		"react-virtuoso": "^4.7.13",
+		"rehype-highlight": "^7.0.0",
+		"rewire": "^7.0.0",
+		"styled-components": "^6.1.13",
+		"typescript": "^4.9.5",
+		"web-vitals": "^2.1.4"
+	},
+	"scripts": {
+		"start": "react-scripts start",
+		"build": "node ./scripts/build-react-no-split.js",
+		"test": "react-scripts test",
+		"eject": "react-scripts eject"
+	},
+	"eslintConfig": {
+		"extends": [
+			"react-app",
+			"react-app/jest"
+		]
+	},
+	"browserslist": {
+		"production": [
+			">0.2%",
+			"not dead",
+			"not op_mini all"
+		],
+		"development": [
+			"last 1 chrome version",
+			"last 1 firefox version",
+			"last 1 safari version"
+		]
+	},
+	"devDependencies": {
+		"@types/vscode-webview": "^1.57.5"
+	}
 }

webview-ui/public/index.html

@@ -1,20 +1,17 @@
-<!DOCTYPE html>
+<!doctype html>
 <html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <link rel="icon" href="%PUBLIC_URL%/favicon.ico" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <meta name="theme-color" content="#000000" />
-    <meta
-      name="description"
-      content="Web site created using create-react-app"
-    />
-    <!--
+	<head>
+		<meta charset="utf-8" />
+		<link rel="icon" href="%PUBLIC_URL%/favicon.ico" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<meta name="theme-color" content="#000000" />
+		<meta name="description" content="Web site created using create-react-app" />
+		<!--
       manifest.json provides metadata used when your web app is installed on a
       user's mobile device or desktop. See https://developers.google.com/web/fundamentals/web-app-manifest/
     -->
-    <link rel="manifest" href="%PUBLIC_URL%/manifest.json" />
-    <!--
+		<link rel="manifest" href="%PUBLIC_URL%/manifest.json" />
+		<!--
       Notice the use of %PUBLIC_URL% in the tags above.
       It will be replaced with the URL of the `public` folder during the build.
       Only files inside the `public` folder can be referenced from the HTML.
@@ -23,12 +20,12 @@
       work correctly both with client-side routing and a non-root public URL.
       Learn how to configure a non-root public URL by running `npm run build`.
     -->
-    <title>React App</title>
-  </head>
-  <body>
-    <noscript>You need to enable JavaScript to run this app.</noscript>
-    <div id="root"></div>
-    <!--
+		<title>React App</title>
+	</head>
+	<body>
+		<noscript>You need to enable JavaScript to run this app.</noscript>
+		<div id="root"></div>
+		<!--
       This HTML file is a template.
       If you open it directly in the browser, you will see an empty page.
 
@@ -37,6 +34,5 @@
 
       To begin the development, run `npm start` or `yarn start`.
       To create a production bundle, use `npm run build` or `yarn build`.
-    -->
-  </body>
+    --></body>
 </html>

webview-ui/public/manifest.json

@@ -1,25 +1,25 @@
 {
-  "short_name": "React App",
-  "name": "Create React App Sample",
-  "icons": [
-    {
-      "src": "",
-      "sizes": "64x64 32x32 24x24 16x16",
-      "type": "image/x-icon"
-    },
-    {
-      "src": "",
-      "type": "image/png",
-      "sizes": "192x192"
-    },
-    {
-      "src": "",
-      "type": "image/png",
-      "sizes": "512x512"
-    }
-  ],
-  "start_url": ".",
-  "display": "standalone",
-  "theme_color": "#000000",
-  "background_color": "#ffffff"
+	"short_name": "React App",
+	"name": "Create React App Sample",
+	"icons": [
+		{
+			"src": "",
+			"sizes": "64x64 32x32 24x24 16x16",
+			"type": "image/x-icon"
+		},
+		{
+			"src": "",
+			"type": "image/png",
+			"sizes": "192x192"
+		},
+		{
+			"src": "",
+			"type": "image/png",
+			"sizes": "512x512"
+		}
+	],
+	"start_url": ".",
+	"display": "standalone",
+	"theme_color": "#000000",
+	"background_color": "#ffffff"
 }

webview-ui/src/components/chat/BrowserSessionRow.tsx

@@ -91,7 +91,7 @@ const BrowserSessionRow = memo((props: BrowserSessionRowProps) => {
 						nextActionMessages.length > 0
 							? {
 									messages: [...nextActionMessages],
-							  }
+								}
 							: undefined,
 				})
 
@@ -121,7 +121,7 @@ const BrowserSessionRow = memo((props: BrowserSessionRowProps) => {
 					nextActionMessages.length > 0
 						? {
 								messages: [...nextActionMessages],
-						  }
+							}
 						: undefined,
 			})
 		}
@@ -167,13 +167,13 @@ const BrowserSessionRow = memo((props: BrowserSessionRowProps) => {
 				mousePosition: currentPage?.currentState.mousePosition || latestState.mousePosition || "700,400",
 				consoleLogs: currentPage?.currentState.consoleLogs,
 				screenshot: currentPage?.currentState.screenshot || latestState.screenshot,
-		  }
+			}
 		: {
 				url: currentPage?.currentState.url || initialUrl,
 				mousePosition: currentPage?.currentState.mousePosition || "700,400",
 				consoleLogs: currentPage?.currentState.consoleLogs,
 				screenshot: currentPage?.currentState.screenshot,
-		  }
+			}
 
 	const [actionContent, { height: actionHeight }] = useSize(
 		<div>
@@ -188,7 +188,7 @@ const BrowserSessionRow = memo((props: BrowserSessionRowProps) => {
 			{!isBrowsing && messages.some((m) => m.say === "browser_action_result") && currentPageIndex === 0 && (
 				<BrowserActionBox action={"launch"} text={initialUrl} />
 			)}
-		</div>
+		</div>,
 	)
 
 	useEffect(() => {
@@ -381,7 +381,7 @@ const BrowserSessionRow = memo((props: BrowserSessionRowProps) => {
 					</div>
 				</div>
 			)}
-		</div>
+		</div>,
 	)
 
 	// Height change effect

webview-ui/src/components/chat/ChatRow.tsx

@@ -35,7 +35,7 @@ const ChatRow = memo(
 					padding: "10px 6px 10px 15px",
 				}}>
 				<ChatRowContent {...props} />
-			</div>
+			</div>,
 		)
 
 		useEffect(() => {
@@ -55,7 +55,7 @@ const ChatRow = memo(
 		return chatrow
 	},
 	// memo does shallow comparison of props, so we need to do deep comparison of arrays/objects whose properties might change
-	deepEqual
+	deepEqual,
 )
 
 export default ChatRow
@@ -707,9 +707,7 @@ export const ChatRowContent = ({
 												padding: `2px 8px ${isExpanded ? 0 : 8}px 8px`,
 											}}>
 											<span
-												className={`codicon codicon-chevron-${
-													isExpanded ? "down" : "right"
-												}`}></span>
+												className={`codicon codicon-chevron-${isExpanded ? "down" : "right"}`}></span>
 											<span style={{ fontSize: "0.8em" }}>Command Output</span>
 										</div>
 										{isExpanded && <CodeBlock source={`${"```"}shell\n${output}\n${"```"}`} />}

webview-ui/src/components/chat/ChatTextArea.tsx

@@ -40,7 +40,7 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 			shouldDisableImages,
 			onHeightChange,
 		},
-		ref
+		ref,
 	) => {
 		const { filePaths } = useExtensionState()
 		const [isTextAreaFocused, setIsTextAreaFocused] = useState(false)
@@ -119,7 +119,7 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 					const { newValue, mentionIndex } = insertMention(
 						textAreaRef.current.value,
 						cursorPosition,
-						insertValue
+						insertValue,
 					)
 
 					setInputValue(newValue)
@@ -137,7 +137,7 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 					}, 0)
 				}
 			},
-			[setInputValue, cursorPosition]
+			[setInputValue, cursorPosition],
 		)
 
 		const handleKeyDown = useCallback(
@@ -163,14 +163,14 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 							const selectableOptions = options.filter(
 								(option) =>
 									option.type !== ContextMenuOptionType.URL &&
-									option.type !== ContextMenuOptionType.NoResults
+									option.type !== ContextMenuOptionType.NoResults,
 							)
 
 							if (selectableOptions.length === 0) return -1 // No selectable options
 
 							// Find the index of the next selectable option
 							const currentSelectableIndex = selectableOptions.findIndex(
-								(option) => option === options[prevIndex]
+								(option) => option === options[prevIndex],
 							)
 
 							const newSelectableIndex =
@@ -252,7 +252,7 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 				setInputValue,
 				justDeletedSpaceAfterMention,
 				queryItems,
-			]
+			],
 		)
 
 		useLayoutEffect(() => {
@@ -285,7 +285,7 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 					setSelectedMenuIndex(-1)
 				}
 			},
-			[setInputValue]
+			[setInputValue],
 		)
 
 		useEffect(() => {
@@ -370,7 +370,7 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 					}
 				}
 			},
-			[shouldDisableImages, setSelectedImages, cursorPosition, setInputValue, inputValue]
+			[shouldDisableImages, setSelectedImages, cursorPosition, setInputValue, inputValue],
 		)
 
 		const handleThumbnailsHeightChange = useCallback((height: number) => {
@@ -394,7 +394,7 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 
 			highlightLayerRef.current.innerHTML = text
 				.replace(/\n$/, "\n\n")
-				.replace(/[<>&]/g, (c) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;" }[c] || c))
+				.replace(/[<>&]/g, (c) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;" })[c] || c)
 				.replace(mentionRegexGlobal, '<mark class="mention-context-textarea-highlight">$&</mark>')
 
 			highlightLayerRef.current.scrollTop = textAreaRef.current.scrollTop
@@ -417,7 +417,7 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 					updateCursorPosition()
 				}
 			},
-			[updateCursorPosition]
+			[updateCursorPosition],
 		)
 
 		return (
@@ -594,7 +594,7 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 				</div>
 			</div>
 		)
-	}
+	},
 )
 
 export default ChatTextArea

webview-ui/src/components/chat/ChatView.tsx

@@ -271,7 +271,7 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 				disableAutoScrollRef.current = false
 			}
 		},
-		[messages.length, clineAsk]
+		[messages.length, clineAsk],
 	)
 
 	const startNewTask = useCallback(() => {
@@ -366,7 +366,7 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 					const newImages = message.images ?? []
 					if (newImages.length > 0) {
 						setSelectedImages((prevImages) =>
-							[...prevImages, ...newImages].slice(0, MAX_IMAGES_PER_MESSAGE)
+							[...prevImages, ...newImages].slice(0, MAX_IMAGES_PER_MESSAGE),
 						)
 					}
 					break
@@ -392,7 +392,7 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 			handleSendMessage,
 			handlePrimaryButtonClick,
 			handleSecondaryButtonClick,
-		]
+		],
 	)
 
 	useEvent("message", handleMessage)
@@ -530,9 +530,9 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 					})
 				},
 				10,
-				{ immediate: true }
+				{ immediate: true },
 			),
-		[]
+		[],
 	)
 
 	const scrollToBottomAuto = useCallback(() => {
@@ -594,7 +594,7 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 				}
 			}
 		},
-		[groupedMessages, expandedRows, scrollToBottomAuto, isAtBottom]
+		[groupedMessages, expandedRows, scrollToBottomAuto, isAtBottom],
 	)
 
 	const handleRowHeightChange = useCallback(
@@ -609,7 +609,7 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 				}
 			}
 		},
-		[scrollToBottomSmooth, scrollToBottomAuto]
+		[scrollToBottomSmooth, scrollToBottomAuto],
 	)
 
 	useEffect(() => {
@@ -672,7 +672,7 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 				/>
 			)
 		},
-		[expandedRows, modifiedMessages, groupedMessages.length, toggleRowExpansion, handleRowHeightChange]
+		[expandedRows, modifiedMessages, groupedMessages.length, toggleRowExpansion, handleRowHeightChange],
 	)
 
 	return (

webview-ui/src/components/chat/ContextMenu.tsx

@@ -25,7 +25,7 @@ const ContextMenu: React.FC<ContextMenuProps> = ({
 
 	const filteredOptions = useMemo(
 		() => getContextMenuOptions(searchQuery, selectedType, queryItems),
-		[searchQuery, selectedType, queryItems]
+		[searchQuery, selectedType, queryItems],
 	)
 
 	useEffect(() => {

webview-ui/src/components/common/CodeAccordian.tsx

@@ -35,7 +35,7 @@ const CodeAccordian = ({
 }: CodeAccordianProps) => {
 	const inferredLanguage = useMemo(
 		() => code && (language ?? (path ? getLanguageFromPath(path) : undefined)),
-		[path, language, code]
+		[path, language, code],
 	)
 
 	return (

webview-ui/src/components/common/CodeBlock.tsx

@@ -69,8 +69,19 @@ const StyledMarkdown = styled.div<{ forceWrap: boolean }>`
 	}
 
 	background-color: ${CODE_BLOCK_BG_COLOR};
-	font-family: var(--vscode-font-family), system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen,
-		Ubuntu, Cantarell, "Open Sans", "Helvetica Neue", sans-serif;
+	font-family:
+		var(--vscode-font-family),
+		system-ui,
+		-apple-system,
+		BlinkMacSystemFont,
+		"Segoe UI",
+		Roboto,
+		Oxygen,
+		Ubuntu,
+		Cantarell,
+		"Open Sans",
+		"Helvetica Neue",
+		sans-serif;
 	font-size: var(--vscode-editor-font-size, var(--vscode-font-size, 12px));
 	color: var(--vscode-editor-foreground, #fff);
 

webview-ui/src/components/common/Demo.tsx

@@ -1,24 +1,23 @@
-
 import {
-    VSCodeBadge,
-    VSCodeButton,
-    VSCodeCheckbox,
-    VSCodeDataGrid,
-    VSCodeDataGridCell,
-    VSCodeDataGridRow,
-    VSCodeDivider,
-    VSCodeDropdown,
-    VSCodeLink,
-    VSCodeOption,
-    VSCodePanels,
-    VSCodePanelTab,
-    VSCodePanelView,
-    VSCodeProgressRing,
-    VSCodeRadio,
-    VSCodeRadioGroup,
-    VSCodeTag,
-    VSCodeTextArea,
-    VSCodeTextField,
+	VSCodeBadge,
+	VSCodeButton,
+	VSCodeCheckbox,
+	VSCodeDataGrid,
+	VSCodeDataGridCell,
+	VSCodeDataGridRow,
+	VSCodeDivider,
+	VSCodeDropdown,
+	VSCodeLink,
+	VSCodeOption,
+	VSCodePanels,
+	VSCodePanelTab,
+	VSCodePanelView,
+	VSCodeProgressRing,
+	VSCodeRadio,
+	VSCodeRadioGroup,
+	VSCodeTag,
+	VSCodeTextArea,
+	VSCodeTextField,
 } from "@vscode/webview-ui-toolkit/react"
 
 function Demo() {
@@ -81,7 +80,7 @@ function Demo() {
 					))}
 				</VSCodeDataGrid>
 
-                <VSCodeTextField>
+				<VSCodeTextField>
 					<section slot="end" style={{ display: "flex", alignItems: "center" }}>
 						<VSCodeButton appearance="icon" aria-label="Match Case">
 							<span className="codicon codicon-case-sensitive"></span>

webview-ui/src/components/common/MarkdownBlock.tsx

@@ -57,8 +57,19 @@ const StyledMarkdown = styled.div`
 		overflow-wrap: anywhere;
 	}
 
-	font-family: var(--vscode-font-family), system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen,
-		Ubuntu, Cantarell, "Open Sans", "Helvetica Neue", sans-serif;
+	font-family:
+		var(--vscode-font-family),
+		system-ui,
+		-apple-system,
+		BlinkMacSystemFont,
+		"Segoe UI",
+		Roboto,
+		Oxygen,
+		Ubuntu,
+		Cantarell,
+		"Open Sans",
+		"Helvetica Neue",
+		sans-serif;
 	font-size: var(--vscode-font-size, 13px);
 
 	p,

webview-ui/src/components/history/HistoryView.tsx

@@ -430,7 +430,7 @@ const ExportButton = ({ itemId }: { itemId: string }) => (
 // https://gist.github.com/evenfrost/1ba123656ded32fb7a0cd4651efd4db0
 export const highlight = (
 	fuseSearchResult: FuseResult<any>[],
-	highlightClassName: string = "history-item-highlight"
+	highlightClassName: string = "history-item-highlight",
 ) => {
 	const set = (obj: Record<string, any>, path: string, value: any) => {
 		const pathValue = path.split(".")

webview-ui/src/components/settings/OpenRouterModelPicker.tsx

@@ -266,8 +266,19 @@ const DropdownItem = styled.div<{ isSelected: boolean }>`
 // Markdown
 
 const StyledMarkdown = styled.div`
-	font-family: var(--vscode-font-family), system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen,
-		Ubuntu, Cantarell, "Open Sans", "Helvetica Neue", sans-serif;
+	font-family:
+		var(--vscode-font-family),
+		system-ui,
+		-apple-system,
+		BlinkMacSystemFont,
+		"Segoe UI",
+		Roboto,
+		Oxygen,
+		Ubuntu,
+		Cantarell,
+		"Open Sans",
+		"Helvetica Neue",
+		sans-serif;
 	font-size: 12px;
 	color: var(--vscode-descriptionForeground);
 
@@ -403,5 +414,5 @@ export const ModelDescriptionMarkdown = memo(
 			)} */}
 			</StyledMarkdown>
 		)
-	}
+	},
 )

webview-ui/src/components/settings/SettingsView.tsx

@@ -23,6 +23,8 @@ const SettingsView = ({ onDone }: SettingsViewProps) => {
 		setAlwaysAllowWrite,
 		alwaysAllowExecute,
 		setAlwaysAllowExecute,
+		alwaysAllowBrowser,
+		setAlwaysAllowBrowser,
 		openRouterModels,
 	} = useExtensionState()
 	const [apiErrorMessage, setApiErrorMessage] = useState<string | undefined>(undefined)
@@ -39,6 +41,7 @@ const SettingsView = ({ onDone }: SettingsViewProps) => {
 			vscode.postMessage({ type: "alwaysAllowReadOnly", bool: alwaysAllowReadOnly })
 			vscode.postMessage({ type: "alwaysAllowWrite", bool: alwaysAllowWrite })
 			vscode.postMessage({ type: "alwaysAllowExecute", bool: alwaysAllowExecute })
+			vscode.postMessage({ type: "alwaysAllowBrowser", bool: alwaysAllowBrowser })
 			onDone()
 		}
 	}
@@ -170,6 +173,22 @@ const SettingsView = ({ onDone }: SettingsViewProps) => {
 					</p>
 				</div>
 
+				<div style={{ marginBottom: 5 }}>
+					<VSCodeCheckbox
+						checked={alwaysAllowBrowser}
+						onChange={(e: any) => setAlwaysAllowBrowser(e.target.checked)}>
+						<span style={{ fontWeight: "500" }}>Always approve browser actions</span>
+					</VSCodeCheckbox>
+					<p
+						style={{
+							fontSize: "12px",
+							marginTop: "5px",
+							color: "var(--vscode-descriptionForeground)",
+						}}>
+						When enabled, Cline will automatically perform browser actions without requiring
+						you to click the Approve button.
+					</p>
+				</div>
 
 				{IS_DEV && (
 					<>

webview-ui/src/context/ExtensionStateContext.tsx

@@ -22,6 +22,7 @@ export interface ExtensionStateContextType extends ExtensionState {
 	setAlwaysAllowReadOnly: (value: boolean) => void
 	setAlwaysAllowWrite: (value: boolean) => void
 	setAlwaysAllowExecute: (value: boolean) => void
+	setAlwaysAllowBrowser: (value: boolean) => void
 	setShowAnnouncement: (value: boolean) => void
 }
 
@@ -59,7 +60,7 @@ export const ExtensionStateContextProvider: React.FC<{ children: React.ReactNode
 							config.lmStudioModelId,
 							config.geminiApiKey,
 							config.openAiNativeApiKey,
-					  ].some((key) => key !== undefined)
+						].some((key) => key !== undefined)
 					: false
 				setShowWelcome(!hasKey)
 				setDidHydrateState(true)
@@ -118,6 +119,7 @@ export const ExtensionStateContextProvider: React.FC<{ children: React.ReactNode
 		setAlwaysAllowReadOnly: (value) => setState((prevState) => ({ ...prevState, alwaysAllowReadOnly: value })),
 		setAlwaysAllowWrite: (value) => setState((prevState) => ({ ...prevState, alwaysAllowWrite: value })),
 		setAlwaysAllowExecute: (value) => setState((prevState) => ({ ...prevState, alwaysAllowExecute: value })),
+		setAlwaysAllowBrowser: (value) => setState((prevState) => ({ ...prevState, alwaysAllowBrowser: value })),
 		setShowAnnouncement: (value) => setState((prevState) => ({ ...prevState, shouldShowAnnouncement: value })),
 	}
 

webview-ui/src/index.tsx

@@ -9,7 +9,7 @@ const root = ReactDOM.createRoot(document.getElementById("root") as HTMLElement)
 root.render(
 	<React.StrictMode>
 		<App />
-	</React.StrictMode>
+	</React.StrictMode>,
 )
 
 // If you want to start measuring performance in your app, pass a function

webview-ui/src/utils/context-mentions.ts

@@ -3,7 +3,7 @@ import { mentionRegex } from "../../../src/shared/context-mentions"
 export function insertMention(
 	text: string,
 	position: number,
-	value: string
+	value: string,
 ): { newValue: string; mentionIndex: number } {
 	const beforeCursor = text.slice(0, position)
 	const afterCursor = text.slice(position)
@@ -62,7 +62,7 @@ export interface ContextMenuQueryItem {
 export function getContextMenuOptions(
 	query: string,
 	selectedType: ContextMenuOptionType | null = null,
-	queryItems: ContextMenuQueryItem[]
+	queryItems: ContextMenuQueryItem[],
 ): ContextMenuQueryItem[] {
 	if (query === "") {
 		if (selectedType === ContextMenuOptionType.File) {

webview-ui/src/utils/textMateToHljs.ts

@@ -100,7 +100,7 @@ function fallbackTheme() {
 				".hljs-string": "#a31515",
 				".hljs-meta .hljs-string": "#a31515",
 				".hljs-params": "#001080",
-		  }
+			}
 		: {
 				".hljs-comment": "#6A9955",
 				".hljs-doctag": "#569cd6",
@@ -128,7 +128,7 @@ function fallbackTheme() {
 				".hljs-string": "#ce9178",
 				".hljs-meta .hljs-string": "#ce9178",
 				".hljs-params": "#9CDCFE",
-		  }
+			}
 }
 
 export function convertTextMateToHljs(fullColorTheme: any) {

webview-ui/src/utils/validate.ts

@@ -59,7 +59,7 @@ export function validateApiConfiguration(apiConfiguration?: ApiConfiguration): s
 
 export function validateModelId(
 	apiConfiguration?: ApiConfiguration,
-	openRouterModels?: Record<string, ModelInfo>
+	openRouterModels?: Record<string, ModelInfo>,
 ): string | undefined {
 	if (apiConfiguration) {
 		switch (apiConfiguration.apiProvider) {