📌Overview

Purpose:
Cline is designed to be an AI-powered assistant that enhances software development workflows by integrating intelligent automation directly into the command line and code editor environments.

Overview:
Cline leverages advanced agentic AI (notably Claude 3.7 Sonnet) to perform complex development tasks step-by-step within your local workspace. It goes beyond basic code completion by offering an interactive, human-in-the-loop interface that can create and edit files, execute shell commands, analyze large codebases, use the browser, and extend its capabilities with custom tools. Safety is prioritized via user approval for all file changes and terminal commands, making powerful automation accessible and secure.

Key Features:

Seamless Integration with CLI and Editor:
Cline can read, edit, and create files in the workspace, and execute terminal commands with real-time feedback, closely integrating with your development flow.
Advanced Task Automation:
Leverages agentic coding to analyze project structure, fix errors (e.g., imports, syntax), handle build/test/deploy, and perform stepwise troubleshooting for even large, complex projects.
Multi-Model & API Provider Support:
Works with OpenRouter, Anthropic, OpenAI, Google Gemini, and more—plus local models via LM Studio/Ollama—automatically updating available models and tracking API usage and cost.
Browser Automation:
Can launch a headless browser to interact with web apps, capture screenshots/logs, and perform end-to-end or visual debugging tasks autonomously.
Custom Tooling via Model Context Protocol (MCP):
Users can extend Cline’s abilities by instructing it to create and integrate custom tools tailored to specific workflows, such as managing cloud resources or automating external services.
Context and Checkpoint Management:
Easily add relevant context (like URLs, error logs, specific files/folders) for focused AI help, with snapshot-based checkpoints to compare or restore your project state at any step for safe experimentation.

Cline – AI Assistant for CLI and Editor

Cline is an AI assistant that can use your Command Line Interface (CLI) and Code Editor to help automate complex software development tasks. Leveraging advanced AI capabilities, Cline assists with tasks such as creating and editing files, exploring large projects, browsing the web, and executing terminal commands with human approval, all within a secure, interactive environment.

Key Features

Intelligent Code Assistance

Enter tasks and add images to convert mockups or fix bugs.
Cline analyzes your file structure, reads relevant files, and manages context to assist with large projects.
Handles tasks such as creating and editing files, monitoring linter/compiler errors, and fixing common issues autonomously.
Executes terminal commands (with your approval) and monitors their output to react to dev server issues or build errors.
For web development, launches a headless browser to test, debug, and fix runtime or visual errors.

Multi-API and Model Support

Supports API providers such as OpenRouter, Anthropic, OpenAI, Google Gemini, AWS Bedrock, Azure, and GCP Vertex.
Can be configured to use any OpenAI-compatible API or local models through LM Studio/Ollama.
Tracks token usage and API costs for transparency on spending.

Terminal Integration

Executes commands directly in your terminal, adapting to your development environment and toolchain.
Handles tasks such as package installation, building, deployment, database management, and running tests.
For long-running processes, allows Cline to continue working while monitoring terminal output for issues.

File Editing with Safety and Control

Creates and edits files, showing a diff view for every change.
You can edit, revert, or provide feedback on changes directly within your editor.
All modifications are tracked in your file's Timeline for easy review and rollback.

Automated Browser Use

Utilizes AI to launch and interact with a browser: clicks, typing, scrolling, taking screenshots, and capturing console logs for debugging and end-to-end testing.
Enables autonomous resolution of visual and runtime issues in web applications.

Extend with Custom Tools

Thanks to the Model Context Protocol, Cline can be extended with custom tools, tailored to your specific workflow needs.
Examples:
- Fetch Jira tickets and process them.
- Manage AWS EC2 instances.
- Pull latest PagerDuty incidents and fix related bugs.

Flexible Context Addition

@url: Supply a URL for Cline to fetch and convert to markdown (e.g., latest docs).
@problems: Add workspace errors and warnings for Cline to fix.
@file: Share file contents directly for review or modification.
@folder: Add all files in a folder for large batch tasks.

Workspace Checkpoints

The extension takes a snapshot of your workspace at each major step.
Use "Compare" to view diffs between snapshots and current state.
"Restore" to roll back to a previous workspace state or task checkpoint, enabling safe exploration of different approaches.

Quick Start

Tip: Use CMD/CTRL + Shift + P and type "Cline: Open In New Tab" to use Cline alongside your file explorer for better workflow visibility.

Contributing

To contribute, see the Contributing Guide. You can also join our Discord to chat with other contributors. Job opportunities can be found on our careers page.

Local Development Instructions

Clone the repository (Requires git-lfs):

git clone https://github.com/cline/cline.git

Open the project in VSCode:
```
code cline
```
Install necessary dependencies:
```
npm run install:all
```
Launch by pressing F5 (or select Run → Start Debugging) in VSCode.

Creating a Pull Request

Generate a changeset entry:
```
npm run changeset
```
- Choose the type of change (major, minor, patch)
- Provide a description
Commit the changes and the generated .changeset file.
Push your branch and create a PR on GitHub. CI will run necessary checks and handle the release cycle.

cline