expxagents 0.18.2 → 0.20.0

package/dist/cli/src/commands/mcp.js

@@ -0,0 +1,155 @@
+import { Command } from 'commander';
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { loadMcpDefinition, listAllMcpIds } from '../mcp/catalog.js';
+import { detectMcp, detectExtension, resolvePlatformBinary } from '../mcp/detect.js';
+import { writeMcpConfig, removeMcpConfig } from '../mcp/setup.js';
+import { getConfiguredMcpIds } from '../mcp/validate.js';
+import { getAssetsDir } from '../utils/config.js';
+function getMcpsDir() {
+    const local = path.resolve('mcps');
+    if (fs.existsSync(local))
+        return local;
+    return path.join(getAssetsDir(), 'mcps');
+}
+export function mcpCommand() {
+    const mcp = new Command('mcp')
+        .description('Manage MCP integrations');
+    mcp
+        .command('list')
+        .description('List all MCPs: configured, available, unavailable')
+        .action(() => {
+        const mcpsDir = getMcpsDir();
+        const ids = listAllMcpIds(mcpsDir);
+        const configured = getConfiguredMcpIds(process.cwd());
+        const results = [];
+        for (const id of ids) {
+            const def = loadMcpDefinition(mcpsDir, id);
+            if (def)
+                results.push(detectMcp(def));
+        }
+        console.log('\nMCP Integrations:\n');
+        const configuredResults = results.filter(r => configured.includes(r.id));
+        if (configuredResults.length > 0) {
+            console.log('  CONFIGURED');
+            for (const r of configuredResults) {
+                console.log(`  \u2705 ${r.id.padEnd(14)} \u2014 ${r.detail}`);
+            }
+            console.log('');
+        }
+        const available = results.filter(r => !configured.includes(r.id) && r.status !== 'unavailable');
+        if (available.length > 0) {
+            console.log('  AVAILABLE');
+            for (const r of available) {
+                console.log(`  \u2b1c ${r.id.padEnd(14)} \u2014 ${r.detail}`);
+            }
+            console.log('');
+        }
+        const unavailable = results.filter(r => r.status === 'unavailable' && !configured.includes(r.id));
+        if (unavailable.length > 0) {
+            console.log('  UNAVAILABLE');
+            for (const r of unavailable) {
+                console.log(`  \u26d4 ${r.id.padEnd(14)} \u2014 ${r.detail}`);
+            }
+            console.log('');
+        }
+        console.log('Run: expxagents mcp setup <id> to configure\n');
+    });
+    mcp
+        .command('setup <ids...>')
+        .description('Configure one or more MCPs')
+        .action(async (ids) => {
+        const mcpsDir = getMcpsDir();
+        const readline = await import('readline');
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const ask = (q) => new Promise(r => rl.question(q, r));
+        for (const id of ids) {
+            const def = loadMcpDefinition(mcpsDir, id);
+            if (!def) {
+                console.log(`\u274c Unknown MCP: ${id}`);
+                continue;
+            }
+            console.log(`\n\ud83d\udce6 Setting up ${def.name} MCP...\n`);
+            let resolvedCommand;
+            if (def.detection.method === 'extension' && def.detection.extension) {
+                const ext = detectExtension(def.detection.extension.prefix);
+                if (!ext) {
+                    console.log(`\u274c ${def.name} VSCode extension not found`);
+                    continue;
+                }
+                const binary = resolvePlatformBinary();
+                resolvedCommand = path.join(ext.extensionPath, def.detection.extension.binary_dir, binary);
+            }
+            const authValues = {};
+            for (const auth of def.auth) {
+                console.log(`  ${auth.hint}`);
+                const value = await ask(`? ${auth.label}: `);
+                authValues[auth.key] = value.trim();
+            }
+            writeMcpConfig(process.cwd(), def, authValues, resolvedCommand);
+            console.log(`\n\u2705 ${def.name} MCP configured\n`);
+        }
+        rl.close();
+    });
+    mcp
+        .command('remove <id>')
+        .description('Remove an MCP from .mcp.json and .env')
+        .option('-f, --force', 'Skip squad dependency check')
+        .action((id, options) => {
+        const configured = getConfiguredMcpIds(process.cwd());
+        if (!configured.includes(id)) {
+            console.log(`\u274c MCP "${id}" is not configured`);
+            return;
+        }
+        if (!options.force) {
+            const squadsDir = path.resolve('squads');
+            if (fs.existsSync(squadsDir)) {
+                const dependentSquads = [];
+                for (const entry of fs.readdirSync(squadsDir)) {
+                    const yamlPath = path.join(squadsDir, entry, 'squad.yaml');
+                    if (!fs.existsSync(yamlPath))
+                        continue;
+                    try {
+                        const raw = yaml.load(fs.readFileSync(yamlPath, 'utf-8'));
+                        const mcps = raw.squad?.mcps;
+                        if (mcps?.includes(id))
+                            dependentSquads.push(entry);
+                    }
+                    catch { /* skip */ }
+                }
+                if (dependentSquads.length > 0) {
+                    console.log(`\u26a0\ufe0f  Squads that depend on "${id}": ${dependentSquads.join(', ')}`);
+                    console.log(`   Use --force to remove anyway`);
+                    return;
+                }
+            }
+        }
+        removeMcpConfig(process.cwd(), id);
+        console.log(`\u2705 Removed MCP: ${id}`);
+    });
+    mcp
+        .command('check [id]')
+        .description('Validate configured MCP connections')
+        .action((id) => {
+        const configured = getConfiguredMcpIds(process.cwd());
+        const toCheck = id ? [id] : configured;
+        let issues = 0;
+        console.log('\nChecking MCP connections...\n');
+        for (const mcpId of toCheck) {
+            if (!configured.includes(mcpId)) {
+                console.log(`  \u274c ${mcpId.padEnd(14)} \u2014 Not configured`);
+                issues++;
+                continue;
+            }
+            console.log(`  \u2705 ${mcpId.padEnd(14)} \u2014 Configured`);
+        }
+        if (issues > 0) {
+            console.log(`\n${issues} issue(s) found.\n`);
+        }
+        else {
+            console.log(`\nAll MCPs OK.\n`);
+        }
+    });
+    return mcp;
+}

package/dist/cli/src/commands/sync-templates.d.ts

@@ -0,0 +1 @@
+export declare function syncTemplatesCommand(squadFilter?: string): Promise<void>;

package/dist/cli/src/commands/sync-templates.js

@@ -0,0 +1,125 @@
+import fs from 'fs';
+import path from 'path';
+import { findSquadDir, loadSquad } from '../../../core/squad-loader.js';
+/**
+ * Find all .pen files in a squad's templates/ directory.
+ */
+function findPenFiles(squadDir) {
+    const templatesDir = path.join(squadDir, 'templates');
+    if (!fs.existsSync(templatesDir))
+        return [];
+    return fs.readdirSync(templatesDir)
+        .filter(f => f.endsWith('.pen'))
+        .map(f => path.join(templatesDir, f));
+}
+/**
+ * Find all template .md files in a squad's templates/ directory.
+ */
+function findTemplateMds(squadDir) {
+    const templatesDir = path.join(squadDir, 'templates');
+    if (!fs.existsSync(templatesDir))
+        return [];
+    return fs.readdirSync(templatesDir)
+        .filter(f => f.startsWith('template-') && f.endsWith('.md'));
+}
+/**
+ * Walk squads directory and find all squads with visual_templates enabled.
+ */
+function findVisualSquads(squadsDir) {
+    const results = [];
+    function walk(dir, depth) {
+        if (depth > 4)
+            return;
+        const yamlPath = path.join(dir, 'squad.yaml');
+        if (fs.existsSync(yamlPath)) {
+            try {
+                const config = loadSquad(dir);
+                if (config.squad.visualTemplates?.enabled) {
+                    results.push(dir);
+                }
+            }
+            catch {
+                // Invalid squad — skip
+            }
+            return;
+        }
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith('.') || entry.name.startsWith('_'))
+                continue;
+            walk(path.join(dir, entry.name), depth + 1);
+        }
+    }
+    walk(squadsDir, 0);
+    return results;
+}
+export async function syncTemplatesCommand(squadFilter) {
+    const cwd = process.cwd();
+    const squadsDir = path.join(cwd, 'squads');
+    if (!fs.existsSync(squadsDir)) {
+        console.error('No squads/ directory found. Run `expxagents init` first.');
+        process.exit(1);
+    }
+    let squadDirs;
+    if (squadFilter) {
+        const dir = findSquadDir(squadsDir, squadFilter);
+        if (!dir) {
+            console.error(`Squad "${squadFilter}" not found.`);
+            process.exit(1);
+        }
+        squadDirs = [dir];
+    }
+    else {
+        squadDirs = findVisualSquads(squadsDir);
+    }
+    if (squadDirs.length === 0) {
+        console.log('No squads with visual_templates found.');
+        console.log('Add `visual_templates: { enabled: true }` to squad.yaml to enable.');
+        return;
+    }
+    console.log(`\nSync Templates — ${squadDirs.length} visual squad(s) found\n`);
+    for (const squadDir of squadDirs) {
+        const config = loadSquad(squadDir);
+        const penFiles = findPenFiles(squadDir);
+        const existingMds = findTemplateMds(squadDir);
+        const squadName = config.squad.name;
+        console.log(`--- ${squadName} (${config.squad.code}) ---`);
+        if (penFiles.length === 0) {
+            console.log('  No .pen files found in templates/');
+            console.log('  Create a .pen file or use Pencil to design templates.');
+            // Create templates dir if it doesn't exist
+            const templatesDir = path.join(squadDir, 'templates');
+            if (!fs.existsSync(templatesDir)) {
+                fs.mkdirSync(templatesDir, { recursive: true });
+                console.log('  Created templates/ directory');
+            }
+            console.log('');
+            continue;
+        }
+        console.log(`  .pen files: ${penFiles.map(f => path.basename(f)).join(', ')}`);
+        console.log(`  Existing .md templates: ${existingMds.length}`);
+        console.log('');
+        console.log('  To sync, open the .pen file in Pencil (VSCode) and run:');
+        console.log('    1. Open the .pen file in VSCode');
+        console.log('    2. Use Claude Code with Pencil MCP to read frames');
+        console.log('    3. The sync will generate/update template .md files');
+        console.log('');
+        // Report existing template .md files
+        if (existingMds.length > 0) {
+            console.log('  Current templates:');
+            for (const md of existingMds) {
+                console.log(`    - ${md}`);
+            }
+            console.log('');
+        }
+    }
+    console.log('Sync complete.');
+}

package/dist/cli/src/index.js

@@ -14,6 +14,8 @@ import { virtualOfficeCommand } from './commands/virtual-office.js';
 import { jarvisCommand } from './commands/jarvis.js';
 import { schedulerCommand } from './commands/scheduler.js';
 import { reorganizeCommand } from './commands/reorganize.js';
+import { syncTemplatesCommand } from './commands/sync-templates.js';
+import { mcpCommand } from './commands/mcp.js';
 import { ingestCommand } from './commands/ingest.js';
 import { knowledgeCommand } from './commands/knowledge.js';
 import { loginCommand } from './commands/login.js';
@@ -64,6 +66,10 @@ program
     .command('reorganize')
     .description('Reorganize squads into Setor > Grupo > Sessão > Squad hierarchy')
     .action(reorganizeCommand);
+program
+    .command('sync-templates [squad]')
+    .description('Sync Pencil .pen templates to .md specs for visual squads')
+    .action(syncTemplatesCommand);
 program
     .command('install <skill>')
     .description('Install skill from registry')
@@ -94,6 +100,7 @@ program
     .description('Open Jarvis voice assistant in browser')
     .action(jarvisCommand);
 program.addCommand(schedulerCommand());
+program.addCommand(mcpCommand());
 program
     .command('ingest <path>')
     .description('Ingest documents into the knowledge base')

package/dist/cli/src/mcp/__tests__/catalog.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/src/mcp/__tests__/catalog.test.js

@@ -0,0 +1,101 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { loadMcpCatalog, loadMcpDefinition, listAllMcpIds } from '../catalog.js';
+let tmpDir;
+beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-catalog-test-'));
+});
+afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+function writeCatalog(content) {
+    fs.writeFileSync(path.join(tmpDir, '_catalog.yaml'), content, 'utf-8');
+}
+function writeDefinition(id, content) {
+    fs.writeFileSync(path.join(tmpDir, `${id}.mcp.yaml`), content, 'utf-8');
+}
+describe('loadMcpCatalog', () => {
+    it('loads and parses _catalog.yaml', () => {
+        writeCatalog(`
+catalog:
+  version: "1.0.0"
+  categories:
+    - name: development
+      mcps: [github]
+    - name: communication
+      mcps: [slack]
+`);
+        const catalog = loadMcpCatalog(tmpDir);
+        expect(catalog.version).toBe('1.0.0');
+        expect(catalog.categories).toHaveLength(2);
+        expect(catalog.categories[0].name).toBe('development');
+        expect(catalog.categories[0].mcps).toEqual(['github']);
+    });
+    it('returns empty categories when catalog is missing', () => {
+        const catalog = loadMcpCatalog(tmpDir);
+        expect(catalog.categories).toEqual([]);
+    });
+});
+describe('listAllMcpIds', () => {
+    it('flattens all MCP IDs from categories', () => {
+        writeCatalog(`
+catalog:
+  version: "1.0.0"
+  categories:
+    - name: dev
+      mcps: [github, postgresql]
+    - name: comm
+      mcps: [slack]
+`);
+        const ids = listAllMcpIds(tmpDir);
+        expect(ids).toEqual(['github', 'postgresql', 'slack']);
+    });
+});
+describe('loadMcpDefinition', () => {
+    it('loads individual MCP definition by ID', () => {
+        writeDefinition('github', `
+id: github
+name: GitHub
+description: PRs and issues
+category: development
+detection:
+  method: npm
+  npm:
+    package: "@modelcontextprotocol/server-github"
+server:
+  command: npx
+  args: ["-y", "@modelcontextprotocol/server-github"]
+  env:
+    GITHUB_PERSONAL_ACCESS_TOKEN: "\${GITHUB_PERSONAL_ACCESS_TOKEN}"
+auth:
+  - key: GITHUB_PERSONAL_ACCESS_TOKEN
+    label: "GitHub Token"
+    hint: "Create at github.com/settings/tokens"
+    required: true
+tools:
+  - name: list_issues
+    description: List issues
+relevant_sectors:
+  - development
+`);
+        const def = loadMcpDefinition(tmpDir, 'github');
+        expect(def).not.toBeNull();
+        expect(def.id).toBe('github');
+        expect(def.name).toBe('GitHub');
+        expect(def.detection.method).toBe('npm');
+        expect(def.auth).toHaveLength(1);
+        expect(def.auth[0].key).toBe('GITHUB_PERSONAL_ACCESS_TOKEN');
+        expect(def.server.args).toContain('-y');
+    });
+    it('returns null for unknown MCP ID', () => {
+        const def = loadMcpDefinition(tmpDir, 'nonexistent');
+        expect(def).toBeNull();
+    });
+    it('handles malformed YAML gracefully', () => {
+        writeDefinition('broken', '{{{{not yaml');
+        const def = loadMcpDefinition(tmpDir, 'broken');
+        expect(def).toBeNull();
+    });
+});

package/dist/cli/src/mcp/__tests__/detect.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/src/mcp/__tests__/detect.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { detectMcp, resolvePlatformBinary, detectExtension } from '../detect.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+function makeDef(overrides) {
+    return {
+        name: overrides.id,
+        description: '',
+        category: 'test',
+        server: { command: 'npx', args: [], env: {} },
+        auth: [],
+        tools: [],
+        relevant_sectors: [],
+        ...overrides,
+    };
+}
+describe('resolvePlatformBinary', () => {
+    it('resolves darwin + arm64', () => {
+        expect(resolvePlatformBinary('darwin', 'arm64')).toBe('mcp-server-darwin-arm64');
+    });
+    it('resolves darwin + x64', () => {
+        expect(resolvePlatformBinary('darwin', 'x64')).toBe('mcp-server-darwin-x64');
+    });
+    it('resolves linux + x64', () => {
+        expect(resolvePlatformBinary('linux', 'x64')).toBe('mcp-server-linux-x64');
+    });
+    it('resolves win32 + x64 with .exe', () => {
+        expect(resolvePlatformBinary('win32', 'x64')).toBe('mcp-server-win32-x64.exe');
+    });
+});
+describe('detectExtension', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ext-detect-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('returns null when no extension found', () => {
+        const result = detectExtension('nonexistent-prefix-', tmpDir);
+        expect(result).toBeNull();
+    });
+    it('finds latest version', () => {
+        fs.mkdirSync(path.join(tmpDir, 'highagency.pencildev-0.6.30'));
+        fs.mkdirSync(path.join(tmpDir, 'highagency.pencildev-0.6.35'));
+        const result = detectExtension('highagency.pencildev-', tmpDir);
+        expect(result).not.toBeNull();
+        expect(result.version).toBe('0.6.35');
+        expect(result.extensionPath).toContain('0.6.35');
+    });
+});
+describe('detectMcp', () => {
+    it('npm detection — always returns available', () => {
+        const def = makeDef({
+            id: 'slack',
+            detection: { method: 'npm', npm: { package: '@modelcontextprotocol/server-slack' } },
+        });
+        const result = detectMcp(def);
+        expect(result.status).toBe('available');
+        expect(result.detail).toContain('npm');
+    });
+    it('cli detection — returns unavailable when command not found', () => {
+        const def = makeDef({
+            id: 'test-cli',
+            detection: { method: 'cli', cli: { command: 'nonexistent-binary-xyz', version_flag: '--version' } },
+        });
+        const result = detectMcp(def);
+        expect(result.status).toBe('unavailable');
+    });
+    it('hybrid detection — falls back to npm when CLI not found', () => {
+        const def = makeDef({
+            id: 'test-hybrid',
+            detection: {
+                method: 'hybrid',
+                cli: { command: 'nonexistent-binary-xyz', version_flag: '--version' },
+                npm: { package: 'some-package' },
+            },
+        });
+        const result = detectMcp(def);
+        expect(result.status).toBe('available');
+        expect(result.detail).toContain('npm');
+    });
+});

package/dist/cli/src/mcp/__tests__/setup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/src/mcp/__tests__/setup.test.js

@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { writeMcpConfig, removeMcpConfig, readMcpJson } from '../setup.js';
+let tmpDir;
+beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-setup-test-'));
+});
+afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+function makeDef(id) {
+    return {
+        id,
+        name: id,
+        description: '',
+        category: 'test',
+        detection: { method: 'npm', npm: { package: `@test/${id}` } },
+        server: { command: 'npx', args: ['-y', `@test/${id}`], env: { TOKEN: '${TOKEN}' } },
+        auth: [{ key: 'TOKEN', label: 'Token', hint: 'hint', required: true }],
+        tools: [],
+        relevant_sectors: [],
+    };
+}
+describe('writeMcpConfig', () => {
+    it('creates .mcp.json with server entry', () => {
+        writeMcpConfig(tmpDir, makeDef('github'), { TOKEN: 'abc123' });
+        const json = readMcpJson(tmpDir);
+        expect(json.mcpServers.github).toBeDefined();
+        expect(json.mcpServers.github.command).toBe('npx');
+        expect(json.mcpServers.github.args).toContain('-y');
+    });
+    it('merges into existing .mcp.json without overwriting', () => {
+        const existing = { mcpServers: { pencil: { command: '/bin/pencil', args: [], env: {} } } };
+        fs.writeFileSync(path.join(tmpDir, '.mcp.json'), JSON.stringify(existing, null, 2));
+        writeMcpConfig(tmpDir, makeDef('github'), { TOKEN: 'abc' });
+        const json = readMcpJson(tmpDir);
+        expect(json.mcpServers.pencil).toBeDefined();
+        expect(json.mcpServers.github).toBeDefined();
+    });
+    it('adds env vars to .env file', () => {
+        writeMcpConfig(tmpDir, makeDef('github'), { TOKEN: 'mytoken' });
+        const env = fs.readFileSync(path.join(tmpDir, '.env'), 'utf-8');
+        expect(env).toContain('TOKEN=mytoken');
+    });
+    it('adds placeholders to .env.example', () => {
+        writeMcpConfig(tmpDir, makeDef('github'), { TOKEN: 'mytoken' });
+        const example = fs.readFileSync(path.join(tmpDir, '.env.example'), 'utf-8');
+        expect(example).toContain('TOKEN=');
+        expect(example).not.toContain('mytoken');
+    });
+    it('handles extension-based MCP with resolved command', () => {
+        const def = makeDef('pencil');
+        def.server.command = null;
+        writeMcpConfig(tmpDir, def, {}, '/resolved/path/to/binary');
+        const json = readMcpJson(tmpDir);
+        expect(json.mcpServers.pencil.command).toBe('/resolved/path/to/binary');
+    });
+});
+describe('removeMcpConfig', () => {
+    it('removes MCP entry from .mcp.json', () => {
+        const existing = {
+            mcpServers: {
+                github: { command: 'npx', args: [], env: {} },
+                slack: { command: 'npx', args: [], env: {} },
+            },
+        };
+        fs.writeFileSync(path.join(tmpDir, '.mcp.json'), JSON.stringify(existing, null, 2));
+        removeMcpConfig(tmpDir, 'github');
+        const json = readMcpJson(tmpDir);
+        expect(json.mcpServers.github).toBeUndefined();
+        expect(json.mcpServers.slack).toBeDefined();
+    });
+});

package/dist/cli/src/mcp/__tests__/validate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/src/mcp/__tests__/validate.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { validateSquadMcps, getConfiguredMcpIds } from '../validate.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+let tmpDir;
+beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-validate-test-'));
+});
+afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+describe('getConfiguredMcpIds', () => {
+    it('returns MCP IDs from .mcp.json', () => {
+        fs.writeFileSync(path.join(tmpDir, '.mcp.json'), JSON.stringify({
+            mcpServers: { github: { command: 'x', args: [], env: {} }, slack: { command: 'x', args: [], env: {} } },
+        }));
+        expect(getConfiguredMcpIds(tmpDir)).toEqual(['github', 'slack']);
+    });
+    it('returns empty array when .mcp.json missing', () => {
+        expect(getConfiguredMcpIds(tmpDir)).toEqual([]);
+    });
+});
+describe('validateSquadMcps', () => {
+    it('passes when squad has no mcps field', () => {
+        expect(() => validateSquadMcps(undefined, ['github'])).not.toThrow();
+    });
+    it('passes when squad has empty mcps', () => {
+        expect(() => validateSquadMcps([], ['github'])).not.toThrow();
+    });
+    it('passes when all required MCPs are configured', () => {
+        expect(() => validateSquadMcps(['github', 'slack'], ['github', 'slack', 'sentry'])).not.toThrow();
+    });
+    it('throws when required MCP is not configured', () => {
+        expect(() => validateSquadMcps(['github', 'linear'], ['github']))
+            .toThrow(/linear/i);
+    });
+    it('includes setup command in error message', () => {
+        expect(() => validateSquadMcps(['linear'], []))
+            .toThrow(/expxagents mcp setup/i);
+    });
+});

package/dist/cli/src/mcp/catalog.d.ts

@@ -0,0 +1,4 @@
+import type { McpCatalog, McpDefinition } from './types.js';
+export declare function loadMcpCatalog(mcpsDir: string): McpCatalog;
+export declare function listAllMcpIds(mcpsDir: string): string[];
+export declare function loadMcpDefinition(mcpsDir: string, id: string): McpDefinition | null;