CRCT: Recursively Decompose Large Code Tasks and Persistently Save Project State

General Introduction

Cline Recursive Chain-of-Thought System (CRCT for short) is an open source framework designed for managing large code projects in VS Code. The current version is v7.0 , it through recursive methods and file systems , to maintain the continuity of the project state , to avoid problems caused by the loss of context AI assistant . CRCT is the core of efficient dependency tracking and task decomposition , the size of the compressed context up to 90% , suitable for dealing with large and complex code base . The system is divided into three phases: "Setup/Maintenance", "Policy" and "Execution"..clinerulesDocumentation controls progress, ensuring work is transparent and structured. Developers can access source code via GitHub and participate in community optimization.

Function List

• Recursive task decomposition: Split complex tasks into small chunks and store them in files and directories to isolate the management context.
• Persistent State Management: Save the state of the project with the file system to prevent loss of context at each session reset.
• Efficient dependency tracking: Tracks relationships between files, modules and documents through a hierarchical structure, compressing data up to 90%.
• Minimize context loading: Load only the necessary data and scale on demand for very large projects.
• Staged workflowsStructured project progression with support for "Setup/Maintenance", "Policy" and "Execution" phases.
• Transparent reasoning: Provide step-by-step reasoning and reflection to ensure that AI operations are clearly visible.

Using Help

Installation process

CRCT needs to be used with the Cline extension in VS Code. Here are the detailed installation steps:

1. Preparing the environment
   • Ensure that VS Code and the Cline extension are installed.
   • Install Python 3.8+ and Git for running scripts and cloning repositories.
2. clone warehouse
   • Open a terminal and type:

     git clone https://github.com/RPG-fan/Cline-Recursive-Chain-of-Thought-System-CRCT-.git
     

   • Go to the project catalog:

     cd Cline-Recursive-Chain-of-Thought-System-CRCT-
     

3. Installation of dependencies
   • Run the following command to install the Python library:

     pip install -r requirements.txt
     

4. Configuring Cline Extensions
   • Open the project folder in VS Code.
   • Open the Cline Extension Settings and find the "System Tips" field.
   • commander-in-chief (military)cline_docs/prompts/core_prompt(put this in Custom Instructions).mdof the content is copied into the prompted input box.
5. activation system
   • In the Cline input box, enterStart.And run.
   • The system will be based on the.clinerulesFile initialization, automatic generation of missing files and bootstrap setup.
   • probecline_docs/Catalog to ensure thatprojectbrief.md,dependency_tracker.mdetc. core documents have been created.

How to use the main features

Project structure

cline/
│ .clinerules # Controls phase and state
│ README.md # This file
│ requirements.txt # Python dependencies
│
├──cline_docs/ # Operational memory
│ │ activeContext.md # Current state and priorities
│ │ changelog.md # Logs significant changes
│ │ productContext.md # Project purpose and user needs
│ │ progress.md # Tracks progress
│ │ projectbrief.md # Mission and objectives
│ │ dependency_tracker.md # Module-level dependencies
│ │ ... # Additional templates
│ └───prompts/ # System prompts and plugins
│ core_prompt.md # Core system instructions
│ setup_maintenance_plugin.md
│ strategy_plugin.md
│ execution_plugin.md
│ strategy_plugin.md │ execution_plugin.md
├───cline_utils/ # Utility scripts
│ └───dependency_system/
│ dependency_processor.py # Dependency management script
│ Dependency management script
├───docs/ # Project documentation
│ │ doc_tracker.md # Documentation dependencies
│ │ doc_tracker.md
├───src/ # Source code root
│ ├───src/ # Source code root
└───strategy_tasks/ # Strategic plans

CRCT helps developers manage large code projects efficiently. Below is the detailed operation flow of the core functions:

1. Recursive task decomposition

• procedure::
  • existcline_docs/Create subfolders undertask_feature/, depositing specific tasks.
  • Creating in a foldertask.md, write down the objectives and steps of the task.
  • The system automatically recognizes the catalog structure and breaks down tasks into independent units.
• Usage Scenarios: Reduce confusion when dealing with complex projects by breaking large tasks into smaller chunks.
• caveat: Keep folder naming clear and easy to track.

2. Persistent State Management

• procedure::
  • The system is passed through a file (e.g.activeContext.md,progress.md) save state.
  • At the beginning of each session, check the.clinerulesfile that loads the last context.
• Usage Scenarios: In long-term projects, ensure that the state is continuous and no information is lost due to session resets.
• draw attention to sth.: Regular backupscline_docs/To avoid data loss.

3. Efficient dependency tracking

• procedure::
  • show (a ticket)cline_docs/dependency_tracker.md, record module dependencies such as:

    - The login module depends on auth.py.
    - The payment module depends on api_gateway/
    

  • (of a computer) runcline_utils/dependency_system/dependency_processor.py::

    python cline_utils/dependency_system/dependency_processor.py
    

  • Check dependency diagrams to ensure relationships are accurate.
• Usage Scenarios: Track relationships between files and modules in large codebases.
• Advanced Usage: Reduce the amount of data by utilizing RLE compression for an efficiency gain of 90%.

4. Minimize context loading

• procedure::
  • By default, the system only loadsactiveContext.mdThe key data in the
  • When more information is needed, thedependency_tracker.mdMarking modules, system expansion on demand.
• Usage Scenarios: Handle large projects with thousands of files and reduce resource usage.
• caveat: Update dependency tracking on a regular basis to keep the data accurate.

5. Staged workflows

• procedure::
  • ferret out.clinerulesThe current phase (e.g. "Set-up/Maintenance") is confirmed.
  • Update the document according to the phase:
    • Setting stage: refinementprojectbrief.mdThe
    • Strategy phase: editingstrategy_tasks/under the program.
    • Implementation phase: updateprogress.mdRecord progress.
  • importationReview the current state and suggest next steps., get advice from Cline.
• Usage Scenarios: Ensure that team or individual projects are moving forward in a step-by-step manner.
• draw attention to sth.: Timely adjustments when switching phases.clinerulesThe

6. Transparent reasoning

• procedure::
  • Enter specific tasks in Cline, such asOptimize dependency tracking.The
  • The system returns the step-by-step reasoning process displayed in theprogress.mdCenter.
• Usage Scenarios: Understand the logic of AI operations and reduce misunderstandings.
• caveat: Check the results of the reasoning to ensure that it meets the needs of the program.

Existing project access

• procedure::
  • Putting existing code intosrc/The document is placed in thedocs/The
  • Input at Cline:

    Perform initial setup and populate dependency trackers.
    

  • The system analyzes the code, initializes the tracker and guides the setup.
• Usage Scenarios: Apply CRCT to existing programs to improve management efficiency.

caveat

• adjust components during testing: If there is a problem with the system, enterReview the current state and suggest next steps.Get solutions.
• Efficiency Optimization: Dependency tracking compression rate up to 90% for very large projects.
• Community involvement: Participate in CRCT improvements by submitting feedback via GitHub.

With these steps, you can easily use CRCT to manage complex code projects and improve efficiency and clarity.