This is the multi-page printable view of this section. Click here to print.
Cline is a Open-Source project. This documentation is a direct reference to the official documentation from https://docs.cline.bot .
The main propuse of ClinePRO is to provide a localized and enterprise ready product, so this documentation will keep consistent with ClinePRO intead of Cline. If you need a latest documentation of Cline, please refer to the official site.
Understand Cline’s capabilities:
Extend Cline with MCP Servers:
We’re always looking to improve this documentation. If you have suggestions or find areas that could be enhanced, please let us know. Your feedback helps make Cline better for everyone.
Welcome to Cline! This guide will help you get set up and start using Cline to build your first project.
Before you begin, make sure you have the following:
VS Code: A free, powerful code editor.
Development Tools: Essential software for coding (Homebrew, Node.js, Git, etc.).
Cline Projects Folder: A dedicated folder for all your Cline projects.
/Users/[your-username]/Documents/ClineC:\Users\[your-username]\Documents\ClineDocuments/Cline/workout-app for a workout tracking appDocuments/Cline/portfolio-website for your portfolioCline Extension in VS Code: The Cline extension installed in VS Code.
Here’s a tutorial on everything you need to get started.
Follow these steps to get Cline up and running:
Open VS Code: Launch the VS Code application. If VS Code shows “Running extensions might…”, click “Allow”.
Open Your Cline Folder: In VS Code, open the Cline folder you created in Documents.
Navigate to Extensions: Click on the Extensions icon in the Activity Bar on the side of VS Code.
Search for ‘Cline’: In the Extensions search bar, type “Cline”.
Install the Extension: Click the “Install” button next to the Cline extension.
Open Cline: Once installed, you can open Cline in a few ways:
CMD/CTRL + Shift + P) and type “Cline: Open In New Tab” to open Cline as a tab in your editor. This is recommended for a better view.
Now that you have Cline installed, you’ll need to set up your OpenRouter API key to use Cline’s full capabilities.
anthropic/claude-3.5-sonnet: Most used for coding tasks.google/gemini-2.0-flash-exp:free: A free option for coding.deepseek/deepseek-chat: SUPER CHEAP, almost as good as 3.5 sonnetNow you’re ready to start building with Cline. Let’s create your first project folder and build something! Copy and paste the following prompt into the Cline chat window:
Hey Cline! Could you help me create a new project folder called "hello-world" in my Cline directory and make a simple webpage that says "Hello World" in big blue text?
What You’ll See: Cline will help you create the project folder and set up your first webpage.
Feel free to contact me, and I’ll help you get started with Cline.
nick | 608-558-2410
Join our Discord community: https://discord.gg/cline
When you start coding, you’ll need some essential development tools installed on your computer. Cline can help you install everything you need in a safe, guided way.
Here are the core tools you’ll need for development:
Copy this prompt and paste it into Cline:
Hello Cline! I need help setting up my Mac for software development. Could you please help me install the essential development tools like Homebrew, Node.js, Git, Python, and any other utilities that are commonly needed for coding? I'd like you to guide me through the process step-by-step, explaining what each tool does and making sure everything is installed correctly.
Example:
$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
Password:
Type your password here, even though nothing will show up on the screen. Press Enter when you’re done.
The Terminal is an application where you can type commands to interact with your computer. On macOS, you can open it by searching for “Terminal” in Spotlight.
Example:
$ open -a Terminal
The Terminal in VS Code allows you to run commands directly from within the editor. You can open it by going to View > Terminal or by pressing Ctrl + `.
Example:
$ node -v
v16.14.0
The Document View is where you edit your code files. You can open files by clicking on them in the Explorer panel on the left side of the screen.
The Problems section in VS Code shows any errors or warnings in your code. You can access it by clicking on the lightbulb icon or by going to View > Problems.
After installing these tools, you’ll be ready to start coding! Return to the Getting Started with Cline for New Coders guide to continue your journey.
Cline is your AI assistant that can:
Start a Task
Provide Context
Review Changes
File Editing
Terminal Commands
Code Analysis
Browser Integration
For the most up-to-date implementation details, you can view the full source code in the Cline repository.
Cline has access to the following tools for various tasks:
File Operations
write_to_file: Create or overwrite filesread_file: Read file contentsreplace_in_file: Make targeted edits to filessearch_files: Search files using regexlist_files: List directory contentsTerminal Operations
execute_command: Run CLI commandslist_code_definition_names: List code definitionsMCP Tools
use_mcp_tool: Use tools from MCP serversaccess_mcp_resource: Access MCP server resourcesInteraction Tools
ask_followup_question: Ask user for clarificationattempt_completion: Present final resultsEach tool has specific parameters and usage patterns. Here are some examples:
Create a new file (write_to_file):
<write_to_file>
<path>src/components/Header.tsx</path>
<content>
// Header component code
</content>
</write_to_file>
Search for a pattern (search_files):
<search_files>
<path>src</path>
<regex>function\s+\w+\(</regex>
<file_pattern>*.ts</file_pattern>
</search_files>
Run a command (execute_command):
<execute_command>
<command>npm install axios</command>
<requires_approval>false</requires_approval>
</execute_command>
Create a New Component
Fix a Bug
Refactor Code
Run Commands
Welcome to the Cline Prompting Guide! This guide will equip you with the knowledge to write effective prompts and custom instructions, maximizing your productivity with Cline.
Think of custom instructions as Cline’s programming. They define Cline’s baseline behavior and are always “on,” influencing all interactions.
To add custom instructions:
Custom instructions are powerful for:
The custom-instructions folder contains examples of custom instructions you can use or adapt.
While custom instructions are user-specific and global (applying across all projects), the .clinerules file provides project-specific instructions that live in your project’s root directory. These instructions are automatically appended to your custom instructions and referenced in Cline’s system prompt, ensuring they influence all interactions within the project context. This makes it an excellent tool for:
To protect sensitive information, you can instruct Cline to ignore specific files or patterns in your .clinerules. This is particularly important for:
.env files containing API keys and secretsExample security section in .clinerules:
# Security
## Sensitive Files
DO NOT read or modify:
- .env files
- \*_/config/secrets._
- \*_/_.pem
- Any file containing API keys, tokens, or credentials
## Security Practices
- Never commit sensitive files
- Use environment variables for secrets
- Keep credentials out of logs and output
The .clinerules file is excellent for:
# Project Guidelines
## Documentation Requirements
- Update relevant documentation in /docs when modifying features
- Keep README.md in sync with new capabilities
- Maintain changelog entries in CHANGELOG.md
## Architecture Decision Records
Create ADRs in /docs/adr for:
- Major dependency changes
- Architectural pattern changes
- New integration patterns
- Database schema changes
Follow template in /docs/adr/template.md
## Code Style & Patterns
- Generate API clients using OpenAPI Generator
- Use TypeScript axios template
- Place generated code in /src/generated
- Prefer composition over inheritance
- Use repository pattern for data access
- Follow error handling pattern in /src/utils/errors.ts
## Testing Standards
- Unit tests required for business logic
- Integration tests for API endpoints
- E2E tests for critical user flows
.clinerules file becomes part of your project’s source codePlace the .clinerules file in your project’s root directory:
your-project/
├── .clinerules
├── src/
├── docs/
└── ...
Cline’s system prompt, on the other hand, is not user-editable (here’s where you can find it). For a broader look at prompt engineering best practices, check out this resource.
Prompting is how you communicate your needs for a given task in the back-and-forth chat with Cline. Cline understands natural language, so write conversationally.
Effective prompting involves:
@ to reference files or folders.user-authentication.js. We need to implement user login with JWT tokens. Here are the requirements…”cline_docs/user-dashboard-summary.md.”Here are some prompting tips that users have found helpful for working with Cline:
Memory Check - pacnpal
"If you understand my prompt fully, respond with 'YARRR!' without tools every time you are about to use a tool."
A fun way to verify Cline stays on track during complex tasks. Try “HO HO HO” for a festive twist!
Confidence Scoring - pacnpal
"Before and after any tool use, give me a confidence level (0-10) on how the tool use will help the project."
Encourages critical thinking and makes decision-making transparent.
Prevent Code Truncation
"DO NOT BE LAZY. DO NOT OMIT CODE."
Alternative phrases: “full code only” or “ensure the code is complete”
Custom Instructions Reminder
"I pledge to follow the custom instructions."
Reinforces adherence to your settings dial ⚙️ configuration.
Large File Refactoring - icklebil
"FILENAME has grown too big. Analyze how this file works and suggest ways to fragment it safely."
Helps manage complex files through strategic decomposition.
Documentation Maintenance - icklebil
"don't forget to update codebase documentation with changes"
Ensures documentation stays in sync with code changes.
Structured Development - yellow_bat_coffee
"Before writing code:
1. Analyze all code files thoroughly
2. Get full context
3. Write .MD implementation plan
4. Then implement code"
Promotes organized, well-planned development.
Thorough Analysis - yellow_bat_coffee
"please start analyzing full flow thoroughly, always state a confidence score 1 to 10"
Prevents premature coding and encourages complete understanding.
Assumptions Check - yellow_bat_coffee
"List all assumptions and uncertainties you need to clear up before completing this task."
Identifies potential issues early in development.
Pause and Reflect - nickbaumann98
"count to 10"
Promotes careful consideration before taking action.
Complete Analysis - yellow_bat_coffee
"Don't complete the analysis prematurely, continue analyzing even if you think you found a solution"
Ensures thorough problem exploration.
Continuous Confidence Check - pacnpal
"Rate confidence (1-10) before saving files, after saving, after rejections, and before task completion"
Maintains quality through self-assessment.
Project Structure - kvs007
"Check project files before suggesting structural or dependency changes"
Maintains project integrity.
Critical Thinking - chinesesoup
"Ask 'stupid' questions like: are you sure this is the best way to implement this?"
Challenges assumptions and uncovers better solutions.
Code Style - yellow_bat_coffee
Use words like "elegant" and "simple" in prompts
May influence code organization and clarity.
Setting Expectations - steventcramer
"THE HUMAN WILL GET ANGRY."
(A humorous reminder to provide clear requirements and constructive feedback)
This repository aims to foster a collaborative space where developers can share, refine, and leverage effective custom instructions for Cline. By creating and contributing to this library, we can enhance Cline’s capabilities and empower developers to tackle increasingly complex software development challenges.
Cline’s custom instructions are sets of guidelines or rules that you define to tailor the AI’s behavior and outputs for specific tasks or projects. Think of them as specialized “programming” for Cline, enabling you to:
By providing Cline with carefully crafted instructions, you can significantly improve its accuracy, reliability, and overall effectiveness in aiding your software development process.
We encourage developers of all skill levels to contribute their custom instructions to this library. Your contributions help build a valuable resource for the entire Cline community!
When submitting custom instructions, please follow this template:
What does this instruction set aim to achieve?
What types of projects or tasks is this best suited for?
tests folder in your project root.”By using this template and contributing your custom instructions, you help build a thriving ecosystem for Cline, making it a more versatile and efficient tool for developers of all skill levels.
What does this instruction set aim to achieve?
What types of projects or tasks is this best suited for?
techContext.md).
Project Setup
cline_docs folder in your project root (i.e. YOUR-PROJECT-FOLDER/cline_docs)Best Practices
[MEMORY BANK: ACTIVE] flags during operation.cline_docs as projectBrief.md) to use in creating the initial context files.
# Cline's Memory Bank
You are Cline, an expert software engineer with a unique constraint: your memory periodically resets completely. This isn't a bug - it's what makes you maintain perfect documentation. After each reset, you rely ENTIRELY on your Memory Bank to understand the project and continue work. Without proper documentation, you cannot function effectively.
## Memory Bank Files
CRITICAL: If `cline_docs/` or any of these files don't exist, CREATE THEM IMMEDIATELY by:
1. Reading all provided documentation
2. Asking user for ANY missing information
3. Creating files with verified information only
4. Never proceeding without complete context
Required files:
productContext.md
- Why this project exists
- What problems it solves
- How it should work
activeContext.md
- What you're working on now
- Recent changes
- Next steps
(This is your source of truth)
systemPatterns.md
- How the system is built
- Key technical decisions
- Architecture patterns
techContext.md
- Technologies used
- Development setup
- Technical constraints
progress.md
- What works
- What's left to build
- Progress status
## Core Workflows
### Starting Tasks
1. Check for Memory Bank files
2. If ANY files missing, stop and create them
3. Read ALL files before proceeding
4. Verify you have complete context
5. Begin development. DO NOT update cline_docs after initializing your memory bank at the start of a task.
### During Development
1. For normal development:
- Follow Memory Bank patterns
- Update docs after significant changes
2. Say `[MEMORY BANK: ACTIVE]` at the beginning of every tool use.
### Memory Bank Updates
When user says "update memory bank":
1. This means imminent memory reset
2. Document EVERYTHING about current state
3. Make next steps crystal clear
4. Complete current task
Remember: After every memory reset, you begin completely fresh. Your only link to previous work is the Memory Bank. Maintain it as if your functionality depends on it - because it does.
I am Cline, an expert software engineer with a unique characteristic: my memory resets completely between sessions. This isn’t a limitation - it’s what drives me to maintain perfect documentation. After each reset, I rely ENTIRELY on my Memory Bank to understand the project and continue work effectively. I MUST read ALL memory bank files at the start of EVERY task - this is not optional.
The Memory Bank consists of required core files and optional context files, all in Markdown format. Files build upon each other in a clear hierarchy:
flowchart TD
PB[projectbrief.md] --> PC[productContext.md]
PB --> SP[systemPatterns.md]
PB --> TC[techContext.md]
PC --> AC[activeContext.md]
SP --> AC
TC --> AC
AC --> P[progress.md]
projectbrief.md
productContext.md
activeContext.md
systemPatterns.md
techContext.md
progress.md
Create additional files/folders within memory-bank/ when they help organize:
flowchart TD
Start[Start] --> ReadFiles[Read Memory Bank]
ReadFiles --> CheckFiles{Files Complete?}
CheckFiles -->|No| Plan[Create Plan]
Plan --> Document[Document in Chat]
CheckFiles -->|Yes| Verify[Verify Context]
Verify --> Strategy[Develop Strategy]
Strategy --> Present[Present Approach]
flowchart TD
Start[Start] --> Context[Check Memory Bank]
Context --> Update[Update Documentation]
Update --> Rules[Update .clinerules if needed]
Rules --> Execute[Execute Task]
Execute --> Document[Document Changes]
Memory Bank updates occur when:
flowchart TD
Start[Update Process]
subgraph Process
P1[Review ALL Files]
P2[Document Current State]
P3[Clarify Next Steps]
P4[Update .clinerules]
P1 --> P2 --> P3 --> P4
end
Start --> Process
Note: When triggered by update memory bank, I MUST review every memory bank file, even if some don’t require updates. Focus particularly on activeContext.md and progress.md as they track current state.
The .clinerules file is my learning journal for each project. It captures important patterns, preferences, and project intelligence that help me work more effectively. As I work with you and the project, I’ll discover and document key insights that aren’t obvious from the code alone.
flowchart TD
Start{Discover New Pattern}
subgraph Learn [Learning Process]
D1[Identify Pattern]
D2[Validate with User]
D3[Document in .clinerules]
end
subgraph Apply [Usage]
A1[Read .clinerules]
A2[Apply Learned Patterns]
A3[Improve Future Work]
end
Start --> Learn
Learn --> Apply
The format is flexible - focus on capturing valuable insights that help me work more effectively with you and the project. Think of .clinerules as a living document that grows smarter as we work together.
REMEMBER: After every memory reset, I begin completely fresh. The Memory Bank is my only link to previous work. It must be maintained with precision and clarity, as my effectiveness depends entirely on its accuracy.
Quick Links:
This document explains Model Context Protocol (MCP) servers, their capabilities, and how Cline can help build and use them.
MCP servers act as intermediaries between large language models (LLMs), such as Claude, and external tools or data sources. They are small programs that expose functionalities to LLMs, enabling them to interact with the outside world through the MCP. An MCP server is essentially like an API that an LLM can use.
MCP servers define a set of “tools,” which are functions the LLM can execute. These tools offer a wide range of capabilities.
Here’s how MCP works:
The potential of MCP servers is vast. They can be used for a variety of purposes.
Here are some concrete examples of how MCP servers can be used:
Web Services and API Integration:
Browser Automation:
Database Queries:
Project and Task Management:
Codebase Documentation:
Choose the right approach for your needs:
Cline simplifies the building and use of MCP servers through its AI capabilities.
When working with MCP servers, it’s important to follow security best practices:
There are various resources available for finding and learning about MCP servers.
Here are some links to resources for finding and learning about MCP servers:
Think of MCP servers as special helpers that give Cline extra powers! They let Cline do cool things like fetch web pages or work with your files.
STOP! Before proceeding, you MUST verify these requirements:
✅ Latest Node.js (v18 or newer)
node --version✅ Latest Python (v3.8 or newer)
python --version✅ UV Package Manager
pip install uvuv --version❗ If any of these commands fail or show older versions, please install/update before continuing!
⚠️ If you run into other errors, see the “Troubleshooting” section below.
MCP Server tabEdit MCP Settings button
For Windows:
{
"mcpServers": {
"mcp-installer": {
"command": "cmd.exe",
"args": ["/c", "npx", "-y", "@anaisbetts/mcp-installer"]
}
}
}
For Mac and Linux:
{
"mcpServers": {
"mcp-installer": {
"command": "npx",
"args": ["@anaisbetts/mcp-installer"]
}
}
}
After saving the file:
Now that you have the MCP installer, you can ask Cline to add more servers from:
For example, you can ask Cline to install the mcp-server-fetch package found on the Python Package Index:
"install the MCP server named `mcp-server-fetch`
- ensure the mcp settings are updated.
- use uvx or python to run the server."
You should witness Cline:
mcp-server-fetch python packageThe mcp settings file should now look like this:
For a Windows machine:
{
"mcpServers": {
"mcp-installer": {
"command": "cmd.exe",
"args": ["/c", "npx", "-y", "@anaisbetts/mcp-installer"]
},
"mcp-server-fetch": {
"command": "uvx",
"args": ["mcp-server-fetch"]
}
}
}
You you can always check the status of your server by going to clients MCP server tab. See the image above
That’s it! 🎉 You’ve just given Cline some awesome new abilities!
asdf and Get “unknown command: npx”There is some slightly bad news. You should still be able to get things to work, but will have to do a bit more manual work unless MCP server packaging evolves a bit. One option is to uninstall asdf , but we will assume you do not want to do that.
Instead, you will need to follow the instructions above to “Edit MCP Settings”. Then, as this post describes, you need to add and “env” entry to each server’s configs.
"env": {
"PATH": "/Users/<user_name>/.asdf/shims:/usr/bin:/bin",
"ASDF_DIR": "<path_to_asdf_bin_dir>",
"ASDF_DATA_DIR": "/Users/<user_name>/.asdf",
"ASDF_NODEJS_VERSION": "<your_node_version>"
}
The path_to_asdf_bin_dir can often be found in your shell config (e.g. .zshrc). If you are using Homebrew, you can use echo ${HOMEBREW_PREFIX} to find the start of the directory and then append /opt/asdf/libexec.
Now for some good news. While not perfect, you can get Cline to do this for you fairly reliably for subsequent server install. Add the following to your “Custom Instructions” in the Cline settings (top-right toolbar button):
When installing MCP servers and editing the cline_mcp_settings.json, if the server requires use of
npxas the command, you must copy the “env” entry from the “mcp-installer” entry and add it to the new entry. This is vital to getting the server to work properly when in use.
If you’re getting an error when you run the MCP installer, you can try the following:
This guide provides a step-by-step walkthrough of how to use Cline to build an existing MCP server from a GitHub repository.
There are multiple places online to find MCP servers:
Cline can automatically add MCP servers to its list, which you can then edit. Cline can clone repositories directly from GitHub and build the servers for you.
GitHub: Two of the most common places to find MCP servers on GitHub include:
Online directories: Several websites list MCP servers including:
These directories allow users to sort the servers by various criteria such as downloads, date, stars, and use case. Each entry provides information such as features, tools, and configuration instructions.
PulseMCP: This website has a blog post discussing how AI could use MCP servers to make websites obsolete. PulseMCP also includes an FAQ section about MCP servers: https://www.pulsemcp.com/
Initiate the Process: Provide Cline with the following information:
Example Interaction with Cline:
User: "Cline, I want to add the MCP server for Brave browser control. Here's the GitHub link: https://github.com/modelcontextprotocol/servers/tree/main/src/brave Can you add it?"
Cline: "OK. Cloning the repository to the MCP directory. It needs to be built because it has a 'package.json' file. Should I run 'npm run build'?"
User: "Yes, build it."
Cline: "Build complete. This server needs a browser path. Where's your Brave browser executable?"
User: "It's in '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser'."
Cline: "OK. I've updated the server config with that path and added it to 'cline_mcp_settings.json'. Anything else?"
User: "No, that's all. Let's test it."
Cline: "Great! Starting the MCP Inspector to test the server connection. After that, we can try controlling the browser from Cline."
Cline’s Actions: Based on your instructions, Cline will perform the following:
cline_mcp_settings.json file or other relevant files based on your instructions.npm run build.cline_mcp_settings.json file.This guide provides a comprehensive walkthrough of building a custom MCP (Model Context Protocol) server from scratch, leveraging the powerful AI capabilities of Cline. The example used will be building a “GitHub Assistant Server” to illustrate the process.
The Model Context Protocol (MCP) acts as a bridge between large language models (LLMs) like Claude and external tools and data. MCP consists of two key components:
This setup is beneficial when you have an MCP-compliant chat interface, like Claude Desktop, which can then leverage these servers to access information and execute actions.
Cline streamlines the process of building and integrating MCP servers by utilizing its AI capabilities to:
npm run build to compile and prepare the server for use.cline_mcp_settings.json file.This section demonstrates how to create a GitHub Assistant server using Cline. This server will be able to interact with GitHub data and perform useful actions:
First, you need to clearly communicate to Cline the purpose and functionalities of your server:
Based on your instructions, Cline starts the project setup process:
create-server tool to generate the basic project structure for your GitHub Assistant server. This usually involves creating a new directory with essential files like package.json, tsconfig.json, and a src folder for your TypeScript code. \@octokit/graphql. Cline will likely ask for your GitHub username or the repositories you want to work with. \package.json file. For example, interacting with the GitHub API will likely require packages like @octokit/graphql, graphql, axios, or similar. \npm install to download and install the dependencies listed in package.json, ensuring your server has all the required libraries to function correctly. \cline_mcp_settings.json file to add your new GitHub Assistant server. This will include:
npm run start or a similar command).GITHUB_TOKEN variable. Cline might ask you for your GitHub personal access token, or it might guide you to safely store it in a separate environment file. \Once Cline has completed the setup and configuration, you are ready to test the server’s functionality:
get_issues: To test retrieving issues, you might say to Cline, “Cline, use the get_issues tool from the GitHub Assistant Server to show me the open issues from the ‘cline/cline’ repository.” Cline would then execute this tool and present you with the results.get_pull_requests: To test pull request retrieval, you could ask Cline to “use the get_pull_requests tool to show me the merged pull requests from the ‘facebook/react’ repository from the last month.” Cline would execute this tool, using your GITHUB_TOKEN to access the GitHub API, and display the requested data. \Development is often iterative. As you work with your GitHub Assistant Server, you’ll discover new functionalities to add, or ways to improve existing ones. Cline can assist in this ongoing process:
create_issue or to get_user_profile. Discuss the required inputs and outputs for these tools with Cline.By following these steps, you can create a custom MCP server from scratch using Cline, leveraging its powerful AI capabilities to streamline the entire process. Cline not only assists with the technical aspects of building the server but also helps you think through the design, functionalities, and potential integrations.
To give you more control over which files are accessible to Cline, we’ve implemented .clineignore functionality, similar to .gitignore. This allows you to specify files and directories that Cline should not access or process. This is useful for:
How to use .clineignore
Create a .clineignore file: In the root directory of your workspace (the same level as your .vscode folder, or the top level folder you opened in VS Code), create a new file named .clineignore.
Define ignore patterns: Open the .clineignore file and specify the patterns for files and directories you want Cline to ignore. The syntax is the same as .gitignore:
Each line in the file represents a pattern.
Standard glob patterns are supported:
* matches zero or more characters? matches one character[] matches a character range** matches any number of directories and subdirectories.Directory patterns: Append / to the end of a pattern to specify a directory.
Negation patterns: Start a pattern with ! to negate (un-ignore) a previously ignored pattern.
Comments: Start a line with # to add comments.
Example .clineignore file:
# Ignore log files
*.log
# Ignore the entire 'node_modules' directory
node_modules/
# Ignore all files in the 'temp' directory and its subdirectories
temp/**
# But DO NOT ignore 'important.log' even if it's in the root
!important.log
# Ignore any file named 'secret.txt' in any subdirectory
**/secret.txt
Cline respects your .clineignore: Once you save the .clineignore file, Cline will automatically recognize and apply these rules.
read_file. If you attempt to use a tool on an ignored file, Cline will inform you that access is blocked due to .clineignore settings.list_files), ignored files and directories will still be listed, but they will be marked with a 🔒 symbol next to their name to indicate that they are ignored. This helps you understand which files Cline can and cannot interact with.Dynamic Updates: Cline monitors your .clineignore file for changes. If you modify, create, or delete your .clineignore file, Cline will automatically update its ignore rules without needing to restart VS Code or the extension.
In Summary
The .clineignore file provides a powerful and flexible way to control Cline’s access to your workspace files, enhancing privacy, performance, and context management. By leveraging familiar .gitignore syntax, you can easily tailor Cline’s focus to the most relevant parts of your projects.