pi-nocturne-memory 1.0.1

package/.github/workflows/publish.yml

@@ -0,0 +1,27 @@
+name: Publish
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    name: Publish to npm
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - name: Upgrade npm
+        run: npm install -g npm@latest && npm config set registry https://registry.npmjs.org/
+
+      - name: Publish
+        run: npm publish --access public

package/README.md

@@ -0,0 +1,34 @@
+# pi-nocturne-memory
+
+**Nocturne Memory extension for Pi — automated memory management with SessionStart boot protocol.**
+
+## Features
+
+- **SessionStart Boot Protocol** — Automatically calls `read_memory("system://boot")` at session start
+- **Memory Rules** — Global rules injected every session for intelligent memory usage
+- **5 Memory Tools** — read, create, update, delete, alias, search, manage_triggers
+
+## Install
+
+```bash
+pi install npm:pi-nocturne-memory
+```
+
+## Configure
+
+Add to `~/.claude/rules.md` or project rules:
+
+```markdown
+- nocturne-memory rules (from pi-nocturne-memory extension)
+```
+
+## How It Works
+
+1. **SessionStart Hook** — Triggers boot protocol at session start
+2. **Agent calls `nocturne_boot`** — Loads system://boot, recent/5, glossary
+3. **Global Rules** — Memory operation rules injected every session
+4. **Agent uses memory tools** — read/create/update/delete based on rules
+
+## License
+
+MIT

package/extensions/index.ts

@@ -0,0 +1,77 @@
+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",
+];
+
+export default function (pi: ExtensionAPI) {
+  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.",
+    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.",
+    ],
+    parameters: Type.Object({}),
+
+    async execute(_toolCallId, _params, _signal, onUpdate) {
+      onUpdate?.({
+        content: [{ type: "text", text: "🌙 Booting Nocturne Memory..." }],
+        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) {
+            results.push(`=== ${uri} ===\n${data.result.content[0].text}`);
+          }
+        } catch (err) {
+          errors.push(`${uri}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+
+      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: results.join("\n\n---\n\n") }],
+        details: { booted: results.length, failed: errors.length },
+      };
+    },
+
+    renderCall(_args, theme) {
+      return new Text(theme.fg("toolTitle", theme.bold("🌙 Boot Memory")), 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);
+    },
+  });
+}

package/hooks/session-start.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+# SessionStart hook for pi-nocturne-memory
+# This runs when a new Pi session starts
+
+# Check if nocturne-memory MCP is available
+if command -v pi &> /dev/null; then
+  # Trigger the boot protocol by calling the MCP tool
+  # This will be picked up by the agent
+  echo "NOCTURNE_BOOT_REQUIRED"
+fi

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "pi-nocturne-memory",
+  "version": "1.0.1",
+  "description": "Nocturne Memory extension for Pi — automated memory management with SessionStart boot protocol",
+  "license": "MIT",
+  "type": "module",
+  "repository": "github:RealAlexandreAI/pi-nocturne-memory",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "memory",
+    "extension"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ],
+    "hooks": [
+      "./hooks/session-start.sh"
+    ]
+  },
+  "dependencies": {
+    "@earendil-works/pi-coding-agent": "^0.80.0"
+  }
+}

package/rules.md

@@ -0,0 +1,31 @@
+# Nocturne Memory Rules
+
+## Self-Discipline Startup Protocol
+At the start of every new session, the agent MUST call `nocturne_boot` before doing anything else. This loads core memories, recent context, and glossary.
+
+## Memory OPERATIONS
+
+### Reading
+- IF user mentions a topic you should have memory about → read_memory first
+- IF unsure about a memory URI → use search_memory
+- IF conversation exceeds 15 turns → read_memory to recalibrate
+- IF disclosure condition is triggered → must read immediately
+
+### Writing
+- New insights/understandings → create_memory immediately
+- User reveals new info about themselves → create_memory
+- Relationship events → create_memory
+- Technical conclusions → create_memory
+- Successful judgments → create_memory with [Baseline], [Deviation], [Result], [Reusable judgment] format
+
+### Updating
+- Found inaccurate info → update_memory immediately
+- User corrects you → update_memory
+- Outdated info → update_memory
+
+### Deleting
+- New insight covers old record → delete redundant nodes
+- Bug/error/low quality → delete
+
+## Memory Value Principle
+Memory value = ability to change behavior. If remembering something doesn't change your action, it's dead data worth deleting.