@rohirik/pi-ltm 2.0.0

package/README.md

@@ -0,0 +1,38 @@
+# @rohirik/pi-ltm
+
+Long-Term Memory (LTM) native extension for [Pi](https://pi.ai) coding agent — shares the same memory database as Claude Code and OpenCode.
+
+## Install
+
+```bash
+pi install npm:@rohirik/pi-ltm
+```
+
+Or add to `pi.toml`:
+
+```toml
+[[extensions]]
+package = "@rohirik/pi-ltm"
+```
+
+## What it does
+
+- **Session start** (`session:start`): injects a `## Prior Knowledge` block into the system prompt
+- **Compaction** (`compact`): saves session summary to LTM before conversation compaction
+- **3 tools**: `ltm_recall`, `ltm_learn`, `ltm_forget`
+
+## Shared memory
+
+All three tools read from and write to the same database:
+
+```
+~/.claude/plugins/data/ltm-ltm/ltm.db
+```
+
+A memory learned in Pi appears in the next Claude Code session, and vice versa.
+
+## Custom DB path
+
+```bash
+export LTM_DB_PATH="/custom/path/ltm.db"
+```

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@rohirik/pi-ltm",
+  "version": "2.0.0",
+  "description": "LTM (Long-Term Memory) native extension for Pi — share memories with Claude Code and OpenCode",
+  "type": "module",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "typecheck": "bunx tsc --noEmit",
+    "test": "bun test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/RohiRIK/claude-ltm-plugin"
+  },
+  "keywords": ["pi", "pi-coding-agent", "ltm", "long-term-memory", "extension"],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@rohirik/ltm-core": "^2.0.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": {
+    "@types/bun": "latest"
+  }
+}

package/src/__tests__/plugin.test.ts

@@ -0,0 +1,131 @@
+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[]> = {};
+  return {
+    tools,
+    handlers,
+    registerTool(def) { tools.push(def); },
+    on(event, handler) {
+      if (!handlers[event]) handlers[event] = [];
+      handlers[event]!.push(handler as Function);
+    },
+  };
+}
+
+beforeAll(async () => {
+  const { runPendingMigrations, _setDbForTesting } = await import("@rohirik/ltm-core");
+  const db = new Database(dbPath, { create: true });
+  db.exec("PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON;");
+  db.exec(readFileSync(SCHEMA_PATH, "utf-8"));
+  await runPendingMigrations(db);
+  _setDbForTesting(db);
+}, 30_000);
+
+afterAll(() => {
+  try { unlinkSync(dbPath); } catch {}
+  try { unlinkSync(`${dbPath}-shm`); } catch {}
+  try { unlinkSync(`${dbPath}-wal`); } catch {}
+});
+
+describe("Pi LTM extension — registerTools()", () => {
+  it("registers exactly 3 tools", async () => {
+    const { registerTools } = await import("../tools.js");
+    const pi = createMockPi();
+    registerTools(pi);
+    expect(pi.tools).toHaveLength(3);
+  });
+
+  it("registers ltm_recall, ltm_learn, ltm_forget", async () => {
+    const { registerTools } = await import("../tools.js");
+    const pi = createMockPi();
+    registerTools(pi);
+    const names = pi.tools.map(t => t.name);
+    expect(names).toContain("ltm_recall");
+    expect(names).toContain("ltm_learn");
+    expect(names).toContain("ltm_forget");
+  });
+});
+
+describe("Pi LTM extension — registerHooks()", () => {
+  it("registers session:start and 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);
+  });
+
+  it("session:start injects Prior Knowledge block 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 });
+
+    const { registerHooks } = await import("../hooks.js");
+    const pi = createMockPi();
+    registerHooks(pi);
+
+    const appended: string[] = [];
+    const ctx = {
+      cwd: "/tmp/pi-test-proj",
+      sessionID: "pi-test-session-1",
+      appendToSystemPrompt: (block: string) => { appended.push(block); },
+    };
+
+    await pi.handlers["session:start"]![0]!(ctx);
+
+    expect(appended.length).toBeGreaterThan(0);
+    expect(appended.some(b => b.includes("Prior Knowledge"))).toBe(true);
+  });
+
+  it("session:start does not inject 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);
+
+    expect(appended.length).toBe(0);
+  });
+});
+
+describe("ltm_learn / ltm_recall roundtrip via Pi tools", () => {
+  it("stores and retrieves a memory", async () => {
+    const { registerTools } = await import("../tools.js");
+    const pi = createMockPi();
+    registerTools(pi);
+
+    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({
+      content: "Pi roundtrip test — always verify types",
+      category: "gotcha",
+      importance: 4,
+    }) as { id: number; action: string };
+
+    expect(result.id).toBeGreaterThan(0);
+    expect(result.action).toBe("created");
+
+    const memories = await recallTool.handler({
+      query: "Pi roundtrip verify types",
+    }) as Array<{ id: number; content: string }>;
+
+    expect(memories.some(m => m.id === result.id)).toBe(true);
+  });
+});

package/src/hooks.ts

@@ -0,0 +1,52 @@
+import type { PiExtensionAPI } from "@earendil-works/pi-ai";
+import { recall, learn } from "@rohirik/ltm-core";
+
+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}`);
+  return "## Prior Knowledge (LTM)\n\n" + lines.join("\n") + "\n";
+}
+
+function projectFromCwd(cwd: string): string {
+  return cwd.replace(/\/$/, "").split("/").pop() ?? "";
+}
+
+export function registerHooks(pi: PiExtensionAPI): void {
+  pi.on("session:start", async (ctx) => {
+    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 })),
+        ));
+      }
+    } catch {
+      // Non-fatal — session continues without LTM context
+    }
+  });
+
+  pi.on("compact", async (ctx) => {
+    try {
+      const project = projectFromCwd(ctx.cwd);
+      const summary = ctx.getSessionSummary();
+      if (summary.trim().length > 50) {
+        learn({
+          content: summary.slice(0, 500),
+          category: "pattern",
+          importance: 2,
+          project_scope: project,
+          actor: "pi:compact",
+          skipExport: true,
+        });
+      }
+    } catch {
+      // Non-fatal
+    }
+  });
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+import type { PiExtensionAPI } from "@earendil-works/pi-ai";
+import { registerTools } from "./tools.js";
+import { registerHooks } from "./hooks.js";
+
+export default function ltmExtension(pi: PiExtensionAPI): void {
+  registerTools(pi);
+  registerHooks(pi);
+}

package/src/tools.ts

@@ -0,0 +1,76 @@
+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"] },
+        },
+      },
+      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 }));
+      },
+    },
+
+    {
+      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" },
+        },
+        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 };
+      },
+    },
+
+    {
+      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 };
+      },
+    },
+  ];
+
+  for (const tool of tools) {
+    pi.registerTool(tool);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "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

@@ -0,0 +1,43 @@
+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;
+  }
+}