memtrace 0.1.38 → 0.1.47

package/installer/dist/fs-safe.d.ts

@@ -0,0 +1,21 @@
+export interface SafeReadResult<T> {
+    /** Parsed value, or null if file missing or corrupt. */
+    value: T | null;
+    /** True if the file existed but failed to parse. */
+    corrupted: boolean;
+    /** Path to the backup copy, if we made one. */
+    backupPath?: string;
+}
+/**
+ * Read and JSON-parse a file without ever silently losing data.
+ * On parse failure, copies the file to <path>.corrupt-<ISO-timestamp>
+ * and returns { value: null, corrupted: true, backupPath }.
+ * Caller is responsible for deciding whether to proceed with writes.
+ */
+export declare function safeReadJson<T = unknown>(filePath: string): SafeReadResult<T>;
+/**
+ * Write JSON atomically: write to a sibling .tmp file, then rename.
+ * Rename is atomic on POSIX and good enough on Windows for config files.
+ * Creates parent directories as needed.
+ */
+export declare function writeJsonAtomic(filePath: string, data: unknown): void;

package/installer/dist/fs-safe.js

@@ -0,0 +1,35 @@
+import fs from 'fs';
+import path from 'path';
+/**
+ * Read and JSON-parse a file without ever silently losing data.
+ * On parse failure, copies the file to <path>.corrupt-<ISO-timestamp>
+ * and returns { value: null, corrupted: true, backupPath }.
+ * Caller is responsible for deciding whether to proceed with writes.
+ */
+export function safeReadJson(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return { value: null, corrupted: false };
+    }
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    try {
+        return { value: JSON.parse(raw), corrupted: false };
+    }
+    catch {
+        const iso = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupPath = `${filePath}.corrupt-${iso}`;
+        fs.copyFileSync(filePath, backupPath);
+        return { value: null, corrupted: true, backupPath };
+    }
+}
+/**
+ * Write JSON atomically: write to a sibling .tmp file, then rename.
+ * Rename is atomic on POSIX and good enough on Windows for config files.
+ * Creates parent directories as needed.
+ */
+export function writeJsonAtomic(filePath, data) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    const payload = JSON.stringify(data, null, 2) + '\n';
+    fs.writeFileSync(tmpPath, payload);
+    fs.renameSync(tmpPath, filePath);
+}

package/installer/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/installer/dist/index.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { runInstall, runUninstall } from './commands/install.js';
+import { runDoctor } from './commands/doctor.js';
+const program = new Command();
+program
+    .name('memtrace-skills')
+    .description('Install Memtrace skills and MCP for AI coding agents')
+    .version('0.1.0');
+function parseOnly(val) {
+    return val.split(',').map(s => s.trim()).filter(Boolean);
+}
+program
+    .command('install')
+    .description('Install memtrace skills and register MCP for selected agents')
+    .option('--only <agents>', 'comma-separated agent names (claude,cursor)', parseOnly)
+    .option('--local', 'install into the current project (./.claude/, ./.cursor/)', false)
+    .option('--global', 'install globally (~/.claude/, ~/.cursor/) [default]', false)
+    .option('--skip-mcp', 'write skills only, skip MCP server registration', false)
+    .option('--repair', 'alias for install — run after fixing a corrupt settings file')
+    .option('-y, --yes', 'non-interactive, accept defaults')
+    .action(async (opts) => {
+    const options = {
+        scope: opts.local ? 'local' : 'global',
+        only: opts.only,
+        skipMcp: opts.skipMcp,
+        yes: opts.yes,
+    };
+    await runInstall(options);
+});
+program
+    .command('doctor')
+    .description('Check memtrace install health across all agents')
+    .action(async () => {
+    process.exit(await runDoctor());
+});
+program
+    .command('uninstall')
+    .description('Remove memtrace skills and MCP registrations')
+    .option('--only <agents>', 'comma-separated agent names', parseOnly)
+    .option('--local', 'uninstall from the current project', false)
+    .action(async (opts) => {
+    await runUninstall({
+        scope: opts.local ? 'local' : 'global',
+        only: opts.only,
+    });
+});
+// Default: `memtrace-skills` with no subcommand → install with defaults (global, all agents)
+program.action(async () => {
+    await runInstall({ scope: 'global' });
+});
+program.parse();

package/installer/dist/skills.d.ts

@@ -0,0 +1,17 @@
+export interface SkillFrontmatter {
+    name?: string;
+    description: string;
+    'allowed-tools'?: string[];
+    'user-invocable'?: boolean;
+}
+export interface Skill {
+    filename: string;
+    category: 'commands' | 'workflows';
+    frontmatter: SkillFrontmatter;
+    body: string;
+    raw: string;
+}
+/**
+ * Load all skills from a skills directory (expects commands/ and workflows/ subdirs).
+ */
+export declare function loadSkills(skillsDir: string): Skill[];

package/installer/dist/skills.js

@@ -0,0 +1,64 @@
+import fs from 'fs';
+import path from 'path';
+/**
+ * Parse YAML-ish frontmatter from a skill markdown file.
+ * Handles the subset of YAML used in skill files (no nested objects).
+ */
+function parseFrontmatter(raw) {
+    const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!match)
+        return null;
+    const frontmatterRaw = match[1];
+    const body = match[2];
+    const frontmatter = {};
+    // Parse description
+    const descMatch = frontmatterRaw.match(/^description:\s*"?(.*?)"?\s*$/m);
+    if (descMatch)
+        frontmatter.description = descMatch[1];
+    // Parse name
+    const nameMatch = frontmatterRaw.match(/^name:\s*(.+)$/m);
+    if (nameMatch)
+        frontmatter.name = nameMatch[1].trim();
+    // Parse user-invocable
+    const invocableMatch = frontmatterRaw.match(/^user-invocable:\s*(.+)$/m);
+    if (invocableMatch)
+        frontmatter['user-invocable'] = invocableMatch[1].trim() === 'true';
+    // Parse allowed-tools (YAML list)
+    const toolsMatch = frontmatterRaw.match(/^allowed-tools:\n((?:\s+-\s+.+\n?)+)/m);
+    if (toolsMatch) {
+        frontmatter['allowed-tools'] = toolsMatch[1]
+            .split('\n')
+            .map(line => line.replace(/^\s+-\s+/, '').trim())
+            .filter(Boolean);
+    }
+    return { frontmatter, body };
+}
+/**
+ * Load all skills from a skills directory (expects commands/ and workflows/ subdirs).
+ */
+export function loadSkills(skillsDir) {
+    const skills = [];
+    for (const category of ['commands', 'workflows']) {
+        const categoryDir = path.join(skillsDir, category);
+        if (!fs.existsSync(categoryDir))
+            continue;
+        for (const file of fs.readdirSync(categoryDir)) {
+            if (!file.endsWith('.md'))
+                continue;
+            const raw = fs.readFileSync(path.join(categoryDir, file), 'utf-8');
+            const parsed = parseFrontmatter(raw);
+            if (!parsed || !parsed.frontmatter.description) {
+                console.warn(`Warning: could not parse frontmatter for ${file}, skipping`);
+                continue;
+            }
+            skills.push({
+                filename: file,
+                category,
+                frontmatter: parsed.frontmatter,
+                body: parsed.body,
+                raw,
+            });
+        }
+    }
+    return skills;
+}

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

@@ -0,0 +1,41 @@
+import { Skill } from '../skills.js';
+import { Transformer, TransformResult } from './types.js';
+/**
+ * Transform a skill into Claude Code plugin format.
+ * Each skill becomes a directory with SKILL.md inside skills/<skill-name>/
+ */
+export declare function transformForClaude(skill: Skill): TransformResult[];
+/**
+ * Fallback cache directory when the CLI install didn't create one.
+ */
+export declare function getClaudePluginCacheDir(): string;
+export interface SettingsMutationResult {
+    registered: boolean;
+    backupPath?: string;
+}
+/**
+ * Merge-add the memtrace MCP server into a Claude settings.json file.
+ * Never overwrites a malformed file — backs it up and returns registered=false.
+ */
+export declare function registerMcpInSettingsAt(settingsPath: string, memtraceBinary: string): SettingsMutationResult;
+/**
+ * Merge-add plugin + marketplace entries into a Claude settings.json file.
+ * Never overwrites a malformed file.
+ */
+export declare function enablePluginInSettingsAt(settingsPath: string): SettingsMutationResult;
+/**
+ * Full Claude Code plugin installation.
+ *
+ *  1. Try `claude plugin marketplace add` + `claude plugin install`
+ *  2. Fall back to manual: write cache files + update settings.json
+ *  3. Register MCP server for memtrace tools
+ */
+export declare function installClaudePlugin(skills: Skill[], memtraceBinaryPath: string): Promise<{
+    cacheDir: string;
+    skillCount: number;
+}>;
+/**
+ * Remove the Claude Code plugin and MCP server registration.
+ */
+export declare function uninstallClaudePlugin(): Promise<void>;
+export declare const claudeTransformer: Transformer;

package/installer/dist/transformers/claude.js

@@ -0,0 +1,400 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execCommand, commandExists } from '../utils.js';
+import { safeReadJson, writeJsonAtomic } from '../fs-safe.js';
+const PLUGIN_NAME = 'memtrace-skills';
+const MARKETPLACE_NAME = 'memtrace';
+const MARKETPLACE_REPO = 'syncable-dev/memtrace';
+/**
+ * Try to register the memtrace MCP server via `claude mcp add-json`.
+ * Returns true on success, false on timeout/error/missing CLI.
+ * 5-second timeout — we fall back to direct JSON merge fast.
+ */
+async function tryMcpAddJson(memtraceBinary) {
+    if (!(await commandExists('claude')))
+        return false;
+    const config = JSON.stringify({
+        command: memtraceBinary,
+        args: ['mcp'],
+        env: { MEMGRAPH_URL: 'bolt://localhost:7687' },
+    });
+    // Shell-quote the JSON. Use single quotes; escape any embedded single quote.
+    const escaped = config.replace(/'/g, `'\\''`);
+    try {
+        await execCommand(`claude mcp add-json --scope user memtrace '${escaped}'`, { timeoutMs: 5_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Transform a skill into Claude Code plugin format.
+ * Each skill becomes a directory with SKILL.md inside skills/<skill-name>/
+ */
+export function transformForClaude(skill) {
+    const skillName = skill.filename.replace(/\.md$/, '');
+    const safeDesc = skill.frontmatter.description
+        .replace(/"/g, '\\"')
+        .trim();
+    const content = `---\nname: ${skillName}\ndescription: "${safeDesc}"\n---\n\n${skill.body}`;
+    return [{ relativePath: `skills/${skillName}/SKILL.md`, content }];
+}
+/**
+ * Root directory for all cached versions of this plugin.
+ */
+function getPluginCacheRoot() {
+    return path.join(os.homedir(), '.claude', 'plugins', 'cache', MARKETPLACE_NAME, PLUGIN_NAME);
+}
+/**
+ * Find the cache directory that Claude Code's CLI created (from `claude plugin install`).
+ */
+function findCliInstalledCacheDir() {
+    const root = getPluginCacheRoot();
+    if (!fs.existsSync(root))
+        return null;
+    for (const entry of fs.readdirSync(root)) {
+        const dir = path.join(root, entry);
+        if (!fs.statSync(dir).isDirectory())
+            continue;
+        return dir;
+    }
+    return null;
+}
+/**
+ * Fallback cache directory when the CLI install didn't create one.
+ */
+export function getClaudePluginCacheDir() {
+    return path.join(getPluginCacheRoot(), '0.0.0');
+}
+// ────────────────────────────────────────────────────────────────────────────
+// Installation strategy (in priority order):
+//
+//   1. `claude plugin marketplace add` + `claude plugin install`
+//      The official flow. Registers the marketplace, clones the plugin,
+//      caches it, AND auto-enables it in settings.
+//
+//   2. Manual write: cache files + enabledPlugins in settings.json
+//      If the CLI is unavailable, write plugin files directly to the
+//      cache directory AND register in ~/.claude/settings.json.
+// ────────────────────────────────────────────────────────────────────────────
+/**
+ * Try to install the plugin via the Claude Code CLI.
+ */
+async function tryClaudeCliInstall() {
+    const hasClaude = await commandExists('claude');
+    if (!hasClaude)
+        return false;
+    try {
+        await execCommand(`claude plugin marketplace add ${MARKETPLACE_REPO}`);
+    }
+    catch {
+        // Marketplace may already exist
+    }
+    try {
+        await execCommand(`claude plugin install ${PLUGIN_NAME}@${MARKETPLACE_NAME} --scope user`);
+        return true;
+    }
+    catch {
+        try {
+            const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+            if (fs.existsSync(settingsPath)) {
+                const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+                const key = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+                if (settings.enabledPlugins?.[key] === true) {
+                    return true;
+                }
+            }
+        }
+        catch {
+            // Fall through to manual
+        }
+        return false;
+    }
+}
+/**
+ * Write the plugin.json manifest inside the cache directory.
+ */
+function writePluginManifest(cacheDir) {
+    const manifestDir = path.join(cacheDir, '.claude-plugin');
+    fs.mkdirSync(manifestDir, { recursive: true });
+    const version = path.basename(cacheDir);
+    const manifest = {
+        name: PLUGIN_NAME,
+        description: 'Memtrace skills for codebase exploration, code search, relationship analysis, temporal evolution, blast radius impact, code quality, graph algorithms, API topology, and multi-step workflows.',
+        version,
+        author: {
+            name: 'Syncable',
+            email: 'support@syncable.dev',
+        },
+        homepage: 'https://memtrace.io',
+        repository: `https://github.com/${MARKETPLACE_REPO}`,
+        license: 'SEE LICENSE IN LICENSE',
+        keywords: ['memtrace', 'code-intelligence', 'knowledge-graph', 'mcp', 'temporal-analysis'],
+    };
+    fs.writeFileSync(path.join(manifestDir, 'plugin.json'), JSON.stringify(manifest, null, 2));
+}
+/**
+ * Merge-add the memtrace MCP server into a Claude settings.json file.
+ * Never overwrites a malformed file — backs it up and returns registered=false.
+ */
+export function registerMcpInSettingsAt(settingsPath, memtraceBinary) {
+    const { value, corrupted, backupPath } = safeReadJson(settingsPath);
+    if (corrupted) {
+        console.warn(`memtrace: ${settingsPath} is malformed; backed up to ${backupPath}. Skipped MCP registration for Claude.`);
+        console.warn(`memtrace: fix the file and run 'memtrace install --repair'.`);
+        return { registered: false, backupPath };
+    }
+    const settings = (value ?? {});
+    settings.mcpServers = settings.mcpServers ?? {};
+    settings.mcpServers['memtrace'] = {
+        command: memtraceBinary,
+        args: ['mcp'],
+        env: { MEMGRAPH_URL: 'bolt://localhost:7687' },
+    };
+    writeJsonAtomic(settingsPath, settings);
+    return { registered: true };
+}
+/**
+ * Merge-add plugin + marketplace entries into a Claude settings.json file.
+ * Never overwrites a malformed file.
+ */
+export function enablePluginInSettingsAt(settingsPath) {
+    const { value, corrupted, backupPath } = safeReadJson(settingsPath);
+    if (corrupted) {
+        console.warn(`memtrace: ${settingsPath} is malformed; backed up to ${backupPath}.`);
+        return { registered: false, backupPath };
+    }
+    const settings = (value ?? {});
+    settings.enabledPlugins = settings.enabledPlugins ?? {};
+    settings.enabledPlugins[`${PLUGIN_NAME}@${MARKETPLACE_NAME}`] = true;
+    settings.extraKnownMarketplaces = settings.extraKnownMarketplaces ?? {};
+    settings.extraKnownMarketplaces[MARKETPLACE_NAME] = {
+        source: { source: 'github', repo: MARKETPLACE_REPO },
+    };
+    writeJsonAtomic(settingsPath, settings);
+    return { registered: true };
+}
+/**
+ * Enable the plugin in ~/.claude/settings.json.
+ */
+function enablePluginInSettings() {
+    const settingsFile = path.join(os.homedir(), '.claude', 'settings.json');
+    enablePluginInSettingsAt(settingsFile);
+}
+/**
+ * Register the memtrace MCP server in Claude Code's settings.
+ * This adds the MCP server config so Claude Code can connect to memtrace tools.
+ */
+async function registerMcpServer(memtraceBinaryPath) {
+    // Strategy 1 (preferred): claude CLI's own add-json path
+    const viaCli = await tryMcpAddJson(memtraceBinaryPath);
+    if (viaCli)
+        return;
+    // Strategy 2 (fallback): direct settings.json merge (safe + atomic)
+    const settingsFile = path.join(os.homedir(), '.claude', 'settings.json');
+    registerMcpInSettingsAt(settingsFile, memtraceBinaryPath);
+}
+/**
+ * Full Claude Code plugin installation.
+ *
+ *  1. Try `claude plugin marketplace add` + `claude plugin install`
+ *  2. Fall back to manual: write cache files + update settings.json
+ *  3. Register MCP server for memtrace tools
+ */
+export async function installClaudePlugin(skills, memtraceBinaryPath) {
+    // Step 1: Try CLI install
+    await tryClaudeCliInstall();
+    // Step 2: Find or create cache dir
+    let cacheDir = findCliInstalledCacheDir();
+    if (cacheDir) {
+        const orphanedFile = path.join(cacheDir, '.orphaned_at');
+        if (fs.existsSync(orphanedFile))
+            fs.unlinkSync(orphanedFile);
+    }
+    else {
+        cacheDir = getClaudePluginCacheDir();
+    }
+    // Step 3: Clean up old versions
+    const pluginRoot = getPluginCacheRoot();
+    if (fs.existsSync(pluginRoot)) {
+        const activeDirName = path.basename(cacheDir);
+        for (const entry of fs.readdirSync(pluginRoot)) {
+            if (entry !== activeDirName && entry !== '.DS_Store') {
+                fs.rmSync(path.join(pluginRoot, entry), { recursive: true, force: true });
+            }
+        }
+    }
+    // Step 4: Write skills
+    const skillsDir = path.join(cacheDir, 'skills');
+    if (fs.existsSync(skillsDir)) {
+        fs.rmSync(skillsDir, { recursive: true });
+    }
+    for (const skill of skills) {
+        const results = transformForClaude(skill);
+        for (const { relativePath, content } of results) {
+            const fullPath = path.join(cacheDir, relativePath);
+            fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+            fs.writeFileSync(fullPath, content);
+        }
+    }
+    writePluginManifest(cacheDir);
+    enablePluginInSettings();
+    // Step 5: Register MCP server
+    await registerMcpServer(memtraceBinaryPath);
+    // Step 6: Write user-level skills for SDK-based integrations
+    writeUserLevelSkills(skills);
+    return { cacheDir, skillCount: skills.length };
+}
+/**
+ * Write skills to ~/.claude/skills/ for SDK-based integrations.
+ */
+function writeUserLevelSkills(skills) {
+    const userSkillsDir = path.join(os.homedir(), '.claude', 'skills');
+    for (const skill of skills) {
+        const skillName = skill.filename.replace(/\.md$/, '');
+        const safeDesc = skill.frontmatter.description.replace(/"/g, '\\"').trim();
+        const content = `---\nname: ${skillName}\ndescription: "${safeDesc}"\n---\n\n${skill.body}`;
+        const outDir = path.join(userSkillsDir, skillName);
+        fs.mkdirSync(outDir, { recursive: true });
+        fs.writeFileSync(path.join(outDir, 'SKILL.md'), content);
+    }
+}
+/**
+ * Remove the Claude Code plugin and MCP server registration.
+ */
+export async function uninstallClaudePlugin() {
+    const hasClaude = await commandExists('claude');
+    if (hasClaude) {
+        try {
+            await execCommand(`claude plugin uninstall ${PLUGIN_NAME}@${MARKETPLACE_NAME} --scope user`);
+        }
+        catch { /* fall through */ }
+    }
+    // Manual cleanup
+    const cacheRoot = getPluginCacheRoot();
+    if (fs.existsSync(cacheRoot)) {
+        fs.rmSync(cacheRoot, { recursive: true });
+    }
+    // Remove from settings.json
+    const settingsFile = path.join(os.homedir(), '.claude', 'settings.json');
+    if (fs.existsSync(settingsFile)) {
+        try {
+            const settings = JSON.parse(fs.readFileSync(settingsFile, 'utf-8'));
+            const pluginKey = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+            if (settings.enabledPlugins && typeof settings.enabledPlugins === 'object') {
+                delete settings.enabledPlugins[pluginKey];
+            }
+            if (settings.mcpServers && typeof settings.mcpServers === 'object') {
+                delete settings.mcpServers['memtrace'];
+            }
+            fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
+        }
+        catch { /* */ }
+    }
+    // Clean up user-level skills
+    const userSkillsDir = path.join(os.homedir(), '.claude', 'skills');
+    if (fs.existsSync(userSkillsDir)) {
+        for (const entry of fs.readdirSync(userSkillsDir)) {
+            if (entry.startsWith('memtrace-')) {
+                const entryPath = path.join(userSkillsDir, entry);
+                const stat = fs.statSync(entryPath);
+                if (stat.isDirectory()) {
+                    fs.rmSync(entryPath, { recursive: true });
+                }
+                else if (entry.endsWith('.md')) {
+                    fs.unlinkSync(entryPath);
+                }
+            }
+        }
+    }
+}
+/**
+ * Write/merge the memtrace MCP server entry into a project-local .mcp.json.
+ * Safe-reads existing config; never overwrites a malformed file.
+ */
+function writeClaudeLocalMcp(mcpPath, binary) {
+    const { value, corrupted, backupPath } = safeReadJson(mcpPath);
+    if (corrupted) {
+        console.warn(`memtrace: ${mcpPath} is malformed; backed up to ${backupPath}. Skipped MCP registration.`);
+        return false;
+    }
+    const cfg = (value ?? {});
+    cfg.mcpServers = cfg.mcpServers ?? {};
+    cfg.mcpServers['memtrace'] = {
+        command: binary,
+        args: ['mcp'],
+        env: { MEMGRAPH_URL: 'bolt://localhost:7687' },
+    };
+    writeJsonAtomic(mcpPath, cfg);
+    return true;
+}
+export const claudeTransformer = {
+    name: 'claude',
+    async install(skills, ctx) {
+        if (ctx.scope === 'global') {
+            const { skillCount } = await installClaudePlugin(skills, ctx.memtraceBinary);
+            return {
+                agent: 'claude',
+                skillsWritten: skillCount,
+                skillsDir: path.join(os.homedir(), '.claude', 'skills'),
+                mcpConfigPath: path.join(os.homedir(), '.claude', 'settings.json'),
+                mcpRegistered: !ctx.skipMcp,
+                warnings: [],
+            };
+        }
+        // Local scope: write skills into <cwd>/.claude/skills/
+        const skillsDir = path.join(ctx.cwd, '.claude', 'skills');
+        let count = 0;
+        for (const skill of skills) {
+            const skillName = skill.filename.replace(/\.md$/, '');
+            const outDir = path.join(skillsDir, skillName);
+            fs.mkdirSync(outDir, { recursive: true });
+            const safeDesc = skill.frontmatter.description.replace(/"/g, '\\"').trim();
+            const content = `---\nname: ${skillName}\ndescription: "${safeDesc}"\n---\n\n${skill.body}`;
+            fs.writeFileSync(path.join(outDir, 'SKILL.md'), content);
+            count++;
+        }
+        // MCP for local scope: .mcp.json at project root (Claude's project-level convention)
+        const mcpConfigPath = path.join(ctx.cwd, '.mcp.json');
+        let mcpRegistered = false;
+        if (!ctx.skipMcp) {
+            mcpRegistered = writeClaudeLocalMcp(mcpConfigPath, ctx.memtraceBinary);
+        }
+        return {
+            agent: 'claude',
+            skillsWritten: count,
+            skillsDir,
+            mcpConfigPath,
+            mcpRegistered,
+            warnings: [],
+        };
+    },
+    async uninstall(ctx) {
+        if (ctx.scope === 'global') {
+            await uninstallClaudePlugin();
+            return;
+        }
+        // Local: remove <cwd>/.claude/skills/memtrace-* and the memtrace entry from <cwd>/.mcp.json
+        const skillsDir = path.join(ctx.cwd, '.claude', 'skills');
+        if (fs.existsSync(skillsDir)) {
+            for (const entry of fs.readdirSync(skillsDir)) {
+                if (entry.startsWith('memtrace-')) {
+                    fs.rmSync(path.join(skillsDir, entry), { recursive: true, force: true });
+                }
+            }
+        }
+        const mcpPath = path.join(ctx.cwd, '.mcp.json');
+        const { value, corrupted } = safeReadJson(mcpPath);
+        if (!corrupted && value?.mcpServers?.['memtrace']) {
+            delete value.mcpServers['memtrace'];
+            if (Object.keys(value.mcpServers).length === 0)
+                delete value.mcpServers;
+            if (Object.keys(value).length === 0)
+                fs.unlinkSync(mcpPath);
+            else
+                writeJsonAtomic(mcpPath, value);
+        }
+    },
+};

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

@@ -0,0 +1,7 @@
+import { Transformer } from './types.js';
+export interface CursorMcpResult {
+    registered: boolean;
+    backupPath?: string;
+}
+export declare function registerCursorMcpAt(mcpFile: string, binary: string): CursorMcpResult;
+export declare const cursorTransformer: Transformer;