jarvis-ai-assistant 0.1.58__py3-none-any.whl → 0.1.74__py3-none-any.whl

jarvis/jarvis_coder/main.py

@@ -1,16 +1,19 @@
-from concurrent.futures import ThreadPoolExecutor, as_completed
-import hashlib
 import os
 import re
-import sqlite3
 import threading
 import time
-from typing import Dict, Any, List, Optional, Tuple
+from typing import Dict, Any, List, Tuple
 
 import yaml
 from jarvis.models.base import BasePlatform
-from jarvis.utils import OutputType, PrettyOutput, get_multiline_input, load_env_from_file
+from jarvis.utils import OutputType, PrettyOutput, find_git_root, get_multiline_input, load_env_from_file
 from jarvis.models.registry import PlatformRegistry
+from jarvis.jarvis_codebase.main import CodeBase
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import WordCompleter, Completer, Completion
+from prompt_toolkit.formatted_text import FormattedText
+from prompt_toolkit.styles import Style
+import fnmatch
 
 # 全局锁对象
 index_lock = threading.Lock()
@@ -18,12 +21,15 @@ index_lock = threading.Lock()
 class JarvisCoder:
     def __init__(self, root_dir: str, language: str):
         """初始化代码修改工具"""
+        
+        self.platform = os.environ.get("JARVIS_CODEGEN_PLATFORM") or os.environ.get("JARVIS_PLATFORM")
+        self.model = os.environ.get("JARVIS_CODEGEN_MODEL") or os.environ.get("JARVIS_MODEL")
 
-        self.root_dir = root_dir
-        self.platform = os.environ.get("JARVIS_CODEGEN_PLATFORM")
-        self.model = os.environ.get("JARVIS_CODEGEN_MODEL")
 
-        self.root_dir = self._find_git_root_dir(self.root_dir)
+        if not self.platform or not self.model:
+            raise ValueError("JARVIS_CODEGEN_PLATFORM or JARVIS_CODEGEN_MODEL is not set")
+
+        self.root_dir = find_git_root(root_dir)
         if not self.root_dir:
             self.root_dir = root_dir
 
@@ -41,10 +47,6 @@ class JarvisCoder:
         if not os.path.exists(self.jarvis_dir):
             os.makedirs(self.jarvis_dir)
 
-        self.index_db_path = os.path.join(self.jarvis_dir, "index.db")
-        if not os.path.exists(self.index_db_path):
-            self._create_index_db()
-
         self.record_dir = os.path.join(self.jarvis_dir, "record")
         if not os.path.exists(self.record_dir):
             os.makedirs(self.record_dir)
@@ -65,6 +67,9 @@ class JarvisCoder:
             os.system(f"git add .")
             os.system(f"git commit -m 'commit before code edit'")
 
+        # 4. 初始化代码库
+        self._codebase = CodeBase(self.root_dir)
+
     def _new_model(self):
         """获取大模型"""
         model = PlatformRegistry().get_global_platform_registry().create_platform(self.platform)
@@ -109,341 +114,6 @@ class JarvisCoder:
                 time.sleep(delay)
                 delay *= 2  # 指数退避
                 
-    def _get_key_info(self, file_path: str, content: str) -> Optional[Dict[str, Any]]:
-        """获取文件的关键信息
-        
-        Args:
-            file_path: 文件路径
-            content: 文件内容
-            
-        Returns:
-            Optional[Dict[str, Any]]: 文件信息，包含文件描述
-        """
-        model = self._new_model()  # 创建新的模型实例
-        model.set_suppress_output(True)
-        
-        prompt = f"""你是一个资深程序员，请根据文件内容，生成文件的关键信息，要求如下，除了代码，不要输出任何内容：
-
-1. 文件路径: {file_path}
-2. 文件内容:(<CONTENT_START>和<CONTENT_END>之间的部分) 
-<CONTENT_START>
-{content}
-<CONTENT_END>
-3. 关键信息: 请生成这个文件的主要功能和作用描述，包含的特征符号（函数和类、变量等），不超过100字
-"""
-        try:
-            return model.chat(prompt)
-        except Exception as e:
-            PrettyOutput.print(f"解析文件信息失败: {str(e)}", OutputType.ERROR)
-            return None
-        finally:
-            # 确保清理模型资源
-            try:
-                model.delete_chat()
-            except:
-                pass
-
-
-
-    def _get_file_md5(self, file_path: str) -> str:
-        """获取文件MD5"""
-        return hashlib.md5(open(file_path, "rb").read()).hexdigest()
-
-    
-    def _create_index_db(self):
-        """创建索引数据库"""
-        with index_lock:
-            if not os.path.exists(self.index_db_path):
-                PrettyOutput.print("Index database does not exist, creating...", OutputType.INFO)
-                index_db = sqlite3.connect(self.index_db_path)
-                index_db.execute(
-                    "CREATE TABLE files (file_path TEXT PRIMARY KEY, file_md5 TEXT, file_description TEXT)")
-                index_db.commit()
-                index_db.close()
-                PrettyOutput.print("Index database created", OutputType.SUCCESS)
-                # commit
-                os.chdir(self.root_dir)
-                os.system(f"git add .gitignore -f")
-                os.system(f"git commit -m 'add index database'")
-
-    
-    def _find_file_by_md5(self, file_md5: str) -> Optional[str]:
-        """根据文件MD5查找文件路径"""
-        with index_lock:
-            index_db = sqlite3.connect(self.index_db_path)
-            cursor = index_db.cursor()
-            cursor.execute(
-                "SELECT file_path FROM files WHERE file_md5 = ?", (file_md5,))
-            result = cursor.fetchone()
-            index_db.close()
-            return result[0] if result else None
-
-    
-    def _update_file_path(self, file_path: str, file_md5: str):
-        """更新文件路径"""
-        with index_lock:
-            index_db = sqlite3.connect(self.index_db_path)
-            cursor = index_db.cursor()
-            cursor.execute(
-                "UPDATE files SET file_path = ? WHERE file_md5 = ?", (file_path, file_md5))
-            index_db.commit()
-            index_db.close()
-
-    
-    def _insert_info(self, file_path: str, file_md5: str, file_description: str):
-        """插入文件信息"""
-        with index_lock:
-            index_db = sqlite3.connect(self.index_db_path)
-            cursor = index_db.cursor()
-            cursor.execute("DELETE FROM files WHERE file_path = ?", (file_path,))
-            cursor.execute("INSERT INTO files (file_path, file_md5, file_description) VALUES (?, ?, ?)",
-                           (file_path, file_md5, file_description))
-            index_db.commit()
-            index_db.close()
-
-    def _is_text_file(self, file_path: str) -> bool:
-        """判断文件是否是文本文件"""
-        try:
-            with open(file_path, 'rb') as f:
-                # 读取文件前1024个字节
-                chunk = f.read(1024)
-                # 检查是否包含空字节
-                if b'\x00' in chunk:
-                    return False
-                # 尝试解码为文本
-                chunk.decode('utf-8')
-                return True
-        except:
-            return False
-
-    def _index_project(self):
-        """建立代码库索引"""
-        import threading
-        from concurrent.futures import ThreadPoolExecutor, as_completed
-
-        git_files = os.popen("git ls-files").read().splitlines()
-
-        index_db = sqlite3.connect(self.index_db_path)
-        cursor = index_db.cursor()
-        cursor.execute("SELECT file_path FROM files")
-        db_files = [row[0] for row in cursor.fetchall()]
-        for db_file in db_files:
-            if not os.path.exists(db_file):
-                cursor.execute("DELETE FROM files WHERE file_path = ?", (db_file,))
-                PrettyOutput.print(f"删除不存在的文件记录: {db_file}", OutputType.INFO)
-        index_db.commit()
-        index_db.close()
-
-        def process_file(file_path: str):
-            """处理单个文件的索引任务"""
-            if not self._is_text_file(file_path):
-                return
-
-            # 计算文件MD5
-            file_md5 = self._get_file_md5(file_path)
-
-            # 查找文件
-            file_path_in_db = self._find_file_by_md5(file_md5)
-            if file_path_in_db:
-                PrettyOutput.print(
-                    f"文件 {file_path} 重复，跳过", OutputType.INFO)
-                if file_path_in_db != file_path:
-                    self._update_file_path(file_path, file_md5)
-                    PrettyOutput.print(
-                        f"文件 {file_path} 重复，更新路径为 {file_path}", OutputType.INFO)
-                return
-
-            with open(file_path, "r", encoding="utf-8") as f:
-                file_content = f.read()
-                key_info = self._get_key_info(file_path, file_content)
-                if not key_info:
-                    PrettyOutput.print(
-                        f"文件 {file_path} 索引失败", OutputType.INFO)
-                    return
-
-                self._insert_info(file_path, file_md5, key_info)
-                PrettyOutput.print(
-                    f"文件 {file_path} 已建立索引", OutputType.INFO)
-
-
-        # 使用线程池处理文件索引
-        with ThreadPoolExecutor(max_workers=10) as executor:
-            futures = [executor.submit(process_file, file_path) for file_path in git_files]
-            for future in as_completed(futures):
-                try:
-                    future.result()
-                except Exception as e:
-                    PrettyOutput.print(f"处理文件时发生错误: {str(e)}", OutputType.ERROR)
-
-        PrettyOutput.print("项目索引完成", OutputType.INFO)
-
-    def _get_files_from_db(self) -> List[Tuple[str, str]]:
-        """从数据库获取所有文件信息
-        
-        Returns:
-            List[Tuple[str, str]]: [(file_path, file_description), ...]
-        """
-        try:
-            index_db = sqlite3.connect(self.index_db_path)
-            cursor = index_db.cursor()
-            cursor.execute("SELECT file_path, file_description FROM files")
-            all_files = cursor.fetchall()
-            index_db.close()
-            return all_files
-        except sqlite3.Error as e:
-            PrettyOutput.print(f"数据库操作失败: {str(e)}", OutputType.ERROR)
-            return []
-
-    def _analyze_files_in_batches(self, all_files: List[Tuple[str, str]], feature: str, batch_size: int = 100) -> List[Dict]:
-        """批量分析文件相关性
-        
-        Args:
-            all_files: 所有文件列表
-            feature: 需求描述
-            batch_size: 批处理大小
-            
-        Returns:
-            List[Dict]: 带评分的文件列表
-        """
-        batch_results = []
-        
-        with ThreadPoolExecutor(max_workers=10) as executor:
-            futures = []
-            for i in range(0, len(all_files), batch_size):
-                batch_files = all_files[i:i + batch_size]
-                prompt = self._create_batch_analysis_prompt(batch_files, feature)
-                model = self._new_model()
-                model.set_suppress_output(True)
-                futures.append(executor.submit(self._call_model_with_retry, model, prompt))
-
-            for future in as_completed(futures):
-                success, response = future.result()
-                if not success:
-                    continue
-                
-                batch_start = futures.index(future) * batch_size
-                batch_end = min(batch_start + batch_size, len(all_files))
-                current_batch = all_files[batch_start:batch_end]
-                
-                results = self._process_batch_response(response, current_batch)
-                batch_results.extend(results)
-        
-        return batch_results
-
-    def _create_batch_analysis_prompt(self, batch_files: List[Tuple[str, str]], feature: str) -> str:
-        """创建批量分析的提示词
-        
-        Args:
-            batch_files: 批次文件列表
-            feature: 需求描述
-            
-        Returns:
-            str: 提示词
-        """
-        prompt = """你是资深程序员，请根据需求描述，从以下文件路径中选出最相关的文件，按相关度从高到低排序。
-
-相关度打分标准(0-9分)：
-- 9分：文件名直接包含需求中的关键词，且文件功能与需求完全匹配
-- 7-8分：文件名包含需求相关词，或文件功能与需求高度相关
-- 5-6分：文件名暗示与需求有关，或文件功能与需求部分相关
-- 3-4分：文件可能需要小幅修改以配合需求
-- 1-2分：文件与需求关系较远，但可能需要少量改动
-- 0分：文件与需求完全无关
-
-请输出yaml格式，仅输出以下格式内容：
-<RELEVANT_FILES_START>
-file1.py: 9
-file2.py: 7
-<RELEVANT_FILES_END>
-
-文件列表：
-"""
-        for file_path, _ in batch_files:
-            prompt += f"- {file_path}\n"
-        prompt += f"\n需求描述: {feature}\n"
-        prompt += "\n注意：\n1. 只输出最相关的文件，不超过5个\n2. 根据上述打分标准判断相关性\n3. 相关度必须是0-9的整数"
-        
-        return prompt
-
-    def _process_batch_response(self, response: str, batch_files: List[Tuple[str, str]]) -> List[Dict]:
-        """处理批量分析的响应
-        
-        Args:
-            response: 模型响应
-            batch_files: 批次文件列表
-            
-        Returns:
-            List[Dict]: 处理后的文件列表
-        """
-        try:
-            response = response.replace("<RELEVANT_FILES_START>", "").replace("<RELEVANT_FILES_END>", "")
-            result = yaml.safe_load(response)
-            
-            batch_files_dict = {f[0]: f[1] for f in batch_files}
-            results = []
-            for file_path, score in result.items():
-                if isinstance(file_path, str) and isinstance(score, int):
-                    score = max(0, min(9, score))  # Ensure score is between 0-9
-                    if file_path in batch_files_dict:
-                        results.append({
-                            "file_path": file_path,
-                            "file_description": batch_files_dict[file_path],
-                            "score": score
-                        })
-            return results
-        except Exception as e:
-            PrettyOutput.print(f"处理批次文件失败: {str(e)}", OutputType.ERROR)
-            return []
-
-
-    def _process_content_response(self, response: str, top_files: List[Dict]) -> List[Dict]:
-        """处理内容分析的响应"""
-        try:
-            response = response.replace("<FILE_RELATION_START>", "").replace("<FILE_RELATION_END>", "")
-            file_relation = yaml.safe_load(response)
-            if not file_relation:
-                return top_files[:5]
-            
-            score = [[] for _ in range(10)]  # 创建10个空列表，对应0-9分
-            for file_id, relation in file_relation.items():
-                id = int(file_id)
-                relation = max(0, min(9, relation))  # 确保范围在0-9之间
-                score[relation].append(top_files[id])
-            
-            files = []
-            for scores in reversed(score):  # 从高分到低分遍历
-                files.extend(scores)
-                if len(files) >= 5:  # 直接取相关性最高的5个文件
-                    break
-            
-            return files[:5]
-        except Exception as e:
-            PrettyOutput.print(f"处理文件关系失败: {str(e)}", OutputType.ERROR)
-            return top_files[:5]
-
-    def _find_related_files(self, feature: str) -> List[Dict]:
-        """根据需求描述，查找相关文件
-        
-        Args:
-            feature: 需求描述
-            
-        Returns:
-            List[Dict]: 相关文件列表
-        """
-        # 1. 从数据库获取所有文件
-        all_files = self._get_files_from_db()
-        if not all_files:
-            return []
-        
-        # 2. 批量分析文件相关性
-        batch_results = self._analyze_files_in_batches(all_files, feature)
-        
-        # 3. 排序并获取前5个文件
-        batch_results.sort(key=lambda x: x["score"], reverse=True)
-        return batch_results[:5]
-        
-        
-
     def _remake_patch(self, prompt: str) -> List[str]:
         success, response = self._call_model_with_retry(self.main_model, prompt, max_retries=5)  # 增加重试次数
         if not success:
@@ -454,7 +124,7 @@ file2.py: 7
             return [patch.replace('<PATCH_START>', '').replace('<PATCH_END>', '').strip() 
                    for patch in patches if patch.strip()]
         except Exception as e:
-            PrettyOutput.print(f"解析patch失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"解析patch失败: {str(e)}", OutputType.WARNING)
             return []
         
     def _make_patch(self, related_files: List[Dict], feature: str) -> List[str]:
@@ -468,21 +138,32 @@ file2.py: 7
 要替换的内容
 =======
 新的内容
-<<<<<<
+>>>>>>
 <PATCH_END>
 
-2. 如果是新文件，格式如下：
+2. 如果是新文件或者替换整个文件内容，格式如下：
 <PATCH_START>
 >>>>>> path/to/new/file
 =======
 新文件的完整内容
-<<<<<<
+>>>>>>
+<PATCH_END>
+
+3. 如果要删除文件中的某一段，格式如下：
+<PATCH_START>
+>>>>>> path/to/file
+要删除的内容
+=======
+>>>>>>
 <PATCH_END>
 
 文件列表如下：
 """
         for i, file in enumerate(related_files):
-            prompt += f"""{i}. {file["file_path"]} : {file["file_description"]}\n"""
+            if len(prompt) > 30 * 1024:
+                PrettyOutput.print(f'避免上下文超限，丢弃低相关度文件：{file["file_path"]}', OutputType.WARNING)
+                continue
+            prompt += f"""{i}. {file["file_path"]}\n"""
             prompt += f"""文件内容:\n"""
             prompt += f"<FILE_CONTENT_START>\n"
             prompt += f'{file["file_content"]}\n'
@@ -493,6 +174,8 @@ file2.py: 7
 注意事项：
 1、仅输出补丁内容，不要输出任何其他内容，每个补丁必须用<PATCH_START>和<PATCH_END>标记
 2、如果在大段代码中有零星修改，生成多个补丁
+3、要替换的内容，一定要与文件内容完全一致，不要有任何多余或者缺失的内容
+4、每个patch不超过20行，超出20行，请生成多个patch
 """
         
         success, response = self._call_model_with_retry(self.main_model, prompt)
@@ -505,7 +188,7 @@ file2.py: 7
             return [patch.replace('<PATCH_START>', '').replace('<PATCH_END>', '').strip() 
                    for patch in patches if patch.strip()]
         except Exception as e:
-            PrettyOutput.print(f"解析patch失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"解析patch失败: {str(e)}", OutputType.WARNING)
             return []
 
     def _apply_patch(self, related_files: List[Dict], patches: List[str]) -> Tuple[bool, str]:
@@ -544,7 +227,7 @@ file2.py: 7
                     return False, "\n".join(error_info)
                 
                 old_content = parts[0]
-                new_content = parts[1].split("<<<<<<")[0]
+                new_content = parts[1].split(">>>>>>")[0]
                 
                 # 处理新文件
                 if not old_content:
@@ -595,12 +278,12 @@ file2.py: 7
         
         return True, ""
 
-    def _save_edit_record(self, feature: str, patches: List[str]) -> None:
+    def _save_edit_record(self, commit_message: str, git_diff: str) -> None:
         """保存代码修改记录
         
         Args:
-            feature: 需求描述
-            patches: 补丁列表
+            commit_message: 提交信息
+            git_diff: git diff --cached的输出
         """
             
         # 获取下一个序号
@@ -613,8 +296,8 @@ file2.py: 7
         # 创建记录文件
         record = {
             "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
-            "feature": feature,
-            "patches": patches
+            "commit_message": commit_message,
+            "git_diff": git_diff
         }
         
         record_path = os.path.join(self.record_dir, f"{next_num:04d}.yaml")
@@ -623,28 +306,30 @@ file2.py: 7
         
         PrettyOutput.print(f"已保存修改记录: {record_path}", OutputType.SUCCESS)
 
-    def _find_git_root_dir(self, root_dir: str) -> str:
-        """查找git根目录"""
-        while not os.path.exists(os.path.join(root_dir, ".git")):
-            root_dir = os.path.dirname(root_dir)
-            if root_dir == "/":
-                return None
-        return root_dir
+
 
 
     def _prepare_execution(self) -> None:
         """准备执行环境"""
         self.main_model = self._new_model()
-        self._index_project()
+        self._codebase.generate_codebase()
+
 
     def _load_related_files(self, feature: str) -> List[Dict]:
         """加载相关文件内容"""
-        related_files = self._find_related_files(feature)
-        for file in related_files:
-            PrettyOutput.print(f"Related file: {file['file_path']}", OutputType.INFO)
-            with open(file["file_path"], "r", encoding="utf-8") as f:
-                file["file_content"] = f.read()
-        return related_files
+        ret = []
+        # 确保索引数据库已生成
+        if not self._codebase.is_index_generated():
+            PrettyOutput.print("检测到索引数据库未生成，正在生成...", OutputType.WARNING)
+            self._codebase.generate_codebase()
+            
+        related_files = self._codebase.search_similar(feature)
+        for file, score, _ in related_files:
+            PrettyOutput.print(f"相关文件: {file} 相关度: {score:.3f}", OutputType.SUCCESS)
+            with open(file, "r", encoding="utf-8") as f:
+                content = f.read()
+            ret.append({"file_path": file, "file_content": content})
+        return ret
 
     def _handle_patch_application(self, related_files: List[Dict], patches: List[str], feature: str) -> Dict[str, Any]:
         """处理补丁应用流程"""
@@ -661,7 +346,7 @@ file2.py: 7
             if success:
                 user_confirm = input("是否确认修改？(y/n)")
                 if user_confirm.lower() == "y":
-                    self._finalize_changes(feature, patches)
+                    self._finalize_changes(feature)
                     return {
                         "success": True,
                         "stdout": f"已完成功能开发{feature}",
@@ -691,13 +376,74 @@ file2.py: 7
 """
                 patches = self._remake_patch(retry_prompt)
 
-    def _finalize_changes(self, feature: str, patches: List[str]) -> None:
+
+
+
+    def _generate_commit_message(self, git_diff: str, feature: str) -> str:
+        """根据git diff和功能描述生成commit信息
+        
+        Args:
+            git_diff: git diff --cached的输出
+            feature: 用户的功能描述
+            
+        Returns:
+            str: 生成的commit信息
+        """
+        
+        # 生成提示词
+        prompt = f"""你是一个经验丰富的程序员，请根据以下代码变更和功能描述生成简洁明了的commit信息：
+
+功能描述：
+{feature}
+
+代码变更：
+"""
+        # 添加git diff内容
+        prompt += f"Git Diff:\n{git_diff}\n\n"
+            
+        prompt += """
+请遵循以下规则：
+1. 使用英文编写
+2. 采用常规的commit message格式：<type>(<scope>): <subject>
+3. 保持简洁，不超过50个字符
+4. 准确描述代码变更的主要内容
+5. 优先考虑功能描述和git diff中的变更内容
+"""
+        
+        # 使用normal模型生成commit信息
+        model = PlatformRegistry().get_global_platform_registry().create_platform(self.platform)
+        model.set_model_name(self.model)
+        model.set_suppress_output(True)
+        success, response = self._call_model_with_retry(model, prompt)
+        if not success:
+            return "Update code changes"
+            
+        # 清理响应内容
+        return response.strip().split("\n")[0]
+
+    def _finalize_changes(self, feature: str) -> None:
         """完成修改并提交"""
         PrettyOutput.print("修改确认成功，提交修改", OutputType.INFO)
-        os.system(f"git add .")
-        os.system(f"git commit -m '{feature}'")
-        self._save_edit_record(feature, patches)
-        self._index_project()
+
+        # 只添加已经在 git 控制下的修改文件
+        os.system("git add -u")
+        
+        # 然后获取 git diff
+        git_diff = os.popen("git diff --cached").read()
+        
+        # 自动生成commit信息，传入feature
+        commit_message = self._generate_commit_message(git_diff, feature)
+        
+        # 显示并确认commit信息
+        PrettyOutput.print(f"自动生成的commit信息: {commit_message}", OutputType.INFO)
+        user_confirm = input("是否使用该commit信息？(y/n) [y]: ") or "y"
+        
+        if user_confirm.lower() != "y":
+            commit_message = input("请输入新的commit信息: ")
+        
+        # 不需要再次 git add，因为已经添加过了
+        os.system(f"git commit -m '{commit_message}'")
+        self._save_edit_record(commit_message, git_diff)
 
     def _revert_changes(self) -> None:
         """回退所有修改"""
@@ -758,8 +504,8 @@ def main():
     # 循环处理需求
     while True:
         try:
-            # 获取需求
-            feature = get_multiline_input("请输入开发需求 (输入空行退出):")
+            # 获取需求，传入项目根目录
+            feature = get_multiline_input("请输入开发需求 (输入空行退出):", tool.root_dir)
             
             if not feature or feature == "__interrupt__":
                 break
@@ -772,9 +518,9 @@ def main():
                 PrettyOutput.print(result["stdout"], OutputType.SUCCESS)
             else:
                 if result["stderr"]:
-                    PrettyOutput.print(result["stderr"], OutputType.ERROR)
+                    PrettyOutput.print(result["stderr"], OutputType.WARNING)
                 if result["error"]:
-                    PrettyOutput.print(f"错误类型: {type(result['error']).__name__}", OutputType.ERROR)
+                    PrettyOutput.print(f"错误类型: {type(result['error']).__name__}", OutputType.WARNING)
                 
         except KeyboardInterrupt:
             print("\n用户中断执行")
@@ -787,3 +533,122 @@ def main():
 
 if __name__ == "__main__":
     exit(main())
+
+class FilePathCompleter(Completer):
+    """文件路径自动完成器"""
+    
+    def __init__(self, root_dir: str):
+        self.root_dir = root_dir
+        self._file_list = None
+        
+    def _get_files(self) -> List[str]:
+        """获取git管理的文件列表"""
+        if self._file_list is None:
+            try:
+                # 切换到项目根目录
+                old_cwd = os.getcwd()
+                os.chdir(self.root_dir)
+                
+                # 获取git管理的文件列表
+                self._file_list = os.popen("git ls-files").read().splitlines()
+                
+                # 恢复工作目录
+                os.chdir(old_cwd)
+            except Exception as e:
+                PrettyOutput.print(f"获取文件列表失败: {str(e)}", OutputType.WARNING)
+                self._file_list = []
+        return self._file_list
+    
+    def get_completions(self, document, complete_event):
+        """获取补全建议"""
+        text_before_cursor = document.text_before_cursor
+        
+        # 检查是否刚输入了@
+        if text_before_cursor.endswith('@'):
+            # 显示所有文件
+            for path in self._get_files():
+                yield Completion(path, start_position=0)
+            return
+            
+        # 检查之前是否有@，并获取@后的搜索词
+        at_pos = text_before_cursor.rfind('@')
+        if at_pos == -1:
+            return
+            
+        search = text_before_cursor[at_pos + 1:].lower().strip()
+        
+        # 提供匹配的文件建议
+        for path in self._get_files():
+            path_lower = path.lower()
+            if (search in path_lower or  # 直接包含
+                search in os.path.basename(path_lower) or  # 文件名包含
+                any(fnmatch.fnmatch(path_lower, f'*{s}*') for s in search.split())): # 通配符匹配
+                # 计算正确的start_position
+                yield Completion(path, start_position=-(len(search)))
+
+class SmartCompleter(Completer):
+    """智能自动完成器，组合词语和文件路径补全"""
+    
+    def __init__(self, word_completer: WordCompleter, file_completer: FilePathCompleter):
+        self.word_completer = word_completer
+        self.file_completer = file_completer
+        
+    def get_completions(self, document, complete_event):
+        """获取补全建议"""
+        # 如果当前行以@结尾，使用文件补全
+        if document.text_before_cursor.strip().endswith('@'):
+            yield from self.file_completer.get_completions(document, complete_event)
+        else:
+            # 否则使用词语补全
+            yield from self.word_completer.get_completions(document, complete_event)
+
+def get_multiline_input(prompt_text: str, root_dir: str = None) -> str:
+    """获取多行输入，支持文件路径自动完成功能
+    
+    Args:
+        prompt_text: 提示文本
+        root_dir: 项目根目录，用于文件补全
+        
+    Returns:
+        str: 用户输入的文本
+    """
+    # 创建文件补全器
+    file_completer = FilePathCompleter(root_dir or os.getcwd())
+    
+    # 创建提示样式
+    style = Style.from_dict({
+        'prompt': 'ansicyan bold',
+        'input': 'ansiwhite',
+    })
+    
+    # 创建会话
+    session = PromptSession(
+        completer=file_completer,
+        style=style,
+        multiline=False,
+        enable_history_search=True,
+        complete_while_typing=True
+    )
+    
+    # 显示初始提示文本
+    print(f"\n{prompt_text}")
+    
+    # 创建提示符
+    prompt = FormattedText([
+        ('class:prompt', ">>> ")
+    ])
+    
+    # 获取输入
+    lines = []
+    try:
+        while True:
+            line = session.prompt(prompt).strip()
+            if not line:  # 空行表示输入结束
+                break
+            lines.append(line)
+    except KeyboardInterrupt:
+        return "__interrupt__"
+    except EOFError:
+        pass
+    
+    return "\n".join(lines)