auto-coder 0.1.268__py3-none-any.whl → 0.1.269__py3-none-any.whl

autocoder/commands/auto_command.py

@@ -21,6 +21,8 @@ from loguru import logger
 from autocoder.utils import llms as llms_utils
 from autocoder.rag.token_counter import count_tokens
 from autocoder.common.global_cancel import global_cancel
+from autocoder.common.auto_configure import config_readme
+from autocoder.utils.auto_project_type import ProjectTypeAnalyzer
 
 class CommandMessage(BaseModel):
     role: str
@@ -155,7 +157,8 @@ class CommandAutoTuner:
         self.printer = Printer()
         self.memory_config = memory_config
         self.command_config = command_config
-        self.tools = AutoCommandTools(args=args, llm=self.llm)        
+        self.tools = AutoCommandTools(args=args, llm=self.llm)
+        self.project_type_analyzer = ProjectTypeAnalyzer(args=args, llm=self.llm)        
     
     def get_conversations(self) -> List[CommandMessage]:
         """Get conversation history from memory file"""
@@ -440,7 +443,7 @@ class CommandAutoTuner:
                         safe_zone=self.args.conversation_prune_safe_zone_tokens
                     )
                     from autocoder.common.conversation_pruner import ConversationPruner
-                    pruner = ConversationPruner(self.llm)
+                    pruner = ConversationPruner(self.args, self.llm)
                     conversations = pruner.prune_conversations(conversations)                    
 
                 title = printer.get_message_from_key("auto_command_analyzing")
@@ -646,34 +649,7 @@ class CommandAutoTuner:
 
         常见的一些配置选项示例：
 
-        # 配置项说明
-        ## auto_merge: 代码合并方式，可选值为editblock、diff、wholefile.
-        - editblock: 生成 SEARCH/REPLACE 块，然后根据 SEARCH块到对应的源码查找，如果相似度阈值大于 editblock_similarity， 那么则将
-        找到的代码块替换为 REPLACE 块。大部分情况都推荐使用 editblock。        
-        - wholefile: 重新生成整个文件，然后替换原来的文件。对于重构场景，推荐使用 wholefile。
-        - diff: 生成标准 git diff 格式，适用于简单的代码修改。        
-
-        ## editblock_similarity: editblock相似度阈值
-        - editblock相似度阈值，取值范围为0-1，默认值为0.9。如果设置的太低，虽然能合并进去，但是会引入错误。推荐不要修改该值。
-
-        ## generate_times_same_model: 相同模型生成次数,也叫采样数
-        当进行生成代码时，大模型会对同一个需求生成多份代码，然后会使用 generate_rerank_model 模型对多份代码进行重排序，
-        然后选择得分最高的代码。一般次数越多，最终得到正确的代码概率越高。默认值为1，推荐设置为3。但是设置值越多，可能速度就越慢，消耗的token也越多。
-        当用户提到，帮我采样数设置为3， 那么你就设置该参数即可。
-
-        ## skip_filter_index: 是否跳过索引过滤
-        是否跳过根据用户的query 自动查找上下文。推荐设置为 false
-        
-        ## skip_build_index: 是否跳过索引构建
-        是否自动构建索引。推荐设置为 false。注意，如果该值设置为 true, 那么 skip_filter_index 设置不会生效。
-
-        ## enable_global_memory: 是否开启全局记忆
-        是否开启全局记忆。
-
-        ## rank_times_same_model: 相同模型重排序次数
-        默认值为1. 如果 generate_times_same_model 参数设置大于1，那么 coding 函数会自动对多份代码进行重排序。
-        rank_times_same_model 表示重拍的次数，次数越多，选择到最好的代码的可能性越高，但是也会显著增加消耗的token和时间。
-        建议保持默认，要修改也建议不要超过3。
+        {{ config_readme }}
                 
         比如你想开启索引，则可以执行：
 
@@ -1190,10 +1166,26 @@ class CommandAutoTuner:
          exclude_files(query="/drop regex://.*/package-lock\.json")
         </usage>
         </command>
+
+        <command>
+        <name>get_project_type</name>
+        <description>获取项目类型。</description>
+        <usage>
+         该命令获取项目类型。
+
+         使用例子：
+         get_project_type()
+
+         此时会返回诸如 "ts,py,java,go,js,ts" 这样的字符串，表示项目类型。
+        </usage>
+        </command>
         </commands>
         
         
         '''
+        return {
+            "config_readme": config_readme.prompt()
+        }
 
     def execute_auto_command(self, command: str, parameters: Dict[str, Any]) -> None:
         """
@@ -1232,9 +1224,7 @@ class CommandAutoTuner:
             "get_project_related_files": self.tools.get_project_related_files,
             "ask_user":self.tools.ask_user,
             "read_file_with_keyword_ranges": self.tools.read_file_with_keyword_ranges,
-
-            
-                        
+            "get_project_type": self.project_type_analyzer.analyze,                                    
         }
 
         if command not in command_map:

autocoder/common/__init__.py

@@ -376,12 +376,16 @@ class AutoCoderArgs(pydantic.BaseModel):
     conversation_prune_group_size: Optional[int] = 4
     conversation_prune_strategy: Optional[str] = "summarize"
 
-    context_prune_strategy: Optional[str] = "score"
+    context_prune_strategy: Optional[str] = "extract"
     context_prune: Optional[bool] = True
+    context_prune_sliding_window_size: Optional[int] = 1000
+    context_prune_sliding_window_overlap: Optional[int] = 100
 
     auto_command_max_iterations: Optional[int] = 10
     
-    skip_commit: Optional[bool] = False    
+    skip_commit: Optional[bool] = False 
+
+    enable_beta: Optional[bool] = False
 
     class Config:
         protected_namespaces = ()

autocoder/common/auto_coder_lang.py

@@ -161,9 +161,13 @@ MESSAGES = {
         "index_import_success": "Index imported successfully: {{path}}",
         "edits_title": "edits",
         "diff_blocks_title":"diff blocks",
-        "index_exclude_files_error": "index filter exclude files fail: {{ error }}"
+        "index_exclude_files_error": "index filter exclude files fail: {{ error }}",
+        "file_sliding_window_processing": "File {{ file_path }} is too large ({{ tokens }} tokens), processing with sliding window...",
+        "file_snippet_processing": "Processing file {{ file_path }} with code snippet extraction..."
     },
     "zh": {
+        "file_sliding_window_processing": "文件 {{ file_path }} 过大 ({{ tokens }} tokens)，正在使用滑动窗口处理...",
+        "file_snippet_processing": "正在对文件 {{ file_path }} 进行代码片段提取...",
         "file_scored_message": "文件评分: {{file_path}} - 分数: {{score}}",
         "invalid_file_pattern": "无效的文件模式: {{file_pattern}}. 例如: regex://.*/package-lock\\.json",
         "conf_not_found": "未找到配置文件: {{path}}",

autocoder/common/auto_configure.py

@@ -119,7 +119,45 @@ class AutoConfigRequest(BaseModel):
 
 class AutoConfigResponse(BaseModel):
     configs: List[Dict[str, Any]] = Field(default_factory=list)
-    reasoning: str = ""        
+    reasoning: str = "" 
+
+
+@byzerllm.prompt()
+def config_readme() -> str:
+    """
+    # 配置项说明
+    ## auto_merge: 代码合并方式，可选值为editblock、diff、wholefile.
+    - editblock: 生成 SEARCH/REPLACE 块，然后根据 SEARCH块到对应的源码查找，如果相似度阈值大于 editblock_similarity， 那么则将
+    找到的代码块替换为 REPLACE 块。大部分情况都推荐使用 editblock。        
+    - wholefile: 重新生成整个文件，然后替换原来的文件。对于重构场景，推荐使用 wholefile。
+    - diff: 生成标准 git diff 格式，适用于简单的代码修改。        
+
+    ## editblock_similarity: editblock相似度阈值
+    - editblock相似度阈值，取值范围为0-1，默认值为0.9。如果设置的太低，虽然能合并进去，但是会引入错误。推荐不要修改该值。
+
+    ## generate_times_same_model: 相同模型生成次数
+    当进行生成代码时，大模型会对同一个需求生成多份代码，然后会使用 generate_rerank_model 模型对多份代码进行重排序，
+    然后选择得分最高的代码。一般次数越多，最终得到正确的代码概率越高。默认值为1，推荐设置为3。但是设置值越多，可能速度就越慢，消耗的token也越多。
+
+    ## skip_filter_index: 是否跳过索引过滤
+    是否跳过根据用户的query 自动查找上下文。推荐设置为 false
+    
+    ## skip_build_index: 是否跳过索引构建
+    是否自动构建索引。推荐设置为 false。注意，如果该值设置为 true, 那么 skip_filter_index 设置不会生效。
+
+    ## rank_times_same_model: 相同模型重排序次数
+    默认值为1. 如果 generate_times_same_model 参数设置大于1，那么 coding 函数会自动对多份代码进行重排序。
+    rank_times_same_model 表示重拍的次数，次数越多，选择到最好的代码的可能性越高，但是也会显著增加消耗的token和时间。
+    建议保持默认，要修改也建议不要超过3。
+
+    ## project_type: 项目类型
+    项目类型通常为如下三种选择：
+    1. ts
+    2. py
+    3. 代码文件后缀名列表（比如.java,.py,.go,.js,.ts），多个按逗号分割
+
+    推荐使用 3 选项，因为项目类型通常为多种后缀名混合。
+    """
 
 class ConfigAutoTuner:
     def __init__(self,args: AutoCoderArgs, llm: Union[byzerllm.ByzerLLM, byzerllm.SimpleByzerLLM], memory_config: MemoryConfig):
@@ -135,34 +173,7 @@ class ConfigAutoTuner:
         self.memory_config.configure(conf, skip_print)
 
 
-    @byzerllm.prompt()
-    def config_readme(self) -> str:
-        """
-        # 配置项说明
-        ## auto_merge: 代码合并方式，可选值为editblock、diff、wholefile.
-        - editblock: 生成 SEARCH/REPLACE 块，然后根据 SEARCH块到对应的源码查找，如果相似度阈值大于 editblock_similarity， 那么则将
-        找到的代码块替换为 REPLACE 块。大部分情况都推荐使用 editblock。        
-        - wholefile: 重新生成整个文件，然后替换原来的文件。对于重构场景，推荐使用 wholefile。
-        - diff: 生成标准 git diff 格式，适用于简单的代码修改。        
-
-        ## editblock_similarity: editblock相似度阈值
-        - editblock相似度阈值，取值范围为0-1，默认值为0.9。如果设置的太低，虽然能合并进去，但是会引入错误。推荐不要修改该值。
-
-        ## generate_times_same_model: 相同模型生成次数
-        当进行生成代码时，大模型会对同一个需求生成多份代码，然后会使用 generate_rerank_model 模型对多份代码进行重排序，
-        然后选择得分最高的代码。一般次数越多，最终得到正确的代码概率越高。默认值为1，推荐设置为3。但是设置值越多，可能速度就越慢，消耗的token也越多。
-
-        ## skip_filter_index: 是否跳过索引过滤
-        是否跳过根据用户的query 自动查找上下文。推荐设置为 false
-        
-        ## skip_build_index: 是否跳过索引构建
-        是否自动构建索引。推荐设置为 false。注意，如果该值设置为 true, 那么 skip_filter_index 设置不会生效。
-
-        ## rank_times_same_model: 相同模型重排序次数
-        默认值为1. 如果 generate_times_same_model 参数设置大于1，那么 coding 函数会自动对多份代码进行重排序。
-        rank_times_same_model 表示重拍的次数，次数越多，选择到最好的代码的可能性越高，但是也会显著增加消耗的token和时间。
-        建议保持默认，要修改也建议不要超过3。
-        """
+    
 
     def command_readme(self) -> str:
         """
@@ -212,7 +223,7 @@ class ConfigAutoTuner:
             "query": request.query,
             "current_conf": json.dumps(self.memory_config.memory["conf"], indent=2),        
             "last_execution_stat": "",
-            "config_readme": self.config_readme.prompt()
+            "config_readme": config_readme.prompt()
         }
 
     def tune(self, request: AutoConfigRequest) -> 'AutoConfigResponse':

autocoder/common/command_templates.py

@@ -174,9 +174,8 @@ def base_base(source_dir:str,project_type:str)->str:
     source_dir: {{ source_dir }}
     target_file: {{ target_file }}
 
-    model: v3_chat
-    model_max_input_length: 100000
-    model_max_input_length: 120000
+    model: v3_chat    
+    model_max_input_length: 60000
     enable_multi_round_generate: false
     index_filter_workers: 100
     index_build_workers: 100

autocoder/common/context_pruner.py

@@ -1,4 +1,5 @@
 from typing import List, Dict, Any, Union
+from typing import Tuple
 from pathlib import Path
 import json
 from loguru import logger
@@ -19,6 +20,100 @@ class PruneContext:
         self.llm = llm
         self.printer = Printer()
 
+    def _split_content_with_sliding_window(self, content: str, window_size=100, overlap=20) -> List[Tuple[int, int, str]]:
+        """使用滑动窗口分割大文件内容，返回包含行号信息的文本块
+        
+        Args:
+            content: 要分割的文件内容
+            window_size: 每个窗口包含的行数
+            overlap: 相邻窗口的重叠行数
+            
+        Returns:
+            List[Tuple[int, int, str]]: 返回元组列表，每个元组包含:
+                - 起始行号(从1开始)，在原始文件的绝对行号
+                - 结束行号，在原始文件的绝对行号
+                - 带行号的内容文本
+        """
+        # 按行分割内容
+        lines = content.splitlines()
+        chunks = []
+        start = 0
+        
+        while start < len(lines):
+            # 计算当前窗口的结束位置
+            end = min(start + window_size, len(lines))
+            
+            # 计算实际的起始位置(考虑重叠)
+            actual_start = max(0, start - overlap)
+            
+            # 提取当前窗口的行
+            chunk_lines = lines[actual_start:end]
+            
+            # 为每一行添加行号
+            # 行号从actual_start+1开始，保持与原文件的绝对行号一致
+            chunk_content = "\n".join([
+                f"{i+1} {line}" for i, line in enumerate(chunk_lines, start=actual_start)
+            ])
+            
+            # 保存分块信息：(起始行号, 结束行号, 带行号的内容)
+            # 行号从1开始计数
+            chunks.append((actual_start + 1, end, chunk_content))
+            
+            # 移动到下一个窗口的起始位置
+            # 减去overlap确保窗口重叠
+            start += (window_size - overlap)
+            
+        return chunks
+
+    def _merge_overlapping_snippets(self, snippets: List[dict]) -> List[dict]:
+        """合并重叠或相邻的代码片段
+        
+        Args:
+            snippets: 代码片段列表，每个片段是包含start_line和end_line的字典
+            
+        Returns:
+            List[dict]: 合并后的代码片段列表
+            
+        示例:
+            输入: [
+                {"start_line": 1, "end_line": 5},
+                {"start_line": 4, "end_line": 8},
+                {"start_line": 10, "end_line": 12}
+            ]
+            输出: [
+                {"start_line": 1, "end_line": 8},
+                {"start_line": 10, "end_line": 12}
+            ]
+        """
+        if not snippets:
+            return []
+
+        # 按起始行排序
+        sorted_snippets = sorted(snippets, key=lambda x: x["start_line"])
+
+        merged = [sorted_snippets[0]]
+        
+        for current in sorted_snippets[1:]:
+            last = merged[-1]
+            
+            # 判断是否需要合并:
+            # 1. 如果当前片段的起始行小于等于上一个片段的结束行+1
+            # 2. +1是为了合并相邻的片段，比如1-5和6-8应该合并为1-8
+            if current["start_line"] <= last["end_line"] + 1:
+                # 合并区间:
+                # - 起始行取两者最小值
+                # - 结束行取两者最大值
+                merged[-1] = {
+                    "start_line": min(last["start_line"], current["start_line"]),
+                    "end_line": max(last["end_line"], current["end_line"])
+                }
+            else:
+                # 如果不重叠且不相邻，则作为新片段添加
+                merged.append(current)
+
+        return merged
+     
+
     def _delete_overflow_files(self, file_paths: List[str]) -> List[SourceCode]:
         """直接删除超出 token 限制的文件"""
         total_tokens = 0
@@ -40,6 +135,8 @@ class PruneContext:
                 selected_files.append(SourceCode(module_name=file_path,source_code=content,tokens=token_count))
 
         return selected_files
+    
+    
 
     def _extract_code_snippets(self, file_paths: List[str], conversations: List[Dict[str, str]]) -> List[SourceCode]:
         """抽取关键代码片段策略"""
@@ -48,7 +145,7 @@ class PruneContext:
         full_file_tokens = int(self.max_tokens * 0.8)
 
         @byzerllm.prompt()
-        def extract_code_snippets(conversations: List[Dict[str, str]], content: str) -> str:
+        def extract_code_snippets(conversations: List[Dict[str, str]], content: str, is_partial_content: bool = False) -> str:
             """
             根据提供的代码文件和对话历史提取相关代码片段。            
 
@@ -111,6 +208,13 @@ class PruneContext:
             {{ content }}
             </code_file>
 
+            <% if is_partial_content: %>
+            <partial_content_process_note>
+            当前处理的是文件的局部内容（行号{start_line}-{end_line}），
+            请仅基于当前可见内容判断相关性，返回标注的行号区间。            
+            </partial_content_process_note>
+            <% endif %>
+
             2. 对话历史:
             <conversation_history>
             {% for msg in conversations %}
@@ -131,15 +235,17 @@ class PruneContext:
             4. 如果没有相关代码段，返回空数组[]。
 
             输出格式:
-            严格的JSON数组，不包含其他文字或解释。
-
+            严格的JSON数组，不包含其他文字或解释。           
+            
             ```json
             [
                 {"start_line": 第一个代码段的起始行号, "end_line": 第一个代码段的结束行号},
                 {"start_line": 第二个代码段的起始行号, "end_line": 第二个代码段的结束行号}
             ]
-            ```            
+            ``` 
+                       
             """
+            
 
         for file_path in file_paths:
             try:
@@ -152,21 +258,67 @@ class PruneContext:
                         selected_files.append(SourceCode(module_name=file_path,source_code=content,tokens=tokens))
                         token_count += tokens
                         continue
-
+                    
+                    ## 如果单个文件太大，那么先按滑动窗口分割，然后对窗口抽取代码片段
+                    if tokens > self.max_tokens:
+                        self.printer.print_in_terminal("file_sliding_window_processing", file_path=file_path, tokens=tokens)
+                        chunks = self._split_content_with_sliding_window(content, 
+                                                                         self.args.context_prune_sliding_window_size, 
+                                                                         self.args.context_prune_sliding_window_overlap)                        
+                        all_snippets = [] 
+                        for chunk_start, chunk_end, chunk_content in chunks: 
+                            extracted = extract_code_snippets.with_llm(self.llm).run( 
+                                conversations=conversations, 
+                                content=chunk_content, 
+                                is_partial_content=True 
+                            )
+                            if extracted:
+                                json_str = extract_code(extracted)[0][1]
+                                snippets = json.loads(json_str)  
+
+                                # 获取到的本来就是在原始文件里的绝对行号  
+                                # 后续在构建代码片段内容时，会为了适配数组操作修改行号，这里无需处理
+                                adjusted_snippets = [{
+                                    "start_line": snippet["start_line"],
+                                    "end_line": snippet["end_line"]
+                                } for snippet in snippets]                                
+                                all_snippets.extend(adjusted_snippets)                                                                
+                        merged_snippets = self._merge_overlapping_snippets(all_snippets)                        
+                        content_snippets = self._build_snippet_content(file_path, content, merged_snippets)
+                        snippet_tokens = count_tokens(content_snippets)
+                        if token_count + snippet_tokens <= self.max_tokens:
+                            selected_files.append(SourceCode(module_name=file_path,source_code=content_snippets,tokens=snippet_tokens))
+                            token_count += snippet_tokens
+                            continue
+                        else:
+                            break
+                        
                     # 抽取关键片段
+                    lines = content.splitlines()
+                    new_content = ""
+
+                    ## 将文件内容按行编号
+                    for index,line in enumerate(lines):                        
+                        new_content += f"{index+1} {line}\n"
+
+                    ## 抽取代码片段
+                    self.printer.print_in_terminal("file_snippet_processing", file_path=file_path)
                     extracted = extract_code_snippets.with_llm(self.llm).run(
                         conversations=conversations, 
-                        content=content
+                        content=new_content
                     )                
 
+                    ## 构建代码片段内容
                     if extracted:
                         json_str = extract_code(extracted)[0][1]
                         snippets = json.loads(json_str)
-                        new_content = self._build_snippet_content(file_path, content, snippets)
+                        content_snippets = self._build_snippet_content(file_path, content, snippets)
 
-                        snippet_tokens = count_tokens(new_content)
+                        snippet_tokens = count_tokens(content_snippets)
                         if token_count + snippet_tokens <= self.max_tokens:
-                            selected_files.append(SourceCode(module_name=file_path,source_code=new_content,tokens=snippet_tokens))
+                            selected_files.append(SourceCode(module_name=file_path,
+                                                             source_code=content_snippets,
+                                                             tokens=snippet_tokens))
                             token_count += snippet_tokens
                         else:
                             break
@@ -175,10 +327,32 @@ class PruneContext:
                 continue
 
         return selected_files
+    
+
+    def _merge_overlapping_snippets(self, snippets: List[dict]) -> List[dict]: 
+        if not snippets:
+            return []
+
+        # 按起始行排序
+        sorted_snippets = sorted(snippets, key=lambda x: x["start_line"])
+
+        merged = [sorted_snippets[0]]
+        for current in sorted_snippets[1:]:
+            last = merged[-1]
+            if current["start_line"] <= last["end_line"] + 1:  # 允许1行间隔
+                # 合并区间
+                merged[-1] = {
+                    "start_line": min(last["start_line"], current["start_line"]),
+                    "end_line": max(last["end_line"], current["end_line"])
+                }
+            else:
+                merged.append(current)
+
+        return merged
 
     def _build_snippet_content(self, file_path: str, full_content: str, snippets: List[dict]) -> str:
         """构建包含代码片段的文件内容"""
-        lines = full_content.split("\n")
+        lines = full_content.splitlines()
         header = f"Snippets:\n"
 
         content = []
@@ -214,7 +388,7 @@ class PruneContext:
             return self._extract_code_snippets(file_paths, conversations)
         else:
             raise ValueError(f"无效策略: {strategy}. 可选值: delete/extract/score")
-    
+
     def _count_tokens(self, file_paths: List[str]) -> int:
         """计算文件总token数"""
         total_tokens = 0
@@ -312,4 +486,3 @@ class PruneContext:
                 break
 
         return selected_files
-

autocoder/common/conversation_pruner.py

@@ -3,8 +3,9 @@ import json
 from pydantic import BaseModel
 import byzerllm
 from autocoder.common.printer import Printer
-from autocoder.utils.llms import count_tokens
+from autocoder.rag.token_counter import count_tokens
 from loguru import logger
+from autocoder.common import AutoCoderArgs
 
 class PruneStrategy(BaseModel):
     name: str
@@ -12,25 +13,25 @@ class PruneStrategy(BaseModel):
     config: Dict[str, Any] = {"safe_zone_tokens": 0, "group_size": 4}
 
 class ConversationPruner:
-    def __init__(self, llm: Union[byzerllm.ByzerLLM, byzerllm.SimpleByzerLLM], 
-                 safe_zone_tokens: int = 500, group_size: int = 4):
+    def __init__(self, args: AutoCoderArgs, llm: Union[byzerllm.ByzerLLM, byzerllm.SimpleByzerLLM]):
+        self.args = args
         self.llm = llm
         self.printer = Printer()
         self.strategies = {
             "summarize": PruneStrategy(
                 name="summarize",
                 description="对早期对话进行分组摘要，保留关键信息",
-                config={"safe_zone_tokens": safe_zone_tokens, "group_size": group_size}
+                config={"safe_zone_tokens": self.args.conversation_prune_safe_zone_tokens, "group_size": self.args.conversation_prune_group_size}
             ),
             "truncate": PruneStrategy(
                 name="truncate",
                 description="分组截断最早的部分对话",
-                config={"safe_zone_tokens": safe_zone_tokens, "group_size": group_size}
+                config={"safe_zone_tokens": self.args.conversation_prune_safe_zone_tokens, "group_size": self.args.conversation_prune_group_size}
             ),
             "hybrid": PruneStrategy(
                 name="hybrid",
                 description="先尝试分组摘要，如果仍超限则分组截断",
-                config={"safe_zone_tokens": safe_zone_tokens, "group_size": group_size}
+                config={"safe_zone_tokens": self.args.conversation_prune_safe_zone_tokens, "group_size": self.args.conversation_prune_group_size}
             )
         }
 
@@ -57,7 +58,7 @@ class ConversationPruner:
         if strategy.name == "summarize":
             return self._summarize_prune(conversations, strategy.config)
         elif strategy.name == "truncate":
-            return self._truncate_prune.with_llm(self.llm).run(conversations)
+            return self._truncate_prune(conversations)
         elif strategy.name == "hybrid":
             pruned = self._summarize_prune(conversations, strategy.config)
             if count_tokens(json.dumps(pruned, ensure_ascii=False)) > self.args.conversation_prune_safe_zone_tokens:
@@ -80,8 +81,8 @@ class ConversationPruner:
                 break
                 
             # 找到要处理的对话组
-            early_conversations = processed_conversations[:-group_size]
-            recent_conversations = processed_conversations[-group_size:]
+            early_conversations = processed_conversations[:group_size]
+            recent_conversations = processed_conversations[group_size:]
             
             if not early_conversations:
                 break
@@ -90,7 +91,7 @@ class ConversationPruner:
             group_summary = self._generate_summary.with_llm(self.llm).run(early_conversations[-group_size:])
             
             # 更新对话历史
-            processed_conversations = early_conversations[:-group_size] + [
+            processed_conversations =  [
                 {"role": "user", "content": f"历史对话摘要：\n{group_summary}"},
                 {"role": "assistant", "content": f"收到"}
             ] + recent_conversations