@memoryrelay/plugin-memoryrelay-ai 0.15.6 → 0.16.0

package/src/tools/decision-tools.ts

@@ -0,0 +1,309 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { PluginConfig } from "../pipelines/types.js";
+import type { MemoryRelayClient } from "../client/memoryrelay-client.js";
+
+export function registerDecisionTools(
+  api: OpenClawPluginApi,
+  config: PluginConfig,
+  client: MemoryRelayClient,
+  isToolEnabled: (name: string) => boolean,
+): void {
+  const defaultProject = config.defaultProject;
+
+  // --------------------------------------------------------------------------
+  // 21. decision_record
+  // --------------------------------------------------------------------------
+  if (isToolEnabled("decision_record")) {
+    api.registerTool((ctx) => ({
+
+        name: "decision_record",
+        description:
+          "Record an architectural or design decision. Captures the rationale and alternatives considered for future reference. Always check existing decisions with decision_check first to avoid contradictions." +
+          (defaultProject ? ` Project defaults to '${defaultProject}' if not specified.` : ""),
+        parameters: {
+          type: "object",
+          properties: {
+            title: {
+              type: "string",
+              description: "Short title summarizing the decision.",
+            },
+            rationale: {
+              type: "string",
+              description: "Why this decision was made. Include context and reasoning.",
+            },
+            alternatives: {
+              type: "string",
+              description: "What alternatives were considered and why they were rejected.",
+            },
+            project: {
+              type: "string",
+              description: "Project slug this decision applies to.",
+            },
+            tags: {
+              type: "array",
+              description: "Tags for categorizing the decision.",
+              items: { type: "string" },
+            },
+            status: {
+              type: "string",
+              description: "Decision status.",
+              enum: ["active", "experimental"],
+            },
+            metadata: {
+              type: "object",
+              description: "Optional key-value metadata to attach to the decision.",
+              additionalProperties: { type: "string" },
+            },
+          },
+          required: ["title", "rationale"],
+        },
+        execute: async (
+          _id,
+          args: {
+            title: string;
+            rationale: string;
+            alternatives?: string;
+            project?: string;
+            tags?: string[];
+            status?: string;
+            metadata?: Record<string, string>;
+          },
+        ) => {
+          try {
+            const project = args.project ?? defaultProject;
+
+            // Merge user-provided metadata with sender identity from tool context
+            const metadata: Record<string, string> = { ...(args.metadata ?? {}) };
+            if (ctx.requesterSenderId) {
+              metadata.sender_id = ctx.requesterSenderId;
+            }
+
+            const result = await client.recordDecision(
+              args.title,
+              args.rationale,
+              args.alternatives,
+              project,
+              args.tags,
+              args.status,
+              Object.keys(metadata).length > 0 ? metadata : undefined,
+            );
+            return {
+              content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+              details: { result },
+            };
+          } catch (err) {
+            return {
+              content: [{ type: "text", text: `Failed to record decision: ${String(err)}` }],
+              details: { error: String(err) },
+            };
+          }
+        },
+      }),
+      { name: "decision_record" },
+    );
+  }
+
+  // --------------------------------------------------------------------------
+  // 22. decision_list
+  // --------------------------------------------------------------------------
+  if (isToolEnabled("decision_list")) {
+    api.registerTool((ctx) => ({
+
+        name: "decision_list",
+        description: "List recorded decisions, optionally filtered by project, status, or tags." +
+          (defaultProject ? ` Scoped to project '${defaultProject}' by default.` : ""),
+        parameters: {
+          type: "object",
+          properties: {
+            limit: {
+              type: "number",
+              description: "Maximum decisions to return. Default 20.",
+              minimum: 1,
+              maximum: 100,
+            },
+            project: {
+              type: "string",
+              description: "Filter by project slug.",
+            },
+            status: {
+              type: "string",
+              description: "Filter by status.",
+              enum: ["active", "superseded", "reverted", "experimental"],
+            },
+            tags: {
+              type: "string",
+              description: "Comma-separated tags to filter by.",
+            },
+          },
+        },
+        execute: async (
+          _id,
+          args: { limit?: number; project?: string; status?: string; tags?: string },
+        ) => {
+          try {
+            const project = args.project ?? defaultProject;
+            const result = await client.listDecisions(args.limit, project, args.status, args.tags);
+            return {
+              content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+              details: { result },
+            };
+          } catch (err) {
+            return {
+              content: [{ type: "text", text: `Failed to list decisions: ${String(err)}` }],
+              details: { error: String(err) },
+            };
+          }
+        },
+      }),
+      { name: "decision_list" },
+    );
+  }
+
+  // --------------------------------------------------------------------------
+  // 23. decision_supersede
+  // --------------------------------------------------------------------------
+  if (isToolEnabled("decision_supersede")) {
+    api.registerTool((ctx) => ({
+
+        name: "decision_supersede",
+        description:
+          "Supersede an existing decision with a new one. The old decision is marked as superseded and linked to the replacement.",
+        parameters: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "ID of the decision to supersede.",
+            },
+            title: {
+              type: "string",
+              description: "Title of the new replacement decision.",
+            },
+            rationale: {
+              type: "string",
+              description: "Why the previous decision is being replaced.",
+            },
+            alternatives: {
+              type: "string",
+              description: "Alternatives considered for the new decision.",
+            },
+            tags: {
+              type: "array",
+              description: "Tags for the new decision.",
+              items: { type: "string" },
+            },
+            metadata: {
+              type: "object",
+              description: "Optional key-value metadata to attach to the new decision.",
+              additionalProperties: { type: "string" },
+            },
+          },
+          required: ["id", "title", "rationale"],
+        },
+        execute: async (
+          _id,
+          args: {
+            id: string;
+            title: string;
+            rationale: string;
+            alternatives?: string;
+            tags?: string[];
+            metadata?: Record<string, string>;
+          },
+        ) => {
+          try {
+            const result = await client.supersedeDecision(
+              args.id,
+              args.title,
+              args.rationale,
+              args.alternatives,
+              args.tags,
+              args.metadata,
+            );
+            return {
+              content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+              details: { result },
+            };
+          } catch (err) {
+            return {
+              content: [{ type: "text", text: `Failed to supersede decision: ${String(err)}` }],
+              details: { error: String(err) },
+            };
+          }
+        },
+      }),
+      { name: "decision_supersede" },
+    );
+  }
+
+  // --------------------------------------------------------------------------
+  // 24. decision_check
+  // --------------------------------------------------------------------------
+  if (isToolEnabled("decision_check")) {
+    api.registerTool((ctx) => ({
+
+        name: "decision_check",
+        description:
+          "Check if there are existing decisions relevant to a topic. ALWAYS call this before making architectural choices to avoid contradicting past decisions." +
+          (defaultProject ? ` Scoped to project '${defaultProject}' by default.` : ""),
+        parameters: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Natural language description of the topic or decision area.",
+            },
+            project: {
+              type: "string",
+              description: "Project slug to scope the search.",
+            },
+            limit: {
+              type: "number",
+              description: "Maximum results. Default 5.",
+            },
+            threshold: {
+              type: "number",
+              description: "Minimum similarity threshold (0-1). Default 0.3.",
+            },
+            include_superseded: {
+              type: "boolean",
+              description: "Include superseded decisions in results. Default false.",
+            },
+          },
+          required: ["query"],
+        },
+        execute: async (
+          _id,
+          args: {
+            query: string;
+            project?: string;
+            limit?: number;
+            threshold?: number;
+            include_superseded?: boolean;
+          },
+        ) => {
+          try {
+            const project = args.project ?? defaultProject;
+            const result = await client.checkDecisions(
+              args.query,
+              project,
+              args.limit,
+              args.threshold,
+              args.include_superseded,
+            );
+            return {
+              content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+              details: { result },
+            };
+          } catch (err) {
+            return {
+              content: [{ type: "text", text: `Failed to check decisions: ${String(err)}` }],
+              details: { error: String(err) },
+            };
+          }
+        },
+      }),
+      { name: "decision_check" },
+    );
+  }
+}

package/src/tools/entity-tools.ts

@@ -0,0 +1,215 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { PluginConfig } from "../pipelines/types.js";
+import type { MemoryRelayClient } from "../client/memoryrelay-client.js";
+
+export function registerEntityTools(
+  api: OpenClawPluginApi,
+  config: PluginConfig,
+  client: MemoryRelayClient,
+  isToolEnabled: (name: string) => boolean,
+): void {
+
+  // --------------------------------------------------------------------------
+  // 10. entity_create
+  // --------------------------------------------------------------------------
+  if (isToolEnabled("entity_create")) {
+    api.registerTool((ctx) => ({
+
+        name: "entity_create",
+        description:
+          "Create a named entity (person, place, organization, project, concept) for the knowledge graph. Entities help organize and connect memories.",
+        parameters: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Entity name (1-200 characters).",
+            },
+            type: {
+              type: "string",
+              description: "Entity type classification.",
+              enum: ["person", "place", "organization", "project", "concept", "other"],
+            },
+            metadata: {
+              type: "object",
+              description: "Optional key-value metadata.",
+              additionalProperties: { type: "string" },
+            },
+          },
+          required: ["name", "type"],
+        },
+        execute: async (
+          _id,
+          args: { name: string; type: string; metadata?: Record<string, string> },
+        ) => {
+          try {
+            const result = await client.createEntity(args.name, args.type, args.metadata);
+            return {
+              content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+              details: { result },
+            };
+          } catch (err) {
+            return {
+              content: [{ type: "text", text: `Failed to create entity: ${String(err)}` }],
+              details: { error: String(err) },
+            };
+          }
+        },
+      }),
+      { name: "entity_create" },
+    );
+  }
+
+  // --------------------------------------------------------------------------
+  // 11. entity_link
+  // --------------------------------------------------------------------------
+  if (isToolEnabled("entity_link")) {
+    api.registerTool((ctx) => ({
+
+        name: "entity_link",
+        description: "Link an entity to a memory to establish relationships in the knowledge graph.",
+        parameters: {
+          type: "object",
+          properties: {
+            entity_id: {
+              type: "string",
+              description: "Entity UUID.",
+            },
+            memory_id: {
+              type: "string",
+              description: "Memory UUID.",
+            },
+            relationship: {
+              type: "string",
+              description:
+                'Relationship type (e.g., "mentioned_in", "created_by", "relates_to"). Default "mentioned_in".',
+            },
+          },
+          required: ["entity_id", "memory_id"],
+        },
+        execute: async (
+          _id,
+          args: { entity_id: string; memory_id: string; relationship?: string },
+        ) => {
+          try {
+            const result = await client.linkEntity(
+              args.entity_id,
+              args.memory_id,
+              args.relationship,
+            );
+            return {
+              content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+              details: { result },
+            };
+          } catch (err) {
+            return {
+              content: [{ type: "text", text: `Failed to link entity: ${String(err)}` }],
+              details: { error: String(err) },
+            };
+          }
+        },
+      }),
+      { name: "entity_link" },
+    );
+  }
+
+  // --------------------------------------------------------------------------
+  // 12. entity_list
+  // --------------------------------------------------------------------------
+  if (isToolEnabled("entity_list")) {
+    api.registerTool((ctx) => ({
+
+        name: "entity_list",
+        description: "List entities in the knowledge graph.",
+        parameters: {
+          type: "object",
+          properties: {
+            limit: {
+              type: "number",
+              description: "Maximum entities to return. Default 20.",
+              minimum: 1,
+              maximum: 100,
+            },
+            offset: {
+              type: "number",
+              description: "Offset for pagination. Default 0.",
+              minimum: 0,
+            },
+          },
+        },
+        execute: async (_id, args: { limit?: number; offset?: number }) => {
+          try {
+            const result = await client.listEntities(args.limit, args.offset);
+            return {
+              content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+              details: { result },
+            };
+          } catch (err) {
+            return {
+              content: [{ type: "text", text: `Failed to list entities: ${String(err)}` }],
+              details: { error: String(err) },
+            };
+          }
+        },
+      }),
+      { name: "entity_list" },
+    );
+  }
+
+  // --------------------------------------------------------------------------
+  // 13. entity_graph
+  // --------------------------------------------------------------------------
+  if (isToolEnabled("entity_graph")) {
+    api.registerTool((ctx) => ({
+
+        name: "entity_graph",
+        description:
+          "Explore the knowledge graph around an entity. Returns the entity and its neighborhood of connected entities and memories.",
+        parameters: {
+          type: "object",
+          properties: {
+            entity_id: {
+              type: "string",
+              description: "Entity UUID to explore from.",
+            },
+            depth: {
+              type: "number",
+              description: "How many hops to traverse. Default 2.",
+              minimum: 1,
+              maximum: 5,
+            },
+            max_neighbors: {
+              type: "number",
+              description: "Maximum neighbors per node. Default 10.",
+              minimum: 1,
+              maximum: 50,
+            },
+          },
+          required: ["entity_id"],
+        },
+        execute: async (
+          _id,
+          args: { entity_id: string; depth?: number; max_neighbors?: number },
+        ) => {
+          try {
+            const result = await client.entityGraph(
+              args.entity_id,
+              args.depth,
+              args.max_neighbors,
+            );
+            return {
+              content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+              details: { result },
+            };
+          } catch (err) {
+            return {
+              content: [{ type: "text", text: `Failed to get entity graph: ${String(err)}` }],
+              details: { error: String(err) },
+            };
+          }
+        },
+      }),
+      { name: "entity_graph" },
+    );
+  }
+}

package/src/tools/health-tools.ts

@@ -0,0 +1,42 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { PluginConfig } from "../pipelines/types.js";
+import type { MemoryRelayClient } from "../client/memoryrelay-client.js";
+
+export function registerHealthTools(
+  api: OpenClawPluginApi,
+  config: PluginConfig,
+  client: MemoryRelayClient,
+  isToolEnabled: (name: string) => boolean,
+): void {
+
+  // --------------------------------------------------------------------------
+  // 39. memory_health
+  // --------------------------------------------------------------------------
+  if (isToolEnabled("memory_health")) {
+    api.registerTool((ctx) => ({
+
+        name: "memory_health",
+        description: "Check the MemoryRelay API connectivity and health status.",
+        parameters: {
+          type: "object",
+          properties: {},
+        },
+        execute: async () => {
+          try {
+            const health = await client.health();
+            return {
+              content: [{ type: "text", text: JSON.stringify(health, null, 2) }],
+              details: { health },
+            };
+          } catch (err) {
+            return {
+              content: [{ type: "text", text: `Health check failed: ${String(err)}` }],
+              details: { error: String(err) },
+            };
+          }
+        },
+      }),
+      { name: "memory_health" },
+    );
+  }
+}