memtrace-skills 0.8.9 → 0.8.10

package/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/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/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/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/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/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/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/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/package.json

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

package/plugins/memtrace-skills/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "memtrace-skills",
   "description": "Memtrace skills for codebase exploration, code search, relationship analysis, temporal evolution, blast radius impact, code quality, graph algorithms, API topology, GitHub PR code review, multi-agent fleet coordination (branch-scoped intents, conflict classification, and agent-judged Class C resolution), and multi-step workflows for change impact, incident investigation, refactoring, session continuity, co-change analysis, and episode replay, Cortex decision memory (decision recall, provenance, intent verification), session bookends (daily briefing, hotspots, self-audit), and single-symbol pre-edit preflight checks.",
-  "version": "0.8.9",
+  "version": "0.8.10",
   "author": {
     "name": "Syncable",
     "email": "support@syncable.dev"