brainctl 0.1.4 → 0.1.6

package/dist/mcp/server.js

@@ -4,8 +4,11 @@ import { FastMCP } from 'fastmcp';
 import { z } from 'zod';
 import { loadConfig } from '../config.js';
 import { loadMemory } from '../context/memory.js';
+import { createAgentConfigService } from '../services/agent-config-service.js';
 import { createDoctorService } from '../services/doctor-service.js';
 import { createMemoryWriteService } from '../services/memory-write-service.js';
+import { createProfileExportService } from '../services/profile-export-service.js';
+import { createProfileImportService } from '../services/profile-import-service.js';
 import { createProfileService } from '../services/profile-service.js';
 import { createRunService } from '../services/run-service.js';
 import { createStatusService } from '../services/status-service.js';
@@ -175,6 +178,188 @@ export function createMcpServer(options = {}) {
             return JSON.stringify(result, null, 2);
         },
     });
+    server.addTool({
+        name: 'brainctl_get_profile',
+        description: 'Get the full config of a profile including all skills, MCPs, and memory paths.',
+        parameters: z.object({
+            name: z.string().describe('Profile name'),
+        }),
+        execute: async (args) => {
+            const profileService = createProfileService();
+            const profile = await profileService.get({ cwd, name: args.name });
+            return JSON.stringify(profile, null, 2);
+        },
+    });
+    server.addTool({
+        name: 'brainctl_create_profile',
+        description: 'Create a new profile with a default example skill.',
+        parameters: z.object({
+            name: z.string().describe('Profile name to create'),
+            description: z.string().optional().describe('Profile description'),
+        }),
+        execute: async (args) => {
+            const profileService = createProfileService();
+            const result = await profileService.create({
+                cwd,
+                name: args.name,
+                description: args.description,
+            });
+            return JSON.stringify(result, null, 2);
+        },
+    });
+    server.addTool({
+        name: 'brainctl_update_profile',
+        description: 'Update a profile config. Pass the full profile object with skills, mcps, and memory fields. Use this to add, remove, or modify skills and MCPs within a profile.',
+        parameters: z.object({
+            name: z.string().describe('Profile name to update'),
+            config: z.object({
+                name: z.string(),
+                description: z.string().optional(),
+                skills: z.record(z.string(), z.object({
+                    description: z.string().optional(),
+                    prompt: z.string(),
+                })),
+                mcps: z.record(z.string(), z.unknown()),
+                memory: z.object({
+                    paths: z.array(z.string()),
+                }),
+            }).describe('Full profile config object'),
+        }),
+        execute: async (args) => {
+            const profileService = createProfileService();
+            await profileService.update({
+                cwd,
+                name: args.name,
+                config: args.config,
+            });
+            return JSON.stringify({ ok: true, updated: args.name });
+        },
+    });
+    server.addTool({
+        name: 'brainctl_delete_profile',
+        description: 'Delete a profile. Cannot delete the currently active profile.',
+        parameters: z.object({
+            name: z.string().describe('Profile name to delete'),
+        }),
+        execute: async (args) => {
+            const profileService = createProfileService();
+            await profileService.delete({ cwd, name: args.name });
+            return JSON.stringify({ ok: true, deleted: args.name });
+        },
+    });
+    server.addTool({
+        name: 'brainctl_copy_profile_items',
+        description: 'Copy skills and/or MCPs from one profile to another. Specify which skill and MCP keys to copy. Existing items with the same key in the target are overwritten.',
+        parameters: z.object({
+            source: z.string().describe('Source profile name'),
+            target: z.string().describe('Target profile name'),
+            skills: z.array(z.string()).default([]).describe('Skill keys to copy'),
+            mcps: z.array(z.string()).default([]).describe('MCP keys to copy'),
+        }),
+        execute: async (args) => {
+            const profileService = createProfileService();
+            const sourceProfile = await profileService.get({ cwd, name: args.source });
+            const targetProfile = await profileService.get({ cwd, name: args.target });
+            const copiedSkills = [];
+            const copiedMcps = [];
+            for (const key of args.skills) {
+                if (sourceProfile.skills[key]) {
+                    targetProfile.skills[key] = sourceProfile.skills[key];
+                    copiedSkills.push(key);
+                }
+            }
+            for (const key of args.mcps) {
+                if (sourceProfile.mcps[key]) {
+                    targetProfile.mcps[key] = sourceProfile.mcps[key];
+                    copiedMcps.push(key);
+                }
+            }
+            await profileService.update({ cwd, name: args.target, config: targetProfile });
+            return JSON.stringify({
+                source: args.source,
+                target: args.target,
+                copiedSkills,
+                copiedMcps,
+            }, null, 2);
+        },
+    });
+    server.addTool({
+        name: 'brainctl_export_profile',
+        description: 'Export a profile as a portable tarball. Packages the profile config and bundled MCP source code for sharing.',
+        parameters: z.object({
+            name: z.string().describe('Profile name to export'),
+            output_path: z.string().optional().describe('Output file path (defaults to <name>.tar.gz in cwd)'),
+        }),
+        execute: async (args) => {
+            const exportService = createProfileExportService();
+            const result = await exportService.execute({
+                cwd,
+                name: args.name,
+                outputPath: args.output_path,
+            });
+            return JSON.stringify(result, null, 2);
+        },
+    });
+    server.addTool({
+        name: 'brainctl_import_profile',
+        description: 'Import a profile from a tarball. Extracts bundled MCP source, installs dependencies, and registers the profile.',
+        parameters: z.object({
+            archive_path: z.string().describe('Path to the profile tarball'),
+            force: z.boolean().default(false).describe('Overwrite existing profile if it exists'),
+        }),
+        execute: async (args) => {
+            const importService = createProfileImportService();
+            const result = await importService.execute({
+                cwd,
+                archivePath: args.archive_path,
+                force: args.force,
+            });
+            return JSON.stringify(result, null, 2);
+        },
+    });
+    server.addTool({
+        name: 'brainctl_read_agent_configs',
+        description: 'Read the live MCP configs from all agents (Claude, Codex, Gemini). Shows what is actually configured in each agent right now, by reading their real config files.',
+        parameters: z.object({}),
+        execute: async () => {
+            const agentConfigService = createAgentConfigService();
+            const configs = await agentConfigService.readAll({ cwd });
+            return JSON.stringify(configs, null, 2);
+        },
+    });
+    server.addTool({
+        name: 'brainctl_add_agent_mcp',
+        description: 'Add or overwrite an MCP server entry in a specific agent config. Writes directly to the agent config file (e.g., ~/.claude.json).',
+        parameters: z.object({
+            agent: z.enum(['claude', 'codex', 'gemini']).describe('Target agent'),
+            key: z.string().describe('MCP server name/key'),
+            command: z.string().describe('Command to run the MCP server'),
+            args: z.array(z.string()).default([]).describe('Arguments for the command'),
+        }),
+        execute: async (args) => {
+            const agentConfigService = createAgentConfigService();
+            await agentConfigService.addMcp({
+                cwd,
+                agent: args.agent,
+                key: args.key,
+                entry: { command: args.command, args: args.args },
+            });
+            return JSON.stringify({ ok: true, agent: args.agent, key: args.key });
+        },
+    });
+    server.addTool({
+        name: 'brainctl_remove_agent_mcp',
+        description: 'Remove an MCP server entry from a specific agent config.',
+        parameters: z.object({
+            agent: z.enum(['claude', 'codex', 'gemini']).describe('Target agent'),
+            key: z.string().describe('MCP server name/key to remove'),
+        }),
+        execute: async (args) => {
+            const agentConfigService = createAgentConfigService();
+            await agentConfigService.removeMcp({ cwd, agent: args.agent, key: args.key });
+            return JSON.stringify({ ok: true, agent: args.agent, removed: args.key });
+        },
+    });
     return server;
 }
 export async function startMcpServer(options = {}) {

package/dist/services/agent-config-service.d.ts

@@ -0,0 +1,20 @@
+import type { AgentName } from '../types.js';
+import { type AgentLiveConfig, type AgentMcpEntry } from './sync/agent-reader.js';
+export type { AgentLiveConfig, AgentMcpEntry, AgentSkillEntry } from './sync/agent-reader.js';
+export interface AgentConfigService {
+    readAll(options: {
+        cwd: string;
+    }): Promise<AgentLiveConfig[]>;
+    addMcp(options: {
+        cwd: string;
+        agent: AgentName;
+        key: string;
+        entry: AgentMcpEntry;
+    }): Promise<void>;
+    removeMcp(options: {
+        cwd: string;
+        agent: AgentName;
+        key: string;
+    }): Promise<void>;
+}
+export declare function createAgentConfigService(): AgentConfigService;

package/dist/services/agent-config-service.js

@@ -0,0 +1,189 @@
+import { copyFile, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { createClaudeReader, createCodexReader, createGeminiReader, } from './sync/agent-reader.js';
+import { formatTimestamp } from './sync/agent-writer.js';
+const readers = {
+    claude: createClaudeReader(),
+    codex: createCodexReader(),
+    gemini: createGeminiReader(),
+};
+export function createAgentConfigService() {
+    return {
+        async readAll(options) {
+            const results = await Promise.all([
+                readers.claude.read(options),
+                readers.codex.read(options),
+                readers.gemini.read(options),
+            ]);
+            return results;
+        },
+        async addMcp(options) {
+            const { cwd, agent, key, entry } = options;
+            if (agent === 'claude') {
+                await mutateClaudeConfig(cwd, (servers) => {
+                    servers[key] = toClaudeEntry(entry);
+                });
+            }
+            else if (agent === 'codex') {
+                await mutateCodexConfig((servers) => {
+                    servers[key] = entry;
+                });
+            }
+            else if (agent === 'gemini') {
+                await mutateGeminiConfig(cwd, (servers) => {
+                    servers[key] = toGeminiEntry(entry);
+                });
+            }
+        },
+        async removeMcp(options) {
+            const { cwd, agent, key } = options;
+            if (agent === 'claude') {
+                await mutateClaudeConfig(cwd, (servers) => {
+                    delete servers[key];
+                });
+            }
+            else if (agent === 'codex') {
+                await mutateCodexConfig((servers) => {
+                    delete servers[key];
+                });
+            }
+            else if (agent === 'gemini') {
+                await mutateGeminiConfig(cwd, (servers) => {
+                    delete servers[key];
+                });
+            }
+        },
+    };
+}
+/* ---- Claude: JSON with projects[cwd].mcpServers ---- */
+async function mutateClaudeConfig(cwd, mutate) {
+    const configPath = path.join(homedir(), '.claude.json');
+    let existing = {};
+    try {
+        existing = JSON.parse(await readFile(configPath, 'utf8'));
+        await backupFile(configPath);
+    }
+    catch {
+        // fresh config
+    }
+    const projects = (existing.projects ?? {});
+    const projectConfig = projects[cwd] ?? {};
+    const servers = (projectConfig.mcpServers ?? {});
+    mutate(servers);
+    projectConfig.mcpServers = servers;
+    projects[cwd] = projectConfig;
+    existing.projects = projects;
+    await atomicWriteJson(configPath, existing);
+}
+function toClaudeEntry(entry) {
+    return {
+        type: 'stdio',
+        command: entry.command,
+        args: entry.args ?? [],
+        ...(entry.env ? { env: entry.env } : {}),
+    };
+}
+/* ---- Codex: TOML with [mcp_servers.*] ---- */
+async function mutateCodexConfig(mutate) {
+    const configPath = path.join(homedir(), '.codex', 'config.toml');
+    let existingContent = '';
+    try {
+        existingContent = await readFile(configPath, 'utf8');
+        await backupFile(configPath);
+    }
+    catch {
+        // fresh config
+    }
+    // Read current servers via reader
+    const current = await readers.codex.read({ cwd: '' });
+    const servers = { ...current.mcpServers };
+    mutate(servers);
+    // Rebuild: preserve non-mcp content + new mcp sections
+    const nonMcp = stripCodexMcpSections(existingContent).trim();
+    const mcpToml = buildCodexMcpToml(servers);
+    const final = nonMcp.length > 0 ? `${nonMcp}\n\n${mcpToml}` : mcpToml;
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await atomicWrite(configPath, final + '\n');
+}
+function stripCodexMcpSections(content) {
+    const lines = content.split('\n');
+    const result = [];
+    let inMcp = false;
+    for (const line of lines) {
+        if (/^\[mcp_servers[\].]/.test(line)) {
+            inMcp = true;
+            continue;
+        }
+        if (inMcp && /^\[/.test(line) && !/^\[mcp_servers[\].]/.test(line)) {
+            inMcp = false;
+        }
+        if (!inMcp)
+            result.push(line);
+    }
+    return result.join('\n');
+}
+function buildCodexMcpToml(servers) {
+    const lines = [];
+    for (const [name, entry] of Object.entries(servers)) {
+        lines.push(`[mcp_servers.${name}]`);
+        lines.push(`command = ${tomlStr(entry.command)}`);
+        if (entry.args && entry.args.length > 0) {
+            lines.push(`args = [${entry.args.map(tomlStr).join(', ')}]`);
+        }
+        if (entry.env && Object.keys(entry.env).length > 0) {
+            lines.push('');
+            lines.push(`[mcp_servers.${name}.env]`);
+            for (const [k, v] of Object.entries(entry.env)) {
+                lines.push(`${k} = ${tomlStr(v)}`);
+            }
+        }
+        lines.push('');
+    }
+    return lines.join('\n').trim();
+}
+function tomlStr(value) {
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+/* ---- Gemini: JSON with mcpServers ---- */
+async function mutateGeminiConfig(_cwd, mutate) {
+    const configPath = path.join(homedir(), '.gemini', 'settings.json');
+    let existing = {};
+    try {
+        existing = JSON.parse(await readFile(configPath, 'utf8'));
+        await backupFile(configPath);
+    }
+    catch {
+        // fresh config
+    }
+    const servers = (existing.mcpServers ?? {});
+    mutate(servers);
+    existing.mcpServers = servers;
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await atomicWriteJson(configPath, existing);
+}
+function toGeminiEntry(entry) {
+    return {
+        command: entry.command,
+        args: entry.args ?? [],
+        ...(entry.env ? { env: entry.env } : {}),
+    };
+}
+/* ---- Shared helpers ---- */
+async function backupFile(filePath) {
+    const backupPath = `${filePath}.bak.${formatTimestamp()}`;
+    try {
+        await copyFile(filePath, backupPath);
+    }
+    catch {
+        // File may not exist yet
+    }
+}
+async function atomicWriteJson(filePath, data) {
+    await atomicWrite(filePath, JSON.stringify(data, null, 2) + '\n');
+}
+async function atomicWrite(filePath, content) {
+    const tmpPath = `${filePath}.tmp.${Date.now()}`;
+    await writeFile(tmpPath, content, 'utf8');
+    await rename(tmpPath, filePath);
+}

package/dist/services/profile-export-service.d.ts

@@ -0,0 +1,15 @@
+import { type ProfileService } from './profile-service.js';
+export interface ProfileExportService {
+    execute(options: {
+        cwd?: string;
+        name: string;
+        outputPath?: string;
+    }): Promise<{
+        archivePath: string;
+    }>;
+}
+interface ProfileExportDependencies {
+    profileService?: ProfileService;
+}
+export declare function createProfileExportService(deps?: ProfileExportDependencies): ProfileExportService;
+export {};

package/dist/services/profile-export-service.js

@@ -0,0 +1,63 @@
+import { execSync } from 'node:child_process';
+import { cp, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import YAML from 'yaml';
+import { createProfileService } from './profile-service.js';
+export function createProfileExportService(deps = {}) {
+    const profileService = deps.profileService ?? createProfileService();
+    return {
+        async execute(options) {
+            const cwd = options.cwd ?? process.cwd();
+            const profile = await profileService.get({ cwd, name: options.name });
+            const stagingDir = await mkdtemp(path.join(tmpdir(), 'brainctl-export-'));
+            try {
+                const exportProfile = await stageProfile(profile, cwd, stagingDir);
+                await writeFile(path.join(stagingDir, 'profile.yaml'), YAML.stringify(exportProfile), 'utf8');
+                const outputPath = options.outputPath ?? path.join(cwd, `${profile.name}.tar.gz`);
+                execSync(`tar -czf "${outputPath}" -C "${stagingDir}" .`, {
+                    stdio: 'pipe',
+                });
+                return { archivePath: outputPath };
+            }
+            finally {
+                await rm(stagingDir, { recursive: true, force: true });
+            }
+        },
+    };
+}
+async function stageProfile(profile, cwd, stagingDir) {
+    const mcpsDir = path.join(stagingDir, 'mcps');
+    const exportMcps = {};
+    for (const [name, mcp] of Object.entries(profile.mcps)) {
+        if (mcp.type === 'bundled') {
+            const sourcePath = path.isAbsolute(mcp.path)
+                ? mcp.path
+                : path.resolve(cwd, mcp.path);
+            const destPath = path.join(mcpsDir, name);
+            await mkdir(destPath, { recursive: true });
+            await cp(sourcePath, destPath, {
+                recursive: true,
+                filter: (src) => !src.includes('node_modules'),
+            });
+            exportMcps[name] = {
+                type: 'bundled',
+                path: `./mcps/${name}`,
+                ...(mcp.install ? { install: mcp.install } : {}),
+                command: mcp.command,
+                ...(mcp.args ? { args: mcp.args } : {}),
+                ...(mcp.env ? { env: mcp.env } : {}),
+            };
+        }
+        else {
+            exportMcps[name] = mcp;
+        }
+    }
+    return {
+        name: profile.name,
+        ...(profile.description ? { description: profile.description } : {}),
+        skills: profile.skills,
+        mcps: exportMcps,
+        memory: profile.memory,
+    };
+}

package/dist/services/profile-import-service.d.ts

@@ -0,0 +1,11 @@
+export interface ProfileImportService {
+    execute(options: {
+        cwd?: string;
+        archivePath: string;
+        force?: boolean;
+    }): Promise<{
+        profileName: string;
+        installedMcps: string[];
+    }>;
+}
+export declare function createProfileImportService(): ProfileImportService;

package/dist/services/profile-import-service.js

@@ -0,0 +1,81 @@
+import { execSync } from 'node:child_process';
+import { cp, mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import YAML from 'yaml';
+import { ProfileError } from '../errors.js';
+import { parseProfile } from './profile-service.js';
+const PROFILES_DIR = '.brainctl/profiles';
+export function createProfileImportService() {
+    return {
+        async execute(options) {
+            const cwd = options.cwd ?? process.cwd();
+            const archivePath = path.resolve(cwd, options.archivePath);
+            try {
+                await stat(archivePath);
+            }
+            catch {
+                throw new ProfileError(`Archive not found: ${archivePath}`);
+            }
+            const extractDir = await mkdtemp(path.join(tmpdir(), 'brainctl-import-'));
+            try {
+                execSync(`tar -xzf "${archivePath}" -C "${extractDir}"`, {
+                    stdio: 'pipe',
+                });
+                const profileSource = await readFile(path.join(extractDir, 'profile.yaml'), 'utf8');
+                const profile = parseProfile(profileSource, 'imported');
+                const profileName = profile.name;
+                const profilePath = path.join(cwd, PROFILES_DIR, `${profileName}.yaml`);
+                if (!options.force) {
+                    try {
+                        await stat(profilePath);
+                        throw new ProfileError(`Profile "${profileName}" already exists. Use --force to overwrite.`);
+                    }
+                    catch (err) {
+                        if (err instanceof ProfileError)
+                            throw err;
+                    }
+                }
+                const installedMcps = [];
+                const mcpsBaseDir = path.join(cwd, PROFILES_DIR, profileName, 'mcps');
+                for (const [name, mcp] of Object.entries(profile.mcps)) {
+                    if (mcp.type !== 'bundled')
+                        continue;
+                    const extractedMcpPath = path.join(extractDir, 'mcps', name);
+                    const destMcpPath = path.join(mcpsBaseDir, name);
+                    try {
+                        await stat(extractedMcpPath);
+                    }
+                    catch {
+                        throw new ProfileError(`Bundled MCP "${name}" source not found in archive.`);
+                    }
+                    await mkdir(destMcpPath, { recursive: true });
+                    await cp(extractedMcpPath, destMcpPath, { recursive: true });
+                    const installCmd = mcp.install ?? 'npm install';
+                    execSync(installCmd, {
+                        cwd: destMcpPath,
+                        stdio: 'pipe',
+                    });
+                    profile.mcps[name] = {
+                        ...mcp,
+                        path: destMcpPath,
+                    };
+                    installedMcps.push(name);
+                }
+                const outputYaml = {
+                    name: profile.name,
+                    ...(profile.description ? { description: profile.description } : {}),
+                    skills: profile.skills,
+                    mcps: profile.mcps,
+                    memory: profile.memory,
+                };
+                await mkdir(path.dirname(profilePath), { recursive: true });
+                await writeFile(profilePath, YAML.stringify(outputYaml), 'utf8');
+                return { profileName, installedMcps };
+            }
+            finally {
+                await rm(extractDir, { recursive: true, force: true });
+            }
+        },
+    };
+}

package/dist/services/profile-service.d.ts

@@ -17,6 +17,15 @@ export interface ProfileService {
     }): Promise<{
         profilePath: string;
     }>;
+    update(options: {
+        cwd?: string;
+        name: string;
+        config: ProfileConfig;
+    }): Promise<void>;
+    delete(options: {
+        cwd?: string;
+        name: string;
+    }): Promise<void>;
     use(options: {
         cwd?: string;
         name: string;
@@ -28,3 +37,4 @@ export interface ProfileService {
     }): Promise<BrainctlMetaConfig>;
 }
 export declare function createProfileService(): ProfileService;
+export declare function parseProfile(source: string, name: string): ProfileConfig;

package/dist/services/profile-service.js

@@ -1,4 +1,4 @@
-import { readdir, readFile, writeFile, mkdir, stat } from 'node:fs/promises';
+import { readdir, readFile, writeFile, mkdir, stat, unlink } from 'node:fs/promises';
 import path from 'node:path';
 import YAML from 'yaml';
 import { ProfileError, ProfileNotFoundError } from '../errors.js';
@@ -64,6 +64,33 @@ export function createProfileService() {
             await writeFile(profilePath, YAML.stringify(scaffold), 'utf8');
             return { profilePath };
         },
+        async update(options) {
+            const cwd = options.cwd ?? process.cwd();
+            const profilePath = path.join(cwd, PROFILES_DIR, `${options.name}.yaml`);
+            if (!(await pathExists(profilePath))) {
+                throw new ProfileNotFoundError(`Profile "${options.name}" not found.`);
+            }
+            const data = {
+                name: options.config.name,
+                ...(options.config.description ? { description: options.config.description } : {}),
+                skills: options.config.skills,
+                mcps: options.config.mcps,
+                memory: options.config.memory,
+            };
+            await writeFile(profilePath, YAML.stringify(data), 'utf8');
+        },
+        async delete(options) {
+            const cwd = options.cwd ?? process.cwd();
+            const profilePath = path.join(cwd, PROFILES_DIR, `${options.name}.yaml`);
+            if (!(await pathExists(profilePath))) {
+                throw new ProfileNotFoundError(`Profile "${options.name}" not found.`);
+            }
+            const meta = await loadMetaConfig(cwd);
+            if (meta.active_profile === options.name) {
+                throw new ProfileError('Cannot delete the active profile.');
+            }
+            await unlink(profilePath);
+        },
         async use(options) {
             const cwd = options.cwd ?? process.cwd();
             // Validate profile exists
@@ -99,7 +126,7 @@ async function loadMetaConfig(cwd) {
         return { active_profile: '', agents: ['claude', 'codex', 'gemini'] };
     }
 }
-function parseProfile(source, name) {
+export function parseProfile(source, name) {
     let parsed;
     try {
         parsed = YAML.parse(source) ?? {};

package/dist/services/sync/agent-reader.d.ts

@@ -0,0 +1,25 @@
+import type { AgentName } from '../../types.js';
+export interface AgentMcpEntry {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface AgentSkillEntry {
+    name: string;
+    source?: string;
+}
+export interface AgentLiveConfig {
+    agent: AgentName;
+    configPath: string;
+    exists: boolean;
+    mcpServers: Record<string, AgentMcpEntry>;
+    skills: AgentSkillEntry[];
+}
+export interface AgentConfigReader {
+    read(options: {
+        cwd: string;
+    }): Promise<AgentLiveConfig>;
+}
+export declare function createClaudeReader(): AgentConfigReader;
+export declare function createCodexReader(): AgentConfigReader;
+export declare function createGeminiReader(): AgentConfigReader;