jarvis-ai-assistant 0.1.177__py3-none-any.whl → 0.1.179__py3-none-any.whl

jarvis_ai_assistant-0.1.179.dist-info/RECORD

@@ -0,0 +1,98 @@
+jarvis/__init__.py,sha256=AHtR6TjwF1QgHEj70zUFmweOTTTW-KN1Gtvw7DOSA9k,74
+jarvis/jarvis_agent/__init__.py,sha256=9vyME5JbA4koVoqJ_zv5N9eNdvu6iBkB4o4a1CmkVgA,30054
+jarvis/jarvis_agent/builtin_input_handler.py,sha256=f4DaEHPakXcAbgykFP-tiOQP6fh_yGFlZx_h91_j2tQ,1529
+jarvis/jarvis_agent/jarvis.py,sha256=UkNMVUlSNKV6y3v12eAhqc_gIDB6Obxrwk5f7-sQeiQ,6137
+jarvis/jarvis_agent/main.py,sha256=GkjMTIbsd56nkVuRwD_tU_PZWyzixZZhMjVOCd0SzOA,2669
+jarvis/jarvis_agent/output_handler.py,sha256=7qori-RGrQmdiFepoEe3oPPKJIvRt90l_JDmvCoa4zA,1219
+jarvis/jarvis_agent/shell_input_handler.py,sha256=pi3AtPKrkKc6K9e99S1djKXQ_XrxtP6FrSWebQmRT6E,1261
+jarvis/jarvis_code_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jarvis/jarvis_code_agent/code_agent.py,sha256=jEJhPk4Eg-2hsDYeIa2NOfk2YnuvhuPrLCtVHm5hTPg,17879
+jarvis/jarvis_code_agent/lint.py,sha256=TZlhNbeaoLzO9DzExjN5GAjrt66owd8lyQV56LTfkrs,4370
+jarvis/jarvis_code_analysis/code_review.py,sha256=SEK5NOGDWgMNX3zmRMWrIOtq3Xr8cKt_asG51U8h6SA,30219
+jarvis/jarvis_code_analysis/checklists/__init__.py,sha256=cKQ_FOGy5TQgM-YkRCqORo-mUOZaPAJ9VDmZoFX58us,78
+jarvis/jarvis_code_analysis/checklists/c_cpp.py,sha256=SXPpYCNeCtU1PpKdKPiYDuOybfY9vaL0ejDn4imxDwA,1317
+jarvis/jarvis_code_analysis/checklists/csharp.py,sha256=vS-cu6RCGg5SyK9MJ3RE381gt3xYl-yea3Bj2UQEcwQ,2420
+jarvis/jarvis_code_analysis/checklists/data_format.py,sha256=0ljCQPNrhFq3Qzl7WQZy-5jRE5OQG-6fjK-ZMQhP7AE,3005
+jarvis/jarvis_code_analysis/checklists/devops.py,sha256=caupq-mZyXOfK5cSkpgcxdivqK89_2lWuDbXDuVndI8,3542
+jarvis/jarvis_code_analysis/checklists/docs.py,sha256=lOr69-3-wobyfx82NLYZmZKHfoAov_rF4D6YMjsmOkY,3341
+jarvis/jarvis_code_analysis/checklists/go.py,sha256=8Q16X08aj9pyLyi5c85xB2CcZI-eLlxw7TJDTij5BBY,1388
+jarvis/jarvis_code_analysis/checklists/infrastructure.py,sha256=KgyuZHJfKCbon1qxqoTDBnUbDrY7dfFnfPkTlH4BrlI,3765
+jarvis/jarvis_code_analysis/checklists/java.py,sha256=RReiw64i-o5yLIhZdFkkWzMl9yE4_SnQr7CwWz5dTas,2085
+jarvis/jarvis_code_analysis/checklists/javascript.py,sha256=i1srwYq0H-d9Ql98UpJSvceHe5jTJX3CFO_sgmw7_AU,2340
+jarvis/jarvis_code_analysis/checklists/kotlin.py,sha256=AgVEDHdDC4kD-XYjT5V3LNjRpcWeVCoPThVg1juD1Ns,4436
+jarvis/jarvis_code_analysis/checklists/loader.py,sha256=N9tSH4R_HYS5280CQoEcGJSGFq0WbAbYYQNQsKQTCDI,2102
+jarvis/jarvis_code_analysis/checklists/php.py,sha256=_EvpnWwHOGM3wAc9aXJrtwy3LQvYNR-oxPhtv71qZj4,2481
+jarvis/jarvis_code_analysis/checklists/python.py,sha256=rQ2jpDG0CPzeWiBc2Q6kJA0IBpyheL4-gtMwe6whgOM,1452
+jarvis/jarvis_code_analysis/checklists/ruby.py,sha256=JbU1eHafIhlV0qWtYxEltz6AaFzUSU_F3KuqylnMcgc,4274
+jarvis/jarvis_code_analysis/checklists/rust.py,sha256=oe_1wPaBgMScQTn-697aghWVsIvNO2v8E6m_lcP8_iU,1646
+jarvis/jarvis_code_analysis/checklists/shell.py,sha256=IXQkWHwA-4GUQz3WUs7l6hEy7Vrjd92egUYXGfu2FKQ,2619
+jarvis/jarvis_code_analysis/checklists/sql.py,sha256=ecKKT6wJAibn8R0NxGZDNlm4teYXvF3CAJvVk8mmX7w,2355
+jarvis/jarvis_code_analysis/checklists/swift.py,sha256=YcsYFxAitHqOtBZjG-RV9-KNM7X5lIcl6zlEI9XfmfM,2566
+jarvis/jarvis_code_analysis/checklists/web.py,sha256=-Pnj1FQTsGVZUQK7-4ptDsGd7a22Cs0585jRAPT2SdQ,3943
+jarvis/jarvis_data/huggingface.tar.gz,sha256=dWKnc_tvyx-I_ZkXo91O0b38KxDmLW1ZbmJ3E6fCl_k,1120205
+jarvis/jarvis_dev/main.py,sha256=RJ7Z7_qX6ENKrlgjlz7tMfpBTh9g22mGqcasWCv5ygw,42710
+jarvis/jarvis_event/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jarvis/jarvis_git_details/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jarvis/jarvis_git_details/main.py,sha256=MfR7feVVQ7Eo9eZk-wO2bFypnA6uRrYUQn6iTeoF0Os,9007
+jarvis/jarvis_git_squash/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jarvis/jarvis_git_squash/main.py,sha256=q8-r0TtVOaCqY_uYwnWAY76k8YCDd5se_feB6ZWKo9M,2278
+jarvis/jarvis_git_utils/git_commiter.py,sha256=GuUHL0crFZ1QE8MKYr4zAdRd0Y3YnW-C_k_PbokuiX4,12964
+jarvis/jarvis_mcp/__init__.py,sha256=NF_vqRxaNyz8ColcpRh0bOkinV90YLAKHEN--jkP-B8,2114
+jarvis/jarvis_mcp/sse_mcp_client.py,sha256=QNA7HqFvLbvhNaFp3ZsXzs2Rm6_gHUMcpd4t4qAzymY,23485
+jarvis/jarvis_mcp/stdio_mcp_client.py,sha256=IEkas4ojP5J0TdVaUglvlEp61RyezBtuejv4lN3n1I4,11831
+jarvis/jarvis_mcp/streamable_mcp_client.py,sha256=t2uKiIbKlmMsaiN9xHCZC3WTdl7mmoBuIZ_ph-QshzE,15084
+jarvis/jarvis_methodology/main.py,sha256=HhEArlKI5PCpGnBCwVrXMuDn2z84LgpgK7-aGSQH0v4,11880
+jarvis/jarvis_multi_agent/__init__.py,sha256=Xab5sFltJmX_9MoXqanmZs6FqKfUb2v_pG29Vk8ZXaw,4311
+jarvis/jarvis_multi_agent/main.py,sha256=KeGv8sdpSgTjW6VE4-tQ8BWDC_a0aE_4R3OqzPBd5N4,1646
+jarvis/jarvis_platform/__init__.py,sha256=0YnsUoM4JkIBOtImFdjfuDbrqQZT3dEaAwSJ62DrpCc,104
+jarvis/jarvis_platform/base.py,sha256=EyZOl98rpYUX1yISDFvj1ztrYfWIT2ozenwUIZ7TyyI,6972
+jarvis/jarvis_platform/human.py,sha256=xwaTZ1zdrAYZZFXxkbHvUdECwCGsic0kgAFUncUr45g,2567
+jarvis/jarvis_platform/kimi.py,sha256=kkYWmJoOIT-7tp5_v2LaQGUFsEuCftfma3Ztn1P4CKo,13111
+jarvis/jarvis_platform/openai.py,sha256=k1h_FLCd-nqvBFUBDJC_eNjSMohh5huWRJcMe1RLrHQ,5588
+jarvis/jarvis_platform/registry.py,sha256=CxAELjDrc-KKPPKdP71E_qaFisfQztvwc_tdf3WpOt8,7863
+jarvis/jarvis_platform/yuanbao.py,sha256=giuHCDSAhVlaUykoN5D6oZ0DtYu81zMpVHnMepFkt_I,21672
+jarvis/jarvis_platform_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jarvis/jarvis_platform_manager/main.py,sha256=OXWj18SqiV0Gl75YT6D9wspCCB4Nes04EY-ShI9kbpU,25677
+jarvis/jarvis_smart_shell/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jarvis/jarvis_smart_shell/main.py,sha256=CaqAXPk1XW3ruQf2AJjdeZBhqD2xh09KvG3TM0o6-aw,5209
+jarvis/jarvis_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jarvis/jarvis_tools/ask_codebase.py,sha256=FYlrbiN5PjxS4hGvCjN8idF6YnESDH6NLBgQguSnG48,10145
+jarvis/jarvis_tools/ask_user.py,sha256=qwxwJIL698rEWdi1txxlPgIr4UFuihfe--NqBEYhIQQ,2168
+jarvis/jarvis_tools/base.py,sha256=OdlvzUjYQBmZIMcAeBxAqIQo2urh126OerArK-wOPzU,1191
+jarvis/jarvis_tools/chdir.py,sha256=DNKVFrWqu6t_sZ2ipv99s6802QR4cSGlqKlmaI--arE,2707
+jarvis/jarvis_tools/code_plan.py,sha256=pfGOX3fH4-Gg2ECuJkjGpnRtHXEhlVWLV8ZVJAEKmwk,7755
+jarvis/jarvis_tools/create_code_agent.py,sha256=-nHfo5O5pDIG5IX3w1ClQafGvGcdI2_w75-KGrD-gUQ,3458
+jarvis/jarvis_tools/create_sub_agent.py,sha256=lyFrrg4V0yXULmU3vldwGp_euZjwZzJcRU6mJ20zejY,3023
+jarvis/jarvis_tools/edit_file.py,sha256=50OZSdR6bJM7eMh5KCI2pOI5WV7ofUeMh7-ABCKulXY,16249
+jarvis/jarvis_tools/execute_script.py,sha256=yQpc90t678UGbkr-ycGeB7jwqmY7GWWbtFtmcAI0-d4,5739
+jarvis/jarvis_tools/file_analyzer.py,sha256=7ILHkUFm8pPZn1y_s4uT0kaWHP-EmlHnpkovDdA1yRE,4872
+jarvis/jarvis_tools/file_operation.py,sha256=RcOKuMFUv01tvKoiOfu1ERCjvDVfJBvkT4oBpq-8vNQ,9036
+jarvis/jarvis_tools/find_methodology.py,sha256=P1IJU2x9yBoOK-X5TTvzC9Lfa1i6ES3eZn5kjEpWGdA,2440
+jarvis/jarvis_tools/generate_new_tool.py,sha256=k1Vt88kI1bYi1OwxvJqFKr3Ewwwv7lOegYNmZ-1F7x0,10283
+jarvis/jarvis_tools/methodology.py,sha256=m7cQmVhhQpUUl_uYTVvcW0JBovQLx5pWTXh_8K77HsU,5237
+jarvis/jarvis_tools/read_code.py,sha256=j4niDMOAKW_3rVxmOo3wxYBQ2T8vkxqEiTkBt28gUT8,5898
+jarvis/jarvis_tools/read_webpage.py,sha256=PFAYuKjay9j6phWzyuZ99ZfNaHJljmRWAgS0bsvbcvE,2219
+jarvis/jarvis_tools/registry.py,sha256=emAX3DjdWcluthEVSHKs1W5ieKtvaKr2uM2DIlEErHQ,24417
+jarvis/jarvis_tools/rewrite_file.py,sha256=3V2l7kG5DG9iRimBce-1qCRuJPL0QM32SBTzOl2zCqM,7004
+jarvis/jarvis_tools/search_web.py,sha256=rzxrCOTEo-MmLQrKI4k-AbfidUfJUeCPK4f5ZJy48G8,952
+jarvis/jarvis_tools/virtual_tty.py,sha256=8E_n-eC-RRPTqYx6BI5Q2RnorY8dbhKFBfAjIiRQROA,16397
+jarvis/jarvis_tools/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jarvis/jarvis_tools/cli/main.py,sha256=3UuU9tk5cQAS0rfNPXgdtnAd5uDB7v0Exo0_I9sJHRE,6355
+jarvis/jarvis_utils/__init__.py,sha256=x5lbQRH1uOulmWr1IEqNMLXNmDHbqQQot7d1uhKFg4M,851
+jarvis/jarvis_utils/builtin_replace_map.py,sha256=Cx0HFvMmDkkYR9htSS-PCCd8D0Np7yRm2g-C1J2-u08,4314
+jarvis/jarvis_utils/config.py,sha256=5Fouj2RgzsktxptociwJcaXYCcoVctJS3x5CQWRab5I,5684
+jarvis/jarvis_utils/embedding.py,sha256=J8YAqIEj16TJIPEG24uvUlPHeN-5zq0JW_hbNLizQug,3832
+jarvis/jarvis_utils/file_processors.py,sha256=G5kQI7vCGIDnjgAB5J1dYIR102u6WUv3IhcWFfDh_gs,2977
+jarvis/jarvis_utils/git_utils.py,sha256=XJ42U3eVNI5QV7onGbTYlJY-XWdLFSLnQ5QMaonQDSI,12312
+jarvis/jarvis_utils/globals.py,sha256=6JWtB1XoD-wEFiMzZNA790ixlZ_OsJEYUM_B8EwkOE8,2277
+jarvis/jarvis_utils/input.py,sha256=FkLW7MXL8awQUghFLQnW1r5F1wV8K3EZeVPwHFRHJTo,7458
+jarvis/jarvis_utils/methodology.py,sha256=A8pE8ZqNHvGKaDO4TFtg7Oz-hAXPBcQfhmSPWMr6vdg,8629
+jarvis/jarvis_utils/output.py,sha256=QboL42GtG_dnvd1O64sl8o72mEBhXNRADPXQMXgDE7Q,9661
+jarvis/jarvis_utils/tag.py,sha256=YJHmuedLb7_AiqvKQetHr4R1FxyzIh7HN0RRkWMmYbU,429
+jarvis/jarvis_utils/utils.py,sha256=XV-9T8yqThuo0aXkA7BOfBVt1YMUwkyIKeuvK2oDujM,8471
+jarvis_ai_assistant-0.1.179.dist-info/licenses/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
+jarvis_ai_assistant-0.1.179.dist-info/METADATA,sha256=wospENCawSz6yu0ulALwAbZcY5VtG03oV2N-nOI08PM,15200
+jarvis_ai_assistant-0.1.179.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+jarvis_ai_assistant-0.1.179.dist-info/entry_points.txt,sha256=rjj61tZ7ahLi1R-JkJmX-IzIPPHD8mnwDZap1CnMe2s,973
+jarvis_ai_assistant-0.1.179.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
+jarvis_ai_assistant-0.1.179.dist-info/RECORD,,

jarvis/jarvis_lsp/base.py

@@ -1,66 +0,0 @@
-# -*- coding: utf-8 -*-
-from abc import ABC, abstractmethod
-from typing import List, Dict, Any, Union
-
-class BaseLSP(ABC):
-    """Base class for Language Server Protocol integration.
-
-    Core LSP features needed for LLM-based code editing:
-    1. Code navigation and analysis
-    2. Code modification validation
-    3. Diagnostic information
-    4. Symbol analysis
-    """
-
-    language: Union[str, List[str]] = ""  # Language identifier, should be overridden by subclasses
-
-    @abstractmethod
-    def initialize(self, workspace_path: str) -> bool:
-        """Initialize LSP server for the workspace.
-
-        Args:
-            workspace_path: Root path of the workspace
-
-        Returns:
-            bool: True if initialization successful
-        """
-        return False
-
-
-    @abstractmethod
-    def get_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:
-        """Get diagnostics (errors, warnings) for file.
-
-        Args:
-            file_path: Path to the file
-
-        Returns:
-            List of diagnostic items:
-            [
-                {
-                    "range": {
-                        "start": {"line": int, "character": int},
-                        "end": {"line": int, "character": int}
-                    },
-                    "severity": 1 | 2 | 3 | 4,  # Error=1, Warning=2, Info=3, Hint=4
-                    "code": str,                # Error code if any
-                    "source": str,             # Source of diagnostic (e.g. "pylint")
-                    "message": str,            # Diagnostic message
-                    "relatedInformation": [    # Optional related info
-                        {
-                            "location": {
-                                "uri": str,
-                                "range": {...}
-                            },
-                            "message": str
-                        }
-                    ]
-                }
-            ]
-        """
-        return []
-
-
-    def shutdown(self):
-        """Shutdown LSP server cleanly."""
-        pass

jarvis/jarvis_lsp/cpp.py

@@ -1,99 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-import shutil
-import subprocess
-from typing import List, Dict, Optional, Any
-import json
-from jarvis.jarvis_lsp.base import BaseLSP
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-
-class CPPLSP(BaseLSP):
-    """C++ LSP implementation using clangd."""
-
-    language = ["cpp", "c"]
-
-    @staticmethod
-    def check() -> bool:
-        """Check if clangd is installed."""
-        return shutil.which("clangd") is not None
-
-    def __init__(self):
-        self.workspace_path = ""
-        self.clangd_process = None
-        self.request_id = 0
-
-    def initialize(self, workspace_path: str) -> bool:
-        try:
-            self.workspace_path = workspace_path
-            # Start clangd process
-            self.clangd_process = subprocess.Popen(
-                ["clangd", "--background-index"],
-                stdin=subprocess.PIPE,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE
-            )
-
-            # Send initialize request
-            self._send_request("initialize", {
-                "processId": os.getpid(),
-                "rootUri": f"file://{workspace_path}",
-                "capabilities": {}
-            })
-
-            return True
-        except Exception as e:
-            PrettyOutput.print(f"C++ LSP 初始化失败: {str(e)}", OutputType.ERROR)
-            return False
-
-    def _send_request(self, method: str, params: Dict) -> Optional[Dict]:
-        """Send JSON-RPC request to clangd."""
-        if not self.clangd_process:
-            return None
-
-        try:
-            self.request_id += 1
-            request = {
-                "jsonrpc": "2.0",
-                "id": self.request_id,
-                "method": method,
-                "params": params
-            }
-
-            self.clangd_process.stdin.write(json.dumps(request).encode() + b"\n") # type: ignore
-            self.clangd_process.stdin.flush() # type: ignore
-
-            response = json.loads(self.clangd_process.stdout.readline().decode()) # type: ignore
-            return response.get("result")
-        except Exception:
-            return None
-
-
-    def get_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:
-        # Send didOpen notification to trigger diagnostics
-        self._send_request("textDocument/didOpen", {
-            "textDocument": {
-                "uri": f"file://{file_path}",
-                "languageId": "cpp",
-                "version": 1,
-                "text": open(file_path).read()
-            }
-        })
-
-        # Wait for diagnostic notification
-        try:
-            response = json.loads(self.clangd_process.stdout.readline().decode()) # type: ignore
-            if response.get("method") == "textDocument/publishDiagnostics":
-                return response.get("params", {}).get("diagnostics", [])
-        except Exception:
-            pass
-        return []
-
-
-    def shutdown(self):
-        if self.clangd_process:
-            try:
-                self._send_request("shutdown", {})
-                self.clangd_process.terminate()
-                self.clangd_process = None
-            except Exception:
-                pass

jarvis/jarvis_lsp/go.py

@@ -1,104 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-import shutil
-import subprocess
-from typing import List, Dict, Optional, Any
-import json
-from jarvis.jarvis_lsp.base import BaseLSP
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-
-class GoLSP(BaseLSP):
-    """Go LSP implementation using gopls."""
-
-    language = "go"
-
-    @staticmethod
-    def check() -> bool:
-        """Check if gopls is installed."""
-        return shutil.which("gopls") is not None
-
-    def __init__(self):
-        self.workspace_path = ""
-        self.gopls_process = None
-        self.request_id = 0
-
-    def initialize(self, workspace_path: str) -> bool:
-        try:
-            self.workspace_path = workspace_path
-            # Start gopls process
-            self.gopls_process = subprocess.Popen(
-                ["gopls", "serve"],
-                stdin=subprocess.PIPE,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE
-            )
-
-            # Send initialize request
-            self._send_request("initialize", {
-                "processId": os.getpid(),
-                "rootUri": f"file://{workspace_path}",
-                "capabilities": {
-                    "textDocument": {
-                        "hover": {"contentFormat": ["markdown", "plaintext"]},
-                        "completion": {"completionItem": {"snippetSupport": True}},
-                        "signatureHelp": {"signatureInformation": {"documentationFormat": ["markdown", "plaintext"]}},
-                    }
-                }
-            })
-
-            return True
-        except Exception as e:
-            PrettyOutput.print(f"Go LSP 初始化失败: {str(e)}", OutputType.ERROR)
-            return False
-
-    def _send_request(self, method: str, params: Dict) -> Optional[Dict]:
-        """Send JSON-RPC request to gopls."""
-        if not self.gopls_process:
-            return None
-
-        try:
-            self.request_id += 1
-            request = {
-                "jsonrpc": "2.0",
-                "id": self.request_id,
-                "method": method,
-                "params": params
-            }
-
-            self.gopls_process.stdin.write(json.dumps(request).encode() + b"\n") # type: ignore
-            self.gopls_process.stdin.flush() # type: ignore
-
-            response = json.loads(self.gopls_process.stdout.readline().decode()) # type: ignore
-            return response.get("result")
-        except Exception:
-            return None
-
-    def get_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:
-        # Send didOpen notification to trigger diagnostics
-        self._send_request("textDocument/didOpen", {
-            "textDocument": {
-                "uri": f"file://{file_path}",
-                "languageId": "go",
-                "version": 1,
-                "text": open(file_path).read()
-            }
-        })
-
-        # Wait for diagnostic notification
-        try:
-            response = json.loads(self.gopls_process.stdout.readline().decode()) # type: ignore
-            if response.get("method") == "textDocument/publishDiagnostics":
-                return response.get("params", {}).get("diagnostics", [])
-        except Exception:
-            pass
-        return []
-
-
-    def shutdown(self):
-        if self.gopls_process:
-            try:
-                self._send_request("shutdown", {})
-                self.gopls_process.terminate()
-                self.gopls_process = None
-            except Exception:
-                pass

jarvis/jarvis_lsp/python.py

@@ -1,58 +0,0 @@
-# -*- coding: utf-8 -*-
-from typing import List, Dict, Any
-import jedi
-from jarvis.jarvis_lsp.base import BaseLSP
-
-class PythonLSP(BaseLSP):
-    """Python LSP implementation using jedi."""
-
-    language = "python"
-
-    def __init__(self):
-        self.workspace_path = ""
-        self.script_cache = {}
-
-    def initialize(self, workspace_path: str) -> bool:
-        self.workspace_path = workspace_path
-        return True
-
-    def _get_script(self, file_path: str):
-        if file_path not in self.script_cache:
-            try:
-                with open(file_path, 'r', errors="ignore") as f:
-                    content = f.read()
-                self.script_cache[file_path] = jedi.Script(code=content, path=file_path)
-            except Exception:
-                return None
-        return self.script_cache[file_path]
-
-
-    def _location_to_dict(self, location) -> Dict[str, Any]:
-        return {
-            "uri": location.module_path,
-            "range": {
-                "start": {"line": location.line - 1, "character": location.column},
-                "end": {"line": location.line - 1, "character": location.column + len(location.name)}
-            }
-        }
-
-    def get_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:
-        script = self._get_script(file_path)
-        if not script:
-            return []
-        try:
-            errors = script.get_syntax_errors()
-            return [{
-                "range": {
-                    "start": {"line": e.line - 1, "character": e.column},
-                    "end": {"line": e.line - 1, "character": e.column + 1}
-                },
-                "severity": 1,  # Error
-                "source": "jedi",
-                "message": str(e)
-            } for e in errors]
-        except Exception:
-            return []
-
-    def shutdown(self):
-        self.script_cache.clear()

jarvis/jarvis_lsp/registry.py

@@ -1,169 +0,0 @@
-# -*- coding: utf-8 -*-
-import importlib
-import inspect
-import os
-import re
-import sys
-from typing import Dict, Type, Optional, List
-from jarvis.jarvis_lsp.base import BaseLSP
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-from jarvis.jarvis_utils.config import get_data_dir
-
-REQUIRED_METHODS = [
-    ('initialize', ['workspace_path']),
-    ('get_diagnostics', ['file_path']),
-    ('shutdown', [])
-]
-
-class LSPRegistry:
-    """LSP server registry"""
-
-    global_lsp_registry = None
-
-    @staticmethod
-    def get_lsp_dir() -> str:
-        """Get LSP implementation directory."""
-        user_lsp_dir = os.path.join(get_data_dir(), "lsp")
-        if not os.path.exists(user_lsp_dir):
-            try:
-                os.makedirs(user_lsp_dir)
-                with open(os.path.join(user_lsp_dir, "__init__.py"), "w", errors="ignore") as f:
-                    pass
-            except Exception as e:
-                PrettyOutput.print(f"创建 LSP 目录失败: {str(e)}", OutputType.ERROR)
-                return ""
-        return user_lsp_dir
-
-    @staticmethod
-    def check_lsp_implementation(lsp_class: Type[BaseLSP]) -> bool:
-        """Check if the LSP class implements all necessary methods."""
-        missing_methods = []
-
-        for method_name, params in REQUIRED_METHODS:
-            if not hasattr(lsp_class, method_name):
-                missing_methods.append(method_name)
-                continue
-
-            method = getattr(lsp_class, method_name)
-            if not callable(method):
-                missing_methods.append(method_name)
-                continue
-
-            sig = inspect.signature(method)
-            method_params = [p for p in sig.parameters if p != 'self']
-            if len(method_params) != len(params):
-                missing_methods.append(f"{method_name}(parameter mismatch)")
-
-        if missing_methods:
-            PrettyOutput.print(
-                f"LSP {lsp_class.__name__} 缺少必要的方法: {', '.join(missing_methods)}",
-                OutputType.WARNING
-            )
-            return False
-
-        return True
-
-    @staticmethod
-    def load_lsp_from_dir(directory: str) -> Dict[str, Type[BaseLSP]]:
-        """Load LSP implementations from specified directory."""
-        lsp_servers = {}
-
-        if not os.path.exists(directory):
-            PrettyOutput.print(f"LSP 目录不存在: {directory}", OutputType.WARNING)
-            return lsp_servers
-
-        package_name = None
-        if directory == os.path.dirname(__file__):
-            package_name = "jarvis.jarvis_lsp"
-
-        if directory not in sys.path:
-            sys.path.append(directory)
-
-        for filename in os.listdir(directory):
-            if filename.endswith('.py') and not filename.startswith('__'):
-                module_name = filename[:-3]
-                try:
-                    if package_name:
-                        module = importlib.import_module(f"{package_name}.{module_name}")
-                    else:
-                        module = importlib.import_module(module_name)
-
-                    for _, obj in inspect.getmembers(module):
-                        if (inspect.isclass(obj) and
-                            issubclass(obj, BaseLSP) and
-                            obj != BaseLSP and
-                            hasattr(obj, 'language')):
-                            if not LSPRegistry.check_lsp_implementation(obj):
-                                continue
-                            if hasattr(obj, 'check'):
-                                if not obj.check(): # type: ignore
-                                    continue
-                            if isinstance(obj.language, str):
-                                lsp_servers[obj.language] = obj
-                            elif isinstance(obj.language, list):
-                                for lang in obj.language: # type: ignore
-                                    lsp_servers[lang] = obj
-                            break
-                except Exception as e:
-                    PrettyOutput.print(f"加载 LSP {module_name} 失败: {str(e)}", OutputType.ERROR)
-
-        return lsp_servers
-
-    @staticmethod
-    def get_global_lsp_registry():
-        """Get global LSP registry instance."""
-        if LSPRegistry.global_lsp_registry is None:
-            LSPRegistry.global_lsp_registry = LSPRegistry()
-        return LSPRegistry.global_lsp_registry
-
-    def __init__(self):
-        """Initialize LSP registry."""
-        self.lsp_servers: Dict[str, Type[BaseLSP]] = {}
-
-        # Load from user LSP directory
-        lsp_dir = LSPRegistry.get_lsp_dir()
-        if lsp_dir and os.path.exists(lsp_dir):
-            for language, lsp_class in LSPRegistry.load_lsp_from_dir(lsp_dir).items():
-                self.register_lsp(language, lsp_class)
-
-        # Load from built-in LSP directory
-        lsp_dir = os.path.dirname(__file__)
-        if lsp_dir and os.path.exists(lsp_dir):
-            for language, lsp_class in LSPRegistry.load_lsp_from_dir(lsp_dir).items():
-                self.register_lsp(language, lsp_class)
-
-    def register_lsp(self, language: str, lsp_class: Type[BaseLSP]):
-        """Register LSP implementation for a language."""
-        self.lsp_servers[language] = lsp_class
-
-    def create_lsp(self, language: str) -> Optional[BaseLSP]:
-        """Create LSP instance for specified language."""
-        if language not in self.lsp_servers:
-            PrettyOutput.print(f"没有找到 LSP 支持的语言: {language}", OutputType.WARNING)
-            return None
-
-        try:
-            lsp = self.lsp_servers[language]()
-            return lsp
-        except Exception as e:
-            PrettyOutput.print(f"创建 LSP 失败: {str(e)}", OutputType.ERROR)
-            return None
-
-    def get_supported_languages(self) -> List[str]:
-        """Get list of supported languages."""
-        return list(self.lsp_servers.keys())
-
-    @staticmethod
-    def get_text_at_position(file_path: str, line: int, start_character: int) -> str:
-        """Get text at position."""
-        with open(file_path, 'r', errors="ignore") as file:
-            lines = file.readlines()
-            symbol = re.search(r'\b\w+\b', lines[line][start_character:])
-            return symbol.group() if symbol else ""
-
-    @staticmethod
-    def get_line_at_position(file_path: str, line: int) -> str:
-        """Get line at position."""
-        with open(file_path, 'r', errors="ignore") as file:
-            lines = file.readlines()
-            return lines[line]