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

jarvis/jarvis_stats/stats.py

@@ -166,32 +166,58 @@ class StatsManager:
             >>> StatsManager.show("response_time", last_days=7, format="chart")  # 图表显示
         """
         # 处理时间范围
-        if end_time is None:
-            end_time = datetime.now()
-
-        if start_time is None:
-            if last_hours:
-                start_time = end_time - timedelta(hours=last_hours)
-            elif last_days:
-                start_time = end_time - timedelta(days=last_days)
-            else:
-                start_time = end_time - timedelta(days=7)  # 默认7天
+        # 当未提供时间过滤参数时，默认显示全历史数据
+        all_time = False
+        if last_hours or last_days:
+            if end_time is None:
+                end_time = datetime.now()
+            if start_time is None:
+                if last_hours:
+                    start_time = end_time - timedelta(hours=last_hours)
+                elif last_days:
+                    start_time = end_time - timedelta(days=last_days)
+        else:
+            all_time = True
 
         if metric_name is None:
             # 显示所有指标摘要
             StatsManager._show_metrics_summary(start_time, end_time, tags)
         else:
+            # 基于元数据的 created_at / last_updated 推断全历史时间范围
+            storage = StatsManager._get_storage()
+            if start_time is None or end_time is None:
+                info = storage.get_metric_info(metric_name)
+                if info:
+                    try:
+                        created_at = info.get("created_at")
+                        last_updated = info.get("last_updated")
+                        start_dt = start_time or (
+                            datetime.fromisoformat(created_at) if created_at else datetime.now()
+                        )
+                        end_dt = end_time or (
+                            datetime.fromisoformat(last_updated) if last_updated else datetime.now()
+                        )
+                    except Exception:
+                        start_dt = start_time or (datetime.now() - timedelta(days=7))
+                        end_dt = end_time or datetime.now()
+                else:
+                    start_dt = start_time or (datetime.now() - timedelta(days=7))
+                    end_dt = end_time or datetime.now()
+            else:
+                start_dt = start_time
+                end_dt = end_time
+
             # 根据格式显示数据
             if format == "chart":
                 StatsManager._show_chart(
-                    metric_name, start_time, end_time, aggregation, tags
+                    metric_name, start_dt, end_dt, aggregation, tags
                 )
             elif format == "summary":
                 StatsManager._show_summary(
-                    metric_name, start_time, end_time, aggregation, tags
+                    metric_name, start_dt, end_dt, aggregation, tags
                 )
             else:
-                StatsManager._show_table(metric_name, start_time, end_time, tags)
+                StatsManager._show_table(metric_name, start_dt, end_dt, tags)
 
     @staticmethod
     def plot(
@@ -224,21 +250,44 @@ class StatsManager:
             >>> StatsManager.plot(tags={"service": "api"}, last_days=7)
         """
         # 处理时间范围
-        if end_time is None:
-            end_time = datetime.now()
-
-        if start_time is None:
-            if last_hours:
-                start_time = end_time - timedelta(hours=last_hours)
-            elif last_days:
-                start_time = end_time - timedelta(days=last_days)
-            else:
-                start_time = end_time - timedelta(days=7)
+        # 当未提供时间过滤参数时，默认使用全历史数据
+        if last_hours or last_days:
+            if end_time is None:
+                end_time = datetime.now()
+            if start_time is None:
+                if last_hours:
+                    start_time = end_time - timedelta(hours=last_hours)
+                elif last_days:
+                    start_time = end_time - timedelta(days=last_days)
 
         # 如果指定了metric_name，显示单个图表
         if metric_name:
+            # 基于元数据的 created_at / last_updated 推断全历史时间范围
+            storage = StatsManager._get_storage()
+            if start_time is None or end_time is None:
+                info = storage.get_metric_info(metric_name)
+                if info:
+                    try:
+                        created_at = info.get("created_at")
+                        last_updated = info.get("last_updated")
+                        start_dt = start_time or (
+                            datetime.fromisoformat(created_at) if created_at else datetime.now()
+                        )
+                        end_dt = end_time or (
+                            datetime.fromisoformat(last_updated) if last_updated else datetime.now()
+                        )
+                    except Exception:
+                        start_dt = start_time or (datetime.now() - timedelta(days=7))
+                        end_dt = end_time or datetime.now()
+                else:
+                    start_dt = start_time or (datetime.now() - timedelta(days=7))
+                    end_dt = end_time or datetime.now()
+            else:
+                start_dt = start_time
+                end_dt = end_time
+
             StatsManager._show_chart(
-                metric_name, start_time, end_time, aggregation, tags, width, height
+                metric_name, start_dt, end_dt, aggregation, tags, width, height
             )
         else:
             # 如果没有指定metric_name，根据标签过滤获取所有匹配的指标
@@ -272,32 +321,53 @@ class StatsManager:
             统计数据字典
         """
         # 处理时间范围
-        if end_time is None:
-            end_time = datetime.now()
-
-        if start_time is None:
-            if last_hours:
-                start_time = end_time - timedelta(hours=last_hours)
-            elif last_days:
-                start_time = end_time - timedelta(days=last_days)
-            else:
-                start_time = end_time - timedelta(days=7)
+        # 当未提供时间过滤参数时，返回全历史数据
+        if last_hours or last_days or start_time is not None:
+            if end_time is None:
+                end_time = datetime.now()
+            if start_time is None:
+                if last_hours:
+                    start_time = end_time - timedelta(hours=last_hours)
+                elif last_days:
+                    start_time = end_time - timedelta(days=last_days)
 
         storage = StatsManager._get_storage()
+
+        # 基于元数据推断全历史范围（当未提供时间过滤参数时）
+        start_dt = start_time
+        end_dt = end_time
+        if start_dt is None or end_dt is None:
+            info = storage.get_metric_info(metric_name)
+            if info:
+                try:
+                    created_at = info.get("created_at")
+                    last_updated = info.get("last_updated")
+                    if start_dt is None and created_at:
+                        start_dt = datetime.fromisoformat(created_at)
+                    if end_dt is None and last_updated:
+                        end_dt = datetime.fromisoformat(last_updated)
+                except Exception:
+                    pass
+        if start_dt is None:
+            start_dt = datetime.now() - timedelta(days=7)
+        if end_dt is None:
+            end_dt = datetime.now()
+
         if aggregation:
-            # 返回聚合数据
+            # 返回聚合数据（按推断的全历史时间范围）
             return storage.aggregate_metrics(
-                metric_name, start_time, end_time, aggregation, tags
+                metric_name, start_dt, end_dt, aggregation, tags
             )
         else:
-            # 返回原始数据
-            records = storage.get_metrics(metric_name, start_time, end_time, tags)
+            # 返回原始数据（全历史或指定范围）
+            records = storage.get_metrics(metric_name, start_dt, end_dt, tags)
+
             return {
                 "metric": metric_name,
                 "records": records,
                 "count": len(records),
-                "start_time": start_time.isoformat(),
-                "end_time": end_time.isoformat(),
+                "start_time": start_dt.isoformat(),
+                "end_time": end_dt.isoformat(),
             }
 
     @staticmethod
@@ -343,24 +413,56 @@ class StatsManager:
             console.print("[yellow]没有找到任何统计指标[/yellow]")
             return
 
-        # 如果没有指定时间范围，使用默认值
-        if end_time is None:
-            end_time = datetime.now()
-        if start_time is None:
-            start_time = end_time - timedelta(days=7)
+        # 如果未指定时间范围且两者皆为 None，则表示使用全历史数据
+        all_time = False
+        if start_time is None and end_time is None:
+            all_time = True
+        else:
+            if end_time is None:
+                end_time = datetime.now()
+            if start_time is None:
+                start_time = end_time - timedelta(days=7)
+
+
+
+        # 计算时间范围列标题
+        if start_time is None or end_time is None:
+            period_label = "值"
+        else:
+            delta = end_time - start_time
+            if delta.days >= 1:
+                period_label = f"{delta.days}天数据点"
+            else:
+                hours = max(1, int(delta.total_seconds() // 3600))
+                period_label = f"{hours}小时数据点"
 
         # 创建表格
         table = Table(title="统计指标摘要")
         table.add_column("指标名称", style="cyan")
         table.add_column("单位", style="green")
         table.add_column("最后更新", style="yellow")
-        table.add_column("7天数据点", style="magenta")
+        table.add_column(period_label, style="magenta")
 
         # 过滤满足标签条件的指标
         displayed_count = 0
         for metric in metrics:
-            # 获取该指标的记录
-            records = storage.get_metrics(metric, start_time, end_time, tags)
+            # 获取该指标的记录（全历史或指定范围）
+            if 'all_time' in locals() and all_time:
+                _start = None
+                _end = None
+                try:
+                    info = storage.get_metric_info(metric)
+                    if info:
+                        ca = info.get("created_at")
+                        lu = info.get("last_updated")
+                        _start = datetime.fromisoformat(ca) if ca else None
+                        _end = datetime.fromisoformat(lu) if lu else None
+                except Exception:
+                    _start = None
+                    _end = None
+                records = storage.get_metrics(metric, _start, _end, tags)
+            else:
+                records = storage.get_metrics(metric, start_time, end_time, tags)
 
             # 如果指定了标签过滤，但没有匹配的记录，跳过该指标
             if tags and len(records) == 0:
@@ -382,8 +484,14 @@ class StatsManager:
                     except:
                         pass
 
-            count = len(records)
-            table.add_row(metric, unit, last_updated, str(count))
+            total_value = sum(r.get("value", 0) for r in records)
+            # 智能格式化，如果是整数则不显示小数点
+            if total_value == int(total_value):
+                value_to_display = str(int(total_value))
+            else:
+                value_to_display = f"{total_value:.2f}"
+
+            table.add_row(metric, unit, last_updated, value_to_display)
             displayed_count += 1
 
         if displayed_count == 0:
@@ -532,8 +640,28 @@ class StatsManager:
             if i > 0:
                 console.print("\n" + "=" * 80 + "\n")  # 分隔符
 
+            # 计算该指标的有效时间范围（基于元数据推断全历史）
+            _start = start_time
+            _end = end_time
+            if _start is None or _end is None:
+                info = storage.get_metric_info(metric)
+                if info:
+                    try:
+                        ca = info.get("created_at")
+                        lu = info.get("last_updated")
+                        if _start is None and ca:
+                            _start = datetime.fromisoformat(ca)
+                        if _end is None and lu:
+                            _end = datetime.fromisoformat(lu)
+                    except Exception:
+                        pass
+                if _start is None:
+                    _start = datetime.now() - timedelta(days=7)
+                if _end is None:
+                    _end = datetime.now()
+
             StatsManager._show_chart(
-                metric, start_time, end_time, aggregation, tags, width, height
+                metric, _start, _end, aggregation, tags, width, height
             )
 
     @staticmethod

jarvis/jarvis_tools/registry.py

@@ -839,6 +839,21 @@ class ToolRegistry(OutputHandlerProtocol):
             # 执行工具调用（根据工具实现的协议版本，由系统在内部决定agent的传递方式）
             result = self.execute_tool(name, args, agent)
 
+            # 记录本轮实际执行的工具，供上层逻辑（如记忆保存判定）使用
+            try:
+                from jarvis.jarvis_agent import Agent  # 延迟导入避免循环依赖
+                agent_instance_for_record: Agent = agent_instance
+                # 记录最后一次执行的工具
+                agent_instance_for_record.set_user_data("__last_executed_tool__", name)  # type: ignore
+                # 记录本轮累计执行的工具列表
+                executed_list = agent_instance_for_record.get_user_data("__executed_tools__")  # type: ignore
+                if not isinstance(executed_list, list):
+                    executed_list = []
+                executed_list.append(name)
+                agent_instance_for_record.set_user_data("__executed_tools__", executed_list)  # type: ignore
+            except Exception:
+                pass
+
             # 格式化输出
             output = self._format_tool_output(
                 result["stdout"], result.get("stderr", "")

jarvis/jarvis_tools/sub_agent.py

@@ -4,15 +4,16 @@ sub_agent 工具
 将子任务交给通用 Agent 执行，并返回执行结果。
 
 约定：
-- 仅接收一个参数：task
-- 不依赖父 Agent，所有配置使用系统默认与全局变量
+- 必填参数：task, name, background, system_prompt, summary_prompt, use_tools
+- 继承父 Agent 的部分配置：model_group、input_handler、execute_tool_confirm、multiline_inputer；其他参数需显式提供
 - 子Agent必须自动完成(auto_complete=True)且需要summary(need_summary=True)
 """
 from typing import Any, Dict, Optional
 import json
 
-from jarvis.jarvis_agent import Agent, origin_agent_system_prompt
+from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_utils.globals import delete_agent
+from jarvis.jarvis_tools.registry import ToolRegistry
 
 
 class SubAgentTool:
@@ -25,7 +26,7 @@ class SubAgentTool:
 
     # 必须与文件名一致，供 ToolRegistry 自动注册
     name = "sub_agent"
-    description = "将子任务交给通用 Agent 执行，并返回执行结果（使用系统默认配置，自动完成并生成总结）。"
+    description = "将子任务交给通用 Agent 执行，并返回执行结果（继承父Agent部分配置：model_group、input_handler、execute_tool_confirm、multiline_inputer；其他参数需显式提供，自动完成并生成总结）。"
     parameters = {
         "type": "object",
         "properties": {
@@ -33,12 +34,42 @@ class SubAgentTool:
                 "type": "string",
                 "description": "要执行的子任务内容（必填）",
             },
+            "name": {
+                "type": "string",
+                "description": "子Agent名称（必填）",
+            },
             "background": {
                 "type": "string",
-                "description": "任务背景与已知信息（可选，将与任务一并提供给子Agent）",
+                "description": "任务背景与已知信息（必填，将与任务一并提供给子Agent）",
+            },
+            "system_prompt": {
+                "type": "string",
+                "description": "覆盖子Agent的系统提示词（必填）",
+            },
+            "summary_prompt": {
+                "type": "string",
+                "description": "覆盖子Agent的总结提示词（必填）",
+            },
+            "use_tools": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "限制子Agent可用的工具名称列表（必填）。兼容以逗号分隔的字符串输入。可用的工具列表："
+                + "\n".join(
+                    [
+                        t["name"] + ": " + t["description"]
+                        for t in ToolRegistry().get_all_tools()
+                    ]
+                ),
             },
         },
-        "required": ["task"],
+        "required": [
+            "task",
+            "name",
+            "background",
+            "system_prompt",
+            "summary_prompt",
+            "use_tools",
+        ],
     }
 
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
@@ -64,104 +95,83 @@ class SubAgentTool:
                 f"背景信息:\n{background}\n\n任务:\n{task}" if background else task
             )
 
-            # 继承父Agent的运行参数（用于覆盖默认值）；若无父Agent则使用默认/全局配置
-            parent_agent = args.get("agent")
-            # 如未注入父Agent，尝试从全局获取当前或任一已注册Agent
-            if parent_agent is None:
-                try:
-                    from jarvis.jarvis_utils import globals as G  # 延迟导入避免循环
-
-                    curr = getattr(G, "current_agent_name", "")
-                    if curr:
-                        parent_agent = getattr(G, "global_agents", {}).get(curr)
-                    if parent_agent is None and getattr(G, "global_agents", {}):
-                        try:
-                            parent_agent = next(iter(G.global_agents.values()))
-                        except Exception:
-                            parent_agent = None
-                except Exception:
-                    parent_agent = None
-            # 默认/全局
-            system_prompt = origin_agent_system_prompt
+            # 不继承父Agent，所有关键参数必须由调用方显式提供
             need_summary = True
             auto_complete = True
 
-            # 可继承参数
-            model_group = None
-            summary_prompt = None
-            execute_tool_confirm = None
-            use_methodology = None
-            use_analysis = None
-            force_save_memory = None
+            # 读取并校验必填参数
+            system_prompt = str(args.get("system_prompt", "")).strip()
+            summary_prompt = str(args.get("summary_prompt", "")).strip()
+            agent_name = str(args.get("name", "")).strip()
+
+            # 解析可用工具列表（支持数组或以逗号分隔的字符串）
+            _use_tools = args.get("use_tools", None)
             use_tools: list[str] = []
+            if isinstance(_use_tools, list):
+                use_tools = [str(x).strip() for x in _use_tools if str(x).strip()]
+            elif isinstance(_use_tools, str):
+                use_tools = [s.strip() for s in _use_tools.split(",") if s.strip()]
+            else:
+                use_tools = []
+
+            errors = []
+            if not system_prompt:
+                errors.append("system_prompt 不能为空")
+            if not summary_prompt:
+                errors.append("summary_prompt 不能为空")
+            if not agent_name:
+                errors.append("name 不能为空")
+            if not use_tools:
+                errors.append("use_tools 不能为空")
+            if not background:
+                errors.append("background 不能为空")
+
+            if errors:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "; ".join(errors),
+                }
 
+            # 基于父Agent（如有）继承部分配置后创建子Agent
+            parent_agent = args.get("agent", None)
+            parent_model_group = None
+            parent_input_handler = None
+            parent_execute_tool_confirm = None
+            parent_multiline_inputer = None
             try:
                 if parent_agent is not None:
-                    # 继承模型组
                     if getattr(parent_agent, "model", None):
-                        model_group = getattr(parent_agent.model, "model_group", None)
-                    # 继承开关类参数
-                    summary_prompt = getattr(parent_agent, "summary_prompt", None)
-                    execute_tool_confirm = getattr(
-                        parent_agent, "execute_tool_confirm", None
-                    )
-                    use_methodology = getattr(parent_agent, "use_methodology", None)
-                    use_analysis = getattr(parent_agent, "use_analysis", None)
-                    force_save_memory = getattr(parent_agent, "force_save_memory", None)
-                    # 继承工具使用集（名称列表）
-                    parent_registry = parent_agent.get_tool_registry()
-                    if parent_registry:
-                        for t in parent_registry.get_all_tools():
-                            if isinstance(t, dict) and t.get("name"):
-                                use_tools.append(str(t["name"]))
+                        parent_model_group = getattr(parent_agent.model, "model_group", None)
+                    parent_input_handler = getattr(parent_agent, "input_handler", None)
+                    parent_execute_tool_confirm = getattr(parent_agent, "execute_tool_confirm", None)
+                    parent_multiline_inputer = getattr(parent_agent, "multiline_inputer", None)
             except Exception:
-                # 忽略继承失败，退回默认配置
+                # 安全兜底：无法从父Agent获取配置则保持为None，使用系统默认
                 pass
 
-            # 为避免交互阻塞：提供自动确认与空输入处理器
-            def _auto_confirm(tip: str, default: bool = True) -> bool:
-                return default
-
-            # 创建子Agent（其余配置使用默认/全局）
             agent = Agent(
                 system_prompt=system_prompt,
-                name="SubAgent",
+                name=agent_name,
                 description="Temporary sub agent for executing a subtask",
-
-                model_group=model_group,  # 继承父Agent模型组（如可用）
-                summary_prompt=summary_prompt,  # 继承父Agent总结提示词（如可用）
+                model_group=parent_model_group,
+                summary_prompt=summary_prompt,
                 auto_complete=auto_complete,
-                output_handler=None,  # 默认 ToolRegistry
-                use_tools=None,  # 初始不限定，稍后同步父Agent工具集
-                input_handler=None,  # 允许使用系统默认输入链
-                execute_tool_confirm=execute_tool_confirm,  # 继承父Agent（如可用）
+                output_handler=None,
+                use_tools=None,
+                input_handler=parent_input_handler,
+                execute_tool_confirm=parent_execute_tool_confirm,
                 need_summary=need_summary,
-                multiline_inputer=None,  # 使用系统默认输入器（允许用户输入）
-                use_methodology=use_methodology,  # 继承父Agent（如可用）
-                use_analysis=use_analysis,  # 继承父Agent（如可用）
-                force_save_memory=force_save_memory,  # 继承父Agent（如可用）
+                multiline_inputer=parent_multiline_inputer,
+                use_methodology=None,
+                use_analysis=None,
+                force_save_memory=None,
                 files=None,
-                confirm_callback=_auto_confirm,  # 自动确认
             )
 
-            # 同步父Agent的模型名称与工具使用集（若可用）
+            # 设置可用工具列表
             try:
-                if (
-                    parent_agent is not None
-                    and getattr(parent_agent, "model", None)
-                    and getattr(agent, "model", None)
-                ):
-                    try:
-                        model_name = parent_agent.model.name()  # type: ignore[attr-defined]
-                        if model_name:
-                            from typing import Any
-                            model_obj: Any = getattr(agent, "model", None)
-                            if model_obj is not None:
-                                model_obj.set_model_name(model_name)
-                    except Exception:
-                        pass
-                if use_tools:
-                    agent.set_use_tools(use_tools)
+                agent.set_use_tools(use_tools)
             except Exception:
                 pass
 

jarvis/jarvis_tools/sub_code_agent.py

@@ -13,7 +13,7 @@ import json
 
 from jarvis.jarvis_code_agent.code_agent import CodeAgent
 from jarvis.jarvis_utils.globals import delete_agent
-from jarvis.jarvis_code_agent import code_agent as code_agent_module
+from jarvis.jarvis_utils.config import set_config, get_git_check_mode
 
 
 class SubCodeAgentTool:
@@ -59,11 +59,6 @@ class SubCodeAgentTool:
                     "stderr": "task 不能为空",
                 }
 
-            # 在模块级别打补丁，仅自动确认交互（允许用户输入）
-            def _auto_confirm(tip: str, default: bool = True) -> bool:
-                return default
-
-            code_agent_module.user_confirm = _auto_confirm
 
             # 读取背景信息并组合任务
             background: str = str(args.get("background", "")).strip()
@@ -131,7 +126,12 @@ class SubCodeAgentTool:
             except Exception:
                 append_tools = None
 
+            # 在子Agent中放宽 Git 配置校验，避免因严格校验导致进程退出
+            # 使用配置项将校验模式临时切换为 warn，构造完成后恢复原值
+            old_mode = None
             try:
+                old_mode = get_git_check_mode()
+                set_config("JARVIS_GIT_CHECK_MODE", "warn")
                 code_agent = CodeAgent(
                     model_group=model_group,
                     need_summary=True,
@@ -145,6 +145,12 @@ class SubCodeAgentTool:
                     "stdout": "",
                     "stderr": f"初始化 CodeAgent 失败（可能未配置 git 或当前非 git 仓库）: {se}",
                 }
+            finally:
+                if old_mode is not None:
+                    try:
+                        set_config("JARVIS_GIT_CHECK_MODE", old_mode)
+                    except Exception:
+                        pass
 
             # 子Agent需要自动完成
             try:

jarvis/jarvis_utils/config.py

@@ -423,6 +423,20 @@ def is_enable_static_analysis() -> bool:
     return GLOBAL_CONFIG_DATA.get("JARVIS_ENABLE_STATIC_ANALYSIS", True) is True
 
 
+def get_git_check_mode() -> str:
+    """
+    获取Git校验模式。
+
+    返回:
+        str: "strict" 或 "warn"，默认为 "strict"
+    """
+    mode = GLOBAL_CONFIG_DATA.get("JARVIS_GIT_CHECK_MODE", "strict")
+    try:
+        return str(mode)
+    except Exception:
+        return "strict"
+
+
 def get_mcp_config() -> List[Dict[str, Any]]:
     """
     获取MCP配置列表。