jarvis-ai-assistant 0.3.26__py3-none-any.whl → 0.3.27__py3-none-any.whl

jarvis/jarvis_agent/task_analyzer.py

@@ -6,7 +6,7 @@
 from typing import Optional
 
 from jarvis.jarvis_utils.globals import get_interrupt, set_interrupt
-from jarvis.jarvis_utils.input import user_confirm
+
 from jarvis.jarvis_agent.prompts import TASK_ANALYSIS_PROMPT
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
@@ -22,6 +22,12 @@ class TaskAnalyzer:
             agent: Agent实例
         """
         self.agent = agent
+        self._analysis_done = False
+        # 旁路集成事件订阅，失败不影响主流程
+        try:
+            self._subscribe_events()
+        except Exception:
+            pass
 
     def analysis_task(self, satisfaction_feedback: str = ""):
         """分析任务并生成方法论"""
@@ -40,6 +46,13 @@ class TaskAnalyzer:
 
         except Exception as e:
             PrettyOutput.print("分析失败", OutputType.ERROR)
+        finally:
+            # 标记已完成一次分析，避免事件回调重复执行
+            self._analysis_done = True
+            try:
+                self.agent.set_user_data("__task_analysis_done__", True)
+            except Exception:
+                pass
 
     def _prepare_analysis_prompt(self, satisfaction_feedback: str) -> str:
         """准备分析提示"""
@@ -59,8 +72,27 @@ class TaskAnalyzer:
                 if not self._handle_analysis_interrupt(response):
                     break
 
-            # 执行工具调用
-            need_return, self.agent.session.prompt = self.agent._call_tools(response)
+            # 执行工具调用（补充事件：before_tool_call/after_tool_call）
+            try:
+                self.agent.event_bus.emit(
+                    "before_tool_call",
+                    agent=self.agent,
+                    current_response=response,
+                )
+            except Exception:
+                pass
+            need_return, tool_prompt = self.agent._call_tools(response)
+            self.agent.session.prompt = tool_prompt
+            try:
+                self.agent.event_bus.emit(
+                    "after_tool_call",
+                    agent=self.agent,
+                    current_response=response,
+                    need_return=need_return,
+                    tool_prompt=tool_prompt,
+                )
+            except Exception:
+                pass
 
             # 如果没有工具调用或者没有新的提示，退出循环
             if not self.agent.session.prompt:
@@ -73,8 +105,8 @@ class TaskAnalyzer:
             bool: True 继续分析，False 退出分析
         """
         set_interrupt(False)
-        user_input = self.agent.multiline_inputer(
-            f"分析任务期间被中断，请输入用户干预信息："
+        user_input = self.agent._multiline_input(
+            "分析任务期间被中断，请输入用户干预信息：", False
         )
 
         if not user_input:
@@ -98,7 +130,7 @@ class TaskAnalyzer:
 
     def _handle_interrupt_with_tool_calls(self, user_input: str) -> str:
         """处理有工具调用时的中断"""
-        if user_confirm("检测到有工具调用，是否继续处理工具调用？", True):
+        if self.agent.user_confirm("检测到有工具调用，是否继续处理工具调用？", True):
             return f"被用户中断，用户补充信息为：{user_input}\n\n用户同意继续工具调用。"
         else:
             return f"被用户中断，用户补充信息为：{user_input}\n\n检测到有工具调用，但被用户拒绝执行。请根据用户的补充信息重新考虑下一步操作。"
@@ -108,11 +140,11 @@ class TaskAnalyzer:
         satisfaction_feedback = ""
 
         if not auto_completed and self.agent.use_analysis:
-            if user_confirm("您对本次任务的完成是否满意？", True):
+            if self.agent.user_confirm("您对本次任务的完成是否满意？", True):
                 satisfaction_feedback = "\n\n用户对本次任务的完成表示满意。"
             else:
-                feedback = self.agent.multiline_inputer(
-                    "请提供您的反馈意见（可留空直接回车）:"
+                feedback = self.agent._multiline_input(
+                    "请提供您的反馈意见（可留空直接回车）:", False
                 )
                 if feedback:
                     satisfaction_feedback = (
@@ -124,3 +156,50 @@ class TaskAnalyzer:
                     )
 
         return satisfaction_feedback
+
+    # -----------------------
+    # 事件订阅与处理（旁路）
+    # -----------------------
+    def _subscribe_events(self) -> None:
+        bus = self.agent.get_event_bus()  # type: ignore[attr-defined]
+        # 在生成总结前触发（保持与原顺序一致）
+        bus.subscribe("before_summary", self._on_before_summary)
+        # 当无需总结时，作为兜底触发分析
+        bus.subscribe("task_completed", self._on_task_completed)
+
+    def _on_before_summary(self, **payload) -> None:
+        if self._analysis_done:
+            return
+        # 避免与直接调用重复
+        try:
+            if bool(self.agent.get_user_data("__task_analysis_done__")):
+                self._analysis_done = True
+                return
+        except Exception:
+            pass
+        auto_completed = bool(payload.get("auto_completed", False))
+        try:
+            feedback = self.collect_satisfaction_feedback(auto_completed)
+            if getattr(self.agent, "use_analysis", False):
+                self.analysis_task(feedback)
+        except Exception:
+            # 忽略事件处理异常，保证主流程
+            self._analysis_done = True
+
+    def _on_task_completed(self, **payload) -> None:
+        # 当未在 before_summary 阶段执行过时，作为兜底
+        if self._analysis_done:
+            return
+        try:
+            if bool(self.agent.get_user_data("__task_analysis_done__")):
+                self._analysis_done = True
+                return
+        except Exception:
+            pass
+        auto_completed = bool(payload.get("auto_completed", False))
+        try:
+            feedback = self.collect_satisfaction_feedback(auto_completed)
+            if getattr(self.agent, "use_analysis", False):
+                self.analysis_task(feedback)
+        except Exception:
+            self._analysis_done = True

jarvis/jarvis_agent/task_manager.py

@@ -15,6 +15,7 @@ from jarvis.jarvis_agent import (
     user_confirm,
 )
 from jarvis.jarvis_utils.config import get_data_dir
+from jarvis.jarvis_utils.fzf import fzf_select
 
 
 class TaskManager:
@@ -89,6 +90,31 @@ class TaskManager:
         Console().print(table)
         PrettyOutput.print("[0] 跳过预定义任务", OutputType.INFO)
 
+        # Try fzf selection first (with numbered options and a skip option)
+        fzf_list = [f"{0:>3} | 跳过预定义任务"] + [
+            f"{i:>3} | {name}" for i, name in enumerate(task_names, 1)
+        ]
+        selected_str = fzf_select(fzf_list, prompt="选择一个任务编号 (ESC跳过) > ")
+        if selected_str:
+            try:
+                num_part = selected_str.split("|", 1)[0].strip()
+                idx = int(num_part)
+                if idx == 0:
+                    return ""
+                if 1 <= idx <= len(task_names):
+                    selected_task = tasks[task_names[idx - 1]]
+                    PrettyOutput.print(f"将要执行任务:\n {selected_task}", OutputType.INFO)
+                    # 询问是否需要补充信息
+                    need_additional = user_confirm("需要为此任务添加补充信息吗？", default=False)
+                    if need_additional:
+                        additional_input = get_multiline_input("请输入补充信息：")
+                        if additional_input:
+                            selected_task = f"{selected_task}\n\n补充信息:\n{additional_input}"
+                    return selected_task
+            except Exception:
+                # 如果解析失败，则回退到手动输入
+                pass
+
         while True:
             try:
                 choice_str = prompt(

jarvis/jarvis_agent/user_interaction.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+"""
+UserInteractionHandler: 抽象用户交互（多行输入与确认）逻辑，便于将来替换为 TUI/WebUI。
+
+阶段一（最小变更）：
+- 仅提供封装，不直接修改 Agent 的现有调用
+- 后续步骤在 Agent 中以旁路方式接入，保持向后兼容
+"""
+from typing import Callable, Optional
+
+
+
+class UserInteractionHandler:
+    def __init__(
+        self,
+        multiline_inputer: Callable[..., str],
+        confirm_func: Callable[[str, bool], bool],
+    ) -> None:
+        """
+        参数:
+          - multiline_inputer: 提供多行输入的函数，优先支持 (tip, print_on_empty=bool)，兼容仅接受 (tip) 的实现
+          - confirm_func: 用户确认函数 (tip: str, default: bool) -> bool
+        """
+        self._multiline_inputer = multiline_inputer
+        self._confirm = confirm_func
+
+    def multiline_input(self, tip: str, print_on_empty: bool) -> str:
+        """
+        多行输入封装：兼容两类签名
+        1) func(tip, print_on_empty=True/False)
+        2) func(tip)
+        """
+        try:
+            return self._multiline_inputer(tip, print_on_empty=print_on_empty)  # type: ignore[call-arg]
+        except TypeError:
+            return self._multiline_inputer(tip)  # type: ignore[misc]
+
+    def confirm(self, tip: str, default: bool = True) -> bool:
+        """
+        用户确认封装，直接委派
+        """
+        return self._confirm(tip, default)

jarvis/jarvis_code_agent/code_agent.py

@@ -21,6 +21,7 @@ from jarvis.jarvis_tools.registry import ToolRegistry
 from jarvis.jarvis_utils.config import (
     is_confirm_before_apply_patch,
     is_enable_static_analysis,
+    get_git_check_mode,
 )
 from jarvis.jarvis_utils.git_utils import (
     confirm_add_new_files,
@@ -197,6 +198,17 @@ class CodeAgent:
                     missing_configs
                 )
                 PrettyOutput.print(message, OutputType.WARNING)
+                # 通过配置控制严格校验模式（JARVIS_GIT_CHECK_MODE）：
+                # - warn: 仅告警并继续，后续提交可能失败
+                # - strict: 严格模式（默认），直接退出
+                mode = get_git_check_mode().lower()
+                if mode == "warn":
+                    PrettyOutput.print(
+                        "已启用 Git 校验警告模式（JARVIS_GIT_CHECK_MODE=warn），将继续运行。"
+                        "注意：后续提交可能失败，请尽快配置 git user.name 与 user.email。",
+                        OutputType.INFO,
+                    )
+                    return
                 sys.exit(1)
 
         except FileNotFoundError:
@@ -250,7 +262,7 @@ class CodeAgent:
         if has_uncommitted_changes():
 
             git_commiter = GitCommitTool()
-            git_commiter.execute({"prefix": prefix, "suffix": suffix})
+            git_commiter.execute({"prefix": prefix, "suffix": suffix, "agent": self.agent})
 
     def _init_env(self, prefix: str, suffix: str) -> None:
         """初始化环境，组合以下功能：
@@ -510,7 +522,7 @@ class CodeAgent:
                 check=True,
             )
             git_commiter = GitCommitTool()
-            git_commiter.execute({"prefix": prefix, "suffix": suffix})
+            git_commiter.execute({"prefix": prefix, "suffix": suffix, "agent": self.agent})
 
             # 在用户接受commit后，根据配置决定是否保存记忆
             if self.agent.force_save_memory:
@@ -544,7 +556,7 @@ class CodeAgent:
                     f"提交 {i+1}: {commit['hash'][:7]} - {commit['message']} ({len(commit['files'])}个文件)\n"
                     + "\n".join(f"    - {file}" for file in commit["files"][:5])
                     + ("\n    ..." if len(commit["files"]) > 5 else "")
-                    for i, commit in enumerate(commits_info)
+                    for i, commit in enumerate(commits_info[:5])
                 )
                 project_info.append(f"最近提交:\n{commits_str}")
 
@@ -575,6 +587,8 @@ class CodeAgent:
                 PrettyOutput.print(f"执行失败: {str(e)}", OutputType.WARNING)
                 return str(e)
 
+
+
             self._handle_uncommitted_changes()
             end_commit = get_latest_commit_hash()
             commits = self._show_commit_history(start_commit, end_commit)
@@ -615,6 +629,7 @@ class CodeAgent:
 
                 StatsManager.increment("code_modifications", group="code_agent")
 
+
                 # 获取提交信息
                 end_hash = get_latest_commit_hash()
                 commits = get_commits_between(start_hash, end_hash)

jarvis/jarvis_code_agent/lint.py

@@ -27,11 +27,11 @@ LINT_TOOLS = {
     # Go
     ".go": ["go vet"],
     # Python
-    ".py": ["black", "pylint", "mypy"],
-    ".pyw": ["black", "pylint", "mypy"],
-    ".pyi": ["black", "pylint", "mypy"],
-    ".pyx": ["black", "pylint", "mypy"],
-    ".pxd": ["black", "pylint", "mypy"],
+    ".py": ["ruff", "mypy"],
+    ".pyw": ["ruff", "mypy"],
+    ".pyi": ["ruff", "mypy"],
+    ".pyx": ["ruff", "mypy"],
+    ".pxd": ["ruff", "mypy"],
     # Rust
     ".rs": ["cargo clippy", "rustfmt"],
     ".rlib": ["cargo clippy", "rustfmt"],

jarvis/jarvis_data/config_schema.json

@@ -126,8 +126,6 @@
       "description": "常规操作模型名称",
       "default": "deep_seek_v3"
     },
-
-
     "JARVIS_WEB_SEARCH_PLATFORM": {
       "type": "string",
       "description": "Web搜索使用的平台名称",
@@ -160,8 +158,6 @@
               "type": "string",
               "default": "deep_seek_v3"
             },
-
-
             "JARVIS_MAX_INPUT_TOKEN_COUNT": {
               "type": "number",
               "default": 32000
@@ -196,7 +192,6 @@
       "description": "Jarvis数据存储目录路径",
       "default": "~/.jarvis"
     },
-
     "JARVIS_PRETTY_OUTPUT": {
       "type": "boolean",
       "description": "是否启用美化输出",
@@ -292,6 +287,12 @@
       "description": "是否启用立即中断：在对话迭代中检测到中断信号时立即返回",
       "default": false
     },
+    "JARVIS_GIT_CHECK_MODE": {
+      "type": "string",
+      "enum": ["strict", "warn"],
+      "description": "Git 配置校验模式：strict 表示严格模式（默认），缺失配置时直接退出；warn 表示警告模式，仅提示并继续运行",
+      "default": "strict"
+    },
     "JARVIS_TOOL_GROUP": {
       "type": "string",
       "description": "选择一个预定义的工具配置组",
@@ -445,4 +446,4 @@
     }
   },
   "additionalProperties": true
-}
+}

jarvis/jarvis_git_squash/main.py

@@ -8,6 +8,7 @@ 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
+from jarvis.jarvis_utils.globals import get_agent, current_agent_name
 
 app = typer.Typer(help="Git压缩工具")
 
@@ -46,7 +47,11 @@ class GitSquashTool:
 
             # Use existing GitCommitTool for new commit
             commit_tool = GitCommitTool()
-            commit_tool.execute({"lang": args.get("lang", "Chinese")})
+            agent = get_agent(current_agent_name)
+            exec_args = {"lang": args.get("lang", "Chinese")}
+            if agent:
+                exec_args["agent"] = agent
+            commit_tool.execute(exec_args)
         except Exception as e:
             PrettyOutput.print(f"压缩提交失败: {str(e)}", OutputType.WARNING)
 

jarvis/jarvis_git_utils/git_commiter.py

@@ -163,6 +163,9 @@ commit信息
 {ct("COMMIT_MESSAGE")}
                 """
 
+                # 优先从调用方传入的 agent 获取平台与模型
+                agent_from_args = args.get("agent")
+
                 # Get model_group from args
                 model_group = args.get("model_group")
 
@@ -172,21 +175,44 @@ commit信息
                     get_normal_model_name,
                 )
 
-                platform_name = get_normal_platform_name(model_group)
-                model_name = get_normal_model_name(model_group)
+                platform_name = None
+                model_name = None
 
-                # If no explicit parameters, try to get from existing agent
-                agent = get_agent(current_agent_name)
                 if (
-                    not platform_name
-                    and agent
-                    and hasattr(agent, "model")
-                    and agent.model
+                    agent_from_args
+                    and hasattr(agent_from_args, "model")
+                    and getattr(agent_from_args, "model", None)
                 ):
-                    platform_name = agent.model.platform_name()
-                    model_name = agent.model.name()
-                    if not model_group:
-                        model_group = agent.model.model_group
+                    try:
+                        platform_name = agent_from_args.model.platform_name()
+                        model_name = agent_from_args.model.name()
+                        if not model_group and hasattr(
+                            agent_from_args.model, "model_group"
+                        ):
+                            model_group = agent_from_args.model.model_group
+                    except Exception:
+                        # 安全回退到后续逻辑
+                        platform_name = None
+                        model_name = None
+
+                # 如果未能从agent获取到，再根据 model_group 获取
+                if not platform_name:
+                    platform_name = get_normal_platform_name(model_group)
+                if not model_name:
+                    model_name = get_normal_model_name(model_group)
+
+                # If no explicit parameters, try to get from existing global agent
+                if not platform_name:
+                    agent = get_agent(current_agent_name)
+                    if (
+                        agent
+                        and hasattr(agent, "model")
+                        and getattr(agent, "model", None)
+                    ):
+                        platform_name = agent.model.platform_name()
+                        model_name = agent.model.name()
+                        if not model_group and hasattr(agent.model, "model_group"):
+                            model_group = agent.model.model_group
 
                 # Create a new platform instance
                 if platform_name:

jarvis/jarvis_platform/base.py

@@ -188,12 +188,11 @@ class BasePlatform(ABC):
 
                                 # If content overflows, truncate to show only the last few lines
                                 if len(lines) > max_text_height:
-                                    new_text = "\n".join(
-                                        text_content.plain.splitlines()[
-                                            -max_text_height:
-                                        ]
+                                    # Rebuild the text from the wrapped lines to ensure visual consistency
+                                    # This correctly handles both wrapped long lines and explicit newlines
+                                    text_content.plain = "\n".join(
+                                        [line.plain for line in lines[-max_text_height:]]
                                     )
-                                    text_content.plain = new_text
 
                                 panel.subtitle = (
                                     "[yellow]正在回答... (按 Ctrl+C 中断)[/yellow]"

jarvis/jarvis_platform_manager/main.py

@@ -18,6 +18,7 @@ from jarvis.jarvis_utils.input import get_multiline_input, get_single_line_input
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import init_env
 from jarvis.jarvis_platform_manager.service import start_service
+from jarvis.jarvis_utils.fzf import fzf_select
 
 app = typer.Typer(help="Jarvis AI 平台")
 
@@ -451,17 +452,33 @@ def role_command(
     )
     PrettyOutput.print(output_str, OutputType.INFO)
 
-    # 让用户选择角色
-    raw_choice = get_single_line_input("请选择角色(输入编号，直接回车退出): ")
-    if not raw_choice.strip():
-        PrettyOutput.print("已取消，退出程序", OutputType.INFO)
-        raise typer.Exit(code=0)
-    try:
-        choice = int(raw_choice)
-        selected_role = config["roles"][choice - 1]
-    except (ValueError, IndexError):
-        PrettyOutput.print("无效的选择", OutputType.ERROR)
-        return
+    # 让用户选择角色（优先 fzf，回退编号输入）
+    selected_role = None  # type: ignore[var-annotated]
+    fzf_options = [
+        f"{i:>3} | {role['name']} - {role.get('description', '')}"
+        for i, role in enumerate(config["roles"], 1)
+    ]
+    selected_str = fzf_select(fzf_options, prompt="选择角色编号 (Enter退出) > ")
+    if selected_str:
+        try:
+            num_part = selected_str.split("|", 1)[0].strip()
+            idx = int(num_part)
+            if 1 <= idx <= len(config["roles"]):
+                selected_role = config["roles"][idx - 1]
+        except Exception:
+            selected_role = None
+
+    if selected_role is None:
+        raw_choice = get_single_line_input("请选择角色(输入编号，直接回车退出): ")
+        if not raw_choice.strip():
+            PrettyOutput.print("已取消，退出程序", OutputType.INFO)
+            raise typer.Exit(code=0)
+        try:
+            choice = int(raw_choice)
+            selected_role = config["roles"][choice - 1]
+        except (ValueError, IndexError):
+            PrettyOutput.print("无效的选择", OutputType.ERROR)
+            return
 
 
 

jarvis/jarvis_stats/cli.py

@@ -98,11 +98,6 @@ def inc(
 @app.command()
 def show(
     metric: Optional[str] = typer.Argument(None, help="指标名称，不指定则显示所有"),
-    last_hours: Optional[int] = typer.Option(None, "--hours", "-h", help="最近N小时"),
-    last_days: Optional[int] = typer.Option(None, "--days", "-d", help="最近N天"),
-    format: str = typer.Option(
-        "table", "--format", "-f", help="显示格式: table/chart/summary"
-    ),
     aggregation: str = typer.Option(
         "hourly", "--agg", "-a", help="聚合方式: hourly/daily"
     ),
@@ -123,9 +118,7 @@ def show(
 
     stats.show(
         metric_name=metric,
-        last_hours=last_hours,
-        last_days=last_days,
-        format=format,
+
         aggregation=aggregation,
         tags=tag_dict if tag_dict else None,
     )
@@ -136,8 +129,6 @@ def plot(
     metric: Optional[str] = typer.Argument(
         None, help="指标名称（可选，不指定则根据标签过滤所有匹配的指标）"
     ),
-    last_hours: Optional[int] = typer.Option(None, "--hours", "-h", help="最近N小时"),
-    last_days: Optional[int] = typer.Option(None, "--days", "-d", help="最近N天"),
     aggregation: str = typer.Option(
         "hourly", "--agg", "-a", help="聚合方式: hourly/daily"
     ),
@@ -160,8 +151,6 @@ def plot(
 
     stats.plot(
         metric_name=metric,
-        last_hours=last_hours,
-        last_days=last_days,
         aggregation=aggregation,
         width=width,
         height=height,
@@ -260,9 +249,9 @@ def clean(
 @app.command()
 def export(
     metric: str = typer.Argument(..., help="指标名称"),
-    output: str = typer.Option("csv", "--format", "-f", help="输出格式: csv/json"),
-    last_hours: Optional[int] = typer.Option(None, "--hours", "-h", help="最近N小时"),
-    last_days: Optional[int] = typer.Option(None, "--days", "-d", help="最近N天"),
+
+
+
     tags: Optional[List[str]] = typer.Option(
         None, "--tag", "-t", help="标签过滤，格式: key=value"
     ),
@@ -285,27 +274,19 @@ def export(
     # 获取数据
     data = stats.get_stats(
         metric_name=metric,
-        last_hours=last_hours,
-        last_days=last_days,
         tags=tag_dict if tag_dict else None,
     )
 
-    if output == "json":
-        # JSON格式输出
-        PrettyOutput.print(
-            json.dumps(data, indent=2, ensure_ascii=False), OutputType.CODE, lang="json"
-        )
+    # CSV格式输出（默认）
+    records = data.get("records", [])
+    if records:
+        writer = csv.writer(sys.stdout)
+        writer.writerow(["timestamp", "value", "tags"])
+        for record in records:
+            tags_str = json.dumps(record.get("tags", {}))
+            writer.writerow([record["timestamp"], record["value"], tags_str])
     else:
-        # CSV格式输出
-        records = data.get("records", [])
-        if records:
-            writer = csv.writer(sys.stdout)
-            writer.writerow(["timestamp", "value", "tags"])
-            for record in records:
-                tags_str = json.dumps(record.get("tags", {}))
-                writer.writerow([record["timestamp"], record["value"], tags_str])
-        else:
-            rprint("[yellow]没有找到数据[/yellow]", file=sys.stderr)
+        rprint("[yellow]没有找到数据[/yellow]", file=sys.stderr)
 
 
 @app.command()