update system prompt, we use this cline prompt system

src/core/prompts/responses.ts

@@ -0,0 +1,136 @@
+import { Anthropic } from "@anthropic-ai/sdk"
+import * as diff from "diff"
+import * as path from "path"
+
+export const formatResponse = {
+	toolDenied: () => `The user denied this operation.`,
+
+	toolDeniedWithFeedback: (feedback?: string) =>
+		`The user denied this operation and provided the following feedback:\n<feedback>\n${feedback}\n</feedback>`,
+
+	toolApprovedWithFeedback: (feedback?: string) =>
+		`The user approved this operation and provided the following context:\n<feedback>\n${feedback}\n</feedback>`,
+
+	toolError: (error?: string) => `The tool execution failed with the following error:\n<error>\n${error}\n</error>`,
+
+	noToolsUsed: () =>
+		`[ERROR] You did not use a tool in your previous response! Please retry with a tool use.
+
+${toolUseInstructionsReminder}
+
+# Next Steps
+
+If you have completed the user's task, use the attempt_completion tool. 
+If you require additional information from the user, use the ask_followup_question tool. 
+Otherwise, if you have not completed the task and do not need additional information, then proceed with the next step of the task. 
+(This is an automated message, so do not respond to it conversationally.)`,
+
+	tooManyMistakes: (feedback?: string) =>
+		`You seem to be having trouble proceeding. The user has provided the following feedback to help guide you:\n<feedback>\n${feedback}\n</feedback>`,
+
+	missingToolParameterError: (paramName: string) =>
+		`Missing value for required parameter '${paramName}'. Please retry with complete response.\n\n${toolUseInstructionsReminder}`,
+
+	invalidMcpToolArgumentError: (serverName: string, toolName: string) =>
+		`Invalid JSON argument used with ${serverName} for ${toolName}. Please retry with a properly formatted JSON argument.`,
+
+	toolResult: (
+		text: string,
+		images?: string[],
+	): string | Array<Anthropic.TextBlockParam | Anthropic.ImageBlockParam> => {
+		if (images && images.length > 0) {
+			const textBlock: Anthropic.TextBlockParam = { type: "text", text }
+			const imageBlocks: Anthropic.ImageBlockParam[] = formatImagesIntoBlocks(images)
+			// Placing images after text leads to better results
+			return [textBlock, ...imageBlocks]
+		} else {
+			return text
+		}
+	},
+
+	imageBlocks: (images?: string[]): Anthropic.ImageBlockParam[] => {
+		return formatImagesIntoBlocks(images)
+	},
+
+	formatFilesList: (absolutePath: string, files: string[], didHitLimit: boolean): string => {
+		const sorted = files
+			.map((file) => {
+				// convert absolute path to relative path
+				const relativePath = path.relative(absolutePath, file).toPosix()
+				return file.endsWith("/") ? relativePath + "/" : relativePath
+			})
+			// Sort so files are listed under their respective directories to make it clear what files are children of what directories. Since we build file list top down, even if file list is truncated it will show directories that cline can then explore further.
+			.sort((a, b) => {
+				const aParts = a.split("/") // only works if we use toPosix first
+				const bParts = b.split("/")
+				for (let i = 0; i < Math.min(aParts.length, bParts.length); i++) {
+					if (aParts[i] !== bParts[i]) {
+						// If one is a directory and the other isn't at this level, sort the directory first
+						if (i + 1 === aParts.length && i + 1 < bParts.length) {
+							return -1
+						}
+						if (i + 1 === bParts.length && i + 1 < aParts.length) {
+							return 1
+						}
+						// Otherwise, sort alphabetically
+						return aParts[i].localeCompare(bParts[i], undefined, { numeric: true, sensitivity: "base" })
+					}
+				}
+				// If all parts are the same up to the length of the shorter path,
+				// the shorter one comes first
+				return aParts.length - bParts.length
+			})
+		if (didHitLimit) {
+			return `${sorted.join(
+				"\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."
+		} else {
+			return sorted.join("\n")
+		}
+	},
+
+	createPrettyPatch: (filename = "file", oldStr?: string, newStr?: string) => {
+		// strings cannot be undefined or diff throws exception
+		const patch = diff.createPatch(filename.toPosix(), oldStr || "", newStr || "")
+		const lines = patch.split("\n")
+		const prettyPatchLines = lines.slice(4)
+		return prettyPatchLines.join("\n")
+	},
+}
+
+// to avoid circular dependency
+const formatImagesIntoBlocks = (images?: string[]): Anthropic.ImageBlockParam[] => {
+	return images
+		? images.map((dataUrl) => {
+				// data:image/png;base64,base64string
+				const [rest, base64] = dataUrl.split(",")
+				const mimeType = rest.split(":")[1].split(";")[0]
+				return {
+					type: "image",
+					source: { type: "base64", media_type: mimeType, data: base64 },
+				} as Anthropic.ImageBlockParam
+			})
+		: []
+}
+
+const toolUseInstructionsReminder = `# Reminder: Instructions for Tool Use
+
+Tool uses are formatted using XML-style tags. The tool name is enclosed in opening and closing tags, and each parameter is similarly enclosed within its own set of tags. Here's the structure:
+
+<tool_name>
+<parameter1_name>value1</parameter1_name>
+<parameter2_name>value2</parameter2_name>
+...
+</tool_name>
+
+For example:
+
+<attempt_completion>
+<result>
+I have completed the task...
+</result>
+</attempt_completion>
+
+Always adhere to this format for all tool uses to ensure proper parsing and execution.`

src/core/prompts/sections/capabilities.ts

@@ -0,0 +1,19 @@
+export function getCapabilitiesSection(
+	cwd: string,
+	searchTool: string, 
+): string {
+
+	const searchInstructions = searchTool === 'regex'
+	? "\n- You can use regex_search_files to perform pattern-based searches across files using regular expressions. This tool is ideal for finding exact text matches, specific patterns (like tags, links, dates, URLs), or structural elements in notes. It excels at locating precise format patterns and is perfect for finding connections between notes, frontmatter elements, or specific Markdown formatting."
+	: searchTool === 'semantic'
+		? "\n- You can use semantic_search_files to find content based on meaning rather than exact text matches. Semantic search uses embedding vectors to understand concepts and ideas, finding relevant content even when keywords differ. This is especially powerful for discovering thematically related notes, answering conceptual questions about your knowledge base, or finding content when you don't know the exact wording used in the notes."
+		: "";
+
+	return `====
+
+CAPABILITIES
+
+- You have access to tools that let you list files, search content, read and write files, and ask follow-up questions. These tools help you effectively accomplish a wide range of tasks, such as creating notes, making edits or improvements to existing notes, understanding the current state of an Obsidian vault, and much more.
+- When the user initially gives you a task, environment_details will include a list of all files in the current Obsidian folder ('${cwd}'). This file list provides an overview of the vault structure, offering key insights into how knowledge is organized through directory and file names, as well as what file formats are being used. This information can guide your decision-making on which notes might be most relevant to explore further. If you need to explore directories outside the current folder, you can use the list_files tool. If you pass 'true' for the recursive parameter, it will list files recursively. Otherwise, it will list only files at the top level, which is better suited for generic directories where you don't necessarily need the nested structure.${searchInstructions}
+`
+}

src/core/prompts/sections/custom-instructions.ts

@@ -0,0 +1,95 @@
+import fs from "fs/promises"
+import path from "path"
+
+async function safeReadFile(filePath: string): Promise<string> {
+	try {
+		const content = await fs.readFile(filePath, "utf-8")
+		return content.trim()
+	} catch (err) {
+		const errorCode = (err as NodeJS.ErrnoException).code
+		if (!errorCode || !["ENOENT", "EISDIR"].includes(errorCode)) {
+			throw err
+		}
+		return ""
+	}
+}
+
+export async function loadRuleFiles(cwd: string): Promise<string> {
+	const ruleFiles = [".clinerules", ".cursorrules", ".windsurfrules"]
+	let combinedRules = ""
+
+	for (const file of ruleFiles) {
+		const content = await safeReadFile(path.join(cwd, file))
+		if (content) {
+			combinedRules += `\n# Rules from ${file}:\n${content}\n`
+		}
+	}
+
+	return combinedRules
+}
+
+export async function addCustomInstructions(
+	modeCustomInstructions: string,
+	globalCustomInstructions: string,
+	cwd: string,
+	mode: string,
+	options: { preferredLanguage?: string } = {},
+): Promise<string> {
+	const sections = []
+
+	// Load mode-specific rules if mode is provided
+	let modeRuleContent = ""
+	if (mode) {
+		const modeRuleFile = `.clinerules-${mode}`
+		modeRuleContent = await safeReadFile(path.join(cwd, modeRuleFile))
+	}
+
+	// Add language preference if provided
+	if (options.preferredLanguage) {
+		sections.push(
+			`Language Preference:\nYou should always speak and think in the ${options.preferredLanguage} language.`,
+		)
+	}
+
+	// Add global instructions first
+	if (typeof globalCustomInstructions === "string" && globalCustomInstructions.trim()) {
+		sections.push(`Global Instructions:\n${globalCustomInstructions.trim()}`)
+	}
+
+	// Add mode-specific instructions after
+	if (typeof modeCustomInstructions === "string" && modeCustomInstructions.trim()) {
+		sections.push(`Mode-specific Instructions:\n${modeCustomInstructions.trim()}`)
+	}
+
+	// Add rules - include both mode-specific and generic rules if they exist
+	const rules = []
+
+	// Add mode-specific rules first if they exist
+	if (modeRuleContent && modeRuleContent.trim()) {
+		const modeRuleFile = `.clinerules-${mode}`
+		rules.push(`# Rules from ${modeRuleFile}:\n${modeRuleContent}`)
+	}
+
+	// Add generic rules
+	const genericRuleContent = await loadRuleFiles(cwd)
+	if (genericRuleContent && genericRuleContent.trim()) {
+		rules.push(genericRuleContent.trim())
+	}
+
+	if (rules.length > 0) {
+		sections.push(`Rules:\n\n${rules.join("\n\n")}`)
+	}
+
+	const joinedSections = sections.join("\n\n")
+
+	return joinedSections
+		? `
+====
+
+USER'S CUSTOM INSTRUCTIONS
+
+The following additional instructions are provided by the user, and should be followed to the best of your ability without interfering with the TOOL USE guidelines.
+
+${joinedSections}`
+		: ""
+}

src/core/prompts/sections/custom-system-prompt.ts

@@ -0,0 +1,60 @@
+import fs from "fs/promises"
+import path from "path"
+import { Mode } from "../../../shared/modes"
+import { fileExistsAtPath } from "../../../utils/fs"
+
+/**
+ * Safely reads a file, returning an empty string if the file doesn't exist
+ */
+async function safeReadFile(filePath: string): Promise<string> {
+	try {
+		const content = await fs.readFile(filePath, "utf-8")
+		// When reading with "utf-8" encoding, content should be a string
+		return content.trim()
+	} catch (err) {
+		const errorCode = (err as NodeJS.ErrnoException).code
+		if (!errorCode || !["ENOENT", "EISDIR"].includes(errorCode)) {
+			throw err
+		}
+		return ""
+	}
+}
+
+/**
+ * Get the path to a system prompt file for a specific mode
+ */
+export function getSystemPromptFilePath(cwd: string, mode: Mode): string {
+	return path.join(cwd, ".roo", `system-prompt-${mode}`)
+}
+
+/**
+ * Loads custom system prompt from a file at .roo/system-prompt-[mode slug]
+ * If the file doesn't exist, returns an empty string
+ */
+export async function loadSystemPromptFile(cwd: string, mode: Mode): Promise<string> {
+	const filePath = getSystemPromptFilePath(cwd, mode)
+	return safeReadFile(filePath)
+}
+
+/**
+ * Ensures the .roo directory exists, creating it if necessary
+ */
+export async function ensureRooDirectory(cwd: string): Promise<void> {
+	const rooDir = path.join(cwd, ".roo")
+
+	// Check if directory already exists
+	if (await fileExistsAtPath(rooDir)) {
+		return
+	}
+
+	// Create the directory
+	try {
+		await fs.mkdir(rooDir, { recursive: true })
+	} catch (err) {
+		// If directory already exists (race condition), ignore the error
+		const errorCode = (err as NodeJS.ErrnoException).code
+		if (errorCode !== "EEXIST") {
+			throw err
+		}
+	}
+}

src/core/prompts/sections/index.ts

@@ -0,0 +1,9 @@
+export { getRulesSection } from "./rules"
+export { getSystemInfoSection } from "./system-info"
+export { getObjectiveSection } from "./objective"
+export { addCustomInstructions } from "./custom-instructions"
+export { getSharedToolUseSection } from "./tool-use"
+export { getMcpServersSection } from "./mcp-servers"
+export { getToolUseGuidelinesSection } from "./tool-use-guidelines"
+export { getCapabilitiesSection } from "./capabilities"
+export { getModesSection } from "./modes"

src/core/prompts/sections/mcp-servers.ts

@@ -0,0 +1,427 @@
+import { DiffStrategy } from "../../diff/DiffStrategy"
+import { McpHub } from "../../mcp/McpHub"
+
+export async function getMcpServersSection(
+	mcpHub?: McpHub,
+	diffStrategy?: DiffStrategy,
+	enableMcpServerCreation?: boolean,
+): Promise<string> {
+	if (!mcpHub) {
+		return ""
+	}
+
+	const connectedServers =
+		mcpHub.getServers().length > 0
+			? `${mcpHub
+					.getServers()
+					.filter((server) => server.status === "connected")
+					.map((server) => {
+						const tools = server.tools
+							?.map((tool) => {
+								const schemaStr = tool.inputSchema
+									? `    Input Schema:
+    ${JSON.stringify(tool.inputSchema, null, 2).split("\n").join("\n    ")}`
+									: ""
+
+								return `- ${tool.name}: ${tool.description}\n${schemaStr}`
+							})
+							.join("\n\n")
+
+						const templates = server.resourceTemplates
+							?.map((template) => `- ${template.uriTemplate} (${template.name}): ${template.description}`)
+							.join("\n")
+
+						const resources = server.resources
+							?.map((resource) => `- ${resource.uri} (${resource.name}): ${resource.description}`)
+							.join("\n")
+
+						const config = JSON.parse(server.config)
+
+						return (
+							`## ${server.name} (\`${config.command}${config.args && Array.isArray(config.args) ? ` ${config.args.join(" ")}` : ""}\`)` +
+							(tools ? `\n\n### Available Tools\n${tools}` : "") +
+							(templates ? `\n\n### Resource Templates\n${templates}` : "") +
+							(resources ? `\n\n### Direct Resources\n${resources}` : "")
+						)
+					})
+					.join("\n\n")}`
+			: "(No MCP servers currently connected)"
+
+	const baseSection = `MCP SERVERS
+
+The Model Context Protocol (MCP) enables communication between the system and locally running MCP servers that provide additional tools and resources to extend your capabilities.
+
+# Connected MCP Servers
+
+When a server is connected, you can use the server's tools via the \`use_mcp_tool\` tool, and access the server's resources via the \`access_mcp_resource\` tool.
+
+${connectedServers}`
+
+	if (!enableMcpServerCreation) {
+		return baseSection
+	}
+
+	return (
+		baseSection +
+		`
+
+## Creating an MCP Server
+
+The user may ask you something along the lines of "add a tool" that does some function, in other words to create an MCP server that provides tools and resources that may connect to external APIs for example. You have the ability to create an MCP server and add it to a configuration file that will then expose the tools and resources for you to use with \`use_mcp_tool\` and \`access_mcp_resource\`.
+
+When creating MCP servers, it's important to understand that they operate in a non-interactive environment. The server cannot initiate OAuth flows, open browser windows, or prompt for user input during runtime. All credentials and authentication tokens must be provided upfront through environment variables in the MCP settings configuration. For example, Spotify's API uses OAuth to get a refresh token for the user, but the MCP server cannot initiate this flow. While you can walk the user through obtaining an application client ID and secret, you may have to create a separate one-time setup script (like get-refresh-token.js) that captures and logs the final piece of the puzzle: the user's refresh token (i.e. you might run the script using execute_command which would open a browser for authentication, and then log the refresh token so that you can see it in the command output for you to use in the MCP settings configuration).
+
+Unless the user specifies otherwise, new MCP servers should be created in: ${await mcpHub.getMcpServersPath()}
+
+### Example MCP Server
+
+For example, if the user wanted to give you the ability to retrieve weather information, you could create an MCP server that uses the OpenWeather API to get weather information, add it to the MCP settings configuration file, and then notice that you now have access to new tools and resources in the system prompt that you might use to show the user your new capabilities.
+
+The following example demonstrates how to build an MCP server that provides weather data functionality. While this example shows how to implement resources, resource templates, and tools, in practice you should prefer using tools since they are more flexible and can handle dynamic parameters. The resource and resource template implementations are included here mainly for demonstration purposes of the different MCP capabilities, but a real weather server would likely just expose tools for fetching weather data. (The following steps are for macOS)
+
+1. Use the \`create-typescript-server\` tool to bootstrap a new project in the default MCP servers directory:
+
+\`\`\`bash
+cd ${await mcpHub.getMcpServersPath()}
+npx @modelcontextprotocol/create-server weather-server
+cd weather-server
+# Install dependencies
+npm install axios
+\`\`\`
+
+This will create a new project with the following structure:
+
+\`\`\`
+weather-server/
+  ├── package.json
+      {
+        ...
+        "type": "module", // added by default, uses ES module syntax (import/export) rather than CommonJS (require/module.exports) (Important to know if you create additional scripts in this server repository like a get-refresh-token.js script)
+        "scripts": {
+          "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
+          ...
+        }
+        ...
+      }
+  ├── tsconfig.json
+  └── src/
+      └── weather-server/
+          └── index.ts      # Main server implementation
+\`\`\`
+
+2. Replace \`src/index.ts\` with the following:
+
+\`\`\`typescript
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ErrorCode,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ListToolsRequestSchema,
+  McpError,
+  ReadResourceRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import axios from 'axios';
+
+const API_KEY = process.env.OPENWEATHER_API_KEY; // provided by MCP config
+if (!API_KEY) {
+  throw new Error('OPENWEATHER_API_KEY environment variable is required');
+}
+
+interface OpenWeatherResponse {
+  main: {
+    temp: number;
+    humidity: number;
+  };
+  weather: [{ description: string }];
+  wind: { speed: number };
+  dt_txt?: string;
+}
+
+const isValidForecastArgs = (
+  args: any
+): args is { city: string; days?: number } =>
+  typeof args === 'object' &&
+  args !== null &&
+  typeof args.city === 'string' &&
+  (args.days === undefined || typeof args.days === 'number');
+
+class WeatherServer {
+  private server: Server;
+  private axiosInstance;
+
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'example-weather-server',
+        version: '0.1.0',
+      },
+      {
+        capabilities: {
+          resources: {},
+          tools: {},
+        },
+      }
+    );
+
+    this.axiosInstance = axios.create({
+      baseURL: 'http://api.openweathermap.org/data/2.5',
+      params: {
+        appid: API_KEY,
+        units: 'metric',
+      },
+    });
+
+    this.setupResourceHandlers();
+    this.setupToolHandlers();
+    
+    // Error handling
+    this.server.onerror = (error) => console.error('[MCP Error]', error);
+    process.on('SIGINT', async () => {
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+
+  // MCP Resources represent any kind of UTF-8 encoded data that an MCP server wants to make available to clients, such as database records, API responses, log files, and more. Servers define direct resources with a static URI or dynamic resources with a URI template that follows the format \`[protocol]://[host]/[path]\`.
+  private setupResourceHandlers() {
+    // For static resources, servers can expose a list of resources:
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+      resources: [
+        // This is a poor example since you could use the resource template to get the same information but this demonstrates how to define a static resource
+        {
+          uri: \`weather://San Francisco/current\`, // Unique identifier for San Francisco weather resource
+          name: \`Current weather in San Francisco\`, // Human-readable name
+          mimeType: 'application/json', // Optional MIME type
+          // Optional description
+          description:
+            'Real-time weather data for San Francisco including temperature, conditions, humidity, and wind speed',
+        },
+      ],
+    }));
+
+    // For dynamic resources, servers can expose resource templates:
+    this.server.setRequestHandler(
+      ListResourceTemplatesRequestSchema,
+      async () => ({
+        resourceTemplates: [
+          {
+            uriTemplate: 'weather://{city}/current', // URI template (RFC 6570)
+            name: 'Current weather for a given city', // Human-readable name
+            mimeType: 'application/json', // Optional MIME type
+            description: 'Real-time weather data for a specified city', // Optional description
+          },
+        ],
+      })
+    );
+
+    // ReadResourceRequestSchema is used for both static resources and dynamic resource templates
+    this.server.setRequestHandler(
+      ReadResourceRequestSchema,
+      async (request) => {
+        const match = request.params.uri.match(
+          /^weather:\/\/([^/]+)\/current$/
+        );
+        if (!match) {
+          throw new McpError(
+            ErrorCode.InvalidRequest,
+            \`Invalid URI format: \${request.params.uri}\`
+          );
+        }
+        const city = decodeURIComponent(match[1]);
+
+        try {
+          const response = await this.axiosInstance.get(
+            'weather', // current weather
+            {
+              params: { q: city },
+            }
+          );
+
+          return {
+            contents: [
+              {
+                uri: request.params.uri,
+                mimeType: 'application/json',
+                text: JSON.stringify(
+                  {
+                    temperature: response.data.main.temp,
+                    conditions: response.data.weather[0].description,
+                    humidity: response.data.main.humidity,
+                    wind_speed: response.data.wind.speed,
+                    timestamp: new Date().toISOString(),
+                  },
+                  null,
+                  2
+                ),
+              },
+            ],
+          };
+        } catch (error) {
+          if (axios.isAxiosError(error)) {
+            throw new McpError(
+              ErrorCode.InternalError,
+              \`Weather API error: \${
+                error.response?.data.message ?? error.message
+              }\`
+            );
+          }
+          throw error;
+        }
+      }
+    );
+  }
+
+  /* MCP Tools enable servers to expose executable functionality to the system. Through these tools, you can interact with external systems, perform computations, and take actions in the real world.
+   * - Like resources, tools are identified by unique names and can include descriptions to guide their usage. However, unlike resources, tools represent dynamic operations that can modify state or interact with external systems.
+   * - While resources and tools are similar, you should prefer to create tools over resources when possible as they provide more flexibility.
+   */
+  private setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: 'get_forecast', // Unique identifier
+          description: 'Get weather forecast for a city', // Human-readable description
+          inputSchema: {
+            // JSON Schema for parameters
+            type: 'object',
+            properties: {
+              city: {
+                type: 'string',
+                description: 'City name',
+              },
+              days: {
+                type: 'number',
+                description: 'Number of days (1-5)',
+                minimum: 1,
+                maximum: 5,
+              },
+            },
+            required: ['city'], // Array of required property names
+          },
+        },
+      ],
+    }));
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      if (request.params.name !== 'get_forecast') {
+        throw new McpError(
+          ErrorCode.MethodNotFound,
+          \`Unknown tool: \${request.params.name}\`
+        );
+      }
+
+      if (!isValidForecastArgs(request.params.arguments)) {
+        throw new McpError(
+          ErrorCode.InvalidParams,
+          'Invalid forecast arguments'
+        );
+      }
+
+      const city = request.params.arguments.city;
+      const days = Math.min(request.params.arguments.days || 3, 5);
+
+      try {
+        const response = await this.axiosInstance.get<{
+          list: OpenWeatherResponse[];
+        }>('forecast', {
+          params: {
+            q: city,
+            cnt: days * 8,
+          },
+        });
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(response.data.list, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        if (axios.isAxiosError(error)) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: \`Weather API error: \${
+                  error.response?.data.message ?? error.message
+                }\`,
+              },
+            ],
+            isError: true,
+          };
+        }
+        throw error;
+      }
+    });
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error('Weather MCP server running on stdio');
+  }
+}
+
+const server = new WeatherServer();
+server.run().catch(console.error);
+\`\`\`
+
+(Remember: This is just an example–you may use different dependencies, break the implementation up into multiple files, etc.)
+
+3. Build and compile the executable JavaScript file
+
+\`\`\`bash
+npm run build
+\`\`\`
+
+4. Whenever you need an environment variable such as an API key to configure the MCP server, walk the user through the process of getting the key. For example, they may need to create an account and go to a developer dashboard to generate the key. Provide step-by-step instructions and URLs to make it easy for the user to retrieve the necessary information. Then use the ask_followup_question tool to ask the user for the key, in this case the OpenWeather API key.
+
+5. Install the MCP Server by adding the MCP server configuration to the settings file located at '${await mcpHub.getMcpSettingsFilePath()}'. The settings file may have other MCP servers already configured, so you would read it first and then add your new server to the existing \`mcpServers\` object.
+
+IMPORTANT: Regardless of what else you see in the MCP settings file, you must default any new MCP servers you create to disabled=false and alwaysAllow=[].
+
+\`\`\`json
+{
+  "mcpServers": {
+    ...,
+    "weather": {
+      "command": "node",
+      "args": ["/path/to/weather-server/build/index.js"],
+      "env": {
+        "OPENWEATHER_API_KEY": "user-provided-api-key"
+      }
+    },
+  }
+}
+\`\`\`
+
+(Note: the user may also ask you to install the MCP server to the Claude desktop app, in which case you would read then modify \`~/Library/Application\ Support/Claude/claude_desktop_config.json\` on macOS for example. It follows the same format of a top level \`mcpServers\` object.)
+
+6. After you have edited the MCP settings configuration file, the system will automatically run all the servers and expose the available tools and resources in the 'Connected MCP Servers' section.
+
+7. Now that you have access to these new tools and resources, you may suggest ways the user can command you to invoke them - for example, with this new weather tool now available, you can invite the user to ask "what's the weather in San Francisco?"
+
+## Editing MCP Servers
+
+The user may ask to add tools or resources that may make sense to add to an existing MCP server (listed under 'Connected MCP Servers' above: ${
+			mcpHub
+				.getServers()
+				.map((server) => server.name)
+				.join(", ") || "(None running currently)"
+		}, e.g. if it would use the same API. This would be possible if you can locate the MCP server repository on the user's system by looking at the server arguments for a filepath. You might then use list_files and read_file to explore the files in the repository, and use write_to_file${diffStrategy ? " or apply_diff" : ""} to make changes to the files.
+
+However some MCP servers may be running from installed packages rather than a local repository, in which case it may make more sense to create a new MCP server.
+
+# MCP Servers Are Not Always Necessary
+
+The user may not always request the use or creation of MCP servers. Instead, they might provide tasks that can be completed with existing tools. While using the MCP SDK to extend your capabilities can be useful, it's important to understand that this is just one specialized type of task you can accomplish. You should only implement MCP servers when the user explicitly requests it (e.g., "add a tool that...").
+
+Remember: The MCP documentation and example provided above are to help you understand and work with existing MCP servers or create new ones when requested by the user. You already have access to tools and capabilities that can be used to accomplish a wide range of tasks.`
+	)
+}

src/core/prompts/sections/modes.ts

@@ -0,0 +1,60 @@
+import { promises as fs } from "fs"
+import * as path from "path"
+import * as vscode from "vscode"
+
+import { ModeConfig, getAllModesWithPrompts } from "../../../utils/modes"
+
+export async function getModesSection(context: vscode.ExtensionContext): Promise<string> {
+	const settingsDir = path.join(context.globalStorageUri.fsPath, "settings")
+	await fs.mkdir(settingsDir, { recursive: true })
+	const customModesPath = path.join(settingsDir, "cline_custom_modes.json")
+
+	// Get all modes with their overrides from extension state
+	const allModes = await getAllModesWithPrompts(context)
+
+	return `====
+
+MODES
+
+- These are the currently available modes:
+${allModes.map((mode: ModeConfig) => `  * "${mode.name}" mode (${mode.slug}) - ${mode.roleDefinition.split(".")[0]}`).join("\n")}
+
+- Custom modes can be configured in two ways:
+  1. Globally via '${customModesPath}' (created automatically on startup)
+  2. Per-workspace via '.roomodes' in the workspace root directory
+
+  When modes with the same slug exist in both files, the workspace-specific .roomodes version takes precedence. This allows projects to override global modes or define project-specific modes.
+
+  If asked to create a project mode, create it in .roomodes in the workspace root. If asked to create a global mode, use the global custom modes file.
+
+- The following fields are required and must not be empty:
+  * slug: A valid slug (lowercase letters, numbers, and hyphens). Must be unique, and shorter is better.
+  * name: The display name for the mode
+  * roleDefinition: A detailed description of the mode's role and capabilities
+  * groups: Array of allowed tool groups (can be empty). Each group can be specified either as a string (e.g., "edit" to allow editing any file) or with file restrictions (e.g., ["edit", { fileRegex: "\\.md$", description: "Markdown files only" }] to only allow editing markdown files)
+
+- The customInstructions field is optional.
+
+- For multi-line text, include newline characters in the string like "This is the first line.\\nThis is the next line.\\n\\nThis is a double line break."
+
+Both files should follow this structure:
+{
+ "customModes": [
+   {
+     "slug": "designer", // Required: unique slug with lowercase letters, numbers, and hyphens
+     "name": "Designer", // Required: mode display name
+     "roleDefinition": "You are Infio, a UI/UX expert specializing in design systems and frontend development. Your expertise includes:\\n- Creating and maintaining design systems\\n- Implementing responsive and accessible web interfaces\\n- Working with CSS, HTML, and modern frontend frameworks\\n- Ensuring consistent user experiences across platforms", // Required: non-empty
+     "groups": [ // Required: array of tool groups (can be empty)
+       "read",    // Read files group (read_file, search_files, list_files)
+       "edit",    // Edit files group (apply_diff, write_to_file) - allows editing any file
+       // Or with file restrictions:
+       // ["edit", { fileRegex: "\\.md$", description: "Markdown files only" }],  // Edit group that only allows editing markdown files
+       "browser", // Browser group (browser_action)
+       "command", // Command group (execute_command)
+       "mcp"     // MCP group (use_mcp_tool, access_mcp_resource)
+     ],
+     "customInstructions": "Additional instructions for the Designer mode" // Optional
+    }
+  ]
+}`
+}

src/core/prompts/sections/objective.ts

@@ -0,0 +1,12 @@
+export function getObjectiveSection(): string {
+	return `====
+
+OBJECTIVE
+
+You accomplish a given task iteratively, breaking it down into clear steps and working through them methodically.
+
+1. Analyze the user's task and set clear, achievable goals to accomplish it. Prioritize these goals in a logical order.
+2. Work through these goals sequentially, utilizing available tools one at a time as necessary. Each goal should correspond to a distinct step in your problem-solving process. You will be informed on the work completed and what's remaining as you go.
+3. Remember, you have extensive capabilities with access to a wide range of tools that can be used in powerful and clever ways as necessary to accomplish each goal. Before calling a tool, do some analysis within <thinking></thinking> tags. First, analyze the file structure provided in environment_details to gain context and insights for proceeding effectively. Then, think about which of the provided tools is the most relevant tool to accomplish the user's task. Next, go through each of the required parameters of the relevant tool and determine if the user has directly provided or given enough information to infer a value. When deciding if the parameter can be inferred, carefully consider all the context to see if it supports a specific value. If all of the required parameters are present or can be reasonably inferred, close the thinking tag and proceed with the tool use. BUT, if one of the values for a required parameter is missing, DO NOT invoke the tool (not even with fillers for the missing params) and instead, ask the user to provide the missing parameters using the ask_followup_question tool. DO NOT ask for more information on optional parameters if it is not provided.
+4. The user may provide feedback, which you can use to make improvements and try again. But DO NOT continue in pointless back and forth conversations, i.e. don't end your responses with questions or offers for further assistance.`
+}

src/core/prompts/sections/rules.ts

@@ -0,0 +1,90 @@
+import { DiffStrategy } from "../../diff/DiffStrategy"
+
+function getEditingInstructions(diffStrategy?: DiffStrategy, experiments?: Record<string, boolean>): string {
+	const instructions: string[] = []
+	const availableTools: string[] = []
+
+	// Collect available editing tools
+	if (diffStrategy) {
+		availableTools.push(
+			"apply_diff (for replacing lines in existing documents)",
+			"write_to_file (for creating new documents or complete document rewrites)",
+		)
+	} else {
+		availableTools.push("write_to_file (for creating new documents or complete document rewrites)")
+	}
+	if (experiments?.["insert_content"]) {
+		availableTools.push("insert_content (for adding lines to existing documents)")
+	}
+	if (experiments?.["search_and_replace"]) {
+		availableTools.push("search_and_replace (for finding and replacing individual pieces of text)")
+	}
+
+	// Base editing instruction mentioning all available tools
+	if (availableTools.length > 1) {
+		instructions.push(`- For editing documents, you have access to these tools: ${availableTools.join(", ")}.`)
+	}
+
+	// Additional details for experimental features
+	if (experiments?.["insert_content"]) {
+		instructions.push(
+			"- The insert_content tool adds lines of text to documents, such as adding a new paragraph to a document or inserting a new section in a paper. This tool will insert it at the specified line location. It can support multiple operations at once.",
+		)
+	}
+
+	if (experiments?.["search_and_replace"]) {
+		instructions.push(
+			"- The search_and_replace tool finds and replaces text or regex in documents. This tool allows you to search for a specific regex pattern or text and replace it with another value. Be cautious when using this tool to ensure you are replacing the correct text. It can support multiple operations at once.",
+		)
+	}
+
+	if (availableTools.length > 1) {
+		instructions.push(
+			"- You should always prefer using other editing tools over write_to_file when making changes to existing documents since write_to_file is much slower and cannot handle large files.",
+		)
+	}
+
+	instructions.push(
+		"- When using the write_to_file tool to modify a note, use the tool directly with the desired content. You do not need to display the content before using the tool. ALWAYS provide the COMPLETE file content in your response. This is NON-NEGOTIABLE. Partial updates or placeholders like '// remainder of the note unchanged' are STRICTLY FORBIDDEN. You MUST include ALL parts of the file, even if they haven't been modified. Failure to do so will result in incomplete or broken notes, severely impacting the user's knowledge base.",
+	)
+
+	return instructions.join("\n")
+}
+
+function getSearchInstructions(searchTool: string): string {
+  if (searchTool === 'regex') {
+		return `- When using the regex_search_files tool, craft your regex patterns carefully to balance specificity and flexibility. Based on the user's task, you may use it to find specific content, notes, headings, connections between notes, tags, or any text-based information across the Obsidian vault. The results include context, so analyze the surrounding text to better understand the matches. Leverage the regex_search_files tool in combination with other tools for comprehensive analysis. For example, use it to find specific phrases or patterns, then use read_file to examine the full context of interesting matches before using write_to_file to make informed changes.`
+  } else if (searchTool === 'semantic') {
+		return `- When using the semantic_search_files tool, craft your natural language query to describe concepts and ideas rather than specific patterns. Based on the user's task, you may use it to find thematically related content, conceptually similar notes, or knowledge connections across the Obsidian vault, even when exact keywords aren't present. The results include context, so analyze the surrounding text to understand the conceptual relevance of each match. Leverage the semantic_search_files tool in combination with other tools for comprehensive analysis. For example, use it to find specific phrases or patterns, then use read_file to examine the full context of interesting matches before using write_to_file to make informed changes.`
+  }
+  return ""
+}
+
+export function getRulesSection(
+	cwd: string,
+	searchTool: string,
+	supportsComputerUse: boolean,
+	diffStrategy?: DiffStrategy,
+	experiments?: Record<string, boolean> | undefined,
+): string {
+	return `====
+
+RULES
+
+- Your current obsidian directory is: ${cwd.toPosix()}
+${getSearchInstructions(searchTool)}
+- When creating new notes in Obsidian, organize them according to the existing vault structure unless the user specifies otherwise. Use appropriate file paths when writing files, as the write_to_file tool will automatically create any necessary directories. Structure the content logically, adhering to Obsidian conventions with appropriate frontmatter, headings, lists, and formatting. Unless otherwise specified, new notes should follow Markdown syntax with appropriate use of links ([[note name]]), tags (#tag), callouts, and other Obsidian-specific formatting.
+${getEditingInstructions(diffStrategy, experiments)}
+- Be sure to consider the structure of the Obsidian vault (folders, naming conventions, note organization) when determining the appropriate format and content for new or modified notes. Also consider what files may be most relevant to accomplishing the task, for example examining backlinks, linked mentions, or tags would help you understand the relationships between notes, which you could incorporate into any content you write.
+- When making changes to content, always consider the context within the broader vault. Ensure that your changes maintain existing links, tags, and references, and that they follow the user's established formatting standards and organization.
+- Do not ask for more information than necessary. Use the tools provided to accomplish the user's request efficiently and effectively. When you've completed your task, you must use the attempt_completion tool to present the result to the user. The user may provide feedback, which you can use to make improvements and try again.
+- You are only allowed to ask the user questions using the ask_followup_question tool. Use this tool only when you need additional details to complete a task, and be sure to use a clear and concise question that will help you move forward with the task. However if you can use the available tools to avoid having to ask the user questions, you should do so. For example, if the user mentions a file that may be in an outside directory like the Desktop, you should use the list_files tool to list the files in the Desktop and check if the file they are talking about is there, rather than asking the user to provide the file path themselves.
+- The user may provide a file's contents directly in their message, in which case you shouldn't use the read_file tool to get the file contents again since you already have it.
+- Your goal is to try to accomplish the user's task, NOT engage in a back and forth conversation.
+- NEVER end attempt_completion result with a question or request to engage in further conversation! Formulate the end of your result in a way that is final and does not require further input from the user.
+- You are STRICTLY FORBIDDEN from starting your messages with "Great", "Certainly", "Okay", "Sure". You should NOT be conversational in your responses, but rather direct and to the point. For example you should NOT say "Great, I've updated the markdown" but instead something like "I've updated the markdown". It is important you be clear and technical in your messages.
+- When presented with images, utilize your vision capabilities to thoroughly examine them and extract meaningful information. Incorporate these insights into your thought process as you accomplish the user's task.
+- At the end of each user message, you will automatically receive environment_details. This information is not written by the user themselves, but is auto-generated to provide potentially relevant context about the Obsidian environment. This includes the current file being edited, open tabs, and the vault structure. While this information can be valuable for understanding the context, do not treat it as a direct part of the user's request or response. Use it to inform your actions and decisions, but don't assume the user is explicitly asking about or referring to this information unless they clearly do so in their message. When using environment_details, explain your actions clearly to ensure the user understands, as they may not be aware of these details.
+- Pay special attention to the open tabs in environment_details, as they indicate which notes the user is currently working with and may be most relevant to their task. Similarly, the current file information shows which note is currently in focus and likely the primary subject of the user's request.
+- It is critical you wait for the user's response after each tool use, in order to confirm the success of the tool use. For example, if asked to create a structured note, you would create a file, wait for the user's response it was created successfully, then create another file if needed, wait for the user's response it was created successfully, etc.`
+}

src/core/prompts/sections/system-info.ts

@@ -0,0 +1,34 @@
+import os from "os"
+
+import { Platform } from 'obsidian';
+
+
+export function getSystemInfoSection(cwd: string): string {
+	let platformName = "Unknown"
+	if (Platform.isMacOS) {
+		platformName = "Macos"
+	} else if (Platform.isWin) {
+		platformName = "Windows"
+	} else if (Platform.isLinux) {
+		platformName = "Linux"
+	} else if (Platform.isMobileApp) {
+		if (Platform.isTablet) {
+			platformName = "iPad"
+		} else if (Platform.isPhone) {
+			platformName = "iPhone"
+		} else if (Platform.isAndroidApp) {
+			platformName = "Android"
+		}
+	} else {
+		platformName = "Unknown"
+	}
+	const details = `====
+
+SYSTEM INFORMATION
+
+Platform: ${platformName}
+Current Obsidian Directory: ${cwd.toPosix()}
+`
+
+	return details
+}

src/core/prompts/sections/tool-use-guidelines.ts

@@ -0,0 +1,20 @@
+export function getToolUseGuidelinesSection(): string {
+	return `# Tool Use Guidelines
+
+1. In <thinking> tags, assess what information you already have and what information you need to proceed with the task.
+2. Choose the most appropriate tool based on the task and the tool descriptions provided. Assess if you need additional information to proceed, and which of the available tools would be most effective for gathering this information. It's critical that you think about each available tool and use the one that best fits the current step in the task.
+3. If multiple actions are needed, use one tool at a time per message to accomplish the task iteratively, with each tool use being informed by the result of the previous tool use. Do not assume the outcome of any tool use. Each step must be informed by the previous step's result.
+4. Formulate your tool use using the XML format specified for each tool.
+5. After each tool use, the user will respond with the result of that tool use. This result will provide you with the necessary information to continue your task or make further decisions. This response may include:
+  - Information about whether the tool succeeded or failed, along with any reasons for failure.
+  - Any other relevant feedback or information related to the tool use.
+6. ALWAYS wait for user confirmation after each tool use before proceeding. Never assume the success of a tool use without explicit confirmation of the result from the user.
+
+It is crucial to proceed step-by-step, waiting for the user's message after each tool use before moving forward with the task. This approach allows you to:
+1. Confirm the success of each step before proceeding.
+2. Address any issues or errors that arise immediately.
+3. Adapt your approach based on new information or unexpected results.
+4. Ensure that each action builds correctly on the previous ones.
+
+By waiting for and carefully considering the user's response after each tool use, you can react accordingly and make informed decisions about how to proceed with the task. This iterative process helps ensure the overall success and accuracy of your work.`
+}

src/core/prompts/sections/tool-use.ts

@@ -0,0 +1,25 @@
+export function getSharedToolUseSection(): string {
+	return `====
+
+TOOL USE
+
+You have access to a set of tools that are executed upon the user's approval. You can use one tool per message, and will receive the result of that tool use in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.
+
+# Tool Use Formatting
+
+Tool use is formatted using XML-style tags. The tool name is enclosed in opening and closing tags, and each parameter is similarly enclosed within its own set of tags. Here's the structure:
+
+<tool_name>
+<parameter1_name>value1</parameter1_name>
+<parameter2_name>value2</parameter2_name>
+...
+</tool_name>
+
+For example:
+
+<read_file>
+<path>path/to/file.md</path>
+</read_file>
+
+Always adhere to this format for the tool use to ensure proper parsing and execution.`
+}

src/core/prompts/system.ts

@@ -0,0 +1,156 @@
+import {
+	CustomModePrompts,
+	Mode,
+	ModeConfig,
+	PromptComponent,
+	defaultModeSlug,
+	getGroupName,
+	getModeBySlug,
+	modes
+} from "../../utils/modes"
+import { DiffStrategy } from "../diff/DiffStrategy"
+import { McpHub } from "../mcp/McpHub"
+
+import {
+	addCustomInstructions,
+	getCapabilitiesSection,
+	getMcpServersSection,
+	// getModesSection,
+	getObjectiveSection,
+	getRulesSection,
+	getSharedToolUseSection,
+	getSystemInfoSection,
+	getToolUseGuidelinesSection,
+} from "./sections"
+import { getToolDescriptionsForMode } from "./tools"
+
+async function generatePrompt(
+	cwd: string,
+	supportsComputerUse: boolean,
+	mode: Mode,
+	mcpHub?: McpHub,
+	diffStrategy?: DiffStrategy,
+	browserViewportSize?: string,
+	promptComponent?: PromptComponent,
+	customModeConfigs?: ModeConfig[],
+	globalCustomInstructions?: string,
+	preferredLanguage?: string,
+	diffEnabled?: boolean,
+	experiments?: Record<string, boolean>,
+	enableMcpServerCreation?: boolean,
+): Promise<string> {
+	// if (!context) {
+	// 	throw new Error("Extension context is required for generating system prompt")
+	// }
+
+	const searchTool = "semantic"
+	
+	// If diff is disabled, don't pass the diffStrategy
+	const effectiveDiffStrategy = diffEnabled ? diffStrategy : undefined
+
+	// Get the full mode config to ensure we have the role definition
+	const modeConfig = getModeBySlug(mode, customModeConfigs) || modes.find((m) => m.slug === mode) || modes[0]
+	const roleDefinition = promptComponent?.roleDefinition || modeConfig.roleDefinition
+
+	const mcpServersSection = modeConfig.groups.some((groupEntry) => getGroupName(groupEntry) === "mcp")
+		? await getMcpServersSection(mcpHub, effectiveDiffStrategy, enableMcpServerCreation)
+		: ""
+
+	const basePrompt = `${roleDefinition}
+
+${getSharedToolUseSection()}
+
+${getToolDescriptionsForMode(
+		mode,
+		cwd,
+		searchTool,
+		supportsComputerUse,
+		effectiveDiffStrategy,
+		browserViewportSize,
+		mcpHub,
+		customModeConfigs,
+		experiments,
+	)}
+
+${getToolUseGuidelinesSection()}
+
+${mcpServersSection}
+
+${getCapabilitiesSection(cwd, searchTool)}
+
+${getRulesSection(cwd, searchTool, supportsComputerUse, effectiveDiffStrategy, experiments)}
+
+${getSystemInfoSection(cwd)}
+
+${getObjectiveSection()}
+
+${await addCustomInstructions(promptComponent?.customInstructions || modeConfig.customInstructions || "", globalCustomInstructions || "", cwd, mode, { preferredLanguage })}`
+
+	return basePrompt
+}
+
+export const SYSTEM_PROMPT = async (
+	cwd: string,
+	supportsComputerUse: boolean,
+	mode: Mode = defaultModeSlug,
+	mcpHub?: McpHub,
+	diffStrategy?: DiffStrategy,
+	browserViewportSize?: string,
+	customModePrompts?: CustomModePrompts,
+	customModes?: ModeConfig[],
+	globalCustomInstructions?: string,
+	preferredLanguage?: string,
+	diffEnabled?: boolean,
+	experiments?: Record<string, boolean>,
+	enableMcpServerCreation?: boolean,
+): Promise<string> => {
+	// if (!context) {
+	// 	throw new Error("Extension context is required for generating system prompt")
+	// }
+
+	const getPromptComponent = (value: unknown) => {
+		if (typeof value === "object" && value !== null) {
+			return value as PromptComponent
+		}
+		return undefined
+	}
+
+	// Try to load custom system prompt from file
+	// const fileCustomSystemPrompt = await loadSystemPromptFile(cwd, mode)
+
+	// Check if it's a custom mode
+	const promptComponent = getPromptComponent(customModePrompts?.[mode])
+
+	// Get full mode config from custom modes or fall back to built-in modes
+	const currentMode = getModeBySlug(mode, customModes) || modes.find((m) => m.slug === mode) || modes[0]
+
+	// If a file-based custom system prompt exists, use it
+	// 	if (fileCustomSystemPrompt) {
+	// 		const roleDefinition = promptComponent?.roleDefinition || currentMode.roleDefinition
+	// 		return `${roleDefinition}
+
+	// ${fileCustomSystemPrompt}
+
+	// ${await addCustomInstructions(promptComponent?.customInstructions || currentMode.customInstructions || "", globalCustomInstructions || "", cwd, mode, { preferredLanguage })}`
+	// 	}
+
+	// If diff is disabled, don't pass the diffStrategy
+	const effectiveDiffStrategy = diffEnabled ? diffStrategy : undefined
+
+	return generatePrompt(
+		// context,
+		cwd,
+		supportsComputerUse,
+		currentMode.slug,
+		mcpHub,
+		effectiveDiffStrategy,
+		browserViewportSize,
+		promptComponent,
+		customModes,
+		globalCustomInstructions,
+		preferredLanguage,
+		diffEnabled,
+		experiments,
+		enableMcpServerCreation,
+	)
+}

src/core/prompts/tools/access-mcp-resource.ts

@@ -0,0 +1,24 @@
+import { ToolArgs } from "./types"
+
+export function getAccessMcpResourceDescription(args: ToolArgs): string | undefined {
+	if (!args.mcpHub) {
+		return undefined
+	}
+	return `## access_mcp_resource
+Description: Request to access a resource provided by a connected MCP server. Resources represent data sources that can be used as context, such as files, API responses, or system information.
+Parameters:
+- server_name: (required) The name of the MCP server providing the resource
+- uri: (required) The URI identifying the specific resource to access
+Usage:
+<access_mcp_resource>
+<server_name>server name here</server_name>
+<uri>resource URI here</uri>
+</access_mcp_resource>
+
+Example: Requesting to access an MCP resource
+
+<access_mcp_resource>
+<server_name>weather-server</server_name>
+<uri>weather://san-francisco/current</uri>
+</access_mcp_resource>`
+}

src/core/prompts/tools/ask-followup-question.ts

@@ -0,0 +1,14 @@
+export function getAskFollowupQuestionDescription(): string {
+	return `## ask_followup_question
+Description: Ask the user a question to gather additional information needed to complete the task. This tool should be used when you encounter ambiguities, need clarification, or require more details to proceed effectively. It allows for interactive problem-solving by enabling direct communication with the user. Use this tool judiciously to maintain a balance between gathering necessary information and avoiding excessive back-and-forth.
+Parameters:
+- question: (required) The question to ask the user. This should be a clear, specific question that addresses the information you need.
+Usage:
+<ask_followup_question>
+<question>Your question here</question>
+</ask_followup_question>
+
+Example: Requesting to ask the user for their preferred citation style for an academic document
+<ask_followup_question>
+<question>Which citation style would you like to use for your academic paper (APA, MLA, Chicago, etc.)?</question>`
+}

src/core/prompts/tools/attempt-completion.ts

@@ -0,0 +1,13 @@
+export function getAttemptCompletionDescription(): string {
+	return `## attempt_completion
+Description: After each tool use, the user will respond with the result of that tool use, i.e. if it succeeded or failed, along with any reasons for failure. Once you've received the results of tool uses and can confirm that the task is complete, use this tool to present the result of your work to the user. The user may respond with feedback if they are not satisfied with the result, which you can use to make improvements and try again.
+IMPORTANT NOTE: This tool CANNOT be used until you've confirmed from the user that any previous tool uses were successful. Failure to do so will result in document corruption and system failure. Before using this tool, you must ask yourself in <thinking></thinking> tags if you've confirmed from the user that any previous tool uses were successful. If not, then DO NOT use this tool.
+Parameters:
+- result: The result of the task. Formulate this result in a way that is final and does not require further input from the user. Don't end your result with questions or offers for further assistance.
+Usage:
+<attempt_completion>
+<result>
+Your final result description here
+</result>
+</attempt_completion>`
+}

src/core/prompts/tools/browser-action.ts

@@ -0,0 +1,52 @@
+import { ToolArgs } from "./types"
+
+export function getBrowserActionDescription(args: ToolArgs): string | undefined {
+	if (!args.supportsComputerUse) {
+		return undefined
+	}
+	return `## browser_action
+Description: Request to interact with a Puppeteer-controlled browser. Use this tool for research, information gathering, citation verification, or content reference when writing. Every action, except \`close\`, will be responded to with a screenshot of the browser's current state, along with any new console logs. You may only perform one browser action per message, and wait for the user's response including a screenshot and logs to determine the next action.
+- The sequence of actions **must always start with** launching the browser at a URL, and **must always end with** closing the browser. If you need to visit a new URL that is not possible to navigate to from the current webpage, you must first close the browser, then launch again at the new URL.
+- While the browser is active, only the \`browser_action\` tool can be used. No other tools should be called during this time. You may proceed to use other tools only after closing the browser. For example if you need to save research findings to a document, you must close the browser, then use other tools to write the information to files.
+- The browser window has a resolution of **${args.browserViewportSize}** pixels. When performing any click actions, ensure the coordinates are within this resolution range.
+- Before clicking on any elements such as icons, links, or buttons, you must consult the provided screenshot of the page to determine the coordinates of the element. The click should be targeted at the **center of the element**, not on its edges.
+Parameters:
+- action: (required) The action to perform. The available actions are:
+    * launch: Launch a new Puppeteer-controlled browser instance at the specified URL. This **must always be the first action**.
+        - Use with the \`url\` parameter to provide the URL.
+        - Ensure the URL is valid and includes the appropriate protocol (e.g. https://en.wikipedia.org/wiki/Writing, https://scholar.google.com, etc.)
+    * click: Click at a specific x,y coordinate.
+        - Use with the \`coordinate\` parameter to specify the location.
+        - Always click in the center of an element (icon, button, link, etc.) based on coordinates derived from a screenshot.
+    * type: Type a string of text on the keyboard. You might use this after clicking on a text field to input text.
+        - Use with the \`text\` parameter to provide the string to type.
+    * scroll_down: Scroll down the page by one page height.
+    * scroll_up: Scroll up the page by one page height.
+    * close: Close the Puppeteer-controlled browser instance. This **must always be the final browser action**.
+        - Example: \`<action>close</action>\`
+- url: (optional) Use this for providing the URL for the \`launch\` action.
+    * Example: <url>https://en.wikipedia.org/wiki/Writing</url>
+- coordinate: (optional) The X and Y coordinates for the \`click\` action. Coordinates should be within the **${args.browserViewportSize}** resolution.
+    * Example: <coordinate>450,300</coordinate>
+- text: (optional) Use this for providing the text for the \`type\` action.
+    * Example: <text>academic writing research</text>
+Usage:
+<browser_action>
+<action>Action to perform (e.g., launch, click, type, scroll_down, scroll_up, close)</action>
+<url>URL to launch the browser at (optional)</url>
+<coordinate>x,y coordinates (optional)</coordinate>
+<text>Text to type (optional)</text>
+</browser_action>
+
+Example: Requesting to launch a browser at a research resource
+<browser_action>
+<action>launch</action>
+<url>https://scholar.google.com</url>
+</browser_action>
+
+Example: Requesting to type a search query
+<browser_action>
+<action>type</action>
+<text>academic writing styles comparison</text>
+</browser_action>`
+}

src/core/prompts/tools/execute-command.ts

@@ -0,0 +1,17 @@
+import { ToolArgs } from "./types"
+
+export function getExecuteCommandDescription(args: ToolArgs): string | undefined {
+	return `## execute_command
+Description: Request to execute a CLI command on the system. Use this when you need to perform system operations or run specific commands to accomplish any step in the user's task. You must tailor your command to the user's system and provide a clear explanation of what the command does. For command chaining, use the appropriate chaining syntax for the user's shell. Prefer to execute complex CLI commands over creating executable scripts, as they are more flexible and easier to run. Commands will be executed in the current working directory: ${args.cwd}
+Parameters:
+- command: (required) The CLI command to execute. This should be valid for the current operating system. Ensure the command is properly formatted and does not contain any harmful instructions.
+Usage:
+<execute_command>
+<command>Your command here</command>
+</execute_command>
+
+Example: Requesting to convert a markdown file to PDF using pandoc
+<execute_command>
+<command>pandoc document.md -o document.pdf</command>
+</execute_command>`
+}

src/core/prompts/tools/index.ts

@@ -0,0 +1,98 @@
+import { Mode, ModeConfig, getGroupName, getModeConfig, isToolAllowedForMode } from "../../../utils/modes"
+import { DiffStrategy } from "../../diff/DiffStrategy"
+import { McpHub } from "../../mcp/McpHub"
+
+import { getAccessMcpResourceDescription } from "./access-mcp-resource"
+import { getAskFollowupQuestionDescription } from "./ask-followup-question"
+import { getAttemptCompletionDescription } from "./attempt-completion"
+import { getBrowserActionDescription } from "./browser-action"
+import { getExecuteCommandDescription } from "./execute-command"
+import { getInsertContentDescription } from "./insert-content"
+import { getListFilesDescription } from "./list-files"
+import { getReadFileDescription } from "./read-file"
+import { getSearchAndReplaceDescription } from "./search-and-replace"
+import { getSearchFilesDescription } from "./search-files"
+import { getSwitchModeDescription } from "./switch-mode"
+import { ALWAYS_AVAILABLE_TOOLS, TOOL_GROUPS, ToolName } from "./tool-groups"
+import { ToolArgs } from "./types"
+import { getUseMcpToolDescription } from "./use-mcp-tool"
+import { getWriteToFileDescription } from "./write-to-file"
+
+// Map of tool names to their description functions
+const toolDescriptionMap: Record<string, (args: ToolArgs) => string | undefined> = {
+	execute_command: (args) => getExecuteCommandDescription(args),
+	read_file: (args) => getReadFileDescription(args),
+	write_to_file: (args) => getWriteToFileDescription(args),
+	search_files: (args) => getSearchFilesDescription(args),
+	list_files: (args) => getListFilesDescription(args),
+	ask_followup_question: () => getAskFollowupQuestionDescription(),
+	attempt_completion: () => getAttemptCompletionDescription(),
+	switch_mode: () => getSwitchModeDescription(),
+	insert_content: (args) => getInsertContentDescription(args),
+	search_and_replace: (args) => getSearchAndReplaceDescription(args),
+	apply_diff: (args) =>
+		args.diffStrategy ? args.diffStrategy.getToolDescription({ cwd: args.cwd, toolOptions: args.toolOptions }) : "",
+}
+
+export function getToolDescriptionsForMode(
+	mode: Mode,
+	cwd: string,
+	searchTool: string, 
+	supportsComputerUse: boolean,
+	diffStrategy?: DiffStrategy,
+	browserViewportSize?: string,
+	mcpHub?: McpHub,
+	customModes?: ModeConfig[],
+	experiments?: Record<string, boolean>,
+): string {
+	const config = getModeConfig(mode, customModes)
+	const args: ToolArgs = {
+		cwd,
+		searchTool,
+		supportsComputerUse,
+		diffStrategy,
+		browserViewportSize,
+		mcpHub,
+	}
+
+	const tools = new Set<string>()
+
+	// Add tools from mode's groups
+	config.groups.forEach((groupEntry) => {
+		const groupName = getGroupName(groupEntry)
+		const toolGroup = TOOL_GROUPS[groupName]
+		if (toolGroup) {
+			toolGroup.tools.forEach((tool) => {
+				if (isToolAllowedForMode(tool as ToolName, mode, customModes ?? [], experiments ?? {})) {
+					tools.add(tool)
+				}
+			})
+		}
+	})
+
+	// Add always available tools
+	ALWAYS_AVAILABLE_TOOLS.forEach((tool) => tools.add(tool))
+
+	// Map tool descriptions for allowed tools
+	const descriptions = Array.from(tools).map((toolName) => {
+		const descriptionFn = toolDescriptionMap[toolName]
+		if (!descriptionFn) {
+			return undefined
+		}
+
+		return descriptionFn({
+			...args,
+			toolOptions: undefined, // No tool options in group-based approach
+		})
+	})
+
+	return `# Tools\n\n${descriptions.filter(Boolean).join("\n\n")}`
+}
+
+// Export individual description functions for backward compatibility
+export {
+	getAccessMcpResourceDescription, getAskFollowupQuestionDescription,
+	getAttemptCompletionDescription, getBrowserActionDescription, getExecuteCommandDescription, getInsertContentDescription,
+	getListFilesDescription, getReadFileDescription, getSearchFilesDescription, getSearchAndReplaceDescription, getSwitchModeDescription, getUseMcpToolDescription, getWriteToFileDescription
+}
+

src/core/prompts/tools/insert-content.ts

@@ -0,0 +1,39 @@
+import { ToolArgs } from "./types"
+
+export function getInsertContentDescription(args: ToolArgs): string {
+	return `## insert_content
+Description: Inserts content at specific line positions in a file. This is the primary tool for adding new content (paragraphs, sections, headings, citations, etc.) as it allows for precise insertions without overwriting existing content. The tool uses an efficient line-based insertion system that maintains document integrity and proper ordering of multiple insertions. Beware to use the proper formatting and indentation. This tool is the preferred way to add new content to documents.
+Parameters:
+- path: (required) The path of the file to insert content into (relative to the current working directory ${args.cwd.toPosix()})
+- operations: (required) A JSON array of insertion operations. Each operation is an object with:
+    * start_line: (required) The line number where the content should be inserted.  The content currently at that line will end up below the inserted content.
+    * content: (required) The content to insert at the specified position. IMPORTANT NOTE: If the content is a single line, it can be a string. If it's a multi-line content, it should be a string with newline characters (\n) for line breaks. Make sure to include the correct formatting and indentation for the content.
+Usage:
+<insert_content>
+<path>File path here</path>
+<operations>[
+  {
+    "start_line": 10,
+    "content": "Your content here"
+  }
+]</operations>
+</insert_content>
+Example: Insert a new section heading and paragraph
+<insert_content>
+<path>chapter1.md</path>
+<operations>[
+  {
+    "start_line": 5,
+    "content": "## Historical Context\n\nIn the early 20th century, the literary landscape underwent significant changes as modernist writers began to experiment with new narrative techniques and thematic concerns. This shift was largely influenced by the cultural and societal transformations of the period."
+  },
+  {
+    "start_line": 20,
+    "content": "> \"The purpose of literature is to turn blood into ink.\" - T.S. Eliot"
+  },
+	{
+    "start_line": 1,
+    "content": "\`\`\`mermaid\\nflowchart TD\\n    A[开始]-- > B[结束]\\n\`\`\`"
+  },
+]</operations>
+</insert_content>`
+}

src/core/prompts/tools/list-files.ts

@@ -0,0 +1,20 @@
+import { ToolArgs } from "./types"
+
+export function getListFilesDescription(args: ToolArgs): string {
+	return `## list_files
+Description: Request to list files and directories within the specified directory in the Obsidian vault. If recursive is true, it will list all files and directories recursively. This is particularly useful for understanding the vault structure, discovering note organization patterns, finding templates, or locating notes across different areas of the knowledge base. Use this to navigate through the vault's folder structure to find relevant notes.
+Parameters:
+- path: (required) The path of the directory to list contents for (relative to the current working directory ${args.cwd})
+- recursive: (optional) Whether to list files recursively. Use true for recursive listing, false or omit for top-level only.
+Usage:
+<list_files>
+<path>Directory path here</path>
+<recursive>true or false (optional)</recursive>
+</list_files>
+
+Example: Discovering all notes in a specific area of knowledge
+<list_files>
+<path>Areas/Programming</path>
+<recursive>true</recursive>
+</list_files>`
+}

src/core/prompts/tools/read-file.ts

@@ -0,0 +1,17 @@
+import { ToolArgs } from "./types"
+
+export function getReadFileDescription(args: ToolArgs): string {
+	return `## read_file
+Description: Request to read the contents of a file at the specified path. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze document structure, review text content, or extract information from reference materials. The output includes line numbers prefixed to each line (e.g. "1 | # Introduction"), making it easier to reference specific sections when creating edits or discussing content. Automatically extracts text from PDF and DOCX files. May not be suitable for other types of binary files, as it returns the raw content as a string.
+Parameters:
+- path: (required) The path of the file to read (relative to the current working directory ${args.cwd})
+Usage:
+<read_file>
+<path>File path here</path>
+</read_file>
+
+Example: Requesting to read literature-review.md
+<read_file>
+<path>literature-review.md</path>
+</read_file>`
+}

src/core/prompts/tools/search-and-replace.ts

@@ -0,0 +1,52 @@
+import { ToolArgs } from "./types"
+
+export function getSearchAndReplaceDescription(args: ToolArgs): string {
+	return `## search_and_replace
+Description: Request to perform search and replace operations on a file. Each operation can specify a search pattern (string or regex) and replacement text, with optional line range restrictions and regex flags. Shows a diff preview before applying changes. Useful for revising terminology, correcting errors, or updating references throughout a document.
+Parameters:
+- path: (required) The path of the file to modify (relative to the current working directory ${args.cwd.toPosix()})
+- operations: (required) A JSON array of search/replace operations. Each operation is an object with:
+    * search: (required) The text or pattern to search for
+    * replace: (required) The text to replace matches with. If multiple lines need to be replaced, use "\n" for newlines
+    * start_line: (optional) Starting line number for restricted replacement
+    * end_line: (optional) Ending line number for restricted replacement
+    * use_regex: (optional) Whether to treat search as a regex pattern
+    * ignore_case: (optional) Whether to ignore case when matching
+    * regex_flags: (optional) Additional regex flags when use_regex is true
+Usage:
+<search_and_replace>
+<path>File path here</path>
+<operations>[
+  {
+    "search": "text to find",
+    "replace": "replacement text",
+    "start_line": 1,
+    "end_line": 10
+  }
+]</operations>
+</search_and_replace>
+Example: Replace "climate change" with "climate crisis" in lines 1-10 of an essay
+<search_and_replace>
+<path>essays/environmental-impact.md</path>
+<operations>[
+  {
+    "search": "climate change",
+    "replace": "climate crisis",
+    "start_line": 1,
+    "end_line": 10
+  }
+]</operations>
+</search_and_replace>
+Example: Update citation format throughout a document using regex
+<search_and_replace>
+<path>research-paper.md</path>
+<operations>[
+  {
+    "search": "\\(([A-Za-z]+), (\\d{4})\\)",
+    "replace": "($1 et al., $2)",
+    "use_regex": true,
+    "ignore_case": false
+  }
+]</operations>
+</search_and_replace>`
+}

src/core/prompts/tools/search-files.ts

@@ -0,0 +1,50 @@
+import { ToolArgs } from "./types"
+
+export function getSearchFilesDescription(args: ToolArgs): string {
+	if (args.searchTool === 'regex') {
+		return getRegexSearchFilesDescription(args)
+	} else if (args.searchTool === 'semantic') {
+		return getSemanticSearchFilesDescription(args)
+	} else {
+		return ""
+	}
+}
+
+export function getRegexSearchFilesDescription(args: ToolArgs): string {
+	return `## regex_search_files
+Description: Request to perform a regex search across files in a specified directory, providing context-rich results. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context.
+Parameters:
+- path: (required) The path of the directory to search in (relative to the current working directory ${args.cwd}). This directory will be recursively searched.
+- regex: (required) The regular expression pattern to search for. Uses Rust regex syntax, **but should not include word boundaries (\b)**.
+
+Usage:
+<regex_search_files>
+<path>Directory path here</path>
+<regex>Your regex pattern here</regex>
+</regex_search_files>
+
+Example: Requesting to search for all Markdown files in the current directory
+<regex_search_files>
+<path>.</path>
+<regex>.*</regex>
+</regex_search_files>`
+}
+
+export function getSemanticSearchFilesDescription(args: ToolArgs): string {
+	return `## semantic_search_files
+Description: Request to perform a semantic search across files in a specified directory. This tool searches for documents with content semantically related to your query, leveraging embedding vectors to find conceptually similar information. Ideal for finding relevant documents even when exact keywords are not known or for discovering thematically related content.
+Parameters:
+- path: (required) The path of the directory to search in (relative to the current working directory ${args.cwd}). This directory will be recursively searched.
+- query: (required) The natural language query describing the information you're looking for. The system will find documents with similar semantic meaning.
+Usage:
+<semantic_search_files>
+<path>Directory path here</path>
+<query>Your natural language query here</query>
+</semantic_search_files>
+
+Example: Requesting to find documents related to a specific topic
+<semantic_search_files>
+<path>Project/notes</path>
+<query>Benefits of meditation for stress reduction</query>
+</semantic_search_files>`
+}

src/core/prompts/tools/switch-mode.ts

@@ -0,0 +1,18 @@
+export function getSwitchModeDescription(): string {
+	return `## switch_mode
+Description: Request to switch to a different mode. This tool allows modes to request switching to another mode when needed, such as switching to Write mode edits to files. The user must approve the mode switch.
+Parameters:
+- mode_slug: (required) The slug of the mode to switch to (e.g., "write", "ask",)
+- reason: (optional) The reason for switching modes
+Usage:
+<switch_mode>
+<mode_slug>Mode slug here</mode_slug>
+<reason>Reason for switching here</reason>
+</switch_mode>
+
+Example: Requesting to switch to write mode
+<switch_mode>
+<mode_slug>write</mode_slug>
+<reason>Need to edit files</reason>
+</switch_mode>`
+}

src/core/prompts/tools/tool-groups.ts

@@ -0,0 +1,76 @@
+// Define tool group configuration
+export type ToolGroupConfig = {
+	tools: readonly string[]
+	alwaysAvailable?: boolean // Whether this group is always available and shouldn't show in prompts view
+}
+
+// Map of tool slugs to their display names
+export const TOOL_DISPLAY_NAMES = {
+	execute_command: "run commands",
+	read_file: "read files",
+	write_to_file: "write files",
+	apply_diff: "apply changes",
+	list_files: "list files",
+	search_files: "search files",
+	// list_code_definition_names: "list definitions",
+	// browser_action: "use a browser",
+	// use_mcp_tool: "use mcp tools",
+	// access_mcp_resource: "access mcp resources",
+	ask_followup_question: "ask questions",
+	attempt_completion: "complete tasks",
+	switch_mode: "switch modes",
+	// new_task: "create new task",
+} as const
+
+// Define available tool groups
+export const TOOL_GROUPS: Record<string, ToolGroupConfig> = {
+	read: {
+		tools: ["read_file", "list_files", "search_files"],
+	},
+	edit: {
+		tools: ["apply_diff", "write_to_file", "insert_content", "search_and_replace"],
+	},
+	// browser: {
+	// 	tools: ["browser_action"],
+	// },
+	// command: {
+	// 	tools: ["execute_command"],
+	// },
+	// mcp: {
+	// 	tools: ["use_mcp_tool", "access_mcp_resource"],
+	// },
+	modes: {
+		tools: ["switch_mode"],
+		alwaysAvailable: true,
+	},
+}
+
+export type ToolGroup = keyof typeof TOOL_GROUPS
+
+// Tools that are always available to all modes
+export const ALWAYS_AVAILABLE_TOOLS = [
+	"ask_followup_question",
+	"attempt_completion",
+	"switch_mode",
+] as const
+
+// Tool name types for type safety
+export type ToolName = keyof typeof TOOL_DISPLAY_NAMES
+
+// Tool helper functions
+export function getToolName(toolConfig: string | readonly [ToolName, ...any[]]): ToolName {
+	return typeof toolConfig === "string" ? (toolConfig as ToolName) : toolConfig[0]
+}
+
+export function getToolOptions(toolConfig: string | readonly [ToolName, ...any[]]): any {
+	return typeof toolConfig === "string" ? undefined : toolConfig[1]
+}
+
+// Display names for groups in UI
+export const GROUP_DISPLAY_NAMES: Record<ToolGroup, string> = {
+	read: "Read Files",
+	edit: "Edit Files",
+	// browser: "Use Browser",
+	// command: "Run Commands",
+	// mcp: "Use MCP",
+}

src/core/prompts/tools/types.ts

@@ -0,0 +1,12 @@
+import { DiffStrategy } from "../../diff/DiffStrategy"
+import { McpHub } from "../../mcp/McpHub"
+
+export type ToolArgs = {
+	cwd: string
+	searchTool?: string,
+	supportsComputerUse: boolean
+	diffStrategy?: DiffStrategy
+	browserViewportSize?: string
+	mcpHub?: McpHub
+	toolOptions?: any
+}

src/core/prompts/tools/use-mcp-tool.ts

@@ -0,0 +1,37 @@
+import { ToolArgs } from "./types"
+
+export function getUseMcpToolDescription(args: ToolArgs): string | undefined {
+	if (!args.mcpHub) {
+		return undefined
+	}
+	return `## use_mcp_tool
+Description: Request to use a tool provided by a connected MCP server. Each MCP server can provide multiple tools with different capabilities. Tools have defined input schemas that specify required and optional parameters.
+Parameters:
+- server_name: (required) The name of the MCP server providing the tool
+- tool_name: (required) The name of the tool to execute
+- arguments: (required) A JSON object containing the tool's input parameters, following the tool's input schema
+Usage:
+<use_mcp_tool>
+<server_name>server name here</server_name>
+<tool_name>tool name here</tool_name>
+<arguments>
+{
+  "param1": "value1",
+  "param2": "value2"
+}
+</arguments>
+</use_mcp_tool>
+
+Example: Requesting to use an MCP tool
+
+<use_mcp_tool>
+<server_name>weather-server</server_name>
+<tool_name>get_forecast</tool_name>
+<arguments>
+{
+  "city": "San Francisco",
+  "days": 5
+}
+</arguments>
+</use_mcp_tool>`
+}

src/core/prompts/tools/write-to-file.ts

@@ -0,0 +1,40 @@
+import { ToolArgs } from "./types"
+
+export function getWriteToFileDescription(args: ToolArgs): string {
+	return `## write_to_file
+Description: Request to write full content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file.
+Parameters:
+- path: (required) The path of the file to write to (relative to the current working directory ${args.cwd})
+- content: (required) The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified. Do NOT include the line numbers in the content though, just the actual content of the file.
+- line_count: (required) The number of lines in the file. Make sure to compute this based on the actual content of the file, not the number of lines in the content you're providing.
+Usage:
+<write_to_file>
+<path>File path here</path>
+<content>
+Your file content here
+</content>
+<line_count>total number of lines in the file, including empty lines</line_count>
+</write_to_file>
+
+Example: Requesting to write to document-metadata.md
+<write_to_file>
+<path>document-metadata.md</path>
+<content>
+---
+title: "Introduction to Modern Literature"
+author: "Jane Smith"
+date: "2023-09-15"
+version: "1.0.0"
+tags:
+  - literature
+  - modernism
+  - academic
+format:
+  citation_style: "APA"
+  word_count: 2500
+status: "draft"
+---
+</content>
+<line_count>14</line_count>
+</write_to_file>`
+}