auto-coder 0.1.347__py3-none-any.whl → 0.1.348__py3-none-any.whl

{auto_coder-0.1.347.dist-info → auto_coder-0.1.348.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.347
+Version: 0.1.348
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Programming Language :: Python :: 3.10

{auto_coder-0.1.347.dist-info → auto_coder-0.1.348.dist-info}/RECORD

@@ -4,7 +4,7 @@ autocoder/auto_coder_lang.py,sha256=Rtupq6N3_HT7JRhDKdgCBcwRaiAnyCOR_Gsp4jUomrI,
 autocoder/auto_coder_rag.py,sha256=NesRm7sIJrRQL1xxm_lbMtM7gi-KrYv9f26RfBuloZE,35386
 autocoder/auto_coder_rag_client_mcp.py,sha256=QRxUbjc6A8UmDMQ8lXgZkjgqtq3lgKYeatJbDY6rSo0,6270
 autocoder/auto_coder_rag_mcp.py,sha256=-RrjNwFaS2e5v8XDIrKR-zlUNUE8UBaeOtojffBrvJo,8521
-autocoder/auto_coder_runner.py,sha256=2hI2095L5GWP1J04Lr7xBBTDOcNq_l4-HctcJ8bVaFE,111833
+autocoder/auto_coder_runner.py,sha256=LV2QJZC9CEpDYkQEjVh5Ih5Ga5rhHvoW3J4G5cri8Z8,111857
 autocoder/auto_coder_server.py,sha256=bLORGEclcVdbBVfM140JCI8WtdrU0jbgqdJIVVupiEU,20578
 autocoder/benchmark.py,sha256=Ypomkdzd1T3GE6dRICY3Hj547dZ6_inqJbBJIp5QMco,4423
 autocoder/chat_auto_coder.py,sha256=CthuvdjVjTQOVv-zREsl8OCsZHPSP9OQcIgHULrW2Ro,25842
@@ -14,7 +14,7 @@ autocoder/command_parser.py,sha256=fx1g9E6GaM273lGTcJqaFQ-hoksS_Ik2glBMnVltPCE,1
 autocoder/lang.py,sha256=PFtATuOhHRnfpqHQkXr6p4C893JvpsgwTMif3l-GEi0,14321
 autocoder/models.py,sha256=_SCar82QIeBFTZZBdM2jPS6atKVhHnvE0gX3V0CsxD4,11590
 autocoder/run_context.py,sha256=IUfSO6_gp2Wt1blFWAmOpN0b0nDrTTk4LmtCYUBIoro,1643
-autocoder/version.py,sha256=R1KcSahF3DMgAzBREOFaR3Pjcqm9a3u4b36Hb2RFm50,23
+autocoder/version.py,sha256=1h2cvc5WOu9wxtFBJmh-3rclKh09vlAmUylW6SDUges,23
 autocoder/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autocoder/agent/agentic_edit.py,sha256=XsfePZ-t6M-uBSdG1VLZXk1goqXk2HPeJ_A8IYyBuWQ,58896
 autocoder/agent/agentic_edit_types.py,sha256=oFcDd_cxJ2yH9Ed1uTpD3BipudgoIEWDMPb5pAkq4gI,3288
@@ -54,7 +54,7 @@ autocoder/common/action_yml_file_manager.py,sha256=DdF5P1R_B_chCnnqoA2IgogakWLZk
 autocoder/common/anything2images.py,sha256=0ILBbWzY02M-CiWB-vzuomb_J1hVdxRcenAfIrAXq9M,25283
 autocoder/common/anything2img.py,sha256=iZQmg8srXlD7N5uGl5b_ONKJMBjYoW8kPmokkG6ISF0,10118
 autocoder/common/audio.py,sha256=Kn9nWKQddWnUrAz0a_ZUgjcu4VUU_IcZBigT7n3N3qc,7439
-autocoder/common/auto_coder_lang.py,sha256=bqBoICLIvi9l8jRCwcNLWR6n5pI3ix7YDPGpmqQDmgc,42677
+autocoder/common/auto_coder_lang.py,sha256=TqyxigNAEg_Ouji-cGMx5alkFjboUDgFPSOwYgYAnNM,42757
 autocoder/common/auto_configure.py,sha256=D4N-fl9v8bKM5-Ds-uhkC2uGDmHH_ZjLJ759F8KXMKs,13129
 autocoder/common/buildin_tokenizer.py,sha256=L7d5t39ZFvUd6EoMPXUhYK1toD0FHlRH1jtjKRGokWU,1236
 autocoder/common/chunk_validation.py,sha256=BrR_ZWavW8IANuueEE7hS8NFAwEvm8TX34WnPx_1hs8,3030
@@ -126,7 +126,7 @@ autocoder/common/v2/code_editblock_manager.py,sha256=G0CIuV9Ki0FqMLnpA8nBT4pnkCN
 autocoder/common/v2/code_manager.py,sha256=C403bS-f6urixwitlKHcml-J03hci-UyNwHJOqBiY6Q,9182
 autocoder/common/v2/code_strict_diff_manager.py,sha256=v-J1kDyLg7tLGg_6_lbO9S4fNkx7M_L8Xr2G7fPptiU,9347
 autocoder/common/v2/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autocoder/common/v2/agent/agentic_edit.py,sha256=pxgKD-FZaaRQkPgWsxvLleUXDRFC8qSlYfNUHU6ZENU,94794
+autocoder/common/v2/agent/agentic_edit.py,sha256=qPEvDvK2iF9eyTlWqJMCL6BDzpS1fCbQsTaG4vExyd8,94942
 autocoder/common/v2/agent/agentic_edit_conversation.py,sha256=qLLhTegH619JQTp3s1bj5FVn2hAcoV-DlhGO3UyIOMc,7338
 autocoder/common/v2/agent/agentic_edit_types.py,sha256=VJMrictg6hJ3mC45VgQGRd43DyDUPDUvPV1Rf3z72NI,4776
 autocoder/common/v2/agent/agentic_tool_display.py,sha256=WKirt-2V346KLnbHgH3NVJiK3xvriD9oaCWj2IdvzLU,7309
@@ -199,7 +199,7 @@ autocoder/memory/active_context_manager.py,sha256=nqWD4lBLNcskXDRERhPpqnmn_i1V7_
 autocoder/memory/active_package.py,sha256=NHLLnncFSfFcOFLWILwJLuEVd4nOoL0mqzFev6QHgzU,25480
 autocoder/memory/async_processor.py,sha256=htHzLGupw9IHQAEdLe2AEaALZSItPi3AltDt8FMTRHk,4643
 autocoder/memory/directory_mapper.py,sha256=BXHblOdRpeZb7URDECALp9uN5oi91KmkW9g_UaWFuZY,2513
-autocoder/plugins/__init__.py,sha256=uc8UNSAVb9uQvr5zUSS-Xu_RhrdbO2i3w2NhkrVtODM,43023
+autocoder/plugins/__init__.py,sha256=T71wGXBP24NhFyf9BntKDXWPIvKp5hWhq_-xK7C-ptE,43722
 autocoder/plugins/dynamic_completion_example.py,sha256=dDTeISsGqcWjxY_PzbFSZ4Q7_QwYUcuHUdWJT8x7q-4,4693
 autocoder/plugins/git_helper_plugin.py,sha256=nKQWkU-nQ39A4WC8nC8KI-x68VjwVARQvtrtQQ1GTMI,8386
 autocoder/plugins/sample_plugin.py,sha256=0Hn1SdLovSPwMamooXyfcX5JGzsROt238bMbBhE6aIk,5215
@@ -244,6 +244,7 @@ autocoder/rag/cache/simple_cache.py,sha256=yrGgRXGcMNrWSQOviPshm3Qlo2QDNVFoRZPLN
 autocoder/rag/loaders/__init__.py,sha256=EQHEZ5Cmz-mGP2SllUTvcIbYCnF7W149dNpNItfs0yE,304
 autocoder/rag/loaders/docx_loader.py,sha256=ZswPqiiLngUEpzLhNNm1nmwEYV7ZHFEfIoXoG7c5GDU,614
 autocoder/rag/loaders/excel_loader.py,sha256=Ue8YB1z_kBs8SjIPuBskyM08Q1JiONs_BJZPrzi59oo,896
+autocoder/rag/loaders/image_loader.py,sha256=UMzVDG4wmqpXYlWclNvFWCC0UHr_sWBj36RVBnjaIoA,20218
 autocoder/rag/loaders/pdf_loader.py,sha256=9cLPdhfSiedvEUFFM7I-PkZ-9klJmj8AtuihETfzO_o,706
 autocoder/rag/loaders/ppt_loader.py,sha256=7VEYc-bqgK8VHCoGC3DIUcqbpda-E5jQF9lYLqP256I,1681
 autocoder/rag/stream_event/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -279,9 +280,9 @@ autocoder/utils/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autocoder/utils/auto_coder_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autocoder/utils/auto_coder_utils/chat_stream_out.py,sha256=KW0mlmcHlStXi8-_6fXZ2-ifeJ5mgP0OV7DQFzCtIsw,14008
 autocoder/utils/chat_auto_coder_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-auto_coder-0.1.347.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-auto_coder-0.1.347.dist-info/METADATA,sha256=-wG5ilXMo-fYflOC9zJZY2N0JdHBluyyxYNqxhzNVwQ,2728
-auto_coder-0.1.347.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-auto_coder-0.1.347.dist-info/entry_points.txt,sha256=0nzHtHH4pNcM7xq4EBA2toS28Qelrvcbrr59GqD_0Ak,350
-auto_coder-0.1.347.dist-info/top_level.txt,sha256=Jqc0_uJSw2GwoFQAa9iJxYns-2mWla-9ok_Y3Gcznjk,10
-auto_coder-0.1.347.dist-info/RECORD,,
+auto_coder-0.1.348.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+auto_coder-0.1.348.dist-info/METADATA,sha256=RSE1DWgb1J9bSnwhqwMngmydulCNkWiEETsz7nB6rwQ,2728
+auto_coder-0.1.348.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+auto_coder-0.1.348.dist-info/entry_points.txt,sha256=0nzHtHH4pNcM7xq4EBA2toS28Qelrvcbrr59GqD_0Ak,350
+auto_coder-0.1.348.dist-info/top_level.txt,sha256=Jqc0_uJSw2GwoFQAa9iJxYns-2mWla-9ok_Y3Gcznjk,10
+auto_coder-0.1.348.dist-info/RECORD,,

autocoder/auto_coder_runner.py

@@ -2838,11 +2838,12 @@ def auto_command(query: str,extra_args: Dict[str,Any]={}):
                             memory_config=MemoryConfig(memory=memory, 
                             save_memory_func=save_memory), command_config=CommandConfig,
                             conversation_name="current"
-                            )
-        if get_run_context() == RunMode.TERMINAL:
-            agent.run_in_terminal(AgenticEditRequest(user_input=query))
-        else:
+                            )           
+        if get_run_context().mode == RunMode.WEB:
             agent.run_with_events(AgenticEditRequest(user_input=query))
+        else:
+            agent.run_in_terminal(AgenticEditRequest(user_input=query))
+            
         return
         
     args = get_final_config()  

autocoder/common/auto_coder_lang.py

@@ -836,11 +836,11 @@ MESSAGES = {
     },
     "/agent/edit/apply_pre_changes":{
         "en":"Commit user changes",
-        "zh":"提交用户修改"
+        "zh":"检查用户是否有手动修改(如有，会自动提交)..."
     },
     "/agent/edit/apply_changes":{
-        "en":"Commit changes",
-        "zh":"提交修改"
+        "en":"Commit the changes in preview steps",
+        "zh":"提交前面步骤的修改"
     }
 }
 

autocoder/common/v2/agent/agentic_edit.py

@@ -212,18 +212,7 @@ class AgenticEdit:
     @byzerllm.prompt()
     def _analyze(self, request: AgenticEditRequest) -> str:
         """        
-        You are a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.
-
-        ====
-
-        FILES CONTEXT
-
-        The following files are provided to you as context for the user's task. You can use these files to understand the project structure and codebase, and to make informed decisions about which files to modify.
-        If you need to read more files, you can use the tools to find and read more files.
-
-        <files>
-        {{files}}
-        </files>
+        You are a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.        
 
         ====        
 
@@ -690,8 +679,10 @@ class AgenticEdit:
         The following rules are provided by the user, and you must follow them strictly.
 
         {% for key, value in extra_docs.items() %}
-        ### {{ key }}
+        <user_rule>
+        ##File: {{ key }}
         {{ value }}
+        </user_rule>
         {% endfor %}        
         {% endif %}
         """
@@ -706,7 +697,7 @@ class AgenticEdit:
                     try:
                         with open(fpath, "r", encoding="utf-8") as f:
                             content = f.read()
-                            key = os.path.splitext(fname)[0]
+                            key = fpath
                             extra_docs[key] = content
                     except Exception:
                         continue
@@ -784,11 +775,25 @@ class AgenticEdit:
         # print(system_prompt)
         conversations = [
             {"role": "system", "content": system_prompt},
-        ] + self.conversation_manager.get_history()
+        ] 
+        
+        conversations.append({
+            "role":"user","content":f'''
+Below are some files the user is focused on, and the content is up to date. These entries show the file paths along with their full text content, which can help you better understand the user's needs. If the information is insufficient, you can use tools such as read_file to retrieve more details.
+<files>
+{self.files.to_str()}
+</files>'''
+        })
+
+        conversations.append({
+            "role":"assistant","content":"Ok"
+        })
+        conversations.extend(self.conversation_manager.get_history())        
         conversations.append({
             "role": "user", "content": request.user_input
         })
         self.conversation_manager.add_user_message(request.user_input)
+        
         logger.debug(
             f"Initial conversation history size: {len(conversations)}")
 
@@ -1013,9 +1018,7 @@ class AgenticEdit:
 
         for content_chunk, metadata in generator:
             global_cancel.check_and_raise()
-
-            meta_holder.meta = metadata
-            logger.info(f"metadata: {metadata.input_tokens_count}")
+            meta_holder.meta = metadata            
             if not content_chunk:
                 continue
             buffer += content_chunk

autocoder/plugins/__init__.py

@@ -256,6 +256,7 @@ class PluginManager:
             "/plugins/dirs /remove",
             "/plugins/dirs /clear",
         ]
+        self._wrapped_functions: Dict[str, Callable] = {}
 
     @property
     def cached_discover_plugins(self) -> List[Type[Plugin]]:
@@ -561,6 +562,7 @@ class PluginManager:
                 return result
             return None
 
+        self._wrapped_functions[func_name] = wrapped
         return wrapped
 
     def register_function_interception(self, plugin_name: str, func_name: str) -> None:
@@ -1107,6 +1109,24 @@ class PluginManager:
 
         return processed_completions
 
+    def get_wrapped_functions(self) -> Dict[str, Callable]:
+        """获取所有已包装的函数。
+
+        Returns:
+            Dict[str, Callable]: 包含所有已包装函数的字典，键为函数名，值为包装后的函数
+        """
+        return self._wrapped_functions
+
+    def get_wrapped_function(self, func_name: str) -> Callable:
+        """获取已包装的函数。
+
+        Args:
+            func_name: 函数名
+
+        Returns:
+            已包装的函数，如果未找到则返回 None
+        """
+        return self._wrapped_functions.get(func_name)
 
 def register_global_plugin_dir(plugin_dir: str) -> None:
     """注册一个全局插件目录。

autocoder/rag/loaders/image_loader.py

@@ -0,0 +1,551 @@
+import os
+import traceback
+import re
+from PIL import Image
+
+try:
+    from paddleocr import PaddleOCR
+except ImportError:
+    PaddleOCR = None
+
+try:
+    import paddlex as paddlex_module
+except ImportError:
+    paddlex_module = None
+
+import byzerllm
+from byzerllm.utils.client import code_utils
+from autocoder.utils.llms import get_single_llm
+from loguru import logger
+from typing import List, Tuple, Optional
+from pydantic import BaseModel
+
+
+class ReplaceInFileTool(BaseModel):
+    path: str
+    diff: str
+
+
+class ImageLoader:
+    """
+    A class for loading and processing images, extracting text and tables from them,
+    and converting the content to markdown format.
+    """
+    
+    @staticmethod
+    def parse_diff(diff_content: str) -> List[Tuple[str, str]]:
+        """
+        Parses the diff content into a list of (search_block, replace_block) tuples.
+        """
+        blocks = []
+        lines = diff_content.splitlines(keepends=True)
+        i = 0
+        n = len(lines)
+
+        while i < n:
+            line = lines[i]
+            if line.strip() == "<<<<<<< SEARCH":
+                i += 1
+                search_lines = []
+                # Accumulate search block
+                while i < n and lines[i].strip() != "=======":
+                    search_lines.append(lines[i])
+                    i += 1
+                if i >= n:
+                    logger.warning("Unterminated SEARCH block found in diff content.")
+                    break
+                i += 1  # skip '======='
+                replace_lines = []
+                # Accumulate replace block
+                while i < n and lines[i].strip() != ">>>>>>> REPLACE":
+                    replace_lines.append(lines[i])
+                    i += 1
+                if i >= n:
+                    logger.warning("Unterminated REPLACE block found in diff content.")
+                    break
+                i += 1  # skip '>>>>>>> REPLACE'
+
+                search_block = ''.join(search_lines)
+                replace_block = ''.join(replace_lines)
+                blocks.append((search_block, replace_block))
+            else:
+                i += 1
+
+        if not blocks and diff_content.strip():
+            logger.warning(f"Could not parse any SEARCH/REPLACE blocks from diff: {diff_content}")
+        return blocks
+    
+    @staticmethod
+    def paddleocr_extract_text(
+        file_path,
+        lang='ch',
+        use_angle_cls=True,
+        page_num=10,
+        slice_params=None,
+        det_model_dir=None,
+        rec_model_dir=None,
+        **kwargs
+    ):
+        """
+        使用 PaddleOCR 识别文本，支持图片、PDF、超大图像滑动窗口
+
+        Args:
+            file_path: 图片或PDF路径
+            lang: 语言，默认中文
+            use_angle_cls: 是否启用方向分类
+            page_num: 识别PDF时的最大页数
+            slice_params: 超大图像滑动窗口参数 dict
+            det_model_dir: 自定义检测模型路径
+            rec_model_dir: 自定义识别模型路径
+            kwargs: 其他paddleocr参数
+        Returns:
+            识别出的纯文本字符串
+        """
+        if PaddleOCR is None:
+            print("paddleocr not installed")
+            return ""
+
+        # 初始化 OCR
+        try:
+            ocr = PaddleOCR(
+                use_angle_cls=use_angle_cls,
+                lang=lang,
+                page_num=page_num,
+                det_model_dir=det_model_dir,
+                rec_model_dir=rec_model_dir,
+                **kwargs
+            )
+        except Exception:
+            traceback.print_exc()
+            return ""
+
+        try:
+            ext = os.path.splitext(file_path)[1].lower()
+
+            # 处理PDF
+            if ext == ".pdf":
+                result = ocr.ocr(file_path, cls=True) # result is list of pages, each page is list of lines
+                lines = []
+                if result and isinstance(result, list):
+                    for page in result:
+                        if page and isinstance(page, list):
+                            for line_info in page: # line_info is [points, (text, confidence)]
+                                try:
+                                    # Check structure: [points, (text, confidence)]
+                                    if isinstance(line_info, (list, tuple)) and len(line_info) == 2 and \
+                                       isinstance(line_info[1], (list, tuple)) and len(line_info[1]) >= 1:
+                                        txt = line_info[1][0]
+                                        if isinstance(txt, str):
+                                            lines.append(txt)
+                                        else:
+                                            logger.warning(f"Extracted text is not a string in PDF: {txt} (type: {type(txt)}). Skipping.")
+                                    else:
+                                        logger.warning(f"Unexpected line_info structure in PDF: {line_info}. Skipping.")
+                                except Exception as e:
+                                    logger.warning(f"Error processing line_info in PDF: {line_info}. Error: {e}")
+                return "\n".join(lines)
+
+            # 处理图片
+            else: # Image processing
+                if slice_params is not None:
+                    result = ocr.ocr(file_path, cls=True, slice=slice_params)
+                else:
+                    result = ocr.ocr(file_path, cls=True) # result is [[[points, (text, confidence)], ...]] for single image
+
+                lines = []
+                # Standardize handling: PaddleOCR often returns a list containing one item for single images.
+                # result = [page_result] where page_result = [[line1_info], [line2_info], ...]
+                if result and isinstance(result, list):
+                     # Heuristic: Treat 'result' as the list of pages directly.
+                     # This handles both single image wrapped in list and multi-page PDFs consistently.
+                     page_list = result
+
+                     for page in page_list:
+                        if page and isinstance(page, list):
+                            for line_info in page: # line_info is [points, (text, confidence)]
+                                try:
+                                    # Check structure: [points, (text, confidence)]
+                                    if isinstance(line_info, (list, tuple)) and len(line_info) == 2 and \
+                                       isinstance(line_info[1], (list, tuple)) and len(line_info[1]) >= 1:
+                                        txt = line_info[1][0]
+                                        if isinstance(txt, str):
+                                            lines.append(txt)
+                                        else:
+                                            # Handle potential nested lists in text: join them? Or log?
+                                            if isinstance(txt, list):
+                                                processed_txt = " ".join(map(str, txt))
+                                                logger.warning(f"Extracted text is a list in Image: {txt}. Joined as: '{processed_txt}'.")
+                                                lines.append(processed_txt) # Attempt to join if it's a list of strings/convertibles
+                                            else:
+                                                logger.warning(f"Extracted text is not a string in Image: {txt} (type: {type(txt)}). Skipping.")
+                                    else:
+                                        logger.warning(f"Unexpected line_info structure in Image: {line_info}. Skipping.")
+                                except Exception as e:
+                                    logger.warning(f"Error processing line_info in Image: {line_info}. Error: {e}")
+                return "\n".join(lines)
+        except Exception:
+            traceback.print_exc()
+            return ""
+    
+    @staticmethod
+    def paddlex_table_extract_markdown(image_path):
+        """
+        使用 PaddleX 表格识别pipeline，抽取表格并转换为markdown格式
+
+        Args:
+            image_path: 图片路径
+        Returns:
+            markdown格式的表格字符串
+        """
+        if paddlex_module is None:
+            print("paddlex not installed")
+            return ""
+
+        try:
+            # 创建 pipeline
+            pipeline = paddlex_module.create_pipeline(pipeline='table_recognition')
+            # 预测
+            outputs = pipeline.predict([image_path])
+            if not outputs:
+                return ""
+
+            md_results = []
+            for res in outputs:
+                # 获取HTML表格
+                html = None
+                try:
+                    html = res.to_html() if hasattr(res, "to_html") else None
+                except Exception:
+                    html = None
+
+                # 如果没有to_html方法，尝试res.print()内容中提取，或跳过
+                if html is None:
+                    try:
+                        from io import StringIO
+                        import sys
+                        buffer = StringIO()
+                        sys_stdout = sys.stdout
+                        sys.stdout = buffer
+                        res.print()
+                        sys.stdout = sys_stdout
+                        html = buffer.getvalue()
+                    except Exception:
+                        html = ""
+
+                # 转markdown
+                md = ImageLoader.html_table_to_markdown(html)
+                md_results.append(md)
+
+            return "\n\n".join(md_results)
+        except Exception:
+            traceback.print_exc()
+            return ""
+    
+    @staticmethod
+    def html_table_to_markdown(html):
+        """
+        简单将HTML table转换为markdown table
+        """
+        try:
+            from bs4 import BeautifulSoup
+        except ImportError:
+            print("BeautifulSoup4 not installed, cannot convert HTML to markdown")
+            return ""
+
+        try:
+            soup = BeautifulSoup(html, "html.parser")
+            table = soup.find("table")
+            if table is None:
+                return ""
+
+            rows = []
+            for tr in table.find_all("tr"):
+                cells = tr.find_all(["td", "th"])
+                row = [cell.get_text(strip=True) for cell in cells]
+                rows.append(row)
+
+            if not rows:
+                return ""
+
+            # 生成markdown
+            md_lines = []
+            header = rows[0]
+            md_lines.append("| " + " | ".join(header) + " |")
+            md_lines.append("|" + "|".join(["---"] * len(header)) + "|")
+
+            for row in rows[1:]:
+                md_lines.append("| " + " | ".join(row) + " |")
+
+            return "\n".join(md_lines)
+        except Exception:
+            traceback.print_exc()
+            return ""
+    
+    @staticmethod
+    def format_table_in_content(content: str, llm=None) -> str:
+        """Format table content from OCR results into markdown format.
+        
+        Args:
+            content: The OCR text content that may contain tables
+            llm: The language model to use for formatting
+            
+        Returns:
+            Formatted content with tables converted to markdown
+        """    
+            
+        @byzerllm.prompt()
+        def _format_table(content: str)->str:
+            '''
+            # 表格格式化任务
+            
+            你是一个专业的OCR后处理专家，擅长将OCR识别出的表格数据转换为规范的Markdown表格。
+            
+            ## 输入内容分析
+            
+            OCR识别的表格通常会有以下特点：
+            1. 每个单元格可能被识别为单独的一行
+            2. 表格的行列结构可能不明显
+            3. 可能包含非表格的文本内容
+            4. 可能存在多个表格
+            
+            ## 你的任务
+            
+            1. 识别内容中的表格数据
+            2. 将表格数据转换为标准Markdown格式
+            3. 保留非表格的文本内容
+            4. 使用replace_in_file工具格式输出结果
+            
+            ## 输出格式
+            
+            必须使用以下格式输出结果：
+            
+            ```
+            <replace_in_file>
+            <path>content</path>
+            <diff>
+            <<<<<<< SEARCH
+            [原始表格文本，精确匹配]
+            =======
+            [转换后的Markdown表格]
+            >>>>>>> REPLACE
+            </diff>
+            </replace_in_file>
+            ```
+            
+            ## 示例
+            
+            原始OCR文本：
+            ```
+            下面是库存情况：
+            产品名称 
+            价格 
+            库存
+            苹果手机 
+            8999 352
+            华为平板 
+            4599 
+            128
+            小米电视 
+            3299 
+            89
+            可以看到在，整体库存和价格是健康的。
+            ```
+            
+            转换后的输出：
+            ```
+            <replace_in_file>
+            <path>content</path>
+            <diff>
+            <<<<<<< SEARCH
+            产品名称 
+            价格 
+            库存
+            苹果手机 
+            8999 352
+            华为平板 
+            4599 
+            128
+            小米电视 
+            3299 
+            89
+            =======
+            | 产品名称 | 价格 | 库存 |
+            |---------|------|------|
+            | 苹果手机 | 8999 | 352 |
+            | 华为平板 | 4599 | 128 |
+            | 小米电视 | 3299 | 89  |
+            >>>>>>> REPLACE
+            </diff>
+            </replace_in_file>
+            ```
+            
+            ## 处理规则
+            
+            1. 表格识别：
+               - 分析行列结构，识别表头和数据行
+               - 如果一行中有多个值，可能是一行表格数据
+               - 连续的短行可能是表格的单元格
+            
+            2. Markdown格式：
+               - 表头行使用`|`分隔各列
+               - 在表头下方添加分隔行`|---|---|---|`
+               - 对齐各列数据
+               - 保持原始数据的完整性
+            
+            3. 多表格处理：
+               - 为每个表格创建单独的replace_in_file块
+               - 保持表格在原文中的相对位置
+            
+            4. 非表格内容：
+               - 保留原始格式
+               - 不要修改非表格文本
+            
+            ## 处理以下内容
+            
+            {{content}}
+            '''
+        
+        # Run the prompt with the provided content
+        tool_response = _format_table.with_llm(llm).run(content)    
+        
+        # Parse the tool response to extract replace_in_file tool calls
+        def extract_replace_in_file_tools(response):
+            tools = []
+            # Pattern to match replace_in_file tool blocks
+            pattern = r'<replace_in_file>\s*<path>(.*?)</path>\s*<diff>(.*?)</diff>\s*</replace_in_file>'
+            matches = re.finditer(pattern, response, re.DOTALL)
+            
+            for match in matches:
+                path = match.group(1).strip()
+                diff = match.group(2).strip()
+                tools.append(ReplaceInFileTool(path=path, diff=diff))
+            
+            return tools
+        
+        # Extract tools from the response
+        tools = extract_replace_in_file_tools(tool_response)
+        
+        # Process each tool to apply the replacements
+        formatted_content = content
+        for tool in tools:
+            # For in-memory content replacement (not actual file modification)
+            if tool.path == "content":
+                # Parse the diff to get search/replace blocks
+                blocks = ImageLoader.parse_diff(tool.diff)
+                # Apply each replacement to the content
+                for search_block, replace_block in blocks:
+                    formatted_content = formatted_content.replace(search_block, replace_block)
+        
+        return formatted_content
+    
+    @staticmethod
+    def extract_text_from_image(
+        image_path: str,
+        llm,
+        engine: str = "vl",
+        product_mode: str = "lite",
+        paddle_kwargs: dict = None
+    ) -> str:
+        """
+        识别图片或PDF中的所有文本内容，包括表格（以markdown table格式）
+
+        Args:
+            image_path: 图片或PDF路径
+            llm: LLM对象或字符串（模型名）
+            engine: 选择识别引擎
+                - "vl": 视觉语言模型
+                - "paddle": PaddleOCR
+                - "paddle_table": PaddleX表格识别
+            product_mode: get_single_llm的参数
+            paddle_kwargs: dict，传递给PaddleOCR的参数
+        Returns:
+            markdown内容字符串
+        """
+        if isinstance(llm, str):
+            llm = get_single_llm(llm, product_mode=product_mode)
+
+        markdown_content = ""
+
+        if engine == "vl":
+            try:
+                vl_model = llm.get_sub_client("vl_model") if llm.get_sub_client("vl_model") else llm
+
+                @byzerllm.prompt()
+                def analyze_image(image_path):
+                    """
+                    {{ image }}
+                    你是一名图像理解专家，请识别这张图片中的所有内容，优先识别文字和表格。
+                    对于普通文字，输出为段落文本。
+                    对于表格截图，转换成markdown table格式输出。
+                    请根据内容顺序，整合成一份markdown文档。
+                    只返回markdown内容，不要添加额外解释。
+                    """
+                    image = byzerllm.Image.load_image_from_path(image_path)
+                    return {"image": image}
+
+                result = analyze_image.with_llm(vl_model).run(image_path)
+                md_blocks = code_utils.extract_code(result, language="markdown")
+                if md_blocks:
+                    markdown_content = md_blocks[-1][1]
+                else:
+                    markdown_content = result.strip()
+                if not markdown_content:
+                    raise ValueError("Empty markdown from vl_model")
+                return markdown_content
+
+            except Exception:
+                traceback.print_exc()
+                return ""
+
+        elif engine == "paddle":
+            if paddle_kwargs is None:
+                paddle_kwargs = {}
+
+            markdown_content = ImageLoader.paddleocr_extract_text(image_path, **paddle_kwargs)
+            return markdown_content
+
+        elif engine == "paddle_table":
+            markdown_content = ImageLoader.paddlex_table_extract_markdown(image_path)
+            return markdown_content
+
+        else:
+            print(f"Unknown engine type: {engine}. Supported engines are 'vl', 'paddle', and 'paddle_table'.")
+            return ""
+    
+    @staticmethod
+    def image_to_markdown(
+        image_path: str,
+        llm,
+        engine: str = "vl",
+        product_mode: str = "lite",
+        paddle_kwargs: dict = None
+    ) -> str:
+        """
+        识别图片或PDF内容，生成markdown文件
+
+        Args:
+            image_path: 文件路径
+            llm: LLM对象或字符串
+            engine: 'vl'、'paddle'或'paddle_table'
+            product_mode: LLM参数
+            paddle_kwargs: dict，传递给PaddleOCR参数
+        Returns:
+            markdown内容字符串
+        """
+        md_content = ImageLoader.extract_text_from_image(
+            image_path,
+            llm,
+            engine=engine,
+            product_mode=product_mode,
+            paddle_kwargs=paddle_kwargs
+        )
+
+        md_path = os.path.splitext(image_path)[0] + ".md"
+        try:
+            with open(md_path, "w", encoding="utf-8") as f:
+                f.write(md_content)
+        except Exception:
+            traceback.print_exc()
+
+        return md_content
+

autocoder/version.py

@@ -1 +1 @@
-__version__ = "0.1.347"
+__version__ = "0.1.348"