foxclaw 0.1.2 → 0.1.4

package/python/foxclaw/core/web_search.py

@@ -23,40 +23,23 @@ import urllib.error
 from . import settings
 
 
-# 触发联网搜索的关键词:问到实时/时效性信息时才搜
-# ── 是否需要联网:话题信号(强) vs 时间词(弱) vs 个人数据(否决)──────────────
-# 教训:曾把纯时间词(今天/本月/最近…)也当触发,结果「分析一下本月支出」这类**问自己账本**
-# 的任务被误判为需要联网 → 白跑一次 ~22s 的付费深度搜索。而 Foxclaw 的领域(个人财务/
-# 行程/学习)天生满是时间词,这不是个别误判,是**一整类合法任务**在白交时间和钱。
-# 现在:时间词单独**不足以**触发;必须出现"外部世界话题";且个人数据一律否决。
-# (与既有的 now⊂knowledge / current⊂concurrent 词边界修复同源:都是过度触发。)
-
-# 强触发:出现即说明要的是外部实时信息
 TOPIC_TRIGGERS = [
     "版本", "几个版本", "第几", "价格", "多少钱", "汇率", "股价", "新闻",
     "发布", "上线", "更新到", "迭代", "排行", "排名", "天气",
-    # 问"某产品/技术的模型/型号/出没出/更没更"——都是外部时效信息,过去漏搜→编造。
-    # 只留明确指向外部产品的词;"有哪些/可用/支持"太宽(会误伤"我有哪些任务"),不加。
     "模型", "型号", "出了没", "发布没", "更新没", "新版",
     "latest", "news", "version", "price", "models",
 ]
-# 弱信号:纯时间词。单独出现不触发(个人数据问题天生带这些词)
 TIME_WORDS = [
     "最新", "现在", "目前", "今天", "今日", "昨天", "本周", "本月", "今年",
     "最近", "当前", "today", "current", "now",
 ]
-# 否决:问的是用户自己的账/行程/学习/记忆 —— 这些答案在本地领域内核里,不在网上。
-# 注意别放"我的"这类过宽的词:「我的股票现在多少钱」是真需要联网的。
 PERSONAL_MARKERS = [
     "支出", "收入", "预算", "交易", "账单", "花了", "消费", "记账", "结余", "余额",
     "行程", "日程", "出行", "复习", "知识点", "学习计划", "记忆",
 ]
 
-SEARCH_TRIGGERS = TOPIC_TRIGGERS          # 对外保持同名(旧引用不破)
+SEARCH_TRIGGERS = TOPIC_TRIGGERS
 
-# 中文触发词按「子串」匹配(中文无词边界);英文触发词按「词边界」匹配,
-# 否则短词会误命中常见词:"now"⊂"knowledge"、"current"⊂"concurrent"、
-# "now"⊂"known" —— 在这个满口 knowledge 的项目里会频繁无谓地打百度。
 _CJK_TRIGGERS = [k for k in SEARCH_TRIGGERS if not k.isascii()]
 _ASCII_TRIGGERS = [k.lower() for k in SEARCH_TRIGGERS if k.isascii()]
 _ASCII_RE = (
@@ -85,16 +68,12 @@ def needs_search(query: str) -> bool:
         return False
     q = query.lower()
     if is_personal_query(q):
-        return False                      # 问的是自己的数据 → 答案在本地内核,绝不联网
-    # 自我模型/身份问题(你是什么模型 / 你现在是哪个模型 …)→ 由 ModelRouter 运行时注入本地即答,不联网。
-    # 否则会因含"模型"触发词白跑一次 ~20s 百度搜索。"你"与"模型"相邻(≤8字)才算自问;
-    # "你帮我查 X 的模型"(相距远)仍走搜索。
+        return False
     if re.search(r"你[^,。?!]{0,8}模型", q):
         return False
     if any(k in q for k in _CJK_TRIGGERS):
-        return True                       # 外部世界话题 → 联网
+        return True
     return bool(_ASCII_RE and _ASCII_RE.search(q))
-    # 注:只含时间词(今天/本月/最近…)而无话题 → 不触发(见上方 TIME_WORDS 说明)
 
 
 def _key() -> str:
@@ -139,7 +118,7 @@ def _search_answer_inner(query: str, key: str) -> dict:
             "stream": False,
             "model": _model(),
             "enable_deep_search": _deep(),
-            "enable_corner_markers": False,   # 不要答案里的 ^[1]^ 角标(参考资料已单列)
+            "enable_corner_markers": False,
         }).encode("utf-8")
         req = urllib.request.Request(
             f"{_base()}/chat/completions",
@@ -193,7 +172,6 @@ def format_for_prompt(query: str, payload) -> str:
         refs = payload.get("references", [])
         if not answer and not refs:
             return ""
-        # 我方的作答指令(可信,放在 <untrusted> 之外);检索到的外部内容(不可信,放在 <untrusted> 之内)。
         framing = (
             f"以下是针对「{query}」的实时联网搜索结果(来自百度 AI 搜索)。\n"
             f"【严格要求】只能依据下面 <untrusted> 数据块里的搜索结果作答:结果里没有出现的型号 / "
@@ -215,13 +193,11 @@ def format_for_prompt(query: str, payload) -> str:
                 if u:
                     inner += f"\n链接：{u}"
                 inner += f"\n[webpage {i} end]\n"
-        # 隔离外部内容:搜索结果是外部不可控数据,包裹进 <untrusted> 防间接注入(见 injection_guard)。
         from . import injection_guard as _ig
         block = _ig.wrap_untrusted(inner.rstrip(), source="web_search")
         closing = ("\n请**严格基于以上 <untrusted> 内的搜索结果**回答用户的问题;结果里没提到的内容,"
                    "就明确说「搜索结果中未提及」,绝不编造型号/版本号。")
         return framing + block + closing
-    # 列表形式(兼容)
     results = payload or []
     if not results:
         return ""

package/python/foxclaw/finance/evidence.py

@@ -17,9 +17,9 @@ from datetime import datetime
 @dataclass
 class RiskFactor:
     """单个风险因子:是什么、证据、权重。"""
-    factor: str                  # 风险因子名(如"超预算")
-    evidence: str                # 人类可读证据(如"餐饮已用 120%,超 ¥240")
-    weight: float                # 权重 0-1(对总风险的贡献)
+    factor: str
+    evidence: str
+    weight: float
 
     def to_dict(self) -> dict:
         return {"factor": self.factor, "evidence": self.evidence,
@@ -29,14 +29,14 @@ class RiskFactor:
 @dataclass
 class EvidenceChain:
     """结构化决策证据链 —— 财务决策的可审计输出。"""
-    decision_type: str                                  # 决策类型(如 budget_risk / anomaly)
-    risk_score: float = 0.0                             # 综合风险分 0-1
-    risk_factors: list = field(default_factory=list)    # [RiskFactor]
-    mitigating_factors: list = field(default_factory=list)  # 缓解因素(降低风险的)
-    rationale: str = ""                                 # 决策理由(人类可读)
-    recommended_action: str = ""                        # 建议动作
-    confidence: float = 0.0                             # 置信度 0-1
-    additional_checks: list = field(default_factory=list)  # 还需补充的检查
+    decision_type: str
+    risk_score: float = 0.0
+    risk_factors: list = field(default_factory=list)
+    mitigating_factors: list = field(default_factory=list)
+    rationale: str = ""
+    recommended_action: str = ""
+    confidence: float = 0.0
+    additional_checks: list = field(default_factory=list)
     created_at: str = field(default_factory=lambda: datetime.now().isoformat(timespec="seconds"))
 
     def add_factor(self, factor: str, evidence: str, weight: float):
@@ -53,10 +53,10 @@ class EvidenceChain:
             self.risk_score = 0.0
             return 0.0
         weights = sorted((f.weight for f in self.risk_factors), reverse=True)
-        score = weights[0]                          # 最大因子为主
+        score = weights[0]
         for w in weights[1:]:
-            score += w * (1 - score) * 0.5          # 其余因子衰减叠加(饱和,不会超过1)
-        mitigation = min(0.2, 0.1 * len(self.mitigating_factors))  # 缓解最多减0.2
+            score += w * (1 - score) * 0.5
+        mitigation = min(0.2, 0.1 * len(self.mitigating_factors))
         self.risk_score = max(0.0, min(1.0, round(score - mitigation, 3)))
         return self.risk_score
 
@@ -100,7 +100,6 @@ class FinanceExplainer:
             cat = b.get("category", "?")
             if ratio >= 1.0:
                 over = b.get("spent", 0) - b.get("monthly_limit", 0)
-                # 权重随超支程度递增:超10%→0.5,超50%→0.65,超100%+→0.8(上限)
                 w = min(0.8, 0.45 + (ratio - 1.0) * 0.35)
                 ec.add_factor("超预算", f"{cat} 已用 {ratio*100:.0f}%,超支 ¥{over:.0f}",
                               weight=w)
@@ -109,13 +108,11 @@ class FinanceExplainer:
                 ec.add_factor("接近预算上限",
                               f"{cat} 已用 {ratio*100:.0f}%,接近上限", weight=0.25)
                 near_budgets.append(cat)
-        # 缓解因素:有预算分类未超支
         healthy = [b.get("category") for b in budget_status
                    if b.get("usage_ratio", 0) < 0.8]
         if healthy:
             ec.mitigating_factors.append(f"{len(healthy)} 个分类预算健康")
         ec.compute_risk()
-        # 理由 + 建议
         if over_budgets:
             ec.rationale = f"{','.join(over_budgets)} 已超预算,需立即关注"
             ec.recommended_action = f"削减 {over_budgets[0]} 支出或调整预算"
@@ -134,7 +131,6 @@ class FinanceExplainer:
         ec = EvidenceChain(decision_type="anomaly", confidence=0.85)
         for a in anomalies[:5]:
             z = a.get("z_score", 0)
-            # z 分数越高,权重越大(裁剪到 0.6)
             w = min(0.6, 0.15 + z * 0.05)
             ec.add_factor("异常大额支出",
                           f"{a.get('entity','?')} ¥{abs(a.get('amount',0)):.0f}"

package/python/foxclaw/finance/fx.py

@@ -15,7 +15,6 @@ from pathlib import Path
 
 BASE_CURRENCY = "CNY"
 
-# 参考价(1 单位外币 = 多少 CNY)。宁可粗,但要能改。
 DEFAULT_RATES = {
     "CNY": 1.0,
     "USD": 7.2,
@@ -33,7 +32,7 @@ DEFAULT_RATES = {
 class FxTable:
     """币种 → 本位币折算率,带落盘(原子写)。"""
 
-    def __init__(self, path: str = None):
+    def __init__(self, path: str | None = None):
         self.path = Path(path) if path else None
         self.rates = dict(DEFAULT_RATES)
         self.note = "static"
@@ -54,7 +53,6 @@ class FxTable:
                 if data.get("note"):
                     self.note = data["note"]
         except Exception:
-            # 汇率表坏了不能拖垮记账:退回出厂参考价,下次保存时自动覆盖
             pass
 
     def save(self) -> bool:

package/python/foxclaw/finance/graph.py

@@ -18,7 +18,7 @@ from dataclasses import dataclass, field
 @dataclass
 class GraphNode:
     node_id: str
-    node_type: str                 # transaction/category/entity/account/budget
+    node_type: str
     label: str
     attrs: dict = field(default_factory=dict)
 
@@ -31,7 +31,7 @@ class GraphNode:
 class GraphEdge:
     src: str
     dst: str
-    rel: str                       # belongs_to/paid_to/charged_on/monitors
+    rel: str
     attrs: dict = field(default_factory=dict)
 
     def to_dict(self) -> dict:
@@ -45,15 +45,13 @@ class FinancialDataGraph:
     def __init__(self):
         self.nodes: dict[str, GraphNode] = {}
         self.edges: list[GraphEdge] = []
-        self._adj: dict[str, list] = defaultdict(list)        # 出边邻接
-        self._radj: dict[str, list] = defaultdict(list)       # 入边邻接
+        self._adj: dict[str, list] = defaultdict(list)
+        self._radj: dict[str, list] = defaultdict(list)
 
-    # ── 构建 ──
     def _ensure_node(self, node_id: str, node_type: str, label: str, **attrs):
         if node_id not in self.nodes:
             self.nodes[node_id] = GraphNode(node_id, node_type, label, dict(attrs))
         else:
-            # 已存在 → 累加统计类属性
             self.nodes[node_id].attrs.update(attrs)
         return self.nodes[node_id]
 
@@ -63,7 +61,7 @@ class FinancialDataGraph:
         self._adj[src].append(e)
         self._radj[dst].append(e)
 
-    def build(self, transactions: list, budgets: list = None):
+    def build(self, transactions: list, budgets: list | None = None):
         """从交易 + 预算构建图。"""
         self.nodes.clear(); self.edges.clear()
         self._adj.clear(); self._radj.clear()
@@ -73,7 +71,6 @@ class FinancialDataGraph:
             self._ensure_node(tid, "transaction", f"{t.entity} ¥{abs(t.amount):.0f}",
                               amount=t.amount, timestamp=t.timestamp,
                               is_expense=t.is_expense)
-            # 分类节点 + 边(消费统计只累加支出,收入/退款不计入'花费')
             cat_id = f"cat:{t.category}"
             cnode = self._ensure_node(cat_id, "category", t.category)
             if t.is_expense:
@@ -82,19 +79,16 @@ class FinancialDataGraph:
             else:
                 cnode.attrs["income"] = cnode.attrs.get("income", 0) + abs(t.amount)
             self._add_edge(tid, cat_id, "belongs_to")
-            # 商户节点 + 边(同样只把支出计入消费)
             ent_id = f"ent:{t.entity}"
             enode = self._ensure_node(ent_id, "entity", t.entity)
             if t.is_expense:
                 enode.attrs["total"] = enode.attrs.get("total", 0) + abs(t.amount)
                 enode.attrs["count"] = enode.attrs.get("count", 0) + 1
             self._add_edge(tid, ent_id, "paid_to")
-            # 账户节点 + 边
             acc_id = f"acc:{t.account}"
             self._ensure_node(acc_id, "account", t.account)
             self._add_edge(tid, acc_id, "charged_on")
 
-        # 预算节点 + 监管边(预算 monitors 分类)
         for b in (budgets or []):
             bid = f"bud:{b.category}"
             self._ensure_node(bid, "budget", f"{b.category}预算",
@@ -104,8 +98,7 @@ class FinancialDataGraph:
                 self._add_edge(bid, cat_id, "monitors")
         return self
 
-    # ── 查询 ──
-    def neighbors(self, node_id: str, rel: str = None) -> list:
+    def neighbors(self, node_id: str, rel: str | None = None) -> list:
         """出边邻居(可按关系过滤)。"""
         return [self.nodes[e.dst] for e in self._adj.get(node_id, [])
                 if rel is None or e.rel == rel]
@@ -119,11 +112,10 @@ class FinancialDataGraph:
         """某分类下,按消费额排名的商户 —— 回答'这个分类的钱花在谁身上'。"""
         cat_id = f"cat:{category}"
         txns = self.transactions_of(cat_id)
-        by_entity = defaultdict(float)
+        by_entity: defaultdict[str, float] = defaultdict(float)
         for t in txns:
             if not t.attrs.get("is_expense"):
-                continue   # 只统计支出,排除收入/退款
-            # 找这笔交易付给了谁
+                continue
             for e in self._adj.get(t.node_id, []):
                 if e.rel == "paid_to":
                     by_entity[self.nodes[e.dst].label] += abs(t.attrs.get("amount", 0))
@@ -139,7 +131,6 @@ class FinancialDataGraph:
         cat = self.nodes[cat_id]
         spent = cat.attrs.get("total", 0)
         limit = self.nodes[bud_id].attrs.get("monthly_limit") if bud_id in self.nodes else None
-        # 主要贡献者(商户)
         contributors = self.top_entities_in_category(category, top=3)
         result = {
             "category": category, "found": True,
@@ -170,7 +161,7 @@ class FinancialDataGraph:
         return sorted(out, key=lambda x: -x["outflow"])
 
     def stats(self) -> dict:
-        by_type = defaultdict(int)
+        by_type: defaultdict[str, int] = defaultdict(int)
         for n in self.nodes.values():
             by_type[n.node_type] += 1
         return {"nodes": len(self.nodes), "edges": len(self.edges),

package/python/foxclaw/finance/models.py

@@ -22,21 +22,20 @@ class Transaction:
     原币金额与币种另存 `original_amount` / `currency` / `fx_rate` —— 这样「100 美元」
     不会和「100 元」在求和时混在一起,同时账本里又看得到用户当时说的原话数额。
     """
-    amount: float                       # 负数=支出,正数=收入(本位币 CNY)
-    category: str                       # 分类:subscription/food/transport/salary...
-    entity: str                         # 商户/对手方:Netflix、星巴克、公司
-    account: str                        # 账户:credit_card_1、debit、alipay
+    amount: float
+    category: str
+    entity: str
+    account: str
     timestamp: str = field(default_factory=lambda: datetime.now().isoformat())
-    tags: list = field(default_factory=list)   # ["recurring","media"]
+    tags: list = field(default_factory=list)
     note: str = ""
     id: str = field(default_factory=lambda: f"txn_{uuid.uuid4().hex[:10]}")
-    # —— 多币种 & 自然语言记账 ——
-    currency: str = "CNY"               # 原币种
-    original_amount: Optional[float] = None   # 原币金额(正负号与 amount 一致)
-    fx_rate: float = 1.0                # 记账时原币 → 本位币的折算率
-    description: str = ""               # 报备原话里的"买的什么"
-    status: str = "settled"             # settled=已发生 planned=未来计划
-    source: str = "manual"              # manual / text / csv / bank
+    currency: str = "CNY"
+    original_amount: Optional[float] = None
+    fx_rate: float = 1.0
+    description: str = ""
+    status: str = "settled"
+    source: str = "manual"
 
     @property
     def is_expense(self) -> bool:
@@ -72,8 +71,8 @@ class Transaction:
 class Budget:
     """某分类的预算状态"""
     category: str
-    monthly_limit: float                # 月度上限
-    spent: float = 0.0                  # 本期已花(绝对值)
+    monthly_limit: float
+    spent: float = 0.0
     period: str = field(default_factory=lambda: datetime.now().strftime("%Y-%m"))
 
     @property
@@ -102,12 +101,12 @@ class FinancialEntity:
     """账户 / 商户 / 订阅"""
     name: str
     entity_type: EntityType
-    balance: Optional[float] = None     # 账户余额(仅 account)
-    recurring_amount: Optional[float] = None  # 周期金额(仅 subscription)
-    cycle: Optional[str] = None         # monthly/yearly(仅 subscription)
+    balance: Optional[float] = None
+    recurring_amount: Optional[float] = None
+    cycle: Optional[str] = None
     last_seen: str = ""
     txn_count: int = 0
-    total_amount: float = 0.0           # 累计金额
+    total_amount: float = 0.0
 
     def to_dict(self) -> dict:
         return asdict(self)
@@ -119,16 +118,13 @@ class FinancePolicyRule:
     与 Harness 的 Policy YAML 同构,但作用于资金行为。
     """
     id: str
-    condition: str                      # 人类可读条件描述
+    condition: str
     action: Literal["alert", "require_confirmation", "freeze", "veto", "suggest"]
     threshold: Optional[float] = None
-    scope: str = "global"               # global 或某 category
+    scope: str = "global"
     severity: Literal["info", "warn", "critical"] = "warn"
     source: Literal["builtin", "user", "learned"] = "builtin"
     enabled: bool = True
-    # 自校准留痕:calibrated_value = 上次校准写下的阈值(用于判断"之后有没有人手动改过";
-    # 若 threshold 已偏离它,说明是人的决定,校准就此收手)。calibrated_from = 依据说明,
-    # 让阈值可解释 —— 用户看得到"这个 800 是怎么来的",才敢信它。
     calibrated_value: Optional[float] = None
     calibrated_from: Optional[str] = None
 
@@ -144,7 +140,7 @@ class PolicyVerdict:
     severity: str
     message: str
     transaction_id: Optional[str] = None
-    requires_user_action: bool = False  # 是否需要用户确认/介入
+    requires_user_action: bool = False
 
     def to_dict(self) -> dict:
         return asdict(self)