@lmzhen/dsh-evolution-learning-graph 0.1.0-rc.43 → 0.1.0-rc.44

package/lib/index.js

@@ -1,4 +1,4 @@
-import { SKILL_NAME_RE, SkillLibrary, evolutionIoAdapter } from "@lmzhen/dsh-evolution-core";
+import { SKILL_NAME_RE, SkillLibrary, evolutionIoAdapter, relatedSkillNames } from "@lmzhen/dsh-evolution-core";
 //#region lib/types/index.js
 /**
 * Learning graph over skills and memory, plus node-level commands
@@ -8,13 +8,38 @@ import { SKILL_NAME_RE, SkillLibrary, evolutionIoAdapter } from "@lmzhen/dsh-evo
 * file's entries).
 * @module @lmzhen/dsh-evolution-learning-graph
 */
+function graphDensity(graph) {
+	const linked = /* @__PURE__ */ new Set();
+	let relatedEdges = 0;
+	for (const edge of graph.edges) {
+		if (edge.type !== "related") continue;
+		relatedEdges += 1;
+		linked.add(edge.from);
+		linked.add(edge.to);
+	}
+	const skillNodes = graph.nodes.filter((node) => node.kind === "skill").length;
+	const isolated = graph.nodes.filter((node) => node.kind === "skill" && !linked.has(node.id)).length;
+	return {
+		skillNodes,
+		relatedEdges,
+		edgesPerNode: skillNodes === 0 ? 0 : Math.round(relatedEdges / skillNodes * 100) / 100,
+		isolatedPct: skillNodes === 0 ? 0 : Math.round(isolated / skillNodes * 100)
+	};
+}
 /**
 * Build a small deterministic graph from usage records and memory entries.
 * Memory node ids follow `memory:<source>:<index>` (source = memory|user,
 * index = position in that file's entries) — the SAME rule the parser
 * `parseGraphNodeId` accepts, so graph detail/edit/delete round-trips.
+*
+* Skill-skill edges are semantic only (B-line G3): each entry of `related`
+* (skill name -> names its frontmatter references, from
+* `relatedSkillNames`) becomes an edge when BOTH endpoints exist in the
+* usage set, self-edges are dropped and undirected duplicates collapse. An
+* omitted `related` yields no skill-skill edges — the former alphabet-order
+* chain was a placeholder that connected unrelated neighbors.
 */
-function buildLearningGraph(usage, memoryEntries, userEntries = []) {
+function buildLearningGraph(usage, memoryEntries, userEntries = [], related) {
 	const nodes = [...usage.keys()].map((name) => ({
 		id: name,
 		kind: "skill",
@@ -22,14 +47,20 @@ function buildLearningGraph(usage, memoryEntries, userEntries = []) {
 	}));
 	const edges = [];
 	const sorted = [...usage.keys()].sort();
-	for (let i = 1; i < sorted.length; i += 1) {
-		const from = sorted[i - 1];
-		const to = sorted[i];
-		if (from && to) edges.push({
-			from,
-			to,
-			type: "related"
-		});
+	const seenPairs = /* @__PURE__ */ new Set();
+	for (const [from, targets] of related ?? []) {
+		if (!usage.has(from)) continue;
+		for (const to of targets) {
+			if (to === from || !usage.has(to)) continue;
+			const pairKey = [from, to].sort().join("->");
+			if (seenPairs.has(pairKey)) continue;
+			seenPairs.add(pairKey);
+			edges.push({
+				from,
+				to,
+				type: "related"
+			});
+		}
 	}
 	const appendMemory = (source, entries) => {
 		entries.forEach((entry, index) => {
@@ -124,10 +155,22 @@ function apply(ctx) {
 				if (input !== "") return err(`Unknown graph subcommand "${input.split(" ")[0]}". ${directory}`);
 				return ok(directory);
 				async function renderGraph() {
-					const graph = buildLearningGraph(await usage.report(), await memory.read("memory"), await memory.read("user"));
+					const usageMap = await usage.report();
+					const memoryEntries = await memory.read("memory");
+					const userEntries = await memory.read("user");
+					const skills = withSkills();
+					const related = /* @__PURE__ */ new Map();
+					for (const name of usageMap.keys()) {
+						const content = await skills.read(name);
+						if (content === null) continue;
+						related.set(name, relatedSkillNames(content, name));
+					}
+					const graph = buildLearningGraph(usageMap, memoryEntries, userEntries, related);
 					const lines = graph.nodes.map((node) => (node.kind === "memory" ? "◆" : "●") + " " + node.label);
 					const edges = graph.edges.map((edge) => edge.from + " --" + edge.type + "--> " + edge.to);
-					return lines.join("\n") + "\n\n" + edges.join("\n");
+					const density = graphDensity(graph);
+					const densityLine = `\n\nSkills: ${density.skillNodes} · related edges: ${density.relatedEdges} (${density.edgesPerNode}/node) · isolated: ${density.isolatedPct}%`;
+					return lines.join("\n") + "\n\n" + edges.join("\n") + densityLine;
 				}
 				function withSkills() {
 					return new SkillLibrary(void 0, evolutionIoAdapter(() => io.provider()));
@@ -180,4 +223,4 @@ function apply(ctx) {
 	});
 }
 //#endregion
-export { apply, buildLearningGraph, name, parseGraphNodeId, resolveGraphNode };
+export { apply, buildLearningGraph, graphDensity, name, parseGraphNodeId, resolveGraphNode };

package/lib/types/index.d.ts

@@ -21,16 +21,36 @@ export interface LearningGraph {
     nodes: GraphNode[];
     edges: GraphEdge[];
 }
+/**
+ * Structural summary of the skill subgraph (Hermes `learning_graph` density
+ * parity): edges per skill node and the share of skills no edge touches.
+ * Memory nodes are excluded — they carry token-matched edges by construction,
+ * which would dilute the isolation signal the statistic exists to expose.
+ */
+export interface GraphDensity {
+    skillNodes: number;
+    relatedEdges: number;
+    edgesPerNode: number;
+    isolatedPct: number;
+}
+export declare function graphDensity(graph: LearningGraph): GraphDensity;
 /**
  * Build a small deterministic graph from usage records and memory entries.
  * Memory node ids follow `memory:<source>:<index>` (source = memory|user,
  * index = position in that file's entries) — the SAME rule the parser
  * `parseGraphNodeId` accepts, so graph detail/edit/delete round-trips.
+ *
+ * Skill-skill edges are semantic only (B-line G3): each entry of `related`
+ * (skill name -> names its frontmatter references, from
+ * `relatedSkillNames`) becomes an edge when BOTH endpoints exist in the
+ * usage set, self-edges are dropped and undirected duplicates collapse. An
+ * omitted `related` yields no skill-skill edges — the former alphabet-order
+ * chain was a placeholder that connected unrelated neighbors.
  */
 export declare function buildLearningGraph(usage: ReadonlyMap<string, {
     use_count?: number;
     pinned?: boolean;
-}>, memoryEntries: readonly string[], userEntries?: readonly string[]): LearningGraph;
+}>, memoryEntries: readonly string[], userEntries?: readonly string[], related?: ReadonlyMap<string, readonly string[]>): LearningGraph;
 export type GraphNodeId = {
     kind: 'skill';
     name: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-learning-graph",
   "description": "Learning graph over skills and memory (community build)",
-  "version": "0.1.0-rc.43",
+  "version": "0.1.0-rc.44",
   "publishConfig": {
     "access": "public"
   },
@@ -33,7 +33,7 @@
   "license": "MIT",
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.1",
-    "@lmzhen/dsh-evolution-core": "^0.1.0-rc.43"
+    "@lmzhen/dsh-evolution-core": "^0.1.0-rc.44"
   },
   "peerDependencies": {
     "@deepseek-ai/dsh-invariants": "^0.1.0-rc.6",