pi-nocturne-memory 1.0.1 → 1.0.3

package/extensions/index.ts

@@ -2,48 +2,62 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 
-const BOOT_URIS = [
-  "system://boot",
-  "system://recent/5",
-  "system://glossary",
-];
+const MCP_URL = "https://nocturne-memory.slahser.com/mcp";
+const MCP_AUTH = "Bearer lsU70u_QHX8MJz4j7HZGEK79UGTEnA1RTyiALs7YltU";
 
-export default function (pi: ExtensionAPI) {
+const BOOT_URIS = ["system://boot", "system://recent/5", "system://glossary"];
+
+async function callMCP(method: string, params: Record<string, unknown>): Promise<any> {
+  const resp = await fetch(MCP_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      Authorization: MCP_AUTH,
+    },
+    body: JSON.stringify({ jsonrpc: "2.0", id: method + Date.now(), method, params }),
+  });
+
+  const text = await resp.text();
+  const lines = text.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("data: ")) {
+      try {
+        return JSON.parse(line.slice(6));
+      } catch {
+        // continue
+      }
+    }
+  }
+  return null;
+}
+
+function extractText(data: any): string {
+  return data?.result?.content?.[0]?.text ?? "";
+}
+
+export function registerNocturneMemoryTools(pi: ExtensionAPI): void {
   pi.registerTool({
     name: "nocturne_boot",
     label: "Boot Memory",
     description:
-      "Call this at the start of every new session. Loads core memories, recent context, and glossary. This is your self-discipline startup protocol — call it before doing anything else.",
+      "Call at session start. Loads core memories, recent context, and glossary. Self-discipline startup protocol.",
     promptGuidelines: [
-      "MUST call this at the start of every new session before any other work.",
-      "This loads your core identity, recent context, and trigger glossary.",
-      "After booting, check if any disclosure conditions are triggered by the current conversation.",
+      "MUST call at session start before any other work.",
+      "Loads core identity, recent context, and trigger glossary.",
     ],
     parameters: Type.Object({}),
 
     async execute(_toolCallId, _params, _signal, onUpdate) {
-      onUpdate?.({
-        content: [{ type: "text", text: "🌙 Booting Nocturne Memory..." }],
-        details: { phase: "booting" },
-      });
+      onUpdate?.({ content: [{ type: "text", text: "🌙 Booting..." }], details: { phase: "booting" } });
 
       const results: string[] = [];
       const errors: string[] = [];
 
       for (const uri of BOOT_URIS) {
         try {
-          const resp = await fetch(`http://localhost:3000/mcp`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-              jsonrpc: "2.0",
-              id: uri,
-              method: "tools/call",
-              params: { name: "read_memory", arguments: { uri } },
-            }),
-          });
-          const data = await resp.json();
-          if (data.result?.content?.[0]?.text) {
+          const data = await callMCP("tools/call", { name: "read_memory", arguments: { uri } });
+          if (data?.result?.content?.[0]?.text) {
             results.push(`=== ${uri} ===\n${data.result.content[0].text}`);
           }
         } catch (err) {
@@ -52,26 +66,141 @@ export default function (pi: ExtensionAPI) {
       }
 
       if (results.length === 0 && errors.length > 0) {
-        return {
-          content: [{ type: "text", text: `❌ Failed to boot memory:\n${errors.join("\n")}` }],
-          details: { error: errors.join("\n") },
-        };
+        return { content: [{ type: "text", text: `❌ ${errors.join("\n")}` }], details: { error: errors.join("\n") } };
       }
 
-      return {
-        content: [{ type: "text", text: results.join("\n\n---\n\n") }],
-        details: { booted: results.length, failed: errors.length },
-      };
+      return { content: [{ type: "text", text: results.join("\n\n---\n\n") }], details: { booted: results.length } };
     },
 
     renderCall(_args, theme) {
-      return new Text(theme.fg("toolTitle", theme.bold("🌙 Boot Memory")), 0, 0);
+      return new Text(theme.fg("toolTitle", theme.bold("🌙 Boot")), 0, 0);
     },
 
     renderResult(result, _options, theme) {
       const d = result.details as { error?: string; booted?: number } | undefined;
       if (d?.error) return new Text(theme.fg("error", "❌ Boot failed"), 0, 0);
-      return new Text(theme.fg("success", `✓ ${d?.booted ?? 0} memory nodes loaded`), 0, 0);
+      return new Text(theme.fg("success", `✓ ${d?.booted ?? 0} nodes loaded`), 0, 0);
+    },
+  });
+
+  pi.registerTool({
+    name: "nocturne_read",
+    label: "Read Memory",
+    description: "Read a memory by URI. Use system:// URIs or memory paths like core://agent.",
+    parameters: Type.Object({
+      uri: Type.String({ description: "Memory URI (e.g., core://agent, system://boot)" }),
+    }),
+
+    async execute(_toolCallId, params) {
+      const data = await callMCP("tools/call", { name: "read_memory", arguments: { uri: params.uri } });
+      return { content: [{ type: "text", text: extractText(data) || "No content" }] };
+    },
+
+    renderCall(args, theme) {
+      return new Text(theme.fg("toolTitle", theme.bold("📖 ")) + theme.fg("accent", (args.uri as string) ?? ""), 0, 0);
+    },
+
+    renderResult(result, _options, theme) {
+      const text = (result.content?.[0] as any)?.text ?? "";
+      return new Text(theme.fg("success", `✓ ${text.length} chars`), 0, 0);
+    },
+  });
+
+  pi.registerTool({
+    name: "nocturne_search",
+    label: "Search Memory",
+    description: "Search memories by keywords in path and content.",
+    parameters: Type.Object({
+      query: Type.String({ description: "Search keywords" }),
+      domain: Type.Optional(Type.String({ description: "Domain filter (e.g., core, writer)" })),
+    }),
+
+    async execute(_toolCallId, params) {
+      const args: Record<string, unknown> = { query: params.query };
+      if (params.domain) args.domain = params.domain;
+      const data = await callMCP("tools/call", { name: "search_memory", arguments: args });
+      return { content: [{ type: "text", text: extractText(data) || "No results" }] };
+    },
+
+    renderCall(args, theme) {
+      return new Text(theme.fg("toolTitle", theme.bold("🔍 ")) + theme.fg("accent", (args.query as string) ?? ""), 0, 0);
+    },
+
+    renderResult(result, _options, theme) {
+      const text = (result.content?.[0] as any)?.text ?? "";
+      const lines = text.split("\n").filter(Boolean).length;
+      return new Text(theme.fg("success", `✓ ${lines} results`), 0, 0);
+    },
+  });
+
+  pi.registerTool({
+    name: "nocturne_create",
+    label: "Create Memory",
+    description: "Create a new memory node. Include [Baseline], [Deviation], [Result], [Reusable judgment] for behavior records.",
+    parameters: Type.Object({
+      parent_uri: Type.String({ description: "Parent URI (e.g., core://)" }),
+      content: Type.String({ description: "Memory content (Markdown supported)" }),
+      priority: Type.Number({ description: "Priority (0=highest)", default: 2 }),
+      disclosure: Type.String({ description: "When to recall this memory (e.g., 'When discussing X')" }),
+      title: Type.Optional(Type.String({ description: "Path name (a-z, 0-9, _, -)" })),
+    }),
+
+    async execute(_toolCallId, params) {
+      const data = await callMCP("tools/call", {
+        name: "create_memory",
+        arguments: {
+          parent_uri: params.parent_uri,
+          content: params.content,
+          priority: params.priority,
+          disclosure: params.disclosure,
+          ...(params.title ? { title: params.title } : {}),
+        },
+      });
+      return { content: [{ type: "text", text: extractText(data) || "Created" }] };
+    },
+
+    renderCall(args, theme) {
+      return new Text(theme.fg("toolTitle", theme.bold("➕ Create")), 0, 0);
+    },
+
+    renderResult(result, _options, theme) {
+      const text = (result.content?.[0] as any)?.text ?? "";
+      return new Text(theme.fg("success", text.slice(0, 100)), 0, 0);
+    },
+  });
+
+  pi.registerTool({
+    name: "nocturne_update",
+    label: "Update Memory",
+    description: "Update existing memory. Use patch mode (old_string/new_string) or append mode.",
+    parameters: Type.Object({
+      uri: Type.String({ description: "Memory URI to update" }),
+      old_string: Type.Optional(Type.String({ description: "Text to replace (patch mode)" })),
+      new_string: Type.Optional(Type.String({ description: "Replacement text (patch mode)" })),
+      append: Type.Optional(Type.String({ description: "Text to append (append mode)" })),
+      priority: Type.Optional(Type.Number({ description: "New priority" })),
+      disclosure: Type.Optional(Type.String({ description: "New disclosure condition" })),
+    }),
+
+    async execute(_toolCallId, params) {
+      const args: Record<string, unknown> = { uri: params.uri };
+      if (params.old_string) args.old_string = params.old_string;
+      if (params.new_string) args.new_string = params.new_string;
+      if (params.append) args.append = params.append;
+      if (params.priority !== undefined) args.priority = params.priority;
+      if (params.disclosure) args.disclosure = params.disclosure;
+
+      const data = await callMCP("tools/call", { name: "update_memory", arguments: args });
+      return { content: [{ type: "text", text: extractText(data) || "Updated" }] };
+    },
+
+    renderCall(args, theme) {
+      return new Text(theme.fg("toolTitle", theme.bold("✏️ Update")), 0, 0);
+    },
+
+    renderResult(result, _options, theme) {
+      const text = (result.content?.[0] as any)?.text ?? "";
+      return new Text(theme.fg("success", text.slice(0, 100)), 0, 0);
     },
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-nocturne-memory",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Nocturne Memory extension for Pi — automated memory management with SessionStart boot protocol",
   "license": "MIT",
   "type": "module",