memoryai-mcp 2.2.0 → 2.3.1

package/dist/kiro-setup.d.ts

@@ -1,7 +1,16 @@
 #!/usr/bin/env node
 /**
  * memoryai-kiro-setup
- * Zero-dependency setup script that creates .kiro/settings/mcp.json
- * and .kiro/steering/memoryai.md in the current project directory.
+ * Zero-dependency setup script that creates, in the current project:
+ *   - .kiro/settings/mcp.json            (MCP server wiring)
+ *   - .kiro/steering/memoryai.md         (always-on instructions, soft fallback)
+ *   - .kiro/hooks/memoryai-auto-recall.kiro.hook   (promptSubmit → bootstrap/recall)
+ *   - .kiro/hooks/memoryai-auto-capture.kiro.hook  (agentStop → store/compact)
+ *
+ * The two hooks are what make memory TRULY automatic: they fire on IDE events
+ * (every prompt / end of every turn) instead of relying on the agent to
+ * remember the steering instructions. Result: the user installs once and never
+ * has to think about memory again — recall happens before answers, persistence
+ * happens after turns, compaction happens when context fills.
  */
 export {};

package/dist/kiro-setup.js

@@ -1,12 +1,21 @@
 #!/usr/bin/env node
 /**
  * memoryai-kiro-setup
- * Zero-dependency setup script that creates .kiro/settings/mcp.json
- * and .kiro/steering/memoryai.md in the current project directory.
+ * Zero-dependency setup script that creates, in the current project:
+ *   - .kiro/settings/mcp.json            (MCP server wiring)
+ *   - .kiro/steering/memoryai.md         (always-on instructions, soft fallback)
+ *   - .kiro/hooks/memoryai-auto-recall.kiro.hook   (promptSubmit → bootstrap/recall)
+ *   - .kiro/hooks/memoryai-auto-capture.kiro.hook  (agentStop → store/compact)
+ *
+ * The two hooks are what make memory TRULY automatic: they fire on IDE events
+ * (every prompt / end of every turn) instead of relying on the agent to
+ * remember the steering instructions. Result: the user installs once and never
+ * has to think about memory again — recall happens before answers, persistence
+ * happens after turns, compaction happens when context fills.
  */
 import { createInterface } from "node:readline";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, dirname } from "node:path";
 const rl = createInterface({ input: process.stdin, output: process.stdout });
 function ask(question, fallback) {
     const suffix = fallback ? ` [${fallback}]` : "";
@@ -21,12 +30,42 @@ function writeIfMissing(filePath, content, label) {
         console.log(`  skip  ${label} (already exists)`);
         return false;
     }
-    const dir = filePath.substring(0, filePath.lastIndexOf("/"));
+    const dir = dirname(filePath);
     mkdirSync(dir, { recursive: true });
     writeFileSync(filePath, content, "utf-8");
     console.log(`  create  ${label}`);
     return true;
 }
+/**
+ * Auto-provision a fresh API key from the public self-service endpoint so the
+ * user does nothing — no curl, no dashboard. Returns the key, or null on
+ * failure (caller falls back to asking). Public + IP-rate-limited server-side.
+ */
+async function provisionKey(endpoint, name) {
+    const base = endpoint.replace(/\/+$/, "");
+    try {
+        const resp = await fetch(`${base}/v1/admin/provision`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: name || "kiro", tos_accepted: true }),
+        });
+        if (!resp.ok) {
+            const txt = await resp.text().catch(() => "");
+            console.error(`  warn  auto-provision failed (HTTP ${resp.status}). ${txt.slice(0, 200)}`);
+            return null;
+        }
+        const data = (await resp.json());
+        if (data?.api_key) {
+            console.log(`  ok    provisioned new API key (${String(data.api_key).slice(0, 10)}…, plan=${data.plan || "?"})`);
+            return data.api_key;
+        }
+        return null;
+    }
+    catch (e) {
+        console.error(`  warn  auto-provision request error: ${e instanceof Error ? e.message : String(e)}`);
+        return null;
+    }
+}
 const MCP_CONFIG = (apiKey, endpoint) => JSON.stringify({
     mcpServers: {
         memoryai: {
@@ -36,76 +75,120 @@ const MCP_CONFIG = (apiKey, endpoint) => JSON.stringify({
                 HM_API_KEY: apiKey,
                 HM_ENDPOINT: endpoint,
             },
+            // Auto-approve the everyday memory tools so the hooks can run them
+            // without prompting the user — this is what makes memory truly
+            // hands-off. These are all low-risk (read + append-only store +
+            // context bookkeeping); no destructive operations are listed.
+            autoApprove: [
+                "memory_bootstrap",
+                "memory_recall",
+                "memory_store",
+                "memory_recover",
+                "context_guard_check",
+                "context_guard_compact",
+                "ide_turn_check",
+                "memory_pitfall_check",
+            ],
         },
     },
 }, null, 2) + "\n";
-const STEERING = `---
-inclusion: always
----
-
-# MemoryAI — Persistent Memory Instructions
-
-You have access to MemoryAI tools via MCP. Use them to maintain long-term memory across sessions.
-
-## Session Start
-
-Call \`memory_bootstrap\` at the beginning of every session to load prior context.
-If bootstrap returns nothing, call \`memory_recover\` to check for recent session state.
-
-## During Work
-
-- Before answering questions about past decisions, architecture, or preferences: call \`memory_recall\` with a relevant query.
-- After making a significant decision, completing a task, or learning something about the codebase: call \`memory_store\` with appropriate \`memory_type\`:
-  - \`decision\` — architectural or technical decisions (DNA-protected, never decays)
-  - \`preference\` — user preferences and conventions (DNA-protected, never decays)
-  - \`fact\` — codebase facts, API details, configs
-  - \`error\` — lessons learned from mistakes
-  - \`goal\` — current objectives and milestones
-- After learning from a mistake or unexpected result: call \`learn\` with action, result, and lesson fields.
-
-## Entity Tracking
-
-When you create, modify, or reference important files, packages, or people:
-1. Call \`entity_list\` to check if already tracked
-2. If not tracked, call \`memory_store\` with \`memory_type=entity\`
-
-## Memory Health
-
-If a session is running long, call \`memory_health\` to check working memory usage.
-If above 80%, call \`memory_compact\` proactively to consolidate context.
-
-## Session End
-
-When wrapping up or when the agent is about to stop:
-1. Call \`memory_compact\` to consolidate the session's context into durable memories
-2. Call \`memory_store\` with a brief summary of what was accomplished
-
-## Rules
-
-- Recall only when past context is actually needed — not on every message
-- Store important outcomes after completing tasks, not after every interaction
-- Present memories naturally — integrate recalled info into responses, don't show raw API output
-- Use \`zone: "critical"\` for decisions that must never be forgotten
-- Use \`retention: "forever"\` for permanent project knowledge
+const STEERING = `---
+inclusion: always
+---
+
+# MemoryAI — Persistent Memory (mostly automatic)
+
+You have MemoryAI tools via MCP. Two Agent Hooks automate the common path:
+- **Auto-Recall** (on every prompt) loads memory before you answer.
+- **Auto-Capture** (end of every turn) stores important memory and compacts when full.
+
+So you normally do NOT need to manage memory by hand. This file is a fallback
+for cases the hooks don't cover, plus the rules for HOW to use memory well.
+
+## What the hooks already handle
+- Session-start \`memory_bootstrap\`, per-prompt \`memory_recall\`.
+- Post-turn \`memory_store\` for decisions/preferences/facts/pitfalls/procedures.
+- \`context_guard_check\` → \`context_guard_compact\` when context fills.
+
+Don't duplicate these on your own unless a hook clearly didn't run.
+
+## Memory types
+- \`decision\` — architectural/technical decisions (DNA-protected, never decays)
+- \`preference\` — user preferences and conventions (DNA-protected)
+- \`fact\` — codebase facts, API details, configs
+- \`pitfall\` — a mistake + its lesson (DNA-protected)
+- \`procedure\` — a reusable workflow (DNA-protected)
+- \`error\` / \`goal\` — lessons and current objectives
+
+## Rules
+- Recall only when past context is actually needed — not on every trivial message.
+- Store important outcomes, not every interaction. Dedup is automatic.
+- Integrate recalled info naturally; never show raw tool output.
+- Never store secrets, credentials, tokens, or full API keys.
+- Use \`zone: "critical"\` for things that must never be forgotten.
+- Use \`retention: "forever"\` for permanent project knowledge.
 `;
+// ── Agent Hooks — event-level automation (the real "zero-action" layer) ──
+// These fire on IDE events so memory works even if the agent ignores steering.
+const HOOK_AUTO_RECALL = JSON.stringify({
+    enabled: true,
+    name: "MemoryAI Auto-Recall",
+    description: "Before answering each user message, automatically load relevant memory so the agent always has prior context — zero user action.",
+    version: "1",
+    when: { type: "promptSubmit" },
+    then: {
+        type: "askAgent",
+        prompt: "Before responding, ensure you have the relevant long-term memory (do this silently, integrate naturally, never show raw tool output):\n\n" +
+            "1. If this is the first turn of the session, call memory_bootstrap once to load preferences, decisions, and recent project context.\n" +
+            "2. If the user's message references past work, decisions, preferences, or anything that might be stored (\"what did we\", \"last time\", \"our approach\", \"why did we\", or a question about the project), call memory_recall with a focused query first, then answer using what you find.\n" +
+            "3. If the message is trivial small-talk, skip recall.\n\n" +
+            "Use recalled memory to inform the answer; do not announce that a memory system exists unless asked.",
+    },
+}, null, 2) + "\n";
+const HOOK_AUTO_CAPTURE = JSON.stringify({
+    enabled: true,
+    name: "MemoryAI Auto-Capture",
+    description: "Fully automatic: persist memorable events to MemoryAI after every turn, and persist session state silently when pressure thresholds hit. No user action ever required — the IDE host handles window eviction on its own and the auto-recall hook rehydrates context afterwards.",
+    version: "5",
+    when: { type: "agentStop" },
+    then: {
+        type: "askAgent",
+        prompt: "Run two background tasks SILENTLY. Do not tell the user about either task, do not change your normal reply, do not suggest /compact or 'open a new conversation' — those are not user actions in this design.\n\n" +
+            "1. PERSIST: If the turn produced a decision, preference, important project fact, lesson from a mistake (pitfall), or reusable procedure, call memory_store with the correct memory_type. Skip greetings and trivia. Dedup is automatic. Never store secrets.\n\n" +
+            "2. RELEASE CHECK: Count the assistant turns in this conversation, then call ide_turn_check with turn_count = (your count) and max_tokens = 200000. Read the response's action_prompt field and follow it VERBATIM. Every action_prompt in this design tells you to act SILENTLY — call context_guard_compact when asked, do nothing when asked. Never message the user from this hook.\n\n" +
+            "The design: MemoryAI persists to DB on threshold; the IDE host (Kiro auto-summarize, Claude Code /clear, Cursor /reset) evicts the window on its own schedule; the auto-recall hook on the next user message rehydrates context. From the user's view, nothing ever happens — the chat just keeps working.",
+    },
+}, null, 2) + "\n";
 async function main() {
     const cwd = process.cwd();
     console.log(`\nMemoryAI Kiro Setup`);
     console.log(`Project: ${cwd}\n`);
-    const apiKey = process.env.HM_API_KEY || (await ask("MemoryAI API key (hm_sk_...)"));
+    const endpoint = await ask("Endpoint", process.env.HM_ENDPOINT || "https://memoryai.dev");
+    let apiKey = process.env.HM_API_KEY || (await ask("MemoryAI API key (blank = auto-provision a free one)")).trim();
     if (!apiKey) {
-        console.error("Error: API key is required. Set HM_API_KEY or enter it above.");
+        console.log("  ...  no key given — provisioning one for you");
+        const provisioned = await provisionKey(endpoint, "kiro");
+        if (provisioned)
+            apiKey = provisioned;
+    }
+    if (!apiKey) {
+        console.error("Error: could not obtain an API key (auto-provision failed). Set HM_API_KEY and re-run.");
         process.exit(1);
     }
-    const endpoint = await ask("Endpoint", process.env.HM_ENDPOINT || "https://memoryai.dev");
     console.log("");
     writeIfMissing(join(cwd, ".kiro", "settings", "mcp.json"), MCP_CONFIG(apiKey, endpoint), ".kiro/settings/mcp.json");
     writeIfMissing(join(cwd, ".kiro", "steering", "memoryai.md"), STEERING, ".kiro/steering/memoryai.md");
-    console.log(`
-Done. Next steps:
-  1. Restart Kiro
-  2. Ask: "What do you remember about this project?"
-  3. The agent should call memory_bootstrap automatically
+    writeIfMissing(join(cwd, ".kiro", "hooks", "memoryai-auto-recall.kiro.hook"), HOOK_AUTO_RECALL, ".kiro/hooks/memoryai-auto-recall.kiro.hook");
+    writeIfMissing(join(cwd, ".kiro", "hooks", "memoryai-auto-capture.kiro.hook"), HOOK_AUTO_CAPTURE, ".kiro/hooks/memoryai-auto-capture.kiro.hook");
+    console.log(`
+Done. MemoryAI now runs automatically — you don't have to do anything.
+  - Auto-Recall hook loads relevant memory before each answer.
+  - Auto-Capture hook stores decisions/preferences and compacts when full.
+
+Next steps:
+  1. Restart Kiro (loads the MCP server + hooks)
+  2. Just work normally. Memory persists across sessions on its own.
+  3. Optional check: ask "What do you remember about this project?"
 `);
     rl.close();
 }

package/package.json

@@ -1,45 +1,46 @@
-{
-  "name": "memoryai-mcp",
-  "version": "2.2.0",
-  "description": "MCP server for MemoryAI v2.0 — One brain. ∞ agents. Forever. Adds Brain Export/Import (vendor-neutral bundles), Public Benchmark (smart recall vs full context), Trust Graph (per-agent reputation), Cognitive Twin (simulate user voice). Plus the v1.5 base: 11 biological behaviors, DNA-protected memories, Multi-Agent Mesh.",
-  "homepage": "https://memoryai.dev",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/memoryai-dev/memoryai"
-  },
-  "type": "module",
-  "main": "dist/index.js",
-  "bin": {
-    "memoryai-mcp": "dist/index.js",
-    "memoryai-kiro-setup": "dist/kiro-setup.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "tsx src/index.ts"
-  },
-  "keywords": [
-    "mcp",
-    "memory",
-    "ai",
-    "llm",
-    "context"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.19.15",
-    "tsx": "^4.0.0",
-    "typescript": "^5.5.0"
-  }
-}
+{
+  "name": "memoryai-mcp",
+  "version": "2.3.1",
+  "description": "MCP server for MemoryAI v2.3 — One brain. ∞ agents. Forever. Adds Brain Inheritance/Federation (P2.3), L2 Inject endpoint (DNA #2 retina), Protocol v1 spec lookup. Plus the v2.0 base: Brain Export/Import, Public Benchmark, Trust Graph, Cognitive Twin. Plus the v1.5 base: 11 biological behaviors, DNA-protected memories, Multi-Agent Mesh.",
+  "homepage": "https://memoryai.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/memoryai-dev/memoryai"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "memoryai-mcp": "dist/index.js",
+    "memoryai-kiro-setup": "dist/kiro-setup.js",
+    "memoryai-claude-setup": "dist/claude-setup.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  },
+  "keywords": [
+    "mcp",
+    "memory",
+    "ai",
+    "llm",
+    "context"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.15",
+    "tsx": "^4.0.0",
+    "typescript": "^5.5.0"
+  }
+}