graph TB
    subgraph VSCode[VS Code Extension]
        EXT[extension.ts]
        subgraph UI[User Interface]
            WP[Webview Panel]
            SB[Sidebar]
            CMD[Commands]
        end
    end
 
    subgraph Core[Core System]
        CP[ClineProvider]
        CL[Cline]
 
        subgraph Modules[Core Modules]
            AM[assistant-message]
            IG[ignore]
            PR[prompts]
            SW[sliding-window]
            WV[webview]
        end
    end
 
    subgraph State[State Management]
        GS[Global State]
        WS[Workspace State]
        SS[Secrets Storage]
    end
 
    subgraph Services[External Services]
        AI[AI Services]
        subgraph APIs
            ANT[Anthropic API]
            OAI[OpenAI API]
            OR[OpenRouter]
        end
        AUTH[Authentication]
        BROW[Browser Control]
    end
 
    %% Main Flow
    EXT -->|activates| CP
    EXT -->|registers| UI
    CP -->|initializes| CL
 
    %% Core Interactions
    CP -->|manages| State
    CL -->|uses| Modules
 
    %% UI Flow
    UI -->|communicates via| CP
    CP -->|updates| UI
 
    %% Service Integration
    CL -->|calls| APIs
    CP -->|manages| AUTH
    CL -->|controls| BROW
 
    classDef vscode fill:#e1f3ff,stroke:#333,stroke-width:2px
    classDef core fill:#ffe1e1,stroke:#333,stroke-width:2px
    classDef state fill:#e1ffe1,stroke:#333,stroke-width:2px
    classDef service fill:#fff0db,stroke:#333,stroke-width:2px
 
    class VSCode,UI vscode
    class Core,Modules core
    class State state
    class Services,APIs service

export function activate(context: vscode.ExtensionContext) {
    // 1. Create output channel
    outputChannel = vscode.window.createOutputChannel("Cline");
 
    // 2. Initialize logging system
    Logger.initialize(outputChannel);
 
    // 3. Create sidebar provider
    const sidebarProvider = new ClineProvider(context, outputChannel);
 
    // 4. Register sidebar view
    context.subscriptions.push(
        vscode.window.registerWebviewViewProvider(
            ClineProvider.sideBarId,
            sidebarProvider,
            {
                webviewOptions: {
                    retainContextWhenHidden: true
                }
            }
        )
    );
}
 
// Registers multiple VS Code commands:
- "cline.plusButtonClicked" // New conversation
- "cline.mcpButtonClicked"  // MCP button
- "cline.popoutButtonClicked" // Pop out to new tab
- "cline.settingsButtonClicked" // Settings
- "cline.historyButtonClicked"  // History
- "cline.accountLoginClicked"   // Account login

graph TB
    subgraph ClineProvider[ClineProvider.ts]
        direction TB
 
        subgraph VSCodeIntegration[VS Code Integration]
            WV[Webview View]
            WP[Webview Panel]
            URI[URI Handler]
        end
 
        subgraph StateSystem[State Management System]
            GS[Global State]
            SS[Secrets Storage]
            WS[Workspace State]
        end
 
        subgraph TaskSystem[Task Management]
            TI[Task Init]
            TC[Task Control]
            TH[Task History]
            CK[Checkpoints]
        end
 
        subgraph AuthSystem[Authentication & API]
            AM[Auth Manager]
            AC[API Config]
            MC[Model Config]
            MH[MCP Hub]
        end
 
        subgraph EventSystem[Event Handling]
            ML[Message Listener]
            EH[Event Handler]
            CB[Callbacks]
        end
 
        subgraph DataManagement[Data Management]
            ST[State]
            CF[Config]
            HI[History]
            SE[Secrets]
        end
    end
 
    %% External Systems
    ExtVSCode[VS Code API]
    ExtAuth[Auth Services]
    ExtAPI[External APIs]
    Cline[Cline.ts]
 
    %% Internal Connections
    StateSystem --> DataManagement
    TaskSystem --> StateSystem
    AuthSystem --> StateSystem
    EventSystem --> TaskSystem
    EventSystem --> AuthSystem
    VSCodeIntegration --> EventSystem
 
    %% External Connections
    VSCodeIntegration --> ExtVSCode
    AuthSystem --> ExtAuth
    AuthSystem --> ExtAPI
    TaskSystem --> Cline
 
    %% State Flow
    DataManagement --> ST
    DataManagement --> CF
    DataManagement --> HI
    DataManagement --> SE
 
    classDef default fill:#f9f9f9,stroke:#333,stroke-width:2px
    classDef system fill:#ffe1e1,stroke:#333,stroke-width:2px
    classDef external fill:#e1f3ff,stroke:#333,stroke-width:2px
    classDef data fill:#e1ffe1,stroke:#333,stroke-width:2px
 
    class VSCodeIntegration,StateSystem,TaskSystem,AuthSystem,EventSystem system
    class ExtVSCode,ExtAuth,ExtAPI,Cline external
    class DataManagement data

graph TB
    subgraph Cline[Cline.ts]
        direction TB
 
        subgraph Settings[Settings]
            CFG[API & System Config]
        end
 
        subgraph Core[Core]
            TM[Task Manager]
            FM[File Manager]
            BM[Browser Manager]
            CM[Checkpoint Manager]
        end
 
        subgraph Operations[Operations]
            TC[Task Control]
            FO[File Operations]
            AI[API Integration]
            TE[Tool Execution]
        end
 
        subgraph UI[UI Interface]
            COM[Communication]
        end
    end
 
    %% Main flows
    Settings --> Core
    Core --> Operations
    Operations --> UI
 
    %% Cross-functional flows
    TC -->|uses| CM
    FO -->|uses| FM
    TE -->|uses| BM
    AI -->|via| COM
 
    classDef settings fill:#e1f3ff,stroke:#333,stroke-width:2px
    classDef core fill:#ffe1e1,stroke:#333,stroke-width:2px
    classDef ops fill:#e1ffe1,stroke:#333,stroke-width:2px
    classDef ui fill:#fff0db,stroke:#333,stroke-width:2px
 
    class Settings settings
    class Core core
    class Operations ops
    class UI ui

sequenceDiagram
    participant User
    participant Webview
    participant ClineProvider
    participant Cline
    participant Tools
    participant AI
 
    User->>Webview: Input task
    Webview->>ClineProvider: Send message
    ClineProvider->>Cline: Create instance
 
    activate Cline
    loop Task Loop
        Cline->>AI: Send request
        AI-->>Cline: Return response
        Cline->>Tools: Execute tool
        Tools->>User: Request confirmation
        User-->>Tools: Confirm execution
        Tools-->>Cline: Return result
        Cline->>AI: Return execution result
    end
    Cline-->>User: Task complete
    deactivate Cline

flowchart TD
    A[AI Request] --> B{AI determines tool type}
    B -->|Command| C[Command execution]
    B -->|File| D[File operations]
    B -->|API| E[API calls]
    B -->|Browser| F[Browser operations]
    C --> G{Needs confirmation?}
    G -->|Yes| H[User confirmation]
    G -->|No| I[Direct execution]
    H --> I
    I --> J[Collect results]
    D --> K[Permission check]
    K --> L[Execute operation]
    L --> J
    E --> M[Validate params]
    M --> N[Call API]
    N --> J
    F --> O[Browser session]
    O --> P[Execute action]
    P --> J
    J --> Q[Return to AI]

class ClineProvider implements vscode.WebviewViewProvider {
    private cline?: Cline
    private view?: vscode.WebviewView
    private context: vscode.ExtensionContext
 
    // Core management features
    async initClineWithTask(task?: string)
    async handleMessage(message: Message)
    async updateState(state: State)
 
    // Define global filenames
    export const GlobalFileNames = {
        apiConversationHistory: "api_conversation_history.json", // API conversation history
        uiMessages: "ui_messages.json", // UI messages
        openRouterModels: "openrouter_models.json", // OpenRouter models
        mcpSettings: "cline_mcp_settings.json", // MCP settings
        clineRules: ".clinerules", // Cline rules
    }
}

class ClineProvider {
    constructor(context: vscode.ExtensionContext) {
        this.context = context
        this.cline = undefined  // Lazy initialization
    }
 
    async initClineWithTask(task?: string) {
        await this.clearTask()  // Clear existing tasks
 
        // Get configuration
        const config = await this.getState()
 
        // Create new instance
        this.cline = new Cline(
            this,
            config.apiConfiguration,
            config.autoApprovalSettings,
            config.browserSettings,
            config.chatSettings,
            config.customInstructions
        )
    }
}

export class Cline {
    // Core properties
    readonly taskId: string;
    api: ApiHandler;
    private terminalManager: TerminalManager;
    private urlContentFetcher: UrlContentFetcher;
    browserSession: BrowserSession;
 
    // State control
    private didEditFile: boolean = false;
    private abort: boolean = false;
    private consecutiveMistakeCount: number = 0;
 
    // History
    apiConversationHistory: Anthropic.MessageParam[] = [];
    clineMessages: ClineMessage[] = [];
 
    // Configuration system
    autoApprovalSettings: AutoApprovalSettings;
    private browserSettings: BrowserSettings;
    private chatSettings: ChatSettings;
 
    // Core task execution method
    async startTask(task?: string, images?: string[]): Promise<void> {
        // Initialize state
        this.clineMessages = [];
        this.apiConversationHistory = [];
 
        // Update interface
        await this.providerRef.deref()?.postStateToWebview();
 
        // Display task
        await this.say("text", task, images);
 
        // Mark initialization complete
        this.isInitialized = true;
 
        // Build initial message
        let imageBlocks = formatResponse.imageBlocks(images);
 
        // Start task loop
        await this.initiateTaskLoop(
            [{
                type: "text",
                text: `<task>\\n${task}\\n</task>`,
            },
            ...imageBlocks],
            true // isNewTask flag
        );
    }
}

private async initiateTaskLoop(
    userContent: UserContent,
    isNewTask: boolean
): Promise<void> {
    let nextUserContent = userContent;
    let includeFileDetails = true;
 
    while (!this.abort) {
        // Core request processing
        const didEndLoop = await this.recursivelyMakeClineRequests(
            nextUserContent,
            includeFileDetails,
            isNewTask
        );
 
        includeFileDetails = false;
 
        if (didEndLoop) {
            break;
        } else {
            // Handle case where tools weren't used
            nextUserContent = [{
                type: "text",
                text: formatResponse.noToolsUsed(),
            }];
            this.consecutiveMistakeCount++;
        }
    }
}

// 1. Cases where this.abort is true:
- User manually aborts
- Serious error occurs
- Cline instance is destroyed
 
// 2. Cases where didEndLoop is true:
- Task successfully completed (using attempt_completion tool)
- Maximum error count reached
- Task marked as complete
 
// 3. Other termination conditions:
- Too many consecutive errors
- API call failure
- Tool execution failure

private async recursivelyMakeClineRequests(
    userContent: UserContent,
    includeFileDetails: boolean,
    isNewTask: boolean
): Promise<boolean> {
    // 1. Error checking
    if (this.consecutiveMistakeCount >= MAX_CONSECUTIVE_MISTAKES) {
        throw new Error("Too many consecutive mistakes")
    }
 
    try {
        // 2. Prepare messages
        const messages = this.prepareMessages(userContent, includeFileDetails)
 
        // 3. Send API request
        const response = await this.api.sendRequest(messages)
 
        // 4. Process response
        if (response.type === "completion") {
            return true  // Task complete
        } else if (response.type === "tool_use") {
            await this.handleToolUse(response.tool)
            return false  // Continue execution
        }
    } catch (error) {
        this.handleError(error)
        return true
    }
}

private prepareMessages(
    userContent: UserContent,
    includeFileDetails: boolean
): MessageParam[] {
    // 1. Build base messages
    const messages = [...this.apiConversationHistory]
 
    // 2. Add environment details
    if (includeFileDetails) {
        messages.push({
            type: "environment_details",
            content: this.getEnvironmentDetails()
        })
    }
 
    // 3. Add user content
    messages.push({
        type: "user_content",
        content: userContent
    })
 
    return messages
}

class ApiHandler {
    async *attemptApiRequest(previousApiReqIndex: number) {
        // 1. System prompt preparation
        let systemPrompt = await SYSTEM_PROMPT(
            cwd,
            this.api.getModel().info.supportsComputerUse,
            mcpHub,
            this.browserSettings
        );
 
        // 2. Context preprocessing
        const { truncatedHistory, deletedRange } = this.truncateHistoryToFitContext(
            previousApiReqIndex
        );
 
        // 3. Streaming communication
        const stream = this.api.createMessage(systemPrompt, truncatedHistory);
        yield* this.handleStreamResponse(stream);
    }
 
    private truncateHistoryToFitContext(previousIndex: number) {
        const totalTokens = this.calculateTokensUsage();
 
        switch (this.contextWindow) {
            case 64_000: // deepseek models
                this.maxAllowedSize = this.contextWindow - 27_000;
                break;
            case 128_000: // most models
                this.maxAllowedSize = this.contextWindow - 30_000;
                break;
        }
 
        if (totalTokens >= this.maxAllowedSize) {
            return this.performTruncation();
        }
 
        return { truncatedHistory: this.history };
    }
}

export const toolUseNames = [
    "execute_command",
    "read_file",
    "write_to_file",
    "replace_in_file",
    "search_files",
    "list_files",
    "list_code_definition_names",
    "browser_action",
    "use_mcp_tool",
    "access_mcp_resource",
    "ask_followup_question",
    "plan_mode_response",
    "attempt_completion",
] as const

async executeCommandTool(command: string): Promise<[boolean, ToolResponse]> {
    // 1. Terminal management
    const terminalInfo = await this.terminalManager.getOrCreateTerminal(cwd)
    terminalInfo.terminal.show()
 
    // 2. Execute command
    const process = this.terminalManager.runCommand(terminalInfo, command)
 
    // 3. Output processing
    process.on("line", (line) => {
        result += line + "\\n"
        if (!didContinue) {
            sendCommandOutput(line)
        } else {
            this.say("command_output", line)
        }
    })
 
    // 4. Wait for completion
    await process
 
    // 5. Return result
    return [completed, formatResult(result)]
}

class FileOperations implements Tool {
    // File reading
    async readFile(path: string): Promise<string> {
        return fs.readFile(path, 'utf8');
    }
 
    // File writing
    async writeFile(path: string, content: string): Promise<void> {
        await this.ensureDirectoryExists(path);
        await fs.writeFile(path, content);
    }
 
    // File replacement
    async replaceInFile(path: string, diff: string): Promise<void> {
        const content = await this.readFile(path);
        const newContent = await constructNewFileContent(diff, content);
        await this.writeFile(path, newContent);
    }
 
    // File listing
    async listFiles(path: string, recursive: boolean): Promise<string[]> {
        if (recursive) {
            return this.recursiveListFiles(path);
        }
        return fs.readdir(path);
    }
}

class FileOperationApproval {
    async checkFileAccess(operation: FileOperation): Promise<boolean> {
        // 1. Path safety check
        if (!this.isPathSafe(operation.path)) {
            return false;
        }
 
        // 2. Operation permission check
        if (!this.hasPermission(operation.type)) {
            return false;
        }
 
        // 3. Content safety check
        if (operation.type === 'write' && !this.isContentSafe(operation.content)) {
            return false;
        }
 
        return true;
    }
 
    private isPathSafe(path: string): boolean {
        // Check if path is within working directory
        // Prevent directory traversal attacks
        const normalizedPath = normalizePath(path);
        return isWithinWorkspace(normalizedPath);
    }
}

class CommandSecurity {
    private readonly restrictedCommands: Set<string> = new Set([
        'rm -rf',
        'format',
        'shutdown',
        // ... other dangerous commands
    ]);
 
    async validateCommand(command: string): Promise<boolean> {
        // 1. Check if restricted command
        if (this.isRestrictedCommand(command)) {
            return false;
        }
 
        // 2. Check command permissions
        if (!await this.checkCommandPermissions(command)) {
            return false;
        }
 
        // 3. Check resource limits
        if (!this.checkResourceLimits(command)) {
            return false;
        }
 
        return true;
    }
 
    private isRestrictedCommand(command: string): boolean {
        return Array.from(this.restrictedCommands).some(
            restricted => command.includes(restricted)
        );
    }
}

class CheckpointSystem {
    private checkpoints: Map<string, Checkpoint> = new Map();
 
    // Create checkpoint
    async createCheckpoint(): Promise<string> {
        const checkpoint = {
            id: generateId(),
            timestamp: Date.now(),
            state: await this.captureCurrentState(),
            files: await this.captureFileState()
        };
 
        this.checkpoints.set(checkpoint.id, checkpoint);
        return checkpoint.id;
    }
 
    // Restore checkpoint
    async restoreCheckpoint(id: string): Promise<void> {
        const checkpoint = this.checkpoints.get(id);
        if (!checkpoint) {
            throw new Error('Checkpoint not found');
        }
 
        await this.restoreState(checkpoint.state);
        await this.restoreFiles(checkpoint.files);
    }
}