jarvis-ai-assistant 0.1.123__py3-none-any.whl → 0.1.125__py3-none-any.whl

jarvis/jarvis_code_agent/patch.py

@@ -1,16 +1,21 @@
 import re
-from typing import Dict, Any, List, Tuple
+from typing import Dict, Any, Tuple
 import os
+
 from jarvis.jarvis_agent.output_handler import OutputHandler
+from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_tools.git_commiter import GitCommitTool
-from jarvis.jarvis_tools.read_code import ReadCodeTool
-from jarvis.jarvis_utils import OutputType, PrettyOutput, get_multiline_input, has_uncommitted_changes, user_confirm
-
+from jarvis.jarvis_tools.file_operation import FileOperationTool
+from jarvis.jarvis_tools.execute_shell_script import ShellScriptTool
+from jarvis.jarvis_utils.config import is_confirm_before_apply_patch
+from jarvis.jarvis_utils.git_utils import get_commits_between, get_latest_commit_hash
+from jarvis.jarvis_utils.input import get_multiline_input
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.utils import user_confirm
 
 class PatchOutputHandler(OutputHandler):
     def name(self) -> str:
         return "PATCH"
-
     def handle(self, response: str) -> Tuple[bool, Any]:
         return False, apply_patch(response)
     
@@ -21,144 +26,51 @@ class PatchOutputHandler(OutputHandler):
     
     def prompt(self) -> str:
         return """
-# 🛠️ Code Patch Specification
-When making changes, you MUST:
-1. Explain each modification BEFORE the <PATCH> block using:
-   # [OPERATION] on [FILE]: Lines X-Y
-   # Reason: [CLEAR EXPLANATION]
-2. Maintain original code style and compatibility:
-   - Preserve existing indentation levels
-   - Keep surrounding empty lines
-   - Match variable naming conventions
-   - Maintain API compatibility
-3. Follow the exact patch format below
-4. Use separate <PATCH> blocks for different files
-5. Include ONLY modified lines in content
-
-<PATCH>
-File path [Range]
-Code content
-</PATCH>
-
-Critical Rules:
-- NEVER include unchanged code in patch content
-- ONLY show lines that are being modified/added
-- Maintain original line breaks around modified sections
-- Preserve surrounding comments unless explicitly modifying them
-
-Examples:
-# ======== REPLACE ========
-# GOOD: Only modified lines
-# REPLACE in src/app.py: Lines 5-8
-# Reason: Update calculation formula
-<PATCH>
-src/app.py [5,8]
-    result = (base_value * 1.15) + tax
-    logger.debug("New calculation applied")
-</PATCH>
-
-# BAD: Includes unchanged lines
-<PATCH>
-src/app.py [5,8]
-def calculate():
-    # Original comment (should not be included)
-    result = (base_value * 1.15) + tax
-    return result  # Original line
-</PATCH>
-
-# ======== INSERT ========
-# GOOD: Insert single line
-# INSERT in utils/logger.py: Before line 3 
-# Reason: Add initialization check
-<PATCH>
-utils/logger.py [3]
-if not _initialized: initialize()
-</PATCH>
-
-# BAD: Extra empty lines
-<PATCH>
-utils/logger.py [3]
-
-if not _initialized: 
-    initialize()
-
-</PATCH>
-
-# ======== NEW FILE ========
-# GOOD: Complete minimal content
-# NEW FILE in config/settings.yaml: Create new config
-<PATCH>
-config/settings.yaml [1]
-database:
-  host: localhost
-  port: 5432
-</PATCH>
-
-# BAD: Placeholder content
+# 🛠️ Contextual Code Patch Specification
+Use <PATCH> blocks to specify code changes:
+--------------------------------
 <PATCH>
-config/settings.yaml [1]
-TODO: Add configuration
+File: [file_path]
+Reason: [change_reason]
+[contextual_code_snippet]
 </PATCH>
-
-# ======== DELETE ========
-# GOOD: Empty content for deletion
-# DELETE in src/old.py: Lines 10-12 
-# Reason: Remove deprecated function
-<PATCH>
-src/old.py [10,12]
-</PATCH>
-
-# BAD: Comment in delete operation
+--------------------------------
+Rules:
+1. Code snippets must include sufficient context (3 lines before/after)
+2. I can see full code, so only show modified code sections
+3. Preserve original indentation and formatting
+4. For new files, provide complete code
+5. When modifying existing files, retain surrounding unchanged code
+Example:
 <PATCH>
-src/old.py [10,12]
-# Remove these lines
+File: src/utils/math.py
+Reason: Fix zero division handling
+def safe_divide(a, b):
+    # Add parameter validation
+    if b == 0:
+        raise ValueError("Divisor cannot be zero")
+    return a / b
+# existing code ...
+def add(a, b):
+    return a + b
 </PATCH>
 """
 
-
-def _parse_patch(patch_str: str) -> Dict[str, List[Dict[str, Any]]]:
-    """解析补丁格式"""
+def _parse_patch(patch_str: str) -> Dict[str, str]:
+    """解析新的上下文补丁格式"""
     result = {}
-    header_pattern = re.compile(
-        r'^\s*"?(.+?)"?\s*\[(\d+)(?:,(\d+))?\]\s*$'  # Match file path and line number
-    )
     patches = re.findall(r'<PATCH>\n?(.*?)\n?</PATCH>', patch_str, re.DOTALL)
-    
-    for patch in patches:
-        # 分割首行和内容
-        parts = patch.split('\n', 1)
-        if len(parts) < 1:
-            continue
-        header_line = parts[0].strip()
-        content = parts[1] if len(parts) > 1 else ''
-        
-        # 仅在内容非空时添加换行符
-        if content and not content.endswith('\n'):
-            content += '\n'
-            
-        # 解析文件路径和行号
-        header_match = header_pattern.match(header_line)
-        if not header_match:
-            continue
-
-        filepath = header_match.group(1)
-        start = int(header_match.group(2))       # 保持1-based行号
-        end = int(header_match.group(3)) + 1 if header_match.group(3) else start
-
-        # 存储参数
-        if filepath not in result:
-            result[filepath] = []
-        result[filepath].append({
-            'filepath': filepath,
-            'start': start,
-            'end': end,
-            'content': content  # 保留原始内容（可能为空）
-        })
-    for filepath in result.keys():
-        result[filepath] = sorted(result[filepath], key=lambda x: x['start'], reverse=True)
+    if patches:
+        for patch in patches:
+            first_line = patch.splitlines()[0]
+            sm = re.match(r'^File:\s*(.+)$', first_line)
+            if not sm:
+                PrettyOutput.print("无效的补丁格式", OutputType.WARNING)
+                continue
+            filepath = sm.group(1).strip()
+            result[filepath] = patch
     return result
 
-
 def apply_patch(output_str: str) -> str:
     """Apply patches to files"""
     try:
@@ -166,158 +78,179 @@ def apply_patch(output_str: str) -> str:
     except Exception as e:
         PrettyOutput.print(f"解析补丁失败: {str(e)}", OutputType.ERROR)
         return ""
-
-    ret = ""
     
-    for filepath, patch_list in patches.items():
-        for patch in patch_list:
-            try:
-                handle_code_operation(filepath, patch)
-                PrettyOutput.print(f"成功处理 操作", OutputType.SUCCESS)
-            except Exception as e:
-                PrettyOutput.print(f"操作失败: {str(e)}", OutputType.ERROR)
+    # 获取当前提交hash作为起始点
+    start_hash = get_latest_commit_hash()
     
-    if has_uncommitted_changes():
-        diff = get_diff()
-        if handle_commit_workflow(diff):
-            ret += "Successfully applied the patch\n"
-            # Get modified line ranges
-            modified_ranges = get_modified_line_ranges()
-            modified_code = ReadCodeTool().execute({"files": [{"path": filepath, "start_line": start, "end_line": end} for filepath, (start, end) in modified_ranges.items()]})
-            if modified_code["success"]:
-                ret += "New code:\n"
-                ret += modified_code["stdout"]
+    # 按文件逐个处理
+    for filepath, patch_content in patches.items():
+        try:
+            handle_code_operation(filepath, patch_content)
+            PrettyOutput.print(f"文件 {filepath} 处理完成", OutputType.SUCCESS)
+        except Exception as e:
+            revert_file(filepath)  # 回滚单个文件
+            PrettyOutput.print(f"文件 {filepath} 处理失败: {str(e)}", OutputType.ERROR)
+    
+    final_ret = ""
+    diff = get_diff()
+    if diff:
+        PrettyOutput.print(diff, OutputType.CODE, lang="diff")
+        if handle_commit_workflow():
+            # 获取提交信息
+            end_hash = get_latest_commit_hash()
+            commits = get_commits_between(start_hash, end_hash)
+            
+            # 添加提交信息到final_ret
+            if commits:
+                final_ret += "✅ The patches have been applied\n"
+                final_ret += "Commit History:\n"
+                for commit_hash, commit_message in commits:
+                    final_ret += f"- {commit_hash[:7]}: {commit_message}\n"
+            else:
+                final_ret += "✅ The patches have been applied (no new commits)"
         else:
-            ret += "User rejected the patch\nThis is your patch preview:\n"
-            ret += diff
-        user_input = get_multiline_input("你可以继续输入（输入空行重试，Ctrl+C退出）: ")
-        if user_input:
-            ret += "\n" + user_input
+            final_ret += "❌ I don't want to commit the code"
+    else:
+        final_ret += "❌ There are no changes to commit"
+    # 用户确认最终结果
+    PrettyOutput.print(final_ret, OutputType.USER)
+    if not is_confirm_before_apply_patch() or user_confirm("是否使用此回复？", default=True):
+        return final_ret
+    return get_multiline_input("请输入自定义回复")
+def revert_file(filepath: str):
+    """增强版git恢复，处理新文件"""
+    import subprocess
+    try:
+        # 检查文件是否在版本控制中
+        result = subprocess.run(
+            ['git', 'ls-files', '--error-unmatch', filepath],
+            stderr=subprocess.PIPE
+        )
+        if result.returncode == 0:
+            subprocess.run(['git', 'checkout', 'HEAD', '--', filepath], check=True)
         else:
-            ret = ""
-
-    return ret  # Ensure a string is always returned
-
+            if os.path.exists(filepath):
+                os.remove(filepath)
+        subprocess.run(['git', 'clean', '-f', '--', filepath], check=True)
+    except subprocess.CalledProcessError as e:
+        PrettyOutput.print(f"恢复文件失败: {str(e)}", OutputType.ERROR)
+# 修改后的恢复函数
+def revert_change():
+    import subprocess
+    subprocess.run(['git', 'reset', '--hard', 'HEAD'], check=True)
+    subprocess.run(['git', 'clean', '-fd'], check=True)
+# 修改后的获取差异函数
 def get_diff() -> str:
-    """使用更安全的subprocess代替os.system"""
+    """使用git获取暂存区差异"""
     import subprocess
     try:
         subprocess.run(['git', 'add', '.'], check=True)
         result = subprocess.run(
-            ['git', 'diff', 'HEAD'],
+            ['git', 'diff', '--cached'],
             capture_output=True,
             text=True,
             check=True
         )
-        return result.stdout
-    finally:
-        subprocess.run(['git', 'reset', 'HEAD'], check=True)
-
-def handle_commit_workflow(diff:str)->bool:
+        ret = result.stdout
+        subprocess.run(['git', "reset", "--soft", "HEAD"], check=True)
+        return ret
+    except subprocess.CalledProcessError as e:
+        return f"获取差异失败: {str(e)}"
+def handle_commit_workflow()->bool:
     """Handle the git commit workflow and return the commit details.
     
     Returns:
         tuple[bool, str, str]: (continue_execution, commit_id, commit_message)
     """
-    if not user_confirm("是否要提交代码？", default=True):
-        import subprocess
-        subprocess.run(['git', 'reset', 'HEAD'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-        subprocess.run(['git', 'checkout', '--', '.'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-        subprocess.run(['git', 'clean', '-fd'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    if is_confirm_before_apply_patch() and not user_confirm("是否要提交代码？", default=True):
+        revert_change()
         return False
-
     git_commiter = GitCommitTool()
     commit_result = git_commiter.execute({})
     return commit_result["success"]
 
-def get_modified_line_ranges() -> Dict[str, Tuple[int, int]]:
-    """Get modified line ranges from git diff for all changed files.
-    
-    Returns:
-        Dictionary mapping file paths to tuple with (start_line, end_line) ranges
-        for modified sections. Line numbers are 1-based.
-    """
-    # Get git diff for all files
-    diff_output = os.popen("git show").read()
-    
-    # Parse the diff to get modified files and their line ranges
-    result = {}
-    current_file = None
-    
-    for line in diff_output.splitlines():
-        # Match lines like "+++ b/path/to/file"
-        file_match = re.match(r"^\+\+\+ b/(.*)", line)
-        if file_match:
-            current_file = file_match.group(1)
-            continue
-            
-        # Match lines like "@@ -100,5 +100,7 @@" where the + part shows new lines
-        range_match = re.match(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@", line)
-        if range_match and current_file:
-            start_line = int(range_match.group(1))  # Keep as 1-based
-            line_count = int(range_match.group(2)) if range_match.group(2) else 1
-            end_line = start_line + line_count - 1
-            result[current_file] = (start_line, end_line)
-    
-    return result
 # New handler functions below ▼▼▼
-
-def handle_new_file(filepath: str, patch: Dict[str, Any]):
-    """统一参数格式处理新文件"""
-    os.makedirs(os.path.dirname(filepath), exist_ok=True)
-    with open(filepath, 'w', encoding='utf-8') as f:
-        f.write(patch['content'])
-
-def handle_code_operation(filepath: str, patch: Dict[str, Any]):
-    """处理紧凑格式补丁"""
+def handle_code_operation(filepath: str, patch_content: str) -> str:
+    """处理基于上下文的代码片段"""
     try:
-        # 新建文件时强制覆盖
-        os.makedirs(os.path.dirname(filepath) or '.', exist_ok=True)
         if not os.path.exists(filepath):
+            # 新建文件
+            os.makedirs(os.path.dirname(filepath), exist_ok=True)
             open(filepath, 'w', encoding='utf-8').close()
-        with open(filepath, 'r+', encoding='utf-8') as f:
-            lines = f.readlines()
-            
-            new_lines = validate_and_apply_changes(
-                lines,
-                patch['start'],
-                patch['end'],
-                patch['content']
-            )
-            
-            f.seek(0)
-            f.writelines(new_lines)
-            f.truncate()
-
-        PrettyOutput.print(f"成功更新 {filepath}", OutputType.SUCCESS)
-
+        old_file_content = FileOperationTool().execute({"operation": "read", "files": [{"path": filepath}]})
+        if not old_file_content["success"]:
+            return f"文件读取失败: {old_file_content['stderr']}"
+        
+        prompt = f"""
+You are a code reviewer, please review the following code and merge the code with the context.
+Original Code:
+{old_file_content["stdout"]}
+Patch:
+{patch_content}
+"""
+        prompt += f"""
+Please merge the code with the context and return the fully merged code.
+
+Requirements:
+1. Strictly preserve original code formatting and indentation
+2. Only include actual code content in <MERGED_CODE> block
+3. Absolutely NO markdown code blocks (```) or backticks
+4. Maintain exact line numbers from original code except for changes
+
+Output Format:
+<MERGED_CODE>
+[merged_code]
+</MERGED_CODE>
+"""
+        model = PlatformRegistry().get_codegen_platform()
+        model.set_suppress_output(False)
+        count = 5
+        start_line = -1
+        end_line = -1
+        response = []
+        while count > 0:
+            count -= 1
+            response.extend(model.chat_until_success(prompt).splitlines())
+            try:
+                start_line = response.index("<MERGED_CODE>") + 1
+            except:
+                pass
+            try:
+                end_line = response.index("</MERGED_CODE>")
+            except:
+                pass
+            if start_line == -1:
+                PrettyOutput.print(f"❌ 为文件 {filepath} 应用补丁失败", OutputType.WARNING)
+                return f"代码合并失败"
+            if end_line == -1:
+                last_line = response[-1]
+                prompt = f"""
+                continue with the last line:
+                {last_line}
+                """
+                response.pop() # 删除最后一行
+                continue
+            if end_line < start_line:
+                PrettyOutput.print(f"❌ 为文件 {filepath} 应用补丁失败", OutputType.WARNING)
+                return f"代码合并失败"
+            break
+        # 写入合并后的代码
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write("\n".join(response[start_line:end_line]))
+        PrettyOutput.print(f"✅ 为文件 {filepath} 应用补丁成功", OutputType.SUCCESS)
+        return ""
     except Exception as e:
-        PrettyOutput.print(f"操作失败: {str(e)}", OutputType.ERROR)
-
-def validate_and_apply_changes(
-    lines: List[str],
-    start: int,
-    end: int,
-    content: str
-) -> List[str]:
-
-    new_content = content.splitlines(keepends=True)
-    
-    # 插入操作处理
-    if start == end:
-        if start < 1 or start > len(lines)+1:
-            raise ValueError(f"无效插入位置: {start}")
-        # 在指定位置前插入
-        return lines[:start-1] + new_content + lines[start-1:]
-    
-    # 范围替换/删除操作
-    if start > end:
-        raise ValueError(f"起始行{start}不能大于结束行{end}")
-    
-    max_line = len(lines)
-    # 自动修正行号范围
-    start = max(1, min(start, max_line+1))
-    end = max(start, min(end, max_line+1))
+        return f"文件操作失败: {str(e)}"
+def shell_input_handler(user_input: str, agent: Any) -> Tuple[str, bool]:
+    lines = user_input.splitlines()
+    cmdline = [line for line in lines if line.startswith("!")]
+    if len(cmdline) == 0:
+        return user_input, False
+    else:
+        script = '\n'.join([c[1:] for c in cmdline])
+        PrettyOutput.print(script, OutputType.CODE, lang="bash")
+        if user_confirm(f"是否要执行以上shell脚本？", default=True):
+            ShellScriptTool().execute({"script_content": script})
+            return "", True
+        return user_input, False
     
-    # 执行替换
-    return lines[:start-1] + new_content + lines[end-1:]

jarvis/jarvis_codebase/main.py

@@ -7,14 +7,18 @@ from typing import List, Tuple, Optional, Dict
 from jarvis.jarvis_platform.registry import PlatformRegistry
 import concurrent.futures
 from concurrent.futures import ThreadPoolExecutor
-from jarvis.jarvis_utils import OutputType, PrettyOutput, find_git_root, get_context_token_count, get_embedding, get_file_md5, get_max_token_count, get_thread_count, load_embedding_model, user_confirm
-from jarvis.jarvis_utils import init_env
 import argparse
 import pickle
 import lzma  # 添加 lzma 导入
 from tqdm import tqdm
 import re
 
+from jarvis.jarvis_utils.config import get_max_token_count, get_thread_count
+from jarvis.jarvis_utils.embedding import get_embedding, load_embedding_model, get_context_token_count
+from jarvis.jarvis_utils.git_utils import find_git_root
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.utils import  get_file_md5, init_env, user_confirm
+
 class CodeBase:
     def __init__(self, root_dir: str):
         init_env()

jarvis/jarvis_dev/main.py

@@ -1,7 +1,9 @@
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_multi_agent import MultiAgent, AgentConfig
 from jarvis.jarvis_tools.registry import ToolRegistry
-from jarvis.jarvis_utils import get_multiline_input, init_env
+from jarvis.jarvis_utils.input import get_multiline_input
+from jarvis.jarvis_utils.utils import init_env
+
 
 # Define system prompts for each role
 PM_PROMPT = """
@@ -830,13 +832,13 @@ def create_dev_team() -> MultiAgent:
     """Create a development team with multiple agents."""
 
     PM_output_handler = ToolRegistry()
-    PM_output_handler.use_tools(["ask_user", "file_operation", "search", "rag", "execute_shell"])
+    PM_output_handler.use_tools(["ask_user", "file_operation", "search_web", "rag", "execute_shell"])
 
     BA_output_handler = ToolRegistry()
-    BA_output_handler.use_tools(["ask_user", "file_operation", "search", "rag", "execute_shell"])
+    BA_output_handler.use_tools(["ask_user", "file_operation", "search_web", "rag", "execute_shell"])
 
     SA_output_handler = ToolRegistry()
-    SA_output_handler.use_tools(["read_code", "file_operation", "search", "rag", "ask_codebase", "lsp_get_document_symbols", "execute_shell"])
+    SA_output_handler.use_tools(["read_code", "file_operation", "search_web", "rag", "ask_codebase", "lsp_get_document_symbols", "execute_shell"])
     
     TL_output_handler = ToolRegistry()
     TL_output_handler.use_tools(["read_code", "file_operation", "ask_codebase", "lsp_get_diagnostics", "lsp_find_references", "lsp_find_definition", "execute_shell"])

jarvis/jarvis_git_squash/main.py

@@ -0,0 +1,81 @@
+import sys
+import argparse
+from typing import Dict, Any
+from jarvis.jarvis_tools.git_commiter import GitCommitTool
+import subprocess
+
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.utils import init_env, user_confirm
+class GitSquashTool:
+    name = "git_squash_agent"
+    description = "Squash commits interactively using a base commit hash"
+    
+    def _confirm_squash(self) -> bool:
+        """Prompt user for confirmation to squash commits"""
+        return user_confirm("是否确认压缩提交?", default=True)
+    
+    def _reset_to_commit(self, commit_hash: str) -> bool:
+        """Perform soft reset to specified commit hash"""
+        try:
+            subprocess.Popen(
+                ["git", "reset", "--soft", commit_hash],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL
+            ).wait()
+            return True
+        except Exception:
+            return False
+    
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """Execute the squash operation"""
+        try:
+            if not self._confirm_squash():
+                return {
+                    "success": False,
+                    "stdout": "Operation cancelled",
+                    "stderr": ""
+                }
+            
+            if not self._reset_to_commit(args['commit_hash']):
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "Failed to reset to specified commit"
+                }
+            
+            # Use existing GitCommitTool for new commit
+            commit_tool = GitCommitTool()
+            result = commit_tool.execute({"lang": args.get('lang', 'Chinese')})
+            
+            return {
+                "success": result['success'],
+                "stdout": result['stdout'],
+                "stderr": result['stderr']
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"Squash failed: {str(e)}"
+            }
+def main():
+    init_env()
+    parser = argparse.ArgumentParser(description='Git squash tool')
+    parser.add_argument('commit_hash', type=str, help='Base commit hash to squash from')
+    parser.add_argument('--lang', type=str, default='Chinese', help='Language for commit messages')
+    args = parser.parse_args()
+    
+    tool = GitSquashTool()
+    result = tool.execute({
+        'commit_hash': args.commit_hash,
+        'lang': args.lang
+    })
+    
+    if not result['success']:
+        PrettyOutput.print(result['stderr'], OutputType.ERROR)
+        sys.exit(1)
+        
+    PrettyOutput.print(result['stdout'], OutputType.SUCCESS)
+if __name__ == "__main__":
+    sys.exit(main())

jarvis/jarvis_lsp/cpp.py

@@ -4,7 +4,7 @@ import subprocess
 from typing import List, Dict, Optional, Tuple, Any
 import json
 from jarvis.jarvis_lsp.base import BaseLSP
-from jarvis.jarvis_utils import PrettyOutput, OutputType
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 class CPPLSP(BaseLSP):
     """C++ LSP implementation using clangd."""

jarvis/jarvis_lsp/go.py

@@ -4,7 +4,7 @@ import subprocess
 from typing import List, Dict, Optional, Tuple, Any
 import json
 from jarvis.jarvis_lsp.base import BaseLSP
-from jarvis.jarvis_utils import PrettyOutput, OutputType
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 class GoLSP(BaseLSP):
     """Go LSP implementation using gopls."""