memtrace-skills 0.7.10

package/dist/transformers/index.js

@@ -0,0 +1,24 @@
+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 const ALL_TRANSFORMERS = [
+    claudeTransformer,
+    cursorTransformer,
+    codexTransformer,
+    geminiTransformer,
+    windsurfTransformer,
+    vscodeTransformer,
+    hermesTransformer,
+    opencodeTransformer,
+    kiroTransformer,
+];
+export function findTransformer(name) {
+    return ALL_TRANSFORMERS.find(t => t.name === name);
+}
+export { claudeTransformer, cursorTransformer, codexTransformer, geminiTransformer, windsurfTransformer, vscodeTransformer, hermesTransformer, opencodeTransformer, kiroTransformer, };

package/dist/transformers/kiro.d.ts

@@ -0,0 +1,2 @@
+import { Transformer } from './types.js';
+export declare const kiroTransformer: Transformer;

package/dist/transformers/kiro.js

@@ -0,0 +1,69 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { registerMcpServersJsonAt, removeMcpServersJsonAt, skillName, } from './shared.js';
+function steeringRoot(ctx) {
+    return ctx.scope === 'global'
+        ? path.join(os.homedir(), '.kiro', 'steering')
+        : path.join(ctx.cwd, '.kiro', 'steering');
+}
+function mcpPath(ctx) {
+    return ctx.scope === 'global'
+        ? path.join(os.homedir(), '.kiro', 'settings', 'mcp.json')
+        : path.join(ctx.cwd, '.kiro', 'settings', 'mcp.json');
+}
+function writeSteering(skill, rootDir) {
+    const name = skillName(skill);
+    const safeDesc = skill.frontmatter.description.replace(/"/g, '\\"').trim();
+    const content = [
+        '---',
+        'inclusion: auto',
+        `name: ${name}`,
+        `description: "${safeDesc}"`,
+        '---',
+        '',
+        skill.body,
+    ].join('\n');
+    fs.mkdirSync(rootDir, { recursive: true });
+    fs.writeFileSync(path.join(rootDir, `${name}.md`), content);
+}
+function removeMemtraceSteering(rootDir) {
+    if (!fs.existsSync(rootDir))
+        return;
+    for (const entry of fs.readdirSync(rootDir)) {
+        if (entry.startsWith('memtrace-') && entry.endsWith('.md')) {
+            fs.rmSync(path.join(rootDir, entry), { force: true });
+        }
+    }
+}
+export const kiroTransformer = {
+    name: 'kiro',
+    async install(skills, ctx) {
+        const rootDir = steeringRoot(ctx);
+        removeMemtraceSteering(rootDir);
+        for (const skill of skills)
+            writeSteering(skill, rootDir);
+        let mcpRegistered = false;
+        const warnings = [];
+        const mcpConfigPath = mcpPath(ctx);
+        if (!ctx.skipMcp) {
+            const result = registerMcpServersJsonAt(mcpConfigPath, ctx.memtraceBinary);
+            mcpRegistered = result.registered;
+            if (!mcpRegistered && result.backupPath) {
+                warnings.push(`Kiro MCP config was malformed; backed up to ${result.backupPath}.`);
+            }
+        }
+        return {
+            agent: 'kiro',
+            skillsWritten: skills.length,
+            skillsDir: rootDir,
+            mcpConfigPath,
+            mcpRegistered,
+            warnings,
+        };
+    },
+    async uninstall(ctx) {
+        removeMemtraceSteering(steeringRoot(ctx));
+        removeMcpServersJsonAt(mcpPath(ctx));
+    },
+};

package/dist/transformers/opencode.d.ts

@@ -0,0 +1,2 @@
+import { Transformer } from './types.js';
+export declare const opencodeTransformer: Transformer;

package/dist/transformers/opencode.js

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { registerOpenCodeMcpAt, removeMemtraceSkills, removeOpenCodeMcpAt, writeSkills, } from './shared.js';
+import { openCodePluginSource } from './rail-hooks.js';
+function opencodeConfigDir() {
+    const xdg = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), '.config');
+    return path.join(xdg, 'opencode');
+}
+function skillsRoot(ctx) {
+    return ctx.scope === 'global'
+        ? path.join(opencodeConfigDir(), 'skills')
+        : path.join(ctx.cwd, '.opencode', 'skills');
+}
+function mcpPath(ctx) {
+    return ctx.scope === 'global'
+        ? path.join(opencodeConfigDir(), 'opencode.json')
+        : path.join(ctx.cwd, 'opencode.json');
+}
+// OpenCode's plugin directory name changed across versions: current official
+// docs use `plugins/` (plural) while older/community builds load `plugin/`
+// (singular). We write the plugin to BOTH so it loads regardless of version;
+// uninstall removes both. (Identical content — whichever the runtime reads.)
+function railPluginPaths(ctx) {
+    const base = ctx.scope === 'global' ? opencodeConfigDir() : path.join(ctx.cwd, '.opencode');
+    return [
+        path.join(base, 'plugin', 'memtrace-rail.js'),
+        path.join(base, 'plugins', 'memtrace-rail.js'),
+    ];
+}
+export const opencodeTransformer = {
+    name: 'opencode',
+    async install(skills, ctx) {
+        const rootDir = skillsRoot(ctx);
+        const count = writeSkills(skills, rootDir, { compatibility: 'opencode' });
+        let mcpRegistered = false;
+        const warnings = [];
+        const mcpConfigPath = mcpPath(ctx);
+        if (!ctx.skipMcp) {
+            const result = registerOpenCodeMcpAt(mcpConfigPath, ctx.memtraceBinary);
+            mcpRegistered = result.registered;
+            if (!mcpRegistered && result.backupPath) {
+                warnings.push(`OpenCode config was malformed; backed up to ${result.backupPath}.`);
+            }
+        }
+        // ─── memtrace-rail ─── Write the in-process discovery plugin (OpenCode
+        // has no stdio hook). Defaults to observe; fail-open. Best effort.
+        try {
+            const src = openCodePluginSource(ctx.memtraceBinary);
+            for (const pluginPath of railPluginPaths(ctx)) {
+                fs.mkdirSync(path.dirname(pluginPath), { recursive: true });
+                fs.writeFileSync(pluginPath, src);
+            }
+        }
+        catch (e) {
+            warnings.push(`failed to write OpenCode Rail plugin: ${e.message}`);
+        }
+        return {
+            agent: 'opencode',
+            skillsWritten: count,
+            skillsDir: rootDir,
+            mcpConfigPath,
+            mcpRegistered,
+            warnings,
+        };
+    },
+    async uninstall(ctx) {
+        removeMemtraceSkills(skillsRoot(ctx));
+        removeOpenCodeMcpAt(mcpPath(ctx));
+        for (const p of railPluginPaths(ctx)) {
+            try {
+                fs.rmSync(p, { force: true });
+            }
+            catch { /* best effort */ }
+        }
+    },
+};

package/dist/transformers/rail-hooks.d.ts

@@ -0,0 +1,56 @@
+/** Substring identifying a memtrace-owned Rail hook entry. */
+export declare const RAIL_HOOK_MARKER = "route --hook";
+/** The discovery tools each host surfaces. */
+export declare const CLAUDE_MATCHER = "Grep|Glob|Bash";
+export declare const CODEX_MATCHER = "Bash";
+export declare const GEMINI_MATCHER = "run_shell_command|read_file|read_many_files|glob|search_file_content";
+export declare function railCommand(binary: string, host: string): string;
+export declare function isRailHookEntry(entry: unknown): boolean;
+export interface HookResult {
+    registered: boolean;
+    backupPath?: string;
+}
+export interface CleanupResult {
+    changed: boolean;
+    backupPath?: string;
+}
+/**
+ * Register a Claude-style settings.json hook (Codex `PreToolUse`, Gemini
+ * `BeforeTool`). Idempotent; preserves unrelated hooks; never overwrites a
+ * malformed file.
+ */
+export declare function registerSettingsHook(settingsPath: string, binary: string, host: string, eventName: string, matcher: string, extraSettings?: Record<string, unknown>): HookResult;
+/** Remove a Rail hook from a Claude-style settings.json event array. */
+export declare function removeSettingsHook(settingsPath: string, eventName: string): CleanupResult;
+/**
+ * Register the Cursor Rail hook in `.cursor/hooks.json`. Cursor uses a distinct
+ * schema: `{version, hooks: {beforeShellExecution: [{command}]}}`. We intercept
+ * both shell execution (where rg/grep/find run) and file reads.
+ */
+export declare function registerCursorRailHook(hooksPath: string, binary: string): HookResult;
+/** Remove the Cursor Rail hook entries. */
+/** Windsurf Cascade hooks path (user-level). */
+export declare function windsurfHooksPath(): string;
+/**
+ * Register Windsurf `pre_run_command` Rail hook. Uses exit codes (not JSON stdout);
+ * `show_output: true` so nudge context on stdout is visible in Cascade.
+ */
+export declare function registerWindsurfRailHook(hooksPath: string, binary: string): HookResult;
+export declare function removeWindsurfRailHook(hooksPath: string): CleanupResult;
+/** VS Code / Copilot user hooks file (global). */
+export declare function vscodeCopilotRailHookPath(): string;
+/**
+ * Register VS Code agent `PreToolUse` hook (Claude-compatible JSON on stdio).
+ * Writes a dedicated file under `~/.copilot/hooks/` (loaded by default in recent VS Code).
+ */
+export declare function registerVsCodeRailHook(hookFilePath: string, binary: string): HookResult;
+export declare function removeVsCodeRailHook(hookFilePath: string): CleanupResult;
+export declare function removeCursorRailHook(hooksPath: string): CleanupResult;
+/**
+ * The OpenCode in-process plugin source. OpenCode has no stdio hook — plugins
+ * are TS/JS modules with a `tool.execute.before` async hook. This plugin shells
+ * out to the SAME router via `--host generic` (a ToolAttempt in, a
+ * DecisionEnvelope out) and, on suppression, throws to block the raw tool with
+ * the Memtrace result as the error the agent sees.
+ */
+export declare function openCodePluginSource(binary: string): string;

package/dist/transformers/rail-hooks.js

@@ -0,0 +1,303 @@
+/**
+ * memtrace-rail — per-host installer wiring for the Memtrace-first discovery
+ * hook. Each supported agent intercepts tool calls differently, so each gets a
+ * thin host-specific registration that points at the SAME router
+ * (`memtrace route --hook --host <h>`). All entries are idempotent and remove
+ * cleanly. Hooks default to observe mode (zero behavior change); the user opts
+ * into more via `MEMTRACE_RAIL=nudge|rail|strict`.
+ *
+ * Host families:
+ *  - Claude Code   → `.claude/settings.json` hooks.PreToolUse (in claude.ts)
+ *  - Codex         → `.codex/hooks.json`     hooks.PreToolUse
+ *  - Gemini CLI    → `.gemini/settings.json` hooks.BeforeTool
+ *  - Cursor        → `.cursor/hooks.json`    beforeShellExecution/beforeReadFile
+ *  - OpenCode      → `.opencode/plugin/memtrace-rail.js` (in-process plugin)
+ *  - Windsurf      → `~/.codeium/windsurf/hooks.json`  pre_run_command (exit-code contract)
+ *  - VS Code       → `~/.copilot/hooks/memtrace-rail.json` PreToolUse (Claude-shaped)
+ */
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { safeReadJson, writeJsonAtomic } from '../fs-safe.js';
+/** Substring identifying a memtrace-owned Rail hook entry. */
+export const RAIL_HOOK_MARKER = 'route --hook';
+/** The discovery tools each host surfaces. */
+export const CLAUDE_MATCHER = 'Grep|Glob|Bash';
+export const CODEX_MATCHER = 'Bash';
+export const GEMINI_MATCHER = 'run_shell_command|read_file|read_many_files|glob|search_file_content';
+export function railCommand(binary, host) {
+    return `${binary} route --hook --host ${host}`;
+}
+function isRecord(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+export function isRailHookEntry(entry) {
+    if (!isRecord(entry) || !Array.isArray(entry.hooks))
+        return false;
+    return entry.hooks.some((h) => isRecord(h) && typeof h.command === 'string' && h.command.includes(RAIL_HOOK_MARKER));
+}
+/**
+ * Register a Claude-style settings.json hook (Codex `PreToolUse`, Gemini
+ * `BeforeTool`). Idempotent; preserves unrelated hooks; never overwrites a
+ * malformed file.
+ */
+export function registerSettingsHook(settingsPath, binary, host, eventName, matcher, extraSettings) {
+    const { value, corrupted, backupPath } = safeReadJson(settingsPath);
+    if (corrupted) {
+        console.warn(`memtrace: ${settingsPath} is malformed; backed up to ${backupPath}. Skipped Rail hook.`);
+        return { registered: false, backupPath };
+    }
+    const settings = (value ?? {});
+    // Some hosts gate the hook system behind top-level feature flags (e.g. Gemini
+    // requires `enableHooks` + `enableMessageBusIntegration` or BeforeTool hooks
+    // never fire). Merge them in without clobbering a value the user already set.
+    if (extraSettings) {
+        for (const [k, v] of Object.entries(extraSettings)) {
+            if (!(k in settings))
+                settings[k] = v;
+        }
+    }
+    settings.hooks = settings.hooks ?? {};
+    const existing = Array.isArray(settings.hooks[eventName])
+        ? settings.hooks[eventName]
+        : [];
+    const preserved = existing.filter((e) => !isRailHookEntry(e));
+    preserved.push({
+        matcher,
+        hooks: [{ type: 'command', command: railCommand(binary, host) }],
+    });
+    settings.hooks[eventName] = preserved;
+    writeJsonAtomic(settingsPath, settings);
+    return { registered: true };
+}
+/** Remove a Rail hook from a Claude-style settings.json event array. */
+export function removeSettingsHook(settingsPath, eventName) {
+    const { value, corrupted, backupPath } = safeReadJson(settingsPath);
+    if (corrupted)
+        return { changed: false, backupPath };
+    if (!value)
+        return { changed: false };
+    const settings = value;
+    if (!isRecord(settings.hooks) || !Array.isArray(settings.hooks[eventName])) {
+        return { changed: false };
+    }
+    const before = settings.hooks[eventName];
+    const after = before.filter((e) => !isRailHookEntry(e));
+    if (after.length === before.length)
+        return { changed: false };
+    if (after.length === 0)
+        delete settings.hooks[eventName];
+    else
+        settings.hooks[eventName] = after;
+    if (Object.keys(settings.hooks).length === 0)
+        delete settings.hooks;
+    writeJsonAtomic(settingsPath, settings);
+    return { changed: true };
+}
+/**
+ * Register the Cursor Rail hook in `.cursor/hooks.json`. Cursor uses a distinct
+ * schema: `{version, hooks: {beforeShellExecution: [{command}]}}`. We intercept
+ * both shell execution (where rg/grep/find run) and file reads.
+ */
+export function registerCursorRailHook(hooksPath, binary) {
+    const { value, corrupted, backupPath } = safeReadJson(hooksPath);
+    if (corrupted) {
+        console.warn(`memtrace: ${hooksPath} is malformed; backed up to ${backupPath}. Skipped Cursor Rail hook.`);
+        return { registered: false, backupPath };
+    }
+    const cfg = (value ?? {});
+    cfg.version = cfg.version ?? 1;
+    cfg.hooks = cfg.hooks ?? {};
+    const cmd = railCommand(binary, 'cursor');
+    // Only `beforeShellExecution` — that's where rg/grep/find run. We do NOT wire
+    // `beforeReadFile`: a file Read always classifies non-discovery (→ allow), so
+    // hooking it would spawn a router subprocess on every file read for no benefit.
+    const event = 'beforeShellExecution';
+    const existing = Array.isArray(cfg.hooks[event]) ? cfg.hooks[event] : [];
+    const preserved = existing.filter((e) => !(isRecord(e) && typeof e.command === 'string' && e.command.includes(RAIL_HOOK_MARKER)));
+    preserved.push({ command: cmd });
+    cfg.hooks[event] = preserved;
+    writeJsonAtomic(hooksPath, cfg);
+    return { registered: true };
+}
+/** Remove the Cursor Rail hook entries. */
+/** Windsurf Cascade hooks path (user-level). */
+export function windsurfHooksPath() {
+    return path.join(os.homedir(), '.codeium', 'windsurf', 'hooks.json');
+}
+/**
+ * Register Windsurf `pre_run_command` Rail hook. Uses exit codes (not JSON stdout);
+ * `show_output: true` so nudge context on stdout is visible in Cascade.
+ */
+export function registerWindsurfRailHook(hooksPath, binary) {
+    const { value, corrupted, backupPath } = safeReadJson(hooksPath);
+    if (corrupted) {
+        console.warn(`memtrace: ${hooksPath} is malformed; backed up to ${backupPath}. Skipped Windsurf Rail hook.`);
+        return { registered: false, backupPath };
+    }
+    const cfg = (value ?? {});
+    cfg.hooks = cfg.hooks ?? {};
+    const event = 'pre_run_command';
+    const cmd = railCommand(binary, 'windsurf');
+    const existing = Array.isArray(cfg.hooks[event]) ? cfg.hooks[event] : [];
+    const preserved = existing.filter((e) => !(isRecord(e) &&
+        typeof e.command === 'string' &&
+        e.command.includes(RAIL_HOOK_MARKER)));
+    preserved.push({ command: cmd, show_output: true });
+    cfg.hooks[event] = preserved;
+    writeJsonAtomic(hooksPath, cfg);
+    return { registered: true };
+}
+export function removeWindsurfRailHook(hooksPath) {
+    const { value, corrupted, backupPath } = safeReadJson(hooksPath);
+    if (corrupted)
+        return { changed: false, backupPath };
+    if (!value)
+        return { changed: false };
+    const cfg = value;
+    if (!isRecord(cfg.hooks) || !Array.isArray(cfg.hooks.pre_run_command)) {
+        return { changed: false };
+    }
+    const before = cfg.hooks.pre_run_command;
+    const after = before.filter((e) => !(isRecord(e) &&
+        typeof e.command === 'string' &&
+        e.command.includes(RAIL_HOOK_MARKER)));
+    if (after.length === before.length)
+        return { changed: false };
+    if (after.length === 0)
+        delete cfg.hooks.pre_run_command;
+    else
+        cfg.hooks.pre_run_command = after;
+    if (Object.keys(cfg.hooks).length === 0)
+        delete cfg.hooks;
+    writeJsonAtomic(hooksPath, cfg);
+    return { changed: true };
+}
+/** VS Code / Copilot user hooks file (global). */
+export function vscodeCopilotRailHookPath() {
+    return path.join(os.homedir(), '.copilot', 'hooks', 'memtrace-rail.json');
+}
+/**
+ * Register VS Code agent `PreToolUse` hook (Claude-compatible JSON on stdio).
+ * Writes a dedicated file under `~/.copilot/hooks/` (loaded by default in recent VS Code).
+ */
+export function registerVsCodeRailHook(hookFilePath, binary) {
+    const { value, corrupted, backupPath } = safeReadJson(hookFilePath);
+    if (corrupted) {
+        console.warn(`memtrace: ${hookFilePath} is malformed; backed up to ${backupPath}. Skipped VS Code Rail hook.`);
+        return { registered: false, backupPath };
+    }
+    const cmd = railCommand(binary, 'vscode');
+    const existing = (value ?? {});
+    const pre = Array.isArray(existing.hooks?.PreToolUse) ? existing.hooks.PreToolUse : [];
+    const preserved = pre.filter((e) => !(isRecord(e) &&
+        typeof e.command === 'string' &&
+        e.command.includes(RAIL_HOOK_MARKER)));
+    preserved.push({ type: 'command', command: cmd, timeout: 30 });
+    writeJsonAtomic(hookFilePath, {
+        hooks: {
+            PreToolUse: preserved,
+        },
+    });
+    return { registered: true };
+}
+export function removeVsCodeRailHook(hookFilePath) {
+    const { value, corrupted, backupPath } = safeReadJson(hookFilePath);
+    if (corrupted)
+        return { changed: false, backupPath };
+    if (!value)
+        return { changed: false };
+    const cfg = value;
+    if (!Array.isArray(cfg.hooks?.PreToolUse))
+        return { changed: false };
+    const before = cfg.hooks.PreToolUse;
+    const after = before.filter((e) => !(isRecord(e) &&
+        typeof e.command === 'string' &&
+        e.command.includes(RAIL_HOOK_MARKER)));
+    if (after.length === before.length)
+        return { changed: false };
+    if (after.length === 0) {
+        try {
+            fs.rmSync(hookFilePath, { force: true });
+        }
+        catch {
+            writeJsonAtomic(hookFilePath, { hooks: {} });
+        }
+        return { changed: true };
+    }
+    writeJsonAtomic(hookFilePath, { hooks: { PreToolUse: after } });
+    return { changed: true };
+}
+export function removeCursorRailHook(hooksPath) {
+    const { value, corrupted, backupPath } = safeReadJson(hooksPath);
+    if (corrupted)
+        return { changed: false, backupPath };
+    if (!value)
+        return { changed: false };
+    const cfg = value;
+    if (!isRecord(cfg.hooks))
+        return { changed: false };
+    let changed = false;
+    for (const event of ['beforeShellExecution', 'beforeReadFile']) {
+        if (!Array.isArray(cfg.hooks[event]))
+            continue;
+        const before = cfg.hooks[event];
+        const after = before.filter((e) => !(isRecord(e) && typeof e.command === 'string' && e.command.includes(RAIL_HOOK_MARKER)));
+        if (after.length !== before.length) {
+            changed = true;
+            if (after.length === 0)
+                delete cfg.hooks[event];
+            else
+                cfg.hooks[event] = after;
+        }
+    }
+    if (changed) {
+        if (isRecord(cfg.hooks) && Object.keys(cfg.hooks).length === 0)
+            delete cfg.hooks;
+        writeJsonAtomic(hooksPath, cfg);
+    }
+    return { changed };
+}
+/**
+ * The OpenCode in-process plugin source. OpenCode has no stdio hook — plugins
+ * are TS/JS modules with a `tool.execute.before` async hook. This plugin shells
+ * out to the SAME router via `--host generic` (a ToolAttempt in, a
+ * DecisionEnvelope out) and, on suppression, throws to block the raw tool with
+ * the Memtrace result as the error the agent sees.
+ */
+export function openCodePluginSource(binary) {
+    return `// AUTO-GENERATED by memtrace install — Memtrace Rail discovery hook.
+// Routes OpenCode tool calls through \`${binary} route\`. Defaults to observe
+// (no-op) unless MEMTRACE_RAIL=nudge|rail|strict. Remove via 'memtrace uninstall'.
+import { execFileSync } from 'node:child_process';
+
+const BIN = ${JSON.stringify(binary)};
+
+export const MemtraceRail = async ({ project, client, $ }) => ({
+  'tool.execute.before': async (input, output) => {
+    try {
+      const tool = input?.tool;
+      if (tool !== 'bash' && tool !== 'grep' && tool !== 'glob') return;
+      const attempt = {
+        host: 'open-code',
+        cwd: output?.args?.cwd || process.cwd(),
+        tool: tool === 'bash' ? 'Bash' : tool === 'grep' ? 'Grep' : 'Glob',
+        input: output?.args || {},
+        session_id: input?.sessionID || 'opencode',
+      };
+      const out = execFileSync(BIN, ['route', '--json', '-'], {
+        input: JSON.stringify(attempt), timeout: 1500, encoding: 'utf8',
+      });
+      const decision = JSON.parse(out);
+      if (decision.action === 'suppress_raw_with_result') {
+        throw new Error('[Memtrace Rail] ' + (decision.message || 'Use Memtrace for code discovery.') +
+          (decision.result ? '\\n' + JSON.stringify(decision.result, null, 2) : ''));
+      }
+    } catch (e) {
+      // Fail open on any router/exec error — never block the agent.
+      if (e && String(e.message || '').startsWith('[Memtrace Rail]')) throw e;
+    }
+  },
+});
+`;
+}

package/dist/transformers/shared.d.ts

@@ -0,0 +1,18 @@
+import { Skill } from '../skills.js';
+export declare const MCP_SERVER_NAME = "memtrace";
+export declare const MEMTRACE_MCP_ENV: Record<string, string>;
+export declare function skillName(skill: Skill): string;
+export declare function skillMarkdown(skill: Skill, extraFrontmatter?: Record<string, string>): string;
+export declare function writeSkills(skills: Skill[], rootDir: string, extraFrontmatter?: Record<string, string>): number;
+export declare function removeMemtraceSkills(rootDir: string): void;
+export declare function writeTextAtomic(filePath: string, content: string): void;
+export interface JsonMcpResult {
+    registered: boolean;
+    backupPath?: string;
+}
+export declare function registerMcpServersJsonAt(filePath: string, binary: string): JsonMcpResult;
+export declare function removeMcpServersJsonAt(filePath: string): void;
+export declare function registerVsCodeMcpAt(filePath: string, binary: string): JsonMcpResult;
+export declare function removeVsCodeMcpAt(filePath: string): void;
+export declare function registerOpenCodeMcpAt(filePath: string, binary: string): JsonMcpResult;
+export declare function removeOpenCodeMcpAt(filePath: string): void;