auto-coder 0.1.267__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"""
@@ -213,7 +216,11 @@ class CommandAutoTuner:
         通过 get_project_structure 来获取项目结构，然后通过 get_project_map 来获取你想看的某个文件的用途，符号列表，最后再通过 read_files/read_file_with_keyword_ranges 函数来读取文件内容,确认对应的功能是否在相关的文件里。
         5. 调用 coding 函数的时候，尽可能多的 @文件和@@符号，让需求更加清晰明了，建议多描述具体怎么完成对应的需求。
         6. 对于代码需求设计，尽可能使用 chat 函数。
-        7. 如果成功执行了 coding 函数，最好再调用一次 chat("/review /commit")
+        7. 如果成功执行了 coding 函数，最好再调用一次 chat("/review /commit")    
+        8. 我们所有的对话不能超过 {{ conversation_safe_zone_tokens }} 个tokens,当你读取索引文件 (get_project_map) 的时候，你可以看到
+        每个文件的tokens数，你可以根据这个信息来决定如何读取这个文件。比如对于很小的文件，那么可以直接全部读取，
+        而对于分析一个超大文件推荐组合 read_files 带上 line_ranges 参数来读取，或者组合 read_file_withread_file_with_keyword_ranges 等来读取，
+        每个函数你还可以使用多次来获取更多信息。
         </function_combination_readme>
 
 
@@ -262,7 +269,8 @@ class CommandAutoTuner:
             "current_conf": json.dumps(self.memory_config.memory["conf"], indent=2),        
             "env_info": env_info,
             "shell_type": shells.get_terminal_name(),
-            "shell_encoding": shells.get_terminal_encoding()
+            "shell_encoding": shells.get_terminal_encoding(),
+            "conversation_safe_zone_tokens": self.args.conversation_prune_safe_zone_tokens
         }
     
     @byzerllm.prompt()
@@ -274,7 +282,7 @@ class CommandAutoTuner:
         
         <function_result>
         {{ result }}
-        </function_result>
+        </function_result>                
 
         请根据命令执行结果以及前面的对话，返回下一个函数。
         
@@ -283,7 +291,8 @@ class CommandAutoTuner:
         2. 你最多尝试 {{ auto_command_max_iterations }} 次，如果 {{ auto_command_max_iterations }} 次都没有满足要求，则不要返回任何函数，确保 suggestions 为空。
         '''   
         return {
-            "auto_command_max_iterations": self.args.auto_command_max_iterations
+            "auto_command_max_iterations": self.args.auto_command_max_iterations,
+            "conversation_safe_zone_tokens": self.args.conversation_prune_safe_zone_tokens
         } 
     
     def analyze(self, request: AutoCommandRequest) -> AutoCommandResponse:
@@ -434,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")
@@ -640,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 }}
                 
         比如你想开启索引，则可以执行：
 
@@ -985,23 +967,7 @@ class CommandAutoTuner:
          感兴趣，可以配合 read_files 函数来读取文件内容，从而帮你做更好的决策
              
         </usage>
-        </command>
-
-        <command>
-        <name>get_related_files</name>
-        <description>根据类名、函数名或文件用途描述，返回项目中相关的文件。</description>
-        <usage>
-         该命令接受一个参数 query，为要查询的符号或描述字符串。
-         
-         使用例子：
-         
-         get_related_files(query="用户登录功能")
-         
-         注意：
-         - 返回值为逗号分隔的文件路径列表
-         - 只能返回已被索引的文件
-        </usage>
-        </command>
+        </command>        
 
         <command>
         <name>get_project_map</name>
@@ -1200,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:
         """
@@ -1242,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

@@ -3,6 +3,7 @@ from byzerllm.utils import format_str_jinja2
 
 MESSAGES = {
     "en": {
+        "file_scored_message": "File scored: {{file_path}} - Score: {{score}}",
         "invalid_file_pattern": "Invalid file pattern: {{file_pattern}}. e.g. regex://.*/package-lock\\.json",
         "config_validation_error": "Config validation error: {{error}}",
         "invalid_boolean_value": "Value '{{value}}' is not a valid boolean(true/false)",
@@ -159,9 +160,15 @@ MESSAGES = {
         "index_export_success": "Index exported successfully: {{path}}",
         "index_import_success": "Index imported successfully: {{path}}",
         "edits_title": "edits",
-        "diff_blocks_title":"diff blocks"
+        "diff_blocks_title":"diff blocks",
+        "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}}",
         "conf_import_success": "成功导入配置: {{path}}",
@@ -317,6 +324,7 @@ MESSAGES = {
         "index_import_success": "索引导入成功: {{path}}",
         "edits_title": "编辑块",
         "diff_blocks_title": "差异块",
+        "index_exclude_files_error": "索引排除文件时出错: {{error}}"
     }}
 
 

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
@@ -9,11 +10,109 @@ from autocoder.index.types import VerifyFileRelevance
 import byzerllm
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
+from autocoder.common.printer import Printer
+from autocoder.common.auto_coder_lang import get_message_with_format
+
 class PruneContext:
     def __init__(self, max_tokens: int, args: AutoCoderArgs, llm: Union[byzerllm.ByzerLLM, byzerllm.SimpleByzerLLM]):
         self.max_tokens = max_tokens
         self.args = args
         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 限制的文件"""
@@ -36,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]:
         """抽取关键代码片段策略"""
@@ -44,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:
             """
             根据提供的代码文件和对话历史提取相关代码片段。            
 
@@ -107,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 %}
@@ -127,15 +235,17 @@ class PruneContext:
             4. 如果没有相关代码段，返回空数组[]。
 
             输出格式:
-            严格的JSON数组，不包含其他文字或解释。
-
+            严格的JSON数组，不包含其他文字或解释。           
+            
             ```json
             [
                 {"start_line": 第一个代码段的起始行号, "end_line": 第一个代码段的结束行号},
                 {"start_line": 第二个代码段的起始行号, "end_line": 第二个代码段的结束行号}
             ]
-            ```            
+            ``` 
+                       
             """
+            
 
         for file_path in file_paths:
             try:
@@ -148,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
@@ -171,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 = []
@@ -201,7 +379,7 @@ class PruneContext:
         total_tokens,sources = self._count_tokens(file_paths)
         if total_tokens <= self.max_tokens:
             return sources
-
+        # print(f"total_tokens: {total_tokens} {self.max_tokens}, 进行策略: {strategy}")
         if strategy == "score":            
             return self._score_and_filter_files(file_paths, conversations)
         if strategy == "delete":
@@ -210,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
@@ -281,9 +459,15 @@ class PruneContext:
         with ThreadPoolExecutor() as executor:
             futures = [executor.submit(_score_file, file_path) for file_path in file_paths]
             for future in as_completed(futures):
-                result = future.result()
-                print(f"score file {result['file_path']} {result['score']}")
+                result = future.result()                
                 if result:
+                    self.printer.print_str_in_terminal(
+                        get_message_with_format(
+                            "file_scored_message",
+                            file_path=result["file_path"],
+                            score=result["score"]
+                        )
+                    )
                     scored_files.append(result)
 
         # 第二步：按分数从高到低排序
@@ -302,4 +486,3 @@ class PruneContext:
                 break
 
         return selected_files
-