jarvis-ai-assistant 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

jarvis/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 """Jarvis AI Assistant"""
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"

jarvis/jarvis_agent/jarvis.py

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-import argparse
 import os
 import shutil
 import subprocess
@@ -7,6 +6,7 @@ import sys
 from pathlib import Path
 from typing import Dict, Optional
 
+import typer
 import yaml  # type: ignore
 from prompt_toolkit import prompt  # type: ignore
 
@@ -24,6 +24,8 @@ from jarvis.jarvis_tools.registry import ToolRegistry
 from jarvis.jarvis_utils.config import get_data_dir
 from jarvis.jarvis_utils.utils import init_env
 
+app = typer.Typer(help="Jarvis AI assistant")
+
 
 def _load_tasks() -> Dict[str, str]:
     """Load tasks from .jarvis files in user home and current directory."""
@@ -109,48 +111,14 @@ def _select_task(tasks: Dict[str, str]) -> str:
             PrettyOutput.print(f"选择任务失败: {str(val_err)}", OutputType.ERROR)
 
 
-def _parse_args() -> argparse.Namespace:
-    """Parse command line arguments."""
-    parser = argparse.ArgumentParser(description="Jarvis AI assistant")
-    parser.add_argument(
-        "--llm_type",
-        type=str,
-        default="normal",
-        choices=["normal", "thinking"],
-        help="LLM type to use",
-    )
-    parser.add_argument(
-        "-t",
-        "--task",
-        type=str,
-        help="Directly input task content from command line",
-    )
-    parser.add_argument(
-        "--model_group",
-        type=str,
-        help="Model group to use, overriding config",
-    )
-    parser.add_argument("-f", "--config", type=str, help="Path to custom config file")
-    parser.add_argument(
-        "--restore-session",
-        action="store_true",
-        help="Restore session from .jarvis/saved_session.json",
-        default=False,
-    )
-    parser.add_argument(
-        "-e", "--edit", action="store_true", help="Edit the configuration file"
-    )
-    return parser.parse_args()
-
-
-def _handle_edit_mode(args: argparse.Namespace) -> None:
+def _handle_edit_mode(edit: bool, config_file: Optional[str]) -> None:
     """If edit flag is set, open config file in editor and exit."""
-    if not args.edit:
+    if not edit:
         return
 
     config_file_path = (
-        Path(args.config)
-        if args.config
+        Path(config_file)
+        if config_file
         else Path(os.path.expanduser("~/.jarvis/config.yaml"))
     )
     editors = ["nvim", "vim", "vi"]
@@ -159,30 +127,32 @@ def _handle_edit_mode(args: argparse.Namespace) -> None:
     if editor:
         try:
             subprocess.run([editor, str(config_file_path)], check=True)
-            sys.exit(0)
+            raise typer.Exit(code=0)
         except (subprocess.CalledProcessError, FileNotFoundError) as e:
             PrettyOutput.print(f"Failed to open editor: {e}", OutputType.ERROR)
-            sys.exit(1)
+            raise typer.Exit(code=1)
     else:
         PrettyOutput.print(
             "No suitable editor found (nvim, vim, vi).", OutputType.ERROR
         )
-        sys.exit(1)
+        raise typer.Exit(code=1)
 
 
-def _initialize_agent(args: argparse.Namespace) -> Agent:
+def _initialize_agent(
+    llm_type: str, model_group: Optional[str], restore_session: bool
+) -> Agent:
     """Initialize the agent and restore session if requested."""
     agent = Agent(
         system_prompt=origin_agent_system_prompt,
-        llm_type=args.llm_type,
-        model_group=args.model_group,
+        llm_type=llm_type,
+        model_group=model_group,
         input_handler=[shell_input_handler, builtin_input_handler],
         output_handler=[ToolRegistry()],  # type: ignore
         need_summary=False,
     )
 
     # 尝试恢复会话
-    if args.restore_session:
+    if restore_session:
         if agent.restore_session():
             PrettyOutput.print("会话已成功恢复。", OutputType.SUCCESS)
         else:
@@ -195,36 +165,68 @@ def _get_and_run_task(agent: Agent, task_content: Optional[str] = None) -> None:
     # 优先处理命令行直接传入的任务
     if task_content:
         agent.run(task_content)
-        sys.exit(0)
+        raise typer.Exit(code=0)
 
     if agent.first:
         tasks = _load_tasks()
         if tasks and (selected_task := _select_task(tasks)):
             PrettyOutput.print(f"开始执行任务: \n{selected_task}", OutputType.INFO)
             agent.run(selected_task)
-            sys.exit(0)
+            raise typer.Exit(code=0)
 
     user_input = get_multiline_input("请输入你的任务（输入空行退出）:")
     if user_input:
         agent.run(user_input)
-    sys.exit(0)
+    raise typer.Exit(code=0)
 
 
-def main() -> None:
-    """Main function for Jarvis AI assistant."""
-    args = _parse_args()
-    _handle_edit_mode(args)
+@app.callback(invoke_without_command=True)
+def run_cli(
+    ctx: typer.Context,
+    llm_type: str = typer.Option(
+        "normal",
+        "--llm_type",
+        help="LLM type to use, choices are 'normal' and 'thinking'",
+    ),
+    task: Optional[str] = typer.Option(
+        None, "-t", "--task", help="Directly input task content from command line"
+    ),
+    model_group: Optional[str] = typer.Option(
+        None, "--model_group", help="Model group to use, overriding config"
+    ),
+    config_file: Optional[str] = typer.Option(
+        None, "-f", "--config", help="Path to custom config file"
+    ),
+    restore_session: bool = typer.Option(
+        False,
+        "--restore-session",
+        help="Restore session from .jarvis/saved_session.json",
+    ),
+    edit: bool = typer.Option(
+        False, "-e", "--edit", help="Edit the configuration file"
+    ),
+) -> None:
+    """Jarvis AI assistant command-line interface."""
+    if ctx.invoked_subcommand is not None:
+        return
+        
+    _handle_edit_mode(edit, config_file)
 
-    init_env(
-        "欢迎使用 Jarvis AI 助手，您的智能助理已准备就绪！", config_file=args.config
-    )
+    init_env("欢迎使用 Jarvis AI 助手，您的智能助理已准备就绪！", config_file=config_file)
 
     try:
-        agent = _initialize_agent(args)
-        _get_and_run_task(agent, args.task)
+        agent = _initialize_agent(llm_type, model_group, restore_session)
+        _get_and_run_task(agent, task)
+    except typer.Exit:
+        raise
     except Exception as err:  # pylint: disable=broad-except
         PrettyOutput.print(f"初始化错误: {str(err)}", OutputType.ERROR)
-        sys.exit(1)
+        raise typer.Exit(code=1)
+
+
+def main() -> None:
+    """Application entry point."""
+    app()
 
 
 if __name__ == "__main__":

jarvis/jarvis_agent/main.py

@@ -1,7 +1,8 @@
 # -*- coding: utf-8 -*-
-import argparse
 import os
+from typing import Optional
 
+import typer
 import yaml
 
 from jarvis.jarvis_agent import Agent
@@ -9,6 +10,8 @@ from jarvis.jarvis_utils.input import get_multiline_input
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import init_env
 
+app = typer.Typer(help="Jarvis AI assistant")
+
 
 def load_config(config_path: str) -> dict:
     """从YAML文件加载配置
@@ -34,59 +37,53 @@ def load_config(config_path: str) -> dict:
             return {}
 
 
-def main():
-    """Main entry point for Jarvis agent"""
-    # Set up argument parser
-    parser = argparse.ArgumentParser(description="Jarvis AI assistant")
-    parser.add_argument(
-        "-f", "--config", type=str, required=False, help="Path to agent config file"
-    )
-    parser.add_argument(
-        "-c", "--agent_definition", type=str, help="Path to agent definition file"
-    )
-    parser.add_argument("-t", "--task", type=str, help="Initial task to execute")
-    parser.add_argument(
+@app.command()
+def cli(
+    config_file: Optional[str] = typer.Option(
+        None, "-f", "--config", help="Path to agent config file"
+    ),
+    agent_definition: Optional[str] = typer.Option(
+        None, "-c", "--agent_definition", help="Path to agent definition file"
+    ),
+    task: Optional[str] = typer.Option(
+        None, "-t", "--task", help="Initial task to execute"
+    ),
+    llm_type: str = typer.Option(
+        "normal",
         "--llm_type",
-        type=str,
-        default="normal",
-        choices=["normal", "thinking"],
         help="LLM type to use, overriding config",
-    )
-    parser.add_argument(
-        "--model_group",
-        type=str,
-        help="Model group to use, overriding config",
-    )
-    args = parser.parse_args()
-
+    ),
+    model_group: Optional[str] = typer.Option(
+        None, "--model_group", help="Model group to use, overriding config"
+    ),
+):
+    """Main entry point for Jarvis agent"""
     # Initialize environment
-    init_env(
-        "欢迎使用 Jarvis AI 助手，您的智能助理已准备就绪！", config_file=args.config
-    )
+    init_env("欢迎使用 Jarvis AI 助手，您的智能助理已准备就绪！", config_file=config_file)
 
     # Load configuration
-    config = load_config(args.agent_definition) if args.agent_definition else {}
+    config = load_config(agent_definition) if agent_definition else {}
 
     # Override config with command-line arguments if provided
-    if args.llm_type:
-        config["llm_type"] = args.llm_type
-    if args.model_group:
-        config["model_group"] = args.model_group
+    if llm_type:
+        config["llm_type"] = llm_type
+    if model_group:
+        config["model_group"] = model_group
 
     # Create and run agent
     try:
         agent = Agent(**config)
 
         # Run agent with initial task if specified
-        if args.task:
-            PrettyOutput.print(f"执行初始任务: {args.task}", OutputType.INFO)
-            agent.run(args.task)
-            return 0
+        if task:
+            PrettyOutput.print(f"执行初始任务: {task}", OutputType.INFO)
+            agent.run(task)
+            raise typer.Exit(code=0)
 
         try:
             user_input = get_multiline_input("请输入你的任务（输入空行退出）:")
             if not user_input:
-                return 0
+                raise typer.Exit(code=0)
             agent.set_addon_prompt(
                 "如果有必要，请先指定出行动计划，然后根据计划一步步执行，如果任务过于复杂，可以拆分子Agent进行执行，拆的子Agent需要掌握所有必要的任务信息，否则无法执行"
             )
@@ -94,12 +91,17 @@ def main():
         except Exception as e:
             PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
 
+    except typer.Exit:
+        raise
     except Exception as e:
         PrettyOutput.print(f"初始化错误: {str(e)}", OutputType.ERROR)
-        return 1
+        raise typer.Exit(code=1)
+
 
-    return 0
+def main() -> None:
+    """Application entry point."""
+    app()
 
 
 if __name__ == "__main__":
-    exit(main())
+    main()

jarvis/jarvis_code_agent/code_agent.py

@@ -4,12 +4,13 @@
 该模块提供CodeAgent类，用于处理代码修改任务。
 """
 
-import argparse
 import os
 import subprocess
 import sys
 from typing import List, Optional, Tuple
 
+import typer
+
 from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_agent.builtin_input_handler import builtin_input_handler
 from jarvis.jarvis_agent.edit_file_handler import EditFileHandler
@@ -37,6 +38,8 @@ from jarvis.jarvis_utils.input import get_multiline_input, user_confirm
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import get_loc_stats, init_env
 
+app = typer.Typer(help="Jarvis Code Agent")
+
 
 class CodeAgent:
     """Jarvis系统的代码修改代理。
@@ -401,33 +404,27 @@ class CodeAgent:
         agent.session.prompt += final_ret
 
 
-def main() -> None:
-    """Jarvis主入口点。"""
-    init_env("欢迎使用 Jarvis-CodeAgent，您的代码工程助手已准备就绪！")
-
-    parser = argparse.ArgumentParser(description="Jarvis Code Agent")
-    parser.add_argument(
+@app.command()
+def cli(
+    llm_type: str = typer.Option(
+        "normal",
         "--llm_type",
-        type=str,
-        default="normal",
-        choices=["normal", "thinking"],
-        help="LLM type to use",
-    )
-    parser.add_argument(
-        "--model_group",
-        type=str,
-        help="Model group to use, overriding config",
-    )
-    parser.add_argument(
-        "-r", "--requirement", type=str, help="Requirement to process", default=None
-    )
-    parser.add_argument(
+        help="LLM type to use, choices are 'normal' and 'thinking'",
+    ),
+    model_group: Optional[str] = typer.Option(
+        None, "--model_group", help="Model group to use, overriding config"
+    ),
+    requirement: Optional[str] = typer.Option(
+        None, "-r", "--requirement", help="Requirement to process"
+    ),
+    restore_session: bool = typer.Option(
+        False,
         "--restore-session",
-        action="store_true",
         help="Restore session from .jarvis/saved_session.json",
-        default=False,
-    )
-    args = parser.parse_args()
+    ),
+) -> None:
+    """Jarvis主入口点。"""
+    init_env("欢迎使用 Jarvis-CodeAgent，您的代码工程助手已准备就绪！")
 
     curr_dir = os.getcwd()
     git_dir = find_git_root_and_cd(curr_dir)
@@ -435,13 +432,13 @@ def main() -> None:
 
     try:
         agent = CodeAgent(
-            llm_type=args.llm_type,
-            model_group=args.model_group,
+            llm_type=llm_type,
+            model_group=model_group,
             need_summary=False,
         )
 
         # 尝试恢复会话
-        if args.restore_session:
+        if restore_session:
             if agent.agent.restore_session():
                 PrettyOutput.print(
                     "已从 .jarvis/saved_session.json 恢复会话。", OutputType.SUCCESS
@@ -451,19 +448,26 @@ def main() -> None:
                     "无法从 .jarvis/saved_session.json 恢复会话。", OutputType.WARNING
                 )
 
-        if args.requirement:
-            agent.run(args.requirement)
+        if requirement:
+            agent.run(requirement)
         else:
             while True:
                 user_input = get_multiline_input("请输入你的需求（输入空行退出）:")
                 if not user_input:
-                    return
+                    raise typer.Exit(code=0)
                 agent.run(user_input)
 
+    except typer.Exit:
+        raise
     except RuntimeError as e:
         PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
         sys.exit(1)
 
 
+def main() -> None:
+    """Application entry point."""
+    app()
+
+
 if __name__ == "__main__":
     main()

jarvis/jarvis_code_analysis/code_review.py

@@ -3,8 +3,11 @@ import os
 import re
 import subprocess
 import tempfile
+import sys
 from typing import Any, Dict, List, Optional
 
+import typer
+
 from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_code_analysis.checklists.loader import get_language_checklist
 from jarvis.jarvis_platform.registry import PlatformRegistry
@@ -14,6 +17,8 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.tag import ct, ot
 from jarvis.jarvis_utils.utils import init_env, is_context_overflow
 
+app = typer.Typer(help="Autonomous code review tool")
+
 
 class CodeReviewTool:
     name = "code_review"
@@ -762,60 +767,89 @@ def extract_code_report(result: str) -> str:
     return result
 
 
-def main():
-    """CLI entry point"""
-    import argparse
-
-    init_env("欢迎使用 Jarvis-CodeReview，您的代码审查助手已准备就绪！")
-
-    parser = argparse.ArgumentParser(description="Autonomous code review tool")
-    subparsers = parser.add_subparsers(dest="type")
-
-    # Commit subcommand
-    commit_parser = subparsers.add_parser("commit", help="Review specific commit")
-    commit_parser.add_argument("commit", help="Commit SHA to review")
+@app.command("commit")
+def review_commit(
+    commit: str = typer.Argument(..., help="Commit SHA to review"),
+    root_dir: str = typer.Option(".", "--root-dir", help="Root directory of the codebase"),
+):
+    """Review specific commit"""
+    tool = CodeReviewTool()
+    tool_args = {"review_type": "commit", "commit_sha": commit, "root_dir": root_dir}
+    result = tool.execute(tool_args)
+    if result["success"]:
+        PrettyOutput.section("自动代码审查结果:", OutputType.SUCCESS)
+        report = extract_code_report(result["stdout"])
+        PrettyOutput.print(report, OutputType.SUCCESS, lang="markdown")
+    else:
+        PrettyOutput.print(result["stderr"], OutputType.WARNING)
 
-    # Current subcommand
-    subparsers.add_parser("current", help="Review current changes")
 
-    # Range subcommand
-    range_parser = subparsers.add_parser("range", help="Review commit range")
-    range_parser.add_argument("start_commit", help="Start commit SHA")
-    range_parser.add_argument("end_commit", help="End commit SHA")
+@app.command("current")
+def review_current(
+    root_dir: str = typer.Option(".", "--root-dir", help="Root directory of the codebase"),
+):
+    """Review current changes"""
+    tool = CodeReviewTool()
+    tool_args = {"review_type": "current", "root_dir": root_dir}
+    result = tool.execute(tool_args)
+    if result["success"]:
+        PrettyOutput.section("自动代码审查结果:", OutputType.SUCCESS)
+        report = extract_code_report(result["stdout"])
+        PrettyOutput.print(report, OutputType.SUCCESS, lang="markdown")
+    else:
+        PrettyOutput.print(result["stderr"], OutputType.WARNING)
 
-    # File subcommand
-    file_parser = subparsers.add_parser("file", help="Review specific file")
-    file_parser.add_argument("file", help="File path to review")
 
-    # Common arguments
-    parser.add_argument(
-        "--root-dir", type=str, help="Root directory of the codebase", default="."
-    )
+@app.command("range")
+def review_range(
+    start_commit: str = typer.Argument(..., help="Start commit SHA"),
+    end_commit: str = typer.Argument(..., help="End commit SHA"),
+    root_dir: str = typer.Option(".", "--root-dir", help="Root directory of the codebase"),
+):
+    """Review commit range"""
+    tool = CodeReviewTool()
+    tool_args = {
+        "review_type": "range",
+        "start_commit": start_commit,
+        "end_commit": end_commit,
+        "root_dir": root_dir,
+    }
+    result = tool.execute(tool_args)
+    if result["success"]:
+        PrettyOutput.section("自动代码审查结果:", OutputType.SUCCESS)
+        report = extract_code_report(result["stdout"])
+        PrettyOutput.print(report, OutputType.SUCCESS, lang="markdown")
+    else:
+        PrettyOutput.print(result["stderr"], OutputType.WARNING)
 
-    # Set default subcommand to 'current'
-    parser.set_defaults(type="current")
-    args = parser.parse_args()
 
+@app.command("file")
+def review_file(
+    file: str = typer.Argument(..., help="File path to review"),
+    root_dir: str = typer.Option(".", "--root-dir", help="Root directory of the codebase"),
+):
+    """Review specific file"""
     tool = CodeReviewTool()
-    tool_args = {"review_type": args.type, "root_dir": args.root_dir}
-    if args.type == "commit":
-        tool_args["commit_sha"] = args.commit
-    elif args.type == "range":
-        tool_args["start_commit"] = args.start_commit
-        tool_args["end_commit"] = args.end_commit
-    elif args.type == "file":
-        tool_args["file_path"] = args.file
-
+    tool_args = {"review_type": "file", "file_path": file, "root_dir": root_dir}
     result = tool.execute(tool_args)
-
     if result["success"]:
         PrettyOutput.section("自动代码审查结果:", OutputType.SUCCESS)
         report = extract_code_report(result["stdout"])
         PrettyOutput.print(report, OutputType.SUCCESS, lang="markdown")
-
     else:
         PrettyOutput.print(result["stderr"], OutputType.WARNING)
 
 
+def cli():
+    """Typer application entry point"""
+    init_env("欢迎使用 Jarvis-CodeReview，您的代码审查助手已准备就绪！")
+    app()
+
+
+def main():
+    """Main entry point for the script"""
+    cli()
+
+
 if __name__ == "__main__":
     main()

jarvis/jarvis_git_squash/main.py

@@ -1,14 +1,16 @@
 # -*- coding: utf-8 -*-
-import argparse
 import subprocess
-import sys
 from typing import Dict
 
+import typer
+
 from jarvis.jarvis_git_utils.git_commiter import GitCommitTool
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import init_env
 from jarvis.jarvis_utils.input import user_confirm
 
+app = typer.Typer(help="Git squash tool")
+
 
 class GitSquashTool:
     name = "git_squash_agent"
@@ -49,18 +51,20 @@ class GitSquashTool:
             PrettyOutput.print(f"压缩提交失败: {str(e)}", OutputType.WARNING)
 
 
-def main():
+@app.command()
+def cli(
+    commit_hash: str = typer.Argument(..., help="Base commit hash to squash from"),
+    lang: str = typer.Option("Chinese", "--lang", help="Language for commit messages"),
+):
     init_env("欢迎使用 Jarvis-GitSquash，您的Git压缩助手已准备就绪！")
-    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()
-    tool.execute({"commit_hash": args.commit_hash, "lang": args.lang})
+    tool.execute({"commit_hash": commit_hash, "lang": lang})
+
+
+def main():
+    """Application entry point"""
+    app()
 
 
 if __name__ == "__main__":
-    sys.exit(main())
+    main()