@rohirik/pi-ltm 2.0.1 → 2.1.0

package/dist/index.js

@@ -0,0 +1,9 @@
+import{spawn as w,execSync as b}from"node:child_process";import{createRequire as y}from"node:module";import{resolve as x,dirname as T,join as p}from"node:path";import{homedir as v}from"node:os";import{existsSync as u,readdirSync as k}from"node:fs";var m="LTM_BRIDGE_DEPTH";function P(){let c=[process.env.BUN_INSTALL?p(process.env.BUN_INSTALL,"bin","bun"):null,p(v(),".bun","bin","bun"),"/opt/homebrew/bin/bun","/usr/local/bin/bun","/usr/bin/bun"].filter(t=>t!==null&&u(t));if(c.length>0)return c[0];for(let t of["which bun","command -v bun"])try{let e=b(t,{encoding:"utf-8",stdio:"pipe"}).trim();if(e&&u(e)&&!/\bpi\b/.test(e))return e}catch{}return null}function E(){let c=p(v(),".claude","plugins","cache","ltm","ltm");if(u(c))try{let t=k(c).filter(e=>/^\d/.test(e)).sort().reverse();for(let e of t){let n=p(c,e,"src","mcp-server.ts");if(u(n))return n}}catch{}try{let e=y(import.meta.url).resolve("@rohirik/ltm-core/package.json"),n=x(T(e),"src","mcp-server.ts");if(u(n))return n}catch{}return null}var f=class{constructor(t,e){this.runtime=t;this.script=e}child=null;pending=new Map;buffer="";nextId=1;exited=!1;start(){if(this.child)return;let t=parseInt(process.env[m]??"0",10),e={...process.env,[m]:String(t+1)};this.child=w(this.runtime,[this.script],{stdio:["pipe","pipe","pipe"],env:e}),this.child.stdout?.on("data",n=>{this.buffer+=n.toString("utf-8");let r=this.buffer.split(`
+`);this.buffer=r.pop()??"";for(let o of r){let l=o.trim();if(l)try{let i=JSON.parse(l);if(i.id!==void 0){let s=this.pending.get(i.id);s&&(this.pending.delete(i.id),i.error?s.reject(new Error(i.error.message)):s.resolve(i.result))}}catch{}}}),this.child.on("exit",()=>{this.exited=!0;for(let n of this.pending.values())n.reject(new Error("LTM MCP server exited"));this.pending.clear()}),this.child.on("error",()=>{this.exited=!0;for(let n of this.pending.values())n.reject(new Error("LTM MCP server error"));this.pending.clear()})}send(t,e,n){let r=JSON.stringify({jsonrpc:"2.0",id:n,method:t,params:e})+`
+`;this.child?.stdin?.write(r)}request(t,e,n=3e4){let r=this.nextId++;return new Promise((o,l)=>{let i=setTimeout(()=>{this.pending.delete(r),l(new Error(`LTM MCP timeout: ${t}`))},n);this.pending.set(r,{resolve:s=>{clearTimeout(i),o(s)},reject:s=>{clearTimeout(i),l(s)}}),this.send(t,e,r)})}async initialize(){await this.request("initialize",{protocolVersion:"2024-11-05",capabilities:{},clientInfo:{name:"pi-ltm-bridge",version:"1.0.0"}}),this.send("notifications/initialized")}async listTools(){return(await this.request("tools/list"))?.tools??[]}async callTool(t,e){let n=await this.request("tools/call",{name:t,arguments:e},6e4),r=(n?.content??[]).filter(o=>o?.type==="text"&&o.text).map(o=>o.text).join(`
+`);if(n?.isError)throw new Error(r||`${t} returned an error`);return r}};function S(c){let t=c;if(parseInt(process.env[m]??"0",10)>0)return;let e=P(),n=E();if(!e||!n)return;let r=new f(e,n);r.start();let o=(async()=>{await r.initialize();let l=await r.listTools();for(let i of l){let s=i.name;t.registerTool({name:s,label:s,description:i.description??"",parameters:i.inputSchema??{type:"object",properties:{}},async execute(g,a){return{content:[{type:"text",text:await r.callTool(s,a??{})}],details:{}}}})}})().catch(()=>{});t.on("before_agent_start",async l=>{await o;let i=l;try{let g=String(i?.cwd??process.cwd()).replace(/\/$/,"").split("/").pop()??"",a=await r.callTool("ltm_recall",{project:g,limit:8,sort_by:"relevance"});if(!a||a==="[]")return;let d=`## Prior Knowledge (LTM)
+
+${a}
+`,h=String(i?.systemPrompt??"");return{systemPrompt:h?`${h}
+
+${d}`:d}}catch{}})}export{S as default};

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "@rohirik/pi-ltm",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "description": "LTM (Long-Term Memory) native extension for Pi — share memories with Claude Code and OpenCode",
   "type": "module",
-  "main": "./src/index.ts",
+  "main": "./dist/index.js",
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./dist/index.js"
+  },
+  "files": ["dist", "src"],
+  "pi": {
+    "extensions": ["./dist/index.js"]
   },
   "scripts": {
+    "build": "bunx esbuild src/index.ts --bundle --platform=node --format=esm --target=esnext --outfile=dist/index.js --external:bun:sqlite --external:bun:test --external:@rohirik/ltm-core --minify",
+    "prepublishOnly": "bun run build",
     "typecheck": "bunx tsc --noEmit",
     "test": "bun test"
   },
@@ -21,14 +27,12 @@
     "access": "public"
   },
   "dependencies": {
-    "@rohirik/ltm-core": "^2.0.1"
+    "@rohirik/ltm-core": "^2.1.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=1.0.0",
     "bun-types": ">=1.0.0"
   },
   "peerDependenciesMeta": {
-    "@earendil-works/pi-ai": { "optional": true },
     "bun-types": { "optional": true }
   },
   "devDependencies": {

package/src/__tests__/plugin.test.ts

@@ -2,22 +2,26 @@ import { describe, it, expect, beforeAll, afterAll } from "bun:test";
 import { readFileSync, unlinkSync } from "fs";
 import { join } from "path";
 import { Database } from "bun:sqlite";
-import type { PiExtensionAPI, PiToolDefinition } from "@earendil-works/pi-ai";
 
 const dbPath = `/tmp/test-pi-ltm-${process.pid}-${Date.now()}.db`;
 const SCHEMA_PATH = join(import.meta.dir, "..", "..", "..", "ltm-core", "src", "schema.sql");
 
-// Mock Pi API
-function createMockPi(): PiExtensionAPI & { tools: PiToolDefinition[]; handlers: Record<string, Function[]> } {
-  const tools: PiToolDefinition[] = [];
-  const handlers: Record<string, Function[]> = {};
+function createMockPi() {
+  const tools: Array<{
+    name: string;
+    label: string;
+    description: string;
+    parameters: unknown;
+    execute: (toolCallId: string, params: Record<string, unknown>) => Promise<unknown>;
+  }> = [];
+  const handlers: Record<string, Array<(...args: unknown[]) => unknown>> = {};
   return {
     tools,
     handlers,
-    registerTool(def) { tools.push(def); },
-    on(event, handler) {
+    registerTool(def: typeof tools[0]) { tools.push(def); },
+    on(event: string, handler: (...args: unknown[]) => unknown) {
       if (!handlers[event]) handlers[event] = [];
-      handlers[event]!.push(handler as Function);
+      handlers[event]!.push(handler);
     },
   };
 }
@@ -54,53 +58,60 @@ describe("Pi LTM extension — registerTools()", () => {
     expect(names).toContain("ltm_learn");
     expect(names).toContain("ltm_forget");
   });
+
+  it("tools have label and description", async () => {
+    const { registerTools } = await import("../tools.js");
+    const pi = createMockPi();
+    registerTools(pi);
+    for (const tool of pi.tools) {
+      expect(tool.label).toBeTruthy();
+      expect(tool.description).toBeTruthy();
+    }
+  });
 });
 
 describe("Pi LTM extension — registerHooks()", () => {
-  it("registers session:start and compact hooks", async () => {
+  it("registers before_agent_start and session_compact hooks", async () => {
     const { registerHooks } = await import("../hooks.js");
     const pi = createMockPi();
     registerHooks(pi);
-    expect(pi.handlers["session:start"]?.length).toBeGreaterThan(0);
-    expect(pi.handlers["compact"]?.length).toBeGreaterThan(0);
+    expect(pi.handlers["before_agent_start"]?.length).toBeGreaterThan(0);
+    expect(pi.handlers["session_compact"]?.length).toBeGreaterThan(0);
   });
 
-  it("session:start injects Prior Knowledge block when memories exist", async () => {
+  it("before_agent_start returns systemPrompt with Prior Knowledge when memories exist", async () => {
     const { learn } = await import("@rohirik/ltm-core");
-    learn({ content: "Pi test memory — use strict types", category: "pattern", importance: 3, project_scope: "pi-test-proj", skipExport: true });
+    learn({
+      content: "Pi test memory — use strict types",
+      category: "pattern",
+      importance: 3,
+      project_scope: "pi-test-proj",
+      skipExport: true,
+    });
 
     const { registerHooks } = await import("../hooks.js");
     const pi = createMockPi();
     registerHooks(pi);
 
-    const appended: string[] = [];
-    const ctx = {
+    const result = await pi.handlers["before_agent_start"]![0]!({
       cwd: "/tmp/pi-test-proj",
-      sessionID: "pi-test-session-1",
-      appendToSystemPrompt: (block: string) => { appended.push(block); },
-    };
-
-    await pi.handlers["session:start"]![0]!(ctx);
+      systemPrompt: "",
+    }) as { systemPrompt?: string } | undefined;
 
-    expect(appended.length).toBeGreaterThan(0);
-    expect(appended.some(b => b.includes("Prior Knowledge"))).toBe(true);
+    expect(result?.systemPrompt).toContain("Prior Knowledge");
   });
 
-  it("session:start does not inject when no memories for project", async () => {
+  it("before_agent_start returns undefined when no memories for project", async () => {
     const { registerHooks } = await import("../hooks.js");
     const pi = createMockPi();
     registerHooks(pi);
 
-    const appended: string[] = [];
-    const ctx = {
-      cwd: "/tmp/empty-pi-project",
-      sessionID: "pi-test-session-2",
-      appendToSystemPrompt: (block: string) => { appended.push(block); },
-    };
-
-    await pi.handlers["session:start"]![0]!(ctx);
+    const result = await pi.handlers["before_agent_start"]![0]!({
+      cwd: "/tmp/empty-pi-project-xyz-no-memories",
+      systemPrompt: "",
+    });
 
-    expect(appended.length).toBe(0);
+    expect(result).toBeUndefined();
   });
 });
 
@@ -113,19 +124,21 @@ describe("ltm_learn / ltm_recall roundtrip via Pi tools", () => {
     const learnTool = pi.tools.find(t => t.name === "ltm_learn")!;
     const recallTool = pi.tools.find(t => t.name === "ltm_recall")!;
 
-    const result = await learnTool.handler({
+    const learnResult = await learnTool.execute("call-1", {
       content: "Pi roundtrip test — always verify types",
       category: "gotcha",
       importance: 4,
-    }) as { id: number; action: string };
+    }) as { content: Array<{ type: string; text: string }> };
 
-    expect(result.id).toBeGreaterThan(0);
-    expect(result.action).toBe("created");
+    const learned = JSON.parse(learnResult.content[0]!.text) as { id: number; action: string };
+    expect(learned.id).toBeGreaterThan(0);
+    expect(learned.action).toBe("created");
 
-    const memories = await recallTool.handler({
+    const recallResult = await recallTool.execute("call-2", {
       query: "Pi roundtrip verify types",
-    }) as Array<{ id: number; content: string }>;
+    }) as { content: Array<{ type: string; text: string }> };
 
-    expect(memories.some(m => m.id === result.id)).toBe(true);
+    const memories = JSON.parse(recallResult.content[0]!.text) as Array<{ id: number }>;
+    expect(memories.some(m => m.id === learned.id)).toBe(true);
   });
 });

package/src/hooks.ts

@@ -1,10 +1,11 @@
-import type { PiExtensionAPI } from "@earendil-works/pi-ai";
 import { recall, learn } from "@rohirik/ltm-core";
 
+type PiAny = any;
+
 const MAX_CONTEXT_MEMORIES = 10;
 
 function formatContextBlock(memories: Array<{ id: number; content: string; category: string }>): string {
-  const lines = memories.map(m => `- [${m.id}] (${m.category}) ${m.content}`);
+  const lines = memories.map((m) => `- [${m.id}] (${m.category}) ${m.content}`);
   return "## Prior Knowledge (LTM)\n\n" + lines.join("\n") + "\n";
 }
 
@@ -12,29 +13,32 @@ function projectFromCwd(cwd: string): string {
   return cwd.replace(/\/$/, "").split("/").pop() ?? "";
 }
 
-export function registerHooks(pi: PiExtensionAPI): void {
-  pi.on("session:start", async (ctx) => {
+export function registerHooks(pi: PiAny): void {
+  // Inject relevant memories into the system prompt before each agent turn
+  pi.on("before_agent_start", async (event: PiAny) => {
     try {
-      const project = projectFromCwd(ctx.cwd);
-      const memories = await recall({
-        project,
-        limit: MAX_CONTEXT_MEMORIES,
-        sort_by: "relevance",
-      });
-      if (memories.length > 0) {
-        ctx.appendToSystemPrompt(formatContextBlock(
-          memories.map(m => ({ id: m.id, content: m.content, category: m.category })),
-        ));
-      }
+      const cwd = String(event?.cwd ?? process.cwd());
+      const project = projectFromCwd(cwd);
+      const memories = await recall({ project, limit: MAX_CONTEXT_MEMORIES, sort_by: "relevance" });
+      if (memories.length === 0) return;
+
+      const block = formatContextBlock(
+        memories.map((m) => ({ id: m.id, content: m.content, category: m.category })),
+      );
+      const existing = String(event?.systemPrompt ?? "");
+      const parts = existing ? [existing, block] : [block];
+      return { systemPrompt: parts.join("\n\n") };
     } catch {
       // Non-fatal — session continues without LTM context
     }
   });
 
-  pi.on("compact", async (ctx) => {
+  // Learn from session summary after compact
+  pi.on("session_compact", (event: PiAny) => {
     try {
-      const project = projectFromCwd(ctx.cwd);
-      const summary = ctx.getSessionSummary();
+      const cwd = String(event?.cwd ?? process.cwd());
+      const project = projectFromCwd(cwd);
+      const summary = String(event?.summary ?? "");
       if (summary.trim().length > 50) {
         learn({
           content: summary.slice(0, 500),

package/src/index.ts

@@ -1,8 +1,243 @@
-import type { PiExtensionAPI } from "@earendil-works/pi-ai";
-import { registerTools } from "./tools.js";
-import { registerHooks } from "./hooks.js";
+/**
+ * Pi extension entry point.
+ *
+ * Pi loads extensions with Node.js, not Bun — so bun:sqlite is unavailable.
+ * We bridge LTM tools by spawning the ltm-core MCP server as a Bun child
+ * process and proxying calls via newline-delimited JSON-RPC (MCP stdio transport).
+ *
+ * Pattern adapted from context-mode's Pi adapter (MIT).
+ */
+import { spawn, execSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { resolve, dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync, readdirSync } from "node:fs";
 
-export default function ltmExtension(pi: PiExtensionAPI): void {
-  registerTools(pi);
-  registerHooks(pi);
+// ── Fork-bomb prevention ──────────────────────────────────────────────────────
+
+const BRIDGE_DEPTH_ENV = "LTM_BRIDGE_DEPTH";
+
+// ── Runtime discovery ─────────────────────────────────────────────────────────
+
+function findBun(): string | null {
+  const candidates = [
+    process.env["BUN_INSTALL"] ? join(process.env["BUN_INSTALL"]!, "bin", "bun") : null,
+    join(homedir(), ".bun", "bin", "bun"),
+    "/opt/homebrew/bin/bun",
+    "/usr/local/bin/bun",
+    "/usr/bin/bun",
+  ].filter((p): p is string => p !== null && existsSync(p));
+
+  if (candidates.length > 0) return candidates[0]!;
+
+  // PATH fallback — try `which` which works even from Node.js
+  for (const cmd of ["which bun", "command -v bun"]) {
+    try {
+      const out = execSync(cmd, { encoding: "utf-8", stdio: "pipe" }).trim();
+      if (out && existsSync(out) && !/\bpi\b/.test(out)) return out;
+    } catch {
+      // try next
+    }
+  }
+  return null;
+}
+
+function findMcpServer(): string | null {
+  // 1. Plugin cache — newest version first (Claude Code users)
+  const cacheBase = join(homedir(), ".claude", "plugins", "cache", "ltm", "ltm");
+  if (existsSync(cacheBase)) {
+    try {
+      const versions = readdirSync(cacheBase)
+        .filter((v) => /^\d/.test(v))
+        .sort()
+        .reverse();
+      for (const v of versions) {
+        const s = join(cacheBase, v, "src", "mcp-server.ts");
+        if (existsSync(s)) return s;
+      }
+    } catch {
+      // continue to next strategy
+    }
+  }
+  // 2. ltm-core package (if mcp-server is added in a future version)
+  try {
+    const req = createRequire(import.meta.url);
+    const pkgJson = req.resolve("@rohirik/ltm-core/package.json");
+    const script = resolve(dirname(pkgJson), "src", "mcp-server.ts");
+    if (existsSync(script)) return script;
+  } catch {
+    // not available
+  }
+  return null;
+}
+
+// ── Minimal MCP stdio client ──────────────────────────────────────────────────
+
+interface MCPTool {
+  name: string;
+  description?: string;
+  inputSchema?: Record<string, unknown>;
+}
+
+class LtmMcpClient {
+  private child: ReturnType<typeof spawn> | null = null;
+  private pending = new Map<number, { resolve: (v: unknown) => void; reject: (e: Error) => void }>();
+  private buffer = "";
+  private nextId = 1;
+  private exited = false;
+
+  constructor(
+    private readonly runtime: string,
+    private readonly script: string,
+  ) {}
+
+  start(): void {
+    if (this.child) return;
+    const depth = parseInt(process.env[BRIDGE_DEPTH_ENV] ?? "0", 10);
+    const env = { ...process.env, [BRIDGE_DEPTH_ENV]: String(depth + 1) };
+
+    this.child = spawn(this.runtime, [this.script], { stdio: ["pipe", "pipe", "pipe"], env });
+
+    this.child.stdout?.on("data", (chunk: Buffer) => {
+      this.buffer += chunk.toString("utf-8");
+      const lines = this.buffer.split("\n");
+      this.buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const msg = JSON.parse(trimmed) as { id?: number; result?: unknown; error?: { message: string } };
+          if (msg.id !== undefined) {
+            const handler = this.pending.get(msg.id);
+            if (handler) {
+              this.pending.delete(msg.id);
+              if (msg.error) handler.reject(new Error(msg.error.message));
+              else handler.resolve(msg.result);
+            }
+          }
+        } catch {
+          // ignore malformed lines
+        }
+      }
+    });
+
+    this.child.on("exit", () => {
+      this.exited = true;
+      for (const h of this.pending.values()) h.reject(new Error("LTM MCP server exited"));
+      this.pending.clear();
+    });
+    this.child.on("error", () => {
+      this.exited = true;
+      for (const h of this.pending.values()) h.reject(new Error("LTM MCP server error"));
+      this.pending.clear();
+    });
+  }
+
+  private send(method: string, params?: unknown, id?: number): void {
+    const msg = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
+    this.child?.stdin?.write(msg);
+  }
+
+  private request(method: string, params?: unknown, timeoutMs = 30_000): Promise<unknown> {
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`LTM MCP timeout: ${method}`));
+      }, timeoutMs);
+
+      this.pending.set(id, {
+        resolve: (v) => { clearTimeout(timer); resolve(v); },
+        reject: (e) => { clearTimeout(timer); reject(e); },
+      });
+      this.send(method, params, id);
+    });
+  }
+
+  async initialize(): Promise<void> {
+    await this.request("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "pi-ltm-bridge", version: "1.0.0" },
+    });
+    this.send("notifications/initialized");
+  }
+
+  async listTools(): Promise<MCPTool[]> {
+    const result = await this.request("tools/list") as { tools?: MCPTool[] };
+    return result?.tools ?? [];
+  }
+
+  async callTool(name: string, args: Record<string, unknown>): Promise<string> {
+    const result = await this.request("tools/call", { name, arguments: args }, 60_000) as {
+      content?: Array<{ type: string; text?: string }>;
+      isError?: boolean;
+    };
+    const text = (result?.content ?? [])
+      .filter((c) => c?.type === "text" && c.text)
+      .map((c) => c.text!)
+      .join("\n");
+    if (result?.isError) throw new Error(text || `${name} returned an error`);
+    return text;
+  }
+}
+
+// ── Extension entry point ─────────────────────────────────────────────────────
+
+export default function ltmExtension(pi: unknown): void {
+  const p = pi as {
+    registerTool: (def: {
+      name: string; label: string; description: string;
+      parameters: unknown;
+      execute: (toolCallId: string, params: Record<string, unknown>) => Promise<unknown>;
+    }) => void;
+    on: (event: string, handler: (...args: unknown[]) => unknown) => void;
+  };
+
+  // Guard: skip if already inside a spawned bridge child
+  if (parseInt(process.env[BRIDGE_DEPTH_ENV] ?? "0", 10) > 0) return;
+
+  const bun = findBun();
+  const script = findMcpServer();
+  if (!bun || !script) return; // degrade gracefully — no bun or server found
+
+  const client = new LtmMcpClient(bun, script);
+  client.start();
+
+  // Bootstrap runs async — tools are registered once handshake completes.
+  // Pi allows registerTool after extension load; before_agent_start awaits ready.
+  const ready = (async () => {
+    await client.initialize();
+    const tools = await client.listTools();
+    for (const tool of tools) {
+      const name = tool.name;
+      p.registerTool({
+        name,
+        label: name,
+        description: tool.description ?? "",
+        parameters: tool.inputSchema ?? { type: "object", properties: {} },
+        async execute(_toolCallId: string, params: Record<string, unknown>) {
+          const text = await client.callTool(name, params ?? {});
+          return { content: [{ type: "text", text }], details: {} };
+        },
+      });
+    }
+  })().catch(() => {});
+
+  // Inject relevant memories — wait for bootstrap so tools are live first
+  p.on("before_agent_start", async (event: unknown) => {
+    await ready;
+    const ev = event as { cwd?: string; systemPrompt?: string } | null;
+    try {
+      const cwd = String(ev?.cwd ?? process.cwd());
+      const project = cwd.replace(/\/$/, "").split("/").pop() ?? "";
+      const text = await client.callTool("ltm_recall", { project, limit: 8, sort_by: "relevance" });
+      if (!text || text === "[]") return;
+      const block = `## Prior Knowledge (LTM)\n\n${text}\n`;
+      const existing = String(ev?.systemPrompt ?? "");
+      return { systemPrompt: existing ? `${existing}\n\n${block}` : block };
+    } catch {
+      // non-fatal
+    }
+  });
 }

package/src/tools.ts

@@ -1,76 +1,97 @@
-import type { PiExtensionAPI, PiToolDefinition } from "@earendil-works/pi-ai";
 import { recall, learn, forget } from "@rohirik/ltm-core";
 
-export function registerTools(pi: PiExtensionAPI): void {
-  const tools: PiToolDefinition[] = [
-    {
-      name: "ltm_recall",
-      description: "Search long-term memories by query, category, or project scope. Call before starting any non-trivial task.",
-      parameters: {
-        type: "object",
-        properties: {
-          query: { type: "string", description: "Full-text search query" },
-          project: { type: "string", description: "Filter by project scope" },
-          limit: { type: "number", description: "Max results (default 10)", minimum: 1, maximum: 50 },
-          category: { type: "string", enum: ["preference", "architecture", "gotcha", "pattern", "workflow", "constraint"] },
+type PiAny = any; // Pi's extension API — no published types package
+
+function toText(value: unknown): string {
+  return JSON.stringify(value, null, 2);
+}
+
+export function registerTools(pi: PiAny): void {
+  pi.registerTool({
+    name: "ltm_recall",
+    label: "ltm_recall",
+    description:
+      "Search long-term memories by query, category, or project scope. Call before starting any non-trivial task.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Full-text search query" },
+        project: { type: "string", description: "Filter by project scope" },
+        limit: { type: "number", description: "Max results (default 10)", minimum: 1, maximum: 50 },
+        category: {
+          type: "string",
+          enum: ["preference", "architecture", "gotcha", "pattern", "workflow", "constraint"],
         },
       },
-      async handler({ query, project, limit, category }) {
-        const results = await recall({
-          query: query as string | undefined,
-          project: project as string | undefined,
-          limit: limit as number | undefined,
-          category: category as string | undefined,
-        });
-        return results.map(m => ({ id: m.id, content: m.content, category: m.category, importance: m.importance }));
-      },
     },
+    async execute(_toolCallId: string, params: Record<string, unknown>) {
+      const results = await recall({
+        query: params["query"] as string | undefined,
+        project: params["project"] as string | undefined,
+        limit: params["limit"] as number | undefined,
+        category: params["category"] as string | undefined,
+      });
+      return {
+        content: [{ type: "text", text: toText(results.map(m => ({ id: m.id, content: m.content, category: m.category, importance: m.importance }))) }],
+        details: {},
+      };
+    },
+  });
 
-    {
-      name: "ltm_learn",
-      description: "Store or reinforce a memory. Call after discovering a non-obvious pattern, gotcha, or architectural decision.",
-      parameters: {
-        type: "object",
-        properties: {
-          content: { type: "string", description: "The insight, pattern, or decision to store" },
-          category: { type: "string", enum: ["preference", "architecture", "gotcha", "pattern", "workflow", "constraint"] },
-          importance: { type: "number", description: "Importance 1-5 (default 3)", minimum: 1, maximum: 5 },
-          project: { type: "string", description: "Scope to a specific project" },
+  pi.registerTool({
+    name: "ltm_learn",
+    label: "ltm_learn",
+    description:
+      "Store or reinforce a memory. Call after discovering a non-obvious pattern, gotcha, or architectural decision. Always provide a title: a concise noun-phrase label (≤60 chars).",
+    parameters: {
+      type: "object",
+      properties: {
+        content: { type: "string", description: "The insight, pattern, or decision to store" },
+        title: { type: "string", description: "Short label (≤60 chars, noun-phrase). Always provide this.", maxLength: 60 },
+        category: {
+          type: "string",
+          enum: ["preference", "architecture", "gotcha", "pattern", "workflow", "constraint"],
         },
-        required: ["content"],
-      },
-      async handler({ content, category, importance, project }) {
-        const result = learn({
-          content: content as string,
-          category: category as string | undefined,
-          importance: importance as number | undefined,
-          project_scope: project as string | undefined,
-          actor: "pi:ltm_learn",
-          skipExport: true,
-        });
-        return { id: result.id, action: result.action, category: result.category };
+        importance: { type: "number", description: "Importance 1-5 (default 3)", minimum: 1, maximum: 5 },
+        project: { type: "string", description: "Scope to a specific project" },
       },
+      required: ["content"],
     },
+    async execute(_toolCallId: string, params: Record<string, unknown>) {
+      const result = learn({
+        content: params["content"] as string,
+        title: params["title"] as string | undefined,
+        category: params["category"] as string | undefined,
+        importance: params["importance"] as number | undefined,
+        project_scope: params["project"] as string | undefined,
+        actor: "pi:ltm_learn",
+        skipExport: true,
+      });
+      return {
+        content: [{ type: "text", text: toText({ id: result.id, action: result.action, category: result.category }) }],
+        details: {},
+      };
+    },
+  });
 
-    {
-      name: "ltm_forget",
-      description: "Delete a memory by ID. Call when a memory is wrong or outdated.",
-      parameters: {
-        type: "object",
-        properties: {
-          id: { type: "number", description: "Memory ID to delete" },
-          reason: { type: "string", description: "Why this memory is being removed" },
-        },
-        required: ["id"],
-      },
-      async handler({ id, reason }) {
-        forget({ id: id as number, reason: reason as string | undefined, actor: "pi:ltm_forget" });
-        return { ok: true, id };
+  pi.registerTool({
+    name: "ltm_forget",
+    label: "ltm_forget",
+    description: "Delete a memory by ID. Call when a memory is wrong or outdated.",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "number", description: "Memory ID to delete" },
+        reason: { type: "string", description: "Why this memory is being removed" },
       },
+      required: ["id"],
     },
-  ];
-
-  for (const tool of tools) {
-    pi.registerTool(tool);
-  }
+    async execute(_toolCallId: string, params: Record<string, unknown>) {
+      forget({ id: params["id"] as number, reason: params["reason"] as string | undefined, actor: "pi:ltm_forget" });
+      return {
+        content: [{ type: "text", text: toText({ ok: true, id: params["id"] }) }],
+        details: {},
+      };
+    },
+  });
 }

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": ".",
-    "outDir": "dist",
-    "typeRoots": ["./types", "../../node_modules/@types"]
-  },
-  "include": ["src/**/*", "types/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

package/types/pi-ai.d.ts

@@ -1,43 +0,0 @@
-declare module "@earendil-works/pi-ai" {
-  export interface PiToolParameter {
-    type: string;
-    description?: string;
-    enum?: string[];
-    minimum?: number;
-    maximum?: number;
-    default?: unknown;
-  }
-
-  export interface PiToolDefinition {
-    name: string;
-    description: string;
-    parameters: {
-      type: "object";
-      properties: Record<string, PiToolParameter>;
-      required?: string[];
-    };
-    handler(params: Record<string, unknown>): Promise<unknown>;
-  }
-
-  export interface SessionStartContext {
-    cwd: string;
-    sessionID: string;
-    appendToSystemPrompt(block: string): void;
-  }
-
-  export interface CompactContext {
-    cwd: string;
-    sessionID: string;
-    getSessionSummary(): string;
-  }
-
-  type EventMap = {
-    "session:start": SessionStartContext;
-    compact: CompactContext;
-  };
-
-  export interface PiExtensionAPI {
-    on<E extends keyof EventMap>(event: E, handler: (ctx: EventMap[E]) => void | Promise<void>): void;
-    registerTool(definition: PiToolDefinition): void;
-  }
-}