memtrace 0.8.9 → 0.8.11

package/installer/dist/commands/doctor.js

@@ -66,6 +66,17 @@ function hermesMcpHasMemtrace(file) {
     const raw = fs.readFileSync(file, 'utf-8');
     return /^mcp_servers:\s*$(?:[\s\S]*?)^\s{2}memtrace:\s*$/m.test(raw);
 }
+function piPackageRegistered(file) {
+    const { value } = safeReadJson(file);
+    if (!value?.packages?.length)
+        return false;
+    return value.packages.some(entry => {
+        const source = typeof entry === 'string' ? entry : entry.source;
+        if (!source)
+            return false;
+        return source.endsWith(`${path.sep}pi-package`) || source.endsWith('/pi-package');
+    });
+}
 function opencodeConfigDir() {
     const xdg = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), '.config');
     return path.join(xdg, 'opencode');
@@ -170,6 +181,17 @@ function checkAgent(agent) {
             mcpConfigPath,
         };
     }
+    if (agent === 'pi') {
+        const skillsDir = path.join(os.homedir(), '.pi', 'agent', 'skills');
+        const mcpConfigPath = path.join(os.homedir(), '.pi', 'agent', 'settings.json');
+        return {
+            agent,
+            skillsFound: countMemtraceSkills(skillsDir),
+            skillsDir,
+            mcpRegistered: piPackageRegistered(mcpConfigPath),
+            mcpConfigPath,
+        };
+    }
     const skillsDir = path.join(os.homedir(), '.cursor', 'skills');
     const mcpConfigPath = path.join(os.homedir(), '.cursor', 'mcp.json');
     return {
@@ -197,7 +219,8 @@ export function formatReport(r) {
         lines.push(`  version: ${r.binaryVersion}`);
     for (const a of r.agents) {
         lines.push(`${check(a.skillsFound > 0)} ${a.agent} skills installed   ${a.skillsFound} in ${a.skillsDir}`);
-        lines.push(`${check(a.mcpRegistered)} ${a.agent} MCP registered      ${a.mcpConfigPath}`);
+        const integrationLabel = a.agent === 'pi' ? 'Pi package registered' : 'MCP registered';
+        lines.push(`${check(a.mcpRegistered)} ${a.agent} ${integrationLabel}      ${a.mcpConfigPath}`);
     }
     return lines.join('\n');
 }

package/installer/dist/commands/install.js

@@ -61,12 +61,18 @@ export async function runInstall(options) {
         try {
             const r = await t.install(skills, ctx);
             console.log(`  [${t.name}] ✓ ${r.skillsWritten} skills → ${r.skillsDir}`);
-            if (r.mcpRegistered)
-                console.log(`  [${t.name}] ✓ MCP registered`);
-            else if (ctx.skipMcp)
+            if (r.mcpRegistered) {
+                console.log(`  [${t.name}] ✓ ${t.name === 'pi' ? 'Pi package registered' : 'MCP registered'}`);
+            }
+            else if (t.name === 'pi') {
+                console.log(`  [${t.name}] ⚠ Pi package registration failed`);
+            }
+            else if (ctx.skipMcp) {
                 console.log(`  [${t.name}] (MCP skipped)`);
-            else
+            }
+            else {
                 console.log(`  [${t.name}] ⚠ MCP registration failed`);
+            }
             for (const w of r.warnings)
                 console.warn(`  [${t.name}] warn: ${w}`);
         }

package/installer/dist/index.js

@@ -15,7 +15,7 @@ function parseOnly(val) {
 program
     .command('install')
     .description('Install memtrace skills and register MCP for selected agents')
-    .option('--only <agents>', 'comma-separated agent names (claude,cursor,codex,gemini,windsurf,vscode,hermes,opencode,kiro,warp)', parseOnly)
+    .option('--only <agents>', 'comma-separated agent names (claude,cursor,codex,gemini,windsurf,vscode,hermes,opencode,kiro,warp,pi)', parseOnly)
     .option('--local', 'install into the current project where the selected agent supports project scope', false)
     .option('--global', 'install globally (~/.claude/, ~/.cursor/, ~/.agents/) [default]', false)
     .option('--skip-mcp', 'write skills only, skip MCP server registration', false)

package/installer/dist/transformers/index.d.ts

@@ -9,7 +9,8 @@ import { hermesTransformer } from './hermes.js';
 import { opencodeTransformer } from './opencode.js';
 import { kiroTransformer } from './kiro.js';
 import { warpTransformer } from './warp.js';
+import { piTransformer } from './pi.js';
 export declare const ALL_TRANSFORMERS: Transformer[];
 export declare function findTransformer(name: string): Transformer | undefined;
-export { claudeTransformer, cursorTransformer, codexTransformer, geminiTransformer, windsurfTransformer, vscodeTransformer, hermesTransformer, opencodeTransformer, kiroTransformer, warpTransformer, };
+export { claudeTransformer, cursorTransformer, codexTransformer, geminiTransformer, windsurfTransformer, vscodeTransformer, hermesTransformer, opencodeTransformer, kiroTransformer, warpTransformer, piTransformer, };
 export type { Transformer, InstallContext, InstallResult, TransformResult } from './types.js';

package/installer/dist/transformers/index.js

@@ -8,6 +8,7 @@ import { hermesTransformer } from './hermes.js';
 import { opencodeTransformer } from './opencode.js';
 import { kiroTransformer } from './kiro.js';
 import { warpTransformer } from './warp.js';
+import { piTransformer } from './pi.js';
 export const ALL_TRANSFORMERS = [
     claudeTransformer,
     cursorTransformer,
@@ -19,8 +20,9 @@ export const ALL_TRANSFORMERS = [
     opencodeTransformer,
     kiroTransformer,
     warpTransformer,
+    piTransformer,
 ];
 export function findTransformer(name) {
     return ALL_TRANSFORMERS.find(t => t.name === name);
 }
-export { claudeTransformer, cursorTransformer, codexTransformer, geminiTransformer, windsurfTransformer, vscodeTransformer, hermesTransformer, opencodeTransformer, kiroTransformer, warpTransformer, };
+export { claudeTransformer, cursorTransformer, codexTransformer, geminiTransformer, windsurfTransformer, vscodeTransformer, hermesTransformer, opencodeTransformer, kiroTransformer, warpTransformer, piTransformer, };

package/installer/dist/transformers/pi.d.ts

@@ -0,0 +1,5 @@
+import { Transformer, InstallContext } from './types.js';
+export declare function piSettingsPath(ctx: InstallContext): string;
+/** Resolve the pi-package directory shipped inside the memtrace npm bundle. */
+export declare function resolveBundledPiPackage(fromDir?: string): string;
+export declare const piTransformer: Transformer;

package/installer/dist/transformers/pi.js

@@ -0,0 +1,152 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { removeMemtraceSkills, skillName } from './shared.js';
+import { safeReadJson, writeJsonAtomic } from '../fs-safe.js';
+import { commandExists } from '../utils.js';
+// Pi (https://pi.dev/docs/latest/packages) uses native pi packages — not MCP JSON
+// config like Cursor. The bundled `pi-package/` extension spawns `memtrace mcp`
+// itself and registers every Memtrace tool as a native Pi tool (`memtrace_*`).
+//
+// `memtrace install --only pi` writes skills + registers this bundled package.
+function piAgentRoot(ctx) {
+    return ctx.scope === 'global'
+        ? path.join(os.homedir(), '.pi', 'agent')
+        : path.join(ctx.cwd, '.pi');
+}
+function skillsRoot(ctx) {
+    return path.join(piAgentRoot(ctx), 'skills');
+}
+export function piSettingsPath(ctx) {
+    return path.join(piAgentRoot(ctx), 'settings.json');
+}
+/** Resolve the pi-package directory shipped inside the memtrace npm bundle. */
+export function resolveBundledPiPackage(fromDir = path.dirname(fileURLToPath(import.meta.url))) {
+    for (const rel of ['../../../pi-package', '../../pi-package']) {
+        const candidate = path.resolve(fromDir, rel);
+        if (fs.existsSync(path.join(candidate, 'package.json')))
+            return candidate;
+    }
+    throw new Error('bundled pi-package not found (reinstall memtrace from npm)');
+}
+function transformForPi(text) {
+    return text.replace(/mcp__memtrace__/g, 'memtrace_');
+}
+function transformAllowedTool(tool) {
+    return tool
+        .replace(/^mcp__memtrace__/, 'memtrace_')
+        .replace(/^Read$/, 'read')
+        .replace(/^Grep$/, 'grep')
+        .replace(/^Glob$/, 'find');
+}
+function skillMarkdownForPi(skill) {
+    const name = skillName(skill);
+    const safeDesc = skill.frontmatter.description.replace(/"/g, '\\"').trim();
+    const tools = skill.frontmatter['allowed-tools'];
+    const toolsLine = tools?.length
+        ? `\nallowed-tools: ${tools.map(transformAllowedTool).join(' ')}`
+        : '';
+    const body = transformForPi(skill.body);
+    return `---\nname: ${name}\ndescription: "${safeDesc}"${toolsLine}\n---\n\n${body}`;
+}
+function writeSkillsForPi(skills, rootDir) {
+    removeMemtraceSkills(rootDir);
+    for (const skill of skills) {
+        const name = skillName(skill);
+        const outDir = path.join(rootDir, name);
+        fs.mkdirSync(outDir, { recursive: true });
+        fs.writeFileSync(path.join(outDir, 'SKILL.md'), skillMarkdownForPi(skill));
+    }
+    return skills.length;
+}
+function packageEntrySource(entry) {
+    if (typeof entry === 'string')
+        return entry;
+    return typeof entry.source === 'string' ? entry.source : undefined;
+}
+function isMemtracePiPackageEntry(entry, packagePath) {
+    const source = packageEntrySource(entry);
+    if (!source)
+        return false;
+    if (source === packagePath)
+        return true;
+    const base = `${path.sep}pi-package`;
+    return source.endsWith(base) || source.endsWith('/pi-package');
+}
+function registerPiPackageAt(settingsFile, packagePath) {
+    const { value, corrupted, backupPath } = safeReadJson(settingsFile);
+    if (corrupted)
+        return { registered: false, backupPath, packagePath };
+    const cfg = (value ?? {});
+    cfg.packages = (cfg.packages ?? []).filter(entry => !isMemtracePiPackageEntry(entry, packagePath));
+    cfg.packages.push(packagePath);
+    writeJsonAtomic(settingsFile, cfg);
+    return { registered: true, packagePath };
+}
+function removePiPackageAt(settingsFile, packagePath) {
+    const { value, corrupted } = safeReadJson(settingsFile);
+    if (corrupted || !value?.packages?.length)
+        return;
+    const kept = value.packages.filter(entry => !isMemtracePiPackageEntry(entry, packagePath));
+    if (kept.length === value.packages.length)
+        return;
+    if (kept.length === 0) {
+        delete value.packages;
+        if (Object.keys(value).length === 0)
+            fs.unlinkSync(settingsFile);
+        else
+            writeJsonAtomic(settingsFile, value);
+        return;
+    }
+    value.packages = kept;
+    writeJsonAtomic(settingsFile, value);
+}
+export const piTransformer = {
+    name: 'pi',
+    async install(skills, ctx) {
+        const rootDir = skillsRoot(ctx);
+        const count = writeSkillsForPi(skills, rootDir);
+        const warnings = [];
+        const settingsFile = piSettingsPath(ctx);
+        let packagePath;
+        try {
+            packagePath = resolveBundledPiPackage();
+        }
+        catch (e) {
+            return {
+                agent: 'pi',
+                skillsWritten: count,
+                skillsDir: rootDir,
+                mcpConfigPath: settingsFile,
+                mcpRegistered: false,
+                warnings: [`${e.message}`],
+            };
+        }
+        const result = registerPiPackageAt(settingsFile, packagePath);
+        if (!result.registered && result.backupPath) {
+            warnings.push(`Pi settings.json was malformed; backed up to ${result.backupPath}.`);
+        }
+        if (!(await commandExists('pi'))) {
+            warnings.push('Pi CLI not found on PATH — skills and package path are configured; install Pi from https://pi.dev to use them.');
+        }
+        if (ctx.skipMcp) {
+            warnings.push('memtrace binary not found — the Pi extension will connect once `memtrace` is on PATH.');
+        }
+        return {
+            agent: 'pi',
+            skillsWritten: count,
+            skillsDir: rootDir,
+            mcpConfigPath: settingsFile,
+            mcpRegistered: result.registered,
+            warnings,
+        };
+    },
+    async uninstall(ctx) {
+        removeMemtraceSkills(skillsRoot(ctx));
+        try {
+            removePiPackageAt(piSettingsPath(ctx), resolveBundledPiPackage());
+        }
+        catch { /* bundled pi-package path unavailable */ }
+    },
+};

package/installer/dist/transformers/types.d.ts

@@ -29,7 +29,7 @@ export interface InstallResult {
     mcpRegistered: boolean;
     warnings: string[];
 }
-export type AgentName = 'claude' | 'cursor' | 'codex' | 'gemini' | 'windsurf' | 'vscode' | 'hermes' | 'opencode' | 'kiro' | 'warp';
+export type AgentName = 'claude' | 'cursor' | 'codex' | 'gemini' | 'windsurf' | 'vscode' | 'hermes' | 'opencode' | 'kiro' | 'warp' | 'pi';
 /**
  * One transformer per supported AI coding agent.
  */

package/installer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memtrace-skills",
-  "version": "0.8.9",
+  "version": "0.8.11",
   "description": "Memtrace skills for AI coding agents — codebase exploration, temporal evolution, impact analysis, and more.",
   "type": "module",
   "bin": {

package/lib/install-consent.js

@@ -85,7 +85,7 @@ function buildMutationList({ home, cwd, projectOnly = false, noHooks = false })
         { path: path.join(claude, "plugins", "installed_plugins.json"), change: "plugin registry entry (written by the `claude` CLI when available)" },
         { path: path.join(home, ".claude.json"), change: "possible memtrace MCP entry (written by `claude mcp add-json --scope user` when the `claude` CLI is available)" },
         { path: path.join(home, ".memtrace") + path.sep, change: "create memtrace data dir: persisted uninstall.js + install-backup/ (backups + manifest)" },
-        { path: path.join(home, "{.cursor,.codex,.gemini,.codeium,.hermes,.kiro,.copilot,.warp,.config/opencode,VS Code user config}"), change: "skills + memtrace MCP registration for other detected agents (same merge-add pattern)" },
+        { path: path.join(home, "{.cursor,.codex,.gemini,.codeium,.hermes,.kiro,.copilot,.warp,.pi,.config/opencode,VS Code user config}"), change: "skills + memtrace MCP registration (or Pi native package) for other detected agents (same merge-add pattern)" },
     );
     return list;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memtrace",
-  "version": "0.8.9",
+  "version": "0.8.11",
   "description": "Code intelligence graph — MCP server + AI agent skills + visualization UI",
   "keywords": [
     "mcp",
@@ -27,7 +27,8 @@
     "skills/",
     "installer/",
     "install.js",
-    "uninstall.js"
+    "uninstall.js",
+    "pi-package/"
   ],
   "scripts": {
     "prepack": "node ../../installer/scripts/prepare-npm-package.js",
@@ -39,12 +40,12 @@
     "fs-extra": "^11.0.0"
   },
   "optionalDependencies": {
-    "@memtrace/darwin-arm64": "0.8.9",
-    "@memtrace/linux-x64": "0.8.9",
-    "@memtrace/linux-arm64": "0.8.9",
-    "@memtrace/win32-x64": "0.8.9",
-    "@memtrace/linux-x64-noavx2": "0.8.9",
-    "@memtrace/win32-x64-noavx2": "0.8.9"
+    "@memtrace/darwin-arm64": "0.8.11",
+    "@memtrace/linux-x64": "0.8.11",
+    "@memtrace/linux-arm64": "0.8.11",
+    "@memtrace/win32-x64": "0.8.11",
+    "@memtrace/linux-x64-noavx2": "0.8.11",
+    "@memtrace/win32-x64-noavx2": "0.8.11"
   },
   "engines": {
     "node": ">=18"

package/pi-package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Memtrace
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/pi-package/README.md

@@ -0,0 +1,51 @@
+# Memtrace for Pi
+
+Bundled Pi extension for [Memtrace](https://memtrace.io). Installed automatically by `memtrace install --only pi` — not published or installed separately.
+
+This package speaks the Memtrace MCP protocol over stdio and registers every Memtrace tool as a **native Pi tool** (`memtrace_*`), so Pi's model sees real Typebox schemas and tool names instead of a generic MCP passthrough.
+
+## Install
+
+```bash
+npm install -g memtrace
+memtrace install --only pi -y
+# or pick pi from the interactive harness list:
+memtrace install
+```
+
+This writes all Memtrace skills to `~/.pi/agent/skills/` and registers this package in `~/.pi/agent/settings.json`.
+
+Use `--local` for project scope (`.pi/skills/` + `.pi/settings.json`).
+
+## Requirements
+
+- [Pi](https://pi.dev) on PATH
+- `memtrace` CLI on PATH (`npm install -g memtrace`)
+
+The extension spawns `memtrace mcp` itself. Run `memtrace start` separately only if you want the daemon/HTTP API to stay up outside Pi sessions.
+
+## Usage
+
+| Command | What it does |
+|---|---|
+| `/memtrace` | Connection state, indexed repos, cwd coverage |
+| `/memtrace:connect` | Reconnect and refresh tools |
+| `/memtrace:index [path]` | Index a directory (defaults to cwd) |
+| `/memtrace:reindex` | Incremental re-index for cwd repo |
+| `/memtrace:tools` | List registered `memtrace_*` tools |
+| `/memtrace:setup` | Check binary install, print next steps |
+
+## Configuration
+
+Precedence (highest first):
+
+1. `MEMTRACE_PI_COMMAND`, `MEMTRACE_PI_ARGS` env vars
+2. `.pi/memtrace.json` (project)
+3. `~/.pi/agent/memtrace.json` (user)
+4. Defaults: `memtrace` + `["mcp"]`
+
+Set `MEMTRACE_PI_DEBUG=1` to log connection lifecycle to stderr.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

package/pi-package/extension/config.ts

@@ -0,0 +1,96 @@
+// config.ts — resolve the Memtrace server connection config.
+//
+// Precedence (highest first):
+//   1. MEMTRACE_*_PI env overrides (MEMTRACE_PI_COMMAND, MEMTRACE_PI_ARGS)
+//   2. project file  .pi/memtrace.json
+//   3. user file     ~/.pi/agent/memtrace.json
+//   4. base env      process.env (MEMTRACE_EMBED_KEY, MEMTRACE_MEMDB_ENDPOINT, …)
+//   5. defaults      command "memtrace", args ["mcp"]
+//
+// `memtrace mcp` is the real stdio MCP subcommand (verified against memtrace
+// 0.8.7's CLI); it attaches to an already-running `memtrace start` workspace
+// daemon or boots its own embedded MemDB sidecar if none is running. Older
+// docs/configs may still reference a `serve` subcommand that never shipped —
+// index.ts retries with ["mcp"] if a configured `serve` is rejected.
+
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+
+export interface MemtraceConfig {
+  /** Executable used to launch the Memtrace MCP server over stdio. */
+  command: string;
+  /** Args passed to the command. Default ["mcp"]; a configured legacy ["serve"] falls back to ["mcp"] on failure. */
+  args: string[];
+  /** Extra env merged on top of process.env for the child process. */
+  env: Record<string, string>;
+  /** Working directory for the child process. */
+  cwd?: string;
+  /** Idle disconnect timeout in minutes (0 = never). */
+  idleTimeoutMin: number;
+  /** Per-request timeout in ms. */
+  requestTimeoutMs: number;
+  /** Startup connect timeout in ms (eager connect at session start). */
+  startupTimeoutMs: number;
+}
+
+const DEFAULTS: MemtraceConfig = {
+  command: "memtrace",
+  args: ["mcp"],
+  env: {},
+  idleTimeoutMin: 10,
+  requestTimeoutMs: 60_000,
+  startupTimeoutMs: 4000,
+};
+
+function tryRead(path: string): Record<string, unknown> | null {
+  try {
+    const raw = readFileSync(path, "utf8");
+    return JSON.parse(raw) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+function shallowMerge(base: MemtraceConfig, extra: Record<string, unknown>): MemtraceConfig {
+  const out = { ...base };
+  if (typeof extra.command === "string" && extra.command.trim()) out.command = extra.command;
+  if (Array.isArray(extra.args) && extra.args.every((a) => typeof a === "string")) {
+    out.args = extra.args as string[];
+  }
+  if (extra.env && typeof extra.env === "object") {
+    out.env = { ...out.env, ...(extra.env as Record<string, string>) };
+  }
+  if (typeof extra.cwd === "string") out.cwd = extra.cwd;
+  if (typeof extra.idleTimeoutMin === "number") out.idleTimeoutMin = extra.idleTimeoutMin;
+  if (typeof extra.requestTimeoutMs === "number") out.requestTimeoutMs = extra.requestTimeoutMs;
+  if (typeof extra.startupTimeoutMs === "number") out.startupTimeoutMs = extra.startupTimeoutMs;
+  return out;
+}
+
+export function loadConfig(projectDir: string): MemtraceConfig {
+  let cfg: MemtraceConfig = { ...DEFAULTS, env: {} };
+
+  const userFile = resolve(homedir(), ".pi/agent/memtrace.json");
+  const userJson = tryRead(userFile);
+  if (userJson) cfg = shallowMerge(cfg, userJson);
+
+  const projectFile = resolve(projectDir, ".pi/memtrace.json");
+  const projectJson = tryRead(projectFile);
+  if (projectJson) cfg = shallowMerge(cfg, projectJson);
+
+  // MEMTRACE_EMBED_KEY / MEMTRACE_MEMDB_ENDPOINT etc. propagate automatically
+  // because the child inherits process.env; surface a couple of common ones into
+  // the explicit env map only if the user already set them in config.
+  if (process.env.MEMTRACE_EMBED_KEY && !cfg.env.MEMTRACE_EMBED_KEY) {
+    cfg.env.MEMTRACE_EMBED_KEY = process.env.MEMTRACE_EMBED_KEY;
+  }
+
+  // Highest-precedence env overrides for the launcher itself.
+  if (process.env.MEMTRACE_PI_COMMAND) cfg.command = process.env.MEMTRACE_PI_COMMAND;
+  if (process.env.MEMTRACE_PI_ARGS) {
+    cfg.args = process.env.MEMTRACE_PI_ARGS.split(/\s+/).filter(Boolean);
+  }
+
+  return cfg;
+}