memtrace-skills 0.7.10

package/dist/transformers/codex.d.ts

@@ -0,0 +1,8 @@
+import { Transformer, InstallContext } from './types.js';
+export declare function codexConfigPath(ctx: InstallContext): string;
+export declare function stripCodexMcpServer(raw: string): string;
+export interface CodexMcpResult {
+    registered: boolean;
+}
+export declare function registerCodexMcpAt(configFile: string, binary: string): CodexMcpResult;
+export declare const codexTransformer: Transformer;

package/dist/transformers/codex.js

@@ -0,0 +1,294 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { commandExists, execCommand } from '../utils.js';
+import { registerSettingsHook, removeSettingsHook, CODEX_MATCHER, } from './rail-hooks.js';
+const MCP_SERVER_NAME = 'memtrace';
+const CODEX_MCP_SHIM_NAME = 'memtrace-mcp-codex-shim.cjs';
+function codexRailHooksPath(ctx) {
+    const base = ctx.scope === 'global' ? path.join(os.homedir(), '.codex') : path.join(ctx.cwd, '.codex');
+    return path.join(base, 'hooks.json');
+}
+function skillsRoot(ctx) {
+    const base = ctx.scope === 'global' ? os.homedir() : ctx.cwd;
+    return path.join(base, '.agents', 'skills');
+}
+export function codexConfigPath(ctx) {
+    const base = ctx.scope === 'global' ? path.join(os.homedir(), '.codex') : path.join(ctx.cwd, '.codex');
+    return path.join(base, 'config.toml');
+}
+function writeSkill(skill, rootDir) {
+    const name = skill.filename.replace(/\.md$/, '');
+    const outDir = path.join(rootDir, name);
+    fs.mkdirSync(outDir, { recursive: true });
+    const safeDesc = skill.frontmatter.description.replace(/"/g, '\\"').trim();
+    const content = `---\nname: ${name}\ndescription: "${safeDesc}"\n---\n\n${skill.body}`;
+    fs.writeFileSync(path.join(outDir, 'SKILL.md'), content);
+}
+function tomlString(value) {
+    return `"${value
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')}"`;
+}
+function writeTextAtomic(filePath, content) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(tmpPath, content);
+    fs.renameSync(tmpPath, filePath);
+}
+function codexMcpShimSource() {
+    return `#!/usr/bin/env node
+const { spawn } = require('node:child_process');
+
+const binary = process.argv[2] || 'memtrace';
+const child = spawn(binary, ['mcp'], { stdio: ['pipe', 'pipe', 'pipe'] });
+
+process.stdin.pipe(child.stdin);
+child.stderr.pipe(process.stderr);
+
+function stripAnnotations(line) {
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    return line;
+  }
+
+  const content = message && message.result && message.result.content;
+  if (!Array.isArray(content)) return line;
+
+  const assistantItems = [];
+  const fallbackItems = [];
+  for (const item of content) {
+    if (!item || typeof item !== 'object') continue;
+    const clean = { ...item };
+    const annotations = clean.annotations;
+    delete clean.annotations;
+    fallbackItems.push(clean);
+    const audience = annotations && annotations.audience;
+    if (Array.isArray(audience) && audience.includes('assistant')) {
+      assistantItems.push(clean);
+    }
+  }
+
+  message.result.content = assistantItems.length > 0 ? assistantItems : fallbackItems;
+  return JSON.stringify(message);
+}
+
+let buffer = '';
+child.stdout.on('data', (chunk) => {
+  buffer += chunk.toString('utf8');
+  let index = buffer.indexOf('\\n');
+  while (index !== -1) {
+    const line = buffer.slice(0, index);
+    buffer = buffer.slice(index + 1);
+    process.stdout.write(stripAnnotations(line) + '\\n');
+    index = buffer.indexOf('\\n');
+  }
+});
+
+child.stdout.on('end', () => {
+  if (buffer.length > 0) process.stdout.write(stripAnnotations(buffer));
+});
+
+child.on('exit', (code, signal) => {
+  if (signal) process.kill(process.pid, signal);
+  process.exit(code ?? 0);
+});
+`;
+}
+function codexMcpShimPath(configFile) {
+    return path.join(path.dirname(configFile), CODEX_MCP_SHIM_NAME);
+}
+function writeCodexMcpShim(configFile) {
+    const shimPath = codexMcpShimPath(configFile);
+    writeTextAtomic(shimPath, codexMcpShimSource());
+    try {
+        fs.chmodSync(shimPath, 0o755);
+    }
+    catch {
+        // Windows and locked-down filesystems may reject chmod; Codex invokes it
+        // through Node, so executable bits are a convenience, not a requirement.
+    }
+    return shimPath;
+}
+function isMemtraceMcpTable(tableName) {
+    return tableName === `mcp_servers.${MCP_SERVER_NAME}`
+        || tableName === `mcp_servers."${MCP_SERVER_NAME}"`
+        || tableName.startsWith(`mcp_servers.${MCP_SERVER_NAME}.`)
+        || tableName.startsWith(`mcp_servers."${MCP_SERVER_NAME}".`);
+}
+/**
+ * Tables we want stripped on re-registration.
+ *
+ * PRESERVE [mcp_servers.memtrace.env] so user-set env vars
+ * (MEMTRACE_LICENSE_KEY, etc.) survive `memtrace install` re-registration.
+ * Only the top-level table + non-env sub-tables get stripped.
+ */
+function isMemtraceMcpTableToStrip(tableName) {
+    if (tableName === `mcp_servers.${MCP_SERVER_NAME}.env`)
+        return false;
+    if (tableName === `mcp_servers."${MCP_SERVER_NAME}".env`)
+        return false;
+    return isMemtraceMcpTable(tableName);
+}
+export function stripCodexMcpServer(raw) {
+    const lines = raw.split(/\r?\n/);
+    const kept = [];
+    let skipping = false;
+    for (const line of lines) {
+        const table = line.match(/^\s*\[([^\]]+)\]\s*$/);
+        if (table) {
+            skipping = isMemtraceMcpTableToStrip(table[1].trim());
+            if (skipping)
+                continue;
+        }
+        if (!skipping)
+            kept.push(line);
+    }
+    return kept.join('\n').trimEnd();
+}
+/**
+ * Extracts the preserved `[mcp_servers.memtrace.env]` block (if any) and
+ * returns:
+ *   - rest: the input with the env block removed
+ *   - envBlock: the env block as a string (empty if absent)
+ *
+ * Used by `registerCodexMcpAt` so the env block can be reattached AFTER the
+ * freshly-written `[mcp_servers.memtrace]` parent for readable ordering.
+ */
+function extractMemtraceEnvBlock(raw) {
+    const lines = raw.split(/\r?\n/);
+    const rest = [];
+    const envLines = [];
+    let inEnv = false;
+    for (const line of lines) {
+        const table = line.match(/^\s*\[([^\]]+)\]\s*$/);
+        if (table) {
+            const name = table[1].trim();
+            const isEnv = name === `mcp_servers.${MCP_SERVER_NAME}.env`
+                || name === `mcp_servers."${MCP_SERVER_NAME}".env`;
+            if (isEnv) {
+                inEnv = true;
+                envLines.push(line);
+                continue;
+            }
+            // Any other table header closes the env capture.
+            inEnv = false;
+        }
+        if (inEnv) {
+            envLines.push(line);
+        }
+        else {
+            rest.push(line);
+        }
+    }
+    return {
+        rest: rest.join('\n').replace(/\n+$/, ''),
+        envBlock: envLines.join('\n').replace(/\n+$/, ''),
+    };
+}
+export function registerCodexMcpAt(configFile, binary) {
+    const existing = fs.existsSync(configFile) ? fs.readFileSync(configFile, 'utf-8') : '';
+    // Strip leaves the env sub-table intact; split it out so we can reorder it
+    // after the freshly written parent block for readability.
+    const stripped = stripCodexMcpServer(existing);
+    const { rest, envBlock } = extractMemtraceEnvBlock(stripped);
+    const shimPath = writeCodexMcpShim(configFile);
+    const block = [
+        `[mcp_servers.${MCP_SERVER_NAME}]`,
+        `command = ${tomlString(process.execPath)}`,
+        `args = [${[shimPath, binary].map(tomlString).join(', ')}]`,
+    ].join('\n');
+    const parts = [];
+    if (rest)
+        parts.push(rest);
+    parts.push(block);
+    if (envBlock)
+        parts.push(envBlock);
+    const next = `${parts.join('\n\n')}\n`;
+    writeTextAtomic(configFile, next);
+    return { registered: true };
+}
+function shellQuote(value) {
+    if (process.platform === 'win32')
+        return `"${value.replace(/"/g, '\\"')}"`;
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+async function tryCodexMcpAdd(binary) {
+    if (!(await commandExists('codex')))
+        return false;
+    try {
+        await execCommand(`codex mcp add ${MCP_SERVER_NAME} -- ${shellQuote(binary)} mcp`, { timeoutMs: 5_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const codexTransformer = {
+    name: 'codex',
+    async install(skills, ctx) {
+        const rootDir = skillsRoot(ctx);
+        if (fs.existsSync(rootDir)) {
+            for (const entry of fs.readdirSync(rootDir)) {
+                if (entry.startsWith('memtrace-')) {
+                    fs.rmSync(path.join(rootDir, entry), { recursive: true, force: true });
+                }
+            }
+        }
+        for (const s of skills)
+            writeSkill(s, rootDir);
+        let mcpRegistered = false;
+        const warnings = [];
+        const mcpConfigPath = codexConfigPath(ctx);
+        if (!ctx.skipMcp) {
+            const cliRegistered = ctx.scope === 'global' && await tryCodexMcpAdd(ctx.memtraceBinary);
+            registerCodexMcpAt(mcpConfigPath, ctx.memtraceBinary);
+            mcpRegistered = true;
+            if (ctx.scope === 'global' && !cliRegistered) {
+                warnings.push('codex CLI MCP registration was unavailable; wrote ~/.codex/config.toml directly.');
+            }
+        }
+        // ─── memtrace-rail ─── Wire the discovery hook into .codex/hooks.json
+        // (PreToolUse, Bash matcher — Codex code discovery runs through the shell).
+        try {
+            registerSettingsHook(codexRailHooksPath(ctx), ctx.memtraceBinary, 'codex', 'PreToolUse', CODEX_MATCHER);
+        }
+        catch (e) {
+            warnings.push(`failed to register Codex Rail hook: ${e.message}`);
+        }
+        return {
+            agent: 'codex',
+            skillsWritten: skills.length,
+            skillsDir: rootDir,
+            mcpConfigPath,
+            mcpRegistered,
+            warnings,
+        };
+    },
+    async uninstall(ctx) {
+        const rootDir = skillsRoot(ctx);
+        if (fs.existsSync(rootDir)) {
+            for (const entry of fs.readdirSync(rootDir)) {
+                if (entry.startsWith('memtrace-')) {
+                    fs.rmSync(path.join(rootDir, entry), { recursive: true, force: true });
+                }
+            }
+        }
+        try {
+            removeSettingsHook(codexRailHooksPath(ctx), 'PreToolUse');
+        }
+        catch { /* best effort */ }
+        const configFile = codexConfigPath(ctx);
+        if (fs.existsSync(configFile)) {
+            const next = stripCodexMcpServer(fs.readFileSync(configFile, 'utf-8'));
+            if (next.trim())
+                writeTextAtomic(configFile, `${next}\n`);
+            else
+                fs.unlinkSync(configFile);
+        }
+    },
+};

package/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;

package/dist/transformers/cursor.js

@@ -0,0 +1,124 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { safeReadJson, writeJsonAtomic } from '../fs-safe.js';
+import { MEMTRACE_MCP_ENV } from './shared.js';
+import { registerCursorRailHook, removeCursorRailHook } from './rail-hooks.js';
+function skillsRoot(ctx) {
+    const base = ctx.scope === 'global' ? os.homedir() : ctx.cwd;
+    return path.join(base, '.cursor', 'skills');
+}
+function mcpPath(ctx) {
+    const base = ctx.scope === 'global' ? os.homedir() : ctx.cwd;
+    return path.join(base, '.cursor', 'mcp.json');
+}
+function railHooksPath(ctx) {
+    const base = ctx.scope === 'global' ? os.homedir() : ctx.cwd;
+    return path.join(base, '.cursor', 'hooks.json');
+}
+function writeSkill(skill, rootDir) {
+    const name = skill.filename.replace(/\.md$/, '');
+    const outDir = path.join(rootDir, name);
+    fs.mkdirSync(outDir, { recursive: true });
+    const safeDesc = skill.frontmatter.description.replace(/"/g, '\\"').trim();
+    // Cursor requires frontmatter `name` matching the folder name.
+    const content = `---\nname: ${name}\ndescription: "${safeDesc}"\n---\n\n${skill.body}`;
+    fs.writeFileSync(path.join(outDir, 'SKILL.md'), content);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function registerCursorMcpAt(mcpFile, binary) {
+    const { value, corrupted, backupPath } = safeReadJson(mcpFile);
+    if (corrupted) {
+        console.warn(`memtrace: ${mcpFile} is malformed; backed up to ${backupPath}. Skipped Cursor MCP registration.`);
+        return { registered: false, backupPath };
+    }
+    const cfg = (value ?? {});
+    cfg.mcpServers = cfg.mcpServers ?? {};
+    // Deep-merge env: preserve user-set keys (e.g. MEMTRACE_LICENSE_KEY) across
+    // re-registration; memtrace-owned defaults (MEMTRACE_MCP_ENV) win on conflict.
+    const existing = cfg.mcpServers['memtrace'];
+    const existingEnv = (isRecord(existing) && isRecord(existing.env))
+        ? existing.env
+        : {};
+    const mergedEnv = {
+        ...existingEnv,
+        ...MEMTRACE_MCP_ENV,
+        MEMTRACE_WORKSPACE_ROOT: '${workspaceFolder}',
+    };
+    cfg.mcpServers['memtrace'] = {
+        command: binary,
+        args: ['mcp'],
+        env: mergedEnv,
+    };
+    writeJsonAtomic(mcpFile, cfg);
+    return { registered: true };
+}
+export const cursorTransformer = {
+    name: 'cursor',
+    async install(skills, ctx) {
+        const rootDir = skillsRoot(ctx);
+        if (fs.existsSync(rootDir)) {
+            for (const entry of fs.readdirSync(rootDir)) {
+                if (entry.startsWith('memtrace-')) {
+                    fs.rmSync(path.join(rootDir, entry), { recursive: true, force: true });
+                }
+            }
+        }
+        for (const s of skills)
+            writeSkill(s, rootDir);
+        let mcpRegistered = false;
+        if (!ctx.skipMcp) {
+            const result = registerCursorMcpAt(mcpPath(ctx), ctx.memtraceBinary);
+            mcpRegistered = result.registered;
+        }
+        // ─── memtrace-rail ─── Wire the Memtrace-first discovery hook (default
+        // observe). Failure must not block the rest of the install.
+        try {
+            registerCursorRailHook(railHooksPath(ctx), ctx.memtraceBinary);
+        }
+        catch (e) {
+            console.warn(`memtrace: failed to register Cursor Rail hook: ${e.message}`);
+        }
+        return {
+            agent: 'cursor',
+            skillsWritten: skills.length,
+            skillsDir: rootDir,
+            mcpConfigPath: mcpPath(ctx),
+            mcpRegistered,
+            warnings: [],
+        };
+    },
+    async uninstall(ctx) {
+        // 1. Remove memtrace-* skill dirs
+        const rootDir = skillsRoot(ctx);
+        if (fs.existsSync(rootDir)) {
+            for (const entry of fs.readdirSync(rootDir)) {
+                if (entry.startsWith('memtrace-')) {
+                    fs.rmSync(path.join(rootDir, entry), { recursive: true, force: true });
+                }
+            }
+        }
+        // 1b. Remove the Rail hook.
+        try {
+            removeCursorRailHook(railHooksPath(ctx));
+        }
+        catch { /* best effort */ }
+        // 2. Remove memtrace entry from mcp.json; delete file if empty
+        const mcpFile = mcpPath(ctx);
+        const { value, corrupted } = safeReadJson(mcpFile);
+        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(mcpFile);
+            }
+            else {
+                writeJsonAtomic(mcpFile, value);
+            }
+        }
+    },
+};

package/dist/transformers/gemini.d.ts

@@ -0,0 +1,3 @@
+import { Transformer, InstallContext } from './types.js';
+export declare function geminiSettingsPath(ctx: InstallContext): string;
+export declare const geminiTransformer: Transformer;

package/dist/transformers/gemini.js

@@ -0,0 +1,78 @@
+import os from 'os';
+import path from 'path';
+import { registerMcpServersJsonAt, removeMcpServersJsonAt, removeMemtraceSkills, writeSkills, } from './shared.js';
+import { registerSettingsHook, removeSettingsHook, GEMINI_MATCHER, } from './rail-hooks.js';
+/**
+ * Gemini CLI transformer.
+ *
+ * Gemini CLI (v0.26+) supports:
+ *  - MCP servers in `.gemini/settings.json` under `mcpServers` — the SAME
+ *    shape as the generic JSON registration (`command`/`args`/`env`).
+ *  - Lifecycle hooks under `hooks.BeforeTool` (matcher against the tool name,
+ *    e.g. `run_shell_command`) — where Memtrace Rail wires the discovery hook.
+ *
+ * Both live in the one `settings.json`; we register MCP first, then the Rail
+ * hook (each is a read-modify-write that preserves the other's keys).
+ */
+function geminiBase(ctx) {
+    return ctx.scope === 'global' ? path.join(os.homedir(), '.gemini') : path.join(ctx.cwd, '.gemini');
+}
+function skillsRoot(ctx) {
+    return path.join(geminiBase(ctx), 'skills');
+}
+export function geminiSettingsPath(ctx) {
+    return path.join(geminiBase(ctx), 'settings.json');
+}
+export const geminiTransformer = {
+    name: 'gemini',
+    async install(skills, ctx) {
+        const warnings = [];
+        const rootDir = skillsRoot(ctx);
+        // Skills as Markdown context files (Gemini reads MCP-server instructions
+        // for tool guidance; the skill files document the Memtrace-first workflow).
+        const skillsWritten = writeSkills(skills, rootDir);
+        const settingsPath = geminiSettingsPath(ctx);
+        let mcpRegistered = false;
+        if (!ctx.skipMcp) {
+            const result = registerMcpServersJsonAt(settingsPath, ctx.memtraceBinary);
+            mcpRegistered = result.registered;
+            if (!mcpRegistered && result.backupPath) {
+                warnings.push(`Gemini settings.json was malformed; backed up to ${result.backupPath}.`);
+            }
+        }
+        // ─── memtrace-rail ─── Wire the BeforeTool discovery hook (default
+        // observe). Matches Gemini's shell/read/glob/grep tool names. Gemini gates
+        // its hook system behind `enableHooks` + `enableMessageBusIntegration`
+        // (PR #14460) — without them a registered BeforeTool hook NEVER fires, so we
+        // enable both here (only if the user hasn't already set them).
+        try {
+            registerSettingsHook(settingsPath, ctx.memtraceBinary, 'gemini', 'BeforeTool', GEMINI_MATCHER, {
+                enableHooks: true,
+                enableMessageBusIntegration: true,
+            });
+        }
+        catch (e) {
+            warnings.push(`failed to register Gemini Rail hook: ${e.message}`);
+        }
+        return {
+            agent: 'gemini',
+            skillsWritten,
+            skillsDir: rootDir,
+            mcpConfigPath: settingsPath,
+            mcpRegistered,
+            warnings,
+        };
+    },
+    async uninstall(ctx) {
+        removeMemtraceSkills(skillsRoot(ctx));
+        const settingsPath = geminiSettingsPath(ctx);
+        try {
+            removeSettingsHook(settingsPath, 'BeforeTool');
+        }
+        catch { /* best effort */ }
+        try {
+            removeMcpServersJsonAt(settingsPath);
+        }
+        catch { /* best effort */ }
+    },
+};

package/dist/transformers/hermes.d.ts

@@ -0,0 +1,5 @@
+import { Transformer } from './types.js';
+export declare function hermesConfigPath(): string;
+export declare function registerHermesMcpAt(configFile: string, binary: string): void;
+export declare function removeHermesMcpAt(configFile: string): void;
+export declare const hermesTransformer: Transformer;

package/dist/transformers/hermes.js

@@ -0,0 +1,136 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { MEMTRACE_MCP_ENV, MCP_SERVER_NAME, removeMemtraceSkills, writeSkills, writeTextAtomic, } from './shared.js';
+function skillsRoot(ctx) {
+    void ctx;
+    return path.join(os.homedir(), '.hermes', 'skills');
+}
+export function hermesConfigPath() {
+    return path.join(os.homedir(), '.hermes', 'config.yaml');
+}
+function yamlQuote(value) {
+    return `"${value
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')}"`;
+}
+function memtraceYamlBlock(binary) {
+    return [
+        `  ${MCP_SERVER_NAME}:`,
+        `    command: ${yamlQuote(binary)}`,
+        '    args:',
+        '      - "mcp"',
+        '    env:',
+        ...Object.entries(MEMTRACE_MCP_ENV).map(([key, value]) => `      ${key}: ${yamlQuote(value)}`),
+        '    enabled: true',
+    ];
+}
+function removeMemtraceYamlBlock(raw) {
+    const lines = raw.split(/\r?\n/);
+    const out = [];
+    let inMcpServers = false;
+    let skippingMemtrace = false;
+    for (const line of lines) {
+        if (/^\S/.test(line) && !line.startsWith('mcp_servers:')) {
+            inMcpServers = false;
+            skippingMemtrace = false;
+        }
+        if (/^mcp_servers:\s*$/.test(line)) {
+            inMcpServers = true;
+            skippingMemtrace = false;
+            out.push(line);
+            continue;
+        }
+        if (inMcpServers && new RegExp(`^\\s{2}${MCP_SERVER_NAME}:\\s*$`).test(line)) {
+            skippingMemtrace = true;
+            continue;
+        }
+        if (skippingMemtrace) {
+            if (/^\s{2}\S/.test(line) || /^\S/.test(line)) {
+                skippingMemtrace = false;
+            }
+            else {
+                continue;
+            }
+        }
+        if (!skippingMemtrace)
+            out.push(line);
+    }
+    return out.join('\n').trimEnd();
+}
+function removeEmptyMcpServersSection(raw) {
+    const lines = raw.split(/\r?\n/);
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!/^mcp_servers:\s*$/.test(line)) {
+            out.push(line);
+            continue;
+        }
+        let j = i + 1;
+        while (j < lines.length && /^\s*$/.test(lines[j]))
+            j++;
+        if (j >= lines.length || /^\S/.test(lines[j])) {
+            continue;
+        }
+        out.push(line);
+    }
+    return out.join('\n').trimEnd();
+}
+export function registerHermesMcpAt(configFile, binary) {
+    const existing = fs.existsSync(configFile) ? fs.readFileSync(configFile, 'utf-8') : '';
+    const withoutMemtrace = removeMemtraceYamlBlock(existing);
+    const hasMcpServers = /^mcp_servers:\s*$/m.test(withoutMemtrace);
+    const block = memtraceYamlBlock(binary);
+    let next;
+    if (hasMcpServers) {
+        const lines = withoutMemtrace.split(/\r?\n/);
+        const index = lines.findIndex(line => /^mcp_servers:\s*$/.test(line));
+        lines.splice(index + 1, 0, ...block);
+        next = lines.join('\n');
+    }
+    else {
+        next = `${withoutMemtrace}${withoutMemtrace ? '\n\n' : ''}mcp_servers:\n${block.join('\n')}`;
+    }
+    writeTextAtomic(configFile, `${next.trimEnd()}\n`);
+}
+export function removeHermesMcpAt(configFile) {
+    if (!fs.existsSync(configFile))
+        return;
+    const next = removeEmptyMcpServersSection(removeMemtraceYamlBlock(fs.readFileSync(configFile, 'utf-8')));
+    if (next.trim())
+        writeTextAtomic(configFile, `${next.trimEnd()}\n`);
+    else
+        fs.unlinkSync(configFile);
+}
+export const hermesTransformer = {
+    name: 'hermes',
+    async install(skills, ctx) {
+        const rootDir = skillsRoot(ctx);
+        const count = writeSkills(skills, rootDir);
+        const warnings = [];
+        let mcpRegistered = false;
+        const mcpConfigPath = hermesConfigPath();
+        if (!ctx.skipMcp) {
+            registerHermesMcpAt(mcpConfigPath, ctx.memtraceBinary);
+            mcpRegistered = true;
+            if (ctx.scope === 'local') {
+                warnings.push('Hermes skills and MCP config are user-level; wrote ~/.hermes/skills and ~/.hermes/config.yaml.');
+            }
+        }
+        return {
+            agent: 'hermes',
+            skillsWritten: count,
+            skillsDir: rootDir,
+            mcpConfigPath,
+            mcpRegistered,
+            warnings,
+        };
+    },
+    async uninstall(ctx) {
+        removeMemtraceSkills(skillsRoot(ctx));
+        removeHermesMcpAt(hermesConfigPath());
+    },
+};

package/dist/transformers/index.d.ts

@@ -0,0 +1,14 @@
+import { Transformer } from './types.js';
+import { claudeTransformer } from './claude.js';
+import { cursorTransformer } from './cursor.js';
+import { codexTransformer } from './codex.js';
+import { geminiTransformer } from './gemini.js';
+import { windsurfTransformer } from './windsurf.js';
+import { vscodeTransformer } from './vscode.js';
+import { hermesTransformer } from './hermes.js';
+import { opencodeTransformer } from './opencode.js';
+import { kiroTransformer } from './kiro.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, };
+export type { Transformer, InstallContext, InstallResult, TransformResult } from './types.js';