jarvis-ai-assistant 0.7.0__py3-none-any.whl → 0.7.6__py3-none-any.whl

jarvis/jarvis_agent/jarvis.py

@@ -6,7 +6,6 @@ from datetime import datetime
 
 import typer
 
-from jarvis.jarvis_agent import OutputType, PrettyOutput
 from jarvis.jarvis_agent.agent_manager import AgentManager
 from jarvis.jarvis_agent.config_editor import ConfigEditor
 from jarvis.jarvis_agent.methodology_share_manager import MethodologyShareManager
@@ -170,7 +169,7 @@ def handle_interactive_config_option(
             config_data, ask_all=True
         )
         if not changed:
-            PrettyOutput.print("没有需要更新的配置项，保持现有配置。", OutputType.INFO)
+            print("ℹ️ 没有需要更新的配置项，保持现有配置。")
             return True
 
         # 剔除与 schema 默认值一致的键，保持配置精简
@@ -209,10 +208,10 @@ def handle_interactive_config_option(
                 wf.write(header)
             wf.write(yaml_str)
 
-        PrettyOutput.print(f"配置已更新: {config_path}", OutputType.SUCCESS)
+        print(f"✅ 配置已更新: {config_path}")
         return True
     except Exception as e:
-        PrettyOutput.print(f"交互式配置失败: {e}", OutputType.ERROR)
+        print(f"❌ 交互式配置失败: {e}")
         return True
 
 
@@ -224,7 +223,7 @@ def handle_backup_option(backup_dir_path: Optional[str]) -> bool:
     init_env("", config_file=None)
     data_dir = Path(get_data_dir())
     if not data_dir.is_dir():
-        PrettyOutput.print(f"数据目录不存在: {data_dir}", OutputType.ERROR)
+        print(f"❌ 数据目录不存在: {data_dir}")
         return True
 
     backup_dir_str = backup_dir_path if backup_dir_path.strip() else "~/jarvis_backups"
@@ -238,9 +237,9 @@ def handle_backup_option(backup_dir_path: Optional[str]) -> bool:
         archive_path = shutil.make_archive(
             str(backup_file_base), "zip", root_dir=str(data_dir)
         )
-        PrettyOutput.print(f"数据已成功备份到: {archive_path}", OutputType.SUCCESS)
+        print(f"✅ 数据已成功备份到: {archive_path}")
     except Exception as e:
-        PrettyOutput.print(f"数据备份失败: {e}", OutputType.ERROR)
+        print(f"❌ 数据备份失败: {e}")
 
     return True
 
@@ -253,7 +252,7 @@ def handle_restore_option(restore_path: Optional[str], config_file: Optional[str
     restore_file = Path(os.path.expanduser(os.path.expandvars(restore_path)))
     # 兼容 ~ 与环境变量，避免用户输入未展开路径导致找不到文件
     if not restore_file.is_file():
-        PrettyOutput.print(f"指定的恢复文件不存在: {restore_file}", OutputType.ERROR)
+        print(f"❌ 指定的恢复文件不存在: {restore_file}")
         return True
 
     # 在恢复数据时不要触发完整环境初始化，避免引导流程或网络请求
@@ -281,23 +280,21 @@ def handle_restore_option(restore_path: Optional[str], config_file: Optional[str
         if not user_confirm(
             f"数据目录 '{data_dir}' 已存在，恢复操作将覆盖它。是否继续？", default=False
         ):
-            PrettyOutput.print("恢复操作已取消。", OutputType.INFO)
+            print("ℹ️ 恢复操作已取消。")
             return True
         try:
             shutil.rmtree(data_dir)
         except Exception as e:
-            PrettyOutput.print(f"无法移除现有数据目录: {e}", OutputType.ERROR)
+            print(f"❌ 无法移除现有数据目录: {e}")
             return True
 
     try:
         data_dir.mkdir(parents=True)
         shutil.unpack_archive(str(restore_file), str(data_dir), "zip")
-        PrettyOutput.print(
-            f"数据已从 '{restore_path}' 成功恢复到 '{data_dir}'", OutputType.SUCCESS
-        )
+        print(f"✅ 数据已从 '{restore_path}' 成功恢复到 '{data_dir}'")
 
     except Exception as e:
-        PrettyOutput.print(f"数据恢复失败: {e}", OutputType.ERROR)
+        print(f"❌ 数据恢复失败: {e}")
 
     return True
 
@@ -333,9 +330,7 @@ def try_switch_to_jca_if_git_repo(
             if res.returncode == 0:
                 git_root = res.stdout.strip()
                 if git_root and os.path.isdir(git_root):
-                    PrettyOutput.print(
-                        f"检测到当前位于 Git 仓库: {git_root}", OutputType.INFO
-                    )
+                    print(f"ℹ️ 检测到当前位于 Git 仓库: {git_root}")
                     if user_confirm(
                         "检测到Git仓库，是否切换到代码开发模式（jca）？", default=False
                     ):
@@ -351,10 +346,7 @@ def try_switch_to_jca_if_git_repo(
                             args += ["--restore-session"]
                         if task:
                             args += ["-r", task]
-                        PrettyOutput.print(
-                            "正在切换到 'jca'（jarvis-code-agent）以进入代码开发模式...",
-                            OutputType.INFO,
-                        )
+                        print("ℹ️ 正在切换到 'jca'（jarvis-code-agent）以进入代码开发模式...")
                         os.execvp(args[0], args)
         except Exception:
             # 静默忽略检测异常，不影响主流程
@@ -458,10 +450,7 @@ def handle_builtin_config_selector(
                 # 可选调试输出：查看每类的搜索目录
                 try:
                     if os.environ.get("JARVIS_DEBUG_BUILTIN_SELECTOR") == "1":
-                        PrettyOutput.print(
-                            f"DEBUG: category={cat} search_dirs=" + ", ".join(str(p) for p in unique_dirs),
-                            OutputType.INFO,
-                        )
+                        print(f"ℹ️ DEBUG: category={cat} search_dirs=" + ", ".join(str(p) for p in unique_dirs))
                 except Exception:
                     pass
 
@@ -538,7 +527,7 @@ def handle_builtin_config_selector(
                     },
                 )
 
-                PrettyOutput.section("可用的内置配置", OutputType.SUCCESS)
+                print("✅ 可用的内置配置")
                 # 使用 rich Table 呈现
                 table = Table(show_header=True, header_style="bold magenta")
                 table.add_column("No.", style="cyan", no_wrap=True)
@@ -643,9 +632,7 @@ def handle_builtin_config_selector(
                                     args += ["-g", str(model_group)]
 
                             if args:
-                                PrettyOutput.print(
-                                    f"正在启动: {' '.join(args)}", OutputType.INFO
-                                )
+                                print(f"ℹ️ 正在启动: {' '.join(args)}")
                                 os.execvp(args[0], args)
                     except Exception:
                         # 任何异常都不影响默认流程
@@ -710,10 +697,14 @@ def run_cli(
     non_interactive: bool = typer.Option(
         False, "-n", "--non-interactive", help="启用非交互模式：用户无法与命令交互，脚本执行超时限制为5分钟"
     ),
-    plan: Optional[bool] = typer.Option(None, "--plan/--no-plan", help="启用或禁用任务规划（不指定则从配置加载）"),
     web: bool = typer.Option(False, "--web", help="以 Web 模式启动，通过浏览器 WebSocket 交互"),
     web_host: str = typer.Option("127.0.0.1", "--web-host", help="Web 服务主机"),
     web_port: int = typer.Option(8765, "--web-port", help="Web 服务端口"),
+    web_launch_cmd: Optional[str] = typer.Option(
+        None,
+        "--web-launch-cmd",
+        help="交互式终端启动命令（字符串格式，用空格分隔，如: --web-launch-cmd 'jca --task \"xxx\"'）",
+    ),
     stop: bool = typer.Option(False, "--stop", help="停止后台 Web 服务（需与 --web 一起使用）"),
 ) -> None:
     """Jarvis AI assistant command-line interface."""
@@ -748,10 +739,7 @@ def run_cli(
 
     # 非交互模式要求从命令行传入任务
     if non_interactive and not (task and str(task).strip()):
-        PrettyOutput.print(
-            "非交互模式已启用：必须使用 --task 传入任务内容，因多行输入不可用。",
-            OutputType.ERROR,
-        )
+        print("❌ 非交互模式已启用：必须使用 --task 传入任务内容，因多行输入不可用。")
         raise typer.Exit(code=2)
 
     # 处理数据备份
@@ -811,10 +799,10 @@ def run_cli(
                                     candidate_pid = int(ln.strip())
                                     try:
                                         os.kill(candidate_pid, signal.SIGTERM)
-                                        PrettyOutput.print(f"已按端口停止后台 Web 服务 (PID {candidate_pid})。", OutputType.SUCCESS)
+                                        print(f"✅ 已按端口停止后台 Web 服务 (PID {candidate_pid})。")
                                         killed_any = True
                                     except Exception as e:
-                                        PrettyOutput.print(f"按端口停止失败: {e}", OutputType.WARNING)
+                                        print(f"⚠️ 按端口停止失败: {e}")
                                 except Exception:
                                     continue
                     except Exception:
@@ -833,10 +821,10 @@ def run_cli(
                                                 candidate_pid = int(pid_str2)
                                                 try:
                                                     os.kill(candidate_pid, signal.SIGTERM)
-                                                    PrettyOutput.print(f"已按端口停止后台 Web 服务 (PID {candidate_pid})。", OutputType.SUCCESS)
+                                                    print(f"✅ 已按端口停止后台 Web 服务 (PID {candidate_pid})。")
                                                     killed_any = True
                                                 except Exception as e:
-                                                    PrettyOutput.print(f"按端口停止失败: {e}", OutputType.WARNING)
+                                                    print(f"⚠️ 按端口停止失败: {e}")
                                                 break
                                         except Exception:
                                             continue
@@ -853,10 +841,10 @@ def run_cli(
                                         p = int(ptxt)
                                         try:
                                             os.kill(p, signal.SIGTERM)
-                                            PrettyOutput.print(f"已停止后台 Web 服务 (PID {p})。", OutputType.SUCCESS)
+                                            print(f"✅ 已停止后台 Web 服务 (PID {p})。")
                                             killed_any = True
                                         except Exception as e:
-                                            PrettyOutput.print(f"停止 PID {p} 失败: {e}", OutputType.WARNING)
+                                            print(f"⚠️ 停止 PID {p} 失败: {e}")
                                     except Exception:
                                         pass
                                     try:
@@ -866,7 +854,7 @@ def run_cli(
                         except Exception:
                             pass
                     if not killed_any:
-                        PrettyOutput.print("未找到后台 Web 服务的 PID 文件，可能未启动或已停止。", OutputType.WARNING)
+                        print("⚠️ 未找到后台 Web 服务的 PID 文件，可能未启动或已停止。")
                     return
                 # 优先使用 PID 文件中的 PID
                 try:
@@ -878,10 +866,10 @@ def run_cli(
                 if pid > 0:
                     try:
                         os.kill(pid, signal.SIGTERM)
-                        PrettyOutput.print(f"已向后台 Web 服务发送停止信号 (PID {pid})。", OutputType.SUCCESS)
+                        print(f"✅ 已向后台 Web 服务发送停止信号 (PID {pid})。")
                         killed = True
                     except Exception as e:
-                        PrettyOutput.print(f"发送停止信号失败或进程不存在: {e}", OutputType.WARNING)
+                        print(f"⚠️ 发送停止信号失败或进程不存在: {e}")
                 if not killed:
                     # 无 PID 文件或停止失败时，尝试按端口查找进程
                     candidate_pid = 0
@@ -921,10 +909,10 @@ def run_cli(
                     if candidate_pid:
                         try:
                             os.kill(candidate_pid, signal.SIGTERM)
-                            PrettyOutput.print(f"已按端口停止后台 Web 服务 (PID {candidate_pid})。", OutputType.SUCCESS)
+                            print(f"✅ 已按端口停止后台 Web 服务 (PID {candidate_pid})。")
                             killed = True
                         except Exception as e:
-                            PrettyOutput.print(f"按端口停止失败: {e}", OutputType.WARNING)
+                            print(f"⚠️ 按端口停止失败: {e}")
                 # 清理可能存在的 PID 文件（两个位置）
                 try:
                     pidfile.unlink(missing_ok=True)  # 家目录位置
@@ -936,7 +924,7 @@ def run_cli(
                 except Exception:
                     pass
             except Exception as e:
-                PrettyOutput.print(f"停止后台 Web 服务失败: {e}", OutputType.ERROR)
+                print(f"❌ 停止后台 Web 服务失败: {e}")
             finally:
                 return
         # 后台启动：父进程拉起子进程并记录 PID
@@ -970,6 +958,8 @@ def run_cli(
                     args += ["-D"]
                 if non_interactive:
                     args += ["-n"]
+                if web_launch_cmd:
+                    args += ["--web-launch-cmd", str(web_launch_cmd)]
                 env = os.environ.copy()
                 env["JARVIS_WEB_DAEMON"] = "1"
                 # 启动子进程（后台运行）
@@ -990,24 +980,23 @@ def run_cli(
                     pidfile.write_text(str(proc.pid), encoding="utf-8")
                 except Exception:
                     pass
-                PrettyOutput.print(
-                    f"Web 服务已在后台启动 (PID {proc.pid})，地址: http://{web_host}:{web_port}",
-                    OutputType.SUCCESS,
-                )
+                print(f"✅ Web 服务已在后台启动 (PID {proc.pid})，地址: http://{web_host}:{web_port}")
             except Exception as e:
-                PrettyOutput.print(f"后台启动 Web 服务失败: {e}", OutputType.ERROR)
+                print(f"❌ 后台启动 Web 服务失败: {e}")
                 raise typer.Exit(code=1)
             return
 
     # 在初始化环境前检测Git仓库，并可选择自动切换到代码开发模式（jca）
-    if not non_interactive:
+    # 如果指定了 -T/--task 参数，跳过切换提示
+    if not non_interactive and not task:
         try_switch_to_jca_if_git_repo(
             model_group, tool_group, config_file, restore_session, task
         )
 
     # 在进入默认通用代理前，列出内置配置供选择（agent/multi_agent/roles）
     # 非交互模式下跳过内置角色/配置选择
-    if not non_interactive:
+    # 如果指定了 -T/--task 参数，跳过配置选择
+    if not non_interactive and not task:
         handle_builtin_config_selector(model_group, tool_group, config_file, task)
 
     # 初始化环境
@@ -1051,13 +1040,7 @@ def run_cli(
             non_interactive=non_interactive,
             **extra_kwargs,
         )
-        agent = agent_manager.initialize()
-        # CLI 开关：启用/禁用规划（不依赖 AgentManager 支持，直接设置 Agent 属性）
-        if plan is not None:
-            try:
-                agent.plan = bool(plan)
-            except Exception:
-                pass
+        agent_manager.initialize()
 
         if web:
             try:
@@ -1068,7 +1051,7 @@ def run_cli(
                 try:
                     import os as _os
                     _os.environ["COLUMNS"] = "200"
-                    # 尝试固定全局 Console 的宽度（PrettyOutput 使用该 Console 实例）
+                    # 尝试固定全局 Console 的宽度
                     try:
                         from jarvis.jarvis_utils.globals import console as _console
                         try:
@@ -1087,45 +1070,77 @@ def run_cli(
                     enable_web_stdin_redirect()
                 except Exception:
                     pass
-                # 记录用于交互式终端（PTY）重启的 jvs 启动命令（移除 web 相关参数）
-                try:
-                    import sys as _sys
-                    import os as _os
-                    import json as _json
-                    _argv = list(_sys.argv)
-                    # 去掉程序名（argv[0]），并过滤 --web 相关参数
-                    filtered = []
-                    i = 1
-                    while i < len(_argv):
-                        a = _argv[i]
-                        if a == "--web" or a.startswith("--web="):
-                            i += 1
-                            continue
-                        if a == "--web-host":
-                            i += 2
-                            continue
-                        if a.startswith("--web-host="):
-                            i += 1
-                            continue
-                        if a == "--web-port":
-                            i += 2
-                            continue
-                        if a.startswith("--web-port="):
+                # 构建用于交互式终端（PTY）重启的启动命令
+                launch_cmd = None
+                # 优先使用命令行参数指定的启动命令
+                if web_launch_cmd and web_launch_cmd.strip():
+                    # 解析字符串命令（支持引号）
+                    try:
+                        import shlex
+                        launch_cmd = shlex.split(web_launch_cmd.strip())
+                        # 调试输出（可选，可以通过环境变量控制）
+                        if os.environ.get("JARVIS_DEBUG_WEB_LAUNCH_CMD") == "1":
+                            print(f"🔍 解析后的启动命令: {launch_cmd}")
+                    except Exception:
+                        # 如果解析失败，使用简单的空格分割
+                        launch_cmd = web_launch_cmd.strip().split()
+                        if os.environ.get("JARVIS_DEBUG_WEB_LAUNCH_CMD") == "1":
+                            print(f"🔍 使用简单分割的启动命令: {launch_cmd}")
+                else:
+                    # 如果没有指定，则自动构建（移除 web 相关参数）
+                    try:
+                        import sys as _sys
+                        import os as _os
+                        _argv = list(_sys.argv)
+                        # 去掉程序名（argv[0]），并过滤 --web 相关参数
+                        filtered = []
+                        i = 1
+                        while i < len(_argv):
+                            a = _argv[i]
+                            if a == "--web" or a.startswith("--web="):
+                                i += 1
+                                continue
+                            if a == "--web-host":
+                                i += 2
+                                continue
+                            if a.startswith("--web-host="):
+                                i += 1
+                                continue
+                            if a == "--web-port":
+                                i += 2
+                                continue
+                            if a.startswith("--web-port="):
+                                i += 1
+                                continue
+                            if a == "--web-launch-cmd":
+                                # 跳过 --web-launch-cmd 及其值
+                                i += 2
+                                continue
+                            if a.startswith("--web-launch-cmd="):
+                                i += 1
+                                continue
+                            filtered.append(a)
                             i += 1
-                            continue
-                        filtered.append(a)
-                        i += 1
-                    # 使用 jvs 命令作为可执行文件，保留其余业务参数
-                    cmd = ["jvs"] + filtered
-                    _os.environ["JARVIS_WEB_LAUNCH_JSON"] = _json.dumps(cmd, ensure_ascii=False)
-                except Exception:
-                    pass
-                PrettyOutput.print("以 Web 模式启动，请在浏览器中打开提供的地址进行交互。", OutputType.INFO)
-                # 启动 Web 服务（阻塞调用）
-                start_web_server(agent_manager, host=web_host, port=web_port)
+                        # 使用 jvs 命令作为可执行文件，保留其余业务参数
+                        launch_cmd = ["jvs"] + filtered
+                    except Exception:
+                        pass
+                
+                # 同时写入环境变量作为备选（向后兼容）
+                if launch_cmd:
+                    try:
+                        import os as _os
+                        import json as _json
+                        _os.environ["JARVIS_WEB_LAUNCH_JSON"] = _json.dumps(launch_cmd, ensure_ascii=False)
+                    except Exception:
+                        pass
+                
+                print("ℹ️ 以 Web 模式启动，请在浏览器中打开提供的地址进行交互。")
+                # 启动 Web 服务（阻塞调用），传入启动命令
+                start_web_server(agent_manager, host=web_host, port=web_port, launch_command=launch_cmd)
                 return
             except Exception as e:
-                PrettyOutput.print(f"Web 模式启动失败: {e}", OutputType.ERROR)
+                print(f"❌ Web 模式启动失败: {e}")
                 raise typer.Exit(code=1)
 
         # 默认 CLI 模式：运行任务（可能来自 --task 或交互输入）
@@ -1133,7 +1148,7 @@ def run_cli(
     except typer.Exit:
         raise
     except Exception as err:  # pylint: disable=broad-except
-        PrettyOutput.print(f"初始化错误: {str(err)}", OutputType.ERROR)
+        print(f"❌ 初始化错误: {str(err)}")
         raise typer.Exit(code=1)
 
 

jarvis/jarvis_agent/language_extractors/__init__.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+"""Language extractors for file context handler.
+
+This module automatically registers all language extractors.
+"""
+
+# Import all language extractors to trigger registration
+try:
+    from .python_extractor import register_python_extractor
+    register_python_extractor()
+except (ImportError, Exception):
+    pass
+
+try:
+    from .rust_extractor import register_rust_extractor
+    register_rust_extractor()
+except (ImportError, Exception):
+    pass
+
+try:
+    from .go_extractor import register_go_extractor
+    register_go_extractor()
+except (ImportError, Exception):
+    pass
+
+try:
+    from .c_extractor import register_c_extractor
+    register_c_extractor()
+except (ImportError, Exception):
+    pass
+
+try:
+    from .cpp_extractor import register_cpp_extractor
+    register_cpp_extractor()
+except (ImportError, Exception):
+    pass
+
+try:
+    from .javascript_extractor import register_javascript_extractor
+    register_javascript_extractor()
+except (ImportError, Exception):
+    pass
+
+try:
+    from .typescript_extractor import register_typescript_extractor
+    register_typescript_extractor()
+except (ImportError, Exception):
+    pass
+
+try:
+    from .java_extractor import register_java_extractor
+    register_java_extractor()
+except (ImportError, Exception):
+    pass
+
+__all__ = []
+

jarvis/jarvis_agent/language_extractors/c_extractor.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+"""C language symbol extractor."""
+
+from typing import Optional, Any
+
+from jarvis.jarvis_agent.file_context_handler import register_language_extractor
+
+
+def create_c_extractor() -> Optional[Any]:
+    """Create C symbol extractor using tree-sitter."""
+    try:
+        from jarvis.jarvis_code_agent.code_analyzer.languages.c_cpp_language import CSymbolExtractor
+        return CSymbolExtractor()
+    except (ImportError, RuntimeError, Exception):
+        return None
+
+
+def register_c_extractor() -> None:
+    """Register C extractor for .c and .h files."""
+    register_language_extractor(['.c', '.h'], create_c_extractor)
+

jarvis/jarvis_agent/language_extractors/cpp_extractor.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+"""C++ language symbol extractor."""
+
+from typing import Optional, Any
+
+from jarvis.jarvis_agent.file_context_handler import register_language_extractor
+
+
+def create_cpp_extractor() -> Optional[Any]:
+    """Create C++ symbol extractor using tree-sitter."""
+    try:
+        from jarvis.jarvis_code_agent.code_analyzer.languages.c_cpp_language import CppSymbolExtractor
+        return CppSymbolExtractor()
+    except (ImportError, RuntimeError, Exception):
+        return None
+
+
+def register_cpp_extractor() -> None:
+    """Register C++ extractor for .cpp, .cc, .cxx, .hpp, .hxx files."""
+    register_language_extractor(['.cpp', '.cc', '.cxx', '.hpp', '.hxx'], create_cpp_extractor)
+

jarvis/jarvis_agent/language_extractors/go_extractor.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+"""Go language symbol extractor."""
+
+from typing import Optional, Any
+
+from jarvis.jarvis_agent.file_context_handler import register_language_extractor
+
+
+def create_go_extractor() -> Optional[Any]:
+    """Create Go symbol extractor using tree-sitter."""
+    try:
+        from jarvis.jarvis_code_agent.code_analyzer.languages.go_language import GoSymbolExtractor
+        return GoSymbolExtractor()
+    except (ImportError, RuntimeError, Exception):
+        return None
+
+
+def register_go_extractor() -> None:
+    """Register Go extractor for .go files."""
+    register_language_extractor('.go', create_go_extractor)
+

jarvis/jarvis_agent/language_extractors/java_extractor.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+"""Java language symbol extractor."""
+
+from typing import Optional, Any
+
+from jarvis.jarvis_agent.file_context_handler import register_language_extractor
+
+
+def create_java_extractor() -> Optional[Any]:
+    """Create Java symbol extractor using tree-sitter."""
+    try:
+        from jarvis.jarvis_code_agent.code_analyzer.languages.java_language import JavaSymbolExtractor
+        return JavaSymbolExtractor()
+    except (ImportError, RuntimeError, Exception):
+        # 如果 code_analyzer 中没有 Java 支持，尝试直接使用 tree-sitter
+        try:
+            from tree_sitter import Language, Parser
+            import tree_sitter_java
+            from jarvis.jarvis_code_agent.code_analyzer.symbol_extractor import Symbol
+            
+            JAVA_LANGUAGE = tree_sitter_java.language()
+            JAVA_SYMBOL_QUERY = """
+            (method_declaration
+              name: (identifier) @method.name)
+            
+            (class_declaration
+              name: (identifier) @class.name)
+            
+            (interface_declaration
+              name: (identifier) @interface.name)
+            
+            (field_declaration
+              (variable_declarator
+                name: (identifier) @field.name))
+            """
+            
+            class JavaSymbolExtractor:
+                def __init__(self):
+                    # 如果传入的是 PyCapsule，需要转换为 Language 对象
+                    if not isinstance(JAVA_LANGUAGE, Language):
+                        self.language = Language(JAVA_LANGUAGE)
+                    else:
+                        self.language = JAVA_LANGUAGE
+                    self.parser = Parser()
+                    # 使用 language 属性而不是 set_language 方法
+                    self.parser.language = self.language
+                    self.symbol_query = JAVA_SYMBOL_QUERY
+                
+                def extract_symbols(self, file_path: str, content: str) -> list:
+                    try:
+                        tree = self.parser.parse(bytes(content, "utf8"))
+                        query = self.language.query(self.symbol_query)
+                        captures = query.captures(tree.root_node)
+                        
+                        symbols = []
+                        for node, name in captures:
+                            kind_map = {
+                                "method.name": "method",
+                                "class.name": "class",
+                                "interface.name": "interface",
+                                "field.name": "field",
+                            }
+                            symbol_kind = kind_map.get(name)
+                            if symbol_kind:
+                                symbols.append(Symbol(
+                                    name=node.text.decode('utf8'),
+                                    kind=symbol_kind,
+                                    file_path=file_path,
+                                    line_start=node.start_point[0] + 1,
+                                    line_end=node.end_point[0] + 1,
+                                ))
+                        return symbols
+                    except Exception:
+                        return []
+            
+            return JavaSymbolExtractor()
+        except (ImportError, Exception):
+            return None
+
+
+def register_java_extractor() -> None:
+    """Register Java extractor for .java files."""
+    register_language_extractor('.java', create_java_extractor)
+