myagent-ai 1.13.2 → 1.13.4

package/memory/manager.py

@@ -633,6 +633,62 @@ class MemoryManager:
     # 记忆搜索
     # ==========================================================================
 
+    # ==========================================================================
+    # 时间衰减权重 (遗忘曲线)
+    # ==========================================================================
+
+    @staticmethod
+    def _compute_time_weight(created_at: str, half_life_days: float = 30.0) -> float:
+        """
+        计算记忆的时间衰减权重（模拟遗忘曲线）。
+
+        使用指数衰减模型:  weight = e^(-ln(2) * age_days / half_life_days)
+        - 刚创建的记忆权重为 1.0
+        - 经过 half_life_days 后权重降至 0.5
+        - 经过 2 * half_life_days 后权重降至 0.25
+        - 权重永远不会降到 0（长期记忆仍可被召回）
+
+        Args:
+            created_at: 记忆创建时间（ISO 8601 格式，如 "2025-01-15T08:30:00+00:00"）
+            half_life_days: 半衰期天数（默认 30 天）
+                - 7 天: 适合短期会话记忆，快速遗忘
+                - 30 天: 默认值，平衡近期与长期记忆
+                - 90 天: 适合知识型场景，长期保留
+
+        Returns:
+            时间权重值 (0.0 ~ 1.0)
+
+        Examples:
+            >>> _compute_time_weight("2025-04-12T00:00:00+00:00", half_life_days=30)
+            1.0  # 今天的记忆
+            >>> _compute_time_weight("2025-03-13T00:00:00+00:00", half_life_days=30)
+            0.5  # 30天前的记忆
+            >>> _compute_time_weight("2025-02-11T00:00:00+00:00", half_life_days=30)
+            0.25  # 60天前的记忆
+        """
+        if not created_at:
+            return 0.5  # 无时间信息的记忆给中等权重
+
+        try:
+            # 解析 ISO 8601 时间戳
+            created_dt = datetime.fromisoformat(created_at.replace("Z", "+00:00"))
+            now_dt = datetime.now(created_dt.tzinfo) if created_dt.tzinfo else datetime.now()
+
+            age_seconds = (now_dt - created_dt).total_seconds()
+            if age_seconds <= 0:
+                return 1.0  # 未来的时间戳或零延迟
+
+            age_days = age_seconds / 86400.0
+
+            # 指数衰减: e^(-ln(2) * age / half_life)
+            decay = math.exp(-0.693147 * age_days / half_life_days)
+
+            # 限制最低权重为 0.05，确保极老的记忆仍有一丝被召回的可能
+            return max(decay, 0.05)
+        except (ValueError, TypeError, OSError) as e:
+            logger.debug(f"时间衰减计算失败 ({created_at}): {e}")
+            return 0.5  # 解析失败时给中等权重
+
     # ==========================================================================
     # TF-IDF 语义搜索 (无外部依赖)
     # ==========================================================================
@@ -753,21 +809,31 @@ class MemoryManager:
         category: str = "",
         limit: int = 10,
         mode: str = "hybrid",
+        time_decay: bool = True,
+        half_life_days: float = 30.0,
     ) -> List[MemoryEntry]:
         """
-        搜索记忆。
+        搜索记忆（内置遗忘曲线时间衰减）。
 
         支持三种搜索模式:
           - "keyword": 传统 LIKE 关键词匹配（快速）
           - "semantic": TF-IDF 语义搜索（理解语义相似性）
           - "hybrid": 混合搜索（默认）= 0.4 * keyword_score + 0.6 * tfidf_score
 
+        所有模式均支持时间衰减权重（遗忘曲线），越久远的记忆权重越低。
+        最终得分 = 相关性得分 × 时间权重。
+
         Args:
             query: 搜索查询
             session_id: 会话 ID（空=所有会话）
             category: 记忆类别（空=所有类别）
             limit: 返回数量
             mode: 搜索模式 "keyword" | "semantic" | "hybrid"
+            time_decay: 是否启用时间衰减（默认 True）
+            half_life_days: 遗忘曲线半衰期天数（默认 30 天）
+                - 7 天: 短期记忆场景，快速遗忘
+                - 30 天: 默认，平衡近期与长期
+                - 90 天: 知识型场景，长期保留
         """
         conn = self._get_conn()
         conditions = ["1=1"]
@@ -787,26 +853,38 @@ class MemoryManager:
         where = " AND ".join(conditions)
 
         if mode == "keyword":
-            return self._search_keyword(conn, query, where, params, limit)
+            return self._search_keyword(conn, query, where, params, limit,
+                                         time_decay=time_decay, half_life_days=half_life_days)
         elif mode == "semantic":
-            return self._search_semantic(conn, query, where, params, limit)
+            return self._search_semantic(conn, query, where, params, limit,
+                                         time_decay=time_decay, half_life_days=half_life_days)
         else:
-            # 混合模式：取两种搜索结果的加权和
-            keyword_results = self._search_keyword(conn, query, where, params, limit * 2)
-            semantic_results = self._search_semantic(conn, query, where, params, limit * 2)
+            # 混合模式：取两种搜索结果的加权和 + 时间衰减
+            keyword_results = self._search_keyword(conn, query, where, params, limit * 2,
+                                                   time_decay=False, half_life_days=half_life_days)
+            semantic_results = self._search_semantic(conn, query, where, params, limit * 2,
+                                                     time_decay=False, half_life_days=half_life_days)
 
-            # 合并评分
+            # 合并评分（相关性 + 时间衰减）
             combined: Dict[str, Tuple[MemoryEntry, float]] = {}
             for i, entry in enumerate(keyword_results):
-                score = 1.0 - (i / max(len(keyword_results), 1))
-                combined[entry.id] = (entry, score * 0.4)
+                relevance = 1.0 - (i / max(len(keyword_results), 1))
+                score = relevance * 0.4
+                combined[entry.id] = (entry, score)
 
             for i, entry in enumerate(semantic_results):
-                score = 1.0 - (i / max(len(semantic_results), 1))
+                relevance = 1.0 - (i / max(len(semantic_results), 1))
+                sem_score = relevance * 0.6
                 if entry.id in combined:
-                    combined[entry.id] = (entry, combined[entry.id][1] + score * 0.6)
+                    combined[entry.id] = (entry, combined[entry.id][1] + sem_score)
                 else:
-                    combined[entry.id] = (entry, score * 0.6)
+                    combined[entry.id] = (entry, sem_score)
+
+            # 应用时间衰减权重: final_score = relevance_score × time_weight
+            if time_decay:
+                for mem_id, (entry, relevance_score) in combined.items():
+                    tw = self._compute_time_weight(entry.created_at, half_life_days)
+                    combined[mem_id] = (entry, relevance_score * tw)
 
             # 按综合得分排序
             sorted_results = sorted(
@@ -832,28 +910,45 @@ class MemoryManager:
         where: str,
         params: list,
         limit: int,
+        time_decay: bool = False,
+        half_life_days: float = 30.0,
     ) -> List[MemoryEntry]:
-        """关键词 LIKE 搜索"""
+        """关键词 LIKE 搜索（支持时间衰减重排序）"""
         like_pattern = f"%{query}%"
         conditions = f"{where} AND (content LIKE ? OR summary LIKE ? OR key LIKE ?)"
         search_params = params + [like_pattern, like_pattern, like_pattern]
 
+        # 取更多候选（后续按时间衰减重排序）
+        fetch_limit = limit * 3 if time_decay else limit
         sql = f"""
             SELECT * FROM memories WHERE {conditions}
             ORDER BY importance DESC, access_count DESC
             LIMIT ?
         """
-        search_params.append(limit)
+        search_params.append(fetch_limit)
         rows = conn.execute(sql, search_params).fetchall()
 
-        for row in rows:
+        entries = [MemoryEntry.from_row(row) for row in rows]
+
+        # 应用时间衰减重排序
+        if time_decay and entries:
+            scored = []
+            for entry in entries:
+                base_score = entry.importance + entry.access_count * 0.01
+                tw = self._compute_time_weight(entry.created_at, half_life_days)
+                scored.append((entry, base_score * tw))
+            scored.sort(key=lambda x: x[1], reverse=True)
+            entries = [e for e, _ in scored[:limit]]
+
+        # 更新访问计数
+        for entry in entries:
             conn.execute(
                 "UPDATE memories SET access_count = access_count + 1 WHERE id = ?",
-                (row["id"],),
+                (entry.id,),
             )
         conn.commit()
 
-        return [MemoryEntry.from_row(row) for row in rows]
+        return entries
 
     def _search_semantic(
         self,
@@ -862,8 +957,10 @@ class MemoryManager:
         where: str,
         params: list,
         limit: int,
+        time_decay: bool = False,
+        half_life_days: float = 30.0,
     ) -> List[MemoryEntry]:
-        """TF-IDF 语义搜索"""
+        """TF-IDF 语义搜索（支持时间衰减重排序）"""
         # 先取一批候选文档
         candidate_sql = f"SELECT * FROM memories WHERE {where} ORDER BY created_at DESC LIMIT 200"
         rows = conn.execute(candidate_sql, params).fetchall()
@@ -883,6 +980,14 @@ class MemoryManager:
         # 计算 TF-IDF 得分
         scores = self._compute_tfidf(query, documents)
 
+        # 应用时间衰减重排序
+        if time_decay:
+            for doc_id, tfidf_score in scores.items():
+                row = row_map.get(doc_id)
+                if row:
+                    tw = self._compute_time_weight(row["created_at"], half_life_days)
+                    scores[doc_id] = tfidf_score * tw
+
         # 按得分排序，取 top N
         top_ids = list(scores.keys())[:limit]
         result = [MemoryEntry.from_row(row_map[doc_id]) for doc_id in top_ids if doc_id in row_map]
@@ -903,9 +1008,12 @@ class MemoryManager:
         category: str = "",
         limit: int = 20,
         mode: str = "hybrid",
+        time_decay: bool = True,
+        half_life_days: float = 30.0,
     ) -> List[MemoryEntry]:
         """跨会话搜索"""
-        return self.search(query, session_id="", category=category, limit=limit, mode=mode)
+        return self.search(query, session_id="", category=category, limit=limit, mode=mode,
+                          time_decay=time_decay, half_life_days=half_life_days)
 
     # ==========================================================================
     # 记忆总结与维护

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.13.2",
+  "version": "1.13.4",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {

package/web/api_server.py

@@ -1034,23 +1034,25 @@ class ApiServer:
         base_instruction = (
             "你当前处于【执行模式】(Execution Mode)。\n\n"
             "## 核心规则\n"
-            "1. **任务列表（强制）**：每次回复【必须】包含一个 ```tasklist``` 代码块，内含 JSON 数组格式的任务进度。\n"
+            "1. **任务列表（按复杂度决定）**：\n"
+            "   - 如果用户的需求是简单任务（预计操作步骤不超过5步，如：单次查询、简单计算、问答题、格式转换、文件读取等），【不要】使用 ```tasklist```，直接用纯文本回复并执行即可。\n"
+            "   - 只有当任务较复杂（预计需要超过5步操作，如：多文件修改、需要调研+实现+测试、涉及多个模块联动等），才使用 ```tasklist``` 代码块来跟踪进度。\n"
             "   - 格式：```tasklist\\n[{\"text\": \"步骤描述\", \"status\": \"pending\"}]\\n```\n"
             "   - status 可选值：pending(待执行)、running(进行中)、done(已完成)、blocked(受阻)\n"
-            "   - 首次收到任务时，拆分为多个步骤，全部标记为 pending\n"
+            "   - 首次收到复杂任务时，拆分为多个步骤，全部标记为 pending\n"
             "   - 每次执行完一个步骤后，更新对应步骤状态为 done，下一个为 running\n"
             "2. **单步执行（强制）**：每次回复【只能执行一个操作】（一个工具调用、一个代码块或一个技能调用）。\n"
             "   - 执行完一个操作后停下来，等待结果反馈后再决定下一步\n"
             "   - 不要一次性执行多个操作\n"
-            "3. **回复格式**：先写纯文本分析/总结 → 再写 ```tasklist``` 更新进度 → 最后写 ```action``` 执行操作（如有）\n"
-            "4. **任务完成**：当所有步骤都标记为 done 时，用 ```action``` 输出 {\"type\": \"final_answer\", \"content\": \"...\"} 结束任务。\n"
+            "3. **回复格式**：先写纯文本分析/总结 → 如有任务列表则用 ```tasklist``` 更新进度 → 最后用 ```action``` 执行操作（如有）\n"
+            "4. **任务完成**：当使用任务列表且所有步骤都标记为 done 时，用 ```action``` 输出 {\"type\": \"final_answer\", \"content\": \"...\"} 结束任务。简单任务直接回复即可。\n"
         )
 
         # 从内存读取当前任务列表（按 session 隔离）
         store_key = session_id or agent_path
         tasks = self._task_list_store.get(store_key, [])
         if not tasks:
-            return base_instruction + "\n## 当前状态\n暂无任务计划。请先分析用户需求，拆分为具体步骤，然后用 ```tasklist``` 输出计划。"
+            return base_instruction + "\n## 当前状态\n暂无任务计划。如果是简单任务（不超过5步），直接执行即可，无需创建任务列表。如果是复杂任务（超过5步），请先分析用户需求，拆分为具体步骤，然后用 ```tasklist``` 输出计划。"
 
         pending = [f"  - ⏳ {t['text']}" for t in tasks if t.get("status") in ("pending", "running", "blocked")]
         done = [f"  - ✅ {t['text']}" for t in tasks if t.get("status") == "done"]

package/web/ui/chat/chat_main.js

@@ -345,15 +345,10 @@ function initChat() {
     document.getElementById('sendBtn').disabled = !this.value.trim();
     saveDraft();
   });
-  // Load task plan if in exec mode (collapsed by default)
+  // Load task plan if in exec mode (panel stays hidden until tasks exist)
   if (state.chatMode === 'exec') {
-    document.getElementById('taskPanel').classList.remove('hidden');
-    // Ensure task body starts collapsed
-    var taskBody = document.getElementById('taskBody');
-    var taskToggle = document.getElementById('taskToggle');
-    if (taskBody) taskBody.classList.remove('expanded');
-    if (taskToggle) taskToggle.classList.remove('expanded');
-    state.taskPanelExpanded = false;
+    // Don't show task panel by default - it will appear when the LLM creates a task list
+    // document.getElementById('taskPanel').classList.remove('hidden');
     loadTaskPlan();
   }
 
@@ -536,7 +531,10 @@ function setMode(mode) {
   } else {
     chatBtn.className = 'mode-btn';
     execBtn.className = 'mode-btn active-exec';
-    taskPanel.classList.remove('hidden');
+    // Only show task panel if tasks already exist (don't show empty panel)
+    if (state.taskItems.length > 0) {
+      taskPanel.classList.remove('hidden');
+    }
     // Default collapsed when switching to exec mode
     var tb = document.getElementById('taskBody');
     var tt = document.getElementById('taskToggle');
@@ -642,7 +640,7 @@ async function loadTaskPlan() {
     var data = await api(url);
     state.taskItems = data.tasks || [];
     renderTaskList();
-    // Auto-show task panel header if tasks exist (don't auto-expand body)
+    // Show/hide task panel based on whether tasks exist
     const panel = document.getElementById('taskPanel');
     if (panel && state.taskItems.length > 0) {
       panel.classList.remove('hidden');
@@ -651,6 +649,9 @@ async function loadTaskPlan() {
         triggerTaskAutoFade();
       }
       // Don't auto-expand the body - user can click to expand manually
+    } else if (panel) {
+      // Hide panel when no tasks exist
+      panel.classList.add('hidden');
     }
   } catch (e) {
     state.taskItems = [];