@lmzhen/dsh-evolution-learning-graph 0.1.0-rc.4 → 0.1.0-rc.41

package/lib/index.js

@@ -1,10 +1,20 @@
+import { SKILL_NAME_RE, SkillLibrary, evolutionIoAdapter } from "@lmzhen/dsh-evolution-core";
 //#region lib/types/index.js
 /**
-* Learning graph over skills and memory.
+* Learning graph over skills and memory, plus node-level commands
+* (`/evolution graph [detail|edit|delete] <nodeId>`) aligned with the Hermes
+* journey surface: a skill node is its name, a memory node is
+* `memory:<source>:<index>` (source = memory|user, index = position in that
+* file's entries).
 * @module @lmzhen/dsh-evolution-learning-graph
 */
-/** Build a small deterministic graph from usage records and memory entries. */
-function buildLearningGraph(usage, memoryEntries) {
+/**
+* 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.
+*/
+function buildLearningGraph(usage, memoryEntries, userEntries = []) {
 	const nodes = [...usage.keys()].map((name) => ({
 		id: name,
 		kind: "skill",
@@ -21,43 +31,153 @@ function buildLearningGraph(usage, memoryEntries) {
 			type: "related"
 		});
 	}
-	memoryEntries.forEach((entry, index) => {
-		const id = `memory:${index}`;
-		nodes.push({
-			id,
-			kind: "memory",
-			label: entry.split("\n")[0]?.slice(0, 80) ?? id
-		});
-		const token = entry.toLowerCase();
-		for (const name of sorted) if (name && token.includes(name.toLowerCase())) edges.push({
-			from: id,
-			to: name,
-			type: "memory_skill"
+	const appendMemory = (source, entries) => {
+		entries.forEach((entry, index) => {
+			const id = `memory:${source}:${index}`;
+			nodes.push({
+				id,
+				kind: "memory",
+				label: entry.split("\n")[0]?.slice(0, 80) ?? id
+			});
+			const token = entry.toLowerCase();
+			for (const name of sorted) if (name && token.includes(name.toLowerCase())) edges.push({
+				from: id,
+				to: name,
+				type: "memory_skill"
+			});
 		});
-	});
+	};
+	appendMemory("memory", memoryEntries);
+	appendMemory("user", userEntries);
 	return {
 		nodes,
 		edges
 	};
 }
+/** Parse a graph node id: skill names pass through; `memory:<source>:<index>` becomes a memory node. */
+function parseGraphNodeId(id) {
+	const memory = /^memory:(memory|user):(\d+)$/.exec(id);
+	if (memory) return {
+		kind: "memory",
+		source: memory[1],
+		index: Number(memory[2])
+	};
+	if (SKILL_NAME_RE.test(id)) return {
+		kind: "skill",
+		name: id
+	};
+	return null;
+}
+/** Resolve a parsed node to its current content (read-only). */
+async function resolveGraphNode(parsed, repository) {
+	if (parsed.kind === "skill") {
+		const content = await repository.readSkill(parsed.name);
+		return content === null ? {
+			ok: false,
+			message: `Skill "${parsed.name}" not found.`
+		} : {
+			ok: true,
+			message: content
+		};
+	}
+	const entries = await repository.readMemory(parsed.source);
+	const entry = entries[parsed.index];
+	return entry === void 0 ? {
+		ok: false,
+		message: `Memory ${parsed.source}[${parsed.index}] does not exist (${entries.length} entries).`
+	} : {
+		ok: true,
+		message: entry
+	};
+}
 const name = "evolution-learning-graph";
 function apply(ctx) {
 	ctx.inject(["commands"], (commandCtx) => {
 		commandCtx.commands.register({
-			name: "evolution graph",
-			description: "Show the current learning graph",
+			name: "graph",
+			description: "Show the learning graph, or act on a node: graph [detail|edit|delete] <nodeId>",
 			recordInput: false,
-			handler: async () => {
-				const usage = ctx.get("skillUsage");
-				const memory = ctx.get("memory");
-				if (!usage || !memory) return { text: "skill-usage or memory service is not mounted." };
-				const graph = buildLearningGraph(await usage.report(), await memory.read("memory"));
-				const lines = graph.nodes.map((node) => (node.kind === "memory" ? "◆" : "●") + " " + node.label);
-				const edges = graph.edges.map((edge) => edge.from + " --" + edge.type + "--> " + edge.to);
-				return { text: lines.join("\n") + "\n\n" + edges.join("\n") };
+			handler: async (invocation) => {
+				const ok = (text) => ({
+					kind: "success",
+					text
+				});
+				const err = (text) => ({
+					kind: "error",
+					text
+				});
+				const usageService = ctx.get("skillUsage");
+				const memoryService = ctx.get("memory");
+				const ioService = ctx.get("evolutionIo");
+				if (!usageService || !memoryService || !ioService) return err("skill-usage, memory or evolution-io service is not mounted.");
+				const usage = usageService;
+				const memory = memoryService;
+				const io = ioService;
+				const input = (invocation.rawInput ?? "").trim();
+				const detail = /^detail\s+(\S+)$/.exec(input);
+				if (detail && detail[1]) return await nodeDetail(detail[1]);
+				const edit = /^edit\s+(\S+)\s+([\s\S]+)$/.exec(input);
+				if (edit && edit[1] && edit[2] !== void 0) return await nodeEdit(edit[1], edit[2]);
+				const remove = /^delete\s+(\S+)$/.exec(input);
+				if (remove && remove[1]) return await nodeDelete(remove[1]);
+				const directory = await renderGraph();
+				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 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");
+				}
+				function withSkills() {
+					return new SkillLibrary(void 0, evolutionIoAdapter(() => io.provider()));
+				}
+				async function nodeDetail(id) {
+					const parsed = parseGraphNodeId(id);
+					if (parsed === null) return err(`Invalid node id "${id}". Skill names or memory:<source>:<index> expected.`);
+					const resolved = await resolveGraphNode(parsed, {
+						readSkill: (name) => withSkills().read(name),
+						readMemory: (target) => memory.read(target)
+					});
+					return resolved.ok ? ok(resolved.message) : err(resolved.message);
+				}
+				async function nodeEdit(id, content) {
+					const parsed = parseGraphNodeId(id);
+					if (parsed === null) return err(`Invalid node id "${id}". Skill names or memory:<source>:<index> expected.`);
+					if (parsed.kind === "skill") {
+						const result = await withSkills().update(parsed.name, content, "foreground");
+						return result.ok ? ok(result.message) : err(result.message);
+					}
+					const entries = await memory.read(parsed.source);
+					const entry = entries[parsed.index];
+					if (entry === void 0) return err(`Memory ${parsed.source}[${parsed.index}] does not exist (${entries.length} entries).`);
+					const result = await memory.applyBatch(parsed.source, [{
+						action: "replace",
+						old_text: entry,
+						facts: content
+					}]);
+					return result.ok ? ok(result.message) : err(result.message);
+				}
+				async function nodeDelete(id) {
+					const parsed = parseGraphNodeId(id);
+					if (parsed === null) return err(`Invalid node id "${id}". Skill names or memory:<source>:<index> expected.`);
+					if (parsed.kind === "skill") {
+						const result = await withSkills().archive(parsed.name);
+						if (result.ok) await usageService?.markArchived?.(parsed.name);
+						return result.ok ? ok(result.message) : err(result.message);
+					}
+					const entries = await memory.read(parsed.source);
+					const entry = entries[parsed.index];
+					if (entry === void 0) return err(`Memory ${parsed.source}[${parsed.index}] does not exist (${entries.length} entries).`);
+					const result = await memory.applyBatch(parsed.source, [{
+						action: "remove",
+						old_text: entry
+					}]);
+					return result.ok ? ok(result.message) : err(result.message);
+				}
 			}
 		});
 	});
 }
 //#endregion
-export { apply, buildLearningGraph, name };
+export { apply, buildLearningGraph, name, parseGraphNodeId, resolveGraphNode };

package/lib/types/index.d.ts

@@ -1,5 +1,9 @@
 /**
- * Learning graph over skills and memory.
+ * Learning graph over skills and memory, plus node-level commands
+ * (`/evolution graph [detail|edit|delete] <nodeId>`) aligned with the Hermes
+ * journey surface: a skill node is its name, a memory node is
+ * `memory:<source>:<index>` (source = memory|user, index = position in that
+ * file's entries).
  * @module @deepseek-ai/dsh-evolution-learning-graph
  */
 import type { Context } from '@deepseek-ai/cordis';
@@ -17,11 +21,34 @@ export interface LearningGraph {
     nodes: GraphNode[];
     edges: GraphEdge[];
 }
-/** Build a small deterministic graph from usage records and memory entries. */
+/**
+ * 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.
+ */
 export declare function buildLearningGraph(usage: ReadonlyMap<string, {
     use_count?: number;
     pinned?: boolean;
-}>, memoryEntries: readonly string[]): LearningGraph;
+}>, memoryEntries: readonly string[], userEntries?: readonly string[]): LearningGraph;
+export type GraphNodeId = {
+    kind: 'skill';
+    name: string;
+} | {
+    kind: 'memory';
+    source: 'memory' | 'user';
+    index: number;
+};
+/** Parse a graph node id: skill names pass through; `memory:<source>:<index>` becomes a memory node. */
+export declare function parseGraphNodeId(id: string): GraphNodeId | null;
+/** Resolve a parsed node to its current content (read-only). */
+export declare function resolveGraphNode(parsed: GraphNodeId, repository: {
+    readSkill(name: string): Promise<string | null>;
+    readMemory(target: 'memory' | 'user'): Promise<string[]>;
+}): Promise<{
+    ok: boolean;
+    message: string;
+}>;
 export declare const name = "evolution-learning-graph";
 export declare function apply(ctx: Context): void;
 //# sourceMappingURL=index.d.ts.map

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.4",
+  "version": "0.1.0-rc.41",
   "publishConfig": {
     "access": "public"
   },
@@ -32,7 +32,8 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@deepseek-ai/schemastery": "^3.18.1"
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "@lmzhen/dsh-evolution-core": "^0.1.0-rc.41"
   },
   "peerDependencies": {
     "@deepseek-ai/dsh-invariants": "^0.1.0-rc.6",