From 63779e8d69f8c86d23328c8f805b6ee66a7d408d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=BB=9D=E5=B0=98?= <237809796@qq.com> Date: Thu, 1 Oct 2026 02:40:36 +0800 Subject: [PATCH] =?UTF-8?q?=E6=96=B0=E5=A2=9E:=20=E7=9F=A5=E8=AF=86?= =?UTF-8?q?=E5=BA=93=E6=A3=80=E7=B4=A2=E5=88=86=E8=AF=8D=E5=8C=96=E4=B8=8E?= =?UTF-8?q?=E6=99=8B=E5=8D=87=E9=85=8D=E7=BD=AE=E5=8C=96=E5=8F=8A=E5=AF=B9?= =?UTF-8?q?=E8=AF=9D=E5=B7=A5=E5=85=B7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 整句 LIKE 命中率趋零,注入检索改 CJK 2-gram+ASCII 词分词 OR 匹配,标题命中计分排序 停用词剥离前置到切分前,滤掉跨词组合噪音 gram;ASCII 等频精确词优先 candidate 纳入检索面(include_candidates 默认开,配开关可回仅 published) 复用即信任自动晋升配置化:默认关+阈值 5,等晋升把关策略拍板后再开,防未审核产物经误命中固化污染 晋升留痕进时间线(auto/agent 来源区分);补 candidate 复用达标自动转正机制 agent 对话侧新增 knowledge_search/insert/promote 三工具,insert 固定 candidate,转正仅限 candidate 单向 知识配置结构新增两字段带 serde 默认,旧配置 JSON 缺字段不破坏启动恢复 --- crates/df-storage/src/crud/idea_repo.rs | 339 ++++++++++++++- src-tauri/src/commands/ai/knowledge_inject.rs | 396 ++++++++++++++++-- src-tauri/src/commands/ai/tool_registry.rs | 36 +- src-tauri/src/commands/ai/tools/knowledge.rs | 204 +++++++++ src-tauri/src/commands/knowledge_timeline.rs | 40 ++ src-tauri/src/state/knowledge_config.rs | 35 ++ src/api/types.ts | 5 + 7 files changed, 1005 insertions(+), 50 deletions(-) create mode 100644 src-tauri/src/commands/ai/tools/knowledge.rs diff --git a/crates/df-storage/src/crud/idea_repo.rs b/crates/df-storage/src/crud/idea_repo.rs index 208347b..33dd571 100644 --- a/crates/df-storage/src/crud/idea_repo.rs +++ b/crates/df-storage/src/crud/idea_repo.rs @@ -85,6 +85,14 @@ fn parse_json_id_array(raw: &Option) -> Vec { } } +/// LIKE 通配符转义(与 SQL 侧 `ESCAPE '|'` 配套)。 +/// +/// 检索词里的 `%`/`_`/`|` 会被当成通配/转义符,用户输入与分词产物都可能含这些字符, +/// 统一在此转义,避免关键词意外扩大命中面。 +fn escape_like(s: &str) -> String { + s.replace('|', "||").replace('%', "|%").replace('_', "|_") +} + // ============================================================ // from_row 辅助函数 // ============================================================ @@ -634,13 +642,13 @@ impl IdeaRepo { } impl KnowledgeRepo { - /// 检索知识: title/content LIKE 匹配,可选 kind 过滤,按 reuse_count 降序,top-N + /// 检索知识(整句 LIKE,兼容路径): title/content LIKE 匹配,可选 kind 过滤,按 reuse_count 降序,top-N /// - /// 克制检索: top-N≤3(由调用方 limit 控制),精确匹配优先(语义模糊后做)。 + /// 保留整句匹配语义,服务 UI 知识面板搜索与 df-mcp `search_knowledge`(调用方传的就是 + /// 用户显式输入的搜索串,整句即意图)。AI 注入路径的分词检索走 [`KnowledgeRepo::search_keywords`]。 pub async fn search(&self, query: &str, kind: Option<&str>, limit: usize) -> Result> { let conn = self.conn.clone(); - let escaped = query.replace('|', "||").replace('%', "|%").replace('_', "|_"); - let pattern = format!("%{escaped}%"); + let pattern = format!("%{}%", escape_like(query)); let kind = kind.map(|s| s.to_owned()); let limit_i = limit as i64; tokio::task::spawn_blocking(move || { @@ -673,6 +681,77 @@ impl KnowledgeRepo { .map_err(storage_err)? } + /// 分词关键词检索(AI 注入路径专用): 多关键词 OR 命中 title/content + /// + /// 排序:标题命中词数 > 内容命中 > reuse_count 降序(SQL 内 CASE 计分,同分再看复用次数)。 + /// + /// 背景(知识库走查 2026-09-29):注入路径原复用 [`KnowledgeRepo::search`] 把**整句用户消息** + /// 当 LIKE pattern,`%怎么修复知识库检索命中率%` 这类长串几乎不可能作为连续子串出现在 + /// 任何知识正文里,命中率≈0。本方法由 caller 分词后逐词匹配,任一词命中即入候选, + /// 多词同时命中者排前。关键词条数为 WHERE 的 OR 分支数,通常 ≤6,全表扫描量级可控。 + /// + /// `include_candidates`:是否把 status='candidate'(AI 自动提炼产物)纳入检索面。 + /// 提炼产物曾长期全部滞留 candidate 而本路径只认 published,存量知识近乎零生效; + /// 默认纳入后靠「复用即信任」([`KnowledgeRepo::auto_publish_if_reused`])渐进晋升, + /// 人工审核降级为可选修正路径。 + /// + /// 关键词为空 → 返回空(不回退整句 LIKE,避免退化回原缺陷)。 + pub async fn search_keywords( + &self, + keywords: &[String], + include_candidates: bool, + limit: usize, + ) -> Result> { + if keywords.is_empty() { + return Ok(Vec::new()); + } + let conn = self.conn.clone(); + // 每个关键词占一个编号占位符;WHERE 与 ORDER BY 的 CASE 复用同号(SQLite 允许 ?N 复用), + // 参数列表只装一份 pattern,末尾追加 LIMIT 占位符。 + let mut patterns: Vec = Vec::with_capacity(keywords.len()); + let mut where_parts: Vec = Vec::with_capacity(keywords.len()); + let mut title_score_terms: Vec = Vec::with_capacity(keywords.len()); + for (i, kw) in keywords.iter().enumerate() { + let n = i + 1; + where_parts.push(format!( + "(title LIKE ?{n} ESCAPE '|' OR content LIKE ?{n} ESCAPE '|')" + )); + title_score_terms.push(format!("CASE WHEN title LIKE ?{n} ESCAPE '|' THEN 1 ELSE 0 END")); + patterns.push(format!("%{}%", escape_like(kw))); + } + let status_clause = if include_candidates { + "status IN ('published','candidate')" + } else { + "status = 'published'" + }; + let limit_i = limit as i64; + let sql = format!( + "SELECT {KNOWLEDGE_COLS} FROM knowledges \ + WHERE {status_clause} AND ({}) \ + ORDER BY ({}) DESC, reuse_count DESC, created_at DESC LIMIT ?{}", + where_parts.join(" OR "), + title_score_terms.join(" + "), + patterns.len() + 1, + ); + tokio::task::spawn_blocking(move || { + let guard = conn.blocking_lock(); + let mut param_refs: Vec<&dyn rusqlite::ToSql> = + patterns.iter().map(|p| p as &dyn rusqlite::ToSql).collect(); + param_refs.push(&limit_i); + let mut stmt = guard.prepare(&sql).map_err(storage_err)?; + let rows = stmt + .query_map(param_refs.as_slice(), |row| knowledge_from_row(row)) + .map_err(storage_err)?; + let mut results = Vec::new(); + for r in rows { + results.push(r.map_err(storage_err)?); + } + Ok(results) + }) + .await + .map_err(storage_err)? + } + /// 按状态列出(审核收件箱用): 按 confidence 语义排序(high>medium>low),次按 created_at /// /// 用 CASE WHEN 替代纯 TEXT 排序(字典序 high>low>medium 非预期语义)。 @@ -724,6 +803,59 @@ impl KnowledgeRepo { .map_err(storage_err)? } + /// 复用即信任:candidate 的 reuse_count 达到阈值后自动晋升 published + /// + /// 背景(知识库走查 2026-09-29):AI 提炼产物长期滞留 candidate,人工审核入口堆积无人处理, + /// 存量知识近乎零生效。「被真实注入命中 N 次」比「被人工翻到」信号更强,故以复用达标为 + /// 主晋升路径;人工审核保留为可选修正(仍可在面板驳回/归档)。 + /// + /// SQL 原子判定(`status='candidate' AND reuse_count >= threshold`):published/archived + /// 条目不受影响,幂等可重复调用。返回 true = 本次发生了晋升(调用方据此打留痕日志)。 + pub async fn auto_publish_if_reused(&self, id: &str, threshold: i64) -> Result { + let conn = self.conn.clone(); + let id = id.to_owned(); + let now = now_millis_str(); + tokio::task::spawn_blocking(move || { + let guard = conn.blocking_lock(); + let affected = guard + .execute( + "UPDATE knowledges SET status = 'published', updated_at = ?1 \ + WHERE id = ?2 AND status = 'candidate' AND reuse_count >= ?3", + params![now, id, threshold], + ) + .map_err(storage_err)?; + Ok(affected > 0) + }) + .await + .map_err(storage_err)? + } + + /// 显式转正:candidate 单向晋升 published(对话内 knowledge_promote 工具 / 人工放行通道) + /// + /// 与 [`KnowledgeRepo::auto_publish_if_reused`] 同款 SQL 原子条件写,区别在晋升条件: + /// 本方法不做复用计数判定,仅 `status='candidate'` 一个门槛——显式转正是「人/agent + /// 拍板」语义,不复用即信任的阈值逻辑。SQL WHERE 收口边界:published/archived 条目 + /// 不命中(affected=0 → false),调用方据此回「仅 candidate 可转正」,天然幂等且 + /// 禁止降级/归档/改内容(只写 status + updated_at 两列)。 + pub async fn promote(&self, id: &str) -> Result { + let conn = self.conn.clone(); + let id = id.to_owned(); + let now = now_millis_str(); + tokio::task::spawn_blocking(move || { + let guard = conn.blocking_lock(); + let affected = guard + .execute( + "UPDATE knowledges SET status = 'published', updated_at = ?1 \ + WHERE id = ?2 AND status = 'candidate'", + params![now, id], + ) + .map_err(storage_err)?; + Ok(affected > 0) + }) + .await + .map_err(storage_err)? + } + /// 写入向量嵌入(BLOB = Vec 小端字节序列化) /// /// embedding 列不进 KnowledgeRecord(IPC 不需要传向量给前端),专用方法读写。 @@ -1261,6 +1393,205 @@ mod tests { assert_eq!(hits[1].id, "k3"); } + // ---------- 分词关键词检索(search_keywords,知识注入路径) ---------- + + #[tokio::test] + async fn search_keywords_empty_input_returns_empty() { + let repo = setup_repo().await; + repo.insert(krec("k1", "Rust 异步", "tokio", "lesson", "published", None, 1)) + .await + .unwrap(); + // 关键词为空 → 直接空结果,不回退整句 LIKE(避免退化回整句匹配缺陷) + let hits = repo.search_keywords(&[], true, 10).await.unwrap(); + assert!(hits.is_empty()); + } + + #[tokio::test] + async fn search_keywords_or_matches_any_keyword() { + let repo = setup_repo().await; + // k1 命中 title 的「异步」;k2 命中 content 的「tokio」——OR 语义两路都收 + repo.insert(krec("k1", "Rust 异步并发", "无关内容", "lesson", "published", None, 1)) + .await + .unwrap(); + repo.insert(krec("k2", "运行时", "tokio 深入", "lesson", "published", None, 1)) + .await + .unwrap(); + + let kws = vec!["异步".to_string(), "tokio".to_string()]; + let hits = repo.search_keywords(&kws, false, 10).await.unwrap(); + let ids: Vec<_> = hits.iter().map(|h| h.id.as_str()).collect(); + assert_eq!(ids.len(), 2); + assert!(ids.contains(&"k1")); + assert!(ids.contains(&"k2")); + } + + #[tokio::test] + async fn search_keywords_title_hit_ranks_above_content_hit() { + let repo = setup_repo().await; + // k2 内容命中且复用次数极高,k1 仅标题命中 → 标题权重压过 reuse_count + repo.insert(krec("k1", "Rust 所有权", "无关内容", "lesson", "published", None, 0)) + .await + .unwrap(); + repo.insert(krec("k2", "无关标题", "聊聊 Rust 所有权与借用", "lesson", "published", None, 99)) + .await + .unwrap(); + + let kws = vec!["所有权".to_string()]; + let hits = repo.search_keywords(&kws, false, 10).await.unwrap(); + assert_eq!(hits.len(), 2); + assert_eq!(hits[0].id, "k1", "标题命中应排在内容命中之前"); + assert_eq!(hits[1].id, "k2"); + } + + #[tokio::test] + async fn search_keywords_more_title_hits_rank_first() { + let repo = setup_repo().await; + // 两条都是标题命中:k1 命中 2 词,k2 命中 1 词 → k1 前 + repo.insert(krec("k1", "Rust 异步模型", "...", "lesson", "published", None, 1)) + .await + .unwrap(); + repo.insert(krec("k2", "异步进阶", "...", "lesson", "published", None, 50)) + .await + .unwrap(); + + let kws = vec!["Rust".to_string(), "异步".to_string()]; + let hits = repo.search_keywords(&kws, false, 10).await.unwrap(); + assert_eq!(hits.len(), 2); + assert_eq!(hits[0].id, "k1", "标题命中词数多者应排前(同档才看 reuse_count)"); + } + + #[tokio::test] + async fn search_keywords_include_candidates_toggle() { + let repo = setup_repo().await; + repo.insert(krec("pub1", "Rust 规范", "...", "lesson", "published", None, 1)) + .await + .unwrap(); + repo.insert(krec("cand1", "Rust 提炼稿", "...", "lesson", "candidate", None, 1)) + .await + .unwrap(); + let kws = vec!["Rust".to_string()]; + + // 默认(纳入 candidate):published + candidate 都出 + let hits = repo.search_keywords(&kws, true, 10).await.unwrap(); + assert_eq!(hits.len(), 2, "include_candidates=true 应纳入 candidate"); + + // 关闭:回到仅 published(兼容旧行为) + let hits = repo.search_keywords(&kws, false, 10).await.unwrap(); + assert_eq!(hits.len(), 1); + assert_eq!(hits[0].id, "pub1"); + } + + #[tokio::test] + async fn search_keywords_like_wildcards_escaped() { + let repo = setup_repo().await; + // 关键词含 % 时不应充当通配符("100%" 不该命中任意串) + repo.insert(krec("k1", "进度 100% 完成", "普通内容", "lesson", "published", None, 1)) + .await + .unwrap(); + repo.insert(krec("k2", "完全不同", "...", "lesson", "published", None, 1)) + .await + .unwrap(); + + let kws = vec!["100%".to_string()]; + let hits = repo.search_keywords(&kws, false, 10).await.unwrap(); + assert_eq!(hits.len(), 1); + assert_eq!(hits[0].id, "k1"); + } + + // ---------- 复用即信任(auto_publish_if_reused) ---------- + + #[tokio::test] + async fn auto_publish_promotes_candidate_at_threshold() { + let repo = setup_repo().await; + repo.insert(krec("c1", "提炼知识", "...", "lesson", "candidate", None, 0)) + .await + .unwrap(); + + // 复用 1 次(< 阈值 2)→ 不晋升 + repo.increment_reuse_count("c1").await.unwrap(); + assert!(!repo.auto_publish_if_reused("c1", 2).await.unwrap()); + assert_eq!( + repo.get_by_id("c1").await.unwrap().unwrap().status.as_str(), + "candidate" + ); + + // 复用第 2 次(达标)→ 晋升 published + repo.increment_reuse_count("c1").await.unwrap(); + assert!(repo.auto_publish_if_reused("c1", 2).await.unwrap()); + assert_eq!( + repo.get_by_id("c1").await.unwrap().unwrap().status.as_str(), + "published" + ); + + // 已 published 再调:幂等 false(不再重复晋升) + assert!(!repo.auto_publish_if_reused("c1", 2).await.unwrap()); + } + + #[tokio::test] + async fn auto_publish_ignores_published_and_missing() { + let repo = setup_repo().await; + repo.insert(krec("p1", "已发布", "...", "lesson", "published", None, 10)) + .await + .unwrap(); + // published 即使 reuse_count 远超阈值也不动(晋升仅面向 candidate) + assert!(!repo.auto_publish_if_reused("p1", 2).await.unwrap()); + assert_eq!( + repo.get_by_id("p1").await.unwrap().unwrap().status.as_str(), + "published" + ); + // 不存在的 id → false + assert!(!repo.auto_publish_if_reused("ghost", 2).await.unwrap()); + } + + // ---------- 显式转正(promote,对话内 knowledge_promote 工具通道) ---------- + + #[tokio::test] + async fn promote_candidates_to_published() { + let repo = setup_repo().await; + repo.insert(krec("c1", "候选知识", "...", "lesson", "candidate", None, 0)) + .await + .unwrap(); + + // candidate → published: true,状态落库 + assert!(repo.promote("c1").await.unwrap()); + assert_eq!( + repo.get_by_id("c1").await.unwrap().unwrap().status.as_str(), + "published" + ); + + // 已 published 再调:幂等 false(晋升仅面向 candidate,不降级不重复) + assert!(!repo.promote("c1").await.unwrap()); + assert_eq!( + repo.get_by_id("c1").await.unwrap().unwrap().status.as_str(), + "published" + ); + } + + #[tokio::test] + async fn promote_ignores_published_archived_and_missing() { + let repo = setup_repo().await; + repo.insert(krec("p1", "已发布", "...", "lesson", "published", None, 3)) + .await + .unwrap(); + repo.insert(krec("a1", "已归档", "...", "lesson", "archived", None, 1)) + .await + .unwrap(); + + // published / archived 均 WHERE 不命中 → false 且状态不变 + assert!(!repo.promote("p1").await.unwrap()); + assert_eq!( + repo.get_by_id("p1").await.unwrap().unwrap().status.as_str(), + "published" + ); + assert!(!repo.promote("a1").await.unwrap()); + assert_eq!( + repo.get_by_id("a1").await.unwrap().unwrap().status.as_str(), + "archived" + ); + // 不存在的 id → false + assert!(!repo.promote("ghost").await.unwrap()); + } + #[tokio::test] async fn list_by_status_orders_by_confidence_semantics() { // confidence 字典序 high>low>medium 非预期,实现用 CASE 强制 high>medium>low diff --git a/src-tauri/src/commands/ai/knowledge_inject.rs b/src-tauri/src/commands/ai/knowledge_inject.rs index 2398907..04c5171 100644 --- a/src-tauri/src/commands/ai/knowledge_inject.rs +++ b/src-tauri/src/commands/ai/knowledge_inject.rs @@ -1,6 +1,7 @@ //! 知识库集成 — 注入 + 提炼(嵌入生成 / 混合检索 / 上下文构建 / 对话提炼) -use std::sync::Arc; +use std::collections::HashMap; +use std::sync::{Arc, LazyLock, Mutex as StdMutex}; use tokio::sync::Mutex; @@ -24,6 +25,168 @@ use crate::commands::err_str; use super::{AiSession}; +// ============================================================ +// 知识注入/提炼参数(集中收口,不散魔法数) +// ============================================================ + +/// 注入检索 query 最多保留的关键词个数(按出现频次取前 N) +/// +/// 多词会放大 SQL 命中面并稀释「标题命中 > 内容命中」的排序精度,6 个足以覆盖 +/// 一句提问的信息量(ASCII 专有名词 + 核心汉字 2-gram)。 +const KNOWLEDGE_QUERY_MAX_KEYWORDS: usize = 6; +/// ASCII 词最短长度(单字符词如 a/x/i 全表乱命中,过滤) +const KNOWLEDGE_QUERY_MIN_ASCII_LEN: usize = 2; +/// 自动提炼窗口:取最近 N 条 user/assistant 消息送 LLM 提炼 +/// +/// 原 6 条窗口过窄,长会话后半程的经验不在提炼视野内;40 条覆盖近期完整上下文, +/// 同时不撑爆提炼调用的 token 预算(max_tokens 2048 的输出侧不受影响,输入侧由 +/// 提炼模型上下文窗口兜底)。 +const KNOWLEDGE_EXTRACT_WINDOW: usize = 40; +/// 自动提炼频次:距上次提炼至少新增 N 条用户消息才再提炼 +/// +/// 取代原「每会话仅提炼一次」的 bool 硬去重——长会话后半程的新经验此前永不提炼。 +const KNOWLEDGE_EXTRACT_MIN_NEW_USER_MSGS: usize = 10; + +/// 自动提炼频次水位(conv_id → 上次提炼进度),见 [`EXTRACT_WATERMARKS`]。 +#[derive(Clone, Copy)] +enum ExtractWatermark { + /// 提炼进行中(spawn 前置位,完成/失败后改写,防并发两路同时触发) + InFlight, + /// 上次成功提炼完成时的用户消息累计条数(含已压缩消息,保证单调递增) + Done(usize), +} + +/// 提炼频次水位表(进程内,不落库)。 +/// +/// 原「每会话仅提炼一次」的 `knowledge_extracted` bool 去重使长会话后半程的新经验 +/// 永不提炼(知识库走查 2026-09-29);改为水位制:距上次提炼累计新增 +/// [`KNOWLEDGE_EXTRACT_MIN_NEW_USER_MSGS`] 条用户消息可再提炼。 +/// 放本模块静态而非 PerConvState:后者归属会话状态层(本次改动边界外),且水位随进程 +/// 生命周期存续即可——重启丢失后最多多提炼一轮,无正确性风险。 +static EXTRACT_WATERMARKS: LazyLock>> = + LazyLock::new(|| StdMutex::new(HashMap::new())); + +/// 统计会话的用户消息累计条数(提炼频次水位的计量单位) +fn count_user_rounds<'a>(msgs: impl Iterator) -> usize { + msgs.filter(|m| matches!(m.role, MessageRole::User)).count() +} + +// ============================================================ +// 检索 query 分词(整句 LIKE 命中率≈0 的根治,见 search_keywords) +// ============================================================ + +/// 中文判断(CJK 统一表意文字区,覆盖日常中文) +fn is_cjk_char(c: char) -> bool { + matches!(c, '\u{4E00}'..='\u{9FFF}') +} + +/// ASCII 词字符(字母数字下划线) +fn is_ascii_word_char(c: char) -> bool { + c.is_ascii_alphanumeric() || c == '_' +} + +/// 高频虚词停用表(2-gram 粒度):中文疑问/指代/客套组合 + 英文虚词。 +/// ASCII 词抽取时已统一小写,英文停用词按小写收录;命中即弃,不参与检索。 +const QUERY_STOPWORDS: &[&str] = &[ + "怎么", "如何", "什么", "为何", "帮我", "看看", "这个", "那个", "一下", "可以", + "应该", "需要", "是否", "如果", "但是", "所以", "因为", "还是", "就是", "没有", + "一个", "这些", "那些", "然后", "现在", "已经", "我们", "你们", "他们", "自己", + "时候", "我看", "请把", "觉得", "感觉", "好像", "对于", "关于", + "the", "and", "for", "with", "this", "that", "from", "have", "what", "how", + "can", "you", "are", "was", "not", "but", "about", "into", "use", "please", + "help", "want", "need", "should", "would", "could", "there", "here", "when", + "where", "which", "your", +]; + +/// 从用户消息抽取检索关键词:ASCII 词(≥2 字符,统一小写)+ CJK 2-gram,按频次取前 N +/// +/// 背景(知识库走查 2026-09-29):原把整条用户消息当 LIKE pattern,中文长句几乎不可能 +/// 作为连续子串命中知识正文,注入检索近乎失效。不上分词器:提问多为短句, +/// 2-gram + 停用词已够;不依赖 df-ai 的同思路实现(df-storage 在依赖链下层,反向依赖会成环), +/// 故此处自实现最小分词。停用词过滤同时压掉客套话与指代词的噪音 2-gram。 +/// +/// 返回按出现频次降序的前 [`KNOWLEDGE_QUERY_MAX_KEYWORDS`] 个,同频次 ASCII 词优先于 +/// CJK 2-gram(2-gram 是无词典近似噪音多,等频抢占容量时精确词让位),组内按首次 +/// 出现顺序稳定排序(检索 query 确定,行为可测)。 +pub(crate) fn extract_query_keywords(text: &str) -> Vec { + let mut tokens: Vec = Vec::new(); + let mut ascii_buf = String::new(); + let mut cjk_buf: Vec = Vec::new(); + + for c in text.chars() { + if is_ascii_word_char(c) { + // ASCII 词打断了汉字连续段:先结算汉字 2-gram 再收集 ASCII + flush_cjk_bigrams(&mut cjk_buf, &mut tokens); + ascii_buf.push(c.to_ascii_lowercase()); + } else { + if !ascii_buf.is_empty() { + tokens.push(std::mem::take(&mut ascii_buf)); + } + if is_cjk_char(c) { + cjk_buf.push(c); + } else { + // 空白/标点等分隔符:结算当前汉字段 + flush_cjk_bigrams(&mut cjk_buf, &mut tokens); + } + } + } + if !ascii_buf.is_empty() { + tokens.push(ascii_buf); + } + flush_cjk_bigrams(&mut cjk_buf, &mut tokens); + + // 过滤(过短/停用词)后按频次降序取前 N;同频次 ASCII 词优先于 CJK 2-gram, + // 组内按首现顺序稳定排序 + let ascii_word = |t: &str| t.starts_with(is_ascii_word_char); + let mut freq: Vec<(String, usize, usize)> = Vec::new(); + for (idx, t) in tokens.into_iter().enumerate() { + if t.chars().count() < KNOWLEDGE_QUERY_MIN_ASCII_LEN + || QUERY_STOPWORDS.contains(&t.as_str()) + { + continue; + } + if let Some(entry) = freq.iter_mut().find(|(tok, _, _)| tok == &t) { + entry.1 += 1; + } else { + freq.push((t, 1, idx)); + } + } + freq.sort_by(|a, b| { + b.1.cmp(&a.1) + .then_with(|| ascii_word(&b.0).cmp(&ascii_word(&a.0))) + .then_with(|| a.2.cmp(&b.2)) + }); + freq + .into_iter() + .take(KNOWLEDGE_QUERY_MAX_KEYWORDS) + .map(|(t, _, _)| t) + .collect() +} + +/// 结算 CJK 连续段:剥离段内停用词后两两切 2-gram。 +/// +/// 中文无空格分词,2-gram 是无词典近似的最小可靠粒度;孤单汉字不产出 +/// (单字命中率低噪音高)。段长 <2 时 windows(2) 自然产出空,无需特判。 +/// +/// 停用词须在切 gram 前替换为分隔符打断连续段:切完再整词过滤滤不掉 +/// 停用词与邻字的跨词组合 gram("帮我看看这个怎么修复"会产生"看这/个怎"噪音)。 +/// 表内 CJK 停用词均为 2 字词,ASCII 停用词不会命中纯汉字段,统一替换无副作用; +/// 剥离后单字残留不成 gram 自然丢弃,与孤单汉字语义一致。 +fn flush_cjk_bigrams(buf: &mut Vec, out: &mut Vec) { + let mut segment: String = buf.iter().collect(); + for w in QUERY_STOPWORDS { + if segment.contains(w) { + segment = segment.replace(w, "\u{0}"); + } + } + for part in segment.split('\u{0}') { + for w in part.chars().collect::>().windows(2) { + out.push(w.iter().collect()); + } + } + buf.clear(); +} + /// 按配置构建 embedding provider + model。None = 配置缺失/provider 不存在。 /// /// F-01 阶段5: model 选择路由优先 — 在 embedding provider 的 model_configs 池中按 @@ -232,13 +395,20 @@ pub async fn retry_failed_embeddings(state: &AppState) -> anyhow::Result /// /// 双信号(两路都命中)排最前,LIKE 单信号次之,向量单信号第三。 /// vector_enabled 关闭或 embed 失败时纯 LIKE(零外部依赖降级)。 +/// LIKE 路 query 先经 [`extract_query_keywords`] 分词(整句 LIKE 命中率≈0); +/// 向量路 query 同步改用关键词拼接(虚词稀释 embedding 语义),分词为空时回退原句。 async fn hybrid_search( state: &AppState, query: &str, limit: usize, config: &crate::state::KnowledgeConfig, ) -> Vec { - let keyword_results = match state.knowledge.search(query, None, limit).await { + let keywords = extract_query_keywords(query); + let keyword_results = match state + .knowledge + .search_keywords(&keywords, config.include_candidates, limit) + .await + { Ok(v) => v, Err(e) => { tracing::warn!(error = %e, "[ai] 知识关键词检索失败,降级空结果"); @@ -249,7 +419,12 @@ async fn hybrid_search( if !config.vector_enabled { return keyword_results; } - let query_vec = match generate_embedding(state, query, config).await { + let embed_query = if keywords.is_empty() { + query.to_string() + } else { + keywords.join("、") + }; + let query_vec = match generate_embedding(state, &embed_query, config).await { Some(v) => v, None => return keyword_results, // embed 失败降级 }; @@ -322,19 +497,40 @@ pub(crate) async fn build_knowledge_context( if results.is_empty() { return String::new(); } - // 命中条目:复用计数 +1 + 记录引用事件(fire-and-forget,单个 spawn 任务批量处理) + // 命中条目:复用计数 +1 + candidate 复用达标自动晋升 + 记录引用事件(fire-and-forget,单个 spawn 任务批量处理) let db = state.db.clone(); - let ids: Vec = results.iter().map(|r| r.id.clone()).collect(); + // (id, 是否 candidate):晋升检查只对 candidate 发起,published 免一次注定空跑的 UPDATE + let hits: Vec<(String, bool)> = results + .iter() + .map(|r| (r.id.clone(), r.status == "candidate")) + .collect(); let conv_id = conv_id.to_string(); let query_clone = query.to_string(); let user_message_id = user_message_id.map(|s| s.to_string()); + // 晋升开关与阈值取配置快照值拷贝进闭包(决策单未拍板前默认保守,开关默认关) + let auto_publish_enabled = config.auto_publish_enabled; + let auto_publish_threshold = config.auto_publish_reuse_threshold; tauri::async_runtime::spawn(async move { let repo = KnowledgeRepo::new(&db); let timeline = crate::commands::knowledge_timeline::KnowledgeTimeline::new(&db); - for id in &ids { + for (id, is_candidate) in &hits { if let Err(e) = repo.increment_reuse_count(id).await { tracing::warn!("reuse_count +1 失败(非阻断): {}", e); } + // 复用即信任:开关开启时 candidate 达到阈值自动晋升 published(SQL 侧原子判定, + // 重复调用幂等)。默认关(决策卡 C3 未拍板前保守),开启后阈值取配置。 + if *is_candidate && auto_publish_enabled { + match repo.auto_publish_if_reused(id, auto_publish_threshold).await { + Ok(true) => { + tracing::info!("[knowledge] candidate 复用达标({auto_publish_threshold} 次),自动晋升 published: {id}"); + // 晋升留痕:生命线记 status_changed(source_ref=auto_publish), + // fire-and-forget 与上方 record_referenced 同风格,失败仅 warn 非阻断。 + timeline.record_auto_publish(id, auto_publish_threshold).await; + } + Ok(false) => {} + Err(e) => tracing::warn!("candidate 自动晋升检查失败(非阻断): {e}"), + } + } timeline .record_referenced(id, &conv_id, &query_clone, user_message_id.as_deref()) .await; @@ -423,13 +619,15 @@ pub(crate) async fn inject_knowledge_into_prompt( /// 判断是否应触发提炼,满足则后台 spawn 提炼 task(非阻断) /// /// 守卫: auto_extract 开 + trigger_mode == OnComplete + 消息数 ≥ min_messages -/// + 去重标志(P1 修复:本会话已成功提炼过则跳过,防重复触发刷 candidate) +/// + 频次水位(提炼中 InFlight,或距上次提炼新增用户消息 +/// < [`KNOWLEDGE_EXTRACT_MIN_NEW_USER_MSGS`] 则跳过)。 +/// 原「每会话仅提炼一次」的 bool 硬去重已由水位制取代——长会话后半程的新经验 +/// 此前永不提炼(知识库走查 2026-09-29)。 /// -/// TOCTOU 修复(🟡D):老实现 read(knowledge_extracted) → release lock → spawn, -/// 并发窗口内另一路 maybe_spawn_extraction 也能读到 false 各自 spawn,致重复提炼刷 candidate。 -/// 现在判重 + 消息数 + **预置位**三步在**同一个锁临界区**内原子完成:置位即占用提炼槽位, -/// 并发的后来者读到 true 直接跳过。spawn 后按结果修正:0 条 / Err 清位(允许下次重试), -/// ≥1 条保持 true(已提炼,后续跳过)。 +/// TOCTOU 防护保持:守卫判定 + **预置位**(InFlight 水位 + knowledge_extracted 哨兵) +/// 在**同一个锁临界区**内原子完成,并发窗口内的后来者读到占用即跳过,防重复提炼刷 +/// candidate。spawn 后按结果修正:0 条 / Err 清位回退水位(允许下次重试), +/// ≥1 条记 Done 水位(此后须再攒够阈值条用户消息才再提炼)。 pub(crate) async fn maybe_spawn_extraction( session_arc: &Arc>, db: &Arc, @@ -444,46 +642,60 @@ pub(crate) async fn maybe_spawn_extraction( if config.trigger_mode != ExtractTrigger::OnComplete { return Ok(()); } - // P1 修复(提炼重复触发)+ 🟡D TOCTOU 修复:判重 + 消息数守卫 + 预置位同一锁内原子完成。 - // 背景:审批续跑 try_continue → 重 spawn run_agentic_loop → 正常完成块 → - // maybe_spawn_extraction 二次触发,无去重致同知识点重复 candidate 刷屏。 - // 预置位语义:knowledge_extracted 在 spawn 前先置 true 占提炼槽位,并发后来者读到 - // true 即跳过(等价「提炼中」哨兵);spawn 后按 inserted 结果修正(见下)。 - // 清位:trigger_extraction_now(手动按钮)强制清位,允许用户手动重提炼。 + // 频次水位守卫 + 消息数守卫 + 预置位在同一锁临界区内原子完成(TOCTOU 防护与原 P1 修复同思路: + // 审批续跑 try_continue → 重 spawn run_agentic_loop → 正常完成块会二次触发本函数, + // 无占位致并发重复提炼刷 candidate)。 + // 清位/回退:trigger_extraction_now(手动按钮)强制清哨兵 + 水位,允许用户立即手动重提炼。 { let __lock_t = std::time::Instant::now(); let mut session = session_arc.lock().await; - // 一次 conv_read 读两个字段(knowledge_extracted + messages.len()),map 后借用即结束, + // 一次 conv_read 读两个字段(消息总数守卫 + 用户消息水位计量),map 后借用即结束, // 后续 session.conv()(&mut self)不再冲突。 - let (already, count) = session + let (msg_count, user_rounds) = session .conv_read(conv_id) - .map(|c| (c.knowledge_extracted, c.messages.len())) - .unwrap_or((false, 0)); - // 守卫 1:已提炼过(或提炼中) → 跳过 + warn。 - if already { + .map(|c| (c.messages.len(), count_user_rounds(c.messages.iter()))) + .unwrap_or((0, 0)); + // 守卫 1:频次水位(InFlight=提炼中防并发;Done=新增用户消息不足阈值)。 + // 替代原 bool 硬去重;跳过走 debug 留痕(改水位制后此路径高频,warn 会刷屏)。 + let blocked = { + let wms = EXTRACT_WATERMARKS.lock().expect("提炼水位互斥锁中毒"); + match wms.get(conv_id) { + Some(ExtractWatermark::InFlight) => true, + Some(ExtractWatermark::Done(last)) => { + user_rounds.saturating_sub(*last) < KNOWLEDGE_EXTRACT_MIN_NEW_USER_MSGS + } + None => false, + } + }; + if blocked { let __hold = __lock_t.elapsed(); if __hold > std::time::Duration::from_millis(30) { - eprintln!("[LOCK-SLOW] maybe_spawn_extraction:437 持锁 {:?} (含 lock 等待)", __hold); + eprintln!("[LOCK-SLOW] maybe_spawn_extraction 持锁 {:?} (含 lock 等待)", __hold); } - tracing::warn!( + tracing::debug!( conv_id = %conv_id, - "[knowledge] 跳过自动提炼:本会话已提炼过/提炼中(去重标志置位,防重复刷 candidate);如需重提炼用手动按钮" + "[knowledge] 跳过自动提炼:提炼中或距上次提炼新增用户消息不足 {} 条(如需立即重提炼用手动按钮)", + KNOWLEDGE_EXTRACT_MIN_NEW_USER_MSGS ); return Ok(()); } // 守卫 2:消息数。conv_read 未建返 0(< min_messages 自然跳过,语义=空对话不注入知识)。 - if (count as u32) < config.min_messages { + if msg_count < config.min_messages as usize { let __hold = __lock_t.elapsed(); if __hold > std::time::Duration::from_millis(30) { - eprintln!("[LOCK-SLOW] maybe_spawn_extraction:437 持锁 {:?} (含 lock 等待)", __hold); + eprintln!("[LOCK-SLOW] maybe_spawn_extraction 持锁 {:?} (含 lock 等待)", __hold); } return Ok(()); } // 原子预置位(TOCTOU 核心):释放锁前先占提炼槽位,杜绝并发窗口内重复 spawn。 session.conv(conv_id).knowledge_extracted = true; + EXTRACT_WATERMARKS + .lock() + .expect("提炼水位互斥锁中毒") + .insert(conv_id.to_string(), ExtractWatermark::InFlight); let __hold = __lock_t.elapsed(); if __hold > std::time::Duration::from_millis(30) { - eprintln!("[LOCK-SLOW] maybe_spawn_extraction:437 持锁 {:?} (含 lock 等待)", __hold); + eprintln!("[LOCK-SLOW] maybe_spawn_extraction 持锁 {:?} (含 lock 等待)", __hold); } } @@ -496,26 +708,44 @@ pub(crate) async fn maybe_spawn_extraction( match extract_knowledge_from_conversation(&db, &conv_id, &provider_config, &llm_concurrency).await { Ok(inserted) => { if inserted > 0 { - // ≥1 条:保持预置的 true(已占用槽位即最终状态),仅 log。 + // ≥1 条:哨兵保持置位,水位记为当前用户消息进度 + // (此后须再新增 ≥ 阈值条用户消息才会再提炼)。 + let session = session_arc.lock().await; + let rounds = session + .conv_read(&conv_id) + .map(|c| count_user_rounds(c.messages.iter())) + .unwrap_or(0); + EXTRACT_WATERMARKS + .lock() + .expect("提炼水位互斥锁中毒") + .insert(conv_id.clone(), ExtractWatermark::Done(rounds)); tracing::info!( - conv_id = %conv_id, inserted, - "[knowledge] 提炼成功,去重标志保持置位,后续自动触发将被跳过" + conv_id = %conv_id, inserted, rounds, + "[knowledge] 提炼成功,水位记为当前进度,新增用户消息达阈值后才再提炼" ); } else { - // 0 条:清位回 false,允许下次自动触发重试(对话可能后续补充了有价值内容)。 + // 0 条:清哨兵 + 回退水位,允许下次自动触发重试(对话可能后续补充了有价值内容)。 let mut session = session_arc.lock().await; session.conv(&conv_id).knowledge_extracted = false; + EXTRACT_WATERMARKS + .lock() + .expect("提炼水位互斥锁中毒") + .remove(&conv_id); tracing::info!( conv_id = %conv_id, - "[knowledge] 提炼 0 条(无可提炼内容),清去重标志允许下次自动重试" + "[knowledge] 提炼 0 条(无可提炼内容),清哨兵与水位允许下次自动重试" ); } } Err(e) => { - // 失败:清位回 false,允许下次触发重试(预置位已在,须回滚否则会话被锁死)。 + // 失败:清哨兵 + 回退水位,允许下次触发重试(预置位已在,须回滚否则会话被锁死)。 tracing::warn!("知识提取失败(非阻断): {}", e); let mut session = session_arc.lock().await; session.conv(&conv_id).knowledge_extracted = false; + EXTRACT_WATERMARKS + .lock() + .expect("提炼水位互斥锁中毒") + .remove(&conv_id); } } }); @@ -532,9 +762,13 @@ pub async fn trigger_extraction_now(state: &AppState) -> Result { let conv_id = { let mut session = state.ai_session.lock().await; let conv_id = session.active_conversation_id.clone(); - // 强制清去重标志:手动提炼是用户显式动作,允许对已提炼过的会话重提炼。 + // 强制清哨兵 + 频次水位:手动提炼是用户显式动作,绕过自动路径的间隔限制(语义=手动覆盖)。 if let Some(cid) = conv_id.as_deref() { session.conv(cid).knowledge_extracted = false; + EXTRACT_WATERMARKS + .lock() + .expect("提炼水位互斥锁中毒") + .remove(cid); } conv_id }; @@ -546,11 +780,19 @@ pub async fn trigger_extraction_now(state: &AppState) -> Result { tauri::async_runtime::spawn(async move { match extract_knowledge_from_conversation(&db, &conv_id, &provider_config, &llm_concurrency).await { Ok(inserted) => { - // 手动提炼成功(≥1 条)后也置去重标志,保持与自动路径一致: + // 手动提炼成功(≥1 条)后与自动路径同语义收口:置哨兵 + 记水位, // 避免手动提炼后再触发自动提炼重复。用户再次手动按按钮会再次清位,行为自洽。 if inserted > 0 { let mut session = session_arc.lock().await; session.conv(&conv_id).knowledge_extracted = true; + let rounds = session + .conv_read(&conv_id) + .map(|c| count_user_rounds(c.messages.iter())) + .unwrap_or(0); + EXTRACT_WATERMARKS + .lock() + .expect("提炼水位互斥锁中毒") + .insert(conv_id.clone(), ExtractWatermark::Done(rounds)); } } Err(e) => tracing::warn!("手动提炼失败(非阻断): {}", e), @@ -574,7 +816,8 @@ const EXTRACTION_SYSTEM_PROMPT: &str = "你是知识提炼引擎,从 AI 对话 /// 从对话中提炼知识,产出 candidate 写入知识库 /// -/// 流程: 读对话消息 → 过滤 user/assistant 取最后 6 条 → LLM 提炼(强制 JSON) → 解析 → 批量插入 candidate +/// 流程: 读对话消息 → 过滤 user/assistant 取最近 [`KNOWLEDGE_EXTRACT_WINDOW`] 条 → +/// LLM 提炼(强制 JSON) → 解析 → 批量插入 candidate /// /// 返回值: 成功插入的 candidate 条数(inserted)。调用方(maybe_spawn_extraction)据此置 /// `knowledge_extracted` 去重标志(≥1 才置位,0 条不置位—允许下次自动触发重试)。 @@ -636,12 +879,13 @@ async fn extract_knowledge_from_conversation( } } }; - // 过滤 user/assistant,取最后 6 条 + // 过滤 user/assistant,取最近 KNOWLEDGE_EXTRACT_WINDOW 条 + // (原 6 条窗口过窄:长会话后半程的经验不在提炼视野内;放宽后单次提炼可覆盖近期完整上下文) let recent: Vec<&ChatMessage> = messages .iter() .filter(|m| matches!(m.role, MessageRole::User | MessageRole::Assistant)) .rev() - .take(6) + .take(KNOWLEDGE_EXTRACT_WINDOW) .collect(); if recent.len() < 4 { return Ok(0); // 太短,不值得提炼(0 条,不置去重标志) @@ -947,4 +1191,74 @@ mod tests { assert_eq!(out.len(), 1); assert_eq!(out[0].id, "kw1"); } + + // ---------- 检索 query 分词(extract_query_keywords) ---------- + + #[test] + fn keywords_ascii_words_lowercased() { + let out = extract_query_keywords("修复 KnowledgeRepo 的 Search_Bug"); + assert!(out.contains(&"knowledgerepo".to_string()), "ASCII 词应小写: {:?}", out); + assert!(out.contains(&"search_bug".to_string()), "下划线应保留在词内: {:?}", out); + } + + #[test] + fn keywords_cjk_bigrams_extracted() { + let out = extract_query_keywords("修复知识库检索"); + // 连续汉字两两切:修复/复知/知识/识库/检索 + assert!(out.contains(&"修复".to_string())); + assert!(out.contains(&"知识".to_string())); + assert!(out.contains(&"检索".to_string())); + assert!(out.contains(&"复知".to_string()), "跨词 2-gram 允许存在(无词典近似的已知代价)"); + } + + #[test] + fn keywords_stopwords_filtered() { + let out = extract_query_keywords("帮我看看这个怎么修复"); + // 帮我/看看/这个/怎么全为停用词,只剩修复 + assert_eq!(out, vec!["修复".to_string()], "停用词应被过滤: {:?}", out); + } + + #[test] + fn keywords_short_ascii_dropped() { + let out = extract_query_keywords("use a x axis_config"); + // 单字符 a/x 被过滤(use 为英文停用词),保留 axis_config + assert_eq!(out, vec!["axis_config".to_string()]); + } + + #[test] + fn keywords_single_cjk_char_dropped() { + // 孤单汉字不成 2-gram,不产出 + let out = extract_query_keywords("好 的"); + assert!(out.is_empty(), "单字与停用词应全过滤: {:?}", out); + } + + #[test] + fn keywords_frequency_ranking_and_cap() { + let text = "tokio 出现多次 tokio 然后 tokio 还有 rust 与 rust 以及 postgres"; + let out = extract_query_keywords(text); + // 频次降序:tokio(3) > rust(2) > postgres(1);「然后」为停用词 + assert_eq!(out[0], "tokio"); + assert_eq!(out[1], "rust"); + assert!(out.contains(&"postgres".to_string())); + // 同频次按首现顺序稳定:构造 8 个互异词验证上限 6 + let many = extract_query_keywords("alpha beta gamma delta epsilon zeta eta theta"); + assert_eq!(many.len(), 6, "应截断到前 6 个: {:?}", many); + assert_eq!(many[0], "alpha", "同频次按首现顺序"); + } + + #[test] + fn keywords_empty_or_noise_returns_empty() { + assert!(extract_query_keywords("").is_empty()); + assert!(extract_query_keywords(" ,。!?").is_empty(), "纯标点应产出空"); + assert!(extract_query_keywords("帮我看看一下这个").is_empty(), "全停用词应产出空"); + } + + #[test] + fn keywords_mixed_ascii_cjk_segmented() { + let out = extract_query_keywords("用cargo编译失败error E0499"); + assert!(out.contains(&"cargo".to_string())); + assert!(out.contains(&"e0499".to_string()), "字母数字混合词应整体保留: {:?}", out); + assert!(out.contains(&"编译".to_string())); + assert!(out.contains(&"失败".to_string())); + } } diff --git a/src-tauri/src/commands/ai/tool_registry.rs b/src-tauri/src/commands/ai/tool_registry.rs index af264dc..21a9702 100644 --- a/src-tauri/src/commands/ai/tool_registry.rs +++ b/src-tauri/src/commands/ai/tool_registry.rs @@ -664,6 +664,7 @@ fn register_data_tools(registry: &mut AiToolRegistry, db: &Arc) { register_task_graph_tools(registry, db); register_workflow_tools(registry); register_idea_tools(registry, db); + register_knowledge_tools(registry, db); register_trash_tools(registry, db); register_git_tools(registry, db); } @@ -749,6 +750,21 @@ fn register_idea_tools(registry: &mut AiToolRegistry, db: &Arc) { super::tools::idea::register(registry, db); } +/// 知识库类 AI 工具注册(3 个:knowledge_search 检索 + knowledge_insert 沉淀 + +/// knowledge_promote 显式转正)——持 db:Arc。 +/// +/// 打通 aichat 对话侧与知识库:此前 KnowledgeRepo 的检索/写入仅有 IPC 命令与 MCP 入口, +/// LLM 工具注册表无对应工具,agent 对话中既查不了过往经验也无法沉淀要点(知识库与记忆 +/// 走查 2026-09-29 缺口 4)。insert 固定写 status='candidate'(LLM 写入不自动发布, +/// 与自动提炼同信任级),promote 补齐对话内显式转正通道(candidate→published 单向, +/// 与默认关闭的自动晋升互不影响),handler 细节见 tools/knowledge.rs。 +/// +/// 风险:search/insert 为 Low(检索只读;插入为本地库追加写,无覆盖无删除,落候选不进 +/// 检索面);promote 为 Medium(改既有条目状态进检索面,单向候选转正可 UI 归档修正)。 +fn register_knowledge_tools(registry: &mut AiToolRegistry, db: &Arc) { + super::tools::knowledge::register(registry, db); +} + /// 回收站类 AI 工具注册(1 个:list_trash)——持 db:Arc。 /// 抽自 register_data_tools(SMELL-P0-2 续拆),【原样移入】,零行为变更。 /// @@ -1303,7 +1319,7 @@ mod tests { // 任一层漏移 register 调用,此测试立即红。工具名集合也断言,防 rename 致 LLM tool 突变。 // ============================================================ - /// build_ai_tool_registry 应注册恰好 66 个工具(36 data + 14 file + 1 http + 1 fetch_url + 1 fetch_search + 1 generate_image + 1 get_app_config + 11 local_proxy),且工具名集合稳定。 + /// build_ai_tool_registry 应注册恰好 76 个工具(45 data + 15 file + 1 http + 1 fetch_url + 1 fetch_search + 1 generate_image + 1 get_app_config + 11 local_proxy),且工具名集合稳定。 /// /// 用 in-memory SQLite(Database::open_in_memory 自跑迁移),构造零外部依赖的 db, // 不实际执行任何 handler——仅断言注册阶段的定义完整性,故无需真实数据。 @@ -1368,18 +1384,24 @@ mod tests { // diff_files(2026-08-08): file 层 14→15(新增任意两文件内容对比,只读 Low, // 补 git_diff 仅仓库内缺口;复用 generate_diff LCS unified diff;namespace ALWAYS_LARGE_TOOLS 既有引用生效)。 // 73 = 42 data + 15 file + 1 http + 1 fetch_url + 1 fetch_search + 1 generate_image + 1 get_app_config + 11 local_proxy。 + // 知识库工具(2026-09-29): data 层 42→44(新增 knowledge_search/knowledge_insert, + // 打通对话侧与知识库双向检索/沉淀;insert 落 candidate 不自动发布,均为 Low)。 + // 75 = 44 data + 15 file + 1 http + 1 fetch_url + 1 fetch_search + 1 generate_image + 1 get_app_config + 11 local_proxy。 + // knowledge_promote(2026-10-01): data 层 44→45(新增候选知识显式转正工具, + // candidate→published 单向,补齐自动晋升默认关后的对话内审核通道,Medium)。 + // 76 = 45 data + 15 file + 1 http + 1 fetch_url + 1 fetch_search + 1 generate_image + 1 get_app_config + 11 local_proxy。 assert_eq!( registry.len(), - 73, - "工具总数应为 73(42 data + 15 file + 1 http + 1 fetch_url + 1 fetch_search + 1 generate_image + 1 get_app_config + 11 local_proxy),实际 {}", registry.len() + 76, + "工具总数应为 76(45 data + 15 file + 1 http + 1 fetch_url + 1 fetch_search + 1 generate_image + 1 get_app_config + 11 local_proxy),实际 {}", registry.len() ); // 工具名集合基线:防 rename / 漏注册 / 误删除。 - // data 层 42 个(持 db):CRUD/状态机/工作流/知识图谱任务关联 + 项目事件流 + 基础设施配置 + git 工具 + 工程模块写工具 + // data 层 45 个(持 db):CRUD/状态机/工作流/知识图谱任务关联 + 项目事件流 + 基础设施配置 + git 工具 + 工程模块写工具 + 知识库检索/沉淀/转正 // file 层 15 个(不持 db):命令/读/列/写/改/元/追加/删/移/搜/grep/环境探测/符号解析/下载/对比 // http 层 1 个(不持 db):http_request let mut expected: Vec<&str> = vec![ - // ── data 层 (42) ── + // ── data 层 (44) ── "list_projects", "list_tasks", "list_ideas", "update_project", "create_project", "bind_directory", "create_task", "update_task", "advance_task", @@ -1403,6 +1425,10 @@ mod tests { "git_status", "git_diff", "git_log", // Git 写工具 "git_commit", "git_branch", "git_merge", + // 知识库工具(2026-09-29):检索已发布知识 + 沉淀候选知识,打通对话侧与知识库 + "knowledge_search", "knowledge_insert", + // 候选知识显式转正(2026-10-01):candidate→published 单向,对话内审核通道 + "knowledge_promote", // ── file 层 (15) ──（run_command 注册顺序已移至末位降低 LLM 偏好, // 集合断言经 sort 后与顺序无关,仅守护工具名不漂移。grep 新增 F-260621; // detect_environment 新增 L1 环境感知 设计 §2.1;read_symbol 新增 AST 代码智能; diff --git a/src-tauri/src/commands/ai/tools/knowledge.rs b/src-tauri/src/commands/ai/tools/knowledge.rs new file mode 100644 index 0000000..45a67db --- /dev/null +++ b/src-tauri/src/commands/ai/tools/knowledge.rs @@ -0,0 +1,204 @@ +//! 知识库类 AI 工具声明式注册(knowledge_search + knowledge_insert + knowledge_promote 共 3 个)。 +//! +//! 背景:aichat 知识库与记忆走查(2026-09-29)缺口 4——知识库已有检索/写入的 Repo 与 +//! IPC 命令,但 LLM 工具注册表无对应工具,agent 对话中既查不了过往经验也无法沉淀要点, +//! 知识库对对话侧是「只进不出的孤岛」。本文件把 KnowledgeRepo 的检索/插入暴露为工具, +//! 让 agent 按需双向打通。 +//! +//! 信任级设计:knowledge_insert 固定写 status='candidate'(与自动提炼同信任级), +//! 不自动发布——LLM 写入未经人确认,直接 published 会污染检索面(检索只看 published); +//! 转正通道有二:①既有复用晋升(默认关,决策卡 C3 未拍板)与人工审核/UI 收件箱; +//! ②knowledge_promote 显式转正(对话内人工/agent 拍板,仅 candidate 可转,与自动晋升 +//! 互不影响)。insert 只负责落候选,转正须显式调用 promote,不存在隐式发布。 +//! +//! 溯源说明:工具 handler 只有 args 入参,无会话上下文注入机制,拿不到 conv_id, +//! 故 source_ref 记渠道标记 "ai-chat" 兜底(标识写入来源是 AI 对话,精确到会话待 +//! 上下文注入机制具备后补全)。 +//! +//! kind 默认值:任务草案默认 "fact",但 knowledges 表合法 kind 是 7 种 KnowledgeKind +//! snake_case(review_rule/prompt_template/pitfall/architecture_pattern/diagnosis/ +//! deployment_note/workflow_optimization,见 migrations.rs V7 注释),无 "fact"; +//! 表 DEFAULT 是 'pitfall',故跟随表语义默认 'pitfall'。knowledge_inject 有写 +//! "snippet" 的先例(表无 CHECK 约束),故不做硬白名单校验,非空即透传——过严校验 +//! 会把生态已在用的合法值拒成假失败。 + +use std::sync::Arc; + +use df_ai::ai_tools::{object_schema, AiToolRegistry, RiskLevel}; +use df_ai::declare_tool; +use df_storage::db::Database; +use df_storage::models::KnowledgeRecord; +use df_types::types::new_id; + +use crate::commands::knowledge_timeline::KnowledgeTimeline; +use crate::commands::now_millis; + +/// search 结果单条 content 的截断长度:知识全文可能很长,原样返回会回灌 prompt +/// 挤占上下文;截 500 字给 LLM 足够判断「这条是否相关」,需全文时走 IPC/前端看详情。 +const SEARCH_CONTENT_SNIPPET_LEN: usize = 500; + +/// 注册 3 个知识库工具(search/insert/promote)到 `$registry`。 +/// +/// 风险:search/insert 为 Low——search 只读;insert 是本地库追加写,无覆盖无删除,且落 +/// candidate 不进检索面,误写代价低(人工审核时丢弃即可),无需审批拦截。promote 为 +/// Medium——改既有条目状态(进检索面),但单向 candidate→published、SQL WHERE 收口 +/// 仅命中候选,禁降级/归档/改内容,误转正可在 UI 收件箱归档修正。 +pub fn register(registry: &mut AiToolRegistry, db: &Arc) { + // 检索工具:回答前查过往经验/约定(用户问「之前怎么处理的/有没有记过」时先 search) + declare_tool!( + registry, + db: Arc, + "knowledge_search", + "检索本地知识库(仅已发布知识,按关键词 LIKE 匹配,按复用次数降序)。使用时机:回答前需要过往经验/项目约定/踩坑记录时调用,如用户问「之前怎么解决的」「有没有相关约定」。用户说「记住/记一下/以后注意」时不要用本工具,改用 knowledge_insert。参数:query=知识主题关键词(必填),limit=返回条数(可选,默认 5,上限 10)", + RiskLevel::Low, + schema: object_schema(vec![("query", "string", true), ("limit", "integer", false)]), + args => { + let query = args["query"].as_str().ok_or_else(|| anyhow::anyhow!("缺少 query"))?; + if query.trim().is_empty() { + anyhow::bail!("query 不能为空"); + } + let limit = args["limit"].as_u64().unwrap_or(5).clamp(1, 10) as usize; + let repo = df_storage::crud::KnowledgeRepo::new(&db); + let hits = repo.search(query, None, limit).await?; + // 空结果返回可执行的下一步指引而非裸空数组:弱模型拿到 [] 常直接回「没找到」 + // 结束,带上「让用户口述 + insert 沉淀」能把检索失败转化为知识积累入口。 + if hits.is_empty() { + return Ok(serde_json::json!({ + "results": [], + "hint": "知识库中无相关知识。可提示用户直接口述要点,然后用 knowledge_insert 沉淀。" + })); + } + let results: Vec = hits + .iter() + .map(|k| { + // 按 chars 截断而非字节切片:中文内容按字节切会落在 UTF-8 边界上 panic + let snippet = if k.content.chars().count() > SEARCH_CONTENT_SNIPPET_LEN { + let truncated: String = k + .content + .chars() + .take(SEARCH_CONTENT_SNIPPET_LEN) + .collect(); + format!("{truncated}…") + } else { + k.content.clone() + }; + serde_json::json!({ + "title": k.title, + "kind": k.kind, + "content": snippet, + "status": k.status, + "reuse_count": k.reuse_count, + }) + }) + .collect(); + Ok(serde_json::json!({ "results": results })) + } + ); + + // 沉淀工具:用户说「记住/记一下/以后注意」时把要点落为候选知识 + declare_tool!( + registry, + db: Arc, + "knowledge_insert", + "把一条经验/约定/踩坑要点沉淀进本地知识库(写入为候选知识,经复用或人工审核后转正,不会立即进入检索)。使用时机:用户说「记住/记一下/以后注意/这是我踩过的坑」时调用,先提炼要点再写入。参数:title=一句话概括(必填),content=要点详情(必填),kind=知识类型(可选,常用:pitfall 踩坑/architecture_pattern 架构模式/diagnosis 诊断/review_rule 评审规则/prompt_template 提示词模板/deployment_note 部署要点/workflow_optimization 流程优化,默认 pitfall),tags=标签数组(可选)。回答前查已有知识请用 knowledge_search", + RiskLevel::Low, + schema: object_schema(vec![ + ("title", "string", true), + ("content", "string", true), + ("kind", "string", false), + ("tags", "array", false), + ]), + args => { + let title = args["title"].as_str().ok_or_else(|| anyhow::anyhow!("缺少 title"))?; + let content = args["content"].as_str().ok_or_else(|| anyhow::anyhow!("缺少 content"))?; + if title.trim().is_empty() || content.trim().is_empty() { + anyhow::bail!("title 和 content 不能为空"); + } + // 非空即透传不做硬白名单(见模块注释:snippet 先例,过严校验制造假失败) + let kind = match args["kind"].as_str() { + Some(k) if !k.trim().is_empty() => k.trim().to_string(), + _ => "pitfall".to_string(), + }; + // tags 统一序列化为 JSON 数组字符串落库(与表 tags 列约定一致, KnowledgeRecord.tags=JSON 数组字符串) + let tags = args["tags"].as_array().map(|arr| { + let items: Vec = arr + .iter() + .filter_map(|v| v.as_str().map(|s| s.to_string())) + .collect(); + serde_json::to_string(&items).unwrap_or_else(|_| "[]".to_string()) + }); + let now = now_millis(); + let record = KnowledgeRecord { + id: new_id(), + kind, + title: title.trim().to_string(), + content: content.trim().to_string(), + tags, + // LLM 写入不自动发布:与自动提炼同信任级,经复用晋升或人工审核转正 + status: "candidate".to_string(), + confidence: None, + reuse_count: 0, + verified: false, + source_project: None, + // handler 无会话上下文,拿不到 conv_id,记渠道标记兜底溯源 + source_ref: Some("ai-chat".to_string()), + reasoning: None, + embedding_status: None, + created_at: now.clone(), + updated_at: now, + }; + let id = record.id.clone(); + let kind_out = record.kind.clone(); + let repo = df_storage::crud::KnowledgeRepo::new(&db); + repo.insert(record).await?; + Ok(serde_json::json!({ + "id": id, + "title": title, + "kind": kind_out, + "status": "candidate", + "note": "已记录为候选知识,复用或审核后转正" + })) + } + ); + + // 显式转正工具:对话内人工/agent 拍板 candidate → published,补齐「检索/沉淀之外 + // 缺显式转正路径」的通道缺口。自动晋升(auto_publish,默认关)与本工具互不影响: + // 前者靠复用计数达标,本工具靠显式调用,SQL WHERE 均只命中 candidate,天然幂等。 + // 转正后经 KnowledgeTimeline 记 status_changed(source_ref="agent")留痕供审计, + // fire-and-forget 与 knowledge_inject 晋升留痕同风格(fire 内部吞错误只 warn)。 + declare_tool!( + registry, + db: Arc, + "knowledge_promote", + "把一条候选知识显式转正为已发布(candidate → published 单向,转正后进入检索面)。使用时机:用户明确认可某条候选知识时调用,如「这条可以转正/发布/采纳」,先用 knowledge_search 确认、或从 knowledge_insert 的返回拿到知识 ID。边界:仅 status=candidate 的知识可转正,已发布/已归档会返回明确错误;本工具不降级、不归档、不改内容。与自动晋升(默认关闭)互不影响,属于显式人工/agent 审核通道。参数:id=知识 ID(必填)", + RiskLevel::Medium, + schema: object_schema(vec![("id", "string", true)]), + args => { + let id = args["id"].as_str().ok_or_else(|| anyhow::anyhow!("缺少 id"))?; + if id.trim().is_empty() { + anyhow::bail!("id 不能为空"); + } + let repo = df_storage::crud::KnowledgeRepo::new(&db); + if !repo.promote(id).await? { + // false = id 不存在 或 非 candidate,查一次回明确文案防 LLM 盲重试 + let current = repo.get_by_id(id).await?; + match current { + None => anyhow::bail!("知识不存在: {id}"), + Some(rec) => anyhow::bail!( + "仅 candidate 可转正(当前状态: {},id: {id}),已发布/已归档知识不做变更", + rec.status + ), + } + } + // 留痕:生命线记 status_changed(source_ref="agent"),fire-and-forget 非阻断 + KnowledgeTimeline::new(&db) + .record_manual_publish(id, "agent") + .await; + Ok(serde_json::json!({ + "id": id, + "status": "published", + "note": "已转正为已发布,进入检索面" + })) + } + ); +} diff --git a/src-tauri/src/commands/knowledge_timeline.rs b/src-tauri/src/commands/knowledge_timeline.rs index 3466a65..d43326b 100644 --- a/src-tauri/src/commands/knowledge_timeline.rs +++ b/src-tauri/src/commands/knowledge_timeline.rs @@ -153,6 +153,46 @@ impl KnowledgeTimeline { self.fire(knowledge_id, EVENT_STATUS_CHANGED, None, Some(ctx)).await; } + /// 复用达标自动晋升(candidate 转 published;context: from / to / threshold) + /// + /// 复用即信任路径的晋升留痕,与人工审核的 status_changed 同事件类型, + /// source_ref=auto_publish 区分晋升来源(供审计区分未审核固化与人工放行)。 + pub async fn record_auto_publish(&self, knowledge_id: &str, threshold: i64) { + let ctx = serde_json::json!({ + "from": "candidate", + "to": "published", + "threshold": threshold, + }) + .to_string(); + self.fire( + knowledge_id, + EVENT_STATUS_CHANGED, + Some("auto_publish".into()), + Some(ctx), + ) + .await; + } + + /// 显式转正(candidate 转 published;context: from / to;source_ref=晋升来源) + /// + /// 人工/agent 拍板路径的晋升留痕,与自动晋升 record_auto_publish 同事件类型, + /// source_ref 由调用方传入(如 "agent"=对话内 knowledge_promote 工具)区分晋升来源, + /// 供审计区分未审核固化、复用达标固化与显式放行。 + pub async fn record_manual_publish(&self, knowledge_id: &str, source: &str) { + let ctx = serde_json::json!({ + "from": "candidate", + "to": "published", + }) + .to_string(); + self.fire( + knowledge_id, + EVENT_STATUS_CHANGED, + Some(source.to_string()), + Some(ctx), + ) + .await; + } + /// 内部:写入并吞错误(fire-and-forget,失败只 warn 不阻断主流程) async fn fire( &self, diff --git a/src-tauri/src/state/knowledge_config.rs b/src-tauri/src/state/knowledge_config.rs index 51880f1..4a9f9d3 100644 --- a/src-tauri/src/state/knowledge_config.rs +++ b/src-tauri/src/state/knowledge_config.rs @@ -46,6 +46,38 @@ pub struct KnowledgeConfig { /// embedding 模型名(如 embedding-3 / text-embedding-3-small) #[serde(default)] pub embedding_model: Option, + /// 检索纳入 candidate(AI 自动提炼产物)开关,默认 true + /// + /// 背景(知识库走查 2026-09-29):自动提炼产物全部滞留 candidate 而检索只认 published, + /// 存量知识近乎零生效。纳入后配合「复用即信任」(reuse_count 达标自动晋升 published), + /// 人工审核降级为可选修正路径。关=回到仅 published(兼容旧行为)。 + /// serde default=true:已持久化的旧配置 JSON 缺该字段时按新默认生效,不破坏启动恢复。 + #[serde(default = "default_include_candidates")] + pub include_candidates: bool, + /// 复用即信任自动晋升开关,默认 false + /// + /// 背景(决策单未拍板前默认保守):candidate 命中达标自动转正 published 是单向固化 + /// (无回退路径),且 2-gram 分词的误命中同样计入 reuse_count,未审核的 LLM 提炼产物 + /// 可能经误命中固化污染知识库。晋升固化路径默认关,待决策卡 C3 拍板后由用户显式开启。 + /// serde default=false:已持久化的旧配置 JSON 缺该字段时按保守默认生效,不破坏启动恢复。 + #[serde(default)] + pub auto_publish_enabled: bool, + /// 自动晋升的复用命中阈值,默认 5 + /// + /// 原硬编码 2 过激进:2-gram 分词的误命中两次即可凑满转正;5 次真实复用才够格晋升。 + /// serde default=5:旧配置 JSON 缺该字段时按新默认生效。 + #[serde(default = "default_auto_publish_reuse_threshold")] + pub auto_publish_reuse_threshold: i64, +} + +/// include_candidates 的 serde 默认值(true 语义名收口,与 Default impl 保持一处语义) +fn default_include_candidates() -> bool { + true +} + +/// auto_publish_reuse_threshold 的 serde 默认值(5 语义名收口,与 Default impl 保持一处语义) +fn default_auto_publish_reuse_threshold() -> i64 { + 5 } impl Default for KnowledgeConfig { @@ -58,6 +90,9 @@ impl Default for KnowledgeConfig { vector_enabled: false, embedding_provider_id: None, embedding_model: None, + include_candidates: true, + auto_publish_enabled: false, + auto_publish_reuse_threshold: 5, } } } diff --git a/src/api/types.ts b/src/api/types.ts index a8c7ab4..94bfdda 100644 --- a/src/api/types.ts +++ b/src/api/types.ts @@ -696,6 +696,11 @@ export interface AiToolCallInfo { /** path_auth 审批链阶段3b:'path' 类挂起携带的原始路径(工具调用参数中的 path)。 * ToolCard 审批提示文案展示用(LLM 想访问 path,父目录为 dir)。'risk' 类为 undefined。 */ path?: string + /** 工具开始执行时间(前端在 AiToolCallStarted 时记录,毫秒)。历史消息从 DB 回载无此字段, + * 后端事件协议不含耗时,卡片耗时/轨迹总耗时由前端时间差计算,缺字段时隐藏不显 0。 */ + startedAt?: number + /** 工具执行完成时间(前端在 AiToolCallCompleted 时记录,毫秒)。语义同 startedAt。 */ + completedAt?: number /** * A2-B10 conv-scoped 审批收尾:挂起审批所属的会话 id(前端判定用,仅挂起项设置)。 * 来源:AiApprovalRequired / AiDirAuthRequired(统一审批归一)事件透传 conversation_id