### Parallel Tool Execution Prompt Example

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/LEARNING_FROM_OPEN_SOURCE.md

Provides an example of a system prompt guiding an agent to execute multiple read/search tools in parallel for improved performance. It emphasizes that read operations can be parallelized, while write operations require sequential execution or locking to avoid conflicts. Validation steps should also run serially after modifications. This strategy can achieve significant speedups.

```text
When gathering context information, call multiple read/search tools in parallel:
- Example: readFile(A) + searchText(B) + listFiles(C) simultaneously
- Only use sequential execution when later tools depend on earlier results
- Parallel execution can achieve 3-5x speedup
```

--------------------------------

### Same.dev Linter Loop Example

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/sources/notes-system-prompts.md

This example illustrates a typical linting loop in Same.dev. It involves editing files, running the linter, fixing reported errors, and re-running the linter until no errors are found. It includes a failsafe to stop after multiple attempts.

```text
1. edit_file (or string_replace)
2. run_linter → finds 3 errors
3. Fix errors (clear plan)
4. run_linter → still 1 error
5. Fix again
6. run_linter → no errors → continue
(If still failing after 3rd attempt → stop and ask user)
```

--------------------------------

### API Examples: List Java Files, Read File, Search Pattern

Source: https://github.com/cuipengfei/simple-coder/blob/main/CLAUDE.md

Demonstrates how to interact with the Simple Coder API to perform common file operations. These examples use cURL to send POST requests with JSON payloads to the agent endpoint.

```bash
# List Java files
curl -X POST http://localhost:8080/api/agent \
  -H "Content-Type: application/json" \
  -d '{"prompt":"list all java files","toolType":"auto","contextHistory":[]}'
```

```bash
# Read file segment
curl -X POST http://localhost:8080/api/agent \
  -H "Content-Type: application/json" \
  -d '{"prompt":"Read src/main/java/com/simplecoder/service/AgentService.java lines 1-40","toolType":"auto","contextHistory":[]}'
```

```bash
# Search pattern
curl -X POST http://localhost:8080/api/agent \
  -H "Content-Type: application/json" \
  -d '{"prompt":"search for AgentService in src/main/java","toolType":"auto","contextHistory":[]}'
```

--------------------------------

### Spring Boot: Running the Application

Source: https://github.com/cuipengfei/simple-coder/blob/main/slides.html

This command demonstrates how to run the Simple Coder project using Maven. Executing this command will start the Spring Boot application, making it accessible via a browser.

```bash
mvn spring-boot:run
```

--------------------------------

### Portable Shell Command Example

Source: https://github.com/cuipengfei/simple-coder/blob/main/AGENTS.md

Provides an example of a minimally portable shell command for finding Java files and limiting the output. This adheres to the policy of preferring `bash`/POSIX equivalents over PowerShell cmdlets.

```bash
find . -name '*.java' | head -20
```

--------------------------------

### Application Configuration Example

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/IMPLEMENTATION.md

Illustrates the configuration properties for the simple-coder application, including repository root, timeouts for shell commands, and AI service settings. This YAML excerpt defines essential parameters for the project's operation.

```yaml
simple-coder:
  repo-root: ${user.dir}
  max-file-lines: 500
  max-search-results: 50
  max-list-results: 200
  agent:
    max-steps: 10
  bash:
    timeout: 60
  powershell:
    timeout: 60

spring:
  ai:
    openai:
      api-key: dummy-local
      base-url: http://localhost:4141
      chat:
        options:
          model: gpt-4.1

server:
  port: 8080

logging:
  level:
    org.springframework.ai: DEBUG
    com.simplecoder.config.SimpleLoggerAdvisor: INFO
```

--------------------------------

### Project Dependencies Example

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/IMPLEMENTATION.md

Lists the core dependencies required for the simple-coder project, including web starter, OpenAI AI starter, Lombok for boilerplate code reduction, and testing utilities. Dependency versions for spring-ai are managed by the spring-ai-bom.

```xml
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-starter-model-openai</artifactId>
        <!-- Version managed by spring-ai-bom -->
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>
```

--------------------------------

### Example API Request to Simple Coder

Source: https://github.com/cuipengfei/simple-coder/blob/main/slides.html

This is an example of a JSON payload that can be sent to the Simple Coder API's `/api/agent` endpoint. It includes a user prompt and an empty `contextHistory`, suitable for initiating a new conversation.

```json
{
  "prompt": "列出所有 Java 文件",
  "contextHistory": []
}
```

--------------------------------

### Amp Build Fix Workflow Example

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/sources/notes-system-prompts.md

This workflow demonstrates a sequence of steps for running a build process and fixing type errors. It involves running the build, identifying errors, marking tasks, fixing errors iteratively, and finally running diagnostics and rebuilding.

```text
User: "Run the build and fix any type errors"
1. todo_write: ["Run the build", "Fix any type errors"]
2. npm run build → reports 10 type errors
3. todo_write: ["Fix error 1", "Fix error 2", ..., "Fix error 10"]
4. Mark each in_progress
5. Fix error 1 → mark completed
6. Fix error 2 → mark completed
   ...
7. After all fixed: run get_diagnostics + rebuild
```

--------------------------------

### YAML Configuration for Agent Environment and Model

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/syntheses/architecture-patterns.md

Provides an example of YAML configuration for defining an agent's environment and model. This configuration is used for protocol implementation and allows for runtime specification of components like DockerEnvironment and AnthropicModel.

```yaml
environment:
  class: "DockerEnvironment"
  image: "sweagent/swe-bench:latest"

model:
  class: "AnthropicModel"
  name: "claude-3-5-sonnet-20241022"
```

--------------------------------

### JSON for Qoder Search Replace Tool

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/syntheses/code-modification.md

Example JSON configuration for Qoder's 'search_replace' tool, demonstrating how to specify file paths and multiple replacement rules, including an option to replace all occurrences.

```json
{
  "file_path": "design.md",
  "replacements": [
    {
      "original_text": "## Old Section Title",
      "new_text": "## New Section Title"
    },
    {
      "original_text": "- Feature A\n- Feature B",
      "new_text": "- Feature A (enhanced)\n- Feature B\n- Feature C (new)",
      "replace_all": false
    }
  ]
}
```

--------------------------------

### Task Management System Example (Amp's TODO)

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/LEARNING_FROM_OPEN_SOURCE.md

Demonstrates a task management system, exemplified by Amp's TODO list, using YAML format. It outlines key principles such as immediately marking tasks as completed, decomposing errors into subtasks, and displaying progress in a UI for transparency. This system helps agents stay organized and provides users with visibility into the agent's reasoning and progress.

```yaml
todo_write([
  {id: 1, content: "Run the build", status: "in_progress"},
  {id: 2, content: "Fix error 1", status: "todo"},
  {id: 3, content: "Fix error 2", status: "todo"}
])

# Key principles
- Mark task as completed IMMEDIATELY after finishing, not batched
- When errors occur, decompose into specific subtasks
- Display progress in UI so user sees what agent is doing
```

--------------------------------

### Agent Communication Strategy Example

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/LEARNING_FROM_OPEN_SOURCE.md

Illustrates the communication strategy for development agents, emphasizing conciseness and avoiding direct code output. Instead of naming tools, agents should describe their actions naturally. This improves user experience and maintains a clear separation between the agent's actions and the underlying tools.

```plaintext
❌ Bad: "I will use the edit_file tool to modify the code"
✅ Good: "I'll update the configuration to fix the issue"
```

--------------------------------

### Simple Coder Java: Agent Execution Example

Source: https://github.com/cuipengfei/simple-coder/blob/main/slides.html

This Java snippet illustrates how Simple Coder might execute a tool call response. It shows a method that takes a tool name and arguments, then proceeds to execute the corresponding tool, returning a success response.

```java
// Assuming AgentService.java handles tool execution
public ToolResponse executeTool(String toolName, Map<String, String> arguments) {
    // Logic to map toolName to a method in ToolsService and execute it
    if ("listFiles".equals(toolName)) {
        String path = arguments.get("path");
        List<String> files = toolsService.listFiles(path);
        return ToolResponse.success("Files found:", files.toString());
    } 
    // ... other tool implementations
    return ToolResponse.error("Unknown tool: " + toolName);
}
```

--------------------------------

### API Request and Response Examples

Source: https://github.com/cuipengfei/simple-coder/blob/main/AGENTS.md

Demonstrates a typical JSON API request to execute a command within the agent, and a successful JSON response indicating tool execution results, including potential truncation of output. This serves as a reference for interacting with the agent's execution API.

```json
POST /api/agent
{
  "prompt": "Read src/main/java/com/simplecoder/service/AgentService.java lines 1-40",
  "toolType": "auto",
  "contextHistory": []
}
```

```json
{
  "success": true,
  "message": "Tool execution result",
  "data": "Read ... (lines 1-40 of X total)\n\n<file content>",
  "error": null
}
```

--------------------------------

### Code Modification Placeholder Convention Example

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/LEARNING_FROM_OPEN_SOURCE.md

This demonstrates a convention for marking modified code sections using placeholders. It helps to avoid returning the entire file, saving tokens, and clearly indicates which parts of the code have been changed, facilitating user review.

```javascript
// ... keep existing code ...  // unchanged code
const result = newValue;       // only this line changed
// ... rest of code ...         // subsequent code
```

--------------------------------

### Bash Shell Execution Policy Example

Source: https://github.com/cuipengfei/simple-coder/blob/main/AGENTS.md

Illustrates the recommended way to execute shell commands that require shell features like pipes or environment variables. It specifies using `bash -lc` for multi-command invocations to ensure portability and avoid PowerShell-specific syntax.

```bash
command:["bash","-lc","<commands>"]
```

--------------------------------

### Apply Patch Virtual Command Example

Source: https://github.com/cuipengfei/simple-coder/blob/main/AGENTS.md

Demonstrates the mandatory use of the `apply_patch` virtual command for all repository file operations, including creation, modification, rename, or deletion. This ensures atomic and reviewable changes, prohibiting direct mutation via shell redirection or in-place editors.

```bash
command:["apply_patch","*** Begin Patch\n...\n*** End Patch\n"]
```

--------------------------------

### Execute Agent Request - Multi-step Task with History (Bash)

Source: https://context7.com/cuipengfei/simple-coder/llms.txt

Executes a multi-step agent request that utilizes context history. This example asks about available tools in 'ToolsService' after a previous request to list Java files. The agent uses the history to provide a detailed response about the identified tools.

```bash
curl -X POST http://localhost:8080/api/agent \
  -H "Content-Type: application/json" \
  -d '{ \
    "prompt": "What tools are available in ToolsService?", \
    "toolType": "auto", \
    "contextHistory": [ \
      { \
        "timestamp": "2025-10-29T10:00:00", \
        "prompt": "list all java files", \
        "result": "Found 14 Java files in the project" \
      } \
    ] \
  }'
```

--------------------------------

### Preserve Indentation with Python Example

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/syntheses/code-modification.md

This Python example demonstrates how to correctly capture and use 'old_string' for code modification, emphasizing the preservation of exact indentation. Incorrect indentation can lead to failures, especially when 'old_string' is not unique and 'replace_all' is not used. It's crucial to maintain the indentation level present in the original code.

```python
# Read tool output
    1→def example():
    2→    result = old_value  # note: 2 spaces indentation
    3→    return result

# old_string (correct) - preserves exact indentation
old_string = "    result = old_value"  # 4 spaces (after line number)

# old_string (incorrect) - indentation mismatch
old_string = "  result = old_value"  # 2 spaces
```

--------------------------------

### Python Function for Data Processing

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/syntheses/code-modification.md

A Python function that processes data by first validating and transforming it, then saving the result. This serves as an example of the 'lov-line-replace' operation's output.

```python
def process_data(data):
    # Data processing steps
    validate_and_transform(data)
    save(data)
    return data
```

--------------------------------

### Python Example: String Replace Functionality

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/syntheses/code-modification.md

Demonstrates a Python function for replacing all occurrences of a substring within a larger string. This is a fundamental operation used in various code modification strategies.

```python
def string_replace(content: str, old_str: str, new_str: str) -> str:
    """Replaces all occurrences of old_str with new_str in the content."""
    return content.replace(old_str, new_str)
```

--------------------------------

### JavaScript Function with Placeholder

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/syntheses/code-modification.md

A JavaScript function example demonstrating the use of placeholders for keeping existing code while inserting new functionality. This is a common convention across various code editing tools.

```javascript
function example() {
    // ... keep existing code 
    newCode();
    // ... keep existing code 
}
```

--------------------------------

### Bash Example: Sed for In-Place Replacement

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/syntheses/code-modification.md

Shows how to use the `sed` command in Bash for in-place replacement of text within a file. This is often used when validation needs are lower or for quick, non-unique replacements.

```bash
# Replace all occurrences of 'old_text' with 'new_text' in 'file.txt'
sed -i 's/old_text/new_text/g' file.txt
```

--------------------------------

### Common Maven Commands for Compilation, Testing, and Running

Source: https://github.com/cuipengfei/simple-coder/blob/main/CLAUDE.md

Provides a list of essential Maven commands for managing the project build lifecycle. These include compiling code, running tests (individually or in groups), and executing the Spring Boot application.

```bash
mvn clean compile          # Compile
```

```bash
mvn test                   # Run all tests
```

```bash
mvn test -Dtest=ToolRequestTest                # Single test class
```

```bash
mvn test -Dtest="ToolRequestTest,ToolResponseTest"  # Multiple test classes
```

```bash
mvn spring-boot:run        # Run app (port 8080)
```

```bash
mvn clean package          # Build jar
```

--------------------------------

### Jinja2 Template System for Output Truncation

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/LEARNING_FROM_OPEN_SOURCE.md

Demonstrates the use of Jinja2 templates for dynamic prompt generation and output truncation. This system allows for conditional formatting of output based on its length, ensuring that long outputs are presented in a truncated manner with clear indicators of elided content, useful for managing LLM responses.

```jinja2
{% if output|length < max_output_length %}
<output>{{ output }}</output>
{% else %}
<output_head>{{ output[:max_output_length//2] }}</output_head>
<elided_chars>{{ output|length - max_output_length }}</elided_chars>
<output_tail>{{ output[-max_output_length//2:] }}</output_tail>
{% endif %}
```

--------------------------------

### Spring Boot: Running Tests

Source: https://github.com/cuipengfei/simple-coder/blob/main/slides.html

This command shows how to execute the project's tests using Maven. Running tests is crucial for verifying the functionality and stability of the Simple Coder application.

```bash
mvn test
```

--------------------------------

### Tool Invocation via cURL (Bash)

Source: https://context7.com/cuipengfei/simple-coder/llms.txt

Example of how to invoke the replaceText tool using a cURL command. This demonstrates sending a JSON payload with the prompt, tool type, and context history to an agent endpoint.

```bash
# Safe replacement example
curl -X POST http://localhost:8080/api/agent \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "change max-file-lines from 500 to 1000 in application.yml",
    "toolType": "auto",
    "contextHistory": []
  }'

# Agent calls: replaceText("src/main/resources/application.yml", "max-file-lines: 500", "max-file-lines: 1000")

```

--------------------------------

### DefaultAgent run() Method Implementation

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/sources/notes-mini-swe-agent.md

Implements the main execution loop for the DefaultAgent. It initializes the message history with system and user prompts, then repeatedly calls the step() method to process tasks. Handles non-terminating and terminating exceptions, returning the final status and message upon termination.

```python
def run(self) -> tuple[str, str]:
    # 1. initialize message history
    self.messages = [
        {"role": "system", "content": self.render_template(system_template)},
        {"role": "user", "content": self.render_template(instance_template)}
    ]

    # 2. main loop
    while True:
        try:
            self.step()  # execute single step
        except NonTerminatingException as e:
            # append error to history, continue
            self.add_message("user", str(e))
        except TerminatingException as e:
            # return exit status and message
            return (type(e).__name__, str(e)))
```

--------------------------------

### Python Function with Placeholder (Recommended)

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/syntheses/code-modification.md

An example of a recommended placeholder usage in Python for editing large files. It uses '// ... existing code ...' to denote unchanged sections, improving readability and reducing token consumption.

```python
# Large file edit (300 lines)
def complex_function():
    # ... existing code ...

# Only this section changed
    new_logic = optimized_approach()

    # ... existing code ...

```

--------------------------------

### Execute Agent Request - Error Handling (Bash)

Source: https://context7.com/cuipengfei/simple-coder/llms.txt

Demonstrates error handling for an agent request. This example attempts to replace text in a non-existent file. The response shows 'success: false' along with an error message indicating the file was not found.

```bash
curl -X POST http://localhost:8080/api/agent \
  -H "Content-Type: application/json" \
  -d '{ \
    "prompt": "replace \"foo\" with \"bar\" in nonexistent.txt", \
    "toolType": "auto", \
    "contextHistory": [] \
  }'
```

--------------------------------

### HTML Frontend - Single Page Application

Source: https://github.com/cuipengfei/simple-coder/blob/main/README.md

前端代码实现了一个单页应用（SPA），提供用户输入、执行按钮、结果展示区以及交互记录功能。它使用原生 HTML、Fetch API 和 TailwindCDN 来构建用户界面，并处理加载和错误状态提示。

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Simple Coder</title>
    <script src="https://cdn.tailwindcss.com"></script>
    <style>
        .result-display {
            white-space: pre-wrap; /* Preserve whitespace and line breaks */
            word-wrap: break-word; /* Break long words */
        }
    </style>
</head>
<body class="bg-gray-100 p-8">

    <div class="max-w-4xl mx-auto bg-white p-6 rounded-lg shadow-md">
        <h1 class="text-3xl font-bold mb-4 text-center">Simple Coder</h1>
        <p class="text-center text-gray-600 mb-6">Interact with the AI Coder Agent</p>

        <div class="mb-4">
            <label for="promptInput" class="block text-sm font-medium text-gray-700">Your Prompt:</label>
            <textarea id="promptInput" rows="4" class="mt-1 block w-full rounded-md border-gray-300 shadow-sm focus:border-indigo-500 focus:ring-indigo-500 sm:text-sm"></textarea>
        </div>

        <div class="flex justify-center mb-6">
            <button id="executeButton" class="inline-flex items-center px-6 py-3 border border-transparent rounded-md shadow-sm text-white bg-indigo-600 hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500">
                Execute
            </button>
        </div>

        <div id="statusMessage" class="text-center text-gray-500 mb-4"></div>

        <h2 class="text-xl font-semibold mb-3">Results:</h2>
        <div id="resultsArea" class="bg-gray-50 p-4 rounded-md border border-gray-200 result-display h-64 overflow-y-auto">
            <p>Results will appear here...</p>
        </div>

        <h2 class="text-xl font-semibold mt-6 mb-3">Interaction History (Last 20):</h2>
        <div id="historyArea" class="bg-gray-50 p-4 rounded-md border border-gray-200 h-48 overflow-y-auto">
            <p>History will be logged here...</p>
        </div>
    </div>

    <script>
        const promptInput = document.getElementById('promptInput');
        const executeButton = document.getElementById('executeButton');
        const resultsArea = document.getElementById('resultsArea');
        const historyArea = document.getElementById('historyArea');
        const statusMessage = document.getElementById('statusMessage');
        const MAX_HISTORY_ITEMS = 20;

        let history = [];

        function updateHistory() {
            historyArea.innerHTML = '';
            // Display most recent items first, up to MAX_HISTORY_ITEMS
            const itemsToDisplay = history.slice(-MAX_HISTORY_ITEMS).reverse();
            if (itemsToDisplay.length === 0) {
                historyArea.innerHTML = '<p>History is empty.</p>';
                return;
            }
            itemsToDisplay.forEach(item => {
                const p = document.createElement('p');
                p.className = 'text-sm mb-1';
                p.innerHTML = `<strong>${item.role}:</strong> ${item.content}`;
                historyArea.appendChild(p);
            });
        }

        function addToHistory(role, content) {
            history.push({ role, content });
            updateHistory();
        }

        async function executeAgent() {
            const prompt = promptInput.value.trim();
            if (!prompt) {
                statusMessage.textContent = 'Please enter a prompt.';
                statusMessage.style.color = 'red';
                return;
            }

            statusMessage.textContent = 'Processing...';
            statusMessage.style.color = 'blue';
            executeButton.disabled = true;
            resultsArea.innerHTML = '<p>Waiting for response...</p>';

            // Prepare context history for the request
            // Convert history strings to the expected format if necessary
            // For this example, assume history is already in the format required by the backend.
            // If the backend expects a specific structure for contextHistory, adjust here.
            const requestContextHistory = history.map(item => ({
                role: item.role,
                content: item.content
            }));

            const requestBody = {
                prompt: prompt,
                contextHistory: requestContextHistory
            };

            try {
                const response = await fetch('/api/agent', {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json'
                    },
                    body: JSON.stringify(requestBody)
                });

                if (!response.ok) {
                    const errorData = await response.json().catch(() => ({ message: 'Unknown error' }));
                    throw new Error(`HTTP error! status: ${response.status}, message: ${errorData.message || 'Unknown error'}`);
                }

                const result = await response.json();

                // Add user prompt to history
                addToHistory('You', prompt);

                if (result.success) {
                    statusMessage.textContent = 'Success!';
                    statusMessage.style.color = 'green';
                    resultsArea.innerHTML = `<p class='result-display'>${result.message || JSON.stringify(result.data, null, 2)}</p>`;
                    // Add agent response to history
                    addToHistory('Agent', result.message || JSON.stringify(result.data, null, 2));
                } else {
                    statusMessage.textContent = `Error: ${result.message}`;
                    statusMessage.style.color = 'red';
                    resultsArea.innerHTML = `<p class='result-display text-red-500'>${result.message}</p>`;
                    // Add error to history
                    addToHistory('Agent (Error)', result.message);
                }

            } catch (error) {
                console.error('Fetch error:', error);
                statusMessage.textContent = `Failed
```

--------------------------------

### Simple Coder: Technical Stack Overview

Source: https://github.com/cuipengfei/simple-coder/blob/main/slides.html

This table outlines the core technologies and versions used in the Simple Coder project. It highlights Java, Spring Boot, Spring AI, native HTML/Fetch API for the frontend, JUnit 5 for testing, and Maven for building.

```markdown
| Component       | Version/Technology |
|-----------------|--------------------|
| Java            | 21                 |
| Spring Boot     | 3.5.6              |
| Spring AI       | 1.0.3 (ChatClient + @Tool) |
| Frontend        | Native HTML + Fetch API |
| Testing         | JUnit 5            |
| Build           | Maven              |
```

--------------------------------

### File Creation Operations

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/sources/notes-system-prompts.md

Details the functionality for creating new files or overwriting existing ones across different platforms. Each tool may have specific use cases or content limitations.

```amp
// Amp create_file:
// file_path: "path/to/new_file.js"
// content: "// Content for the new file"
```

```lovable
// Lovable lov-write:
// file_path: "path/to/new_file.js"
// content: "// Content for the new file"
// Primarily for new files or as a fallback.
```

```qoder
// Qoder create_file:
// file_path: "path/to/new_design_file.md"
// content: "# Design Document\n..." (limit 600 lines)
// Used for creating new design files.
```

--------------------------------

### Simple Coder: Key Features

Source: https://github.com/cuipengfei/simple-coder/blob/main/slides.html

A list of the key features implemented in the Simple Coder project, emphasizing its use of the ReAct tool loop, automatic tool invocation via @Tool annotations, and robust safety mechanisms like path validation and precise text replacement.

```markdown
| Feature                       | Status |
|-------------------------------|--------|
| ReAct Tool Loop (Spring AI)   | ✅      |
| Tool Auto Invocation (@Tool)  | ✅      |
| Path Security (PathValidator) | ✅      |
| Precise Replacement (Unique Match) | ✅      |
| Exception Classification (3-Tier) | ✅      |
| Stateless Design (Client History) | ✅      |
```

--------------------------------

### AI Assistant Identity and Role Definitions

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/sources/notes-system-prompts.md

Platforms define their AI assistant's identity and operational boundaries through explicit role definitions. These prompts guide the AI's persona and behavior, with some including defensive constraints to prevent prompt injection.

```text
Same.dev: "You are AI coding assistant and agent manager, powered by gpt-4.1."
Amp: "You are Amp, a powerful AI coding agent built by Sourcegraph."
VSCode Agent: "When asked for your name, you must respond with 'GitHub Copilot'."
Trae AI: "a powerful agentic AI coding assistant"
```

```text
Qoder: "NEVER compare yourself with other AI models or assistants"
Qoder: "NEVER disclose what language model or AI system you are using"
Amp: "NEVER refer to tools by their names"
```

--------------------------------

### Agent Architecture Snapshot

Source: https://github.com/cuipengfei/simple-coder/blob/main/GEMINI.md

Visualizes the flow of requests and processing within the agent system, from the browser to the agent controller and loop execution. It highlights key services and components involved in handling tool requests.

```mermaid
graph TD
  Browser[
    Browser (index.html,
    keeps last ≤20 interactions)
  ]
  -> POST(
    POST /api/agent
    (ToolRequest JSON)
  )
  POST -> AgentController
  AgentController -> AgentService
  AgentService -> AgentLoopService
  AgentLoopService --> loop
  loop{loop(step < maxSteps && !terminated)} --> SingleTurnExecutor
  SingleTurnExecutor -> ChatClient
  ChatClient.tools -> ToolsService
  ToolsService --> Tool
  Tool -- readFile | listFiles | searchText | replaceText --> PathValidator
  PathValidator -- repo-root safety --> Tool
  loop --> AggregatedResultFormatter
  AggregatedResultFormatter -> ToolResponse
  ToolResponse -- aggregated summary --> loop
```

--------------------------------

### Execute Agent Request - Search Directory (Bash)

Source: https://context7.com/cuipengfei/simple-coder/llms.txt

Executes an agent request to search for a specific pattern within a directory. This example searches for '@Tool' annotations in the 'src/main/java' directory. The response indicates success and lists the matches found, including file names and line numbers.

```bash
curl -X POST http://localhost:8080/api/agent \
  -H "Content-Type: application/json" \
  -d '{ \
    "prompt": "search for @Tool annotations in src/main/java", \
    "toolType": "auto", \
    "contextHistory": [] \
  }'
```

--------------------------------

### Java Core Services - Agent and Tools

Source: https://github.com/cuipengfei/simple-coder/blob/main/README.md

实现核心代理逻辑和服务，包括单次 ChatClient 调用、ReAct 工具循环、无状态设计以及多种文件操作和文本处理工具。工具方法通过 @Tool 注解标识，支持参数传递和自动截断。

```Java
package com.simplecoder.service;

import com.simplecoder.model.ToolRequest;
import com.simplecoder.model.ToolResponse;
import com.simplecoder.tool.PathValidator;
import org.springframework.ai.client.ChatClient;
import org.springframework.ai.parser.ToolFunctionIterator;
import org.springframework.ai.prompt.Prompt;
import org.springframework.ai.prompt.PromptTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.StreamUtils;

import java.io.IOException;
import java.nio.file.*;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Service
public class AgentService {

    private final ChatClient chatClient;
    private final ToolsService toolsService;

    public AgentService(ChatClient chatClient, ToolsService toolsService) {
        this.chatClient = chatClient;
        this.toolsService = toolsService;
    }

    public ToolResponse process(ToolRequest request) {
        // Spring AI 内部处理 ReAct 工具循环
        // 无状态设计，每次请求独立处理
        // 上下文由客户端随请求传入 (ToolRequest.contextHistory)
        PromptTemplate promptTemplate = new PromptTemplate("{prompt}\nContext:\n{contextHistory}");
        Prompt prompt = promptTemplate.create(request.getPrompt(), request.getContextHistory());

        var result = chatClient.prompt(prompt)
                .generators(List.of(toolsService))
                .call();

        // 假设 result.getResult() 包含 ToolResponse 或类似的结构
        // 这里需要根据实际 Spring AI 返回类型进行适配
        // 示例：如果返回的是文本，需要解析；如果是结构化数据，直接转换
        // For simplicity, assume it directly returns a ToolResponse object or can be cast
        if (result.getResult() instanceof ToolResponse) {
            return (ToolResponse) result.getResult();
        } else {
            // Handle cases where the result is not a ToolResponse, e.g., plain text or an error message
            return new ToolResponse(false, "Processing failed or returned unexpected format: " + result.getResult().toString(), null);
        }
    }
}

@Service
class ToolsService {

    private static final int MAX_FILE_LINES = 500;
    private static final int MAX_LIST_RESULTS = 200;
    private static final int MAX_SEARCH_RESULTS = 50;

    private final PathValidator pathValidator;

    public ToolsService(PathValidator pathValidator) {
        this.pathValidator = pathValidator;
    }

    /**
     * @param filePath   The path to the file.
     * @param startLine  The starting line number (inclusive).
     * @param endLine    The ending line number (inclusive).
     * @return The content of the file within the specified line range.
     */
    @org.springframework.ai.model.Tool
    public String readFile(String filePath, Integer startLine, Integer endLine) throws IOException {
        Path path = pathValidator.validatePath(filePath);
        StringBuilder content = new StringBuilder();
        try (var lines = Files.lines(path)) {
            lines.skip(Math.max(0, startLine - 1))
                 .limit(endLine - Math.max(0, startLine - 1) + 1)
                 .limit(MAX_FILE_LINES)
                 .forEach(line -> content.append(line).append(System.lineSeparator()));
        }
        return content.toString();
    }

    /**
     * @param path The directory path or glob pattern.
     * @return A list of files matching the path or pattern.
     */
    @org.springframework.ai.model.Tool
    public List<String> listFiles(String path) throws IOException {
        Path startPath = pathValidator.validatePath(Paths.get(path).getParent() != null ? path : ".");
        try (var walk = Files.walk(startPath, FileVisitOption.FOLLOW_LINKS))
        {
            return walk.filter(Files::isRegularFile)
                       .map(Path::toString)
                       .limit(MAX_LIST_RESULTS)
                       .toList();
        }
    }

    /**
     * @param pattern       The text pattern to search for.
     * @param searchPath    The directory or file path to search within.
     * @param isRegex       Whether the pattern is a regular expression.
     * @param caseSensitive Whether the search should be case-sensitive.
     * @return A list of file:line:snippet entries matching the pattern.
     */
    @org.springframework.ai.model.Tool
    public List<String> searchText(String pattern, String searchPath, boolean isRegex, boolean caseSensitive) throws IOException {
        Path path = pathValidator.validatePath(searchPath);
        List<String> results = new java.util.ArrayList<>();
        Pattern compiledPattern = isRegex ? Pattern.compile(pattern, caseSensitive ? 0 : Pattern.CASE_INSENSITIVE)
                                          : Pattern.quote(pattern);

        try (var walk = Files.walk(path)) {
            for (Path file : (Iterable<Path>) walk::iterator) {
                if (Files.isRegularFile(file)) {
                    int lineNumber = 0;
                    try (var lines = Files.lines(file)) {
                        for (String line : (Iterable<String>) lines::iterator) {
                            lineNumber++;
                            Matcher matcher = compiledPattern.matcher(line);
                            if (matcher.find()) {
                                results.add(String.format("%s:%d:%s", file.toString(), lineNumber, line.trim()));
                                if (results.size() >= MAX_SEARCH_RESULTS) return results;
                            }
                        }
                    }
                }
            }
        }
        return results;
    }

    /**
     * @param filePath  The path to the file.
     * @param oldString The exact string to replace.
     * @param newString The string to replace with.
     */
    @org.springframework.ai.model.Tool
    public void replaceText(String filePath, String oldString, String newString) throws IOException {
        Path path = pathValidator.validatePath(filePath);
        String content = Files.readString(path);
        long count = content.chars().filter(ch -> ch == oldString.charAt(0)).count(); // Basic check

        if (count != 1) { // Strict check: only replace if the exact string appears exactly once
             throw new IllegalArgumentException("String to replace must appear exactly once. Found " + count + " occurrences.");
        }

        String updatedContent = content.replaceFirst(Pattern.quote(oldString), Matcher.quoteReplacement(newString));
        Files.writeString(path, updatedContent);
    }
}

```

--------------------------------

### Bash Tool Execution for Compilation and Testing

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/LEARNING_FROM_OPEN_SOURCE.md

This snippet shows how to execute bash commands for compilation and testing using tools like 'mvn'. It's a part of implementing a bash tool with whitelist validation for security, although the whitelist is noted as not strictly necessary for the current development stage.

```bash
mvn compile/test
```

--------------------------------

### Unified Tool Execution Loop in Go

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/LEARNING_FROM_OPEN_SOURCE.md

Illustrates a unified tool execution loop within a Go program. It iterates through content blocks, identifies 'tool_use' types, looks up the corresponding tool, executes its function with the provided input, and collects the results. This pattern centralizes tool invocation logic, simplifies error handling, and facilitates the addition of logging or metrics.

```go
// In response processing loop
for _, block := range message.Content {
    if block.Type == "tool_use" {
        tool := lookupTool(block.Name)
        result := tool.Function(block.Input)
        toolResults.append(ToolResultBlock{
            ToolUseID: block.ID,
            Content:   result,
        })
    }
}
```

--------------------------------

### Line Number Replace with Python Example

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/syntheses/code-modification.md

The 'lov-line-replace' tool allows for precise replacement of code segments within a specified range of line numbers. It requires the file path, the search string, the first and last replaced line numbers, and the replacement string. This method supports ellipsis notation for representing large unchanged sections.

```python
# Original file (line numbers)
1: def process_data(data):
2:     validate(data)
3:     transform(data)
4:     save(data)
5:     return data
```

--------------------------------

### Simple Coder Java: Tool Service Implementation

Source: https://github.com/cuipengfei/simple-coder/blob/main/slides.html

This Java code snippet demonstrates the execution of a tool within the Simple Coder's `ToolsService`. It shows a method that calls `listFiles` with a glob pattern to find files, simulating one of the core functionalities.

```java
// Assuming ToolsService.java contains this method
public List<String> listFiles(String globPattern) {
    // Implementation to list files based on glob pattern
    // For example, using java.nio.file.FileSystems.getDefault().getPathMatcher("glob:" + globPattern)
    System.out.println("Executing: listFiles(\"" + globPattern + "\")");
    // Return a list of file paths
    return List.of("path/to/AgentController.java", "path/to/AgentService.java"); 
}
```

--------------------------------

### Insert Edit into File with JavaScript Example

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/syntheses/code-modification.md

The 'insert_edit_into_file' tool automatically infers the insertion position for new code within a file. It takes an explanation of the edit, the file path, and the code to be inserted. This 'smart' tool requires minimal prompting and follows a convention where new code is placed between existing code blocks, often indicated by placeholders.

```javascript
// Original file
function calculate() {
    const a = 1;
    const b = 2;
    return a + b;
}

// code parameter for insert_edit_into_file
function calculate() {
    const a = 1;
    // ...existing code...
    console.log('Debugging:', a, b);  // inserted line
    // ...existing code...
}
```

--------------------------------

### Bash API Request: searchText Tool Trigger (Regex)

Source: https://context7.com/cuipengfei/simple-coder/llms.txt

Demonstrates triggering the searchText tool with a regular expression using a bash curl command. The JSON payload includes a prompt to find methods starting with 'validate'. The agent constructs a call to searchText with the regex pattern, target file, and flags for regex and case-insensitivity.

```bash
# Regex search example
curl -X POST http://localhost:8080/api/agent \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "find all methods starting with validate using regex in ToolsService.java",
    "toolType": "auto",
    "contextHistory": []
  }'

# Agent calls: searchText("validate\\w+\( ", "src/main/java/com/simplecoder/service/ToolsService.java", true, false)
```

--------------------------------

### String Replacement Variants Across Platforms

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/sources/notes-system-prompts.md

Illustrates various string replacement methods used for code modification, including line-based, substring, and full-file replacements. Each platform has specific tool names and parameter structures.

```lovable
// Lovable lov-line-replace parameters:
// file_path: "path/to/your/file.js"
// search: "// Old line to replace"
// first_replaced_line: 10
// last_replaced_line: 12
// replace: "// New replacement line(s)"
// Ellipsis supported for large code sections.
```

```same.dev
// Same.dev string_replace parameters:
// file_path: "path/to/your/file.js"
// old_str: "// Old string to replace"
// new_str: "// New string"
// replace_all: true
// Recommended for files > 2500 lines or small edits.
```

```windsurf
// Windsurf replace_file_content parameters:
// file_path: "path/to/your/file.js"
// replacements: [
//   {
//     "TargetContent": "// Old content part",
//     "ReplacementChunk": "// New content part"
//   }
// ]
```

```qoder
// Qoder search_replace parameters:
// file_path: "path/to/your/file.js"
// replacements: [
//   {
//     "original_text": "// Original text",
//     "new_text": "// Replacement text",
//     "replace_all": true
//   }
// ]
// Strict uniqueness and exact match required.
```

```replit
// Replit <proposed_file_replace_substring> (XML format):
// <proposed_file_replace_substring file_path="path/to/your/file.js">
//   <change_summary>Replace specific string</change_summary>
//   <old_str>// Old string</old_str>
//   <new_str>// New string</new_str>
// </proposed_file_replace_substring>
// For full file replace use <proposed_file_replace>
```

```claude_code_2.0
// Claude Code 2.0 Edit tool parameters:
// file_path: "path/to/your/file.js"
// old_string: "// Old string"
// new_string: "// New string"
// replace_all: false
// Preserves indentation; ensure old_string uniqueness or use replace_all.
```

--------------------------------

### DefaultAgent step() Method Implementation

Source: https://github.com/cuipengfei/simple-coder/blob/main/docs/sources/notes-mini-swe-agent.md

Executes a single step of the agent's task processing. This method queries the model, parses the action from the response, executes the action in the environment, checks for task completion, and renders the observation before appending it to the message history.

```python
def step(self) -> None:
    # 1. query model
    response = self.query()

    # 2. parse action
    action = self.parse_action(response)

    # 3. execute action
    output, returncode = self.execute_action(action)

    # 4. check completion
    if self.has_finished(output):
        raise Submitted(output)

    # 5. render observation
    observation = self.render_template(
        self.action_observation_template,
        output=output,
        returncode=returncode
    )

    # 6. append to history
    self.add_message("user", observation)
```