Files
marqdo/src/knowledge/lifecycle.rs
cflmy 9331af78e2 release(2.8.0): 合入 CHANGELOG/README/发版说明/skills prove 任务;CI 链接指向 doc/releases
- CHANGELOG.md:v2.8.0 条目(中英双语);
- README.md:版本行 2.7.1→2.8.0 + 愿景第 6 条(知识可证明);
- doc/releases/v2.8.0.md:双语发版说明(亮点/用法/已知限制);
- skills/marqdo-dev/index.mq.md:新增 prove 任务(路径/目录模式/
  require_lean/json;参数用 + 行声明升参,check 与 narrative-ratio 通过);
- 设计文档 §12.5 标记已合入;发版链接统一指向 doc/releases/v2.8.0.md。
2026-11-18 10:29:26 +08:00

252 lines
7.7 KiB
Rust
Executable File

//! Lifecycle: stale, conflicts, verify.
use std::fs;
use std::path::Path;
use serde_json::{json, Value};
use crate::knowledge::ir::{EdgeKind, KnowledgeGraph, Lifecycle};
#[derive(Debug, Clone)]
pub struct StaleItem {
pub id: String,
pub reason: String,
}
#[derive(Debug, Clone)]
pub struct ConflictItem {
pub left: String,
pub right: String,
pub note: Option<String>,
}
#[derive(Debug, Clone)]
pub struct VerifyIssue {
pub severity: String, // error | warning
pub message: String,
}
pub fn find_stale(graph: &KnowledgeGraph, root: &Path) -> Vec<StaleItem> {
let mut out = Vec::new();
let now = chrono::Utc::now().date_naive();
for k in &graph.knowledge {
if let Some(ref sa) = k.stale_after {
if let Ok(d) = chrono::NaiveDate::parse_from_str(sa, "%Y-%m-%d") {
if d < now {
out.push(StaleItem {
id: k.id.clone(),
reason: format!("stale_after {sa} passed"),
});
}
}
}
if matches!(k.status, Lifecycle::Deprecated | Lifecycle::Superseded) {
out.push(StaleItem {
id: k.id.clone(),
reason: format!("status={}", k.status.as_str()),
});
}
// Source newer than projection evidence — mtime drift
let src = root.join(&k.resource);
if src.exists() {
if let (Ok(meta), Ok(proj_meta)) = (
fs::metadata(&src),
fs::metadata(root.join(".marqdo/ekc/graph/graph.json"))
.or_else(|_| fs::metadata(root.join(".marqdo/graph/graph.json")))
.or_else(|_| fs::metadata(root.join("ekc/graph/graph.json")))
.or_else(|_| fs::metadata(root.join("graph/graph.json"))),
) {
if let (Ok(st), Ok(pt)) = (meta.modified(), proj_meta.modified()) {
if st > pt {
out.push(StaleItem {
id: k.id.clone(),
reason: "source newer than knowledge graph — recompile".into(),
});
}
}
}
}
}
for c in &graph.capabilities {
if matches!(c.status, Lifecycle::Deprecated | Lifecycle::Superseded) {
out.push(StaleItem {
id: c.id.clone(),
reason: format!("capability status={}", c.status.as_str()),
});
}
}
// Dedup
out.sort_by(|a, b| a.id.cmp(&b.id));
out.dedup_by(|a, b| a.id == b.id && a.reason == b.reason);
out
}
pub fn find_conflicts(graph: &KnowledgeGraph) -> Vec<ConflictItem> {
let mut out = Vec::new();
for e in &graph.edges {
if e.kind == EdgeKind::ConflictsWith {
out.push(ConflictItem {
left: e.from.clone(),
right: e.to.clone(),
note: e.note.clone(),
});
}
}
// Knowledge items that claim supersession without edge already covered
for k in &graph.knowledge {
for c in &k.conflicts_with {
out.push(ConflictItem {
left: format!("knowledge:{}", k.id),
right: format!("knowledge:{c}"),
note: Some("authored conflicts_with".into()),
});
}
}
out.sort_by(|a, b| (&a.left, &a.right).cmp(&(&b.left, &b.right)));
out.dedup_by(|a, b| a.left == b.left && a.right == b.right);
out
}
pub fn verify(graph: &KnowledgeGraph) -> Vec<VerifyIssue> {
let mut issues = Vec::new();
// Symbols referenced by capabilities must exist
for c in &graph.capabilities {
for sid in &c.implemented_by {
if graph.symbol_by_id(sid).is_none() {
issues.push(VerifyIssue {
severity: "error".into(),
message: format!(
"capability `{}` implements missing symbol `{sid}`",
c.id
),
});
}
}
}
// Edges must reference known-ish nodes (soft: warn)
let mut node_ids = std::collections::HashSet::new();
node_ids.insert("repo".into());
for m in &graph.modules {
node_ids.insert(format!("module:{}", m.id));
}
for s in &graph.symbols {
node_ids.insert(format!("symbol:{}", s.id));
}
for c in &graph.capabilities {
node_ids.insert(format!("capability:{}", c.id));
}
for k in &graph.knowledge {
node_ids.insert(format!("knowledge:{}", k.id));
}
for e in &graph.edges {
if !node_ids.contains(&e.from) && !e.from.contains('/') {
// allow raw applies_to strings
if !e.from.starts_with("knowledge:")
&& !e.from.starts_with("symbol:")
&& !e.from.starts_with("capability:")
&& !e.from.starts_with("module:")
{
continue;
}
issues.push(VerifyIssue {
severity: "warning".into(),
message: format!("edge from unknown node `{}`", e.from),
});
}
}
// Duplicate high-similarity without documentation
for c in &graph.capabilities {
if !c.possible_duplicates.is_empty() {
issues.push(VerifyIssue {
severity: "warning".into(),
message: format!(
"capability `{}` has possible_duplicates: {}",
c.id,
c.possible_duplicates.join(", ")
),
});
}
}
// Supersedes targets should exist
for k in &graph.knowledge {
for s in &k.supersedes {
if !graph.knowledge.iter().any(|o| o.id == *s || o.id.ends_with(s)) {
issues.push(VerifyIssue {
severity: "warning".into(),
message: format!("knowledge `{}` supersedes unknown `{s}`", k.id),
});
}
}
}
issues
}
pub fn format_stale_text(items: &[StaleItem]) -> String {
let mut out = String::from("Stale knowledge\n\n");
if items.is_empty() {
out.push_str("_None._\n");
return out;
}
for i in items {
out.push_str(&format!("- {} — {}\n", i.id, i.reason));
}
out
}
pub fn format_conflicts_text(items: &[ConflictItem]) -> String {
let mut out = String::from("Knowledge conflicts\n\n");
if items.is_empty() {
out.push_str("_None._\n");
return out;
}
for i in items {
out.push_str(&format!(
"- {} ↔ {}{}\n",
i.left,
i.right,
i.note
.as_ref()
.map(|n| format!(" ({n})"))
.unwrap_or_default()
));
}
out
}
pub fn format_verify_text(issues: &[VerifyIssue]) -> String {
let mut out = String::from("Knowledge verify\n\n");
if issues.is_empty() {
out.push_str("OK — code and knowledge projections are consistent.\n");
return out;
}
for i in issues {
out.push_str(&format!("[{}] {}\n", i.severity, i.message));
}
out
}
pub fn stale_json(items: &[StaleItem]) -> Value {
json!({ "stale": items.iter().map(|i| json!({"id": i.id, "reason": i.reason})).collect::<Vec<_>>() })
}
pub fn conflicts_json(items: &[ConflictItem]) -> Value {
json!({ "conflicts": items.iter().map(|i| json!({"left": i.left, "right": i.right, "note": i.note})).collect::<Vec<_>>() })
}
pub fn verify_json(issues: &[VerifyIssue]) -> Value {
json!({
"ok": issues.iter().all(|i| i.severity != "error"),
"issues": issues.iter().map(|i| json!({"severity": i.severity, "message": i.message})).collect::<Vec<_>>(),
})
}