Files
marqdo/src/knowledge/graph.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

171 lines
5.4 KiB
Rust
Executable File

//! Knowledge graph edge construction.
use crate::knowledge::ir::{
CapabilityInfo, Edge, EdgeKind, KnowledgeItem, KnowledgeKind, ModuleInfo, SymbolInfo,
};
pub fn build_edges(
modules: &[ModuleInfo],
symbols: &[SymbolInfo],
capabilities: &[CapabilityInfo],
knowledge: &[KnowledgeItem],
) -> Vec<Edge> {
let mut edges = Vec::new();
// Module depends_on
for m in modules {
for imp in &m.imports {
let path = imp
.split(':')
.nth(1)
.unwrap_or(imp)
.trim()
.to_string();
if let Some(dep) = modules.iter().find(|o| {
o.resource == path
|| o.resource.ends_with(&path)
|| o.resource.ends_with(&format!("/{path}"))
|| o.id == path.trim_end_matches(".mq.md")
}) {
edges.push(Edge {
from: format!("module:{}", m.id),
to: format!("module:{}", dep.id),
kind: EdgeKind::DependsOn,
note: Some(imp.clone()),
});
}
}
}
// Symbol uses (calls)
for s in symbols {
for c in &s.calls {
let short = c.rsplit('.').next().unwrap_or(c);
if let Some(target) = symbols.iter().find(|t| t.name == short || t.name == *c || t.id == *c)
{
edges.push(Edge {
from: format!("symbol:{}", s.id),
to: format!("symbol:{}", target.id),
kind: EdgeKind::Uses,
note: None,
});
}
}
for t in &s.tests {
edges.push(Edge {
from: format!("symbol:{}", s.id),
to: format!("symbol:{t}"),
kind: EdgeKind::TestedBy,
note: None,
});
}
for r in &s.related {
edges.push(Edge {
from: format!("symbol:{}", s.id),
to: r.clone(),
kind: EdgeKind::RelatedTo,
note: None,
});
}
for r in &s.reuse {
edges.push(Edge {
from: format!("symbol:{}", s.id),
to: r.clone(),
kind: EdgeKind::DerivedFrom,
note: Some("reuse".into()),
});
}
}
// Capability implements
for c in capabilities {
for sid in &c.implemented_by {
edges.push(Edge {
from: format!("capability:{}", c.id),
to: format!("symbol:{sid}"),
kind: EdgeKind::Implements,
note: None,
});
}
for r in &c.related {
edges.push(Edge {
from: format!("capability:{}", c.id),
to: r.clone(),
kind: EdgeKind::RelatedTo,
note: None,
});
}
}
// Knowledge edges
for k in knowledge {
let kid = format!("knowledge:{}", k.id);
for a in &k.applies_to {
let kind = match k.kind {
KnowledgeKind::Constraint => EdgeKind::ConstrainedBy,
KnowledgeKind::Decision => EdgeKind::DecidedBy,
KnowledgeKind::Failure | KnowledgeKind::AntiPattern => EdgeKind::FailedBy,
_ => EdgeKind::DocumentedBy,
};
// Edge direction: subject --constrained_by--> knowledge (from subject to knowledge)
// Or capability constrained_by knowledge: from applies_to to knowledge
edges.push(Edge {
from: normalize_ref(a, capabilities, symbols),
to: kid.clone(),
kind,
note: Some(k.title.clone()),
});
}
for s in &k.supersedes {
edges.push(Edge {
from: kid.clone(),
to: format!("knowledge:{s}"),
kind: EdgeKind::Supersedes,
note: None,
});
}
for s in &k.conflicts_with {
edges.push(Edge {
from: kid.clone(),
to: format!("knowledge:{s}"),
kind: EdgeKind::ConflictsWith,
note: None,
});
}
for r in &k.related {
edges.push(Edge {
from: kid.clone(),
to: normalize_ref(r, capabilities, symbols),
kind: EdgeKind::RelatedTo,
note: None,
});
}
if k.status == crate::knowledge::ir::Lifecycle::Deprecated {
// no target
}
}
edges.sort_by(|a, b| {
(&a.from, a.kind.as_str(), &a.to).cmp(&(&b.from, b.kind.as_str(), &b.to))
});
edges.dedup_by(|a, b| a.from == b.from && a.to == b.to && a.kind == b.kind);
edges
}
fn normalize_ref(r: &str, capabilities: &[CapabilityInfo], symbols: &[SymbolInfo]) -> String {
if r.starts_with("capability:")
|| r.starts_with("symbol:")
|| r.starts_with("module:")
|| r.starts_with("knowledge:")
{
return r.to_string();
}
if let Some(c) = capabilities.iter().find(|c| c.id == r || c.name == r) {
return format!("capability:{}", c.id);
}
if let Some(s) = symbols.iter().find(|s| s.id == r || s.name == r) {
return format!("symbol:{}", s.id);
}
r.to_string()
}