World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
Show potential inputs and consumers of rule definitions (#830)
Maya Kidc65d7b4c2613
diff --git a/web/src/i18n/en.ts b/web/src/i18n/en.tsindex a84edb05..c3282f75 100644--- a/web/src/i18n/en.ts+++ b/web/src/i18n/en.ts@@ -1224,6 +1224,12 @@ export const en = {rulesShort: "Business rules",ruleExpressionReadOnly: "This definition is read-only in this form. You can edit its name and description without changing its expressions or conditions.",ruleUnknownExpression: "Unsupported expression (read-only)",+ ruleDependencies: "Potential dependencies",+ ruleDependenciesHint: "Candidates from rule definitions, not proof of execution. Readings, conditions and time determine what actually runs; disabled definitions are included.",+ ruleDependenciesIncomplete: "Some definitions or classes could not be read completely. This list may be incomplete.",+ rulePotentialProducers: "May receive input from",+ rulePotentialConsumers: "May provide input to",+ ruleDependenciesEmpty: "No candidates found in the readable definitions.",rulesTitle: "Business rules",/* 说清三件事:谁写的、结论是什么身份、什么时候重算。第三件最容易被误解成「保存就生效」,而它其实等下一轮物化 */diff --git a/web/src/i18n/zh.ts b/web/src/i18n/zh.tsindex 67593ffb..b809c1a7 100644--- a/web/src/i18n/zh.ts+++ b/web/src/i18n/zh.ts@@ -1100,6 +1100,12 @@ export const zh: Strings = {rulesShort: "业务规则",ruleExpressionReadOnly: "此表单只读展示这条规则的定义。可修改名称和说明,表达式和条件保持原样。",ruleUnknownExpression: "暂不支持的表达式(只读)",+ ruleDependencies: "潜在依赖",+ ruleDependenciesHint: "根据规则定义列出的候选关系,不代表实际执行。读数、条件和时间决定哪些规则成立;这里也包括已停用的定义。",+ ruleDependenciesIncomplete: "部分定义或类信息无法完整读取,此列表可能不完整。",+ rulePotentialProducers: "可能从这些规则获得输入",+ rulePotentialConsumers: "可能为这些规则提供输入",+ ruleDependenciesEmpty: "在可读取的定义中未找到候选关系。",rulesTitle: "业务规则",rulesHint: "按实体自己的属性判定类别、或算出取值的规则。结论是派生的,依据没了就自动失效。",rulesEmpty: "还没有规则。",diff --git a/web/src/pages/RulesPanel.tsx b/web/src/pages/RulesPanel.tsxindex f04245ae..40845d16 100644--- a/web/src/pages/RulesPanel.tsx+++ b/web/src/pages/RulesPanel.tsx@@ -8,7 +8,7 @@** 样式按 web/DESIGN.md 那五条:字号五档、间距六档、颜色只用 token、控件与状态* 一律从 ui/ 来。 */-import { useEffect, useState } from "react";+import { useEffect, useMemo, useState } from "react";import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";import { Pencil, Play, Plus, Search, Trash2 } from "lucide-react";import {@@ -40,6 +40,7 @@ import {} from "../ui";import { toast } from "../toast";import { expressionText, metadataOnly, metadataPatch } from "./ruleExpressions";+import { ruleDependencies } from "./ruleDependencies";/** op → 那句话里的动词。**数字与集合两类分开**,因为它们的操作数长得不一样 */const OPS: {@@ -258,6 +259,15 @@ export function RulesPanel({/** 展开了哪条规则的命中列表。一次只展开一条——两份长列表并排读不了 */const [opened, setOpened] = useState<string | null>(null);const [filter, setFilter] = useState("");+ const [dependenciesOf, setDependenciesOf] = useState<string | null>(null);+ const [navigation, setNavigation] = useState<{ id: string } | null>(null);+ useEffect(() => { setDependenciesOf(null); setNavigation(null); }, [kbId]);+ useEffect(() => {+ if (!navigation) return;+ const row = document.getElementById(`rule-${kbId}-${navigation.id}`);+ row?.scrollIntoView({ block: "center" });+ row?.focus();+ }, [kbId, navigation]);const invalidate = () => {qc.invalidateQueries({ queryKey: ["rules", kbId] });@@ -344,6 +354,11 @@ export function RulesPanel({});const all = rules.data?.rules ?? [];+ const dependencies = useMemo(() => ruleDependencies(rules.data?.rules ?? [], classes, attributes), [rules.data, classes, attributes]);+ const inspecting = all.find((r) => r.id === dependenciesOf);+ const navigateRule = (id: string) => {+ setFilter(""); setDependenciesOf(null); setNavigation({ id });+ };const needle = filter.trim().toLowerCase();const list = needle? all.filter((r) => searchText(r, attributes).includes(needle))@@ -432,13 +447,16 @@ export function RulesPanel({{list.map((r) => (<Trkey={r.id}+ id={`rule-${kbId}-${r.id}`}+ tabIndex={-1}className={cn(!r.enabled && "opacity-55",- r.id === focusId && "u-picked bg-surface-2",+ (r.id === focusId || r.id === navigation?.id) && "u-picked bg-surface-2",)}><Td><div className="text-body text-ink">{r.name}</div>+ <LinkButton onClick={() => setDependenciesOf(r.id)}>{S.ontology.ruleDependencies}</LinkButton>{r.description && (<div className="text-fine text-ink-2">{r.description}</div>)}@@ -513,6 +531,17 @@ export function RulesPanel({</div>)}+ <Dialog open={!!inspecting} onOpenChange={(open) => !open && setDependenciesOf(null)}+ closeLabel={S.ui.close} title={inspecting?.name ?? ""} description={S.ontology.ruleDependenciesHint}>+ {inspecting && <div className="space-y-4">+ {dependencies.incomplete && <p className="text-small text-warn">{S.ontology.ruleDependenciesIncomplete}</p>}+ <RuleDependencyList title={S.ontology.rulePotentialProducers}+ rules={all.filter((r) => dependencies.links.get(inspecting.id)?.producers.has(r.id))} onSelect={navigateRule} />+ <RuleDependencyList title={S.ontology.rulePotentialConsumers}+ rules={all.filter((r) => dependencies.links.get(inspecting.id)?.consumers.has(r.id))} onSelect={navigateRule} />+ </div>}+ </Dialog>+{/* 命中:这一条此刻推出了哪些结论 */}<Dialogopen={!!opening}@@ -848,3 +877,15 @@ function RuleMetadataDialog({ kbId, rule, attributes, onClose, onSaved }: {</div></Dialog>;}++export function RuleDependencyList({ title, rules, onSelect }: {+ title: string; rules: BusinessRule[]; onSelect: (id: string) => void;+}) {+ return <section className="space-y-2">+ <h3 className="text-body font-medium text-ink">{title}</h3>+ {rules.length ? rules.map((r) => <div key={r.id} className="flex flex-wrap items-baseline gap-2">+ <LinkButton onClick={() => onSelect(r.id)}>{r.name}</LinkButton>+ <span className="text-fine text-ink-2">{r.subject_label} · {r.enabled ? S.ontology.ruleEnabled : S.ontology.ruleDisabled}</span>+ </div>) : <p className="text-small text-ink-2">{S.ontology.ruleDependenciesEmpty}</p>}+ </section>;+}diff --git a/web/src/pages/ruleDependencies.test.ts b/web/src/pages/ruleDependencies.test.tsnew file mode 100644index 00000000..c103f47b--- /dev/null+++ b/web/src/pages/ruleDependencies.test.ts@@ -0,0 +1,79 @@+import { describe, expect, it, vi } from "vitest";+import { Children, isValidElement, type ReactElement, type ReactNode } from "react";+import { renderToStaticMarkup } from "react-dom/server";+import type { BusinessRule } from "../api";+import { ruleDependencies } from "./ruleDependencies";+import { RuleDependencyList } from "./RulesPanel";+import { en } from "../i18n/en";+import { zh } from "../i18n/zh";+const r = (id: string, patch: Partial<BusinessRule> = {}): BusinessRule => ({+ id, name: id, subject_type_id: "root", subject_label: "Class", conclusion: "attribute",+ conclude_predicate_id: `out-${id}`, conclude_type_label: null, conclude_predicate_label: "Value",+ conditions: [{ predicate_id: "input", op: "gt", operand: 100 }], enabled: true, derived_count: 0, capped: 0, ...patch,+});+const classes = [{ id: "root", parents: [] }, { id: "child", parents: ["root"] }, { id: "leaf", parents: ["child"] }];+describe("potential definition dependencies", () => {+ it("finds every producer and consumer by ID, regardless of labels, thresholds or enabled state", () => {+ const rules = [r("a", { conclude_predicate_id: "p" }), r("b", { conclude_predicate_id: "p", enabled: false }), r("c", { conditions: [{ predicate_id: "p", op: "lt", operand: -999 }] }), r("d", { conclude_predicate_id: "q" })];+ const before = JSON.stringify(rules);+ const { links } = ruleDependencies(rules, classes);+ expect([...links.get("c")!.producers]).toEqual(["a", "b"]);+ expect([...links.get("a")!.consumers]).toEqual(["c"]);+ expect(links.get("d")!.consumers.size).toBe(0);+ expect(JSON.stringify(rules)).toBe(before);+ });+ it("reads nested computed expressions and condition operands", () => {+ const expr = { op: "div", l: { const: 2 }, r: { op: "sub", l: { attr: "p" }, r: { attr: "q" } } };+ const computed = { ...r("computed"), conclusion: "computed", conclude_expr: expr };+ const { links } = ruleDependencies([r("p", { conclude_predicate_id: "p" }), r("q", { conclude_predicate_id: "q" }), computed, r("operand", { conditions: [{ predicate_id: "other", op: "gt", operand: expr }] })], classes);+ expect([...links.get("computed")!.producers]).toEqual(["p", "q"]);+ expect([...links.get("operand")!.producers]).toEqual(["p", "q"]);+ });+ it("matches concluded subclasses to ancestor scopes, not the reverse", () => {+ const { links } = ruleDependencies([r("child-output", { conclusion: "typing", conclude_type_id: "child" }), r("root-output", { conclusion: "typing", conclude_type_id: "root" }), r("child-scope", { subject_type_id: "child" }), r("leaf-scope", { subject_type_id: "leaf" })], classes);+ expect(links.get("child-output")!.consumers.has("child-scope")).toBe(true);+ expect(links.get("child-output")!.consumers.has("root-output")).toBe(true);+ expect(links.get("child-output")!.consumers.has("leaf-scope")).toBe(false);+ expect(links.get("root-output")!.consumers.has("child-scope")).toBe(false);+ });+ it("includes explicit readers of the built-in typing predicate", () => {+ const { links } = ruleDependencies([r("typing", { conclusion: "typing", conclude_type_id: "child" }), r("literal", { subject_type_id: "leaf", conditions: [{ predicate_id: "is-a-id", op: "present" }] })], classes, [{ id: "is-a-id", key: "is_a" }]);+ expect(links.get("typing")!.consumers.has("literal")).toBe(true);+ });+ it("preserves self-dependencies and cycles without treating them as errors", () => {+ const { links } = ruleDependencies([r("a", { conclude_predicate_id: "input" }), r("b", { conclude_predicate_id: "input" })], classes);+ expect([...links.get("a")!.consumers]).toEqual(["a", "b"]);+ expect([...links.get("b")!.consumers]).toEqual(["a", "b"]);+ });+ it("does not reuse another snapshot and reports incomplete definitions", () => {+ const first = ruleDependencies([r("old", { conclude_predicate_id: "input" })], classes);+ expect(first.links.get("old")!.producers.size).toBe(1);+ expect(ruleDependencies([], classes).links.size).toBe(0);+ expect(ruleDependencies([{ ...r("new"), conclusion: "computed", conclude_expr: { op: "future" } }], classes).incomplete).toBe(true);+ expect(ruleDependencies([r("new")], []).incomplete).toBe(true);+ });+ it("handles hierarchy cycles and all parents", () => {+ const tree = [{ id: "x", parents: ["y", "z"] }, { id: "y", parents: ["x"] }, { id: "z", parents: [] }];+ const { links } = ruleDependencies([r("p", { conclusion: "typing", conclude_type_id: "x", subject_type_id: "x" }), r("c", { subject_type_id: "z" })], tree);+ expect(links.get("p")!.consumers.has("c")).toBe(true);+ });+ it("does not truncate a large sparse rule set", () => {+ const rules = Array.from({ length: 10000 }, (_, i) => r(String(i), { conclude_predicate_id: `p${i}`, conditions: [{ predicate_id: `p${i-1}`, op: "present" }] }));+ const start = performance.now();+ const { links } = ruleDependencies(rules, classes);+ expect(links.size).toBe(10000);+ expect([...links.get("9999")!.producers]).toEqual(["9998"]);+ expect([...links.values()].reduce((n, x) => n + x.consumers.size, 0)).toBe(9999);+ expect(performance.now() - start).toBeLessThan(3000);+ });+ it("renders disabled definitions and navigates to the selected ID", () => {+ const onSelect = vi.fn();+ const element = RuleDependencyList({ title: "May receive input from", rules: [r("chosen", { enabled: false })], onSelect });+ const markup = renderToStaticMarkup(element);+ expect(markup).toContain("chosen"); expect(markup).toContain(en.ontology.ruleDisabled);+ type El = ReactElement<{ children?: ReactNode; onClick?: () => void }>;+ const walk = (e: El): void => { if (e.props.onClick) e.props.onClick(); Children.forEach(e.props.children, (c) => { if (isValidElement(c)) walk(c as El); }); };+ walk(element as El); expect(onSelect).toHaveBeenCalledWith("chosen");+ for (const bundle of [en, zh]) expect(bundle.ontology.ruleDependenciesHint.length).toBeGreaterThan(30);+ });+});diff --git a/web/src/pages/ruleDependencies.ts b/web/src/pages/ruleDependencies.tsnew file mode 100644index 00000000..b163e4bd--- /dev/null+++ b/web/src/pages/ruleDependencies.ts@@ -0,0 +1,75 @@+import type { BusinessRule, EntityTypeView, RelationTypeView } from "../api";++type Definition = Omit<BusinessRule, "conclusion"> & { conclusion: string; conclude_expr?: unknown };+export interface RuleLinks { producers: Set<string>; consumers: Set<string> }++/** Definition-level candidates only. Conditions, time and actual readings decide+ * which links are used in a proof. Disabled rules remain part of the definition. */+export function ruleDependencies(rules: Definition[], classes: Pick<EntityTypeView, "id" | "parents">[], attributes: Pick<RelationTypeView, "id" | "key">[] = []) {+ const links = new Map<string, RuleLinks>(rules.map((r) => [r.id, { producers: new Set(), consumers: new Set() }]));+ const readers = new Map<string, Set<string>>();+ const scopes = new Map<string, Set<string>>();+ const parents = new Map(classes.map((c) => [c.id, c.parents]));+ let incomplete = false;+ const isA = attributes.find((a) => a.key === "is_a")?.id;+ const index = (map: Map<string, Set<string>>, key: string, id: string) => {+ if (!map.has(key)) map.set(key, new Set());+ map.get(key)!.add(id);+ };+ const readExpr = (raw: unknown, id: string, depth = 0): void => {+ if (depth > 4 || !raw || typeof raw !== "object" || Array.isArray(raw)) { incomplete = true; return; }+ const node = raw as Record<string, unknown>;+ if (typeof node.attr === "string") { index(readers, node.attr, id); return; }+ if (typeof node.const === "number" || typeof node.const === "string") return;+ if (["add", "sub", "mul", "div"].includes(String(node.op))) {+ readExpr(node.l, id, depth + 1); readExpr(node.r, id, depth + 1);+ } else incomplete = true;+ };+ for (const r of rules) {+ index(scopes, r.subject_type_id, r.id);+ if (!parents.has(r.subject_type_id)) incomplete = true;+ for (const c of r.conditions) {+ index(readers, c.predicate_id, r.id);+ if (c.operand && typeof c.operand === "object" && !Array.isArray(c.operand)) readExpr(c.operand, r.id);+ }+ if (r.conclusion === "computed") readExpr(r.conclude_expr, r.id);+ else if (!["typing", "attribute"].includes(r.conclusion)) incomplete = true;+ }+ const connect = (producer: string, consumers?: Set<string>) => {+ for (const consumer of consumers ?? []) {+ links.get(producer)!.consumers.add(consumer);+ links.get(consumer)!.producers.add(producer);+ }+ };+ const ancestorCache = new Map<string, Set<string>>();+ const ancestors = (type: string) => {+ const cached = ancestorCache.get(type);+ if (cached) return cached;+ const seen = new Set<string>(); const pending = [type];+ while (pending.length) {+ const id = pending.pop()!;+ if (seen.has(id)) continue;+ seen.add(id);+ const ps = parents.get(id);+ if (!ps) incomplete = true;+ else pending.push(...ps);+ }+ ancestorCache.set(type, seen);+ return seen;+ };+ for (const r of rules) {+ if (r.conclusion === "typing" && r.conclude_type_id) {+ // reasoning::attribute_rules scopes a rule to its class and descendants;+ // therefore a concluded child can supply membership in an ancestor scope.+ for (const type of ancestors(r.conclude_type_id)) connect(r.id, scopes.get(type));+ // Typings also enter the literal fact pool on the built-in is_a predicate.+ if (isA) connect(r.id, readers.get(isA));+ } else if (["attribute", "computed"].includes(r.conclusion) && r.conclude_predicate_id) {+ connect(r.id, readers.get(r.conclude_predicate_id));+ // A literal is_a conclusion can also affect scope, but the ontology view+ // does not expose every IRI the runner resolves. Do not claim completeness.+ if (r.conclude_predicate_id === isA) incomplete = true;+ }+ }+ return { links, incomplete };+}