新增: 工具工作流补全(diff_files工具 + 技能清单注入 + 工作流进度共享 + human端到端测试 + 知识库MCP工具)
This commit is contained in:
+252
-2
@@ -15,9 +15,9 @@
|
||||
// name→id 解析:src-tauri 有机制层解析(audit/mod.rs auto_resolve),MCP 面暂不同步。
|
||||
use std::sync::{Arc, OnceLock};
|
||||
|
||||
use df_storage::crud::{IdeaQuery, IdeaRepo, ProjectQuery, ProjectRepo, TaskQuery, TaskRepo};
|
||||
use df_storage::crud::{IdeaQuery, IdeaRepo, KnowledgeRepo, ProjectQuery, ProjectRepo, TaskQuery, TaskRepo};
|
||||
use df_storage::db::Database;
|
||||
use df_storage::models::{IdeaRecord, ProjectRecord, TaskRecord};
|
||||
use df_storage::models::{IdeaRecord, KnowledgeRecord, ProjectRecord, TaskRecord};
|
||||
use df_types::types::{IdeaStatus, ProjectStatus, TaskStatus, new_id};
|
||||
use futures::future::BoxFuture;
|
||||
use serde_json::{json, Value};
|
||||
@@ -123,6 +123,22 @@ pub fn all_tools() -> &'static Vec<&'static ToolSpec> {
|
||||
spec("score_idea", "评分并写库(Medium 风险+审计日志):对想法做启发式评估,把 scores 写回 DB 并返回更新后的记录", object_schema(json!({"id": str_field("想法 ID"), "expected_updated_at": int_field("乐观锁版本(可空):上次读取到的 updated_at 毫秒时间戳,不一致则拒绝写入")}), &["id"]), Medium, score_idea),
|
||||
// ─── 工作流(High) ───
|
||||
spec("run_workflow", "触发工作流——High 风险,默认拒绝,请在 DevFlow 应用内执行", object_schema(json!({"project_id": str_field("项目 ID"), "task_id": opt_str_field("任务 ID(可空)")}), &["project_id"]), High, run_workflow),
|
||||
// ─── 知识库 ───
|
||||
spec("search_knowledge", "检索知识库:按关键词 LIKE 匹配 title/content(可选 kind/limit);传 query_embedding 数组则走向量检索(余弦相似度 top-N)", object_schema(json!({
|
||||
"query": str_field("检索关键词"),
|
||||
"kind": opt_str_field("知识类型过滤(可空):review_rule/prompt_template/pitfall/architecture_pattern/diagnosis/deployment_note/workflow_optimization"),
|
||||
"limit": int_field("返回上限(可空,默认 5,上限 10)"),
|
||||
"query_embedding": json!({ "type": "array", "items": { "type": "number" }, "description": "查询向量(可空,传则走向量检索)" })
|
||||
}), &["query"]), Low, search_knowledge),
|
||||
spec("insert_knowledge", "新增知识条目(Medium 风险,默认允许+审计日志;状态恒为 candidate,审核发布后才参与检索)", object_schema(json!({
|
||||
"kind": str_field("知识类型:review_rule/prompt_template/pitfall/architecture_pattern/diagnosis/deployment_note/workflow_optimization"),
|
||||
"title": str_field("标题"),
|
||||
"content": str_field("内容"),
|
||||
"tags": opt_str_field("标签 JSON 数组字符串(可空)"),
|
||||
"source_project": opt_str_field("来源项目(可空)"),
|
||||
"source_ref": opt_str_field("来源引用(可空,如 conv:{id})"),
|
||||
"confidence": opt_str_field("置信度(可空:high/medium/low)")
|
||||
}), &["kind", "title", "content"]), Medium, insert_knowledge),
|
||||
// ─── 回收站 ───
|
||||
spec("list_trash", "列出回收站(deleted_at IS NOT NULL 的项目与任务)", object_schema(json!({}), &[]), Low, list_trash),
|
||||
spec("restore_project", "从回收站恢复项目(Medium 风险+审计日志)", object_schema(json!({"id": str_field("项目 ID")}), &["id"]), Medium, restore_project),
|
||||
@@ -980,6 +996,126 @@ fn restore_project(ctx: &Ctx, args: Value) -> BoxFuture<'static, CallToolResult>
|
||||
})
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// handler 实现 — 知识库(复用 df-storage KnowledgeRepo)
|
||||
// ============================================================
|
||||
//
|
||||
// 分层存储(Tier 2/3:热/温/冷知识分级)需单独设计,本批只接 Tier 1 扁平
|
||||
// KnowledgeRepo(单表 + 向量列),不引入存储分层。
|
||||
|
||||
/// 7 种合法知识类型(对齐 migrations.rs V7 建表注释)。
|
||||
const KNOWLEDGE_KINDS: &[&str] = &[
|
||||
"review_rule", "prompt_template", "pitfall", "architecture_pattern",
|
||||
"diagnosis", "deployment_note", "workflow_optimization",
|
||||
];
|
||||
|
||||
/// 检索知识(Low 只读):默认关键词 LIKE(title/content),可选 kind/limit;
|
||||
/// 传 query_embedding(数组)则走向量检索(余弦 top-N),返回带相似度。
|
||||
/// 向量由调用方生成(MCP 无 AI provider 上下文),与 GUI 的 hybrid_search 共用
|
||||
/// KnowledgeRepo::search_vector,结果一致只做列裁剪。
|
||||
fn search_knowledge(ctx: &Ctx, args: Value) -> BoxFuture<'static, CallToolResult> {
|
||||
let db = ctx.db.clone();
|
||||
let query = match arg_str(&args, "query") {
|
||||
Ok(v) => v,
|
||||
Err(r) => return Box::pin(std::future::ready(r)),
|
||||
};
|
||||
let kind = args.get("kind").and_then(|v| v.as_str()).map(|s| s.to_owned());
|
||||
let limit = args
|
||||
.get("limit")
|
||||
.and_then(|v| v.as_i64())
|
||||
.map(|i| i.max(1) as usize)
|
||||
.unwrap_or(5)
|
||||
.min(10);
|
||||
let query_vec: Option<Vec<f32>> = args
|
||||
.get("query_embedding")
|
||||
.and_then(|v| v.as_array())
|
||||
.map(|arr| arr.iter().filter_map(|n| n.as_f64()).map(|f| f as f32).collect());
|
||||
Box::pin(async move {
|
||||
let repo = KnowledgeRepo::new(&db);
|
||||
match query_vec {
|
||||
Some(vec) => {
|
||||
if vec.is_empty() {
|
||||
return CallToolResult::error("query_embedding 不能为空数组");
|
||||
}
|
||||
match repo.search_vector(&vec, limit).await {
|
||||
Ok(hits) => {
|
||||
let hits: Vec<Value> = hits
|
||||
.into_iter()
|
||||
.map(|(rec, score)| json!({
|
||||
"score": (score * 1000.0).round() / 1000.0,
|
||||
"knowledge": rec
|
||||
}))
|
||||
.collect();
|
||||
json_ok(json!({ "count": hits.len(), "hits": hits }))
|
||||
}
|
||||
Err(e) => err_str(e),
|
||||
}
|
||||
}
|
||||
None => match repo.search(&query, kind.as_deref(), limit).await {
|
||||
Ok(list) => json_ok(json!({ "count": list.len(), "knowledge": list })),
|
||||
Err(e) => err_str(e),
|
||||
},
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// 新增知识条目(Medium 写库):状态恒为 candidate(审核发布后才参与检索,
|
||||
/// 对齐 GUI knowledge_create 语义),不自动生成嵌入(嵌入由发布链路处理)。
|
||||
fn insert_knowledge(ctx: &Ctx, args: Value) -> BoxFuture<'static, CallToolResult> {
|
||||
let db = ctx.db.clone();
|
||||
let kind = match arg_str(&args, "kind") {
|
||||
Ok(v) => v,
|
||||
Err(r) => return Box::pin(std::future::ready(r)),
|
||||
};
|
||||
let title = match arg_str(&args, "title") {
|
||||
Ok(v) => v,
|
||||
Err(r) => return Box::pin(std::future::ready(r)),
|
||||
};
|
||||
let content = match arg_str(&args, "content") {
|
||||
Ok(v) => v,
|
||||
Err(r) => return Box::pin(std::future::ready(r)),
|
||||
};
|
||||
let tags = args.get("tags").and_then(|v| v.as_str()).map(|s| s.to_owned());
|
||||
let source_project = args.get("source_project").and_then(|v| v.as_str()).map(|s| s.to_owned());
|
||||
let source_ref = args.get("source_ref").and_then(|v| v.as_str()).map(|s| s.to_owned());
|
||||
let confidence = args.get("confidence").and_then(|v| v.as_str()).map(|s| s.to_owned());
|
||||
medium_audit("insert_knowledge", &title);
|
||||
Box::pin(async move {
|
||||
if !KNOWLEDGE_KINDS.contains(&kind.as_str()) {
|
||||
return CallToolResult::error(format!(
|
||||
"非法知识类型: {kind}, 有效值: {}",
|
||||
KNOWLEDGE_KINDS.join("/")
|
||||
));
|
||||
}
|
||||
if title.trim().is_empty() || content.trim().is_empty() {
|
||||
return CallToolResult::error("title/content 不能为空");
|
||||
}
|
||||
let now = now_millis();
|
||||
let rec = KnowledgeRecord {
|
||||
id: new_id(),
|
||||
kind,
|
||||
title,
|
||||
content,
|
||||
tags,
|
||||
status: "candidate".to_string(),
|
||||
confidence,
|
||||
reuse_count: 0,
|
||||
verified: false,
|
||||
source_project,
|
||||
source_ref,
|
||||
reasoning: None,
|
||||
embedding_status: None,
|
||||
created_at: now.clone(),
|
||||
updated_at: now,
|
||||
};
|
||||
let repo = KnowledgeRepo::new(&db);
|
||||
match repo.insert(rec.clone()).await {
|
||||
Ok(id) => json_ok(json!({ "id": id, "knowledge": rec })),
|
||||
Err(e) => err_str(e),
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// 单测:evaluate_idea(只读,不写库)/ score_idea(写库)/ 风险契约
|
||||
// ============================================================
|
||||
@@ -1079,6 +1215,30 @@ mod tests {
|
||||
repo.insert(rec).await.unwrap()
|
||||
}
|
||||
|
||||
/// 插入一条知识,返回 id(search_knowledge 测试用;status=published 才进检索)
|
||||
async fn seed_knowledge(ctx: &Ctx, title: &str, content: &str, kind: &str) -> String {
|
||||
let repo = KnowledgeRepo::new(&ctx.db);
|
||||
let now = now_millis();
|
||||
let rec = KnowledgeRecord {
|
||||
id: new_id(),
|
||||
kind: kind.to_owned(),
|
||||
title: title.to_owned(),
|
||||
content: content.to_owned(),
|
||||
tags: None,
|
||||
status: "published".to_string(),
|
||||
confidence: Some("high".to_owned()),
|
||||
reuse_count: 0,
|
||||
verified: true,
|
||||
source_project: None,
|
||||
source_ref: None,
|
||||
reasoning: None,
|
||||
embedding_status: None,
|
||||
created_at: now.clone(),
|
||||
updated_at: now,
|
||||
};
|
||||
repo.insert(rec).await.unwrap()
|
||||
}
|
||||
|
||||
/// 读当前 DB 中的 idea.scores(原始字符串)
|
||||
async fn db_scores(ctx: &Ctx, id: &str) -> Option<String> {
|
||||
IdeaRepo::new(&ctx.db)
|
||||
@@ -1557,4 +1717,94 @@ mod tests {
|
||||
let stack = v["project"]["stack"].as_str().unwrap_or_default();
|
||||
assert!(stack.contains("rust"), "应探测到 rust 技术栈,实际 stack: {stack}");
|
||||
}
|
||||
|
||||
// ── 知识库工具(search_knowledge Low / insert_knowledge Medium)────────────
|
||||
|
||||
/// search_knowledge:关键词命中已发布知识,返回记录列表(不写库,只读契约)。
|
||||
#[tokio::test]
|
||||
async fn search_knowledge_keyword_returns_hits() {
|
||||
let ctx = test_ctx().await;
|
||||
seed_knowledge(&ctx, "Rust 异步模型", "tokio 运行时与并发", "pitfall").await;
|
||||
|
||||
let r = search_knowledge(&ctx, json!({ "query": "tokio" })).await;
|
||||
assert!(r.is_error.is_none(), "{:?}", text_of(&r));
|
||||
let v = json_of(&r);
|
||||
assert_eq!(v["count"], 1);
|
||||
assert_eq!(v["knowledge"][0]["title"], "Rust 异步模型");
|
||||
}
|
||||
|
||||
/// search_knowledge:缺 query 必填参数 → 报错。
|
||||
#[tokio::test]
|
||||
async fn search_knowledge_missing_query_errors() {
|
||||
let ctx = test_ctx().await;
|
||||
let r = search_knowledge(&ctx, json!({})).await;
|
||||
assert_eq!(r.is_error, Some(true));
|
||||
assert!(text_of(&r).contains("缺少必填参数"));
|
||||
}
|
||||
|
||||
/// search_knowledge:传入 query_embedding → 向量检索,返回带 score 的命中。
|
||||
#[tokio::test]
|
||||
async fn search_knowledge_vector_with_embedding() {
|
||||
let ctx = test_ctx().await;
|
||||
let id = seed_knowledge(&ctx, "Rust 异步", "tokio 并发模型", "pitfall").await;
|
||||
// 写一条向量(f32 数组,维度 3),search_vector 才能命中
|
||||
KnowledgeRepo::new(&ctx.db).set_embedding(&id, &[0.1, 0.2, 0.3]).await.unwrap();
|
||||
|
||||
let r = search_knowledge(&ctx, json!({
|
||||
"query": "ignored", // 有 embedding 时 query 仅作占位,检索走向量
|
||||
"query_embedding": [0.1, 0.2, 0.3]
|
||||
})).await;
|
||||
assert!(r.is_error.is_none(), "{:?}", text_of(&r));
|
||||
let v = json_of(&r);
|
||||
assert_eq!(v["count"], 1);
|
||||
assert!(v["hits"][0]["score"].is_number());
|
||||
assert_eq!(v["hits"][0]["knowledge"]["id"], id);
|
||||
}
|
||||
|
||||
/// insert_knowledge:创建成功,状态恒 candidate(待审核),DB 可读回。
|
||||
#[tokio::test]
|
||||
async fn insert_knowledge_creates_candidate() {
|
||||
let ctx = test_ctx().await;
|
||||
let r = insert_knowledge(&ctx, json!({
|
||||
"kind": "pitfall",
|
||||
"title": "MCP 超时",
|
||||
"content": "审批响应须带 execution_id 匹配",
|
||||
"tags": "[\"mcp\",\"workflow\"]"
|
||||
})).await;
|
||||
assert!(r.is_error.is_none(), "{:?}", text_of(&r));
|
||||
let v = json_of(&r);
|
||||
let id = v["id"].as_str().unwrap().to_string();
|
||||
assert_eq!(v["knowledge"]["status"], "candidate");
|
||||
assert_eq!(v["knowledge"]["reuse_count"], 0);
|
||||
let persisted = KnowledgeRepo::new(&ctx.db).get_by_id(&id).await.unwrap();
|
||||
assert!(persisted.is_some(), "DB 应能读回新建知识");
|
||||
assert_eq!(persisted.unwrap().status, "candidate");
|
||||
}
|
||||
|
||||
/// insert_knowledge:非法 kind / 空 title → 报错(不落库)。
|
||||
#[tokio::test]
|
||||
async fn insert_knowledge_invalid_input_errors() {
|
||||
let ctx = test_ctx().await;
|
||||
let bad_kind = insert_knowledge(&ctx, json!({ "kind": "nope", "title": "t", "content": "c" })).await;
|
||||
assert_eq!(bad_kind.is_error, Some(true));
|
||||
assert!(text_of(&bad_kind).contains("非法知识类型"));
|
||||
|
||||
let empty_title = insert_knowledge(&ctx, json!({ "kind": "pitfall", "title": " ", "content": "c" })).await;
|
||||
assert_eq!(empty_title.is_error, Some(true));
|
||||
assert!(text_of(&empty_title).contains("不能为空"));
|
||||
}
|
||||
|
||||
/// 风险契约:search_knowledge=Low(只读,read-only 放行),insert_knowledge=Medium(写库,read-only 拒)。
|
||||
#[test]
|
||||
fn knowledge_tools_risk_contract() {
|
||||
let search = find("search_knowledge").expect("search_knowledge 必须注册");
|
||||
let insert = find("insert_knowledge").expect("insert_knowledge 必须注册");
|
||||
assert_eq!(search.risk, RiskLevel::Low, "search_knowledge 必须 Low(只读契约)");
|
||||
assert_eq!(insert.risk, RiskLevel::Medium, "insert_knowledge 必须 Medium(写库 → read-only 拒)");
|
||||
|
||||
assert!(visible_for_test(true, "search_knowledge"));
|
||||
assert!(!visible_for_test(true, "insert_knowledge"));
|
||||
assert!(visible_for_test(false, "search_knowledge"));
|
||||
assert!(visible_for_test(false, "insert_knowledge"));
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user