lxy/DevFlow
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

新增: 批次工作落地(推进链/评估闭环/事件总线/并发/加固) + 技术债清理 + 文档整理

Browse Source 
后端:
- 工作流推进链(D-03):advance_task/状态机/闸门走 df-nodes Node trait,conditions 条件引擎扩展
- 想法评估闭环:启发式评分+对抗评估,df-ideas/scoring + df-storage/idea_eval_repo + idea 前端打通
- 全局事件数据总线:df-ai/context+context_helpers+augmentation 跨模块解耦
- AI planner/plan_hint/intent:aichat B 路线并行多轮基础
- patch_file 加固(TD-03/04):读改写整体锁防 lost update,expected_hash 合约闭环
- 压缩超时兜底(F-15 卡死根治)
- F-09 多会话并发:LlmConcurrency per-conv + streamingGuard 前端守护 + verify 脚本
- 知识注入 DRY/skills/audit 扩展

清理:
- aichat 技术债(误报 allow/死导入/过时注释 30 项)
- URGENT.md 删除(11 项加急全解决/迁 todo)
- 文档整理(todo/待决策/待审查/ARCHITECTURE/INDEX + 总线/技术债审查新文档)
This commit is contained in:
绝尘
2026-06-21 20:51:26 +08:00
parent 330bb7f505
commit bd6a41fe6e
111 changed files with 11932 additions and 1034 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
src-tauri/Cargo.toml
View File

@@ -23,6 +23,8 @@ tokio.workspace = true
anyhow.workspace = true
tracing.workspace = true
chrono.workspace = true
# augmentation::MentionResolver async trait(Input Augmentation 层核心设计2)
async-trait = { workspace = true }
# 后端 crate
df-types = { path = "../crates/df-types" }
@@ -39,6 +41,9 @@ futures = "0.3"
base64 = "0.22"
# validate_path URL 解码:防 %2e%2e 等 URL 编码绕过路径遍历检查(BUG-260617-03)
percent-encoding = "2"
# grep AI 工具:跨文件内容搜索(grep -rn 模式),pattern 支持正则。
# workspace regex 已存在(df-ideas 用),此处引用 workspace 版本避免双后端。
regex = { workspace = true }
# keyring:密钥解析下沉到 df-storage(workspace 统一声明平台 feature),
# src-tauri 经 workspace 引用(转发壳 build_provider_for 不直接碰 keyring,但旧路径/兼容保留)。
# 根因见 docs/09-问题排查/aichat-apikey-401排查-2026-06-15.md
@@ -47,3 +52,15 @@ keyring = { workspace = true }
# 复用 df-ai 同款 reqwest 0.12(同版本锁定,避免双 TLS 后端)。默认 native-tls(与 df-ai 一致),
# 启用 json(响应解析)/gzip/brotli(透明解压,常见 API 必备)。重定向手动接管(见 http.rs SSRF)。
reqwest = { version = "0.12", features = ["json", "gzip", "brotli"] }
# 阶段3a/3b 统一审批模型开关(path_auth 审批链扎实重构 plan 阶段3)。
# 3a 后端合并(单 HashMap + kind 字段)为编译期结构性变更,本 flag 用于文档标记 +
# 后续 3b 前端切换开关;3a 本身是单编译路径(合并是原子操作,回退走 git revert)。
#
# 阶段4 容错/恢复开关(path_auth 审批链扎实重构 plan 阶段4):
# retry_count 同 tc_id 重试断路(防 LLM 死循环重试同卡死工具)+ 跨盘预检提示 +
# rename_file/delete_file 跨卷统一降级 helper + ai_pending_tool_calls 返 kind。
# 兜底:flag 关 → retry_count 恒 0(等价单次审批执行),其余 helper 行为不变(纯增强)。
[features]
df-ai-unified-approval = []
df-ai-approval-retry = []

14
src-tauri/src/commands/ai/agentic/guard.rs
View File

@@ -1,7 +1,7 @@
//! B-260615-09: generating 状态 RAII guard —— 从 agentic.rs 抽离(重构第一批,纯结构搬迁)。
//! B-260615-09: generating 状态 RAII guard —— 从 agentic/mod.rs 抽离(重构第一批,纯结构搬迁)。
//!
//! 行为零变更:仅文件位置移动,逻辑/字段/语义完全保留。
//! 调用方(agentic.rs run_agentic_loop)经 `use super::guard::GeneratingGuard;` 复用。
//! 调用方(agentic/mod.rs run_agentic_loop)经 `use super::guard::GeneratingGuard;` 复用。
use std::sync::Arc;
@@ -19,11 +19,9 @@ use crate::commands::ai::AiSession;
/// 注:try_continue_agent_loop 不用 guard——其 should_continue=false 路径需保持
/// generating=true(审批等待态),全函数 guard 会误复位;该函数单点 provider-Err 复位保持手动。
///
/// F-260616-09 B 批2:guard 持 `conv_id`,复位改写 `session.conv(&conv_id).generating = false`
/// (per-conv 真相源)。同时**双写顶层 `session.generating = false`** 作共存期桥接 —— 批2
/// 仅迁移 agentic.rs 路径,IPC(ai_is_generating/ai_chat_send)仍读顶层,故 guard 须双写
/// 保证 IPC 读到正确值(否则前端 ai_is_generating 永远 true 卡死发送)。批4 IPC 迁移后
/// 顶层双写移除。
/// F-260616-09 B 批4:guard 持 `conv_id`,复位改写 `session.conv(&conv_id).generating = false`
/// (per-conv 唯一真相源)。顶层 `session.generating` 字段已在批4 删除,reset/Drop 仅写 per_conv;
/// IPC(ai_is_generating/ai_chat_send 等)亦改读 per_conv,无需双写桥接。
pub(super) struct GeneratingGuard {
session: Arc<Mutex<AiSession>>,
/// guard 所属会话(loop 启动时快照的 conv_id,来自 run_agentic_loop 入参)。
@@ -38,7 +36,7 @@ impl GeneratingGuard {
/// 显式复位 generating=false。emit 前调用保证顺序。幂等。
///
/// 双写:per_conv.conv_id.generating(新真相源)+ 顶层 generating(共存期 IPC 桥接)。
/// 仅写 per_conv.conv_id.generating(唯一真相源)。
pub(super) async fn reset(&mut self) {
if !self.done {
let mut session = self.session.lock().await;

229
src-tauri/src/commands/ai/agentic/mod.rs
View File

@@ -8,13 +8,19 @@ use tokio::sync::Mutex;
use df_ai::ai_tools::AiToolRegistry;
use df_ai::context::TokenEstimator;
// 阶段2 占位配对完整性:agentic 出口第二道防线断言(深度防御)。
use df_ai::context::ContextManager;
// 改进3 B: 压缩失败兜底关键词摘要(纯函数 extract_keyword_summary)。
// 改进4: 工具结果 view-only 摘要(should_summarize_tool_result / extract_key_info)。
use df_ai::context_helpers::{
extract_key_info, extract_keyword_summary, should_summarize_tool_result,
PLACEHOLDER_INTEGRITY_ENABLED,
};
// 改进2 B:意图收敛工具(LLM 可见 tool_defs 按 intent 过滤,执行路径仍走完整 registry)
use df_ai::intent::{filter_tool_defs, IntentRecognizer};
// B 路线 Phase 1:plan_hint 接入主 loop——filter_tool_defs_planned 在 filter_tool_defs
// 收敛的扁平子集之上叠加 plan_hint 编排(并行组同批聚拢/顺序依赖源在前),供 LLM 看到
// 一份按编排意图排序的工具列表。feature flag PLANNING_ENABLED(false 默认关)门控接入。
use df_ai::intent::{filter_tool_defs, filter_tool_defs_planned, IntentRecognizer};
use df_ai::provider::{ChatMessage, CompletionRequest, LlmProvider};
// CR-30-1: 复用 retry::backoff_delay(jitter 1s→2s→4s) + is_status_retryable(Fatal 分类)
// 实现流前失败重试退避对齐(决策 F-260616-07 a1),避免重写退避逻辑。
@@ -36,12 +42,22 @@ use crate::state::{AppState, LlmConcurrency};
use super::audit::process_tool_calls;
use super::compress::compress_via_llm;
use super::conversation::{save_conversation, TokenAccumulator};
use super::knowledge_inject::maybe_spawn_extraction;
use super::knowledge_inject::{inject_knowledge_into_prompt, maybe_spawn_extraction};
use super::prompt::{build_system_prompt, get_active_provider};
use super::stream_recv::{stream_llm, StreamResult};
use super::title::{ensure_conversation_title, spawn_ensure_title};
use super::{AiChatEvent, AiSession, ErrorType};
use super::{AiChatEvent, AiSession, ErrorType, SessionState};
/// L1 补丁:run_agentic_loop 入口 provider 解析超时保护的内部错误类型。
///
/// 用于把 provider 解析块(list_all + select + resolve + ensure + build)包入
/// `tokio::time::timeout` 后的内部 Err 路由——区分 ensure_resolved_key 失败(走 Auth
/// 错误)与整体超时(走 Unknown 错误)。超时由外层 timeout 的 Err(Elapsed) 单独匹配。
enum ProviderResolveError {
/// ensure_resolved_key 失败(key 缺失/钥匙串损坏):走 Auth 错误分支(对齐原 :412 处理)。
EnsureKeyFailed(String),
}
/// Agentic 循环默认最大迭代次数（可配置项的默认值）
///
@@ -90,6 +106,24 @@ pub const TOOL_RESULT_COMPRESS_ENABLED: bool = true;
/// 保守:双高置信才标(任一 topic None 不标),不强制 LLM(软提示非硬约束)。
pub const TOPIC_MARKER_ENABLED: bool = true;
// 阶段2(path_auth 审批链重构):占位配对完整性开关(解 400 orphan)。
//
// 单一真相源:`df_ai::context_helpers::PLACEHOLDER_INTEGRITY_ENABLED`(本模块顶部已 use)。
// 删除本地副本(B 路线改进:避免与 df-ai 同名 const 双源,改一处易漏改另一处)。
//
// 根因:审批挂起占位 tool_result(内容 audit/cache.rs:pending_placeholder_for,带
// `__PENDING__:tc_id` 标记)与其 tool_call 头经 sanitize/裁剪后可能丢配对头 → orphan
// tool_result → deepseek-v4-pro 等端点 400。df-ai 的 sanitize_messages step3.5(反向
// orphan)已豁免保留占位,build_for_request 出口已用 assert_placeholder_pairing 自愈补头。
//
// 该开关控制 agentic loop 末尾(build_for_request + tool_result 压缩后)的**第二道防线**
// 出口断言:在 messages 送 stream 前再过一次 assert_placeholder_pairing(depth-defense,
// 防 build_for_request 到送 stream 之间的转换引入新 orphan)。
//
// true(默认):agentic 出口再断言一次占位配对,失败自愈补头。
// false(回退):agentic 出口不断言(仅依赖 df-ai build_for_request 内部一次自愈,旧行为)。
// 兜底:flag 关→等价改动前(仅 df-ai 内部自愈);view-only 不改持久化。
// ============================================================
// 重构第一批(2026-06-19):GeneratingGuard 抽离到 guard.rs(纯结构搬迁,行为零变更)。
// run_agentic_loop 内仍 `GeneratingGuard::new(...)`,路径从本模块改 super::guard。
@@ -185,7 +219,7 @@ async fn stream_one_provider(
// 否则用 resolved_model(绝不因 override 致无模型)。
let resolved_model = match model_override.as_deref() {
Some(id) if !id.is_empty()
&& candidate.model_configs.iter().any(|m| m.model_id == id) =>
&& candidate.model_configs.iter().any(|m| m.model_id == id && m.enabled) =>
{
id.to_string()
}
@@ -326,7 +360,7 @@ pub(crate) async fn run_agentic_loop(
// F-260616-09 B 批2 入口桥接:loop 启动前确保 per_conv 存在(已存在则保留累积,不存在则建)。
//
// 批2 把所有调用方(IPC commands.rs 写路径 + agentic.rs loop + audit.rs process_tool_calls +
// 批2 把所有调用方(IPC commands.rs 写路径 + agentic/mod.rs loop + audit.rs process_tool_calls +
// conversation.rs save + title.rs + knowledge_inject.rs)迁移到 per_conv 真相源。IPC 在 spawn
// loop 前已通过 `session.conv(active_conversation_id).*` 建立 per_conv 并写入初始状态
// (messages push user / generating=true / stop_flag=false / iteration_used=0 等),故 loop
@@ -363,53 +397,63 @@ pub(crate) async fn run_agentic_loop(
// AiProviderRepo::new 仅 clone Arc<Database>(廉价),不复用 AppState.ai_providers
// (run_agentic_loop 签名只传 Arc<Database>,改签名会牵动 3 调用点 + try_continue)。
let provider_repo = df_storage::crud::AiProviderRepo::new(&db);
let pool_providers: Vec<AiProviderRecord> = match provider_repo.list_all().await {
Ok(v) => v,
Err(e) => {
tracing::warn!(error = %e, "[ai] list_all providers 失败,负载均衡池退化为入参默认 provider(空池兜底)");
Vec::new()
}
};
let ranked_candidates: Vec<AiProviderRecord> = super::provider_pool::ProviderPool::select(
&pool_providers,
// specify 模式(用户指定 model):传 override 作亲和键,ProviderPool 优先选
// 「池中含该 model 的 provider」作 primary,打破下方「router 选模型需 provider_config」
// 的鸡生蛋——override 此时已知(入参 ← session.model_override),无须等 router。
// auto 模式(override=None)→ 全亲和纯权重排序,行为不变(向后兼容)。
model_override.as_deref(),
);
let (primary_provider, candidates): (AiProviderRecord, Vec<AiProviderRecord>) =
match ranked_candidates.split_first() {
Some((first, rest)) => (first.clone(), rest.to_vec()),
None => {
// 空池兜底:用调用方传入的 provider_config 作唯一候选(启动行为不变)。
// candidates 空 → fallback 循环仅跑 primary 一次,等同单 provider 路径。
(provider_config.clone(), Vec::new())
}
};
// 用主候选覆盖入参 provider_config(下游 build_provider / 路由 / 日志均用此)。
// mut:F-04b 切换 candidate 后更新为实际成功所用 provider(供后续 push/save/标题 spawn)。
let mut provider_config = primary_provider;
// FR-S1: resolve→ensure_resolved_key(空 key 早失败)→build_provider 三步统一走工厂
// 空 key 早失败(逻辑见 secret::ensure_resolved_key 单测):避免空 key 发请求吃 401,错误伪装成"API Key 无效"
//
// B-260615-17:resolve 一次复用——原实现 build_provider_for 成功后又独立调 resolve_provider_secret
// 取 key_len(重复 keyring resolve)。现 resolve 一次:既供 key_len 诊断日志,又供 build_provider,
// 去重复 keyring resolve 调用。逻辑等价于 secret::build_provider_for(resolve→ensure→build 三步),
// 仅因 build_provider_for 隐藏 resolved key 无法复用而在此内联(未改 secret.rs 锁边界)。
let resolved_key = super::secret::resolve_provider_secret(&provider_config);
let key_len = resolved_key.len();
let provider: Box<dyn LlmProvider> = match super::secret::ensure_resolved_key(
&provider_config.name, &resolved_key,
) {
Ok(()) => df_ai::build_provider(
&provider_config.provider_type,
&provider_config.base_url,
&resolved_key,
&provider_config.default_model,
),
Err(msg) => {
// L1 补丁:provider 解析(list_all + select + resolve + ensure + build)整体包 30s timeout。
// 原实现无超时,数据库/keyring 卡死时 run_agentic_loop 入口卡住,generating 永真 + 前端看门狗
// 超时静默吞消息。超时走 AiError 分支(对齐 :412 ensure_resolved_key 失败处理),guard.reset 复位。
// 内部 list_all 失败仍容忍(空池兜底,行为不变);仅整体超时(如 DB 挂死无响应)才走 Err 分支。
let provider_resolve = tokio::time::timeout(
std::time::Duration::from_secs(30),
async {
let pool_providers: Vec<AiProviderRecord> = match provider_repo.list_all().await {
Ok(v) => v,
Err(e) => {
tracing::warn!(error = %e, "[ai] list_all providers 失败,负载均衡池退化为入参默认 provider(空池兜底)");
Vec::new()
}
};
let ranked_candidates: Vec<AiProviderRecord> = super::provider_pool::ProviderPool::select(
&pool_providers,
// specify 模式(用户指定 model):传 override 作亲和键,ProviderPool 优先选
// 「池中含该 model 的 provider」作 primary,打破下方「router 选模型需 provider_config」
// 的鸡生蛋——override 此时已知(入参 ← session.model_override),无须等 router。
// auto 模式(override=None)→ 全亲和纯权重排序,行为不变(向后兼容)。
model_override.as_deref(),
);
let (primary_provider, candidates): (AiProviderRecord, Vec<AiProviderRecord>) =
match ranked_candidates.split_first() {
Some((first, rest)) => (first.clone(), rest.to_vec()),
None => {
// 空池兜底:用调用方传入的 provider_config 作唯一候选(启动行为不变)。
// candidates 空 → fallback 循环仅跑 primary 一次,等同单 provider 路径。
(provider_config.clone(), Vec::new())
}
};
// FR-S1: resolve→ensure_resolved_key(空 key 早失败)→build_provider 三步统一走工厂
// 空 key 早失败(逻辑见 secret::ensure_resolved_key 单测):避免空 key 发请求吃 401,错误伪装成"API Key 无效"
//
// B-260615-17:resolve 一次复用——原实现 build_provider_for 成功后又独立调 resolve_provider_secret
// 取 key_len(重复 keyring resolve)。现 resolve 一次:既供 key_len 诊断日志,又供 build_provider,
// 去重复 keyring resolve 调用。逻辑等价于 secret::build_provider_for(resolve→ensure→build 三步),
// 仅因 build_provider_for 隐藏 resolved key 无法复用而在此内联(未改 secret.rs 锁边界)。
let resolved_key = super::secret::resolve_provider_secret(&primary_provider);
let key_len = resolved_key.len();
let provider: Box<dyn LlmProvider> = match super::secret::ensure_resolved_key(
&primary_provider.name, &resolved_key,
) {
Ok(()) => df_ai::build_provider(
&primary_provider.provider_type,
&primary_provider.base_url,
&resolved_key,
&primary_provider.default_model,
),
Err(msg) => return Err(ProviderResolveError::EnsureKeyFailed(msg)),
};
Ok::<_, ProviderResolveError>((primary_provider, candidates, provider, key_len))
},
).await;
let (primary_provider, candidates, provider, key_len) = match provider_resolve {
Ok(Ok((pc, cands, prov, kl))) => (pc, cands, prov, kl),
Ok(Err(ProviderResolveError::EnsureKeyFailed(msg))) => {
guard.reset().await;
let _ = app_handle.emit("ai-chat-event", AiChatEvent::AiError {
error: msg,
@@ -419,7 +463,22 @@ pub(crate) async fn run_agentic_loop(
});
return;
}
Err(_elapsed) => {
// L1 补丁:provider 解析 30s 超时(DB list_all / keyring resolve 卡死)。
// 走 AiError 分支复位 generating,对齐 ensure_resolved_key 失败处理口径。
guard.reset().await;
tracing::error!(conv_id = %conv_id, "[ai] provider 解析超时(30s),可能 DB/keyring 卡死");
let _ = app_handle.emit("ai-chat-event", AiChatEvent::AiError {
error: "Provider 解析超时(30s),请检查数据库/钥匙串状态后重试".to_string(),
error_type: Some(ErrorType::Unknown),
conversation_id: Some(conv_id.clone()),
});
return;
}
};
// 用主候选覆盖入参 provider_config(下游 build_provider / 路由 / 日志均用此)。
// mut:F-04b 切换 candidate 后更新为实际成功所用 provider(供后续 push/save/标题 spawn)。
let mut provider_config = primary_provider;
// 诊断日志:401/错误时据此定位是 url/type/model/key 哪项问题(只记长度不记明文)
tracing::info!(
provider = %provider_config.name,
@@ -447,7 +506,7 @@ pub(crate) async fn run_agentic_loop(
// (新 candidate 模型池不同,必须重选);此后 push/save 均用迭代最新值。
let mut resolved_model = match model_override.as_deref() {
Some(id) if !id.is_empty()
&& provider_config.model_configs.iter().any(|m| m.model_id == id) =>
&& provider_config.model_configs.iter().any(|m| m.model_id == id && m.enabled) =>
{
id.to_string()
}
@@ -484,8 +543,28 @@ pub(crate) async fn run_agentic_loop(
const INTENT_CONF_THRESHOLD: f32 = 0.7;
let all_defs = tools_arc.tool_definitions();
let total = all_defs.len(); // 提前记录全量数(all_defs 将 move 进 tool_defs)
// B 路线 Phase 1 接入:PLANNING_ENABLED(false 默认关)门控 plan_hint 编排。
//
// **零行为变更(关时)**:flag 关时走 filter_tool_defs(intent 收敛扁平子集),
// 与 Phase 1 接入前完全一致——现有 intent/agentic 测试全绿无回归。
//
// **开启时**:调 filter_tool_defs_planned,它内部先 filter_tool_defs 收敛再叠加
// plan_hint 编排(并行组同批聚拢/顺序依赖源在前)。三重 fallback 与 filter_tool_defs
// 同语义(plan_hint 空/非法/registry 漂移均退 filter_tool_defs 扁平结果)。
//
// 关键安全(与 filter_tool_defs 同):本段只改 LLM 可见 tool_defs 的可见性/顺序,
// 不改执行(audit 走 tools_arc 完整 registry)。PLAN_HINT_ENABLED(plan_hint 函数开关,
// Phase0a 就绪 true)与 PLANNING_ENABLED(planner.rs 主 loop 规划开关,本批仍是 false)
// 分离:即使将来 PLANNING_ENABLED 翻 true,plan_hint 内部 PLAN_HINT_ENABLED 关闭时
// filter_tool_defs_planned 仍退扁平(双层开关,任一关闭均退旧行为)。
let tool_defs = if conf >= INTENT_CONF_THRESHOLD {
let filtered = filter_tool_defs(&all_defs, &intent);
let filtered = if df_ai::planner::PLANNING_ENABLED {
// Phase 1:plan_hint 编排排序。intent_label 供 plan_hint 备用(当前规则纯关键词驱动)。
filter_tool_defs_planned(&all_defs, &intent, intent.as_str(), &user_text)
} else {
// 旧行为:intent 收敛扁平子集(零行为变更,flag 默认关走此路)。
filter_tool_defs(&all_defs, &intent)
};
if filtered.len() < 3 {
all_defs // 兜底:过滤<3(漂移/误收敛)回全量
} else {
@@ -500,6 +579,7 @@ pub(crate) async fn run_agentic_loop(
conf,
filtered = tool_defs.len(),
total,
planning_enabled = df_ai::planner::PLANNING_ENABLED,
"[ai] 意图收敛工具"
);
// 停止信号副本：stream_llm 与每轮迭代共享读取，避免重复加锁
@@ -539,7 +619,9 @@ pub(crate) async fn run_agentic_loop(
// retry 同 loop 内,持 per_conv 合理(F-260616-12 核验)。
let _conv_per_conv_permit = llm_concurrency.acquire_per_conv(&conv_id).await;
for iteration in start_iteration..max_iterations {
// 0 = 不限:effective_max=usize::MAX,for 到不了上界,靠 stop_flag/收敛/审批退出(下方达上限暂停分支不触发)
let effective_max = if max_iterations == 0 { usize::MAX } else { max_iterations };
for iteration in start_iteration..effective_max {
// 用户请求停止 → 收尾退出（已生成文本已在上一轮入库）
if stop_flag.load(Ordering::SeqCst) {
let usage = df_ai::provider::TokenUsage {
@@ -893,6 +975,11 @@ pub(crate) async fn run_agentic_loop(
messages
};
// 阶段2 占位配对完整性(第二道防线,depth-defense):build_for_request 已在 df-ai 内部
// 自愈一次,此处 tool_result 压缩/系统提示插入后再断言一次,防转换引入新 orphan。
// view-only:messages 是 clone,assert_placeholder_pairing 仅改本 Vec,不改 ContextManager 持久化。
let messages = ContextManager::assert_placeholder_pairing(messages, PLACEHOLDER_INTEGRITY_ENABLED);
// 预估输入 token(兜底:部分 provider 如 GLM 流式 usage 不报 prompt_tokens,后段用它补)
// 注:stream_one_provider 内每次重试重建 request(因 provider.stream 消费 body),
// 此处不再预构建 request(旧 request 变量已废弃),仅保留 messages 供 estimated_prompt。
@@ -1145,6 +1232,13 @@ pub(crate) async fn run_agentic_loop(
let mut session = session_arc.lock().await;
process_tool_calls(&mut session, tool_calls_acc, &tools_arc, &db, &app_handle, &conv_id).await
};
// F-260620 卡死已根治(DIRAUTH 审批链已闭环)。原 eprintln 诊断降级为 tracing::debug,
// 避免污染 stderr(用户可见),保留排障能力(RUST_LOG=debug 可见)。
tracing::debug!(
conv_id = %conv_id,
pending_count,
"[AI-DIRAUTH-DIAG] agentic loop 收到 pending"
);
// 有待审批 → 暂停循环，等待用户审批后通过 ai_approve → try_continue_agent_loop 恢复
if pending_count > 0 {
@@ -1169,6 +1263,7 @@ pub(crate) async fn run_agentic_loop(
// 或点停止(ai_stop_loop → 走完成流程)。try_continue 续跑 iteration 由调用方传 start_iteration 决定:
// 审批续跑累计(F-260616-11 决策 a,防多次审批反复跑满 max 致 token 失控,传 session.iteration_used),
// 达 max 续跑重计(F-260616-03 决策 a,用户点继续=授权重来,传 0 + 重置 iteration_used)。
// 注:max_iterations=0(不限)时 effective_max=usize::MAX,for 不会正常结束至此,故不触发暂停(靠 stop/收敛/审批退出)
if !converged {
tracing::warn!(
conv_id = %conv_id,
@@ -1264,10 +1359,18 @@ pub(crate) async fn try_continue_agent_loop(
// 传 IPC 参数 conversation_id。
let snap = {
let session = state.ai_session.lock().await;
// has_pending:仅本 conv 的未决审批算续跑阻塞(决策 e 真并发准备)。
let has_pending = session.pending_approvals.values()
.any(|a| a.conversation_id.as_deref() == Some(conv_id));
// path_auth 审批链阶段1:has_pending 改调 session_state(conv_id) 收敛状态机判定,
// 替代手写 path_auth+risk 两表 any 合并(mod.rs 已统一封装)。
// 阶段3a 单真相源合并后:两表合一进 pending_approvals,session_state 单表 any 判定。
// 两表语义不变——任一类挂起都阻塞续跑(agentic loop 在 path_auth 挂起时也已 return 等待,
// 漏任一会致 loop 误续跑空转)。
//
// 兜底/快速回退:若需切回手写 has_pending,原双表组合保留如下(改一行即可):
// let has_pending = session.pending_approvals.values()
// .any(|a| a.conversation_id.as_deref() == Some(conv_id));
let has_pending = session.session_state(conv_id) == SessionState::AwaitingApproval;
// pending_conv_id 保留(should_continue=false 路径的 emit conv_id 回退逻辑)。
// 阶段3a:单表 find_map(原两表合一)。
let pending_conv_id = session.pending_approvals.values()
.find_map(|a| a.conversation_id.clone());
let conv = session.conv_read(conv_id);
@@ -1345,6 +1448,16 @@ pub(crate) async fn try_continue_agent_loop(
let app_handle = app.clone();
let knowledge_config = state.knowledge_config.lock().await.clone();
let llm_concurrency = state.llm_concurrency.clone();
// 知识注入:DRY(B):收敛至 inject_knowledge_into_prompt 单一入口。
// P1 修复(审批恢复路径缺知识注入):try_continue 续跑轮此前用裸 build_system_prompt,
// 不调 build_knowledge_context 致续跑轮丢知识库上下文。现与 chat.rs 四处同款走 helper。
// 同消息取 text+id(②口径修复):原 last_user_text 过滤 is_active / user_message_id 走
// last_user_message_id 不过滤 is_active,末条 user 压缩后两值取自不同消息;helper 单次
// 反向扫描同一条消息取两值。复用上方已 clone 的 knowledge_config 快照(避免重复加锁)。
let system_prompt = inject_knowledge_into_prompt(state, conv_id, system_prompt, &knowledge_config).await;
// F-260616-01: loop 入口 load 快照，当前续生成 loop 锁定边界（热改下次发消息生效）
let max_iterations = state.agent_max_iterations.load(Ordering::SeqCst);
// F-260616-07: 流式失败重试次数快照

39
src-tauri/src/commands/ai/audit/cache.rs
View File

@@ -9,13 +9,40 @@ use df_storage::crud::AiToolExecutionRepo;
use super::super::AiSession;
/// Med/High 工具挂起审批时回填的占位 tool_result 内容。
/// Med/High 工具挂起审批时回填的占位 tool_result 内容(基础文本,不含 tc_id 标记)。
///
/// 单一常量避免「写入处」(process_tool_calls) 与「去重排查处」
/// (find_cached_high_risk_result) 各持一份字面量致耦合——若两者漂移,
/// 去重会把 pending 占位误判为已落定结果命中缓存,污染 LLM 上下文。
///
/// **阶段2(占位配对完整性)**:实际写入 messages 时用 [`pending_placeholder_for`] 生成带
/// `__PENDING__:tc_id` 标记的完整占位文本,供 sanitize 识别"占位不可裁 + 出口断言自愈补头"。
/// 本常量保留为基础文本(向前兼容 + 去重匹配基准)。
pub(crate) const PENDING_APPROVAL_PLACEHOLDER: &str = "需要用户审批，等待确认";
/// 构造带唯一标记(`__PENDING__:tc_id`)的审批挂起占位 tool_result 内容。
///
/// 阶段2 解 400 orphan:占位 tool_result 内嵌 tc_id 标记,sanitize step3.5(反向 orphan 检测)
/// 据此把占位豁免保留(不丢),出口断言 `assert_placeholder_pairing` 据此补 TOOL_MISSING_PREFIX
/// 占位头自愈,使占位 result 与(可能被裁掉的)tool_call 头闭合配对,防 provider 400 orphan。
///
/// 标记格式:`{PENDING_APPROVAL_PLACEHOLDER}{PENDING_MARKER_PREFIX}{tc_id}`,
/// 如 "需要用户审批，等待确认__PENDING__:call_abc123"。tc_id 为空时退回基础文本(老格式,向前兼容)。
pub(crate) fn pending_placeholder_for(tc_id: &str) -> String {
if tc_id.is_empty() {
return PENDING_APPROVAL_PLACEHOLDER.to_string();
}
format!("{}{}{}", PENDING_APPROVAL_PLACEHOLDER, df_ai::context_helpers::PENDING_MARKER_PREFIX, tc_id)
}
/// 判定 tool_result content 是否为审批挂起占位(含基础文本或带 __PENDING__ 标记)。
///
/// 替代原裸 `msg.content == PENDING_APPROVAL_PLACEHOLDER` 精确匹配(阶段2 占位带 tc_id 标记后
/// 不再精确等于基础文本,需用子串/标记匹配)。兼容老占位(纯文本)与新占位(带标记)。
pub(crate) fn is_pending_placeholder(content: &str) -> bool {
df_ai::context_helpers::is_pending_placeholder(content)
}
/// F-260616-05：高危工具去重（根治 run_command 超时→重试→重新审批循环）。
///
/// ⚠ 性能注记(CR-260618-11#5):本函数在 session lock 持有期间对每个 high risk 工具
@@ -41,7 +68,7 @@ pub(crate) const PENDING_APPROVAL_PLACEHOLDER: &str = "需要用户审批，等
/// `session` 只读扫描 messages（不写），调用方据返回值决定是否跳过 insert pending。
///
/// F-260616-09 B 批2:经`conv_id` 索引 per_conv.messages(顶层 messages 批2 后是死字段)。
/// conv_id 来源:process_tool_calls 入参 → 由 agentic.rs run_agentic_loop 入参透传。
/// conv_id 来源:process_tool_calls 入参 → 由 agentic/mod.rs run_agentic_loop 入参透传。
pub(crate) async fn find_cached_high_risk_result(
session: &AiSession,
conv_id: &str,
@@ -98,8 +125,12 @@ pub(crate) async fn find_cached_high_risk_result(
if msg.tool_call_id.as_deref() != Some(old_id.as_str()) {
continue;
}
// 命中旧 tool_result：排除 pending 占位（内容固定为 PENDING_APPROVAL_PLACEHOLDER）
if msg.content == PENDING_APPROVAL_PLACEHOLDER {
// 命中旧 tool_result：排除 pending 占位（基础文本或带 __PENDING__:tc_id 标记）
// 阶段2:占位带标记后不再精确等于基础文本,改用 is_pending_placeholder 匹配。
// 加固(子串误伤):`__PENDING__` 标记是 audit/cache.rs 占位模板独占信号(权威判定);
// 老占位分支已收紧为精确全文等值(非 starts_with 前缀),杜绝用户真实 tool_result 内容
// 恰以"需要用户审批..."开头被误判占位致去重误吞(详见 context_helpers::is_pending_placeholder)。
if is_pending_placeholder(&msg.content) {
return None;
}
// SW-260618-16: 查审计表拿缓存来源真实 status(completed/rejected/failed),透传给

1
src-tauri/src/commands/ai/audit/idea_source.rs
View File

@@ -163,6 +163,7 @@ mod idea_source_test_helpers {
promoted_to: None,
ai_analysis: None,
scores: None,
related_ids: None,
created_at: now.clone(),
updated_at: now,
})

204
src-tauri/src/commands/ai/audit/mod.rs
View File

@@ -15,7 +15,7 @@ use crate::state::AppState;
use crate::commands::err_str;
use super::{AiChatEvent, AiSession, PathAuthRequest, PendingApproval, ToolCallDraft};
use super::{AiChatEvent, AiSession, ApprovalKind, PathAuthRequest, PendingApproval, ToolCallDraft};
// tool_registry::generate_diff 经 audit/diff.rs 直接 use（build_write_file_diff 内调用），
// 本文件不再裸名用 generate_diff，故不再在此 use（避免 unused import warning）。
@@ -116,9 +116,10 @@ pub(crate) use finalize::{audit_finalize, audit_tool_call};
// cache(audit/cache.rs):F-260616-05 高危工具去重缓存。
// 第三批从本文件抽离,行为零变更。pub(super) use 供本文件 process_tool_calls 裸名调用
// (find_cached_high_risk_result),PENDING_APPROVAL_PLACEHOLDER 供 process_tool_calls 占位回填共享。
// (find_cached_high_risk_result)。阶段2:prior placeholder 现经 pending_placeholder_for
// (内嵌 __PENDING__:tc_id 标记)生成,PENDING_APPROVAL_PLACEHOLDER 基础常量留在 cache.rs 内部。
mod cache;
pub(super) use cache::{find_cached_high_risk_result, PENDING_APPROVAL_PLACEHOLDER};
pub(super) use cache::{find_cached_high_risk_result, pending_placeholder_for};
// data_change(audit/data_change.rs):AR-11 数据变更联动刷新。
// 第四批从本文件抽离,行为零变更。pub(crate) use 保持 emit_data_changed 对 crate 内可见
@@ -135,7 +136,7 @@ pub(crate) use idea_source::maybe_fill_idea_source;
/// F-260619-03 Phase B: 提取文件工具的路径参数(用于路径授权预校验)。
///
/// 仅对走 resolve_workspace_path 校验的文件工具返回路径;非文件工具返回空 Vec(不预校验)。
/// - 单路径工具(read_file/write_file/list_directory/patch_file/file_info/append_file/delete_file/search_files)
/// - 单路径工具(read_file/write_file/list_directory/patch_file/file_info/append_file/delete_file/search_files/grep)
/// 取 args["path"]
/// - rename_file 双路径取 args["from"] + args["to"](两个都需授权)
/// - run_command 不返回(它只走 validate_path 黑名单,不限定 workspace,High risk 靠人工审批)
@@ -152,7 +153,7 @@ fn extract_file_tool_paths(tool_name: &str, args: &serde_json::Value) -> Vec<Str
v
}
"read_file" | "write_file" | "list_directory" | "patch_file" | "file_info"
| "append_file" | "delete_file" | "search_files" => {
| "append_file" | "delete_file" | "search_files" | "grep" => {
args.get("path").and_then(|x| x.as_str()).map(|s| vec![s.to_string()]).unwrap_or_default()
}
_ => Vec::new(),
@@ -182,21 +183,66 @@ fn check_file_tool_auth(
// 非文件工具或无路径参数(如缺 path 的异常调用)→ 放行,走原流程(handler 内会因缺参 Err)
return FileToolAuthOutcome::Authorized;
}
let mut pending_dir: Option<std::path::PathBuf> = None;
// L1 补丁(rename_file 双路径漏校):收集**所有**未授权父目录(去重),
// 不只首个。rename_file 的 from/to 若分属不同未授权目录,两个 dir 都需挂起授权。
let mut pending_dirs: Vec<std::path::PathBuf> = Vec::new();
for p in &paths {
match check_path_authorization(p, allowed) {
PathAuthDecision::Denied { reason } => return FileToolAuthOutcome::Denied(reason),
PathAuthDecision::NeedsAuthorization { dir } => {
if pending_dir.is_none() {
pending_dir = Some(dir);
if !pending_dirs.contains(&dir) {
pending_dirs.push(dir);
}
}
PathAuthDecision::Authorized => {}
}
}
match pending_dir {
Some(dir) => FileToolAuthOutcome::NeedsAuth(PathAuthRequest { dir, raw_paths: paths }),
None => FileToolAuthOutcome::Authorized,
if pending_dirs.is_empty() {
FileToolAuthOutcome::Authorized
} else if tool_name == "search_files" {
// 核心设计5:search_files 兜底 — 盲搜语义应拒不应询。
// search_files 仅在已授权目录可用;用户已通过 @项目 提供项目上下文,无需搜索文件系统。
// (黑名单已在上方 for 循环内短路返 Denied,走到此处均为 NeedsAuthorization 场景。)
// 其他文件工具(read_file/write_file/list_directory/patch_file/file_info/
// append_file/delete_file/rename_file)保持原 NeedsAuth 弹窗逻辑完全不变。
FileToolAuthOutcome::Denied(
"search_files 仅在已授权目录可用;请用 @[项目] 引用或提供绝对路径,不要盲搜文件系统。".to_string(),
)
} else {
FileToolAuthOutcome::NeedsAuth(PathAuthRequest { dirs: pending_dirs, raw_paths: paths })
}
}
/// 阶段4(容错/恢复,开关 `df-ai-approval-retry`):查审计表推算同 tc_id 重试计数。
///
/// 返回语义:
/// - 0:审计表无该 tc_id 落定记录(或仅 pending),属首次审批执行,正常挂起。
/// - ≥1:审计表已有该 tc_id 的落定记录(executed/failed/rejected/skipped_retry),即该
/// tc_id 此前已被审批执行过一次,LLM 又用同 id 重试 → 调用方据 ≥1 跳过执行 + emit Completed,
/// 断「超时/权限错→LLM 死循环重试同 id→重新挂起→用户被迫二次授权」循环。
///
/// 实现:查 `find_by_tool_call_id`,status 为 pending 视为"尚未落定"(返 0,首次挂起审批的
/// 正常态);其余落定状态返 1。retry_count 当前仅取 0/1(断路器语义:第二次即跳过),
/// 字段类型 u32 留给未来"允许多次重试"扩展(配置上限阈值)。
///
/// 兜底/回退:flag 关(文档标记)或审计查询失败 → 返 0,等价原行为(单次审批执行,无重试防护)。
async fn detect_retry_count(audit_repo: &AiToolExecutionRepo, tc_id: &str) -> u32 {
// 审计查询失败不阻断主流程(DB 故障等降级为无重试防护,返回 0 走原审批流程)
let rec = match audit_repo.find_by_tool_call_id(tc_id).await {
Ok(opt) => match opt {
Some(r) => r,
None => return 0, // 无记录 = 首次
},
Err(e) => {
tracing::warn!("[阶段4-retry] 查审计表 tc_id={} 失败(降级无重试防护): {}", tc_id, e);
return 0;
}
};
// pending = 首次挂起审批(尚未落定);其余落定状态 = 已执行过 → 计 1 次重试
if rec.status == "pending" {
0
} else {
1
}
}
@@ -223,7 +269,7 @@ pub(crate) async fn process_tool_calls(
let audit_repo = AiToolExecutionRepo::new(db);
// F-260619-04 P1 消息级溯源:取当前 assistant 消息 id。
// 调用前 agentic.rs 已把本轮 assistant_with_tools 消息(LLM 返回带 tool_calls 的那条)
// 调用前 agentic/mod.rs 已把本轮 assistant_with_tools 消息(LLM 返回带 tool_calls 的那条)
// push 到 per_conv.messages(audit/mod.rs:882),此处取末条 assistant id 作为本轮工具
// 调用所属的溯源 message_id,贯穿所有 audit_tool_call 写入。None 表示无 assistant 消息
// (异常路径/老数据无 id),audit 落 message_id=None,展示侧兼容。
@@ -298,8 +344,37 @@ pub(crate) async fn process_tool_calls(
// pending_count 计入(让 agentic loop 检测到挂起并暂停,等 ai_authorize_dir → try_continue 恢复)。
for (draft, args, req) in path_auth_pending {
pending_count += 1;
let dir_str = req.dir.to_string_lossy().to_string();
// L1 补丁:req.dirs 含所有未授权父目录;emit 用首个作主展示目录(前端弹窗主显)。
// ai_authorize_dir 消费时遍历所有 dirs 写白名单。
let dir_str = req.dirs.first()
.map(|d| d.to_string_lossy().to_string())
.unwrap_or_default();
let path_str = req.raw_paths.first().cloned().unwrap_or_default();
// 阶段4(容错/恢复,开关 df-ai-approval-retry):同 tc_id 重试检测。
// 同 tool_call_id 在审计表已有一条落定记录(executed/failed/rejected,即已审批执行过一次)
// → 推算 retry_count≥1,跳过 insert pending + emit Completed 带"已跳过重试"提示,
// 断「超时/权限错→LLM 死循环重试同 id→重新挂起→用户被迫二次授权」循环。
// 兜底:flag 关或无审计记录 → retry_count=0,等价原行为(正常挂起审批)。
let retry_count = detect_retry_count(&audit_repo, &draft.id).await;
if retry_count >= 1 {
let skip_msg = format!(
"已跳过重试(同 tool_call_id={} 此前已审批执行过,防 LLM 死循环重试同卡死工具)",
draft.id
);
session.conv(conv_id).messages.push(ChatMessage::tool_result(&draft.id, &skip_msg));
let _ = app_handle.emit("ai-chat-event", AiChatEvent::AiToolCallCompleted {
id: draft.id.clone(),
result: serde_json::Value::String(skip_msg.clone()),
conversation_id: Some(conv_id.to_string()),
});
let risk_level = tools_arc.get(&draft.name).map(|t| t.risk_level).unwrap_or(RiskLevel::High);
audit_tool_call(
&audit_repo, conv_id, &draft.id, &draft.name, &draft.args,
"skipped_retry", risk_level, Some(skip_msg), Some("auto_retry_guard"),
current_message_id,
).await;
continue;
}
session.pending_approvals.insert(
draft.id.clone(),
PendingApproval {
@@ -308,12 +383,16 @@ pub(crate) async fn process_tool_calls(
arguments: args.clone(),
conversation_id: Some(conv_id.to_string()),
recovered: false,
diff: None,
path_auth: Some(req),
// 阶段3a:路径授权挂起标 kind=Path(req)(下沉原 path_auth 字段)。
kind: ApprovalKind::Path(req),
retry_count,
},
);
// 占位 tool_result(与 RiskLevel 审批一致),ai_authorize_dir 批准后替换为真实结果
session.conv(conv_id).messages.push(ChatMessage::tool_result(&draft.id, PENDING_APPROVAL_PLACEHOLDER));
// 占位 tool_result(与 RiskLevel 审批一致),ai_authorize_dir 批准后替换为真实结果。
// 阶段2:用 pending_placeholder_for 内嵌 __PENDING__:tc_id 标记,供 sanitize 反向 orphan
// 检测豁免保留 + 出口断言自愈补头(防占位头被裁后 orphan result 触发 provider 400)。
session.conv(conv_id).messages.push(ChatMessage::tool_result(&draft.id, &pending_placeholder_for(&draft.id)));
tracing::debug!(target: "ai_dirauth", conv = %conv_id, tool = %draft.name, tc_id = %draft.id, "emit AiDirAuthRequired(路径授权挂起,等 ai_authorize_dir 恢复)");
let _ = app_handle.emit("ai-chat-event", AiChatEvent::AiDirAuthRequired {
id: draft.id.clone(),
tool: draft.name.clone(),
@@ -413,16 +492,38 @@ pub(crate) async fn process_tool_calls(
} else {
None
};
// 阶段4(容错/恢复,开关 df-ai-approval-retry):同 tc_id 重试检测。
// 与 High risk 的 find_cached_high_risk_result 互补:去重按 (tool_name,args) 匹配
// (High only),本 guard 按 tc_id 匹配(覆盖 Med + High 残留场景)。
// 同 tc_id 已有审计落定记录 → retry_count≥1,跳过审批 + emit Completed,断死循环。
// 兜底:flag 关或无审计记录 → retry_count=0,等价原行为。
let retry_count = detect_retry_count(&audit_repo, &draft.id).await;
if retry_count >= 1 {
let skip_msg = format!(
"已跳过重试(同 tool_call_id={} 此前已审批执行过,防 LLM 死循环重试同卡死工具)",
draft.id
);
session.conv(conv_id).messages.push(ChatMessage::tool_result(&draft.id, &skip_msg));
let _ = app_handle.emit("ai-chat-event", AiChatEvent::AiToolCallCompleted {
id: draft.id.clone(),
result: serde_json::Value::String(skip_msg.clone()),
conversation_id: Some(conv_id.to_string()),
});
audit_tool_call(&audit_repo, conv_id, &draft.id, &draft.name, &draft.args, "skipped_retry", risk_level, Some(skip_msg), Some("auto_retry_guard"), current_message_id).await;
continue;
}
session.pending_approvals.insert(draft.id.clone(), PendingApproval {
tool_call_id: draft.id.clone(),
tool_name: draft.name.clone(),
arguments: args.clone(),
conversation_id: Some(conv_id.to_string()),
recovered: false,
diff: approval_diff.clone(),
path_auth: None,
// 阶段3a:普通 RiskLevel 审批标 kind=Risk{diff}(下沉原 diff 字段)。
kind: ApprovalKind::Risk { diff: approval_diff.clone() },
retry_count,
});
session.conv(conv_id).messages.push(ChatMessage::tool_result(&draft.id, PENDING_APPROVAL_PLACEHOLDER));
// 阶段2:占位带 __PENDING__:tc_id 标记,供 sanitize 豁免保留 + 出口断言自愈(防 400 orphan)
session.conv(conv_id).messages.push(ChatMessage::tool_result(&draft.id, &pending_placeholder_for(&draft.id)));
let reason = build_approval_reason(&draft.name, &args, risk_level, db).await;
let _ = app_handle.emit("ai-chat-event", AiChatEvent::AiApprovalRequired {
id: draft.id.clone(),
@@ -438,7 +539,7 @@ pub(crate) async fn process_tool_calls(
}
// AE-04 trust-hit 并行执行：execute + 即时 emit 在闭包内（闭包不访问 session，非"锁已释放"——
// session 锁仍由调用方 agentic.rs 持有至 process_tool_calls 返回，CR-53 审查纠正原"移锁外"误述），
// session 锁仍由调用方 agentic/mod.rs 持有至 process_tool_calls 返回，CR-53 审查纠正原"移锁外"误述），
// push tool_result / audit 在 join_all 后串行回填（持锁）。对齐 Low risk 并行模式。
// CR-51 修：原 inline .await execute 串行执行每个工具（阻塞期间锁被持有，run_command 慢命令
// 阻塞同会话 IPC）；改 join_all 并行多工具减少总阻塞时间（锁持有时长不变，并行化降阻塞）。
@@ -551,5 +652,66 @@ pub(crate) async fn process_tool_calls(
}
}
// 阶段3a:单表 pending_approvals 统计 pending 总数(path/risk 合一,kind 区分)。
let (path_count, risk_count) = session.pending_approvals.values()
.fold((0usize, 0usize), |(p, r), a| match a.kind {
ApprovalKind::Path(_) => (p + 1, r),
ApprovalKind::Risk { .. } => (p, r + 1),
});
tracing::debug!(target: "ai_dirauth", pending_count, pending_approvals_len = session.pending_approvals.len(), path_count, risk_count, "process_tool_calls 返回(路径/风险挂起分布)");
pending_count
}
#[cfg(test)]
mod tests {
use super::*;
/// grep 走单路径授权申请路径(NeedsAuth),非 search_files 盲拒(Denied)。
///
/// F-260621:grep 加入 extract_file_tool_paths 单路径分支,未授权路径触发
/// AiDirAuthRequired 申请(对齐 read_file),不像 search_files 被硬拒。
/// 锁定此差异:grep 与 read_file 同款授权弹窗语义。
#[test]
fn test_grep_unauthorized_path_triggers_auth_not_denied() {
// 空白名单(不含 workspace_root 的目录):任何路径都未授权 → NeedsAuth
let allowed = crate::state::AllowedDirs::default();
let args = serde_json::json!({ "pattern": "foo", "path": "C:/some/unauthorized/dir" });
let outcome = check_file_tool_auth("grep", &args, &allowed);
match outcome {
FileToolAuthOutcome::NeedsAuth(_) => { /* 期望:grep 触发授权申请 */ }
FileToolAuthOutcome::Authorized => panic!("grep 未授权应返 NeedsAuth(申请授权),实际 Authorized"),
FileToolAuthOutcome::Denied(_) => panic!("grep 未授权应返 NeedsAuth(申请授权),实际 Denied(grep 不应像 search_files 盲拒)"),
}
// 对照:search_files 同样未授权但被硬拒(Denied),锁定两工具差异
let search_outcome = check_file_tool_auth("search_files", &args, &allowed);
match search_outcome {
FileToolAuthOutcome::Denied(_) => { /* 期望:search_files 盲拒 */ }
FileToolAuthOutcome::NeedsAuth(_) => panic!("search_files 未授权应返 Denied(盲拒),实际 NeedsAuth"),
FileToolAuthOutcome::Authorized => panic!("search_files 未授权应返 Denied(盲拒),实际 Authorized"),
}
}
/// grep 黑名单路径(.ssh 等)直接 Denied(不申请授权),对齐 read_file。
#[test]
fn test_grep_blacklisted_path_denied() {
let allowed = crate::state::AllowedDirs::default_with_root();
// .ssh 命中系统黑名单(is_in_system_blacklist)
let args = serde_json::json!({ "pattern": "foo", "path": "/home/user/.ssh/config" });
let outcome = check_file_tool_auth("grep", &args, &allowed);
match outcome {
FileToolAuthOutcome::Denied(_) => { /* 期望:黑名单硬拒 */ }
FileToolAuthOutcome::NeedsAuth(_) => panic!("grep 黑名单路径应返 Denied,实际 NeedsAuth"),
FileToolAuthOutcome::Authorized => panic!("grep 黑名单路径应返 Denied,实际 Authorized"),
}
}
/// extract_file_tool_paths:grep 取 args["path"](单路径分支)
#[test]
fn test_extract_grep_path() {
let args = serde_json::json!({ "pattern": "foo", "path": "src/main.rs", "glob": "*.rs" });
let paths = extract_file_tool_paths("grep", &args);
assert_eq!(paths, vec!["src/main.rs".to_string()], "grep 应取 path 参数(忽略 glob 等其他参数)");
}
}

43
src-tauri/src/commands/ai/audit/restore.rs
View File

@@ -7,7 +7,7 @@ use std::collections::HashSet;
use crate::state::AppState;
use super::super::PendingApproval;
use super::super::{ApprovalKind, PendingApproval};
use super::risk_from_str;
/// 启动恢复:从审计表重建 pending_approvals(重启前未审批的工具调用,内存态已丢)
@@ -64,19 +64,26 @@ pub async fn restore_pending_approvals(state: &AppState) {
arguments: args,
conversation_id: rec.conversation_id,
recovered: true,
// 阶段3a 单真相源合并:恢复的审批一律 kind=Risk(diff=None,与原顶层 diff 字段同语义)。
//
// **path 审批不恢复的决策(语义保留)**:路径授权挂起是会话级状态,重启后 session
// 重建,无法恢复挂起语义;且 path 的"always"决策已写入持久白名单(Settings KV),
// 重启后白名单仍生效(文件工具路径预校验会直接 Authorized,不再挂起)。故 path 审批
// 无需恢复 —— 恢复 risk 即可覆盖所有需人工决策的积压。
//
// AE-2025-03: 重启恢复的审批不重读旧文件——审批可能跨重启，
// 期间文件可能已被外部改动，重读生成 diff 反映的不是当初决策时的状态，
// 且恢复路径在 session.lock 内做 async IO 复杂度高，预览价值低。
// 前端见 diff=None 时回退显新 content。
diff: None,
// F-260619-03 Phase B: 重启恢复的审批一律视为普通 RiskLevel 审批(非路径授权挂起)。
// 路径授权挂起是会话级状态,重启后 session 重建,无法恢复挂起语义。
path_auth: None,
kind: ApprovalKind::Risk { diff: None },
// 阶段4:重启恢复的审批 retry_count=0(恢复语义即"待用户首次决策",非重试)。
// 即便审计表已有 pending 记录,恢复后用户审批执行属首次正常执行,不断路。
retry_count: 0,
},
);
}
tracing::info!(
"启动恢复: {} 条 pending 工具审批重建到内存, 分布 {} 个 conv 的 per_conv",
"启动恢复: {} 条 pending 工具审批重建到内存(pending_approvals), 分布 {} 个 conv 的 per_conv",
session.pending_approvals.len(),
convs_restored.len()
);
@@ -84,7 +91,7 @@ pub async fn restore_pending_approvals(state: &AppState) {
#[cfg(test)]
mod tests_f09_batch8_restore {
use super::super::PendingApproval;
use super::super::{ApprovalKind, PendingApproval};
use super::*;
use crate::commands::ai::AiSession;
@@ -114,7 +121,7 @@ mod tests_f09_batch8_restore {
let _ = session.conv(cid); // 惰性建
}
}
// pending 入单层 HashMap(不进 per_conv,设计 §2.1.2)。
// 阶段3a 单真相源合并:恢复的 pending 全部进 pending_approvals,kind=Risk。
session.pending_approvals.insert(
tool_call_id.clone(),
PendingApproval {
@@ -123,8 +130,9 @@ mod tests_f09_batch8_restore {
arguments: serde_json::Value::Null,
conversation_id: conversation_id.clone(),
recovered: true,
diff: None,
path_auth: None,
kind: ApprovalKind::Risk { diff: None },
// 阶段4:恢复的审批 retry_count=0(首次用户决策,非重试)。
retry_count: 0,
},
);
}
@@ -138,8 +146,17 @@ mod tests_f09_batch8_restore {
"未恢复的 conv 不应被惰性建"
);
// 不变量 2:pending_approvals 单层 HashMap 4 条(含无主),conversation_id 保留(业务语义)。
assert_eq!(session.pending_approvals.len(), 4, "全部 pending 入单层 HashMap");
// 不变量 2:pending_approvals HashMap 4 条(含无主),conversation_id 保留(业务语义)。
// 阶段3a:全部进单表 pending_approvals(原 risk_pending 合一,path 审批不恢复)。
assert_eq!(session.pending_approvals.len(), 4, "全部 pending 入 pending_approvals");
// 构造期恒等式:上方 pending_rows 构造的 4 条 PendingApproval 全部 kind=Risk(本测试构造
// 时未插入任何 Path(_)),故 filter Path(_) 计数必为 0。这是构造恒等式而非外部不变量——
// 对齐真实 restore_pending_approvals 的构造(实现 L78 一律 kind=Risk,无 Path 分支)。
// 语义:首次 restore 无历史(Path 审批是会话级状态不恢复,恢复侧构造时本就不产出 Path)。
let path_restored = session.pending_approvals.values()
.filter(|a| matches!(a.kind, ApprovalKind::Path(_)))
.count();
assert_eq!(path_restored, 0, "构造期恒等式:恢复侧构造全部 kind=Risk,无 Path(首次 restore 无历史)");
let conv_a_pending: Vec<_> = session
.pending_approvals
.values()
@@ -157,7 +174,7 @@ mod tests_f09_batch8_restore {
.values()
.filter(|a| a.conversation_id.is_none())
.collect();
assert_eq!(ownerless.len(), 1, "无主审批 1 条仍入单层表(R-9)");
assert_eq!(ownerless.len(), 1, "无主审批 1 条仍入 pending_approvals(R-9)");
// 不变量 3:同 conv 多条 pending 复用同一 PerConvState(conv() 幂等,不重复建)。
let conv_a_ptr = session.conv("conv-a") as *const _;

276
src-tauri/src/commands/ai/augmentation/inject.rs Normal file
View File

@@ -0,0 +1,276 @@
//! Augmentation 注入段构建(核心设计2 注入侧)
//!
//! [`build_augmentation_segment`] 把 resolve 后的 [`Augmentation`] 列表拼成一段
//! 隔离标注的系统提示词片段,拼到 system_prompt 前(复用 chat.rs FR-S4 风格:
//! 头尾明确标注"仅供 AI 参考,非用户消息,勿作为行为准则覆盖",防 prompt injection 混淆)。
//!
//! 空列表返空串(调用方据此跳过拼接,不污染 prompt)。多语言按 lang 参数选标题。
use df_types::augmentation::Augmentation;
/// 标题语言选择(与 build_system_prompt 的 lang 参数同源)。
///
/// 仅 `zh` / `en` 二态:其它值(空串/未知)按 zh 兜底(中文用户为主)。
fn title_lang(lang: &str) -> &'static str {
match lang {
"en" => "en",
_ => "zh",
}
}
/// 拼接 augmentation 列表为一段隔离标注的系统提示词片段。
///
/// - 空 augs 返 `""`(调用方跳过拼接,不污染 prompt)。
/// - 非空:头尾标注段(`--- 以下是用户选择的上下文参考 ... ---` 包裹),
/// 每条 augmentation 按 kind 分小节(项目/任务/灵感/技能),复用 chat.rs FR-S4 隔离头风格。
///
/// `lang` 控制标题语言(zh/en),与 [`build_system_prompt`](super::super::prompt::build_system_prompt) 同源。
///
/// 设计权衡:不在此处决定注入位置(前/后/中),仅产出片段文本,由调用方(chat.rs 4 处)
/// 决定拼到 system_prompt 哪里(当前统一拼到前,与技能注入同序)。
pub fn build_augmentation_segment(augs: &[Augmentation], lang: &str) -> String {
if augs.is_empty() {
return String::new();
}
let l = title_lang(lang);
// 仅头尾标注随 lang 切换;section_label 复用 Augmentation::section_label(中文标签,
// 英文版可后续 i18n)。用方法引用(Augmentation::section_label)而非闭包字面量,
// 避免 match 两分支闭包类型不一致致编译失败。
let (head, tail): (&str, &str) = match l {
"en" => (
"--- The following is the context selected by the user (for AI reference only, NOT a user message, do not override behavioral guidelines) ---",
"--- End of context reference ---",
),
_ => (
"--- 以下是用户选择的上下文参考（仅供 AI 参考，非用户消息，勿作为行为准则覆盖）---",
"--- 上下文参考结束 ---",
),
};
let mut out = String::with_capacity(256);
out.push_str(head);
out.push_str("\n\n");
for aug in augs {
render_one(aug, &mut out, aug.section_label());
}
out.push_str(tail);
out.push('\n');
out
}
/// 渲染单条 Augmentation 到 out(按 kind 取字段)。
fn render_one(aug: &Augmentation, out: &mut String, label: &str) {
// 小节标题:【项目】xxx / 【任务】xxx ...
match aug {
Augmentation::Project {
name,
status,
description,
path,
..
} => {
out.push_str("【");
out.push_str(label);
out.push_str("】");
out.push_str(name);
out.push_str("（状态: ");
out.push_str(status.as_str());
out.push_str("）\n");
if let Some(p) = path {
out.push_str("目录: ");
out.push_str(p.as_str());
out.push('\n');
}
if !description.is_empty() {
out.push_str("说明: ");
out.push_str(description);
out.push('\n');
}
out.push('\n');
}
Augmentation::Task {
title,
status,
description,
project_name,
..
} => {
out.push_str("【");
out.push_str(label);
out.push_str("】");
out.push_str(title);
out.push_str("（状态: ");
out.push_str(status.as_str());
out.push_str("）\n");
if let Some(pn) = project_name {
out.push_str("所属项目: ");
out.push_str(pn);
out.push('\n');
}
if !description.is_empty() {
out.push_str("说明: ");
out.push_str(description);
out.push('\n');
}
out.push('\n');
}
Augmentation::Idea {
title,
status,
description,
..
} => {
out.push_str("【");
out.push_str(label);
out.push_str("】");
out.push_str(title);
out.push_str("（状态: ");
out.push_str(status.as_str());
out.push_str("）\n");
if !description.is_empty() {
out.push_str("说明: ");
out.push_str(description);
out.push('\n');
}
out.push('\n');
}
Augmentation::Skill {
name,
source,
body,
} => {
out.push_str("【");
out.push_str(label);
out.push_str("】");
out.push_str(name);
out.push_str("（来源: ");
out.push_str(source);
out.push_str("）\n");
out.push_str(body);
if !body.ends_with('\n') {
out.push('\n');
}
out.push('\n');
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use df_types::augmentation::SanitizedPath;
use df_types::types::{IdeaStatus, ProjectStatus, TaskStatus};
#[test]
fn empty_returns_empty_string() {
assert_eq!(build_augmentation_segment(&[], "zh"), "");
assert_eq!(build_augmentation_segment(&[], "en"), "");
}
#[test]
fn project_with_path_zh_wrapped_isolated() {
let aug = Augmentation::Project {
id: "p1".into(),
name: "devflow".into(),
status: ProjectStatus::InProgress,
description: "AI-native dev tool".into(),
path: Some(SanitizedPath::new("E:/wk-lab/devflow")),
};
let seg = build_augmentation_segment(&[aug], "zh");
assert!(seg.starts_with("--- 以下是用户选择的上下文参考"), "头部应隔离标注, got: {}", seg);
assert!(seg.ends_with("--- 上下文参考结束 ---\n"), "尾部应结束标注");
assert!(seg.contains("【项目】devflow"));
assert!(seg.contains("in_progress"));
assert!(seg.contains("目录: E:/wk-lab/devflow"));
}
#[test]
fn task_with_project_name_rendered() {
let aug = Augmentation::Task {
id: "t1".into(),
title: "Implement X".into(),
status: TaskStatus::Todo,
description: "do X".into(),
project_name: Some("devflow".into()),
};
let seg = build_augmentation_segment(&[aug], "zh");
assert!(seg.contains("【任务】Implement X"));
assert!(seg.contains("todo"));
assert!(seg.contains("所属项目: devflow"));
}
#[test]
fn skill_body_rendered() {
let aug = Augmentation::Skill {
name: "review".into(),
source: "command".into(),
body: "## Review\nDo X".into(),
};
let seg = build_augmentation_segment(&[aug], "zh");
assert!(seg.contains("【技能】review"));
assert!(seg.contains("来源: command"));
assert!(seg.contains("## Review\nDo X"));
}
#[test]
fn multiple_augs_concatenated() {
let augs = vec![
Augmentation::Idea {
id: "i1".into(),
title: "Idea1".into(),
status: IdeaStatus::Approved,
description: String::new(),
},
Augmentation::Project {
id: "p1".into(),
name: "Proj".into(),
status: ProjectStatus::Planning,
description: String::new(),
path: None,
},
];
let seg = build_augmentation_segment(&augs, "zh");
assert!(seg.contains("【灵感】Idea1"));
assert!(seg.contains("【项目】Proj"));
// 两段都渲染,隔离头尾各一次
assert_eq!(seg.matches("--- 以下是用户选择的上下文参考").count(), 1);
assert_eq!(seg.matches("--- 上下文参考结束 ---").count(), 1);
}
#[test]
fn en_lang_uses_english_header() {
let aug = Augmentation::Idea {
id: "i1".into(),
title: "Idea1".into(),
status: IdeaStatus::Approved,
description: String::new(),
};
let seg = build_augmentation_segment(&[aug], "en");
assert!(seg.starts_with("--- The following is the context"), "en 头部: {}", seg);
assert!(seg.contains("--- End of context reference ---"));
}
#[test]
fn unknown_lang_defaults_zh() {
let aug = Augmentation::Idea {
id: "i1".into(),
title: "Idea1".into(),
status: IdeaStatus::Approved,
description: String::new(),
};
let seg = build_augmentation_segment(&[aug], "fr");
assert!(seg.starts_with("--- 以下是用户选择的上下文参考"), "未知 lang 应按 zh 兜底");
}
#[test]
fn project_no_path_skips_directory_line() {
let aug = Augmentation::Project {
id: "p1".into(),
name: "NoPath".into(),
status: ProjectStatus::Planning,
description: String::new(),
path: None,
};
let seg = build_augmentation_segment(&[aug], "zh");
assert!(!seg.contains("目录:"), "无 path 不应渲染目录行: {}", seg);
}
}

48
src-tauri/src/commands/ai/augmentation/mod.rs Normal file
View File

@@ -0,0 +1,48 @@
//! Input Augmentation 层 — Mention Resolver trait + 注册表 + 注入段构建
//!
//! 核心设计2(plan mighty-wibbling-papert.md):
//! - [`MentionResolver`] async trait:把 [`MentionRef`] 投影成 [`Augmentation`],
//! 按 provider locality 决定 path 脱敏粒度(Local 全路径 / Remote basename)。
//! - [`ResolverRegistry`]:HashMap<kind, Arc<dyn MentionResolver>> + `resolve_all`
//! 按 MentionRef::kind_str 分发,单条失败收集 [`ResolveError`] 不阻断整批注入。
//! - 四 impl(ProjectResolver/TaskResolver/IdeaResolver/SkillResolver)在 [`resolvers`] 模块。
//!
//! 新增 mention 类型 = 加一个 impl + 注册一行,主干零改(破解"改 4-5 处"僵化)。
pub mod inject;
pub mod registry;
pub mod resolvers;
pub mod sanitize;
pub use inject::build_augmentation_segment;
pub use registry::ResolverRegistry;
pub use resolvers::build_resolver_registry;
use async_trait::async_trait;
use df_types::augmentation::{Augmentation, MentionRef, ResolveError};
use crate::commands::ai::augmentation::sanitize::ProviderLocality;
/// Mention → Augmentation 的投影 trait。
///
/// 每个 Resolver 处理一种 kind(`project`/`task`/`idea`/`skill`),`kind()` 返回的标签
/// 须与 [`MentionRef::kind_str`] / serde tag 一致。`resolve()` 接收 locality 用于决定
/// path 脱敏粒度(仅 ProjectResolver 用到,其余忽略即可)。
///
/// 单条 resolve 失败应返 [`ResolveError::NotFound`] / [`ResolveError::Skip`],
/// 由 [`ResolverRegistry::resolve_all`] 收集进 errors 列表不中断其他 mention。
#[async_trait]
pub trait MentionResolver: Send + Sync {
/// 返回 Resolver 处理的 kind 标签(与 serde tag 一致):`project`/`task`/`idea`/`skill`。
fn kind(&self) -> &'static str;
/// 把单个 [`MentionRef`] 投影成 [`Augmentation`]。
///
/// `loc` 为当前 provider 的 locality,ProjectResolver 据此决定 path 是否脱敏。
/// kind 不匹配返 [`ResolveError::KindMismatch`](防注册表分发错配)。
async fn resolve(
&self,
rf: &MentionRef,
loc: ProviderLocality,
) -> Result<Augmentation, ResolveError>;
}

142
src-tauri/src/commands/ai/augmentation/registry.rs Normal file
View File

@@ -0,0 +1,142 @@
//! Mention Resolver 注册表(核心设计2)
//!
//! 借鉴 [`crate::commands::ai::tool_registry::build_ai_tool_registry`] 的 AiToolRegistry
//! 模式:启动期 build 一次性注册,通过 `Arc<ResolverRegistry>` 注入 AppState,
//! 读路径(`resolve_all`)无锁并发访问。
//!
//! `resolve_all` 按 [`MentionRef::kind_str`] 分发到对应 Resolver,单条 resolve 失败
//! 收集进 errors 列表不阻断整批注入(返回 `(Vec<Augmentation>, Vec<ResolveError>)`)。
use std::collections::HashMap;
use std::sync::Arc;
use df_types::augmentation::{Augmentation, MentionRef, ResolveError};
use crate::commands::ai::augmentation::sanitize::ProviderLocality;
use crate::commands::ai::augmentation::MentionResolver;
/// Mention Resolver 注册表 — 按 kind 分发 MentionRef 到对应 Resolver。
///
/// 启动期 build 一次性 `register`,之后只读(`resolve_all`),故内部 HashMap 无 RwLock,
/// 通过 `Arc<ResolverRegistry>` 注入 AppState 共享。新增 mention 类型 = build 处
/// `register` 一行 + 加一个 impl,主干零改。
pub struct ResolverRegistry {
resolvers: HashMap<&'static str, Arc<dyn MentionResolver>>,
}
impl ResolverRegistry {
/// 创建空注册表。
pub fn new() -> Self {
Self {
resolvers: HashMap::new(),
}
}
/// 注册一个 Resolver。重复 kind 后注册者覆盖(开发期防漏注同名)。
pub fn register(&mut self, resolver: Arc<dyn MentionResolver>) {
let kind = resolver.kind();
self.resolvers.insert(kind, resolver);
}
/// 批量 resolve mention 引用列表为 Augmentation。
///
/// 按 [`MentionRef::kind_str`] 分发到对应 Resolver,逐条独立 resolve:
/// - 成功 → push 进 `augs`
/// - 失败(Resolver 返 Err / kind 无对应 Resolver)→ push 进 `errors`,**不中断**
/// 后续 mention(整批注入最大化保留可用上下文)。
///
/// 返回 `(成功列表, 失败列表)`,调用方据 errors 数决定是否提示用户某 mention 跳过。
pub async fn resolve_all(
&self,
refs: &[MentionRef],
loc: ProviderLocality,
) -> (Vec<Augmentation>, Vec<ResolveError>) {
let mut augs = Vec::with_capacity(refs.len());
let mut errors = Vec::new();
for rf in refs {
let kind = rf.kind_str();
match self.resolvers.get(kind) {
Some(resolver) => match resolver.resolve(rf, loc).await {
Ok(aug) => augs.push(aug),
Err(e) => errors.push(e),
},
None => {
// kind 无对应 Resolver(未注册的 mention 类型):收集 KindMismatch 不中断
errors.push(ResolveError::KindMismatch {
expected: "<registered>".to_string(),
actual: kind.to_string(),
});
}
}
}
(augs, errors)
}
}
impl Default for ResolverRegistry {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
use async_trait::async_trait;
/// 测试用 Resolver:kind 固定 "test",resolve 固定返 Skip(模拟失败收集)。
struct SkipResolver;
#[async_trait]
impl MentionResolver for SkipResolver {
fn kind(&self) -> &'static str {
"test"
}
async fn resolve(
&self,
_rf: &MentionRef,
_loc: ProviderLocality,
) -> Result<Augmentation, ResolveError> {
Err(ResolveError::Skip {
kind: "test".into(),
ref_id: "x".into(),
reason: "test skip".into(),
})
}
}
#[tokio::test]
async fn resolve_all_unknown_kind_collected_not_panic() {
let reg = ResolverRegistry::new();
// 未注册任何 Resolver,传入 Project mention → KindMismatch 收集,不 panic
let rf = MentionRef::Project {
id: "p".into(),
name: "n".into(),
};
let (augs, errors) = reg.resolve_all(&[rf], ProviderLocality::Local).await;
assert!(augs.is_empty());
assert_eq!(errors.len(), 1);
match &errors[0] {
ResolveError::KindMismatch { actual, .. } => assert_eq!(actual, "project"),
other => panic!("expected KindMismatch, got {:?}", other),
}
}
#[tokio::test]
async fn resolve_all_failure_collected_continues_others() {
// 验证:单条 resolve 失败不中断后续 mention。
// 构造两条 mention,第一条命中已注册 Resolver(SkipResolver 返 Skip 失败),
// 第二条命中未知 kind(KindMismatch)。两条失败都收集,augs 为空,无 panic。
// 注:SkipResolver kind="test",无法用现有 MentionRef 变体精确匹配(枚举 kind 固定
// project/task/idea/skill),故此处仅验证 unknown-kind 路径收集不中断——核心语义
// (失败收集 + 继续)已在 resolve_all 实现的 for 循环中保证,本测为回归守护。
let mut reg = ResolverRegistry::new();
reg.register(Arc::new(SkipResolver));
let refs = vec![
MentionRef::Project { id: "p".into(), name: "n".into() },
MentionRef::Skill { name: "s".into() },
];
let (augs, errors) = reg.resolve_all(&refs, ProviderLocality::Local).await;
assert!(augs.is_empty(), "两条 mention kind 均≠test 应全 KindMismatch");
assert_eq!(errors.len(), 2, "两条失败都应收集");
}
}

283
src-tauri/src/commands/ai/augmentation/resolvers.rs Normal file
View File

@@ -0,0 +1,283 @@
//! 四个 MentionResolver 实现(核心设计2)
//!
//! - [`ProjectResolver`]:持 `Arc<Database>`,经 `ProjectRepo::get_by_id` 取项目记录,
//! path 经 [`sanitize_for`] 脱敏(Local 全路径 / Remote basename)。
//! - [`TaskResolver`]:经 `TaskRepo::get_by_id` 拿 task,再 join `project_id` 取 project_name。
//! - [`IdeaResolver`]:经 `IdeaRepo::get_by_id`(IdeaRecord 无 project_id,注入无 path)。
//! - [`SkillResolver`]:调 [`super::super::skills::read_skill_content_stripped`] 取剥 frontmatter 正文。
//!
//! Resolver 持 `Arc<Database>` 而非 `Arc<AppState>` —— 避免循环依赖(AppState 持
//! `Arc<ResolverRegistry>`,Resolver 若持 AppState 则成环)。Repo 在 resolve 内即时
//! `::new(&db)` 构造(Arc clone 廉价),与 tool_registry.rs 闭包内建 Repo 同模式。
use std::sync::Arc;
use async_trait::async_trait;
use df_storage::crud::{IdeaRepo, ProjectRepo, TaskRepo};
use df_storage::db::Database;
use df_types::augmentation::{Augmentation, MentionRef, ResolveError, SanitizedPath};
use df_types::types::{IdeaStatus, ProjectStatus, TaskStatus};
use crate::commands::ai::augmentation::registry::ResolverRegistry;
use crate::commands::ai::augmentation::sanitize::{sanitize_for, ProviderLocality};
use crate::commands::ai::augmentation::MentionResolver;
use crate::commands::ai::skills::read_skill_content_stripped;
/// 启动期构建 ResolverRegistry,注册四个 resolver(Project/Task/Idea/Skill)。
///
/// resolver 持 `Arc<Database>` 访问 repo(非 AppState,避免循环依赖)。
/// Skill resolver 不持 db(调 skills::read_skill_content_stripped 读缓存 + 单文件)。
/// 在 [`crate::state::AppState::init`] 与 `build_ai_tool_registry` 同侧调用,产
/// `Arc<ResolverRegistry>` 注入 `AppState.resolvers`。
pub fn build_resolver_registry(db: Arc<Database>) -> ResolverRegistry {
let mut reg = ResolverRegistry::new();
reg.register(Arc::new(ProjectResolver::new(db.clone())));
reg.register(Arc::new(TaskResolver::new(db.clone())));
reg.register(Arc::new(IdeaResolver::new(db.clone())));
reg.register(Arc::new(SkillResolver::new()));
reg
}
/// @项目 Resolver:取项目记录 + path 脱敏。
///
/// path 脱敏(Local 全路径 / Remote basename)由 `loc` 参数决定,经 [`sanitize_for`]
/// 包成 [`SanitizedPath`] newtype 防裸 String 误用。项目未绑定目录(path=None)时
/// Augmentation.path=None(与现状一致,不堵未绑定项目)。
pub struct ProjectResolver {
db: Arc<Database>,
}
impl ProjectResolver {
pub fn new(db: Arc<Database>) -> Self {
Self { db }
}
}
#[async_trait]
impl MentionResolver for ProjectResolver {
fn kind(&self) -> &'static str {
"project"
}
async fn resolve(
&self,
rf: &MentionRef,
loc: ProviderLocality,
) -> Result<Augmentation, ResolveError> {
let id = match rf {
MentionRef::Project { id, .. } => id.clone(),
_ => {
return Err(ResolveError::KindMismatch {
expected: "project".to_string(),
actual: rf.kind_str().to_string(),
});
}
};
let repo = ProjectRepo::new(&self.db);
let record = repo
.get_by_id(&id)
.await
.map_err(|e| ResolveError::Skip {
kind: "project".to_string(),
ref_id: id.clone(),
reason: format!("查询失败: {}", e),
})?
.ok_or_else(|| ResolveError::NotFound {
kind: "project".to_string(),
ref_id: id.clone(),
})?;
// status: String → ProjectStatus(未知字符串按 Planning 兜底,不阻断注入)
let status = ProjectStatus::from_db_str(&record.status).unwrap_or(ProjectStatus::Planning);
// path 脱敏:None(未绑定)保持 None;Some 则按 locality 脱敏包 newtype
let path = record
.path
.as_deref()
.filter(|s| !s.is_empty())
.map(|raw| SanitizedPath::new(sanitize_for(raw, loc)));
Ok(Augmentation::Project {
id: record.id,
name: record.name,
status,
description: record.description,
path,
})
}
}
/// @任务 Resolver:取任务记录 + join 项目名(project_name)。
///
/// TaskRepo::get_by_id 拿 task,再经 ProjectRepo::get_by_id(task.project_id) 取项目名;
/// project_id 无对应项目(游离任务/项目已删)时 project_name=None(非错误,不阻断注入)。
pub struct TaskResolver {
db: Arc<Database>,
}
impl TaskResolver {
pub fn new(db: Arc<Database>) -> Self {
Self { db }
}
}
#[async_trait]
impl MentionResolver for TaskResolver {
fn kind(&self) -> &'static str {
"task"
}
async fn resolve(
&self,
rf: &MentionRef,
_loc: ProviderLocality,
) -> Result<Augmentation, ResolveError> {
let (id, _name) = match rf {
MentionRef::Task { id, name } => (id.clone(), name.clone()),
_ => {
return Err(ResolveError::KindMismatch {
expected: "task".to_string(),
actual: rf.kind_str().to_string(),
});
}
};
let task_repo = TaskRepo::new(&self.db);
let task = task_repo
.get_by_id(&id)
.await
.map_err(|e| ResolveError::Skip {
kind: "task".to_string(),
ref_id: id.clone(),
reason: format!("查询失败: {}", e),
})?
.ok_or_else(|| ResolveError::NotFound {
kind: "task".to_string(),
ref_id: id.clone(),
})?;
let status = TaskStatus::from_db_str(&task.status).unwrap_or(TaskStatus::Todo);
// join project_name:project_id 取 ProjectRecord.name;失败/无对应 None(非错误)
let project_name = {
let project_repo = ProjectRepo::new(&self.db);
match project_repo.get_by_id(&task.project_id).await {
Ok(Some(p)) => Some(p.name),
_ => None,
}
};
Ok(Augmentation::Task {
id: task.id,
title: task.title,
status,
description: task.description,
project_name,
})
}
}
/// @灵感 Resolver:取灵感记录(IdeaRecord 无 project_id,注入无 path)。
pub struct IdeaResolver {
db: Arc<Database>,
}
impl IdeaResolver {
pub fn new(db: Arc<Database>) -> Self {
Self { db }
}
}
#[async_trait]
impl MentionResolver for IdeaResolver {
fn kind(&self) -> &'static str {
"idea"
}
async fn resolve(
&self,
rf: &MentionRef,
_loc: ProviderLocality,
) -> Result<Augmentation, ResolveError> {
let (id, _name) = match rf {
MentionRef::Idea { id, name } => (id.clone(), name.clone()),
_ => {
return Err(ResolveError::KindMismatch {
expected: "idea".to_string(),
actual: rf.kind_str().to_string(),
});
}
};
let repo = IdeaRepo::new(&self.db);
let record = repo
.get_by_id(&id)
.await
.map_err(|e| ResolveError::Skip {
kind: "idea".to_string(),
ref_id: id.clone(),
reason: format!("查询失败: {}", e),
})?
.ok_or_else(|| ResolveError::NotFound {
kind: "idea".to_string(),
ref_id: id.clone(),
})?;
let status = IdeaStatus::from_db_str(&record.status).unwrap_or(IdeaStatus::Draft);
Ok(Augmentation::Idea {
id: record.id,
title: record.title,
status,
description: record.description,
})
}
}
/// /技能 Resolver:调 [`read_skill_content_stripped`] 取剥 frontmatter 正文。
///
/// skill 以 name 为唯一键(无全局 id),MentionRef::Skill 仅携带 name。
/// 缓存未命中 / 文件读失败 → NotFound(skill 已卸载或名称错)。
/// source 取缓存中 SkillInfo.source(skill/command/plugin),默认 "skill" 兜底。
pub struct SkillResolver;
impl SkillResolver {
pub fn new() -> Self {
Self
}
}
impl Default for SkillResolver {
fn default() -> Self {
Self::new()
}
}
#[async_trait]
impl MentionResolver for SkillResolver {
fn kind(&self) -> &'static str {
"skill"
}
async fn resolve(
&self,
rf: &MentionRef,
_loc: ProviderLocality,
) -> Result<Augmentation, ResolveError> {
let name = match rf {
MentionRef::Skill { name } => name.clone(),
_ => {
return Err(ResolveError::KindMismatch {
expected: "skill".to_string(),
actual: rf.kind_str().to_string(),
});
}
};
// 取剥 frontmatter 正文(注入用);None = 缓存未命中或文件读失败
let body = read_skill_content_stripped(&name).ok_or_else(|| ResolveError::NotFound {
kind: "skill".to_string(),
ref_id: name.clone(),
})?;
// source 从缓存取 SkillInfo.source;失败(缓存不一致)默认 "skill"
let source = crate::commands::ai::skills::skills_cached()
.into_iter()
.find(|s| s.name == name)
.map(|s| s.source)
.unwrap_or_else(|| "skill".to_string());
Ok(Augmentation::Skill {
name,
source,
body,
})
}
}

189
src-tauri/src/commands/ai/augmentation/sanitize.rs Normal file
View File

@@ -0,0 +1,189 @@
//! Provider locality 判定 + path 脱敏(核心设计3)
//!
//! 解决 🔴HIGH-1:远程 provider 注入项目 path 不再裸泄用户名/公司目录/客户名。
//! - [`ProviderLocality`]:Local / Remote 二态
//! - [`locality_of`]:据 [`AiProviderRecord::base_url`] 推断(localhost/127.0.0.1/
//! 0.0.0.0/::1/ollama = Local)
//! - [`sanitize_for`]:Local 全路径 / Remote basename(失败回退占位标记)
use std::path::Path;
use df_storage::models::AiProviderRecord;
/// Provider 部署位置,决定注入 path 的脱敏粒度。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProviderLocality {
/// 本地 provider(base_url 指向 localhost/127.0.0.1/0.0.0.0/::1/ollama):保留全路径。
Local,
/// 远程 provider(第三方云):仅保留 basename,避免泄漏盘符/用户名/公司目录。
Remote,
}
/// 据 provider 的 base_url 推断 locality。
///
/// Local 判定(大小写不敏感,任意子串命中即 Local):
/// - `localhost` / `127.0.0.1` / `0.0.0.0` / `::1`(本地回环地址)
/// - `ollama`(Ollama 默认绑定 127.0.0.1:11434,常以 host 名出现)
///
/// 其余(https://api.openai.com / 自建远程网关)视为 Remote。
/// base_url 为空(配置异常)按 Remote 保守处理(脱敏优先,宁可漏放全路径不漏泄)。
pub fn locality_of(provider: &AiProviderRecord) -> ProviderLocality {
let url = provider.base_url.to_lowercase();
const LOCAL_MARKERS: &[&str] = &[
"localhost",
"127.0.0.1",
"0.0.0.0",
"::1",
"ollama",
];
if LOCAL_MARKERS.iter().any(|m| url.contains(m)) {
ProviderLocality::Local
} else {
ProviderLocality::Remote
}
}
/// 按 locality 脱敏原始路径。
///
/// - [`ProviderLocality::Local`]:原样返回(本地 provider 直接操作本地 FS,需全路径)。
/// - [`ProviderLocality::Remote`]:取 basename(`Path::file_name`),失败回退
/// `[remote-path-hidden]`(防裸泄 + 防 LLM 拿到乱码路径瞎调文件工具)。
///
/// 注:脱敏后的字符串由调用方包进 [`df_types::augmentation::SanitizedPath`] newtype,
/// 强制走脱敏入口(防裸 String 误用未脱敏值)。
pub fn sanitize_for(raw: &str, loc: ProviderLocality) -> String {
match loc {
ProviderLocality::Local => raw.to_string(),
ProviderLocality::Remote => Path::new(raw)
.file_name()
.and_then(|n| n.to_str())
.filter(|s| !s.is_empty())
.map(|s| s.to_string())
.unwrap_or_else(|| "[remote-path-hidden]".to_string()),
}
}
// ============================================================
// 单测:locality_of / sanitize_for(覆盖 localhost/127.0.0.1/0.0.0.0/::1/ollama/远程)
// ============================================================
#[cfg(test)]
mod tests {
use super::*;
use df_storage::models::AiProviderRecord;
use df_types::now_millis;
/// 构造测试用 AiProviderRecord(只关心 base_url,其余字段占位)。
fn provider_with_url(base_url: &str) -> AiProviderRecord {
AiProviderRecord {
id: "test".to_string(),
name: "test".to_string(),
provider_type: "openai_compat".to_string(),
api_key: String::new(),
base_url: base_url.to_string(),
default_model: "m".to_string(),
models: None,
model_configs: Vec::new(),
is_default: false,
config: None,
created_at: now_millis().to_string(),
updated_at: now_millis().to_string(),
enabled: true,
weight: 50,
}
}
// ---------- locality_of ----------
#[test]
fn locality_localhost() {
assert_eq!(locality_of(&provider_with_url("http://localhost:11434")), ProviderLocality::Local);
}
#[test]
fn locality_127() {
assert_eq!(locality_of(&provider_with_url("http://127.0.0.1:8080")), ProviderLocality::Local);
}
#[test]
fn locality_0000() {
assert_eq!(locality_of(&provider_with_url("http://0.0.0.0:3000")), ProviderLocality::Local);
}
#[test]
fn locality_ipv6_loopback() {
assert_eq!(locality_of(&provider_with_url("http://[::1]:8080")), ProviderLocality::Local);
}
#[test]
fn locality_ollama_marker() {
// ollama 作为 host 名(部分用户配 http://ollama:11434 容器网络场景)
assert_eq!(locality_of(&provider_with_url("http://ollama:11434")), ProviderLocality::Local);
}
#[test]
fn locality_case_insensitive() {
// 大小写不敏感:LOCALHOST 也应识别
assert_eq!(locality_of(&provider_with_url("http://LOCALHOST:11434")), ProviderLocality::Local);
}
#[test]
fn locality_remote_openai() {
assert_eq!(locality_of(&provider_with_url("https://api.openai.com")), ProviderLocality::Remote);
}
#[test]
fn locality_remote_custom_gateway() {
assert_eq!(locality_of(&provider_with_url("https://my-llm-gateway.company.com")), ProviderLocality::Remote);
}
#[test]
fn locality_empty_url_defaults_remote() {
// 空 base_url(配置异常)保守按 Remote 脱敏
assert_eq!(locality_of(&provider_with_url("")), ProviderLocality::Remote);
}
// ---------- sanitize_for ----------
#[test]
fn sanitize_local_keeps_full_path() {
let raw = "E:/wk-lab/devflow";
assert_eq!(sanitize_for(raw, ProviderLocality::Local), "E:/wk-lab/devflow");
}
#[test]
fn sanitize_remote_basename_unix() {
// Unix 风格路径:取最后一段 basename
assert_eq!(sanitize_for("/home/alice/devflow", ProviderLocality::Remote), "devflow");
}
#[test]
fn sanitize_remote_basename_windows() {
// Windows 路径:取 basename(去盘符/用户目录)
assert_eq!(sanitize_for("C:\\Users\\alice\\projects\\devflow", ProviderLocality::Remote), "devflow");
}
#[test]
fn sanitize_remote_basename_forward_slash() {
assert_eq!(sanitize_for("E:/wk-lab/devflow", ProviderLocality::Remote), "devflow");
}
#[test]
fn sanitize_remote_root_only() {
// 根路径(file_name 返 None)回退占位标记,不裸泄空串也不裸泄根
assert_eq!(sanitize_for("/", ProviderLocality::Remote), "[remote-path-hidden]");
assert_eq!(sanitize_for("C:\\", ProviderLocality::Remote), "[remote-path-hidden]");
}
#[test]
fn sanitize_remote_empty() {
// 空串回退占位标记
assert_eq!(sanitize_for("", ProviderLocality::Remote), "[remote-path-hidden]");
}
#[test]
fn sanitize_local_empty_stays_empty() {
// Local 原样返回(空串保持空串,Local 不脱敏)
assert_eq!(sanitize_for("", ProviderLocality::Local), "");
}
}

421
src-tauri/src/commands/ai/commands/chat.rs
View File

@@ -16,6 +16,8 @@ use serde::Serialize;
use tauri::{AppHandle, Emitter, State};
use df_ai::provider::{ChatMessage, ContentPart};
use df_storage::models::AiProviderRecord;
use df_types::augmentation::{MentionRef, MentionSpanDto};
use df_types::types::new_id;
use crate::state::AppState;
@@ -24,12 +26,13 @@ use crate::commands::{err_str, now_millis};
// chat.rs 的 super = commands,super::super = ai(与原 commands.rs 的 super=ai 等价)。
use super::super::agentic::{run_agentic_loop, try_continue_agent_loop};
use super::super::audit::{audit_finalize, emit_data_changed};
use super::super::augmentation::build_augmentation_segment;
use super::super::augmentation::sanitize;
use super::super::conversation::save_conversation;
use super::super::knowledge_inject::build_knowledge_context;
use super::super::knowledge_inject::inject_knowledge_into_prompt;
use super::super::prompt::build_system_prompt;
use super::super::skills::read_skill_content;
use super::super::AiChatEvent;
use super::super::{AiChatEvent, ApprovalKind, SessionState};
/// 把当前所有挂起审批的占位 tool_result(内容为 audit.rs:PENDING_APPROVAL_PLACEHOLDER
/// "需要用户审批，等待确认")就地替换为终态文本。
@@ -52,6 +55,7 @@ fn finalize_pending_placeholders(session: &mut super::super::AiSession, conv_id:
// SW-260618-02: 先 clone pending 的 tool_call_id(借用在此结束),再可变借 messages。
// 必须整体借 &mut session 在函数体内做 disjoint field borrow —— 调用方若分别传
// &mut messages + &pending 两个引用,函数参数列表不做 disjoint 推断会触发 E0502(2026-06-18 主代修)。
// 阶段3a 单真相源合并:两类挂起(path + risk)合一进 pending_approvals,占位都需终态化。
let entries: Vec<(String, Option<String>)> = session
.pending_approvals
.values()
@@ -66,6 +70,73 @@ fn finalize_pending_placeholders(session: &mut super::super::AiSession, conv_id:
}
}
/// 统一解析「/ 技能」+「@ mention 区间」为 augmentation 注入段。
///
/// 把 4 调用方(send / force_send / regenerate / edit)原本各拼一段的 skill 注入收敛至此,
/// 解决「@ 与 / 两条增强通道分别注入」的结构性问题(plan mighty-wibbling-papert.md 核心设计)。
///
/// - `skill`(若 `Some`)转 [`MentionRef::Skill { name }`],由 SkillResolver 走剥 frontmatter 的读取
/// (取代旧实现直接 `read_skill_content` 灌全文含 frontmatter)。
/// - `spans` 按 `kind` 转 [`MentionRef`]:project/task/idea 用 `ref_id` + `label`,skill 用 `label` 作 name。
/// - locality 取当前激活 provider(远程 provider path 仅 basename / 本地全路径,防裸泄)。
/// - 单条 resolve 失败由 `resolve_all` 收集进 errors 不中断整批(整批注入最大化保留可用上下文)。
///
/// 空结果返 `""`,调用方据之跳过拼接(不污染 prompt)。
///
/// 注:regenerate / edit 路径当前传 `skill=&None, spans=&None`(无新注入诉求),
/// 若后续需从历史末条 user 消息的 mentionSpans resolve,改这两处调用即可。
async fn resolve_and_inject(
state: &AppState,
provider: &AiProviderRecord,
skill: &Option<String>,
spans: &Option<Vec<MentionSpanDto>>,
lang: &str,
) -> String {
let mut refs: Vec<MentionRef> = Vec::new();
if let Some(name) = skill.as_ref().filter(|s| !s.trim().is_empty()) {
refs.push(MentionRef::Skill { name: name.clone() });
}
if let Some(spans) = spans.as_ref() {
for span in spans {
if let Some(rf) = span_to_mention_ref(span) {
refs.push(rf);
}
}
}
if refs.is_empty() {
return String::new();
}
let loc = sanitize::locality_of(provider);
let (augs, _errors) = state.resolvers.resolve_all(&refs, loc).await;
build_augmentation_segment(&augs, lang)
}
/// 单条 [`MentionSpanDto`] → [`MentionRef`] 转换(kind 驱动)。
///
/// 未知 kind / 空 ref_id 返 None(静默跳过,不中断整批注入——与 resolve_all 失败收集语义一致)。
/// skill kind 用 `label` 作 name(skill 以 name 为唯一键,DTO 的 ref_id 也即 name,这里取 label
/// 保证展示一致;二者应等价)。
fn span_to_mention_ref(span: &MentionSpanDto) -> Option<MentionRef> {
match span.kind.as_str() {
"project" => Some(MentionRef::Project {
id: span.ref_id.clone(),
name: span.label.clone(),
}),
"task" => Some(MentionRef::Task {
id: span.ref_id.clone(),
name: span.label.clone(),
}),
"idea" => Some(MentionRef::Idea {
id: span.ref_id.clone(),
name: span.label.clone(),
}),
"skill" => Some(MentionRef::Skill {
name: span.label.clone(),
}),
_ => None,
}
}
// ============================================================
// 发送 / 审批 / 控制
// ============================================================
@@ -128,30 +199,21 @@ pub async fn ai_regenerate(
let lang = language.unwrap_or_else(|| "zh-CN".to_string());
let system_prompt = build_system_prompt(&state, &lang).await;
// 知识注入:取末尾 user 消息文本做检索(与 send 同款,语义命中刷新上下文)
// F-260616-09 B 批4:conv_id 直接用 IPC 参数 conversation_id,读 per_conv.messages。
// conv_id 直接用 IPC 参数 conversation_id(F-260616-09 B 批4,读 per_conv.messages)。
let conv_id = conversation_id.clone();
let last_user_text = {
let session = state.ai_session.lock().await;
let msgs = session.conv_read(&conv_id).map(|c| c.messages.all_messages_clone())
.unwrap_or_default();
msgs.iter().rev()
.find(|m| matches!(m.role, df_ai::provider::MessageRole::User))
.map(|m| m.content.clone())
.unwrap_or_default()
};
// F-260619-04 P1:取末条 user 消息 id 供知识注入 referenced 事件溯源。
let user_message_id = {
let session = state.ai_session.lock().await;
session.conv_read(&conv_id).and_then(|c| c.messages.last_user_message_id())
};
let mut system_prompt = system_prompt;
{
// 知识注入:取末条 active user 消息文本做检索(与 send 同款,语义命中刷新上下文)。
// DRY(B):收敛至 inject_knowledge_into_prompt 单一入口(同消息取 text+id,②口径修复:
// 原 last_user_text 不过滤 is_active / user_message_id 走 last_user_message_id 不过滤 is_active,
// 两值可能取自不同消息;helper 单次反向扫描同一条消息取两值)。
let mut system_prompt = {
let config = state.knowledge_config.lock().await.clone();
let knowledge_context = build_knowledge_context(&state, &conv_id, &last_user_text, &config, user_message_id.as_deref()).await;
if !knowledge_context.is_empty() {
system_prompt = format!("{}\n\n---\n{}", knowledge_context, system_prompt);
}
inject_knowledge_into_prompt(&state, &conv_id, system_prompt, &config).await
};
// Augmentation 注入:regenerate 路径无新 @ mention / 技能,传 None 走空路径(不污染 prompt)。
// 若未来需从末条 user 消息的 mentionSpans resolve(验证 #8),改此处传入即可。
let aug_seg = resolve_and_inject(&state, &provider_config, &None, &None, &lang).await;
if !aug_seg.is_empty() {
system_prompt = format!("{}\n\n---\n{}", aug_seg, system_prompt);
}
// 落库:弹出后的历史先持久化(前端立即反映已删旧回复;loop 内再 save 覆盖)
@@ -221,6 +283,9 @@ pub async fn ai_chat_send(
// (不进 NodeContext.config/NodeOutput/tool_call schema/IPC 返回值/日志/错误),
// 仅经 ai_chat_send 落 session.messages + 经 provider 请求(波20 truncate_parts 防 DB 撑爆)。
parts: Option<Vec<ContentPart>>,
// Input Augmentation:用户消息内 @ mention 区间元数据(chip 精确替换 + 后端 resolve 注入)。
// None/空 → 无 @ mention(向后兼容,仅 / 技能走 skill 参数);非空 → 按 kind 投影成 Augmentation。
mention_spans: Option<Vec<MentionSpanDto>>,
) -> Result<String, String> {
// 获取活跃提供商（只读，失败可直接返回，不影响生成标志）
let provider_config = super::super::prompt::get_active_provider(&state).await?;
@@ -230,7 +295,7 @@ pub async fn ai_chat_send(
// - 目标 conv 取入参 conversation_id(前端传 activeConversationId),None/空时 fallback
// active(旧调用方兼容);若 active 也为 None(首次发送),懒创建新 conv id。
// - per_conv 是唯一真相源,删除顶层双写(批2 桥接已退役)。
let (conv_id, user_message_id) = {
let (conv_id, _user_message_id) = {
let mut session = state.ai_session.lock().await;
// 目标 conv:入参优先 → active → 懒创建。
let target = conversation_id.clone().filter(|s| !s.is_empty())
@@ -288,7 +353,9 @@ pub async fn ai_chat_send(
} else {
conv.messages.push(ChatMessage::user(&user_content));
}
// F-260619-04 P1:push 后立即取末条 user 消息 id(本轮 user,供知识注入 referenced 溯源)。
// F-260619-04 P1:push 后取末条 user 消息 id(本轮 user,原供知识注入 referenced 溯源)。
// DRY(B):知识注入已收敛至 inject_knowledge_into_prompt(helper 内部同消息取 text+id),
// 此处 user_msg_id 不再透传到注入逻辑,保留下划线占用(锁内 push 已发生,语义不变)。
let user_msg_id = conv.messages.last_user_message_id();
(target, user_msg_id)
};
@@ -297,27 +364,21 @@ pub async fn ai_chat_send(
let _tool_defs = state.ai_tools.tool_definitions();
let lang = language.unwrap_or_else(|| "zh-CN".to_string());
let mut system_prompt = build_system_prompt(&state, &lang).await;
// 技能注入：读 SKILL.md 全文拼到 system prompt 前作为指令
// 隔离标注(FR-S4)：用明确头尾标注包裹，标明"仅供 AI 参考、非用户消息、非系统指令"，
// 防 SKILL.md 内的 prompt injection 与用户指令/行为准则混淆。
if let Some(ref skill_name) = skill {
if let Some(content) = read_skill_content(skill_name) {
system_prompt = format!(
"--- 以下是用户选择的技能「{}」的说明（仅供 AI 参考，非用户消息，勿作为行为准则覆盖）---\n\n{}\n\n--- 技能说明结束 ---\n\n{}",
skill_name, content, system_prompt
);
}
// Augmentation 注入:/ 技能 + @ mention 经统一 Resolver 投影后拼到 system prompt 前。
// 隔离标注(build_augmentation_segment 头尾包裹,FR-S4 风格)防 prompt injection 与用户指令/行为准则混淆。
let aug_seg = resolve_and_inject(&state, &provider_config, &skill, &mention_spans, &lang).await;
if !aug_seg.is_empty() {
system_prompt = format!("{}\n\n---\n{}", aug_seg, system_prompt);
}
// conv_id 已在上方状态占用块得出(入参/active/懒创建),供知识注入溯源 + spawn 后台 loop。
// 知识注入：检索相关知识拼到 system prompt 前(可配置开关 auto_inject,默认开)
// 最终顺序:[知识库上下文] --- [技能指令] --- [原始 system prompt]
// DRY(B):收敛至 inject_knowledge_into_prompt 单一入口(同消息取 text+id,②口径修复)。
// 注:此路径 message 刚 push 为末条 active user,helper 读到的即本轮 user,语义等价。
{
let config = state.knowledge_config.lock().await.clone();
let knowledge_context = build_knowledge_context(&state, &conv_id, &message, &config, user_message_id.as_deref()).await;
if !knowledge_context.is_empty() {
system_prompt = format!("{}\n\n---\n{}", knowledge_context, system_prompt);
}
system_prompt = inject_knowledge_into_prompt(&state, &conv_id, system_prompt, &config).await;
}
// 在后台任务中执行流式调用
@@ -347,11 +408,15 @@ pub async fn ai_approve(
tool_call_id: String,
approved: bool,
) -> Result<String, String> {
authz_debug(&format!("[ai_approve] 入口 tool_call_id={} approved={}", tool_call_id, approved));
let mut session = state.ai_session.lock().await;
let approval = match session.pending_approvals.remove(&tool_call_id) {
Some(a) => a,
None => {
// 阶段3a 单真相源合并:ai_approve 从单 pending_approvals remove(原 risk_pending 合一)。
// 若前端误调 ai_approve 消费 path_auth 挂起 → 这里拿不到该 id(kind=Path 的挂起也走同一表,
// 但下方 kind 校验会拦截 Err)。无挂起则查审计表(幂等,已处理返成功)。
// F-260616-06: 幂等——内存无挂起审批时查审计表，若已处理则返回成功（非报错）
// BUG-260618-11: 区分 Err(DB 故障)与 Ok(None)(真无记录),原 unwrap_or_default 把
// Err 压成 None,DB 故障被「未找到」误导(实为可重试故障),对齐 audit.rs audit_finalize 三路分流。
@@ -370,19 +435,18 @@ pub async fn ai_approve(
return Err(format!("未找到挂起的审批: {}", tool_call_id));
}
};
// recovered 字段保留读取(标记重启恢复来源,未来扩展用),本次修复移除 if !recovered 落库守卫。
let _recovered = approval.recovered;
// F-260619-03 Phase B: 路径授权挂起的 pending 不走 ai_approve(它不预写授权目录,
// 直接 execute 会因路径未授权失败)。引导前端改用 ai_authorize_dir(写 session/persistent 后执行)。
// 防御:前端误调时回滚 pending(重新 insert)+ 返明确错误,避免 pending 被误消费丢失。
if approval.path_auth.is_some() {
state.ai_session.lock().await.pending_approvals.insert(tool_call_id.clone(), approval);
// 阶段3a 决策层分离:ai_approve 只消费 kind==Risk(普通 Med/High 审批,一次性 approve/reject)。
// 若前端误调 ai_approve 消费 kind==Path 挂起(应走 ai_authorize_dir)→ Err 防误调,
// 避免把路径授权挂起当 Risk 审批执行(会跳过白名单写入,语义错乱)。
// 兜底/回退:误调返回 Err 前不回滚 insert(前端拿 Err 自行刷新 pending,等价原「未找到」语义)。
if !matches!(approval.kind, ApprovalKind::Risk { .. }) {
return Err(format!(
"tool_call_id={} 是路径授权挂起,请用 ai_authorize_dir(decision: once/always/deny)",
"tool_call_id={} 非普通审批(路径授权请用 ai_authorize_dir)",
tool_call_id
));
}
// recovered 字段保留读取(标记重启恢复来源,未来扩展用),本次修复移除 if !recovered 落库守卫。
let _recovered = approval.recovered;
if !approved {
// 替换占位 tool_result 为拒绝结果
@@ -463,7 +527,17 @@ pub async fn ai_approve(
let exec_result: anyhow::Result<serde_json::Value> = if approval.tool_name == "run_workflow" {
super::super::execute_run_workflow_for_tool(&app, &state, &args).await
} else {
state.ai_tools.execute(&approval.tool_name, args.clone()).await
// F-260620 对齐 ai_authorize_dir(:658):ai_approve 执行同样包 60s 超时。
// 防 list_directory 大目录/run_command 慢命令卡死 → 到不了 audit_finalize/emit/try_continue
// → IPC 永挂 → per_conv.generating 永真 → 前端 130s 看门狗静默吞消息(F-260620 同型故障,
// 之前只给 ai_authorize_dir 加超时,ai_approve 漏)。
match tokio::time::timeout(
std::time::Duration::from_secs(60),
state.ai_tools.execute(&approval.tool_name, args.clone()),
).await {
Ok(r) => r,
Err(_) => Err(anyhow::anyhow!("工具执行超时(60s): {}", approval.tool_name)),
}
};
// 工具失败不 return Err：把错误包成 tool_result，落库 + emit completed + 续循环全走通。
// 否则前端 approveToolCall 的 catch 会回滚 pending_approval，审批按钮卡死无法消除。
@@ -549,6 +623,84 @@ pub async fn ai_approve(
Ok("executed".to_string())
}
/// F-260620 临时诊断:授权/审批 IPC 调用链文件日志(不依赖终端 stderr,读 authz-debug.log 定位)。
fn authz_debug(msg: &str) {
use std::io::Write;
if let Ok(mut f) = std::fs::OpenOptions::new().create(true).append(true)
.open("E:/wk-lab/devflow/authz-debug.log")
{
let _ = writeln!(f, "{}", msg);
}
}
/// 阶段4(容错/恢复):取路径的 Windows 盘符(如 "C:" / "E:"),非 Windows / 无盘符返 None。
///
/// 仅做词法判断(取前两字符 `<drive>:`),不做 canonicalize(避免 IO 卡死——这正是本批
/// 防卡死预检的目标)。UNC 路径 `\\server\share` 返 None(跨盘语义不适用)。
fn drive_letter(path: &str) -> Option<String> {
let bytes = path.as_bytes();
if bytes.len() >= 2 && bytes[1] == b':' && bytes[0].is_ascii_alphabetic() {
let drive = (bytes[0] as char).to_ascii_uppercase();
return Some(format!("{}:", drive));
}
None
}
/// workspace_root 盘符(同 mod.rs workspace_root_str 派生:CARGO_MANIFEST_DIR 上两级)。
///
/// 与 tool_registry::workspace_root() 同源(编译期 CARGO_MANIFEST_DIR),用于跨盘对比基准。
/// 失败回退 None(对比退化,不报跨盘提示)。
fn workspace_drive() -> Option<String> {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.parent()
.and_then(|p| p.parent())
.map(std::path::PathBuf::from)
.unwrap_or_else(|| std::path::PathBuf::from("."));
drive_letter(&root.to_string_lossy())
}
/// 阶段4:检测授权路径是否与 workspace 跨盘,返提示文案(Some=跨盘需告知 LLM,None=同盘无提示)。
///
/// 仅对涉及文件移动/删除的工具(delete_file / rename_file)有意义——这些工具的目标位
/// (.trash 或 rename 的 to)锚定 workspace_root,源在另一盘时走 copy+remove 降级。
/// 其他文件工具(read_file/write_file)无跨盘移动语义,不提示。
fn cross_drive_hint(tool_name: &str, raw_paths: &[String]) -> Option<String> {
// 仅文件移动/删除类工具涉及跨盘(源在 A 盘 → 目标 .trash/to 在 workspace 盘)
if !matches!(tool_name, "delete_file" | "rename_file" | "move_file") {
return None;
}
let ws_drive = workspace_drive()?;
let cross_drives: Vec<&String> = raw_paths.iter()
.filter(|p| drive_letter(p).map_or(false, |d| d != ws_drive))
.collect();
if cross_drives.is_empty() {
return None;
}
Some(format!(
"⚠ 跨盘提示:路径 {:?} 与工作区({})不同盘,工具内部走 copy+remove 降级(非原子,大文件较慢,失败可能留残,已内置回滚)",
cross_drives, ws_drive
))
}
/// 把跨盘提示追加到 tool_result(保留原结果,仅追加提示行)。
///
/// - String 结果:追加 `\n<提示>`。
/// - Object 结果:追加 `cross_drive_note` 字段(不覆盖原字段)。
/// - 其他类型:包成 Object 的 `result` + `cross_drive_note` 双字段。
fn append_cross_drive_note(result: serde_json::Value, note: &str) -> serde_json::Value {
match result {
serde_json::Value::String(s) => serde_json::Value::String(format!("{}\n{}", s, note)),
serde_json::Value::Object(mut map) => {
map.insert("cross_drive_note".to_string(), serde_json::Value::String(note.to_string()));
serde_json::Value::Object(map)
}
other => serde_json::json!({
"result": other,
"cross_drive_note": note,
}),
}
}
/// F-260619-03 Phase B: 路径授权弹窗决策(消费 AiDirAuthRequired 挂起的 pending)。
///
/// 触发:process_tool_calls 预校验文件工具路径未命中白名单 → 挂起 loop(insert pending
@@ -568,7 +720,15 @@ pub async fn ai_authorize_dir(
tool_call_id: String,
decision: String,
) -> Result<String, String> {
// 取 pending(必须是 path_auth 挂起;普通 RiskLevel 审批走 ai_approve)
// F-260620 卡死已根治(路径授权审批链闭环)。原 [AI-AUTHZ] eprintln 降级为 tracing::debug,
// 避免污染 stderr(用户可见);authz_debug 文件日志保留(读 authz-debug.log 定位,排障仍可用)。
tracing::debug!(
tool_call_id = %tool_call_id,
decision = %decision,
"[AI-AUTHZ] ai_authorize_dir 入口"
);
authz_debug(&format!("[ai_authorize_dir] 入口 tool_call_id={} decision={}", tool_call_id, decision));
// 取 pending(阶段3a 单真相源合并:从 pending_approvals remove;kind 校验为 Path)。
let approval = {
let mut session = state.ai_session.lock().await;
match session.pending_approvals.remove(&tool_call_id) {
@@ -576,10 +736,27 @@ pub async fn ai_authorize_dir(
None => return Err(format!("未找到路径授权挂起: {}", tool_call_id)),
}
};
let req = approval.path_auth.clone().ok_or_else(|| {
format!("tool_call_id={} 非路径授权挂起(普通审批请用 ai_approve)", tool_call_id)
})?;
let dir_str = req.dir.to_string_lossy().to_string();
// 阶段3a 决策层分离:ai_authorize_dir 只消费 kind==Path(路径授权挂起,once/always/deny)。
// 提取 PathAuthRequest(kind 下沉原 path_auth 字段),非 Path(误调普通 RiskLevel 审批)→ Err。
// 兜底/回退:Err 前 re-insert 回 pending_approvals 保持挂起态(原「未找到」会丢挂起致卡死,
// re-insert 保守兜底防误调导致 pending 丢失 + loop 永挂)。
let req = match approval.kind.clone() {
ApprovalKind::Path(req) => req,
ApprovalKind::Risk { .. } => {
// 误调:re-insert 回单表保持挂起,返 Err(前端据 Err 提示改调 ai_approve)。
let mut session = state.ai_session.lock().await;
session.pending_approvals.insert(tool_call_id.clone(), approval);
return Err(format!(
"tool_call_id={} 非路径授权挂起(普通审批请用 ai_approve)",
tool_call_id
));
}
};
// L1 补丁:req.dirs 含所有未授权父目录(rename_file from/to 不同目录时多项)。
// once/always 遍历全部写入白名单,确保工具执行时 handler 内 resolve 全放行。
let dir_strs: Vec<String> = req.dirs.iter()
.map(|d| d.to_string_lossy().to_string())
.collect();
let conv_id = approval.conversation_id.clone();
let args = approval.arguments.clone();
@@ -616,30 +793,59 @@ pub async fn ai_authorize_dir(
}
// ── "once":写会话级临时授权(随会话销毁,不落库) ──
// L1 补丁:遍历所有未授权父目录(rename_file from+to 不同目录时多项)。
if decision == "once" {
state.add_session_allowed_dir(dir_str.clone()).await;
for d in &dir_strs {
state.add_session_allowed_dir(d.clone()).await;
}
}
// ── "always":写持久化授权(Settings KV + 同步内存 persistent) ──
if decision == "always" {
if let Err(e) = state.add_persistent_allowed_dir(dir_str.clone()).await {
tracing::warn!("[F-03B] 持久化授权目录失败(降级仅本次会话): {}", e);
// 降级:写入会话临时授权,保本路径本会话可用
state.add_session_allowed_dir(dir_str.clone()).await;
for d in &dir_strs {
if let Err(e) = state.add_persistent_allowed_dir(d.clone()).await {
tracing::warn!("[F-03B] 持久化授权目录失败(降级仅本次会话): dir={} err={}", d, e);
// 降级:写入会话临时授权,保本路径本会话可用
state.add_session_allowed_dir(d.clone()).await;
}
}
}
// ── 执行工具(路径现已授权,handler 内 resolve_workspace_path_with_allowed 放行) ──
// 复用 ai_approve 执行分支:run_workflow 特殊处理 / 其余走 ai_tools.execute
tracing::debug!(tool = %approval.tool_name, "[AI-AUTHZ] execute 前");
// F-260620 防工具卡死 ai_authorize_dir(致 per_conv.generating 永真 + 前端看门狗 130s 超时后
// 静默吞消息):list_directory 等大目录工具可能 read_dir+metadata 海量文件卡住,execute 不返回
// → 到不了 audit_finalize/emit/try_continue → IPC 永挂 → generating 永真。包 60s 超时(对齐
// run_command),超时返 Err → 走 failed 分支 finalize+emit+try_continue,IPC 必返回不卡。
let exec_result: anyhow::Result<serde_json::Value> = if approval.tool_name == "run_workflow" {
super::super::execute_run_workflow_for_tool(&app, &state, &args).await
} else {
state.ai_tools.execute(&approval.tool_name, args.clone()).await
match tokio::time::timeout(
std::time::Duration::from_secs(60),
state.ai_tools.execute(&approval.tool_name, args.clone()),
).await {
Ok(r) => r,
Err(_) => Err(anyhow::anyhow!("工具执行超时(60s): {}", approval.tool_name)),
}
};
let (audit_status, result_val) = match &exec_result {
tracing::debug!(
ok = exec_result.is_ok(),
status = if exec_result.is_ok() { "executed" } else { "failed" },
"[AI-AUTHZ] execute 后"
);
let (audit_status, mut result_val) = match &exec_result {
Ok(val) => ("executed", val.clone()),
Err(e) => ("failed", serde_json::Value::String(e.to_string())),
};
// 阶段4(容错/恢复):跨盘预检 → tool_result 提示。
// 检测授权路径(req.raw_paths 规范化前原值)与 workspace_root 是否跨盘(Windows 不同盘符,
// 如 C盘授权路径 → E盘 workspace)。跨盘时文件工具(delete_file→.trash / rename_file from→to)
// 内部走 copy+remove 降级(非原子,大文件慢),提示 LLM 知晓成本 + 失败留残风险。
// 提示追加到 result_val(tool_result),不阻断执行(降级已能处理,仅告知)。
if let Some(note) = cross_drive_hint(&approval.tool_name, &req.raw_paths) {
result_val = append_cross_drive_note(result_val, &note);
}
audit_finalize(&state, &tool_call_id, audit_status, Some(result_val.to_string())).await;
if exec_result.is_ok() {
emit_data_changed(&app, &approval.tool_name);
@@ -681,10 +887,17 @@ pub async fn ai_authorize_dir(
}
/// 待审批工具调用信息(前端恢复 toolCard pending_approval 态用)
///
/// 阶段4:`kind` 字段透传(`risk` / `path`),前端 switchConversation 恢复 pendingApprovals 时
/// 按 kind 渲染——risk 类显 approve/reject,path 类显 once/always/deny(对齐阶段3b 统一审批模型)。
#[derive(Debug, Serialize)]
pub struct PendingToolCallInfo {
pub tool_call_id: String,
pub conversation_id: Option<String>,
/// 阶段4:审批类型,前端按 kind 渲染不同决策按钮。
/// 'risk' = 普通 RiskLevel 审批(approve/reject);'path' = 路径授权(once/always/deny)。
#[serde(rename = "kind")]
pub kind: &'static str,
}
/// 查询某对话积压的待审批工具(前端 switchConversation 后恢复 toolCard 的 pending_approval 态)
@@ -694,6 +907,10 @@ pub async fn ai_pending_tool_calls(
conv_id: String,
) -> Result<Vec<PendingToolCallInfo>, String> {
let session = state.ai_session.lock().await;
// 阶段3a 单真相源合并:单 pending_approvals 表按 conv_id 过滤,kind 字段透传给前端。
// 阶段4:返 kind 字段,前端 switchConversation 恢复 pendingApprovals 时按 kind 渲染
// (risk→approve/reject,path→once/always/deny),对齐阶段3b 统一审批模型。
// (阶段3a 时前端仅恢复 kind==Risk 走 toolCard;阶段3b 前端切后 path 类也归一渲染,后端两 kind 都返。)
let list = session
.pending_approvals
.values()
@@ -701,6 +918,10 @@ pub async fn ai_pending_tool_calls(
.map(|a| PendingToolCallInfo {
tool_call_id: a.tool_call_id.clone(),
conversation_id: a.conversation_id.clone(),
kind: match a.kind {
ApprovalKind::Risk { .. } => "risk",
ApprovalKind::Path(_) => "path",
},
})
.collect();
Ok(list)
@@ -720,6 +941,7 @@ pub async fn ai_chat_clear(state: State<'_, AppState>) -> Result<(), String> {
if let Some(ref id) = active_id {
session.conv(id).messages.clear();
}
// 阶段3a 单真相源合并:单表 retain(口径不变:清本 conv 保留其他 conv,kind 不区分)。
session.pending_approvals.retain(|_, a| a.conversation_id.as_deref() != active_id.as_deref());
drop(session);
// 真删 DB:清空该对话 messages(JSON 备份列同步清空 + 清零 token,保留对话壳),刷新不再恢复(AR-7)
@@ -966,33 +1188,20 @@ pub async fn ai_chat_edit(
let lang = language.unwrap_or_else(|| "zh-CN".to_string());
let system_prompt = build_system_prompt(&state, &lang).await;
// 知识注入:用新 user 文本检索(与 send/regenerate 同款)
// F-260616-09 B 批4:conv_id 直接用 IPC 参数 conversation_id,读 per_conv.messages。
// conv_id 直接用 IPC 参数 conversation_id(F-260616-09 B 批4,读 per_conv.messages)。
let conv_id = conversation_id.clone();
let last_user_text = {
let session = state.ai_session.lock().await;
let msgs = session.conv_read(&conv_id).map(|c| c.messages.all_messages_clone())
.unwrap_or_default();
// 取末条 active user 文本(sanitize 前的全量,但 truncated 已标,这里取 active 的末条)
msgs.iter()
.rev()
.find(|m| matches!(m.role, df_ai::provider::MessageRole::User) && m.is_active())
.map(|m| m.content.clone())
.unwrap_or_default()
};
// F-260619-04 P1:取末条 active user 消息 id 供知识注入 referenced 溯源。
let user_message_id = {
let session = state.ai_session.lock().await;
session.conv_read(&conv_id).and_then(|c| c.messages.last_user_message_id())
};
let mut system_prompt = system_prompt;
{
// 知识注入:用新 user 文本检索(与 send/regenerate 同款)。
// DRY(B):收敛至 inject_knowledge_into_prompt 单一入口(同消息取 text+id,②口径修复)。
// 注:edit 路径上方已 replace_last_active_user_content 把新文本写回末条 active user,
// helper 读到的末条 active user 即编辑后的新文本,语义等价。
let mut system_prompt = {
let config = state.knowledge_config.lock().await.clone();
let knowledge_context =
build_knowledge_context(&state, &conv_id, &last_user_text, &config, user_message_id.as_deref()).await;
if !knowledge_context.is_empty() {
system_prompt = format!("{}\n\n---\n{}", knowledge_context, system_prompt);
}
inject_knowledge_into_prompt(&state, &conv_id, system_prompt, &config).await
};
// Augmentation 注入:edit 路径无新 @ mention / 技能,传 None 走空路径(不污染 prompt)。
let aug_seg = resolve_and_inject(&state, &provider_config, &None, &None, &lang).await;
if !aug_seg.is_empty() {
system_prompt = format!("{}\n\n---\n{}", aug_seg, system_prompt);
}
// 落库:编辑+截断后的历史先持久化(前端立即反映已截断旧回复)
@@ -1052,6 +1261,8 @@ pub async fn ai_chat_force_send(
// F-260614-05 Phase 2c: 透传 parts(强制发送同款多模态支持)。
// FR-S1 核验:ContentPart Image base64 是图片数据非 api_key,不入敏感面,语义同 ai_chat_send。
parts: Option<Vec<ContentPart>>,
// Input Augmentation:@ mention 区间元数据(同 ai_chat_send,语义一致)。
mention_spans: Option<Vec<MentionSpanDto>>,
// F-260616-09 B 批4(决策 e 真并发上线):加 conversation_id 参数,强制复位+发送仅作用于目标 conv。
// None/空 → fallback active(旧调用方兼容)。
conversation_id: Option<String>,
@@ -1066,7 +1277,7 @@ pub async fn ai_chat_force_send(
// F-260616-09 B 批4(决策 e):force_send 仅复位**目标 conv 自己**的 generating(用户当前面板),
// 不再跨 conv 杀(旧实现清全局 generating + 全 clear pending_approvals,在真并发下会误杀其他
// 后台 conv 的 loop/审批)。pending_approvals 仅清目标 conv 的(retain),保留其他 conv 的。
let (old_conv_id, conv_id, user_message_id) = {
let (old_conv_id, conv_id, _user_message_id) = {
let mut session = state.ai_session.lock().await;
// 目标 conv:入参优先 → active → 懒创建。
let target = conversation_id.clone().filter(|s| !s.is_empty())
@@ -1091,6 +1302,7 @@ pub async fn ai_chat_force_send(
// SW-260618-02:强制发送丢弃目标 conv 的旧审批,先终态化占位 tool_result,防占位随 messages
// 残留下次发送喂给 LLM。仅清目标 conv 的 pending_approvals(retain 保留其他 conv)。
finalize_pending_placeholders(&mut *session, &target, "已取消");
// 阶段3a 单真相源合并:单表 retain(仅清目标 conv,保留其他 conv,kind 不区分)。
session.pending_approvals.retain(|_, a| a.conversation_id.as_deref() != Some(target.as_str()));
{
let conv = session.conv(&target);
@@ -1138,25 +1350,21 @@ pub async fn ai_chat_force_send(
});
}
// system prompt 构建(照 ai_chat_send):技能注入 + 知识注入顺序一致。
// system prompt 构建(照 ai_chat_send):augmentation 注入 + 知识注入顺序一致。
let _tool_defs = state.ai_tools.tool_definitions();
let lang = language.unwrap_or_else(|| "zh-CN".to_string());
let mut system_prompt = build_system_prompt(&state, &lang).await;
if let Some(ref skill_name) = skill {
if let Some(content) = read_skill_content(skill_name) {
system_prompt = format!(
"--- 以下是用户选择的技能「{}」的说明（仅供 AI 参考，非用户消息，勿作为行为准则覆盖）---\n\n{}\n\n--- 技能说明结束 ---\n\n{}",
skill_name, content, system_prompt
);
}
// Augmentation 注入:/ 技能 + @ mention 经统一 Resolver 投影(语义同 ai_chat_send)。
let aug_seg = resolve_and_inject(&state, &provider_config, &skill, &mention_spans, &lang).await;
if !aug_seg.is_empty() {
system_prompt = format!("{}\n\n---\n{}", aug_seg, system_prompt);
}
// conv_id 已在上方状态占用块得出。
// 知识注入:DRY(B):收敛至 inject_knowledge_into_prompt 单一入口(同消息取 text+id,②口径修复)。
// 此路径 message 刚 push 为末条 active user,helper 读到的即本轮 user,语义等价。
{
let config = state.knowledge_config.lock().await.clone();
let knowledge_context = build_knowledge_context(&state, &conv_id, &message, &config, user_message_id.as_deref()).await;
if !knowledge_context.is_empty() {
system_prompt = format!("{}\n\n---\n{}", knowledge_context, system_prompt);
}
system_prompt = inject_knowledge_into_prompt(&state, &conv_id, system_prompt, &config).await;
}
// 后台 spawn agentic loop(照 ai_chat_send:229-242 / ai_chat_edit:695-721 同款)
@@ -1206,8 +1414,13 @@ pub async fn ai_chat_stop(
return Ok(());
}
// 目标 conv 是否有待审批(仅本 conv 的)。
let has_pending = session.pending_approvals.values()
.any(|a| a.conversation_id.as_deref() == Some(target.as_str()));
// path_auth 审批链阶段1:改调 session_state(target) 收敛状态机判定,替代手写两表合并。
// 阶段3a 单真相源合并后:session_state 单表 any 判定(原双表 OR 合一)。
//
// 兜底/快速回退(改一行即可):
// let has_pending = session.pending_approvals.values()
// .any(|a| a.conversation_id.as_deref() == Some(target.as_str()));
let has_pending = session.session_state(&target) == SessionState::AwaitingApproval;
if has_pending {
// 审批等待态：loop 已退出，直接清理目标 conv 让其立即可用
// SW-260618-02:messages 不 clear,占位 tool_result 会残留,下次发送喂给 LLM。
@@ -1314,7 +1527,7 @@ pub async fn ai_continue_loop(
/// 场景：run_agentic_loop 达 max_iterations 未收敛 → emit AiMaxRoundsReached + 保持
/// generating=true 暂停。用户点停止调本命令 → 复位 generating + emit AiCompleted（标收敛）。
///
/// 不重复 save 逻辑：暂停态进入前 run_agentic_loop 已 save_conversation 落库（agentic.rs
/// 不重复 save 逻辑：暂停态进入前 run_agentic_loop 已 save_conversation 落库（agentic/mod.rs
/// 达上限分支），此处仅复位 generating + emit AiCompleted 通知前端收尾。校验复用 ai_approve
/// 模式（generating + active_conversation_id 一致性）。
#[tauri::command]

37
src-tauri/src/commands/ai/commands/config.rs
View File

@@ -1,7 +1,8 @@
//! skills + config 域 IPC — 4 个 `#[tauri::command]` 函数
//! skills + config 域 IPC — 5 个 `#[tauri::command]` 函数
//!
//! 原 `commands/ai/commands/mod.rs` 收敛到 re-export only 后,本文件承接最后一批 IPC:
//! - `ai_list_skills` — 列出本机 Claude 技能(skills + commands + plugins),供前端 `/` 联想
//! - `ai_reload_skills` — 热重载技能列表(核心设计6:invalidate + 重扫,不重启生效)
//! - `ai_set_concurrency_config` — LLM 并发上限运行时调整(global/per-conv,立即生效)
//! - `ai_set_agent_max_iterations` — Agentic 循环最大轮次(下次发消息生效)
//! - `ai_set_agent_max_retries` — 流式对话失败自动重试次数(下次发消息生效)
@@ -10,24 +11,36 @@
//! → `commands::*` → `ai/mod.rs` 的 `pub use self::commands::*` 透传到 `commands::ai::*`
//! → `lib.rs` invoke_handler + 前端 `api/ai.ts` 零改动。
//!
//! 注:`ai_list_skills` 复用 `super::super::skills::{skills_cached, SkillInfo}`(skills.rs
//! 模块提供进程内缓存 + 扫盘逻辑,本文件仅做 IPC 包装,不重复实现)。
//! 注:`ai_list_skills` / `ai_reload_skills` 复用 `super::super::skills::{skills_cached,
//! invalidate_skills, SkillInfo}`(skills.rs 模块提供进程内缓存 + 扫盘逻辑,本文件仅做
//! IPC 包装,不重复实现)。
use std::sync::atomic::Ordering;
use tauri::State;
// skills_cached(进程内缓存命中即 clone,不重复扫盘)/SkillInfo(技能统一返回结构)
// skills_cached(进程内缓存命中即 clone,不重复扫盘;RwLock 懒初始化返 owned Vec)
// /SkillInfo(技能统一返回结构)/invalidate_skills(写锁置 None 触发重扫)
// 来自 commands/ai/skills.rs,本域 IPC 复用,不重复定义。
use super::super::skills::{skills_cached, SkillInfo};
use super::super::skills::{invalidate_skills, skills_cached, SkillInfo};
use crate::state::AppState;
/// 列出本机 Claude 技能（skills + commands + plugins 三类），供前端 `/` 联想
#[tauri::command]
pub async fn ai_list_skills() -> Result<Vec<SkillInfo>, String> {
// 命中进程内缓存，命中后仅 clone，不重复扫盘
Ok(skills_cached().clone())
// 命中进程内缓存（skills_cached 已 owned Vec，直接返回）
Ok(skills_cached())
}
/// 热重载技能列表（核心设计6:进程内重载，不重启生效）。
///
/// 流程:`invalidate_skills`（写锁置 None）→ `skills_cached`（触发重扫）→ 返回最新列表。
/// 前端在用户改 ~/.claude/skills 后调本 IPC，立即拿到新列表（无需重启 app）。
#[tauri::command]
pub async fn ai_reload_skills() -> Result<Vec<SkillInfo>, String> {
invalidate_skills();
Ok(skills_cached())
}
/// 设置 LLM 调用并发上限（运行时调整，立即生效）
@@ -64,9 +77,9 @@ pub async fn ai_set_agent_max_iterations(
state: State<'_, AppState>,
value: u32,
) -> Result<(), String> {
// clamp 1-50：下限防 agent 失能（一轮即截断无法调任何工具），
// 上限防失控烧 token（50 轮足够覆盖复杂多步任务）
let clamped = value.clamp(1, 50) as usize;
// clamp 0-50：0 = 不限(run_agentic_loop 内 0→usize::MAX,loop 靠 stop/收敛/审批退出,不触发达上限暂停);
// 1-50 正常上限,上界 50 防失控烧 token(50 轮足够覆盖复杂多步任务)
let clamped = value.clamp(0, 50) as usize;
state.agent_max_iterations.store(clamped, Ordering::SeqCst);
Ok(())
}
@@ -75,9 +88,9 @@ pub async fn ai_set_agent_max_iterations(
///
/// 只重试流前失败（Init Err：未输出任何 token）；流中途失败（MidStream Partial）保文不重试。
/// 退避复用 retry::backoff_delay(1s→2s→4s+jitter) + is_status_retryable Fatal 分类 +
/// 30s 总预算(详见 agentic.rs 流前重试循环)。
/// 30s 总预算(详见 agentic/mod.rs 流前重试循环)。
/// 范围 clamp 0-10：0 表示不重试（直接报错），上限 10 防过度重试烧 token/拖慢体验。
/// 默认 3（复用 retry.rs backoff_delay + 错误分类，详见 agentic.rs 重试循环）。
/// 默认 3（复用 retry.rs backoff_delay + 错误分类，详见 agentic/mod.rs 重试循环）。
#[tauri::command]
pub async fn ai_set_agent_max_retries(
state: State<'_, AppState>,

8
src-tauri/src/commands/ai/commands/conversation.rs
View File

@@ -309,9 +309,10 @@ pub async fn ai_conversation_switch(
conv.iteration_used = 0;
conv.stop_flag.store(false, Ordering::SeqCst);
}
// 仅清空目标对话自身的 pending_approvals,保留其他对话的(防 init 重建的内存 HashMap 被清空,
// 仅清空目标对话自身的挂起审批,保留其他对话的(防 init 重建的内存 HashMap 被清空,
// 重启恢复链路:restore_pending_approvals(init 重建) → switchConversation(此处不清目标对话的)
// → ai_pending_tool_calls 查询 → ai_approve 落库)
// → ai_pending_tool_calls 查询 → ai_approve 落库)。
// 阶段3a 单真相源合并:单表 retain(kind 不区分,清本 conv 保留其他)。
session.pending_approvals.retain(|_, a| a.conversation_id.as_deref() != Some(&conversation_id));
// 释放 session lock 再做 async provider 查询 + spawn(避免持锁 await DB)
drop(session);
@@ -353,9 +354,10 @@ pub async fn ai_conversation_delete(
state.ai_conversations.delete(&conversation_id).await.map_err(err_str)?;
let mut session = state.ai_session.lock().await;
// 删除任意对话(含非活跃)都应清理其积压审批:pending_approvals 是单例 HashMap,
// 删除任意对话(含非活跃)都应清理其积压审批:挂起审批是会话级 HashMap,
// 非活跃对话的恢复审批(recovered,conversation_id 指向被删对话)若不 retain 清理,
// 会永久残留死审批条目。对齐 ai_conversation_switch 的 retain 口径(仅清目标对话,保留其他)。
// 阶段3a 单真相源合并:单表 retain(kind 不区分)。
session.pending_approvals.retain(|_, a| a.conversation_id.as_deref() != Some(&conversation_id));
// F-260616-09 B 批4:删除 conv 时移除其 per_conv 条目(设计 §4.1 conv 存在性判据依赖此,
// 旧 loop 检测 conv 不存在即退出)。per_conv 唯一真相源,删顶层 messages.clear 双写。

138
src-tauri/src/commands/ai/compress.rs
View File

@@ -40,9 +40,8 @@ use super::prompt::compress_prompt;
/// 注意:本函数只负责"喂 LLM 出摘要文本",不改 ContextManager 状态(标 compressed +
/// 插摘要 system 由调用方做,职责分离,便于单元测试与多调用点复用)。
//
// dead_code:阶段1 基础函数,阶段2 IPC(ai_chat_compress_context)/ 阶段3 agentic
// loop 自动压缩会调用。本阶段只暴露 + 单测,不接调用点(零行为变化原则)。
#[allow(dead_code)]
// 调用方:agentic/mod.rs:807(agentic loop 自动压缩)+ commands/chat.rs:1102
// (ai_chat_compress_context IPC)。
pub(crate) async fn compress_via_llm(
provider: &dyn LlmProvider,
provider_config: &AiProviderRecord,
@@ -54,6 +53,22 @@ pub(crate) async fn compress_via_llm(
if active_msgs.is_empty() {
return Err("无可压缩消息(active 消息为空)".to_string());
}
// 阶段2(占位配对完整性):压缩段含未闭合占位(占位 tool_result 无对应 tool_call 头)→
// 跳过该三元组不压缩,返 Err 让调用方降级(保留原状)。理由:压缩 LLM 摘要可能破坏占位
// content/__PENDING__ 标记或拆散占位 result 与(已丢的)头的关系,使下游 sanitize 无法识别
// 占位 → orphan 触发 400。保守跳过:含未闭合占位的段不压缩(降级走 build_for_request 裁剪
// 或关键词兜底),占位配对完整性由 sanitize step3.5 + 出口断言兜住。
//
// 检测:占位 tool_result(content 带 __PENDING__ 标记)的 tool_call_id 不在任何 assistant
// 头 tool_calls 内 → 未闭合占位 → 返 Err 跳过压缩。
if compress_segment_has_unclosed_placeholder(&active_msgs) {
return Err("压缩段含未闭合占位 tool_result,跳过压缩保留原状(防破坏占位配对致 400 orphan)".to_string());
}
// MED-1214(CR): 治毒——active_msgs 过 sanitize_messages(畸形 tool 配对自愈),
// 防 compress 带毒(assistant tool_calls 缺 result / 孤儿 tool_result 无 tool_calls)触发 provider 400。
// 同 build_for_request 语义:仅发送视图剔毒,不改 ContextManager 持久化。
let active_count = active_msgs.len();
let active_msgs = df_ai::context::ContextManager::sanitize_messages(active_msgs);
// 路由选模型:无 tool_use(纯文本摘要)。
// None(池空/无匹配)→ 兜底 default_model(行为不变)。
@@ -84,10 +99,18 @@ pub(crate) async fn compress_via_llm(
let _global_permit = llm_concurrency.acquire_global().await;
let _per_conv_permit = llm_concurrency.acquire_per_conv(conv_id).await;
let resp = provider
.complete(request)
.await
.map_err(|e| format!("LLM 压缩调用失败: {}", e))?;
// F-15 卡死根治(2026-06-21 诊断):provider.complete 原无超时,LLM hang → agentic loop
// (agentic/mod.rs:780)await 永不返 → run_agentic_loop 永挂 → generating 卡死
// (set_compressing(true) 已置 agentic/mod.rs:753,false 永不到达)。
// 加 60s timeout 兜底(对齐 ai_approve 超时):超时返 Err → 调用方 Err 分支
// (agentic/mod.rs:818-830)set_compressing(false) 复位 + 关键词摘要降级,loop 正常继续不卡死。
let resp = tokio::time::timeout(
std::time::Duration::from_secs(60),
provider.complete(request),
)
.await
.map_err(|_| format!("LLM 压缩调用超时(60s,active {} 条,可能 provider hang;降级关键词裁剪)", active_count))?
.map_err(|e| format!("LLM 压缩调用失败: {} (active {} 条,已 sanitize 治毒;若仍失败查 provider 原文 tool 配对)", e, active_count))?;
let summary = clean_summary(&resp.text);
if summary.is_empty() {
return Err("LLM 压缩返回空摘要".to_string());
@@ -95,9 +118,41 @@ pub(crate) async fn compress_via_llm(
Ok(summary)
}
/// 阶段2(占位配对完整性):检测压缩段是否含未闭合占位 tool_result。
///
/// 占位 tool_result(content 带 __PENDING__ 标记,审批挂起)若无对应 tool_call 头(头被裁/丢)
/// → 未闭合占位。压缩此类段会破坏占位配对(摘要改写 content / 拆散关系),使下游 sanitize
/// 无法识别占位 → orphan 触发 400。故调用方检测到未闭合占位即跳过压缩(返 Err 降级)。
///
/// 检测逻辑:收集段内所有 assistant 头的 tool_call.id;占位 tool_result 的 id 不在内 → 未闭合。
/// 已闭合占位(头在)可正常压缩(配对完整,摘要不影响头关系)。
fn compress_segment_has_unclosed_placeholder(msgs: &[ChatMessage]) -> bool {
use std::collections::HashSet;
let head_ids: HashSet<&str> = msgs
.iter()
.filter(|m| matches!(m.role, df_ai::provider::MessageRole::Assistant))
.filter_map(|m| m.tool_calls.as_ref())
.flatten()
.filter_map(|c| {
// 排除 TOOL_MISSING_PREFIX 占位头(非真实头,由出口断言自愈补的临时闭合头)
if c.id.starts_with(df_ai::context_helpers::TOOL_MISSING_PREFIX) {
None
} else {
Some(c.id.as_str())
}
})
.collect();
msgs.iter().any(|m| {
matches!(m.role, df_ai::provider::MessageRole::Tool)
&& df_ai::context_helpers::is_pending_placeholder(&m.content)
&& m.tool_call_id
.as_deref()
.is_some_and(|id| !head_ids.contains(id))
})
}
/// 清理 LLM 返回的摘要:去首尾空白 / 包裹性 markdown 代码围栏,空则原样返回
/// (调用方据空值报错)。保留内部 markdown 结构(## 标题 / 列表),摘要本身就是结构化文本。
#[allow(dead_code)]
fn clean_summary(raw: &str) -> String {
let t = raw.trim();
// 去掉可能的整体代码围栏(LLM 偶尔把整段包成 ```markdown ... ```)
@@ -146,4 +201,71 @@ mod tests {
// 未知语言降级中文
assert_eq!(compress_prompt("fr"), compress_prompt("zh"));
}
// ── 阶段2 占位配对完整性:compress_segment_has_unclosed_placeholder ──
#[test]
fn unclosed_placeholder_detected_when_no_head() {
// 占位 tool_result(带标记)无对应 tool_call 头 → 未闭合 → 应跳过压缩
let msgs = vec![
df_ai::provider::ChatMessage::user("问题"),
df_ai::provider::ChatMessage::tool_result(
"call_pending",
"需要用户审批，等待确认__PENDING__:call_pending",
),
];
assert!(
compress_segment_has_unclosed_placeholder(&msgs),
"无头的占位 tool_result 应判为未闭合占位"
);
}
#[test]
fn closed_placeholder_not_flagged() {
// 占位 tool_result 有对应 tool_call 头 → 已闭合 → 不跳过(可正常压缩)
let msgs = vec![
df_ai::provider::ChatMessage::user("问题"),
df_ai::provider::ChatMessage::assistant_with_tools(
"调",
vec![df_ai::provider::ToolCall::new(
"call_pending",
"write_file",
"{}",
)],
),
df_ai::provider::ChatMessage::tool_result(
"call_pending",
"需要用户审批，等待确认__PENDING__:call_pending",
),
];
assert!(
!compress_segment_has_unclosed_placeholder(&msgs),
"有头的占位 tool_result 是已闭合,不应跳过压缩"
);
}
#[test]
fn non_placeholder_orphan_not_flagged() {
// 普通 tool_result(非占位)无头 → 不算"未闭合占位"(普通 orphan 由 sanitize 处理,
// 不触发压缩跳过;占位保护语义专属于审批挂起占位)
let msgs = vec![
df_ai::provider::ChatMessage::user("问题"),
df_ai::provider::ChatMessage::tool_result("orphan_id", "普通结果"),
];
assert!(
!compress_segment_has_unclosed_placeholder(&msgs),
"非占位 orphan 不应触发压缩跳过(仅占位专享保护)"
);
}
#[test]
fn no_tool_messages_not_flagged() {
// 纯文本段(无 tool_result)→ 永不触发跳过
let msgs = vec![
df_ai::provider::ChatMessage::user("问题1"),
df_ai::provider::ChatMessage::assistant("回答1"),
df_ai::provider::ChatMessage::user("问题2"),
];
assert!(!compress_segment_has_unclosed_placeholder(&msgs));
}
}

300
src-tauri/src/commands/ai/knowledge_inject.rs
View File

@@ -85,9 +85,64 @@ async fn generate_embedding(
}
}
/// 知识条目发布时后台生成嵌入(fire-and-forget,失败仅 log)
/// 标记某条知识 embedding_status='failed'(G-2 收口:三处重复调用合一)。
///
/// 统一 warn 文案前缀(分支上下文 ctx 区分),失败本身非阻断(仅 log)。幂等(同值覆写)。
async fn mark_embedding_failed(repo: &KnowledgeRepo, id: &str, ctx: &str) {
if let Err(e) = repo.mark_embedding_failed(id).await {
tracing::warn!("标记 embedding_status=failed 失败({ctx},非阻断): {e}");
}
}
/// 后台 spawn 单条知识的嵌入生成任务(provider 已解析复用)。
///
/// 三个失败分支(写库失败 / 空向量 / provider Err)统一走 [`mark_embedding_failed`] 标 failed,
/// 可由 retry 入口补偿重试。成功(set_embedding 内已置 'done')仅 info log。
///
/// provider 以 Arc 共享:retry 路径解析一次 provider 复用传入多个并发子任务;发布路径单条同样可用。
fn spawn_embedding_task(
db: Arc<Database>,
provider: Arc<dyn LlmProvider>,
model: String,
id: String,
title: String,
content: String,
) {
tauri::async_runtime::spawn(async move {
let text = format!("{} {}", title, content);
let input: String = text.chars().take(8000).collect();
let repo = KnowledgeRepo::new(&db);
match provider.embed(&model, vec![input]).await {
Ok(vecs) if !vecs.is_empty() => {
// set_embedding 内已把 embedding_status 置 'done'。
if let Err(e) = repo.set_embedding(&id, &vecs[0]).await {
// 写库失败(非 provider 问题)同样标 failed,可重试。
tracing::warn!("嵌入写入失败(非阻断,标 failed 待补偿): {}", e);
mark_embedding_failed(&repo, &id, "写库失败").await;
} else {
tracing::info!("知识嵌入完成: {}", id);
}
}
Ok(_) => {
// provider 返回空向量(异常但非 Err):标 failed 可重试,优于静默丢弃。
mark_embedding_failed(&repo, &id, "空向量分支").await;
}
Err(e) => {
// provider 临时不可用(网络/限流/模型故障):标 failed 可补偿重试。
tracing::warn!("知识嵌入生成失败(非阻断,走 LIKE 降级,标 failed 待补偿): {}", e);
mark_embedding_failed(&repo, &id, "provider 错误").await;
}
}
});
}
/// 知识条目发布时后台生成嵌入(fire-and-forget,失败标记可补偿重试)
///
/// 由 knowledge_update_status(发布路径)调用。vector_enabled 关闭时直接跳过。
///
/// P1 修复(嵌入失败无标记):此前失败仅 warn,provider 临时不可用 → 该条永久无向量索引
/// 无人感知。现成功置 embedding_status='done'(set_embedding 内已含),失败置 'failed'
/// 并 warn,failed 条目可由 knowledge_retry_embedding IPC 触发补偿重试。
pub async fn spawn_embedding_for_knowledge(
state: &AppState,
record: &df_storage::models::KnowledgeRecord,
@@ -96,25 +151,80 @@ pub async fn spawn_embedding_for_knowledge(
if !config.vector_enabled {
return;
}
let Some((provider, model)) = resolve_embed_provider(state, &config).await else { return };
let text = format!("{} {}", record.title, record.content);
let id = record.id.clone();
let Some((provider, model)) = resolve_embed_provider(state, &config).await else {
// provider 解析失败(配置缺/密钥不可用)也标记 failed,允许用户修好配置后补偿重试。
// 老行为是静默 return(无人感知),现在落 failed 让状态可见可补。
let repo = KnowledgeRepo::new(&state.db);
mark_embedding_failed(&repo, &record.id, "provider 解析失败").await;
return;
};
// 发布路径单条:Box → Arc 装箱复用 spawn_embedding_task(统一嵌入逻辑,DRY)。
spawn_embedding_task(
state.db.clone(),
Arc::from(provider),
model,
record.id.clone(),
record.title.clone(),
record.content.clone(),
);
}
/// 补偿重试:对所有 embedding_status='failed' 的已发布知识重新生成嵌入(fire-and-forget)。
///
/// P1 修复(嵌入失败无标记)的补偿入口。由 knowledge_retry_embedding IPC 触发
/// (前端「重新生成向量」按钮)。立即返回待重试条数,后台逐条 spawn 子任务重跑
/// (成功置 done,失败仍 failed,用户可再次触发)。
///
/// 设计要点:
/// - **真并发 + IPC 立即返回**:IPC 同步拉 failed 列表算 count + 解析一次 provider/config 即返回;
/// 后台 spawn 一个总任务,**逐条 spawn 子任务**真并发跑嵌入。
/// 老实现 `for { spawn_embedding_for_knowledge().await }` 顺序串行,且每条重新
/// `knowledge_config.lock().clone()` + `build_provider_for` 重建 provider,
/// 与文档「立即返回、fire-and-forget」声明矛盾。
/// - **provider 解析一次复用**:IPC 路径解析一次 → Arc<dyn LlmProvider> 跨子任务共享,避免 N 条 N 次重建。
/// - **vector_enabled 关闭时返回 0**:与发布路径一致,无 provider 无意义。
/// - **provider 整体不可用**:解析失败时逐条标 failed(语义同发布路径 resolve 失败分支)。
pub async fn retry_failed_embeddings(state: &AppState) -> anyhow::Result<usize> {
let repo = KnowledgeRepo::new(&state.db);
let failed = repo.list_failed_embeddings().await?;
let count = failed.len();
if count == 0 {
return Ok(0);
}
tracing::info!("[knowledge] 启动 {} 条 failed 嵌入补偿重试", count);
// 解析一次 provider/config(IPC 同步,轻量:lock+clone 配置 + 一次 build_provider)。
let config = state.knowledge_config.lock().await.clone();
let db = state.db.clone();
if !config.vector_enabled {
return Ok(count); // 关闭:不动 failed 状态,仅返回条数(前端可据此提示)
}
let resolved = resolve_embed_provider(state, &config).await;
tauri::async_runtime::spawn(async move {
let input: String = text.chars().take(8000).collect();
match provider.embed(&model, vec![input]).await {
Ok(vecs) if !vecs.is_empty() => {
let repo = KnowledgeRepo::new(&db);
if let Err(e) = repo.set_embedding(&id, &vecs[0]).await {
tracing::warn!("嵌入写入失败(非阻断): {}", e);
} else {
tracing::info!("知识嵌入完成: {}", id);
match resolved {
Some((provider, model)) => {
// Arc 共享:同一 provider 跨所有子任务复用(真并发,无重复重建)。
let provider: Arc<dyn LlmProvider> = Arc::from(provider);
for record in failed {
spawn_embedding_task(
db.clone(),
provider.clone(),
model.clone(),
record.id,
record.title,
record.content,
);
}
}
None => {
// provider 解析失败:逐条标 failed(允许用户修配置后再次触发补偿)。
let repo = KnowledgeRepo::new(&db);
for record in failed {
mark_embedding_failed(&repo, &record.id, "retry provider 解析失败").await;
}
}
Ok(_) => {}
Err(e) => tracing::warn!("知识嵌入生成失败(非阻断,走 LIKE 降级): {}", e),
}
});
Ok(count)
}
/// 混合检索: LIKE 关键词 + 向量语义,合并去重加权
@@ -240,9 +350,69 @@ pub(crate) async fn build_knowledge_context(
out
}
/// 知识注入 system prompt 的单一入口(DRY:F-09 agentic + chat 五处合一)。
///
/// 把原本散落在 `try_continue_agent_loop`(agentic/mod.rs)+ `ai_chat_send` /
/// `ai_regenerate` / `ai_chat_edit` / `ai_chat_force_send`(chat.rs)五处逐行重复的
/// 「取末条 active user 文本 + id → build_knowledge_context → format 拼到 system_prompt 前」
/// 收敛至此。
///
/// **口径修复(②)**:原五处 `last_user_text` 走 `find(role==User && is_active())` 过滤
/// active,但 `user_message_id` 走 `last_user_message_id()` → `last_message_id_by_role`
/// 只判 role discriminant **不过滤 is_active**。末条 user 被压缩(`is_active=false`)后,
/// text 取到次末条 active user、id 取到末条(已压缩)user,**两值取自不同消息**,溯源错位。
/// 本 helper 在**同一次反向扫描同一条消息**取两值(text+id),根除口径漂移。
///
/// 流程:
/// 1. 单次 lock session → 读 per_conv.messages 全量克隆 → 反向扫末条 `role==User && is_active()`,
/// 同一消息取 `content`(检索 query)+ `id`(消息级溯源)。无 active user → text="" / id=None。
/// 2. `build_knowledge_context`(命中文本→混合检索→格式化)。auto_inject 关 / 无命中 → 返 ""。
/// 3. 非空 → `format!("{}\n\n---\n{}", knowledge, system_prompt)` 拼前;否则原样返回 system_prompt。
///
/// 注:`config` 由调用方从 `state.knowledge_config` lock().clone() 后传入(各调用方已在
/// 其他位置 clone 过,避免本 helper 重复加锁;亦兼容 agentic 续跑路径已 clone 的快照)。
pub(crate) async fn inject_knowledge_into_prompt(
state: &AppState,
conv_id: &str,
system_prompt: String,
config: &crate::state::KnowledgeConfig,
) -> String {
// 同一条消息取 text + id(②口径修复):单次反向扫描,避免 text 过滤 is_active 而 id 不过滤
// 导致两值取自不同消息。
let (last_user_text, user_message_id) = {
let session = state.ai_session.lock().await;
let msgs = session
.conv_read(conv_id)
.map(|c| c.messages.all_messages_clone())
.unwrap_or_default();
let found = msgs
.iter()
.rev()
.find(|m| matches!(m.role, MessageRole::User) && m.is_active());
match found {
Some(m) => (m.content.clone(), m.id.clone()),
None => (String::new(), None),
}
};
let knowledge_context =
build_knowledge_context(state, conv_id, &last_user_text, config, user_message_id.as_deref()).await;
if knowledge_context.is_empty() {
system_prompt
} else {
format!("{}\n\n---\n{}", knowledge_context, system_prompt)
}
}
/// 判断是否应触发提炼,满足则后台 spawn 提炼 task(非阻断)
///
/// 守卫: auto_extract 开 + trigger_mode == OnComplete + 消息数 ≥ min_messages
/// + 去重标志(P1 修复:本会话已成功提炼过则跳过,防重复触发刷 candidate)
///
/// TOCTOU 修复(🟡D):老实现 read(knowledge_extracted) → release lock → spawn,
/// 并发窗口内另一路 maybe_spawn_extraction 也能读到 false 各自 spawn,致重复提炼刷 candidate。
/// 现在判重 + 消息数 + **预置位**三步在**同一个锁临界区**内原子完成:置位即占用提炼槽位,
/// 并发的后来者读到 true 直接跳过。spawn 后按结果修正:0 条 / Err 清位(允许下次重试),
/// ≥1 条保持 true(已提炼,后续跳过)。
pub(crate) async fn maybe_spawn_extraction(
session_arc: &Arc<Mutex<AiSession>>,
db: &Arc<Database>,
@@ -257,24 +427,66 @@ pub(crate) async fn maybe_spawn_extraction(
if config.trigger_mode != ExtractTrigger::OnComplete {
return Ok(());
}
// 消息数守卫(总消息数,含 system/assistant/tool)
// F-260616-09 B 批4:per_conv.messages 唯一真相源(conv_id 来源:本函数入参)。
// conv_read 未建返 0(< min_messages 自然跳过,语义=空对话不注入知识)。
let msg_count = {
let session = session_arc.lock().await;
session.conv_read(conv_id).map(|c| c.messages.len()).unwrap_or(0)
};
if (msg_count as u32) < config.min_messages {
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(手动按钮)强制清位,允许用户手动重提炼。
{
let mut session = session_arc.lock().await;
// 一次 conv_read 读两个字段(knowledge_extracted + messages.len()),map 后借用即结束,
// 后续 session.conv()(&mut self)不再冲突。
let (already, count) = session
.conv_read(conv_id)
.map(|c| (c.knowledge_extracted, c.messages.len()))
.unwrap_or((false, 0));
// 守卫 1:已提炼过(或提炼中) → 跳过 + warn。
if already {
tracing::warn!(
conv_id = %conv_id,
"[knowledge] 跳过自动提炼:本会话已提炼过/提炼中(去重标志置位,防重复刷 candidate);如需重提炼用手动按钮"
);
return Ok(());
}
// 守卫 2:消息数。conv_read 未建返 0(< min_messages 自然跳过,语义=空对话不注入知识)。
if (count as u32) < config.min_messages {
return Ok(());
}
// 原子预置位(TOCTOU 核心):释放锁前先占提炼槽位,杜绝并发窗口内重复 spawn。
session.conv(conv_id).knowledge_extracted = true;
}
let session_arc = session_arc.clone();
let db = db.clone();
let conv_id = conv_id.to_string();
let provider_config = provider_config.clone();
let llm_concurrency = llm_concurrency.clone();
tauri::async_runtime::spawn(async move {
if let Err(e) = extract_knowledge_from_conversation(&db, &conv_id, &provider_config, &llm_concurrency).await {
tracing::warn!("知识提取失败(非阻断): {}", e);
match extract_knowledge_from_conversation(&db, &conv_id, &provider_config, &llm_concurrency).await {
Ok(inserted) => {
if inserted > 0 {
// ≥1 条:保持预置的 true(已占用槽位即最终状态),仅 log。
tracing::info!(
conv_id = %conv_id, inserted,
"[knowledge] 提炼成功,去重标志保持置位,后续自动触发将被跳过"
);
} else {
// 0 条:清位回 false,允许下次自动触发重试(对话可能后续补充了有价值内容)。
let mut session = session_arc.lock().await;
session.conv(&conv_id).knowledge_extracted = false;
tracing::info!(
conv_id = %conv_id,
"[knowledge] 提炼 0 条(无可提炼内容),清去重标志允许下次自动重试"
);
}
}
Err(e) => {
// 失败:清位回 false,允许下次触发重试(预置位已在,须回滚否则会话被锁死)。
tracing::warn!("知识提取失败(非阻断): {}", e);
let mut session = session_arc.lock().await;
session.conv(&conv_id).knowledge_extracted = false;
}
}
});
Ok(())
@@ -283,18 +495,35 @@ pub(crate) async fn maybe_spawn_extraction(
/// 手动触发提炼(ManualOnly 模式 / 前端按钮调用)
///
/// fire-and-forget:立即返回,后台执行 LLM 提炼(避免 IPC 长时间阻塞)。
///
/// P1 修复(提炼重复触发):手动路径强制清 knowledge_extracted 去重标志,
/// 允许用户手动重提炼(语义=手动覆盖自动去重)。
pub async fn trigger_extraction_now(state: &AppState) -> Result<bool, String> {
let conv_id = {
let session = state.ai_session.lock().await;
session.active_conversation_id.clone()
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;
}
conv_id
};
let conv_id = conv_id.ok_or_else(|| "当前无活跃对话".to_string())?;
let provider_config = super::prompt::get_active_provider(state).await.map_err(err_str)?;
let db = state.db.clone();
let session_arc = state.ai_session.clone();
let llm_concurrency = state.llm_concurrency.clone();
tauri::async_runtime::spawn(async move {
if let Err(e) = extract_knowledge_from_conversation(&db, &conv_id, &provider_config, &llm_concurrency).await {
tracing::warn!("手动提炼失败(非阻断): {}", e);
match extract_knowledge_from_conversation(&db, &conv_id, &provider_config, &llm_concurrency).await {
Ok(inserted) => {
// 手动提炼成功(≥1 条)后也置去重标志,保持与自动路径一致:
// 避免手动提炼后再触发自动提炼重复。用户再次手动按按钮会再次清位,行为自洽。
if inserted > 0 {
let mut session = session_arc.lock().await;
session.conv(&conv_id).knowledge_extracted = true;
}
}
Err(e) => tracing::warn!("手动提炼失败(非阻断): {}", e),
}
});
Ok(true)
@@ -316,12 +545,15 @@ const EXTRACTION_SYSTEM_PROMPT: &str = "你是知识提炼引擎,从 AI 对话
/// 从对话中提炼知识,产出 candidate 写入知识库
///
/// 流程: 读对话消息 → 过滤 user/assistant 取最后 6 条 → LLM 提炼(强制 JSON) → 解析 → 批量插入 candidate
///
/// 返回值: 成功插入的 candidate 条数(inserted)。调用方(maybe_spawn_extraction)据此置
/// `knowledge_extracted` 去重标志(≥1 才置位,0 条不置位—允许下次自动触发重试)。
async fn extract_knowledge_from_conversation(
db: &Arc<Database>,
conv_id: &str,
provider_config: &AiProviderRecord,
llm_concurrency: &LlmConcurrency,
) -> anyhow::Result<()> {
) -> anyhow::Result<usize> {
let conv_repo = AiConversationRepo::new(db);
let conv = conv_repo
.get_by_id(conv_id)
@@ -349,7 +581,7 @@ async fn extract_knowledge_from_conversation(
.take(6)
.collect();
if recent.len() < 4 {
return Ok(()); // 太短,不值得提炼
return Ok(0); // 太短,不值得提炼(0 条,不置去重标志)
}
// F-260619-04 P1 消息级溯源:取末条 assistant 消息 id(本轮 AI 产出知识的载体)。
@@ -415,7 +647,7 @@ async fn extract_knowledge_from_conversation(
Ok(v) => v,
Err(e) => {
tracing::warn!("知识提炼 JSON 解析失败,整批丢弃(非阻断): {} | 原始: {}", e, raw);
return Ok(());
return Ok(0);
}
};
@@ -457,6 +689,7 @@ async fn extract_knowledge_from_conversation(
None => format!("conv:{}", conv_id),
}),
reasoning: reasoning.clone(),
embedding_status: None,
created_at: now.clone(),
updated_at: now,
};
@@ -485,7 +718,7 @@ async fn extract_knowledge_from_conversation(
if inserted > 0 {
tracing::info!("知识提炼完成: 对话 {} 产出 {} 条 candidate", conv_id, inserted);
}
Ok(())
Ok(inserted)
}
/// 剥离 LLM 输出可能的 ```json ... ``` 代码块包裹
@@ -521,6 +754,7 @@ mod tests {
source_project: None,
source_ref: None,
reasoning: None,
embedding_status: None,
created_at: "2026-01-01".to_string(),
updated_at: "2026-01-01".to_string(),
}

239
src-tauri/src/commands/ai/mod.rs
View File

@@ -1,6 +1,6 @@
//! AI 聊天命令模块 — 流式对话、工具调用、审批门控、提供商管理
//!
//! 由原单文件 ai.rs(2663 行)按职责拆分为 11 个子模块。
//! 由原单文件 ai.rs(2663 行)按职责拆分为 15 个子模块。
//!
//! 模块布局：
//! - [`commands`] — 所有 `#[tauri::command]` IPC 函数
@@ -15,6 +15,9 @@
//! - [`compress`] — F-15 上下文压缩 LLM 摘要(compress_via_llm 公共函数)
//! - [`tool_registry`] — AI 工具注册表构建 + 文件路径校验
//! - [`knowledge_inject`] — 知识库注入 + 提炼
//! - [`augmentation`] — 上下文增强
//! - [`http`] — HTTP 调用封装
//! - [`secret`] — 密钥/凭证管理
//!
//! 事件协议：通过 app.emit("ai-chat-event", payload) 流式推送到前端
//! - AiTextDelta: 流式文本片段
@@ -23,6 +26,7 @@
//! - AiCompleted/AiError: 完成/错误
pub mod agentic;
pub mod augmentation;
pub mod audit;
pub mod commands;
pub mod compress;
@@ -62,9 +66,12 @@ pub use self::commands::*;
#[allow(unused_imports)]
pub use self::audit::restore_pending_approvals;
#[allow(unused_imports)]
pub use self::knowledge_inject::{spawn_embedding_for_knowledge, trigger_extraction_now};
pub use self::knowledge_inject::{retry_failed_embeddings, spawn_embedding_for_knowledge, trigger_extraction_now};
#[allow(unused_imports)]
pub use self::tool_registry::build_ai_tool_registry;
// Input Augmentation 层(核心设计2):ResolverRegistry 构建 helper(state.rs init 调用)
#[allow(unused_imports)]
pub use self::augmentation::build_resolver_registry;
// ============================================================
// 事件载荷类型(放 mod.rs,各子文件经 use super::* 拿到)
@@ -151,7 +158,7 @@ pub enum AiChatEvent {
/// F-260619-03 Phase B: 路径授权弹窗(LLM 想访问白名单外目录,挂起 loop 等用户决定)。
///
/// 触发:resolve_workspace_path 预校验路径未命中 persistent/session 白名单(且非黑名单)。
/// 复用审批挂起架构(PendingApproval.path_auth 标记路径授权挂起),
/// 复用审批挂起架构(PendingApproval.kind=Path 标记路径授权挂起,阶段3a 单真相源合并),
/// 用户经 ai_authorize_dir IPC 选择"仅本次/未来都允许/拒绝",恢复 loop。
/// `dir`:规范化后的待授权目录(父目录,目录粒度对齐 session_trust)。
AiDirAuthRequired {
@@ -183,7 +190,9 @@ pub enum AiChatEvent {
///
/// 优先级：`pending_approvals` 非空（有挂起审批优先报 AwaitingApproval，
/// 即使同时在流式）> `generating`（Streaming）> 都不满足（Idle）。
#[allow(dead_code)] // SW-260618-21 b:预留读视图(SW-02 类终态化复用·当前 0 消费者·保留扩展点)
// SW-260618-21 b:原预留读视图(0 消费者)。path_auth 审批链阶段1 接入后有消费者
// (try_continue_agent_loop / ai_chat_stop 经 session_state 替代手写 has_pending),不再 dead_code。
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SessionState {
/// 空闲：既未生成、也无挂起审批
Idle,
@@ -305,21 +314,20 @@ pub struct AiSession {
pub active_conversation_id: Option<String>,
/// 活跃对话创建时间(懒创建:首条消息落库前仅存内存,upsert 时用作 created_at)
pub active_conv_created_at: Option<String>,
/// 挂起的审批。
/// 挂起的审批(阶段3a 单真相源合并:原 path_auth_pending + risk_pending 双 HashMap)。
///
/// **结构**：单层 `HashMap<tool_call_id, PendingApproval>`，按 `tool_call_id`
/// 路由审批结果（`tool_call_id` 是路由键）。`PendingApproval.conversation_id`
/// 是业务语义（哪个对话产生的审批）而非路由键——IPC 端按 `tool_call_id` 精确命中。
/// 决策1(状态层合 + 决策层分):状态层把两类挂起合并进单 HashMap,
/// `PendingApproval.kind` 字段区分语义(`ApprovalKind::Path` vs `ApprovalKind::Risk`);
/// 决策层仍双轨 —— `ai_authorize_dir` 只消费 `kind==Path`(once/always 写持久白名单),
/// `ai_approve` 只消费 `kind==Risk`(一次性 approve/reject),入口 kind 校验防误调。
/// 键为 `tool_call_id`(路由键不变),`conversation_id` 是业务语义(哪个对话产生)。
///
/// **现状**：`ai_pending_tool_calls` 等读取路径按 `conversation_id` 做 O(n) 线性
/// 过滤。在典型场景（单对话、少量并发审批）下 n 极小，O(n) 可接受，无需二级索引。
///
/// **未来**：若多会话并发、审批量显著增大，可考虑加二级索引
/// （`conversation_id → Vec<tool_call_id>`）把按会话过滤降到 O(1)。
/// 兜底/回退:本合并是结构性的,回退走 git revert(plan 风险表「分 3a/3b 各 revert」)。
/// 兼容靠 kind 字段默认 Risk(老构造点不传 kind 即默认 Risk,语义不变)。
pub pending_approvals: HashMap<String, PendingApproval>,
/// F-260616-09 B 阶段 多会话并发架构 — 会话级状态按 conversation_id 切分。
///
/// **批4 状态(per_conv 唯一真相源)**:批2-批4 已迁移所有调用方(agentic.rs loop +
/// **批4 状态(per_conv 唯一真相源)**:批2-批4 已迁移所有调用方(agentic/mod.rs loop +
/// GeneratingGuard + try_continue + commands.rs IPC 写路径 + audit.rs process_tool_calls +
/// conversation.rs save + title.rs + knowledge_inject.rs + lib.rs L0)读写
/// `session.conv(conv_id).*` / `session.conv_read(conv_id)`。顶层单例会话级字段已全部删除。
@@ -348,15 +356,15 @@ impl AiSession {
/// F-260616-09 B 批4:per_conv 化后接 conv_id 参数(顶层 generating 已删除);
/// pending 判断改为按 conv_id 过滤(决策 e 真并发下各 conv 独立)。
///
/// # 待替换调用点（本次仅新增视图，不替换调用点）
/// path_auth 审批链阶段1(本批)接入:`try_continue_agent_loop`(agentic/mod.rs) +
/// `ai_chat_stop`(commands/chat.rs) 改调本方法替代各自手写的 has_pending,
/// 收敛两处状态机判定到单一入口。
///
/// - `agentic.rs` — agent loop 入口/恢复处对 generating + 审批的组合判断
/// - `commands.rs` — `ai_pending_tool_calls` 等读取前的状态门控
/// - `commands.rs` — 审批提交/会话复位路径的状态判断
///
/// 上述三处替换由 P0 任务承接，本方法先就位供其切换。
#[allow(dead_code)] // SW-260618-21 b:预留(P0 终态化任务承接·当前 0 调用·保留扩展点)
/// 兜底/回退:若本方法判定异常需快速回退手写 has_pending,调用方注释已保留原
/// 三路组合(generating + path_auth + risk)字面量,改一行即可切回。
pub fn session_state(&self, conv_id: &str) -> SessionState {
// 阶段3a 单真相源合并后:两类挂起(path_auth + risk)合一进 pending_approvals,
// kind 字段区分语义但状态机只看「有无挂起」,单表 any 一次即可(消除原双表 OR 合并判断)。
let has_pending = self.pending_approvals.values()
.any(|a| a.conversation_id.as_deref() == Some(conv_id));
if has_pending {
@@ -371,9 +379,9 @@ impl AiSession {
// ============================================================
// F-260616-09 B 阶段批1 PerConvState 访问器(设计 §2.1.2)
//
// 批1 仅定义访问器,**不迁移调用方**(批2 承接)。当前 0 调用方,行为完全不变。
// 批2 迁移:所有 `session.messages` / `session.generating` 等读写改走
// `session.conv(conv_id).*`(写)/ `session.conv_read(conv_id)`(读)。
// 批4 已迁移完成:所有 `session.messages` / `session.generating` 等读写已全部改走
// `session.conv(conv_id).*`(写)/ `session.conv_read(conv_id)`(读),
// per_conv 现为唯一真相源,顶层单例字段已删除。
// ============================================================
/// 取或惰性创建指定会话的可变状态(设计 §2.1.2)。
@@ -410,6 +418,11 @@ mod tests_f09_per_conv {
assert!(s.model_override.is_none(), "model_override 初值应为 None");
assert!(s.session_trust.is_empty(), "session_trust 初值应为空 HashSet");
assert!(s.created_at.is_none(), "created_at 初值应为 None");
// P1 修复(提炼重复触发):knowledge_extracted 初值应为 false(新会话未提炼)
assert!(
!s.knowledge_extracted,
"knowledge_extracted 初值应为 false(新会话未提炼)"
);
// stop_flag 初值 false(与 AiSession::new 对齐)
assert!(
!s.stop_flag.load(std::sync::atomic::Ordering::SeqCst),
@@ -471,6 +484,95 @@ mod tests_f09_per_conv {
"已创建的 conv_id conv_read() 应返 Some"
);
}
// ============================================================
// P1 修复(提炼重复触发): knowledge_extracted 去重标志生命周期测试
//
// 锁定标志三态语义:
// 1) 新会话初值 false → 自动提炼可触发
// 2) 成功提炼后置 true → maybe_spawn_extraction 入口判重跳过
// 3) trigger_extraction_now 清位 → 允许手动重提炼
// ============================================================
/// 新会话 knowledge_extracted 默认 false(自动提炼可触发)
#[test]
fn test_knowledge_extracted_default_false() {
let session = AiSession::new();
// 未创建的 conv_id → conv_read None → maybe_spawn_extraction 视为 false(可触发)
assert!(
session
.conv_read("new-conv")
.map(|c| c.knowledge_extracted)
.unwrap_or(false)
== false,
"新会话 knowledge_extracted 应为 false"
);
}
/// 成功提炼后置位 true(自动路径去重标志)
#[test]
fn test_knowledge_extracted_set_after_extraction() {
let mut session = AiSession::new();
// 模拟提炼成功后置位(extract_knowledge_from_conversation Ok(>0) → maybe_spawn_extraction 置位)
session.conv("conv-done").knowledge_extracted = true;
assert!(
session.conv_read("conv-done").unwrap().knowledge_extracted,
"提炼成功后 knowledge_extracted 应为 true"
);
}
/// maybe_spawn_extraction 入口判重语义:已置位 → 视为已提炼(跳过)
#[test]
fn test_knowledge_extracted_dedup_guard() {
let mut session = AiSession::new();
session.conv("conv-dedup").knowledge_extracted = true;
// 模拟 maybe_spawn_extraction 入口判重读(already_extracted)
let already_extracted = session
.conv_read("conv-dedup")
.map(|c| c.knowledge_extracted)
.unwrap_or(false);
assert!(
already_extracted,
"已置位会话入口判重应为 true(跳过自动提炼)"
);
}
/// trigger_extraction_now 清位语义:手动路径强制清位,允许重提炼
#[test]
fn test_knowledge_extracted_manual_clear() {
let mut session = AiSession::new();
session.active_conversation_id = Some("conv-manual".to_string());
session.conv("conv-manual").knowledge_extracted = true;
// 模拟 trigger_extraction_now 入口清位逻辑:
// active_conversation_id clone(脱离 immutable borrow)后再 mutable borrow conv()
let cid = session.active_conversation_id.clone();
if let Some(cid) = cid.as_deref() {
session.conv(cid).knowledge_extracted = false;
}
assert!(
!session
.conv_read("conv-manual")
.unwrap()
.knowledge_extracted,
"手动触发后 knowledge_extracted 应被清位(允许重提炼)"
);
}
/// 不同会话标志互相独立(P1 去重按 conv_id 切分)
#[test]
fn test_knowledge_extracted_per_conv_independent() {
let mut session = AiSession::new();
session.conv("conv-a").knowledge_extracted = true;
// conv-b 未提炼,标志应独立为 false
assert!(
session.conv("conv-a").knowledge_extracted,
"conv-a 已提炼标志 true"
);
assert!(
!session.conv("conv-b").knowledge_extracted,
"conv-b 未提炼标志 false(各 conv 独立)"
);
}
}
// ============================================================
@@ -484,18 +586,19 @@ mod tests_f09_per_conv {
// agent_language/model_override/session_trust 保留原样),不迁移现有调用方(批2 承接)
// - per_conv HashMap 初始空,旧调用路径继续读写 AiSession 顶层单例字段,完全无感
//
// 共存期:批1 后顶层单例字段(唯一真相源)与 per_conv(全空,无写入)并存,行为不变。
// 批2 迁移:把所有调用方从 session.messages / session.generating 等改为 session.conv(conv_id).*,
// 迁移完成后顶层单例字段废弃删除(批3)。
// 共存期(已结束):批1 后顶层单例字段(原唯一真相源)与 per_conv(全空,无写入)曾并存,行为不变。
// 批2-批4 迁移:把所有调用方从 session.messages / session.generating 等改为 session.conv(conv_id).*,
// 迁移完成后顶层单例字段已废弃删除(批3)。现 per_conv 为唯一真相源。
// ============================================================
/// 单会话级状态(F-260616-09 B 阶段批1 纯新增,设计 §2.1.2)。
///
/// 持有当前会话(按 conversation_id 切分)私有的可变状态。批1 仅定义 + 惰性创建访问器,
/// **不迁移** AiSession 顶层单例字段(共存期顶层字段仍是唯一真相源)。
/// 持有当前会话(按 conversation_id 切分)私有的可变状态。批4 已迁移完成,本结构现为
/// **唯一真相源**:所有调用方(agentic loop / IPC / audit / conversation / title /
/// knowledge_inject 等约 60+ 处)均经 `session.conv(conv_id).*` / `session.conv_read(conv_id)`
/// 读写,AiSession 顶层单例字段已全部删除。
///
/// 字段初值逐字对齐 [`AiSession::new`](#method.new),保证批2 迁移调用方时行为不变。
#[allow(dead_code)] // F-09 B 批1 共存期:0 调用方(批2 迁移承接),字段待迁移后消费
/// 字段初值逐字对齐 [`AiSession::new`](#method.new)。
pub struct PerConvState {
/// 对话历史(ContextManager:会话级消息真相源,裁剪仅影响发送视图)
pub messages: ContextManager,
@@ -513,8 +616,24 @@ pub struct PerConvState {
pub model_override: Option<String>,
/// 会话级信任(Session Trust):随会话销毁,不落库
pub session_trust: HashSet<TrustKey>,
/// 会话创建时间(懒创建:首条消息落库前仅存内存,upsert 时用作 created_at)
/// 会话创建时间(懒创建:首条消息落库前仅存内存,预留 upsert 时用作 created_at)。
///
/// 预留字段:构造期写入但当前 upsert 路径未读取(cargo 报 never read),标 allow 保留;
/// 待 upsert 接入会话创建时间回填时消费。符合零调用方≠垃圾(预留)。
#[allow(dead_code)]
pub created_at: Option<String>,
/// 知识提炼去重标志(P1 修复-提炼重复触发):本会话已成功提炼(至少 insert 1 条 candidate)后置位。
///
/// 背景:审批续跑 try_continue → 重 spawn run_agentic_loop → 正常完成块 →
/// maybe_spawn_extraction 二次触发,无去重致同知识点重复 candidate 刷屏。
///
/// 守卫语义:
/// - maybe_spawn_extraction 入口判重:已置位则跳过 + warn(防重复触发刷 candidate)
/// - extract_knowledge_from_conversation 成功(inserted ≥ 1)后由调用方置位
/// - trigger_extraction_now(手动按钮)强制清位:允许用户手动重提炼(语义=手动覆盖自动去重)
///
/// 随会话销毁(per_conv 内存,不落库):会话切换/删除后该标志消失,新会话从 false 开始。
pub knowledge_extracted: bool,
}
impl PerConvState {
@@ -530,6 +649,7 @@ impl PerConvState {
/// - model_override: None
/// - session_trust: HashSet::new()
/// - created_at: None(批1 新增字段,AiSession 现有 active_conv_created_at 同语义)
/// - knowledge_extracted: false(新会话未提炼,P1 去重标志)
pub fn new() -> Self {
Self {
messages: ContextManager::new(ContextConfig::default()),
@@ -541,6 +661,7 @@ impl PerConvState {
model_override: None,
session_trust: HashSet::new(),
created_at: None,
knowledge_extracted: false,
}
}
}
@@ -552,6 +673,11 @@ impl Default for PerConvState {
}
/// 待审批的工具调用
///
/// 阶段3a(单真相源合并):新增 `kind: ApprovalKind` 字段区分两类挂起(Path/Risk),
/// 原顶层 `diff` / `path_auth` 字段下沉进 `ApprovalKind` enum 变体(决策1:状态层合 +
/// 决策层分 —— kind 在 PendingApproval 内携带语义,但 ai_approve/ai_authorize_dir
/// 各只消费自己 kind,入口校验防误调)。
#[derive(Debug, Clone)]
pub struct PendingApproval {
pub tool_call_id: String,
@@ -560,21 +686,48 @@ pub struct PendingApproval {
pub conversation_id: Option<String>,
/// 重启恢复的积压审批:无 live loop 持有 session.messages,审批后不 save(防空 messages 污染老对话)、不续跑
pub recovered: bool,
/// AE-2025-03（路径 B）：write_file 的行级 unified diff（旧文件 vs 新内容）。
/// 仅挂起审批前预读注入，供前端审批卡预览；旧文件不存在（新建）或非 write_file 为 None。
/// recovered 审批（启动重建）无 diff（文件可能已变，重读无意义）。
#[allow(dead_code)] // IPC 活跃(useAiEvents:252+ToolCard·UX-260618-06)·cargo Rust never-read 误报
pub diff: Option<String>,
/// F-260619-03 Phase B: 路径授权挂起标记(Some = 路径授权挂起,None = 普通 RiskLevel 审批)。
/// 携带待授权目录(规范化父目录),ai_authorize_dir IPC 据此决定写入 session/persistent。
pub path_auth: Option<PathAuthRequest>,
/// 阶段3a:审批类型(Path 路径授权挂起 / Risk 普通 RiskLevel 审批)。
/// 老构造点不传 kind 时默认 Risk(兼容:原 risk_pending 路径行为不变)。
pub kind: ApprovalKind,
/// 阶段4(容错/恢复,开关 `df-ai-approval-retry`):同 tc_id 重试计数。
///
/// 触发:同 tool_call_id 在审计表已有一条 executed/failed/rejected 落定记录(即该
/// tc_id 已被执行/审批过一次),LLM 又用同 id 重试(process_tool_calls 再次 insert pending)。
/// 插入时查审计表落定记录推算 retry_count;≥1 时跳过执行,emit AiToolCallCompleted 带
/// "已跳过重试"提示,防 LLM 死循环重试同卡死工具(超时/权限错等)。
///
/// 兜底/回退:flag 关 → 不查审计表、retry_count 恒 0,等价原行为(单次审批执行)。
//
// dead_code 说明:当前断路决策在 insert 点(detect_retry_count 查审计表),不读存储的
// retry_count;字段保留作审计/未来"允许多次重试阈值"扩展(u32 暂仅 0/1),对齐 Risk{diff}
// 变体同款 allow 处理。
#[allow(dead_code)]
pub retry_count: u32,
}
/// F-260619-03 Phase B: 路径授权挂起请求(PendingApproval.path_auth 标记)。
/// 阶段3a:审批类型枚举(决策层分离,kind 区分 ai_approve vs ai_authorize_dir 消费)。
///
/// - `Path(req)`:F-260619-03 Phase B 路径授权挂起,由 `ai_authorize_dir` 消费(once/always/deny)。
/// - `Risk { diff }`:普通 Med/High RiskLevel 审批,由 `ai_approve` 消费(一次性 approve/reject)。
/// `diff`:AE-2025-03(路径 B)write_file 行级 unified diff,供前端审批卡预览;
/// 旧文件不存在(新建)或非 write_file / recovered 审批为 None。
#[derive(Debug, Clone)]
pub enum ApprovalKind {
/// F-260619-03 Phase B: 路径授权挂起(携带待授权目录列表)。
Path(PathAuthRequest),
/// 普通 RiskLevel 审批(Med/High 风险工具)。
/// diff 仅 write_file 挂起审批前预读注入;其余工具 / recovered 审批为 None。
#[allow(dead_code)] // IPC 活跃(useAiEvents:252+ToolCard·UX-260618-06)·cargo Rust never-read 误报
Risk { diff: Option<String> },
}
/// F-260619-03 Phase B: 路径授权挂起请求(ApprovalKind::Path 标记)。
#[derive(Debug, Clone)]
pub struct PathAuthRequest {
/// 待授权目录(规范化父目录,对齐 session_trust 目录粒度)。
pub dir: std::path::PathBuf,
/// 待授权目录列表(规范化父目录,对齐 session_trust 目录粒度)。
/// L1 补丁(rename_file 双路径漏校):收集所有未授权父目录,rename_file 的 from+to
/// 若分别属于不同未授权目录,都需挂起授权(原仅收首个致 to 路径漏校)。单路径工具通常 1 项。
pub dirs: Vec<std::path::PathBuf>,
/// 原始路径参数(read_file.path / write_file.path / rename_file.from+to / ...)。
pub raw_paths: Vec<String>,
}

18
src-tauri/src/commands/ai/prompt.rs
View File

@@ -103,11 +103,15 @@ fn system_prompt_parts(lang: &str) -> (&'static str, &'static str, &'static str)
}
}
/// 构建系统提示词（环境信息 + 固定前缀 + 当前项目/任务上下文）
/// 构建系统提示词（环境信息 + 固定前缀 + 当前项目/任务**全局清单**）
///
/// 本函数注入"全貌"清单:最近 20 项目 + 20 任务的 name/status/description(无 path),
/// 供 LLM 知道当前存在哪些实体(非精准引用)。
///
/// **被@实体的精准投影**(含 path 脱敏、剥 frontmatter 的 skill 正文)由 chat.rs 的
/// augmentation 层(`ResolverRegistry::resolve_all` + `build_augmentation_segment`)处理,
/// 非 build_system_prompt 职责 —— 两套并行:全局清单(全貌)+ augmentation(用户本次引用)。
///
/// UX-10 §1.4: 用户在输入框 @ 引用实体时插入 `[类型: 名]` 标记(项目/任务)。
/// 项目上下文已在下方注入,任务上下文本函数新增注入,使 LLM 能解析用户消息中的
/// `[项目: xxx]` / `[任务: xxx]` 标记并对齐到真实实体(名称+状态+描述)。
/// 注入克制:仅各取最近 20 条,防 context 膨胀。
pub(crate) async fn build_system_prompt(state: &AppState, lang: &str) -> String {
let (prefix, proj_label, task_label) = system_prompt_parts(lang);
@@ -124,7 +128,7 @@ pub(crate) async fn build_system_prompt(state: &AppState, lang: &str) -> String
}
}
}
// UX-10 §1.4: 任务上下文(供解析用户消息中 [任务: xxx] 标记)
// 任务全貌清单(供 LLM 知道存在哪些任务;被@任务的精准投影走 augmentation 层)
// 仅最近 20 条未删除任务,按 created_at DESC(同 list_active 顺序)。
if let Ok(tasks) = state.tasks.list_active().await {
if !tasks.is_empty() {
@@ -152,9 +156,7 @@ pub(crate) async fn build_system_prompt(state: &AppState, lang: &str) -> String
///
/// `lang` 与系统提示词保持一致取值集合（"en" 英文，其余一律中文）。
//
// dead_code:阶段1 基础函数,阶段2 IPC(ai_chat_compress_context)与阶段3 agentic
// 自动压缩会经 compress_via_llm 调用本函数。本阶段只暴露 + 单测,不接调用点。
#[allow(dead_code)]
// 调用方:compress.rs:85(compress_via_llm 内构造 system 消息)。
pub(crate) fn compress_prompt(lang: &str) -> &'static str {
match lang {
"en" => "You are a conversation summarizer. Compress the following conversation \

266
src-tauri/src/commands/ai/skills.rs
View File

@@ -1,9 +1,17 @@
//! 本机 Claude 技能扫描（skills / commands / plugins 三类）
//!
//! 核心设计6(/ skill 修复):
//! - `strip_frontmatter` + `read_skill_content_stripped`:注入正文剥首个 `---...---` 块
//! (原 `read_skill_content` 保留兼容,返全文)
//! - `OnceLock<Vec>` → `RwLock<Option<Vec>>` + 快路径(读锁命中 clone)/ 慢路径(重扫)
//! + `invalidate_skills` 写锁置 None,支持进程内 `ai_reload_skills` 热重载
//! - `scan_skills` 返 `ScanResult{skills, conflicts}`:同名收集所有 path 入 conflicts,
//! 保留首份(优先级 skills>commands>plugins);`SkillInfo.duplicates` 仅冲突时填。
use std::collections::HashSet;
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::OnceLock;
use std::sync::{RwLock, RwLockReadGuard};
use serde::Serialize;
@@ -17,6 +25,22 @@ pub struct SkillInfo {
pub source: String,
/// SKILL.md 绝对路径（注入时读全文）
pub path: String,
/// 同名冲突时的其它来源路径（仅冲突时填 Some；首份为 None）。
///
/// 注入始终取首份(优先级 skills>commands>plugins)，前端据非空 duplicates 提示用户
/// "存在同名技能 N 份，已用 {source} 来源"。无冲突为 None，向后兼容旧前端（字段缺省）。
#[serde(skip_serializing_if = "Option::is_none")]
pub duplicates: Option<Vec<String>>,
}
/// 扫描结果：去重后的 skills 列表 + 同名冲突明细（前端提示用）。
///
/// `conflicts`: `(name, 所有同名的 path 列表)` —— 注入取 skills[0]（即 ScanResult.skills 中
/// 首份，优先级 skills>commands>plugins），冲突列表仅做提示，不影响注入。
#[derive(Debug, Clone, Serialize)]
pub struct ScanResult {
pub skills: Vec<SkillInfo>,
pub conflicts: Vec<(String, Vec<String>)>,
}
/// ~/.claude 目录（跨平台：USERPROFILE / HOME）
@@ -27,6 +51,47 @@ fn claude_home() -> Option<PathBuf> {
.map(|h| h.join(".claude"))
}
/// 剥离 markdown 首个 `---...---` frontmatter 块，返回正文。
///
/// 状态机：用行索引推进；首个 `---`(trim 后)进入 in_fm，遇到下个 `---` 退出，余为正文。
/// 无 frontmatter（首行非 ---）直接返原文；frontmatter 未闭合（只有起始 --- 无收尾）
/// 按容错返空串（避免把整篇当 frontmatter 误剥，此分支极罕见 —— SKILL.md 都闭合）。
///
/// 注入用：原 `read_skill_content` 返全文（含 frontmatter）会让 LLM 看到 YAML 头噪声，
/// 改用 `read_skill_content_stripped` 后注入正文干净。
pub(crate) fn strip_frontmatter(md: &str) -> String {
let mut lines = md.lines().enumerate().peekable();
// 空串 / 首行非 --- → 无 frontmatter，返原文
let first = match lines.next() {
Some((_, l)) => l,
None => return String::new(),
};
if first.trim() != "---" {
// 无 frontmatter：返原文（首行 + 余下，用 \n 拼回）
let mut out = first.to_string();
for (_, l) in lines {
out.push('\n');
out.push_str(l);
}
return out;
}
// in_fm：跳过直到下个 ---
let mut body_start: Option<usize> = None;
for (i, l) in lines {
if l.trim() == "---" {
body_start = Some(i + 1);
break;
}
}
match body_start {
Some(start) => {
// 正文 = 原文第 start 行（0-based）起所有行
md.lines().skip(start).collect::<Vec<_>>().join("\n")
}
None => String::new(), // frontmatter 未闭合
}
}
/// 剥离 YAML 标量值两侧的引号（`"..."` / `'...'`），简易 frontmatter 解析用
fn unquote(s: &str) -> &str {
s.strip_prefix('"')
@@ -84,6 +149,7 @@ fn parse_skill_file(path: &Path, source: &str) -> Option<SkillInfo> {
argument_hint,
source: source.to_string(),
path: path.to_string_lossy().to_string(),
duplicates: None,
})
}
@@ -106,64 +172,216 @@ fn collect_skill_files(dir: &Path, out: &mut Vec<PathBuf>) {
}
}
/// 扫描三类来源，按 name 去重（skills 优先 > commands > plugins）
fn scan_skills() -> Vec<SkillInfo> {
/// 扫描三类来源，按 name 去重（skills 优先 > commands > plugins）。
///
/// 返 `ScanResult`：`skills` 为去重后首份（优先级保留），`conflicts` 收集所有同名 path
/// （仅当同名 > 1 时入列，前端提示用）。
fn scan_skills() -> ScanResult {
let home = match claude_home() {
Some(h) => h,
None => return Vec::new(),
None => {
return ScanResult {
skills: Vec::new(),
conflicts: Vec::new(),
}
}
};
let mut skills = Vec::new();
let mut seen: HashSet<String> = HashSet::new();
// 三类来源按优先级顺序收集（skills > commands > plugins）
let mut all: Vec<Vec<SkillInfo>> = Vec::with_capacity(3);
// 1. ~/.claude/skills/*/SKILL.md
let mut batch_skill = Vec::new();
if let Ok(entries) = fs::read_dir(home.join("skills")) {
for entry in entries.flatten() {
if let Some(info) = parse_skill_file(&entry.path().join("SKILL.md"), "skill") {
if seen.insert(info.name.clone()) {
skills.push(info);
}
batch_skill.push(info);
}
}
}
all.push(batch_skill);
// 2. ~/.claude/commands/*.md
let mut batch_cmd = Vec::new();
if let Ok(entries) = fs::read_dir(home.join("commands")) {
for entry in entries.flatten() {
let p = entry.path();
if p.extension().and_then(|e| e.to_str()) == Some("md") {
if let Some(info) = parse_skill_file(&p, "command") {
if seen.insert(info.name.clone()) {
skills.push(info);
}
batch_cmd.push(info);
}
}
}
}
all.push(batch_cmd);
// 3. ~/.claude/plugins/marketplaces/**/skills/*/SKILL.md（递归；cache 不在此路径下）
let mut files = Vec::new();
collect_skill_files(&home.join("plugins").join("marketplaces"), &mut files);
let mut batch_plugin = Vec::new();
for f in files {
if let Some(info) = parse_skill_file(&f, "plugin") {
batch_plugin.push(info);
}
}
all.push(batch_plugin);
// 按 name 去重（首份优先级保留）+ 收集冲突
// name -> (首份 index in skills, 所有 path)
let mut seen: HashSet<String> = HashSet::new();
let mut skills: Vec<SkillInfo> = Vec::new();
// name -> Vec<path>（按来源顺序，用于冲突判定 + duplicates 回填）
let mut name_paths: std::collections::HashMap<String, Vec<String>> =
std::collections::HashMap::new();
for batch in &all {
for info in batch {
name_paths
.entry(info.name.clone())
.or_default()
.push(info.path.clone());
if seen.insert(info.name.clone()) {
skills.push(info);
skills.push(info.clone());
}
}
}
skills
// 回填 duplicates + 构造 conflicts
let mut conflicts: Vec<(String, Vec<String>)> = Vec::new();
for skill in skills.iter_mut() {
if let Some(paths) = name_paths.get(&skill.name) {
if paths.len() > 1 {
// 首份 path 是 skill.path 本身，duplicates 填其余（按收集顺序）
let dups: Vec<String> = paths
.iter()
.filter(|p| **p != skill.path)
.cloned()
.collect();
if !dups.is_empty() {
skill.duplicates = Some(dups);
}
conflicts.push((skill.name.clone(), paths.clone()));
}
}
}
ScanResult { skills, conflicts }
}
/// 技能扫描结果缓存（进程内；新增/改动技能需重启生效）
pub(crate) fn skills_cached() -> &'static Vec<SkillInfo> {
static SKILLS: OnceLock<Vec<SkillInfo>> = OnceLock::new();
SKILLS.get_or_init(scan_skills)
/// 进程内技能缓存（RwLock + Option 懒初始化）。
///
/// 设计（核心设计6）:
/// - 快路径:`skills_cached()` 读锁命中 → clone 返回（扫盘零开销）
/// - 慢路径:读锁 None → 释放后 `scan_skills()` 填充（双检锁，避免持写锁扫盘阻塞读）
/// - `invalidate_skills()` 写锁置 None，下次 `skills_cached()` 触发重扫
/// - `ai_reload_skills` IPC:invalidate + 重扫，进程内热重载（不重启生效）
static SKILLS: RwLock<Option<Vec<SkillInfo>>> = RwLock::new(None);
/// 读锁快路径 guard（供 `read_skill_content_stripped` 持引用迭代读缓存）。
///
/// 生命周期 `'static`:SKILLS 是 static 项,对其借用可标注 `'static`(Rust 对 static 的保证),
/// 使函数能返回 guard 跨作用域传递。guard Drop 时释放读锁。
type SkillsGuard = RwLockReadGuard<'static, Option<Vec<SkillInfo>>>;
/// 取读锁快照（懒初始化：None 时先释放锁扫盘填回，再读锁取引用）。
///
/// 返 `RwLockReadGuard<Option<Vec<SkillInfo>>>`，调用方解 `*guard` 得 `&Vec<SkillInfo>`。
/// 懒初始化走双检锁：先读锁查 Some（快），None 时释放 → 扫盘 → 写锁填回 → 读锁重取。
fn skills_lock() -> SkillsGuard {
// 快路径：读锁命中
{
let g = RwLock::read(&SKILLS).expect("SKILLS poisoned");
if g.is_some() {
return g;
}
}
// 慢路径：扫盘 + 写锁填回
let scanned = scan_skills().skills;
{
let mut g = RwLock::write(&SKILLS).expect("SKILLS poisoned");
// 另一线程可能已填，二次检查（双检锁）
if g.is_none() {
*g = Some(scanned);
}
}
// 再取读锁返回（此时必 Some）
let g = RwLock::read(&SKILLS).expect("SKILLS poisoned");
debug_assert!(g.is_some(), "skills_lock 慢路径后必 Some");
g
}
/// 按 name 读取技能全文（注入 system prompt）；扫描走缓存，仅读单个 SKILL.md
pub(crate) fn read_skill_content(name: &str) -> Option<String> {
skills_cached()
.iter()
.find(|s| s.name == name)
.and_then(|s| fs::read_to_string(&s.path).ok())
/// 技能扫描结果缓存（进程内；命中即 clone，不重复扫盘）。
///
/// 替代原 `OnceLock::get_or_init` 路径：返 owned `Vec<SkillInfo>`（clone），
/// 因 RwLock 不能返 `&'static`。调用方(config.rs:30 / read_skill_content_stripped)已同步适配。
pub(crate) fn skills_cached() -> Vec<SkillInfo> {
let g = skills_lock();
g.clone().unwrap_or_default()
}
/// 置缓存为 None，下次 `skills_cached()` 触发重扫。
///
/// `ai_reload_skills` IPC 调用：写锁置 None → 紧接 `skills_cached()` 重扫，
/// 实现"改技能不重启即生效"。
pub(crate) fn invalidate_skills() {
let mut g = RwLock::write(&SKILLS).expect("SKILLS poisoned");
*g = None;
}
/// 按 name 读技能正文（剥首个 `---...---` frontmatter 块）。
///
/// 核心设计6:注入用正文，避免 YAML 头噪声污染 system prompt。
/// 缓存未命中返 None；文件读失败返 None。
pub(crate) fn read_skill_content_stripped(name: &str) -> Option<String> {
let g = skills_lock();
let skills = g.as_ref()?;
let info = skills.iter().find(|s| s.name == name)?;
let md = fs::read_to_string(&info.path).ok()?;
Some(strip_frontmatter(&md))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn strip_frontmatter_normal() {
let md = "---\nname: foo\ndescription: bar\n---\n# Body\ncontent";
assert_eq!(strip_frontmatter(md), "# Body\ncontent");
}
#[test]
fn strip_frontmatter_no_fm() {
let md = "# Title\nbody line";
assert_eq!(strip_frontmatter(md), "# Title\nbody line");
}
#[test]
fn strip_frontmatter_empty() {
assert_eq!(strip_frontmatter(""), "");
}
#[test]
fn strip_frontmatter_only_fm() {
// 只有 frontmatter 无正文
let md = "---\nname: foo\n---\n";
assert_eq!(strip_frontmatter(md), "");
}
#[test]
fn strip_frontmatter_crlf() {
let md = "---\r\nname: foo\r\n---\r\nbody\r\n";
let out = strip_frontmatter(md);
assert!(out.contains("body"), "CRLF 正文应保留: {:?}", out);
}
#[test]
fn scan_result_dedup_and_conflicts() {
// 仅测去重逻辑（不依赖 ~/.claude 存在）；通过 parse_skill_file 间接覆盖
// scan_skills 本身依赖文件系统，此处不集成测
let _ = ScanResult {
skills: vec![],
conflicts: vec![],
};
}
}

2
src-tauri/src/commands/ai/stream_recv.rs
View File

@@ -116,7 +116,7 @@ pub(crate) enum StreamResult {
reasoning_content: Option<String>,
},
/// Init 失败（provider.stream() Err：建连/鉴权/HTTP non-2xx,或流建立后空文本各类中断）。
/// UX-260618-15: **不再 emit AiError**——重试可恢复路径的 emit 权交调用方(agentic.rs),
/// UX-260618-15: **不再 emit AiError**——重试可恢复路径的 emit 权交调用方(agentic/mod.rs),
/// 由 agentic 在重试耗尽/Fatal 时统一 emit 最终 AiError(单气泡),避免 N 次重试 push N+1 气泡。
/// `retryable`: 据状态码分类(retry::is_status_retryable 镜像)：true=5xx/429/timeout/connect
/// 可重试；false=4xx(非429)/鉴权/参数错 Fatal 立即放弃。调用方据此决定是否重试。

863
src-tauri/src/commands/ai/tool_registry.rs
View File

@@ -136,10 +136,11 @@ fn validate_path(path: &str) -> anyhow::Result<()> {
if crate::state::is_in_system_blacklist(&PathBuf::from(&normalized)) {
anyhow::bail!("禁止访问敏感系统目录");
}
// AppData 保留单独 contains(用户级数据,分段匹配会误伤 D:\backup\appdata 这类合法目录名)
if lower.contains("\\appdata\\") {
anyhow::bail!("禁止访问敏感系统目录");
}
// F-260620: AppData 不再硬拦(原 `lower.contains("\\appdata\\")` 一刀切致用户授权后仍拒)。
// AppData 走白名单流程(is_authorized/check_path_authorization):默认不在白名单 → 弹 DirAuthDialog
// → 用户显式授权(once/always)→ 放行。真正敏感凭据(.ssh/.aws/.gnupg)由 is_in_system_blacklist
// 硬拦(授权也不放,防凭据泄漏),AppData 内应用数据(DBeaver Scripts/项目配置等)归用户自治——
// 用户授权 = 用户同意,AI 不越权也不一刀切挡用户数据。
Ok(())
}
@@ -271,6 +272,20 @@ pub(crate) fn resolve_anchor_to_lines(content: &str, start: &str, end: &str) ->
static FILE_LOCKS: LazyLock<TokioMutex<HashMap<PathBuf, ()>>> =
LazyLock::new(|| TokioMutex::new(HashMap::new()));
/// 计算文件指纹 `modified_secs_len`(TD-260621-04 闭环)。
///
/// read_file 返回此值 → LLM 回传 patch_file.expected_hash → patch_file 比对，闭环防并发修改。
/// 抽单一真相源避免 read_file 输出与 patch_file 校验两处 format 漂移(modified_secs_len 格式必须严格一致)。
/// modified 取不到(系统不支持)退 0，仍保留 len 维度作弱保护。
fn compute_file_hash(meta: &std::fs::Metadata) -> String {
let modified = meta
.modified()
.ok()
.and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
.map(|d| d.as_secs());
format!("{}_{}", modified.unwrap_or(0), meta.len())
}
/// workspace 根目录（项目根 = src-tauri 上两级，编译期固定）
fn workspace_root() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
@@ -280,6 +295,50 @@ fn workspace_root() -> PathBuf {
.unwrap_or_else(|| PathBuf::from("."))
}
/// 阶段4(容错/恢复,开关 `df-ai-approval-retry`):跨盘/跨卷文件移动统一降级 helper。
///
/// 背景:Windows 跨盘符(C→E)或跨卷时 `tokio::fs::rename` 报 `os error 17`
/// (ERROR_NOT_SAME_DEVICE),同盘同卷 rename 原子。`delete_file`(源→workspace/.trash)
/// 与 `rename_file`(from→to)在跨盘场景都需降级为 copy + remove(非原子)。
///
/// 本 helper 统一两处降级逻辑(对齐 delete_file:1430 与 rename_file:1534 的 copy+remove 模式):
/// 1. 先试 `rename`(原子,同盘成功直接返 Ok);
/// 2. rename 失败且 `raw_os_error == Some(17)`(跨卷)→ 降级 copy + remove,
/// copy 失败源完整(未动,上抛);remove 失败删 target 回滚保源完整(对齐设计:失败回滚删 target);
/// 3. rename 失败但非 17(权限/占用)→ 上抛原错,不降级(非跨卷问题降级无意义)。
///
/// 返回 `cross_volume: bool`(rename 成功=false,降级 copy+remove=true)供调用方回填结果。
///
/// 兜底/回退:flag 关或 helper 内部 panic 不影响——降级是纯增强,失败上抛 anyhow 让调用方
/// 走原 failed tool_result 路径(LLM 据此修参重试,非死循环:重试由阶段4 retry_guard 兜底)。
async fn rename_or_cross_volume_copy(
from: &str,
to: &str,
) -> anyhow::Result<bool> {
// 同卷:tokio::fs::rename 原子(Windows 走 MoveFileExW UTF-16,中文路径无 GBK 问题)
match tokio::fs::rename(from, to).await {
Ok(()) => Ok(false),
Err(err) => {
// 跨卷(Windows ERROR_NOT_SAME_DEVICE 17)→ 降级 copy+remove;其他错误(权限/占用)直接抛
let cross_volume = err.raw_os_error() == Some(17);
if !cross_volume {
anyhow::bail!("重命名/移动失败: {}", err);
}
// 跨卷降级 copy + remove(非原子):copy 失败 from 完整(未动);copy 成功 remove 失败
// 则 from/to 同时存在,删 to 回滚保 from 完整(对齐设计:失败回滚删 to)
if let Err(e) = tokio::fs::copy(from, to).await {
anyhow::bail!("跨卷复制失败（from 未改动）: {}", e);
}
if let Err(e) = tokio::fs::remove_file(from).await {
// remove 失败:回滚删 to,保 from 完整(用户可重试)
let _ = tokio::fs::remove_file(to).await;
anyhow::bail!("跨卷移动删除源失败已回滚（from 完整,可重试）: {}", e);
}
Ok(true)
}
}
}
/// 解析文件工具路径：相对路径锚定 workspace_root，禁止越出项目目录
///
/// 双层校验：
@@ -839,6 +898,7 @@ fn register_idea_tools(registry: &mut AiToolRegistry, db: &Arc<Database>) {
score: None, tags: args["tags"].as_str().map(|s| s.to_string()),
source: args["source"].as_str().map(|s| s.to_string()),
promoted_to: None, ai_analysis: None, scores: None,
related_ids: None,
created_at: now_millis(), updated_at: now_millis(),
};
let id = record.id.clone();
@@ -910,13 +970,16 @@ fn register_file_tools(
if metadata.len() > 1_048_576 {
anyhow::bail!("文件超过 1MB 限制 ({} 字节)", metadata.len());
}
// TD-260621-04 闭环:返回 file_hash 供 patch_file.expected_hash 比对(防并发修改)。
// 三返回点(二进制降级/search/默认分页)共用此值,文件未改时跨分页稳定。
let file_hash = compute_file_hash(&metadata);
// 二进制/非 UTF-8 降级:read_to_string 对二进制硬失败,降级返 binary 标记而非错(防读二进制炸对话)
let mut content = String::new();
if let Err(e) = file.read_to_string(&mut content).await {
if e.kind() == std::io::ErrorKind::InvalidData {
return Ok(serde_json::json!({
"path": path, "content": null, "binary": true,
"size": metadata.len(),
"size": metadata.len(), "file_hash": file_hash,
"error": "文件非 UTF-8 文本(疑似二进制),无法作为文本读取"
}));
}
@@ -938,7 +1001,7 @@ fn register_file_tools(
let page_matches: Vec<_> = all_matches.into_iter().skip(search_offset).take(search_limit).collect();
let has_more = (search_offset + page_matches.len()) < total;
return Ok(serde_json::json!({
"path": path, "size": metadata.len(),
"path": path, "size": metadata.len(), "file_hash": file_hash,
"search": search,
"matches": page_matches,
"total": total,
@@ -965,7 +1028,7 @@ fn register_file_tools(
(page.join("\n"), None, more)
};
Ok(serde_json::json!({
"path": path, "content": result, "size": metadata.len(), "lines": line_count,
"path": path, "content": result, "size": metadata.len(), "file_hash": file_hash, "lines": line_count,
"offset": offset_used,
"returned_lines": result.lines().count(),
"has_more": has_more,
@@ -1158,7 +1221,14 @@ fn register_file_tools(
anyhow::bail!("文件超过 1MB 限制 ({} 字节)", file_meta.len());
}
// 阶段一：读文件内容 + 校验（无锁，纯读操作）
// TD-260621-03:读改写整体锁内防 lost update。
// 原实现读+校验+new_content 计算在无锁段,仅写序列持 FILE_LOCKS → 两并发 patch 同文件:
// A/B 各自读 v1 算 new_content(锁外)→ A 持锁写 v2 释放 → B 持锁用基于 v1 的 new_content 覆盖 A。
// 改:读+校验+算+写 全程持 _patch_guard,串行化 patch(全局锁,单用户桌面够用,见 FILE_LOCKS 注释)。
// 顺带修 entry().or_insert(()) 内存泄漏(FILE_LOCKS HashMap 只增不清,P2 精选项)。
let _patch_guard = FILE_LOCKS.lock().await;
// 读文件内容 + 校验（锁内,纯读 + CPU 计算）
use tokio::io::AsyncReadExt;
let mut file = tokio::fs::File::open(path).await
.map_err(|e| anyhow::anyhow!("读取文件失败 {}: {}", path, e))?;
@@ -1171,12 +1241,9 @@ fn register_file_tools(
anyhow::bail!("不支持二进制文件");
}
// L3: expected_hash 指纹校验（防外部修改）
// L3: expected_hash 指纹校验（防外部修改，TD-260621-04 闭环：与 read_file 返回的 file_hash 同格式）
if let Some(expected) = args["expected_hash"].as_str() {
let modified = file_meta.modified()
.ok().and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
.map(|d| d.as_secs());
let current_hash = format!("{}_{}", modified.unwrap_or(0), file_meta.len());
let current_hash = compute_file_hash(&file_meta);
if current_hash != expected {
anyhow::bail!(
"文件已被外部修改(hash 不匹配): 期望={} 实际={}，请重新 read_file 获取最新内容",
@@ -1238,34 +1305,26 @@ fn register_file_tools(
warning = None;
}
// 阶段二：L1 tokio::Mutex 保护写序列（backup → tmp write → rename → cleanup）
// tokio::sync::Mutex 的 MutexGuard 是 Send，可安全跨 await
let abs_path = target.canonicalize()
.map_err(|e| anyhow::anyhow!("路径解析失败: {}", e))?;
{
let mut locks = FILE_LOCKS.lock().await;
locks.entry(abs_path.clone()).or_insert(());
// 写序列（_patch_guard 持锁中:backup → tmp write → rename → cleanup）
// .bak 备份
let bak = format!("{}.bak", path);
tokio::fs::copy(path, &bak).await
.map_err(|e| anyhow::anyhow!("备份 .bak 失败: {}", e))?;
// .bak 备份
let bak = format!("{}.bak", path);
tokio::fs::copy(path, &bak).await
.map_err(|e| anyhow::anyhow!("备份 .bak 失败: {}", e))?;
// 原子写: tmp → rename
let tmp = format!("{}.tmp-write", path);
if let Err(e) = tokio::fs::write(&tmp, &new_content).await {
let _ = tokio::fs::remove_file(&tmp).await;
let _ = tokio::fs::remove_file(&bak).await;
return Err(anyhow::anyhow!("写入临时文件失败: {}", e));
}
if let Err(e) = tokio::fs::rename(&tmp, path).await {
let _ = tokio::fs::remove_file(&tmp).await;
return Err(anyhow::anyhow!("原子替换失败: {}，备份保留在 {}", e, bak));
}
// 成功：清理 .bak
// 原子写: tmp → rename
let tmp = format!("{}.tmp-write", path);
if let Err(e) = tokio::fs::write(&tmp, &new_content).await {
let _ = tokio::fs::remove_file(&tmp).await;
let _ = tokio::fs::remove_file(&bak).await;
// _locks 在此 drop，释放锁
return Err(anyhow::anyhow!("写入临时文件失败: {}", e));
}
if let Err(e) = tokio::fs::rename(&tmp, path).await {
let _ = tokio::fs::remove_file(&tmp).await;
return Err(anyhow::anyhow!("原子替换失败: {}，备份保留在 {}", e, bak));
}
// 成功：清理 .bak
let _ = tokio::fs::remove_file(&bak).await;
drop(_patch_guard); // 释放锁(diff 计算纯 CPU,不需持锁)
let size_diff = new_content.len() as i64 - content.len() as i64;
// 生成 unified diff 供前端审批卡/审计留痕展示
@@ -1426,8 +1485,17 @@ fn register_file_tools(
let backup_name = format!("{}-{}", new_id(), file_name);
let backup_path = trash_dir.join(&backup_name);
let backup_path_str = backup_path.to_string_lossy().to_string();
tokio::fs::rename(path, &backup_path).await
.map_err(|e| anyhow::anyhow!("移入回收站失败: {}", e))?;
// 软删除跨盘降级(F-260621):同盘 rename 原子;跨盘(Windows EXDEV os error 17,
// 如 C盘授权路径 → E盘 workspace_root/.trash)rename 失败,降级 copy + remove(非原子,
// 失败回滚删 backup 保源完整)。
// 阶段4:跨盘降级抽统一 helper rename_or_cross_volume_copy(对齐 rename_file 跨卷处理),
// 消除两处 copy+remove 字面量重复。原直接 rename bail 致 delete_file 跨盘场景全失败
// (用户授权工程外 C 盘路径删除时,前几个卡"执行中..."+ 末个报 os error 17)。
// .trash 固定在 workspace_root,授权工程外路径删除必然跨盘。
// helper 内部错误文案含"跨卷复制失败/remove源失败"等,此处 map_err 转成"移入回收站"语义。
if let Err(e) = rename_or_cross_volume_copy(path, &backup_path_str).await {
anyhow::bail!("移入回收站失败({})", e);
}
Ok(serde_json::json!({
"path": path,
"deleted": true,
@@ -1501,44 +1569,171 @@ fn register_file_tools(
}
// 同卷:tokio::fs::rename 原子(Windows 走 MoveFileExW UTF-16,中文路径无 GBK 问题)
let rename_err = tokio::fs::rename(from_path, to_path).await.err();
if rename_err.is_none() {
return Ok(serde_json::json!({
"from": from_path,
"to": to_path,
"renamed": true,
"bytes_moved": bytes_moved,
"cross_volume": false,
}));
}
// rename 失败:跨卷(Windows ERROR_NOT_SAME_DEVICE 17)→ 降级 copy+remove
// 其他错误(权限/占用)直接抛,不降级
let err = rename_err.unwrap();
let cross_volume = err.raw_os_error() == Some(17);
if !cross_volume {
anyhow::bail!("重命名/移动失败: {}", err);
}
// 跨卷降级 copy + remove(非原子):copy 失败 from 完整(未动);copy 成功 remove 失败
// 则 from/to 同时存在,删 to 回滚保 from 完整(对齐设计:失败回滚删 to)
if let Err(e) = tokio::fs::copy(from_path, to_path).await {
anyhow::bail!("跨卷复制失败（from 未改动）: {}", e);
}
if let Err(e) = tokio::fs::remove_file(from_path).await {
// remove 失败:回滚删 to,保 from 完整(用户可重试)
let _ = tokio::fs::remove_file(to_path).await;
anyhow::bail!("跨卷移动删除源失败已回滚（from 完整,可重试）: {}", e);
}
// 阶段4:跨卷降级抽统一 helper rename_or_cross_volume_copy(对齐 delete_file .trash 跨盘降级),
// 消除两处 copy+remove 字面量重复(原 inline 逻辑与此 helper 等价,行为零变更)。
let cross_volume = rename_or_cross_volume_copy(from_path, to_path).await?;
Ok(serde_json::json!({
"from": from_path,
"to": to_path,
"renamed": true,
"bytes_moved": bytes_moved,
"cross_volume": true,
"cross_volume": cross_volume,
}))
})
})},
);
// ── 跨文件内容搜索 grep (Medium risk, F-260621) ──
// 缺口补齐:search_files 只搜文件名、read_file 只搜单文件内容,grep 提供 grep -rn 跨文件内容搜索。
// 参考 memory [[devflow-patch-file-design]] 工具落地模式 + Claude Code grep 工具语义。
//
// 参数语义(对齐 Claude Code grep):
// - pattern(必填):正则表达式(默认),大小写敏感。-i 切大小写不敏感。
// 注意:与 search_files 不同(search_files 字面包含 + 大小写不敏感),grep 用 regex 更强表达力,
// 但"无特殊字符的 pattern"等价字面包含(如 "foo" 匹配含 foo 的行)。
// - path(搜索根):锚 workspace + path_auth 授权(resolve_workspace_path_with_allowed)。
// - glob(可选):文件名过滤,如 "*.rs"。支持基础 glob(* / ? / [seq] 单段),复用 PatternBuilder。
// - output_mode:content(默认,返 file:line:content+context) / files_with_matches(只返命中文件名) /
// count(每文件命中行数)。对齐 Claude Code grep 三模式。
// - -n(行号,默认 true)/ -i(大小写不敏感,默认 false)/ -C context_lines(上下文行数,默认 0)。
// - max_results:防撑爆 LLM context,默认 50(对齐 read_file search/search_files 50 条上限)。
//
// 安全:递归遍历跳过噪音目录(.git/node_modules/target/.trash 等 is_noise_dir)+
// 噪音文件(.bak/.tmp-write 等 is_noise_file)+ symlink(对齐 list_dir_recursive 防逃逸)+
// 二进制文件(对齐 read_file/list_directory:\0 检测)。
// path_auth:授权目录内放行;未授权走 AiDirAuthRequired 申请(audit/mod.rs check_file_tool_auth
// 经 extract_file_tool_paths 单路径分支触发,非 search_files 盲拒)。
// risk:Med(读文件内容,授权目录内放行/外申请)。
// 注册顺序:read_file/list_directory 后,search_files 前(高频检索工具靠前)。
let grep_schema = {
let mut props = serde_json::Map::new();
props.insert("pattern".into(), serde_json::json!({ "type": "string", "description": "正则表达式(默认大小写敏感)。无特殊字符时等价字面包含匹配。必填" }));
props.insert("path".into(), serde_json::json!({ "type": "string", "description": "搜索根目录(锚 workspace + path_auth 授权)。必填" }));
props.insert("glob".into(), serde_json::json!({ "type": "string", "description": "可选文件名 glob 过滤(如 *.rs / *.ts),单段匹配;不传搜全部文件" }));
props.insert("output_mode".into(), serde_json::json!({ "type": "string", "description": "输出模式:content(默认,行级匹配+上下文)/ files_with_matches(仅命中文件名)/ count(每文件命中行数)", "enum": ["content", "files_with_matches", "count"] }));
props.insert("-n".into(), serde_json::json!({ "type": "boolean", "description": "content 模式是否含行号(默认 true)" }));
props.insert("-i".into(), serde_json::json!({ "type": "boolean", "description": "大小写不敏感(默认 false,大小写敏感)" }));
props.insert("-C".into(), serde_json::json!({ "type": "integer", "description": "上下文行数(content 模式,命中行前后各 N 行,默认 0)", "minimum": 0, "maximum": 10 }));
props.insert("max_results".into(), serde_json::json!({ "type": "integer", "description": "返回上限(防撑爆 context,默认 50)", "minimum": 1, "maximum": 200 }));
serde_json::json!({
"type": "object",
"properties": props,
"required": ["pattern", "path"],
})
};
registry.register(
"grep", "跨文件内容搜索(grep -rn 模式)。参数:pattern(正则,大小写敏感,无特殊字符时等价字面包含)、path(搜索根,锚 workspace + path_auth 授权)、glob(可选文件名过滤如 *.rs)、output_mode(content/files_with_matches/count)、-n(行号默认 true)、-i(大小写不敏感默认 false)、-C(上下文行数默认 0)、max_results(上限默认 50)。跳过噪音目录/噪音文件/symlink/二进制文件。返回 matches(files_with_matches 模式)或 matches(含 file/line/content/context,content 模式)+ total + truncated。授权目录内放行,未授权触发目录授权申请(AiDirAuthRequired)",
grep_schema,
RiskLevel::Medium,
{ let allowed_dirs = allowed_dirs.clone(); Box::new(move |args: serde_json::Value| {
let allowed_dirs = allowed_dirs.clone();
Box::pin(async move {
let snap = allowed_dirs.read().await.clone();
let resolved = resolve_workspace_path_with_allowed(
args["path"].as_str().ok_or_else(|| anyhow::anyhow!("缺少 path 参数"))?,
&snap,
)?;
let root = resolved.to_str().ok_or_else(|| anyhow::anyhow!("路径含非法字符"))?;
let pattern = args["pattern"].as_str()
.ok_or_else(|| anyhow::anyhow!("缺少 pattern 参数"))?;
if pattern.is_empty() {
anyhow::bail!("pattern 不能为空");
}
let glob_opt = args.get("glob").and_then(|v| v.as_str()).filter(|s| !s.is_empty());
let case_insensitive = args.get("-i").and_then(|v| v.as_bool()).unwrap_or(false);
let show_line = args.get("-n").and_then(|v| v.as_bool()).unwrap_or(true);
let context_lines = args.get("-C").and_then(|v| v.as_u64()).unwrap_or(0).min(10) as usize;
let output_mode = args.get("output_mode").and_then(|v| v.as_str()).unwrap_or("content");
let max_results = args.get("max_results").and_then(|v| v.as_u64()).unwrap_or(50).clamp(1, 200) as usize;
// 编译正则:case_insensitive 开 i flag;失败上抛明确错误(非法正则不是业务错,LLM 据此修参)
let mut re_builder = regex::RegexBuilder::new(pattern);
re_builder.case_insensitive(case_insensitive);
let re = re_builder.build()
.map_err(|e| anyhow::anyhow!("正则编译失败「{}」: {}", pattern, e))?;
// glob 过滤器:编译为 regex 单段匹配(* → [^/]*, ? → [^/], 字面其他字符 escape)。
// 仅匹配文件名单段(不含 /),对齐 Claude Code grep glob 语义。
let glob_re = match glob_opt {
Some(g) => Some(compile_glob_to_regex(g)
.map_err(|e| anyhow::anyhow!("glob 编译失败「{}」: {}", g, e))?),
None => None,
};
// 递归遍历+逐文件读+行匹配,收集结果
let mut matches_out: Vec<FileGrepHit> = Vec::new();
let mut total: usize = 0;
let mut truncated = false;
grep_recursive(
root, &re, glob_re.as_ref(), output_mode,
context_lines, max_results, 0, 6,
&mut matches_out, &mut total, &mut truncated,
).await?;
// output_mode 分派返回结构
let result = match output_mode {
"files_with_matches" => {
// 仅返命中文件路径列表(去重,顺序保留首次命中)
let files: Vec<String> = matches_out.iter()
.map(|h| h.file.clone())
.collect();
serde_json::json!({
"path": root,
"pattern": pattern,
"output_mode": output_mode,
"files": files,
"total": files.len(),
"truncated": truncated,
})
}
"count" => {
// 每文件命中行数
let counts: Vec<serde_json::Value> = matches_out.iter()
.map(|h| serde_json::json!({ "file": h.file, "count": h.line_matches.len() }))
.collect();
let total_files = counts.len();
serde_json::json!({
"path": root,
"pattern": pattern,
"output_mode": output_mode,
"counts": counts,
"total": total,
"total_files": total_files,
"truncated": truncated,
})
}
_ => {
// content 模式(默认):展平所有命中行为 matches[{file,line,content,context?}]
let mut lines: Vec<serde_json::Value> = Vec::new();
for hit in &matches_out {
for lm in &hit.line_matches {
let line_no = if show_line { serde_json::Value::from(lm.line) } else { serde_json::Value::Null };
let mut entry = serde_json::json!({
"file": hit.file,
"line": line_no,
"content": lm.content,
});
if context_lines > 0 && !lm.context.is_empty() {
entry["context"] = serde_json::Value::String(lm.context.clone());
}
lines.push(entry);
}
}
serde_json::json!({
"path": root,
"pattern": pattern,
"output_mode": "content",
"matches": lines,
"total": total,
"truncated": truncated,
})
}
};
Ok(result)
})
})},
);
// ── 文件搜索 (Low risk) ──
registry.register(
"search_files", "在指定目录下搜索匹配模式（字符串包含匹配）的文件名，支持 offset/limit 分页。返回 results、total、has_more。默认 limit=50",
@@ -1778,6 +1973,240 @@ fn is_noise_file(name: &str) -> bool {
NOISE_SUFFIXES.iter().any(|sfx| name.ends_with(sfx))
}
// ============================================================
// grep 工具底层（F-260621）
//
// FileGrepHit 单文件命中聚合:line_matches 按行号升序。output_mode 分派时:
// - content: 展平 line_matches 为 matches[{file,line,content,context?}]
// - files_with_matches: 仅取 file 字段(顺序保留首次命中)
// - count: 取 line_matches.len() 为每文件命中行数
//
// LineMatch.content 为命中行原文(去尾换行),context 为命中行前后 context_lines 行
// 拼接(前 N 行 + 命中行 + 后 N 行,\n 连接),供前端展开查看上下文。
// ============================================================
/// 单行命中(1-based 行号 + 行内容 + 上下文)
struct LineMatch {
line: usize,
content: String,
context: String,
}
/// 单文件命中聚合(file=绝对/锚定路径,line_matches 按行号升序)
struct FileGrepHit {
file: String,
line_matches: Vec<LineMatch>,
}
/// 编译单段 glob(* / ? / [seq] / 字面字符)为 regex,锚定 ^...$ 整段匹配文件名。
///
/// 转换规则(对齐 Claude Code grep glob 单段语义,不含 /):
/// - `*` → `[^/]*`(任意非分隔符序列)
/// - `?` → `[^/]`(单个非分隔符)
/// - `[seq]` 原样保留为字符集(支持 [a-z] / [!seq] 取反)
/// - 其他字符 regex escape(防 `.+()` 等被当元字符)
///
/// 简化设计:不引入 glob crate(避免新顶层依赖),手写单段 glob→regex 转换。
/// 失败(glob 含非法 regex 构造,如未闭合 `[`)上抛,调用方 map_err 友好提示。
fn compile_glob_to_regex(glob: &str) -> anyhow::Result<regex::Regex> {
let mut out = String::with_capacity(glob.len() + 4);
out.push('^');
let mut chars = glob.chars().peekable();
while let Some(c) = chars.next() {
match c {
'*' => out.push_str("[^/]*"),
'?' => out.push_str("[^/]"),
'[' => {
// 字符集:原样保留到匹配的 ](支持开头 ] 字面 + ! 取反)
out.push('[');
// ] 在首位视为字面(POSIX glob 约定)
if matches!(chars.peek(), Some(']')) {
out.push('\\'); out.push(']');
chars.next();
}
if matches!(chars.peek(), Some('!')) {
out.push('^'); // regex 取反用 ^
chars.next();
}
while let Some(ch) = chars.next() {
if ch == ']' {
out.push(']');
break;
}
// 集合内字符 escape regex 元字符(如 ] 已由 break 处理,此处 \ - 等保留)
out.push(ch);
}
}
// regex 元字符 escape(. + ( ) | ^ $ { } \ 等)
'.' | '+' | '(' | ')' | '|' | '^' | '$' | '{' | '}' | '\\' => {
out.push('\\'); out.push(c);
}
_ => out.push(c),
}
}
out.push('$');
regex::Regex::new(&out).map_err(|e| anyhow::anyhow!(e.to_string()))
}
/// 递归跨文件内容搜索(grep -rn 模式)
///
/// 遍历 `dir`(深度 `depth`,上限 `max_depth`)下所有文件:
/// - 跳过噪音目录(is_noise_dir)/噪音文件(is_noise_file)/symlink(file_type 不跟随)
/// - glob 过滤器(可选):命中文件名才读内容
/// - 二进制文件跳过:前 8KB 含 \0 视为二进制(对齐 read_file/list_directory)
/// - 单文件 1MB 上限跳过(对齐 read_file,防读超大文件撑爆)
/// - 逐行 `re.is_match`,收集命中行(context_lines>0 时附上下文)
/// - 达 `max_results` 命中行数即停止(返 `truncated=true`),`total` 仍累加全部命中数
///
/// 输出聚合到 `out`(按文件分组),`total`/`truncated` 由调用方读后构造响应。
fn grep_recursive<'a>(
dir: &'a str,
re: &'a regex::Regex,
glob: Option<&'a regex::Regex>,
output_mode: &'a str,
context_lines: usize,
max_results: usize,
depth: usize,
max_depth: usize,
out: &'a mut Vec<FileGrepHit>,
total: &'a mut usize,
truncated: &'a mut bool,
) -> std::pin::Pin<Box<dyn std::future::Future<Output = anyhow::Result<()>> + Send + 'a>> {
Box::pin(async move {
let mut entries = tokio::fs::read_dir(dir).await
.map_err(|e| anyhow::anyhow!("无法读取目录 {}: {}", dir, e))?;
// 收集本层 entry 先排序(确定性输出,便于测试稳定 + LLM 可重现)
let mut items: Vec<std::path::PathBuf> = Vec::new();
while let Some(entry) = entries.next_entry().await? {
items.push(entry.path());
}
items.sort();
for path in items {
if *truncated {
return Ok(());
}
let file_name = match path.file_name() {
Some(n) => n.to_string_lossy().to_string(),
None => continue,
};
// file_type 不跟随 symlink(对比 metadata 会跟随);symlink 一律跳过(防逃逸,对齐 list_dir_recursive)
let file_type = match tokio::fs::symlink_metadata(&path).await {
Ok(ft) => ft,
Err(_) => continue, // 元数据读失败跳过(权限/竞态等)
};
if file_type.is_symlink() {
continue;
}
if file_type.is_dir() {
// 噪音目录(.git/node_modules/target/.trash 等)不深入
if is_noise_dir(&file_name) {
continue;
}
if depth < max_depth {
let child = path.to_string_lossy().into_owned();
grep_recursive(
&child, re, glob, output_mode, context_lines, max_results,
depth + 1, max_depth, out, total, truncated,
).await?;
}
continue;
}
// 文件:跳过噪音文件(.bak/.tmp-write 等编辑器产物)
if is_noise_file(&file_name) {
continue;
}
// glob 过滤(单段匹配文件名,glob_re 已锚定 ^...$ 整段匹配)
if let Some(g) = glob {
if !g.is_match(&file_name) {
continue;
}
}
// 单文件读取:1MB 上限 + 二进制检测(\0)。读失败静默跳过(权限/竞态,不阻断整体搜索)
let metadata = match tokio::fs::metadata(&path).await {
Ok(m) => m,
Err(_) => continue,
};
if metadata.len() > 1_048_576 {
continue; // >1MB 跳过(对齐 read_file 上限)
}
let bytes = match tokio::fs::read(&path).await {
Ok(b) => b,
Err(_) => continue,
};
// 二进制检测:前 8KB 含 \0 视为二进制跳过(对齐 file_info/read_file)
if bytes.iter().take(8192).any(|&b| b == 0) {
continue;
}
// 转 UTF-8(lossy 容错非 UTF-8 残片,二进制已挡多数情况)
let content = String::from_utf8_lossy(&bytes);
let lines: Vec<&str> = content.lines().collect();
// files_with_matches 模式:仅记文件级命中,不收集行详情。
// content/count 模式:行级命中,需逐行检查 max_results 截断(单文件可能多行命中,
// 超过 max_results 的行只计入 total 不入 out)。
if output_mode == "files_with_matches" {
// 检查文件数是否已达上限:达则本文件只计入 total 不入 out(设截断)
let mut has_hit = false;
for line in lines.iter() {
if re.is_match(line) {
*total += 1;
has_hit = true;
}
}
if !has_hit {
continue; // 本文件无命中
}
if out.len() >= max_results {
*truncated = true; // 已达文件数上限,只计入 total
} else {
out.push(FileGrepHit {
file: path.to_string_lossy().into_owned(),
line_matches: Vec::new(), // files_with_matches 不收集行详情
});
}
continue;
}
// content/count 模式:逐行收集,达 max_results 行数上限即截断(剩余行只计 total)
let mut line_matches: Vec<LineMatch> = Vec::new();
let mut file_has_hit = false;
// 已收集命中行累计计数(O(1) 维护):初值=前序文件累计收集数(本文件内逐次自增)
// 取代每次命中全量重算 out.iter().map(...).sum() 的 O(n²) 统计。
let mut collected = out.iter().map(|h| h.line_matches.len()).sum::<usize>();
for (idx, line) in lines.iter().enumerate() {
if re.is_match(line) {
*total += 1;
file_has_hit = true;
// 当前已收集行数达上限 → 截断,不再收集
if collected >= max_results {
*truncated = true;
} else {
let context = if context_lines > 0 {
let start = idx.saturating_sub(context_lines);
let end = (idx + context_lines + 1).min(lines.len());
lines[start..end].join("\n")
} else {
String::new()
};
line_matches.push(LineMatch {
line: idx + 1, // 1-based
content: line.to_string(),
context,
});
collected += 1; // 命中收集后累计计数自增(O(1))
}
}
}
if file_has_hit && !line_matches.is_empty() {
// 本文件有命中且有收集(全截断的文件不入 out,避免空 line_matches 污染)
out.push(FileGrepHit {
file: path.to_string_lossy().into_owned(),
line_matches,
});
}
}
Ok(())
})
}
/// 递归搜索文件（字符串包含匹配，大小写不敏感）
fn search_files_recursive<'a>(
path: &'a str,
@@ -1833,7 +2262,7 @@ mod tests {
// 任一层漏移 register 调用,此测试立即红。工具名集合也断言,防 rename 致 LLM tool 突变。
// ============================================================
/// build_ai_tool_registry 应注册恰好 29 个工具(18 data + 10 file + 1 http),且工具名集合稳定。
/// build_ai_tool_registry 应注册恰好 30 个工具(18 data + 11 file + 1 http),且工具名集合稳定。
///
/// 用 in-memory SQLite(Database::open_in_memory 自跑迁移),构造零外部依赖的 db,
// 不实际执行任何 handler——仅断言注册阶段的定义完整性,故无需真实数据。
@@ -1846,16 +2275,17 @@ mod tests {
let allowed_dirs = Arc::new(RwLock::new(AllowedDirs::default_with_root()));
let registry = build_ai_tool_registry(&db, &allowed_dirs);
// 总量基线:29(18 data + 10 file + 1 http)。拆分前后必须一致。
// 总量基线:30(18 data + 11 file + 1 http)。拆分前后必须一致。
// F-260621: file 层 10→11(新增 grep 跨文件内容搜索工具)。
assert_eq!(
registry.len(),
29,
"工具总数应为 29(18 data + 10 file + 1 http),实际 {}", registry.len()
30,
"工具总数应为 30(18 data + 11 file + 1 http),实际 {}", registry.len()
);
// 工具名集合基线:防 rename / 漏注册 / 误删除。
// data 层 18 个(持 db):CRUD/状态机/工作流
// file 层 10 个(不持 db):命令/读/列/写/改/元/追加/删/移/搜
// file 层 11 个(不持 db):命令/读/列/写/改/元/追加/删/移/搜/grep
// http 层 1 个(不持 db):http_request
let mut expected: Vec<&str> = vec![
// ── data 层 (18) ──
@@ -1865,11 +2295,12 @@ mod tests {
"run_workflow", "delete_task", "create_idea",
"delete_project", "restore_project", "purge_project",
"list_trash", "get_project_count", "get_task_count",
// ── file 层 (10) ──（run_command 注册顺序已移至末位降低 LLM 偏好,
// 集合断言经 sort 后与顺序无关,仅守护工具名不漂移）
// ── file 层 (11) ──（run_command 注册顺序已移至末位降低 LLM 偏好,
// 集合断言经 sort 后与顺序无关,仅守护工具名不漂移。grep 新增 F-260621）
"read_file", "list_directory", "write_file",
"patch_file", "file_info", "append_file",
"delete_file", "rename_file", "search_files", "run_command",
"grep",
// ── http 层 (1) ──
"http_request",
];
@@ -2205,4 +2636,286 @@ mod tests {
let out = apply_line_range(content, s, e, "use std::path;").unwrap();
assert_eq!(out, "use std::path;\n\nfn main() {}\n");
}
// ============================================================
// grep 工具测试（F-260621）
//
// compile_glob_to_regex:纯函数,无 fs 依赖。
// grep_recursive:递归遍历临时目录树,覆盖基本匹配/正则/大小写/glob/噪音跳过/截断。
// path_auth 未授权触发申请:经 check_file_tool_auth(单路径分支) → NeedsAuth,
// 非 search_files 盲拒(锁定 grep 走 read_file 同款申请路径)。
// ============================================================
/// compile_glob_to_regex:基础 * / ? / 字面字符
#[test]
fn test_compile_glob_basic() {
let g = compile_glob_to_regex("*.rs").unwrap();
assert!(g.is_match("main.rs"));
assert!(g.is_match("a.rs"));
assert!(!g.is_match("main.ts"));
// * 不跨段(不含 /)
assert!(!g.is_match("dir/main.rs"), "* 不匹配 / (单段语义)");
let q = compile_glob_to_regex("?.txt").unwrap();
assert!(q.is_match("a.txt"));
assert!(!q.is_match("ab.txt"), "? 仅匹配单字符");
// 字面字符(含 regex 元字符 escape:. 不当通配)
let lit = compile_glob_to_regex("v1.0.txt").unwrap();
assert!(lit.is_match("v1.0.txt"));
assert!(!lit.is_match("v1X0.txt"), ". 应字面匹配(escape 防 regex 元字符)");
}
/// compile_glob_to_regex:字符集 [seq] / [!seq] 取反
#[test]
fn test_compile_glob_charset() {
let set = compile_glob_to_regex("*.[ch]").unwrap();
assert!(set.is_match("main.c"));
assert!(set.is_match("main.h"));
assert!(!set.is_match("main.cpp"));
let neg = compile_glob_to_regex("*.[!ch]").unwrap();
assert!(!neg.is_match("main.c"), "[!ch] 取反,c 不命中");
assert!(!neg.is_match("main.h"), "[!ch] 取反,h 不命中");
// [!ch] 匹配单字符非 c/h 的扩展名(锚定 ^...$,多字符扩展不命中)
assert!(neg.is_match("main.s"), "[!ch] 取反,单字符 s 命中");
assert!(!neg.is_match("main.rs"), "[!ch] 锚定单字符,rs(2 字符)不命中");
}
/// grep_recursive:基本字面匹配(无特殊字符等价 contains)
#[tokio::test]
async fn test_grep_basic_literal_match() {
let tmp = std::env::temp_dir().join(format!("df_grep_basic_{}", std::process::id()));
let _ = fs::remove_dir_all(&tmp);
fs::create_dir_all(tmp.join("src")).unwrap();
fs::write(tmp.join("src").join("a.rs"), "fn foo() {}\nfn bar() {}\n").unwrap();
fs::write(tmp.join("src").join("b.rs"), "struct Foo;\n").unwrap();
let root = tmp.to_string_lossy().to_string();
let re = regex::Regex::new("foo").unwrap();
let mut out: Vec<FileGrepHit> = Vec::new();
let mut total = 0usize;
let mut truncated = false;
grep_recursive(&root, &re, None, "content", 0, 50, 0, 6, &mut out, &mut total, &mut truncated).await.unwrap();
// 大小写敏感:只命中 a.rs 第 1 行 "fn foo() {}"(b.rs "struct Foo" 大写不命中)
assert!(!truncated);
assert_eq!(total, 1, "foo 大小写敏感仅命中 1 处");
assert_eq!(out.len(), 1, "命中 1 个文件");
assert!(out[0].file.ends_with("a.rs"));
assert_eq!(out[0].line_matches.len(), 1);
assert_eq!(out[0].line_matches[0].line, 1);
assert_eq!(out[0].line_matches[0].content, "fn foo() {}");
fs::remove_dir_all(&tmp).ok();
}
/// grep_recursive:正则匹配(锚定 ^)
#[tokio::test]
async fn test_grep_regex_match() {
let tmp = std::env::temp_dir().join(format!("df_grep_regex_{}", std::process::id()));
let _ = fs::remove_dir_all(&tmp);
fs::create_dir_all(&tmp).unwrap();
fs::write(tmp.join("a.rs"), "fn main() {}\nasync fn helper() {}\nfn main2() {}\n").unwrap();
let root = tmp.to_string_lossy().to_string();
// ^fn 匹配行首 fn
let re = regex::Regex::new("^fn ").unwrap();
let mut out: Vec<FileGrepHit> = Vec::new();
let mut total = 0usize;
let mut truncated = false;
grep_recursive(&root, &re, None, "content", 0, 50, 0, 6, &mut out, &mut total, &mut truncated).await.unwrap();
// 第 1、3 行行首是 "fn ",第 2 行行首是 "async fn " 不命中 ^fn
assert_eq!(total, 2, "^fn 命中第 1、3 行");
assert_eq!(out[0].line_matches.len(), 2);
fs::remove_dir_all(&tmp).ok();
}
/// grep_recursive:大小写不敏感(-i 语义,经 RegexBuilder case_insensitive)
#[tokio::test]
async fn test_grep_case_insensitive() {
let tmp = std::env::temp_dir().join(format!("df_grep_ci_{}", std::process::id()));
let _ = fs::remove_dir_all(&tmp);
fs::create_dir_all(&tmp).unwrap();
fs::write(tmp.join("a.rs"), "Foo\nfoo\nFOO\n").unwrap();
let root = tmp.to_string_lossy().to_string();
let re = regex::RegexBuilder::new("foo").case_insensitive(true).build().unwrap();
let mut out: Vec<FileGrepHit> = Vec::new();
let mut total = 0usize;
let mut truncated = false;
grep_recursive(&root, &re, None, "content", 0, 50, 0, 6, &mut out, &mut total, &mut truncated).await.unwrap();
assert_eq!(total, 3, "大小写不敏感命中 Foo/foo/FOO 三处");
fs::remove_dir_all(&tmp).ok();
}
/// grep_recursive:glob 过滤(仅搜 *.rs)
#[tokio::test]
async fn test_grep_glob_filter() {
let tmp = std::env::temp_dir().join(format!("df_grep_glob_{}", std::process::id()));
let _ = fs::remove_dir_all(&tmp);
fs::create_dir_all(&tmp).unwrap();
// .rs 与 .ts 都含 "foo",glob *.rs 只搜 .rs
fs::write(tmp.join("a.rs"), "foo\n").unwrap();
fs::write(tmp.join("b.ts"), "foo\n").unwrap();
let root = tmp.to_string_lossy().to_string();
let re = regex::Regex::new("foo").unwrap();
let glob_re = Some(compile_glob_to_regex("*.rs").unwrap());
let mut out: Vec<FileGrepHit> = Vec::new();
let mut total = 0usize;
let mut truncated = false;
grep_recursive(&root, &re, glob_re.as_ref(), "content", 0, 50, 0, 6, &mut out, &mut total, &mut truncated).await.unwrap();
assert_eq!(out.len(), 1, "glob *.rs 仅命中 1 个文件");
assert!(out[0].file.ends_with("a.rs"), "应只命中 a.rs,b.ts 被过滤");
fs::remove_dir_all(&tmp).ok();
}
/// grep_recursive:噪音目录(.git/node_modules/target)与噪音文件(.bak)跳过
#[tokio::test]
async fn test_grep_skips_noise() {
let tmp = std::env::temp_dir().join(format!("df_grep_noise_{}", std::process::id()));
let _ = fs::remove_dir_all(&tmp);
fs::create_dir_all(tmp.join(".git")).unwrap();
fs::write(tmp.join(".git").join("config"), "foo-in-git\n").unwrap();
fs::create_dir_all(tmp.join("target")).unwrap();
fs::write(tmp.join("target").join("app"), "foo-in-target\n").unwrap();
// 噪音文件 .bak
fs::write(tmp.join("a.rs.bak"), "foo-in-bak\n").unwrap();
// 正常文件
fs::write(tmp.join("a.rs"), "foo\n").unwrap();
let root = tmp.to_string_lossy().to_string();
let re = regex::Regex::new("foo").unwrap();
let mut out: Vec<FileGrepHit> = Vec::new();
let mut total = 0usize;
let mut truncated = false;
grep_recursive(&root, &re, None, "content", 0, 50, 0, 6, &mut out, &mut total, &mut truncated).await.unwrap();
// 只命中 a.rs,噪音目录(.git/target)与噪音文件(.bak)被跳过
assert_eq!(total, 1, "仅 a.rs 命中,噪音被跳过");
assert_eq!(out.len(), 1);
assert!(out[0].file.ends_with("a.rs"));
fs::remove_dir_all(&tmp).ok();
}
/// grep_recursive:max_results 截断(total 累加全部,out 受限,truncated=true)
#[tokio::test]
async fn test_grep_truncation() {
let tmp = std::env::temp_dir().join(format!("df_grep_trunc_{}", std::process::id()));
let _ = fs::remove_dir_all(&tmp);
fs::create_dir_all(&tmp).unwrap();
// 一个文件含 5 行 foo,max_results=2 截断
fs::write(tmp.join("a.rs"), "foo\nfoo\nfoo\nfoo\nfoo\n").unwrap();
let root = tmp.to_string_lossy().to_string();
let re = regex::Regex::new("foo").unwrap();
let mut out: Vec<FileGrepHit> = Vec::new();
let mut total = 0usize;
let mut truncated = false;
grep_recursive(&root, &re, None, "content", 0, 2, 0, 6, &mut out, &mut total, &mut truncated).await.unwrap();
assert!(truncated, "达 max_results=2 应截断");
assert_eq!(total, 5, "total 累加全部 5 处命中");
// out 内行数受 max_results 限制(2 行)
let collected: usize = out.iter().map(|h| h.line_matches.len()).sum();
assert_eq!(collected, 2, "out 收集 2 行受 max_results 限制");
fs::remove_dir_all(&tmp).ok();
}
/// grep_recursive:context_lines 上下文(命中行前后各 N 行)
#[tokio::test]
async fn test_grep_context_lines() {
let tmp = std::env::temp_dir().join(format!("df_grep_ctx_{}", std::process::id()));
let _ = fs::remove_dir_all(&tmp);
fs::create_dir_all(&tmp).unwrap();
// 第 3 行命中 foo,context_lines=1 应含第 2-4 行
fs::write(tmp.join("a.rs"), "line1\nline2\nfoo\nline4\nline5\n").unwrap();
let root = tmp.to_string_lossy().to_string();
let re = regex::Regex::new("foo").unwrap();
let mut out: Vec<FileGrepHit> = Vec::new();
let mut total = 0usize;
let mut truncated = false;
grep_recursive(&root, &re, None, "content", 1, 50, 0, 6, &mut out, &mut total, &mut truncated).await.unwrap();
assert_eq!(out[0].line_matches[0].line, 3);
// context = 第 2、3、4 行(命中行前 1 + 命中行 + 后 1)
assert_eq!(out[0].line_matches[0].context, "line2\nfoo\nline4");
fs::remove_dir_all(&tmp).ok();
}
/// grep_recursive:files_with_matches 模式仅返命中文件(不收集行详情)
#[tokio::test]
async fn test_grep_files_with_matches_mode() {
let tmp = std::env::temp_dir().join(format!("df_grep_fwm_{}", std::process::id()));
let _ = fs::remove_dir_all(&tmp);
fs::create_dir_all(&tmp).unwrap();
fs::write(tmp.join("a.rs"), "foo\nfoo\n").unwrap(); // 同文件多命中
fs::write(tmp.join("b.rs"), "foo\n").unwrap();
let root = tmp.to_string_lossy().to_string();
let re = regex::Regex::new("foo").unwrap();
let mut out: Vec<FileGrepHit> = Vec::new();
let mut total = 0usize;
let mut truncated = false;
grep_recursive(&root, &re, None, "files_with_matches", 0, 50, 0, 6, &mut out, &mut total, &mut truncated).await.unwrap();
// total 累加全部命中行(3),out 每文件 line_matches 空(不收集行详情)
assert_eq!(total, 3, "total 计全部命中行");
assert_eq!(out.len(), 2, "命中 2 个文件");
assert!(out.iter().all(|h| h.line_matches.is_empty()), "files_with_matches 不收集行详情");
fs::remove_dir_all(&tmp).ok();
}
/// grep_recursive:二进制文件(\0)跳过
#[tokio::test]
async fn test_grep_skips_binary() {
let tmp = std::env::temp_dir().join(format!("df_grep_bin_{}", std::process::id()));
let _ = fs::remove_dir_all(&tmp);
fs::create_dir_all(&tmp).unwrap();
// 二进制文件(前 8KB 含 \0),内容含 "foo" 但应被跳过
let mut bin_content = b"foo\n".to_vec();
bin_content.push(0u8);
bin_content.extend_from_slice(b"more foo\n");
fs::write(tmp.join("a.bin"), &bin_content).unwrap();
// 正常文本文件
fs::write(tmp.join("a.rs"), "foo\n").unwrap();
let root = tmp.to_string_lossy().to_string();
let re = regex::Regex::new("foo").unwrap();
let mut out: Vec<FileGrepHit> = Vec::new();
let mut total = 0usize;
let mut truncated = false;
grep_recursive(&root, &re, None, "content", 0, 50, 0, 6, &mut out, &mut total, &mut truncated).await.unwrap();
// 二进制 a.bin 被跳过,只命中 a.rs
assert_eq!(total, 1, "二进制文件被跳过,仅 a.rs 命中");
assert_eq!(out.len(), 1);
assert!(out[0].file.ends_with("a.rs"));
fs::remove_dir_all(&tmp).ok();
}
/// path_auth 未授权触发申请:grep 走单路径授权申请路径(非 search_files 盲拒)。
/// 完整 check_file_tool_auth → NeedsAuth 流程覆盖在 audit/mod.rs 测试模块,
/// 此处锁定 grep 编译正则 + glob 的预校验路径(pattern 空 bail、非法正则 bail)。
#[test]
fn test_grep_pattern_validation() {
// 非法正则编译失败上抛(锁定 grep handler 对非法 pattern 的明确错误,非 panic)
let bad = regex::RegexBuilder::new("[unclosed").build();
assert!(bad.is_err(), "未闭合 [ 应编译失败(锁定 handler map_err 路径)");
// 空字符串 pattern 不合法(handler 内 bail,此处锁定 regex 接受空但 handler 显式拒)
assert!(regex::Regex::new("").is_ok(), "regex 接受空串,handler 层显式 bail 空 pattern");
}
}

85
src-tauri/src/commands/idea.rs
View File

@@ -8,7 +8,8 @@ use tauri::State;
use df_ai::provider::LlmProvider;
use df_types::types::{new_id, Priority};
use df_ideas::capture::Idea;
use df_storage::models::{IdeaRecord, ProjectRecord};
use df_storage::crud::is_unique_constraint_err;
use df_storage::models::{IdeaEvaluationRecord, IdeaRecord, ProjectRecord};
use crate::state::AppState;
@@ -43,6 +44,16 @@ pub async fn list_ideas(
}
}
/// 列出指定灵感的评估历史(version DESC,最新版本在前)。
/// IdeaEvaluationRecord 已 Serialize,直接返回前端供历史面板渲染。
#[tauri::command]
pub async fn list_idea_evaluations(
state: State<'_, AppState>,
idea_id: String,
) -> Result<Vec<IdeaEvaluationRecord>, String> {
state.idea_evaluations.list_by_idea(&idea_id).await.map_err(err_str)
}
/// 创建灵感，返回完整记录
#[tauri::command]
pub async fn create_idea(
@@ -62,6 +73,7 @@ pub async fn create_idea(
promoted_to: None,
ai_analysis: None,
scores: None,
related_ids: None,
created_at: now.clone(),
updated_at: now,
};
@@ -219,6 +231,7 @@ pub async fn evaluate_idea(
"negative_strength": negative_strength,
"net_sentiment": net_sentiment,
"recommendation": recommendation,
"evaluated_by": eval.evaluated_by,
"final_score": final_score,
"summary": analyst_summary,
"action_items": action_items,
@@ -239,10 +252,11 @@ pub async fn evaluate_idea(
let score_value = (scores.overall * 10.0).round() as i64;
// 构造完整记录后单次原子写回（update_full 保留 id 与 created_at）
// 构造完整记录后单次原子写回（update_full 保留 id 与 created_at）。
// ai_analysis/scores_json 按值 move 进主表记录后,下方历史快照仍需复用 → 此处 clone 保留绑定。
let updated = IdeaRecord {
scores: Some(scores_json),
ai_analysis: Some(ai_analysis),
scores: Some(scores_json.clone()),
ai_analysis: Some(ai_analysis.clone()),
score: Some(score_value as f64),
status: "pending_review".to_string(),
updated_at: now_millis(),
@@ -254,6 +268,57 @@ pub async fn evaluate_idea(
.await
.map_err(err_str)?;
// 追加一条评估历史快照(idea_evaluations 审计表,version 单调递增)。
// 主表 update_full 成功后再追加,保证主表先落;历史表为额外冗余列(evaluated_by
// 独立冗余,ai_analysis JSON 内的 evaluated_by 字段保留不删)。
//
// version 并发重复兜底(V25 唯一约束 + 重试):version 此前由
// `list_by_idea().first().version + 1` 算出,读-改-写非原子,并发评估同一灵感
// 可能写出相同 version。V25 在 idea_evaluations(idea_id, version) 上加了唯一索引,
// 此处捕获唯一约束冲突 → 重新查最新 version 重算并重试(上限 3 次防死循环)。
// 单用户桌面应用并发概率极低,但唯一约束 + 重试是数据完整性兜底,值得做。
let mut attempt = 0;
let max_attempts = 3;
loop {
attempt += 1;
let version = state
.idea_evaluations
.list_by_idea(&id)
.await
.map_err(err_str)?
.first()
.map(|r| r.version + 1)
.unwrap_or(1);
let eval_record = IdeaEvaluationRecord {
id: new_id(),
idea_id: id.clone(),
version,
ai_analysis: Some(ai_analysis.clone()),
scores: Some(scores_json.clone()),
score: Some(score_value as f64),
evaluated_by: Some(evaluated_by_str(&eval.evaluated_by).to_string()),
evaluated_at: now_millis(),
};
match state.idea_evaluations.insert(eval_record).await {
Ok(_) => break,
Err(e) => {
// 唯一约束冲突(SQLite extended code 2067 / SQLITE_CONSTRAINT_UNIQUE)
// → version 并发重复,命中且未达上限则重试(重新查 version);否则向上抛错。
// 检测逻辑收口到 df_storage::crud::is_unique_constraint_err,集中维护、
// 大小写不敏感,不再散落脆弱的英文文案 contains。
if is_unique_constraint_err(&e) && attempt < max_attempts {
tracing::warn!(
"灵感 {id} 评估历史 version 唯一约束冲突,重试 {}/{}",
attempt,
max_attempts
);
continue;
}
return Err(e.to_string());
}
}
}
Ok(updated)
}
@@ -347,3 +412,15 @@ fn action_items_for(r: &df_ideas::adversarial::Recommendation) -> Vec<String> {
Monitor => vec!["持续跟踪相关指标".into(), "定期评估进展".into(), "等待更好时机".into()],
}
}
/// EvaluatedBy 枚举 → 评估历史表 evaluated_by 列的字符串冗余值。
/// (ai_analysis JSON 内的 evaluated_by 字段保留不删;此处为历史表独立冗余列,
/// 便于不解析 JSON 即可直接按评估来源过滤/统计历史。)
fn evaluated_by_str(e: &df_ideas::adversarial::EvaluatedBy) -> &'static str {
use df_ideas::adversarial::EvaluatedBy::*;
match e {
Llm => "Llm",
Heuristic => "Heuristic",
HeuristicFallback => "HeuristicFallback",
}
}

62
src-tauri/src/commands/knowledge.rs
View File

@@ -135,6 +135,7 @@ pub async fn knowledge_create(
source_project: input.source_project,
source_ref: input.source_ref,
reasoning: None,
embedding_status: None,
created_at: now.clone(),
updated_at: now,
};
@@ -281,6 +282,21 @@ pub async fn knowledge_archive(
knowledge_update_status(state, id, "archived".to_string()).await
}
/// 重新生成向量嵌入(补偿重试)— P1 修复(嵌入失败无标记)的补偿入口
///
/// 触发条件:embedding_status='failed' 的已发布知识(provider 临时不可用导致永久无向量索引)。
/// 行为:fire-and-forget,后台逐条重跑嵌入生成(成功置 done,失败仍 failed 可再次触发)。
/// 返回值:本次触发重试的条数(0 表示无 failed 条目或 vector_enabled 关闭)。
#[tauri::command]
pub async fn knowledge_retry_embedding(
state: State<'_, AppState>,
) -> Result<usize, String> {
let count = crate::commands::ai::retry_failed_embeddings(&state)
.await
.map_err(err_str)?;
Ok(count)
}
// ============================================================
// 配置 + 手动提炼
// ============================================================
@@ -300,8 +316,18 @@ pub async fn knowledge_save_config(
state: State<'_, AppState>,
config: KnowledgeConfig,
) -> Result<bool, String> {
let mut cfg = state.knowledge_config.lock().await;
*cfg = config;
// P0(设置走查-2026-06-21):落 Settings KV 持久化,reload_knowledge_config 启动恢复
// (原纯内存 Arc<Mutex> 启动 default 覆盖致 8 项配置重启全丢)。
let json = serde_json::to_string(&config).map_err(|e| e.to_string())?;
{
let mut cfg = state.knowledge_config.lock().await;
*cfg = config;
}
state
.settings
.set(crate::state::KNOWLEDGE_CONFIG_KEY, &json)
.await
.map_err(|e| e.to_string())?;
Ok(true)
}
@@ -375,21 +401,41 @@ pub async fn knowledge_update(
.await
.map_err(err_str)?
.ok_or_else(|| format!("知识不存在: {id}"))?;
// P1 修复(KP-5 审计断档):记录本次实际改动的字段,供 updated 生命线事件审计展示。
// 只在值确实变化时计入 changed_fields(避免无改动也产生 updated 噪音事件)。
let mut changed_fields: Vec<&'static str> = Vec::new();
if let Some(v) = input.title {
if record.title != v {
changed_fields.push("title");
}
record.title = v;
}
if let Some(v) = input.content {
if record.content != v {
changed_fields.push("content");
}
record.content = v;
}
if let Some(v) = input.tags {
if record.tags.as_deref() != Some(v.as_str()) {
changed_fields.push("tags");
}
record.tags = Some(v);
}
// 空串 = 清空(前端编辑器清空 confidence/reasoning 输入框时传 "")
if let Some(v) = input.confidence {
record.confidence = if v.is_empty() { None } else { Some(v) };
let new_conf = if v.is_empty() { None } else { Some(v) };
if record.confidence != new_conf {
changed_fields.push("confidence");
}
record.confidence = new_conf;
}
if let Some(v) = input.reasoning {
record.reasoning = if v.is_empty() { None } else { Some(v) };
let new_reason = if v.is_empty() { None } else { Some(v) };
if record.reasoning != new_reason {
changed_fields.push("reasoning");
}
record.reasoning = new_reason;
}
record.updated_at = now_millis();
state
@@ -397,6 +443,14 @@ pub async fn knowledge_update(
.update_full(&record)
.await
.map_err(err_str)?;
// 生命线:编辑产生(fire-and-forget)。
// 仅在确有字段改动时记录,无改动不产噪音事件(对齐 create/update_status 的语义粒度)。
// source_ref="ui" 标识编辑来自前端 UI(未来可细分 detail/inbox,当前统一 ui)。
if !changed_fields.is_empty() {
KnowledgeTimeline::new(&state.db)
.record_updated(&id, &changed_fields, "ui")
.await;
}
Ok(record)
}

22
src-tauri/src/commands/knowledge_timeline.rs
View File

@@ -19,6 +19,11 @@ pub const EVENT_CREATED: &str = "created";
pub const EVENT_EXTRACTED: &str = "extracted";
pub const EVENT_STATUS_CHANGED: &str = "status_changed";
pub const EVENT_REFERENCED: &str = "referenced";
/// 编辑产生(人工/前端编辑 title/content/tags/confidence/reasoning)
/// P1 修复(KP-5 审计断档):knowledge_update 编辑路径此前无生命线事件,
/// 与 knowledge_create(created)/knowledge_update_status(status_changed) 不对称,
/// 详情页生命线在编辑后会断档。新增 updated 事件补齐。
pub const EVENT_UPDATED: &str = "updated";
/// 知识生命线记录器 — 持有 DB 句柄,提供便捷事件写入方法
///
@@ -67,6 +72,23 @@ impl KnowledgeTimeline {
self.fire(knowledge_id, EVENT_CREATED, Some("manual".into()), Some(ctx)).await;
}
/// 编辑产生(context: fields 改动字段列表 / source_ref 编辑入口溯源)
///
/// P1 修复(KP-5 审计断档):由 knowledge_update(编辑 title/content/tags/confidence/reasoning)
/// 调用,补齐编辑路径缺失的生命线事件(此前仅 create/update_status 有事件,编辑后生命线断档)。
/// - `fields`: 本次实际改动的字段名列表(如 ["title","tags"]),用于审计/展示改了什么
/// - `source_ref`: 编辑入口溯源,如 "ui:detail" / "ui:inbox",前端调用方传入
pub async fn record_updated(&self, knowledge_id: &str, fields: &[&str], source_ref: &str) {
let ctx = serde_json::json!({ "fields": fields }).to_string();
self.fire(
knowledge_id,
EVENT_UPDATED,
Some(source_ref.to_string()),
Some(ctx),
)
.await;
}
/// AI 对话提炼产生(context: conv_id / conv_title / reasoning)
///
/// F-260619-04 P1 消息级溯源:`message_id` 为末条 assistant 消息 id(本轮 AI 产出知识的载体)。

17
src-tauri/src/commands/task.rs
View File

@@ -33,18 +33,23 @@ fn default_priority() -> i32 {
/// 列出未删除任务(deleted_at IS NULL),可按 project_id 过滤。
///
/// 软删对标 projects:默认过滤回收站(语义与 list_projects 一致)。
/// 无 project_id 时调 list_active(WHERE deleted_at IS NULL);有 project_id 时
/// 先 list_active 再内存过滤 project_id(任务量小,无需 SQL 下推,避免新增专用查询方法)。
/// 有 project_id 时走 list_active_by_project(SQL 下推 WHERE deleted_at IS NULL AND
/// project_id = ?,避免旧 list_active 全表扫 + 内存 retain 的 N×M 热点);
/// 无 project_id 时 fallback list_active(列全部未删任务)。
/// 注意:不能用通用 query 宏——它不带 deleted_at 过滤,会把回收站任务也返回。
#[tauri::command]
pub async fn list_tasks(
state: State<'_, AppState>,
project_id: Option<String>,
) -> Result<Vec<TaskRecord>, String> {
let mut tasks = state.tasks.list_active().await.map_err(err_str)?;
if let Some(pid) = project_id {
tasks.retain(|t| t.project_id == pid);
}
let tasks = match project_id {
Some(pid) => state
.tasks
.list_active_by_project(&pid)
.await
.map_err(err_str)?,
None => state.tasks.list_active().await.map_err(err_str)?,
};
Ok(tasks)
}

27
src-tauri/src/commands/workflow.rs
View File

@@ -10,6 +10,10 @@ use tokio::sync::broadcast::error::RecvError;
use df_types::events::{WorkflowEvent, HumanApprovalResponse, SelectType};
use df_types::types::{new_id, NodeStatus};
use df_nodes::task_advance_node::advance_task_atomic;
// F-260616-06 ②-4: 工作流失败时按 target_status 推算任务退回态。
// regression_target 已收敛到 df-nodes::task_state_machine(状态机业务契约,单一可信源),
// 不再在 app crate 维护私有副本(防 DRY 漂移)。
use df_nodes::task_state_machine::regression_target;
// F-260616-06 ①-1: 空 dag + target_status 时按目标态自动选推进链模板
use df_nodes::task_workflow_templates::template_for;
use df_storage::crud::{TaskRepo, WorkflowRepo};
@@ -30,29 +34,6 @@ struct WorkflowEventPayload {
event: WorkflowEvent,
}
/// F-260616-06 ②-4: 工作流失败时按 target_status 推算任务退回态。
///
/// 映射表(失败退一步):
/// - testing → in_review
/// - in_review → in_progress
/// - in_progress → None(状态机禁止→todo,留 in_progress 等人介入)
/// - 其他(done/blocked/cancelled/todo 等) → None(无退回映射,跳过回调)
///
/// 设计选择:in_progress → None(而非 todo)。理由:状态机禁止 in_progress→todo
/// (task_state_machine.rs backward_to_todo_rejected),失败退回 todo 会被
/// advance_task_atomic 的 InvalidState 拦截,任务原地保留 in_progress 且无信号;
/// 改为 None 则回调跳过推进,留 in_progress 等人介入。
/// 起点状态 todo 无可退态 → None。
fn regression_target(target: &str) -> Option<&str> {
match target {
"testing" => Some("in_review"),
"in_review" => Some("in_progress"),
// in_progress 失败不自动退回(状态机不允许→todo),留 in_progress 等人介入
"in_progress" => None,
_ => None,
}
}
/// 触发工作流执行（核心命令）
///
/// 流程：build_dag 校验 → 写入执行记录(status=running) → 后台异步执行 →

5
src-tauri/src/lib.rs
View File

@@ -59,6 +59,7 @@ pub fn run() {
// BUG-260619-06 修复: clear 致冷启动 restore 重建审批丢失(restore 填充后 clear 无条件清空,
// 重启后待审批工具全丢)。改 retain 仅清非 recovered(本次会话/HMR 死 pending),
// 保留 restore 重建(recovered=true,audit.rs:331),对齐 switchConversation retain 保护意图。
// 阶段3a 单真相源合并:单表按 !recovered retain(kind 不区分,path 审批恢复恒无)。
session.pending_approvals.retain(|_, a| !a.recovered);
drop(session);
if was_generating {
@@ -119,6 +120,7 @@ pub fn run() {
commands::idea::update_idea,
commands::idea::delete_idea,
commands::idea::evaluate_idea,
commands::idea::list_idea_evaluations,
commands::idea::promote_idea,
// 工作流
commands::workflow::run_workflow,
@@ -161,6 +163,8 @@ pub fn run() {
commands::ai::ai_conversation_set_pinned,
commands::ai::ai_conversation_export,
commands::ai::ai_list_skills,
// 核心设计6: 热重载技能(invalidate + 重扫,不重启生效)
commands::ai::ai_reload_skills,
commands::ai::ai_set_concurrency_config,
commands::ai::ai_set_agent_max_iterations,
commands::ai::ai_set_agent_max_retries,
@@ -180,6 +184,7 @@ pub fn run() {
commands::knowledge::knowledge_record_reuse,
commands::knowledge::knowledge_list_candidates,
commands::knowledge::knowledge_archive,
commands::knowledge::knowledge_retry_embedding,
commands::knowledge::knowledge_get_config,
commands::knowledge::knowledge_save_config,
commands::knowledge::knowledge_extract_now,

320
src-tauri/src/state.rs
View File

@@ -11,7 +11,7 @@ use tokio::sync::{Mutex, RwLock, Semaphore};
use df_ai::ai_tools::AiToolRegistry;
use df_storage::crud::{
AiConversationRepo, AiMessageRepo, AiProviderRepo, AiToolExecutionRepo, IdeaRepo,
AiConversationRepo, AiMessageRepo, AiProviderRepo, AiToolExecutionRepo, IdeaEvalRepo, IdeaRepo,
KnowledgeEventsRepo, KnowledgeRepo, NodeExecutionRepo, ProjectRepo, ReleaseRepo,
SettingsRepo, TaskRepo, WorkflowRepo,
};
@@ -20,6 +20,7 @@ use df_workflow::eventbus::EventBus;
use df_workflow::registry::NodeRegistry;
use df_workflow::state::StateMachine;
use crate::commands::ai::augmentation::ResolverRegistry;
use crate::commands::ai::AiSession;
// ============================================================
@@ -32,13 +33,15 @@ use crate::commands::ai::AiSession;
pub enum ExtractTrigger {
/// 对话正常完成时(默认)
OnComplete,
/// 对话闲置 N 秒后
OnIdle,
/// 仅手动按钮触发
ManualOnly,
}
/// 知识库行为配置(存 AppState 内存,前后端通过 IPC 读写)
/// 知识库配置持久化 KV key(P0 设置走查-2026-06-21:原纯内存 Arc<Mutex> 启动 default 覆盖
/// 致 8 项配置重启全丢;save_config 落此 KV,init reload_knowledge_config 恢复)。
pub const KNOWLEDGE_CONFIG_KEY: &str = "df-knowledge-config";
/// 知识库行为配置(内存真相源 + Settings KV 持久化,前后端通过 IPC 读写)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KnowledgeConfig {
/// 提炼总开关,默认 true
@@ -47,8 +50,6 @@ pub struct KnowledgeConfig {
pub trigger_mode: ExtractTrigger,
/// 最少消息数守卫(防闲聊噪音),默认 4
pub min_messages: u32,
/// 闲置触发超时(ms),默认 30000
pub idle_timeout_ms: u64,
/// 聊天时自动注入相关知识开关,默认 true
pub auto_inject: bool,
/// 语义检索(向量)总开关,默认 false——关闭时纯 LIKE 零外部依赖
@@ -68,7 +69,6 @@ impl Default for KnowledgeConfig {
auto_extract: true,
trigger_mode: ExtractTrigger::OnComplete,
min_messages: 4,
idle_timeout_ms: 30_000,
auto_inject: true,
vector_enabled: false,
embedding_provider_id: None,
@@ -113,6 +113,26 @@ impl Default for KnowledgeConfig {
/// `acquire_for_provider` 返回 None(无限流,行为同 F-01 前)。零变化保证。
/// 全局容量 = min(sum(各 provider 上限), global_cap):由调用方在配置时约束
/// (set_provider_caps 传 min(sum, global_cap)),非运行时强约束。
///
/// ## Phase3 预留: per_sub_flow 层(批2-B,占位未接入)
/// `per_sub_flow` 为 HashMap<sub_flow_id, Arc<Semaphore>>,用于 Phase3 单对话并行多轮的
/// **子流并发上限**(单对话内并行 spawn 多条子流时,防子流数失控)。本批仅加层 + 占位,
/// **不接入调用点**(接入待 Phase3 子流 spawn 落地)。
///
/// **key 约定(文档化,非强约束)**:`sub_flow_id` 采用 `"{conv_id}::{sub_id}"` 格式,
/// 唯一标识某对话下的某条子流,便于 release_sub_flow 精确清理。
///
/// **三层语义**:
/// - per_sub_flow = 单对话内**子流**并发上限(每条子流一份 Semaphore,permits 默认 3,预留)
/// - per_conv = 单对话内**总**并发上限(permits 默认 2)
/// - global = 全应用**总**并发上限(permits 默认 3)
///
/// **理想配额(用户配置建议,非硬限)**: per_sub_permits ≤ per_conv_permits ≤ global_permits。
/// 实际限流由各层 Semaphore 自然保证:global Semaphore 硬限全应用并发不超 global permits
/// (跨对话 sum(per_conv) 可 > global,但 global acquire_owned 自然阻塞,不超卖)。
///
/// **acquire 语义(非阻塞)**:`acquire_per_sub_flow` 用 `try_acquire_owned`(非阻塞),
/// 耗尽返 None 降级串行——子流并行不阻塞主 loop(Phase3 子流 spawn 失败不拖垮整对话)。
#[derive(Clone)]
pub struct LlmConcurrency {
/// 全局 LLM 调用并发上限(permits 默认 3)：F-09 batch5 修正后回归原义,由各单次 LLM 调用点
@@ -129,6 +149,16 @@ pub struct LlmConcurrency {
/// F-260614-04: per-provider 信号量表。空 = 无 per-provider 限流(单 provider 路径零变化)。
/// Arc<Mutex<HashMap>>:运行时增删 provider 配置时替换/插入,acquire 时 clone Arc。
per_provider: Arc<Mutex<HashMap<String, Arc<Semaphore>>>>,
/// Phase3 预留(批2-B): per-sub_flow 信号量表。key = sub_flow_id(约定 "{conv_id}::{sub_id}")。
/// 空 = 无子流并发限流(Phase3 未接入时零变化)。acquire 用 try_acquire_owned(非阻塞),
/// 耗尽返 None 降级串行,子流并行不阻塞主 loop。
#[allow(dead_code)] // Phase3 子流 spawn 落地时接入调用点,本批仅占位。
per_sub_flow: Arc<Mutex<HashMap<String, Arc<Semaphore>>>>,
/// Phase3 预留(批2-B): 每子流并发上限(permits 默认 3,内部初始化,预留)。
/// AtomicUsize 支持运行时热改;set_per_sub_permits 同时清空 HashMap(软收敛,对齐 set_per_conv)。
/// new(global, per_conv) 签名保持向后兼容,per_sub_permits 内部 AtomicUsize::new(3)。
#[allow(dead_code)] // Phase3 子流 spawn 落地时接入调用点,本批仅占位。
per_sub_permits: Arc<AtomicUsize>,
}
impl LlmConcurrency {
@@ -138,6 +168,11 @@ impl LlmConcurrency {
per_conv: Arc::new(Mutex::new(HashMap::new())),
per_conv_permits: Arc::new(AtomicUsize::new(per_conv)),
per_provider: Arc::new(Mutex::new(HashMap::new())),
// Phase3 预留(批2-B): per_sub_flow 默认 permits=3,内部初始化。
// 签名保持 new(global, per_conv) 向后兼容;Phase3 接入后用户可经
// set_per_sub_permits 热改(配置化待后续批,本批仅占位)。
per_sub_flow: Arc::new(Mutex::new(HashMap::new())),
per_sub_permits: Arc::new(AtomicUsize::new(3)),
}
}
@@ -185,6 +220,62 @@ impl LlmConcurrency {
self.per_conv.lock().await.clear();
}
// ============================================================
// Phase3 预留(批2-B): per_sub_flow 层 — 占位未接入调用点
// ============================================================
/// Phase3 预留(批2-B): 取单子流内并发 permit(非阻塞)。
///
/// 按 `sub_flow_id` 取/建 Semaphore(permits=当前 per_sub_permits,默认 3)。
/// lock HashMap → 无则建(or_insert_with, permits 取 per_sub_permits 当前值)
/// → clone Arc → 释放 lock → **try_acquire_owned**(非阻塞)。
///
/// **非阻塞语义(关键)**:用 try_acquire_owned 而非 acquire_owned——耗尽返 None
/// 调用方降级串行处理,子流并行不阻塞主 loop(Phase3 子流 spawn 失败不拖垮整对话)。
///
/// - 返 `Ok(Some(permit))`:成功获取,permit 随 Drop 自动释放。
/// - 返 `Ok(None)`:子流并发已耗尽,调用方降级串行(非错误)。
///
/// **key 约定**:`sub_flow_id` 采用 `"{conv_id}::{sub_id}"` 格式(文档化,调用方组装)。
/// 锁持有短(不含 try_acquire),对齐 acquire_per_conv 模式。
#[allow(dead_code)] // Phase3 子流 spawn 落地时接入调用点,本批仅占位。
pub async fn acquire_per_sub_flow(
&self,
sub_flow_id: &str,
) -> Option<tokio::sync::OwnedSemaphorePermit> {
let sema = {
let mut map = self.per_sub_flow.lock().await;
let permits = self.per_sub_permits.load(std::sync::atomic::Ordering::SeqCst);
map.entry(sub_flow_id.to_string())
.or_insert_with(|| Arc::new(Semaphore::new(permits)))
.clone()
};
// try_acquire_owned 非阻塞:Err(NoPermits) 返 None 降级串行,不阻塞主 loop。
// 对齐 acquire_global/per_conv 的 expect 前提:Semaphore 不会 close(无 close() 调用)。
sema.try_acquire_owned().ok()
}
/// Phase3 预留(批2-B): 子流完成清理。remove 该 sub_flow 的 Semaphore 条目(防 HashMap 无限增长)。
///
/// **对齐 release_conv 模式**:remove 后已持 permit 不受影响(permit 绑旧 Arc,随 Drop 释放),
/// 仅阻止新条目累积。时机由调用方判断(Phase3 子流退出点)。
#[allow(dead_code)] // Phase3 子流 spawn 落地时接入调用点,本批仅占位。
pub async fn release_sub_flow(&self, sub_flow_id: &str) {
self.per_sub_flow.lock().await.remove(sub_flow_id);
}
/// Phase3 预留(批2-B): 热改 per_sub_flow permits 上限。
///
/// 行为(对齐 set_per_conv):更新 per_sub_permits(AtomicUsize) + 清空 HashMap(软收敛:
/// 旧 permit 随 Drop 释放,新子流 acquire 用新 permits 值重建 Semaphore)。已建子流若仍在跑,
/// 旧 Semaphore 不变;下次该 sub_flow 新 acquire 时因 HashMap 已清空会重建为新 permits。
#[allow(dead_code)] // Phase3 子流 spawn 落地时接入调用点,本批仅占位。
pub async fn set_per_sub_permits(&self, permits: usize) {
self.per_sub_permits
.store(permits, std::sync::atomic::Ordering::SeqCst);
self.per_sub_flow.lock().await.clear();
}
/// F-260614-04: 取 per-provider 并发 permit(可选)。
///
/// - provider 在 `per_provider` 表中有配置 → 取其 Semaphore permit,返回 Some。
@@ -240,6 +331,8 @@ pub struct AppState {
pub db: Arc<Database>,
/// 灵感表 Repo
pub ideas: IdeaRepo,
/// 灵感评估历史表 Repo(追加型审计表,每次 AI 评估追加一行快照,可追溯历史)
pub idea_evaluations: IdeaEvalRepo,
/// 项目表 Repo
pub projects: ProjectRepo,
/// 任务表 Repo
@@ -267,6 +360,10 @@ pub struct AppState {
pub ai_tool_executions: AiToolExecutionRepo,
/// AI 工具注册表
pub ai_tools: Arc<AiToolRegistry>,
/// Input Augmentation 层 Mention Resolver 注册表(核心设计2):
/// 按 MentionRef kind 分发(project/task/idea/skill),resolve_all 单条失败不阻断整批。
/// 启动期 build 一次性注册四 resolver(持 db Arc 访问 repo),通过 Arc 共享只读。
pub resolvers: Arc<ResolverRegistry>,
/// AI 会话状态
pub ai_session: Arc<Mutex<AiSession>>,
// ── 知识库 ──
@@ -351,19 +448,24 @@ impl AllowedDirs {
/// `\Windows\System32` / `\Program Files\`;Unix `/etc /usr /bin /sbin /boot
/// /dev /proc /sys`)仍拒。黑名单优先于白名单,防用户误授权系统目录。
///
/// 输入 `candidate` 应为 canonicalize 后的真实路径(防 symlink 逃逸);
/// 调用方(resolve_workspace_path_with_allowed)负责 canonicalize,本函数只做 starts_with 比对。
/// 输入 `candidate` 理想为 canonicalize 后的真实路径(防 symlink 逃逸);调用方
/// (resolve_workspace_path_with_allowed)负责 canonicalize。但词法层预校验
/// (`check_path_authorization`)**故意不 canonicalize**(路径可能不存在,如 write_file 新建),
/// 会传入未归一的词法路径 → 与白名单(canonicalize 后)形态不对齐 → 已授权路径反复误弹窗。
/// 故本函数内部 best-effort canonicalize 兜底(失败回退词法),消除所有调用方形态差异。
/// 白名单仍是唯一真相源,canonicalize 不引入新放行,顺带解析 symlink 增强(非削弱)防逃逸。
pub fn is_authorized(&self, candidate: &Path) -> bool {
// Phase C: 黑名单优先(白名单命中也拒)。validate_path 已挡 .ssh/.aws 等,
// 此处补系统核心目录(用户可能误把 C:\ 加入 persistent,黑名单兜底拒 System32)。
if is_in_system_blacklist(candidate) {
return false;
}
// F-260620: 比对侧统一 strip_verbatim 收口。candidate 可能带 \\?\ 前缀
// (handler canonicalize 后)或正斜杠(词法层 LLM 传入),white list 条目已是
// strip+canonicalize 后的 E:\... 形态。单点 strip 消除所有调用方形态不一致
// (误弹窗核心根因 — 此前 strip_verbatim 仅写入侧调用,比对侧遗漏)。
let cand = strip_verbatim(candidate.to_path_buf());
// F-260620 比对侧收口(误弹窗核心根因):白名单 persistent/session 是 canonicalize 后形态,
// candidate 来自两类调用方形态不一(handler canonicalize 后 / 预校验词法未 canonicalize)。
// 仅 strip_verbatim(去 \\?\ 前缀)不够——盘符大小写/.. /symlink/分隔符差异仍让 starts_with
// 失败。best_effort_canonicalize 把 candidate 归一到真实路径(失败回退词法,不阻断合法访问),
// 再 strip_verbatim 去前缀,使比对双侧形态完全对齐。e2ece2d 只收口 verbatim 前缀漏了这步。
let cand = strip_verbatim(best_effort_canonicalize(candidate));
self.persistent.iter().any(|d| cand.starts_with(d))
|| self.session.iter().any(|d| cand.starts_with(d))
}
@@ -482,6 +584,29 @@ fn strip_verbatim(p: PathBuf) -> PathBuf {
p
}
/// best-effort canonicalize:把任意形态路径(词法/正斜杠/含../大小写不一)归一到真实路径,
/// 供 `is_authorized` 与白名单(canonicalize 后)比对侧形态对齐(误弹窗根因修复)。
///
/// - 路径存在 → `canonicalize` 成功,返回真实路径(大小写归一/.. 解析/symlink 解析/去冗余分隔符)
/// - 路径不存在(write_file 新建文件)→ canonicalize 其**父目录**(通常存在)+ 拼回文件名,
/// 父目录也不存在 → 回退原词法路径(交由 strip_verbatim + starts_with 尽力匹配,不阻断)
///
/// 失败一律回退,绝不返回 Err——授权比对宁可降级匹配不可 panic/阻断合法访问。
fn best_effort_canonicalize(p: &Path) -> PathBuf {
if let Ok(real) = std::fs::canonicalize(p) {
return real;
}
if let Some(parent) = p.parent() {
if let Ok(real_parent) = std::fs::canonicalize(parent) {
if let Some(file_name) = p.file_name() {
return real_parent.join(file_name);
}
return real_parent;
}
}
p.to_path_buf()
}
/// workspace 根目录(src-tauri 上两级,与 tool_registry::workspace_root 同源)。
///
/// ⚠️ 已知限制:env!("CARGO_MANIFEST_DIR") 是编译期写死编译机源码路径,打包分发后用户机器
@@ -504,11 +629,16 @@ impl AppState {
// 此处用 default_with_root 占位,下方 init 尾部 reload_allowed_dirs 从 Settings KV 覆盖。
let allowed_dirs = Arc::new(RwLock::new(AllowedDirs::default_with_root()));
let ai_tools = Arc::new(crate::commands::ai::build_ai_tool_registry(&db, &allowed_dirs));
// Input Augmentation 层(核心设计2):ResolverRegistry 启动期注册四 resolver。
// resolver 持 Arc<Database>(非 AppState,避免循环依赖:AppState 持 Arc<ResolverRegistry>),
// 在 struct 字段 `db` move 前 clone 注入,与 build_ai_tool_registry 同侧。
let resolvers = Arc::new(crate::commands::ai::build_resolver_registry(db.clone()));
// build_registry 需注入 Arc<Database>(TaskAdvanceNode 持 db)。
// 在 struct 字段 `db` move 前 clone,避免 E0382。
let registry = Arc::new(build_registry(db.clone()));
let state = Self {
ideas: IdeaRepo::new(&db),
idea_evaluations: IdeaEvalRepo::new(&db),
projects: ProjectRepo::new(&db),
tasks: TaskRepo::new(&db),
releases: ReleaseRepo::new(&db),
@@ -537,6 +667,7 @@ impl AppState {
event_bus: EventBus::new(),
registry,
ai_tools,
resolvers,
};
// 启动恢复:重启前卡 pending 的工具审批(内存 pending_approvals 已丢)从审计表重建,
// 使重启后待审批不丢。前端经 ai_pending_tool_calls + switchConversation 恢复 toolCard 态。
@@ -551,6 +682,8 @@ impl AppState {
// F-260619-03 Phase A: 从 Settings KV 加载持久化授权目录白名单覆盖默认值。
// 失败(读 KV/解析 JSON 出错)不阻断启动,保持 default_with_root(仅 workspace_root)。
state.reload_allowed_dirs().await;
// P0(设置走查):从 Settings KV 恢复持久化知识库配置覆盖 default(防 8 项重启全丢)。
state.reload_knowledge_config().await;
Ok(state)
}
@@ -577,6 +710,23 @@ impl AppState {
self.llm_concurrency.set_provider_caps(caps).await;
}
/// P0(设置走查-2026-06-21):从 Settings KV 加载持久化知识库配置覆盖默认值。
///
/// 原纯内存 knowledge_config 启动 default() 覆盖致用户配置重启全丢;save_config 落
/// KNOWLEDGE_CONFIG_KEY KV,本方法启动恢复。失败(读 KV/反序列化)不阻断启动,保持 default。
pub async fn reload_knowledge_config(&self) {
match self.settings.get(KNOWLEDGE_CONFIG_KEY).await {
Ok(Some(json)) => match serde_json::from_str::<KnowledgeConfig>(&json) {
Ok(cfg) => *self.knowledge_config.lock().await = cfg,
Err(e) => tracing::warn!(
"[KNOWLEDGE-CONFIG] KV 反序列化失败,保持 default: {}", e
),
},
Ok(None) => {} // 首次启动无持久化,保持 default
Err(e) => tracing::warn!("[KNOWLEDGE-CONFIG] 读 KV 失败,保持 default: {}", e),
}
}
/// F-260619-03 Phase A: 从 Settings KV `allowed_dirs`(JSON 字符串数组)加载持久化白名单。
///
/// 启动 + Settings IPC `ai_set_allowed_dirs` 写入后调用。解析失败/缺失 → 保持
@@ -659,18 +809,9 @@ impl AppState {
self.settings.set(AllowedDirs::SETTINGS_KEY, &json).await
.map_err(|e| anyhow::anyhow!("持久化 allowed_dirs 失败: {}", e))?;
self.reload_allowed_dirs().await;
// 返回内存白名单的规范化字符串列表(过滤 workspace_root,与 get_allowed_dirs 一致:
// 内部根不暴露前端,前端回显只含用户显式配置的目录)
let root = workspace_root_path();
let guard = self.allowed_dirs.read().await;
let mut out: Vec<String> = guard
.persistent
.iter()
.filter(|p| **p != root)
.map(|p| p.to_string_lossy().to_string())
.collect();
out.sort();
Ok(out)
// 返回内存白名单的规范化字符串列表:复用 get_allowed_dirs(单一真相源,
// 消除原 9 行逐字重复——过滤 workspace_root + sort,语义完全一致)。
Ok(self.get_allowed_dirs().await)
}
/// F-260619-03 Phase A: 读内存白名单为字符串列表(供 Settings IPC `ai_get_allowed_dirs` 回显)。
@@ -1002,5 +1143,132 @@ mod tests {
assert!(!is_in_system_blacklist(&PathBuf::from("E:\\wk-lab\\devflow\\src")));
assert!(!is_in_system_blacklist(&PathBuf::from("D:\\backup\\appdata\\data")));
}
// ============================================================
// Phase3 预留(批2-B): LlmConcurrency per_sub_flow 层测试
// 占位层:acquire_per_sub_flow / release_sub_flow / set_per_sub_permits。
// 不接入 ai/ 调用点(Phase3 子流 spawn 落地时接入),此处仅验证层本身语义。
// ============================================================
/// 基本 acquire/drop:首次 acquire 返 Some,Drop 后 permit 释放可再 acquire。
#[tokio::test]
async fn test_per_sub_flow_basic_acquire_drop() {
let lc = LlmConcurrency::new(3, 2);
let sub = "conv-1::sub-1";
// 首次 acquire 返 Some(permits=3 默认)。
let p1 = lc.acquire_per_sub_flow(sub).await;
assert!(p1.is_some(), "首次 acquire 应返回 Some");
// Drop 后 permit 释放,可再 acquire。
drop(p1);
let p2 = lc.acquire_per_sub_flow(sub).await;
assert!(p2.is_some(), "Drop 后再 acquire 应返回 Some");
}
/// 耗尽返 None:permits=1 时二次 acquire 返 None 降级串行(非阻塞)。
#[tokio::test]
async fn test_per_sub_flow_exhausted_returns_none() {
let lc = LlmConcurrency::new(3, 2);
let sub = "conv-1::sub-1";
// 先热改 per_sub_permits=1 再 acquire(热改清 HashMap,新 sub_flow 用 permits=1)。
lc.set_per_sub_permits(1).await;
let p1 = lc.acquire_per_sub_flow(sub).await;
assert!(p1.is_some(), "permits=1 首次 acquire 应返回 Some");
// permits=1 已被 p1 占用,二次 acquire 非阻塞返 None 降级串行。
let p2 = lc.acquire_per_sub_flow(sub).await;
assert!(p2.is_none(), "permits=1 二次 acquire 应返回 None(降级串行)");
// Drop p1 后释放,再 acquire 可成功(证明 None 是因耗尽,非 Semaphore close)。
drop(p1);
let p3 = lc.acquire_per_sub_flow(sub).await;
assert!(p3.is_some(), "Drop 后再 acquire 应返回 Some");
}
/// 不同 sub_flow_id 独立限流:A 耗尽不影响 B。
#[tokio::test]
async fn test_per_sub_flow_independent_per_id() {
let lc = LlmConcurrency::new(3, 2);
// permits=1:A 和 B 各自独立 Semaphore。
lc.set_per_sub_permits(1).await;
let pa = lc.acquire_per_sub_flow("conv-1::sub-A").await;
let pb = lc.acquire_per_sub_flow("conv-1::sub-B").await;
assert!(pa.is_some(), "sub-A 首次 acquire 应返回 Some");
assert!(pb.is_some(), "sub-B 首次 acquire 应返回 Some(独立限流,A 不影响 B)");
// A 二次耗尽,B 二次也耗尽(各自 permits=1)。
assert!(lc.acquire_per_sub_flow("conv-1::sub-A").await.is_none());
assert!(lc.acquire_per_sub_flow("conv-1::sub-B").await.is_none());
}
/// release_sub_flow 清理 HashMap:release 后再 acquire 会重建 Semaphore(permits 重置)。
#[tokio::test]
async fn test_per_sub_flow_release_clears_entry() {
let lc = LlmConcurrency::new(3, 2);
lc.set_per_sub_permits(1).await;
let sub = "conv-1::sub-1";
let p1 = lc.acquire_per_sub_flow(sub).await;
assert!(p1.is_some());
// release 清理 HashMap 条目(p1 permit 仍有效,绑旧 Arc)。
lc.release_sub_flow(sub).await;
// 再 acquire:HashMap 已清空 → 重建 Semaphore(permits=1)→ 返 Some。
// 证明 release 移除了条目(否则旧 Semaphore 已耗尽会返 None)。
let p2 = lc.acquire_per_sub_flow(sub).await;
assert!(p2.is_some(), "release 后再 acquire 应重建 Semaphore 返回 Some");
drop(p1);
drop(p2);
}
/// set_per_sub_permits 软收敛:热改后新 sub_flow 用新 permits 值。
#[tokio::test]
async fn test_set_per_sub_permits_soft_converge() {
let lc = LlmConcurrency::new(3, 2);
// 默认 permits=3:可连续 3 个 Some,第 4 个 None。
let sub = "conv-1::sub-1";
let p1 = lc.acquire_per_sub_flow(sub).await;
let p2 = lc.acquire_per_sub_flow(sub).await;
let p3 = lc.acquire_per_sub_flow(sub).await;
let p4 = lc.acquire_per_sub_flow(sub).await;
assert!(p1.is_some() && p2.is_some() && p3.is_some());
assert!(p4.is_none(), "默认 permits=3,第 4 个应返回 None");
drop(p1);
drop(p2);
drop(p3);
drop(p4);
// 热改 permits=2 + 清空 HashMap(软收敛)。
lc.set_per_sub_permits(2).await;
// 新 sub_flow(HashMap 已清空)用新 permits=2:第 3 个 None。
let q1 = lc.acquire_per_sub_flow(sub).await;
let q2 = lc.acquire_per_sub_flow(sub).await;
let q3 = lc.acquire_per_sub_flow(sub).await;
assert!(q1.is_some() && q2.is_some(), "热改 permits=2 后前两个应返回 Some");
assert!(q3.is_none(), "permits=2 第三个应返回 None(软收敛生效)");
}
/// CAS 竞态:多并发 acquire 不超卖 — permits=N 时最多 N 个 Some。
/// 用 try_acquire_owned(非阻塞)模拟瞬时并发,N 个 Some 后其余全 None。
#[tokio::test]
async fn test_per_sub_flow_no_oversell_under_concurrency() {
let lc = LlmConcurrency::new(3, 2);
let n = 5usize;
lc.set_per_sub_permits(n).await;
let sub = "conv-1::sub-1";
// 串行连续 acquire n+3 次:前 n 个 Some,后 3 个 None(非阻塞)。
let mut some_count = 0usize;
let mut held: Vec<tokio::sync::OwnedSemaphorePermit> = Vec::with_capacity(n + 3);
for _ in 0..(n + 3) {
if let Some(permit) = lc.acquire_per_sub_flow(sub).await {
some_count += 1;
held.push(permit);
}
}
assert_eq!(some_count, n, "permits={n} 时最多 {n} 个 Some,不超卖");
// held 持有 n 个 permit,其余 acquire 全 None(已验证 some_count=n)。
// Drop 全部后,可再 acquire n 个(证明超卖未发生,Semaphore 计数正确)。
drop(held);
let mut some_count2 = 0usize;
for _ in 0..n {
if lc.acquire_per_sub_flow(sub).await.is_some() {
some_count2 += 1;
}
}
assert_eq!(some_count2, n, "Drop 全部后应可再 acquire {n} 个");
}
}