expxagents 0.1.0

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

@@ -0,0 +1,86 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { getAssetsDir } from '../utils/config.js';
+export async function doctorCommand() {
+    const cwd = process.cwd();
+    const checks = [];
+    // Node.js version
+    const nodeVersion = process.version;
+    const major = parseInt(nodeVersion.slice(1));
+    checks.push({
+        name: 'Node.js',
+        status: major >= 20 ? 'ok' : 'fail',
+        message: `${nodeVersion} ${major >= 20 ? '(meets >=20)' : '(requires >=20)'}`,
+    });
+    // Claude Code CLI
+    try {
+        const claudeVersion = execSync('claude --version', { encoding: 'utf-8' }).trim();
+        checks.push({ name: 'Claude Code CLI', status: 'ok', message: claudeVersion });
+    }
+    catch {
+        checks.push({ name: 'Claude Code CLI', status: 'fail', message: 'Not found — install from https://claude.ai/code' });
+    }
+    // Project structure
+    const requiredDirs = ['squads', '_expxagents/_memory'];
+    for (const dir of requiredDirs) {
+        const exists = fs.existsSync(path.join(cwd, dir));
+        checks.push({
+            name: `Directory: ${dir}`,
+            status: exists ? 'ok' : 'warn',
+            message: exists ? 'exists' : 'missing — run `expxagents init`',
+        });
+    }
+    // .env file
+    const envExists = fs.existsSync(path.join(cwd, '.env'));
+    checks.push({
+        name: '.env file',
+        status: envExists ? 'ok' : 'warn',
+        message: envExists ? 'exists' : 'missing — run `expxagents init`',
+    });
+    // Company profile
+    const companyPath = path.join(cwd, '_expxagents', '_memory', 'company.md');
+    if (fs.existsSync(companyPath)) {
+        const content = fs.readFileSync(companyPath, 'utf-8');
+        const configured = !content.includes('NOT CONFIGURED');
+        checks.push({
+            name: 'Company profile',
+            status: configured ? 'ok' : 'warn',
+            message: configured ? 'configured' : 'not configured — run `expxagents onboarding`',
+        });
+    }
+    // Squads count
+    const squadsDir = path.join(cwd, 'squads');
+    if (fs.existsSync(squadsDir)) {
+        const squads = fs.readdirSync(squadsDir, { withFileTypes: true })
+            .filter(d => d.isDirectory() && !d.name.startsWith('.') && d.name !== '_memory')
+            .length;
+        checks.push({ name: 'Squads', status: 'ok', message: `${squads} found` });
+    }
+    // Package assets (check in package directory, not user project)
+    const assetsDir = getAssetsDir();
+    const coreFiles = [
+        { label: 'solution-architect.agent.md', path: path.join(assetsDir, 'core', 'solution-architect.agent.md') },
+        { label: 'runner.pipeline.md', path: path.join(assetsDir, 'core', 'runner.pipeline.md') },
+        { label: 'agents catalog', path: path.join(assetsDir, 'agents', '_catalog.yaml') },
+        { label: 'best-practices', path: path.join(assetsDir, 'core', 'best-practices', '_catalog.yaml') },
+    ];
+    for (const file of coreFiles) {
+        const exists = fs.existsSync(file.path);
+        checks.push({
+            name: `Package: ${file.label}`,
+            status: exists ? 'ok' : 'warn',
+            message: exists ? 'present' : 'missing — reinstall expxagents',
+        });
+    }
+    // Display results
+    console.log('\n  ExpxAgents System Diagnostics\n');
+    const symbols = { ok: '  OK', warn: 'WARN', fail: 'FAIL' };
+    let hasFailures = false;
+    for (const check of checks) {
+        if (check.status === 'fail')
+            hasFailures = true;
+        console.log(`  [${symbols[check.status]}] ${check.name}: ${check.message}`);
+    }
+    console.log(hasFailures ? '\n  Some checks failed. See above.\n' : '\n  All checks passed!\n');
+}

package/dist/cli/src/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(): Promise<void>;

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

@@ -0,0 +1,164 @@
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { getTemplateDir } from '../utils/config.js';
+function getDefaultTemplate(file) {
+    if (file === 'company.md') {
+        return `<!-- NOT CONFIGURED -->
+# Company Profile
+
+## Company
+- **Name:**
+- **Website:**
+- **Sector:**
+- **Description:**
+
+## Target Audience
+- **Primary:**
+- **Secondary:**
+
+## Tone of Voice
+- **Style:**
+- **Keywords:**
+
+## Social Media
+- **Instagram:**
+- **LinkedIn:**
+- **Twitter:**
+- **YouTube:**
+
+## Products/Services
+-
+`;
+    }
+    if (file === 'preferences.md') {
+        return `# ExpxAgents Preferences
+
+- **User Name:**
+- **Language:** Portugues (Brasil)
+- **IDE:** claude-code
+- **Date Format:** DD/MM/YYYY
+`;
+    }
+    if (file === 'memories.md') {
+        return `# Squad Memories
+
+> Updated automatically after each pipeline execution.
+> Contains learnings, user preferences, and decisions from past runs.
+
+## Execution History
+
+(No runs yet)
+
+## User Preferences
+
+(No preferences recorded yet)
+
+## Key Learnings
+
+(No learnings recorded yet)
+`;
+    }
+    return '';
+}
+export async function initCommand() {
+    const cwd = process.cwd();
+    console.log('Initializing ExpxAgents project...\n');
+    // Create squads directory
+    const squadsDir = path.join(cwd, 'squads');
+    if (!fs.existsSync(squadsDir)) {
+        fs.mkdirSync(squadsDir, { recursive: true });
+        console.log('  Created squads/');
+    }
+    else {
+        console.log('  squads/ already exists');
+    }
+    // Create _expxagents/_memory/ directory
+    const memoryDir = path.join(cwd, '_expxagents', '_memory');
+    if (!fs.existsSync(memoryDir)) {
+        fs.mkdirSync(memoryDir, { recursive: true });
+        console.log('  Created _expxagents/_memory/');
+    }
+    else {
+        console.log('  _expxagents/_memory/ already exists');
+    }
+    // Copy template files from package assets
+    const templateDir = getTemplateDir();
+    const templateMemoryDir = path.join(templateDir, '_expxagents', '_memory');
+    const memoryFiles = ['company.md', 'preferences.md'];
+    for (const file of memoryFiles) {
+        const destPath = path.join(memoryDir, file);
+        if (!fs.existsSync(destPath)) {
+            const templateSrc = path.join(templateMemoryDir, file);
+            if (fs.existsSync(templateSrc)) {
+                fs.copyFileSync(templateSrc, destPath);
+            }
+            else {
+                fs.writeFileSync(destPath, getDefaultTemplate(file), 'utf-8');
+            }
+            console.log(`  Created _expxagents/_memory/${file}`);
+        }
+        else {
+            console.log(`  _expxagents/_memory/${file} already exists`);
+        }
+    }
+    // Create squads/_memory/ subdirectory
+    const squadsMemoryDir = path.join(cwd, 'squads', '_memory');
+    if (!fs.existsSync(squadsMemoryDir)) {
+        fs.mkdirSync(squadsMemoryDir, { recursive: true });
+        console.log('  Created squads/_memory/');
+    }
+    else {
+        console.log('  squads/_memory/ already exists');
+    }
+    const memoriesTemplateSrc = path.join(templateDir, 'squads', '_memory', 'memories.md');
+    const memoriesTemplateDest = path.join(squadsMemoryDir, 'memories.md');
+    if (!fs.existsSync(memoriesTemplateDest)) {
+        if (fs.existsSync(memoriesTemplateSrc)) {
+            fs.copyFileSync(memoriesTemplateSrc, memoriesTemplateDest);
+        }
+        else {
+            fs.writeFileSync(memoriesTemplateDest, getDefaultTemplate('memories.md'), 'utf-8');
+        }
+        console.log('  Created squads/_memory/memories.md');
+    }
+    // Create .env if it doesn't exist
+    const envPath = path.join(cwd, '.env');
+    if (!fs.existsSync(envPath)) {
+        const jwtSecret = crypto.randomBytes(32).toString('hex');
+        const envContent = `JWT_SECRET=${jwtSecret}
+PORT=3001
+CORS_ORIGIN=http://localhost:3001
+NODE_ENV=development
+BRIDGE_TIMEOUT_MS=300000
+`;
+        fs.writeFileSync(envPath, envContent, 'utf-8');
+        console.log('  Created .env with generated JWT_SECRET');
+    }
+    else {
+        console.log('  .env already exists');
+    }
+    // Create .gitignore additions
+    const gitignorePath = path.join(cwd, '.gitignore');
+    const gitignoreEntries = [
+        'node_modules/',
+        '.env',
+        '*.tmp',
+        'squads/*/state.json',
+        'squads/*/state.json.tmp',
+        'squads/*/output/',
+    ];
+    if (fs.existsSync(gitignorePath)) {
+        const existing = fs.readFileSync(gitignorePath, 'utf-8');
+        const toAdd = gitignoreEntries.filter(e => !existing.includes(e));
+        if (toAdd.length > 0) {
+            fs.appendFileSync(gitignorePath, '\n# ExpxAgents\n' + toAdd.join('\n') + '\n');
+            console.log('  Updated .gitignore');
+        }
+    }
+    else {
+        fs.writeFileSync(gitignorePath, gitignoreEntries.join('\n') + '\n', 'utf-8');
+        console.log('  Created .gitignore');
+    }
+    console.log('\nProject initialized! Run `expxagents onboarding` to configure your profile.');
+}

package/dist/cli/src/commands/install.d.ts

@@ -0,0 +1 @@
+export declare function installCommand(skillName: string): Promise<void>;

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

@@ -0,0 +1,65 @@
+import fs from 'fs';
+import path from 'path';
+const SKILL_CATALOG = {
+    'web-search': {
+        description: 'Web search capability (built-in)',
+        type: 'prompt',
+        template: `---\nname: web-search\ndescription: "Search the web for information"\ntype: prompt\nversion: "1.0.0"\ncategories: [search, research]\n---\n\n# Web Search\n\nUse the built-in web_search tool to find information online.\n`,
+    },
+    'apify': {
+        description: 'Web scraping via Apify Actors',
+        type: 'mcp',
+        template: `---\nname: apify\ndescription: "Web scraping via Apify Actors"\ntype: mcp\nversion: "1.0.0"\nmcp:\n  server_name: "apify"\n  command: "npx"\n  args: ["-y", "@apify/actors-mcp-server@latest"]\n  transport: "stdio"\nenv:\n  - APIFY_TOKEN\ncategories: [scraping, data]\n---\n\n# Apify\n\nUse Apify Actors for web scraping tasks.\n`,
+    },
+    'image-creator': {
+        description: 'AI image generation via DALL-E or Stable Diffusion',
+        type: 'mcp',
+        template: `---\nname: image-creator\ndescription: "Generate images using AI models"\ntype: mcp\nversion: "1.0.0"\nmcp:\n  server_name: "image-creator"\n  command: "npx"\n  args: ["-y", "@modelcontextprotocol/server-dalle@latest"]\n  transport: "stdio"\nenv:\n  - OPENAI_API_KEY\ncategories: [design, content]\n---\n\n# Image Creator\n\nGenerate images using AI models for content creation.\n`,
+    },
+    'github': {
+        description: 'GitHub integration for repositories, issues, PRs',
+        type: 'mcp',
+        template: `---\nname: github\ndescription: "GitHub integration for repository management"\ntype: mcp\nversion: "1.0.0"\nmcp:\n  server_name: "github"\n  command: "npx"\n  args: ["-y", "@modelcontextprotocol/server-github@latest"]\n  transport: "stdio"\nenv:\n  - GITHUB_TOKEN\ncategories: [development, integration]\n---\n\n# GitHub Integration\n\nManage GitHub repositories, issues, and pull requests.\n`,
+    },
+    'slack': {
+        description: 'Slack messaging integration',
+        type: 'mcp',
+        template: `---\nname: slack\ndescription: "Send and receive Slack messages"\ntype: mcp\nversion: "1.0.0"\nmcp:\n  server_name: "slack"\n  command: "npx"\n  args: ["-y", "@anthropic/slack-mcp-server@latest"]\n  transport: "stdio"\nenv:\n  - SLACK_BOT_TOKEN\ncategories: [communication, integration]\n---\n\n# Slack Integration\n\nSend and receive messages via Slack.\n`,
+    },
+    'canva': {
+        description: 'Design creation via Canva API',
+        type: 'mcp',
+        template: `---\nname: canva\ndescription: "Create designs using Canva"\ntype: mcp\nversion: "1.0.0"\nmcp:\n  server_name: "canva"\n  command: "npx"\n  args: ["-y", "@anthropic/canva-mcp-server@latest"]\n  transport: "stdio"\nenv:\n  - CANVA_API_KEY\ncategories: [design, content]\n---\n\n# Canva Integration\n\nCreate professional designs using Canva.\n`,
+    },
+};
+export async function installCommand(skillName) {
+    const cwd = process.cwd();
+    const skillsDir = path.join(cwd, 'skills');
+    if (!skillName) {
+        console.log('\n  Available skills:\n');
+        for (const [name, info] of Object.entries(SKILL_CATALOG)) {
+            const installed = fs.existsSync(path.join(skillsDir, name));
+            console.log(`  ${installed ? '[installed]' : '          '} ${name} — ${info.description}`);
+        }
+        console.log('\n  Usage: expxagents install <skill-name>\n');
+        return;
+    }
+    const skill = SKILL_CATALOG[skillName];
+    if (!skill) {
+        console.error(`  Skill "${skillName}" not found in catalog.`);
+        console.log('  Run `expxagents install` to see available skills.');
+        process.exit(1);
+    }
+    const skillDir = path.join(skillsDir, skillName);
+    if (fs.existsSync(skillDir)) {
+        console.log(`  Skill "${skillName}" is already installed.`);
+        return;
+    }
+    fs.mkdirSync(skillDir, { recursive: true });
+    fs.writeFileSync(path.join(skillDir, 'SKILL.md'), skill.template, 'utf-8');
+    console.log(`  Installed skill: ${skillName}`);
+    if (skill.type === 'mcp') {
+        console.log(`\n  This skill requires MCP configuration.`);
+        console.log(`  Check .mcp.json and set required environment variables.`);
+    }
+}

package/dist/cli/src/commands/list.d.ts

@@ -0,0 +1 @@
+export declare function listCommand(): Promise<void>;

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

@@ -0,0 +1,58 @@
+import fs from 'fs';
+import path from 'path';
+import { loadSquad } from '../../../core/squad-loader.js';
+import { loadSkills } from '../../../core/skills-loader.js';
+import { readState } from '../../../core/state-manager.js';
+export async function listCommand() {
+    const cwd = process.cwd();
+    const squadsDir = path.join(cwd, 'squads');
+    const skillsDir = path.join(cwd, 'skills');
+    // List squads
+    console.log('Squads:');
+    console.log('-------');
+    if (fs.existsSync(squadsDir)) {
+        const entries = fs.readdirSync(squadsDir, { withFileTypes: true });
+        let found = false;
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const squadDir = path.join(squadsDir, entry.name);
+            const yamlPath = path.join(squadDir, 'squad.yaml');
+            if (!fs.existsSync(yamlPath))
+                continue;
+            found = true;
+            try {
+                const config = loadSquad(squadDir);
+                const state = readState(squadDir);
+                const status = state?.status ?? 'idle';
+                const agentCount = config.squad.agents.length;
+                const stepCount = config.squad.pipeline.steps.length;
+                console.log(`  ${config.squad.name} (${config.squad.code})`);
+                console.log(`    Status: ${status} | Agents: ${agentCount} | Steps: ${stepCount}`);
+                console.log(`    ${config.squad.description}`);
+                console.log('');
+            }
+            catch (err) {
+                console.log(`  ${entry.name} — error loading: ${err.message}`);
+            }
+        }
+        if (!found) {
+            console.log('  No squads found. Run `expxagents create` to create one.\n');
+        }
+    }
+    else {
+        console.log('  No squads directory. Run `expxagents init` first.\n');
+    }
+    // List skills
+    console.log('Skills:');
+    console.log('-------');
+    const skills = loadSkills(skillsDir);
+    if (skills.length === 0) {
+        console.log('  No skills installed. Run `expxagents install <skill>` to add one.');
+    }
+    else {
+        for (const skill of skills) {
+            console.log(`  ${skill.name} (${skill.type}) — ${skill.description}`);
+        }
+    }
+}

package/dist/cli/src/commands/onboarding.d.ts

@@ -0,0 +1 @@
+export declare function onboardingCommand(): Promise<void>;

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

@@ -0,0 +1,39 @@
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+function ask(rl, question) {
+    return new Promise(resolve => rl.question(question, resolve));
+}
+export async function onboardingCommand() {
+    const cwd = process.cwd();
+    const companyPath = path.join(cwd, '_expxagents', '_memory', 'company.md');
+    const prefsPath = path.join(cwd, '_expxagents', '_memory', 'preferences.md');
+    if (!fs.existsSync(path.dirname(companyPath))) {
+        console.error('Project not initialized. Run `expxagents init` first.');
+        process.exit(1);
+    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    console.log('\n  Welcome to ExpxAgents!\n');
+    try {
+        const userName = await ask(rl, '  Your name: ');
+        const language = await ask(rl, '  Preferred language (pt-BR, en, es) [pt-BR]: ') || 'pt-BR';
+        const ide = await ask(rl, '  Primary IDE (claude-code, cursor, codex, vscode-copilot) [claude-code]: ') || 'claude-code';
+        const companyName = await ask(rl, '  Company name: ');
+        const companyUrl = await ask(rl, '  Company website URL (optional): ');
+        const sector = await ask(rl, '  Company sector: ');
+        const description = await ask(rl, '  Brief company description: ');
+        const audience = await ask(rl, '  Target audience: ');
+        const toneStyle = await ask(rl, '  Tone of voice (formal, casual, technical, friendly): ');
+        // Save preferences
+        const prefsContent = `# ExpxAgents Preferences\n\n- **User Name:** ${userName}\n- **Language:** ${language}\n- **IDE:** ${ide}\n- **Date Format:** DD/MM/YYYY\n`;
+        fs.writeFileSync(prefsPath, prefsContent, 'utf-8');
+        // Save company profile
+        const companyContent = `# Company Profile\n\n## Company\n- **Name:** ${companyName}\n- **Website:** ${companyUrl}\n- **Sector:** ${sector}\n- **Description:** ${description}\n\n## Target Audience\n- **Primary:** ${audience}\n\n## Tone of Voice\n- **Style:** ${toneStyle}\n`;
+        fs.writeFileSync(companyPath, companyContent, 'utf-8');
+        console.log('\n  Profile saved! You can edit it anytime at _expxagents/_memory/company.md');
+        console.log('  Run `expxagents create` to design your first squad.\n');
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/cli/src/commands/run.d.ts

@@ -0,0 +1 @@
+export declare function runCommand(name: string): Promise<void>;

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

@@ -0,0 +1,226 @@
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import { loadSquad } from '../../../core/squad-loader.js';
+import { createInitialState, readState, writeState, updateAgentStatus, updateStep, setHandoff, setSquadStatus, HANDOFF_DELAY_MS, } from '../../../core/state-manager.js';
+import { loadSkills } from '../../../core/skills-loader.js';
+import { getCoreAsset } from '../utils/config.js';
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function getNextVersionDir(squadDir) {
+    const outputBase = path.join(squadDir, 'output');
+    if (!fs.existsSync(outputBase)) {
+        fs.mkdirSync(outputBase, { recursive: true });
+        const v1 = path.join(outputBase, 'v1');
+        fs.mkdirSync(v1);
+        return v1;
+    }
+    const existing = fs.readdirSync(outputBase)
+        .filter(d => d.startsWith('v'))
+        .map(d => parseInt(d.slice(1)))
+        .filter(n => !isNaN(n))
+        .sort((a, b) => b - a);
+    const next = (existing[0] || 0) + 1;
+    const dir = path.join(outputBase, `v${next}`);
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function buildAgentPrompt(config, step, stepIndex, squadDir, skills, runnerPrompt) {
+    // Load company context (user data — always from cwd)
+    const companyPath = path.join(process.cwd(), '_expxagents', '_memory', 'company.md');
+    let companyContext = '';
+    if (fs.existsSync(companyPath)) {
+        companyContext = fs.readFileSync(companyPath, 'utf-8');
+    }
+    // Load squad memory
+    const memoryPath = path.join(squadDir, '_memory', 'memories.md');
+    let squadMemory = '';
+    if (fs.existsSync(memoryPath)) {
+        squadMemory = fs.readFileSync(memoryPath, 'utf-8');
+    }
+    // Load best-practice if format specified (from package assets)
+    let bestPractice = '';
+    const format = config.squad.format;
+    if (format) {
+        const bpPath = getCoreAsset(`best-practices/${format}.md`);
+        if (fs.existsSync(bpPath)) {
+            bestPractice = fs.readFileSync(bpPath, 'utf-8');
+        }
+    }
+    const agent = config.squad.agents.find(a => a.id === step.agent);
+    let agentInstructions = '';
+    const agentPromptPath = path.join(squadDir, agent.prompt);
+    if (fs.existsSync(agentPromptPath)) {
+        agentInstructions = fs.readFileSync(agentPromptPath, 'utf-8');
+    }
+    let previousOutput = '';
+    if (step.deliverFrom) {
+        const prevStepIdx = config.squad.pipeline.steps.findIndex(s => s.agent === step.deliverFrom);
+        if (prevStepIdx !== -1) {
+            const prevOutputPath = path.join(squadDir, 'output', `step-${String(prevStepIdx + 1).padStart(2, '0')}.md`);
+            if (fs.existsSync(prevOutputPath)) {
+                previousOutput = fs.readFileSync(prevOutputPath, 'utf-8');
+            }
+        }
+    }
+    const squadSkills = config.squad.skills || [];
+    const skillInstructions = skills
+        .filter(s => squadSkills.includes(s.name))
+        .map(s => `### Skill: ${s.name}\n${s.instructions}`)
+        .join('\n\n');
+    const parts = [
+        runnerPrompt,
+        '',
+        `## Current Task`,
+        `- **Squad:** ${config.squad.name} (${config.squad.code})`,
+        `- **Agent:** ${agent.name} (${agent.id})`,
+        `- **Step ${stepIndex}/${config.squad.pipeline.steps.length}:** ${step.label}`,
+        '',
+    ];
+    if (agentInstructions) {
+        parts.push('## Agent Instructions', '', agentInstructions, '');
+    }
+    if (previousOutput) {
+        parts.push(`## Input from ${step.deliverFrom}`, '', previousOutput, '');
+    }
+    if (skillInstructions) {
+        parts.push('## Available Skills', '', skillInstructions, '');
+    }
+    if (companyContext && !companyContext.includes('NOT CONFIGURED')) {
+        parts.push('## Company Context', '', companyContext, '');
+    }
+    if (squadMemory) {
+        parts.push('## Squad Memory (past learnings)', '', squadMemory, '');
+    }
+    if (bestPractice) {
+        parts.push('## Format Best Practices', '', bestPractice, '');
+    }
+    parts.push('## Output', '', `Write your complete output below. It will be saved to output/step-${String(stepIndex).padStart(2, '0')}.md`);
+    return parts.join('\n');
+}
+function spawnClaudeCode(prompt, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('claude', ['-p', '--verbose', prompt], {
+            cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (data) => {
+            const chunk = data.toString();
+            stdout += chunk;
+            process.stdout.write(chunk);
+        });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('error', (err) => {
+            reject(new Error(`Failed to spawn Claude Code: ${err.message}`));
+        });
+        child.on('exit', (code) => {
+            if (code === 0) {
+                resolve(stdout);
+            }
+            else {
+                reject(new Error(`Claude Code exited with code ${code}: ${stderr}`));
+            }
+        });
+    });
+}
+export async function runCommand(name) {
+    const cwd = process.cwd();
+    const squadDir = path.join(cwd, 'squads', name);
+    const skillsDir = path.join(cwd, 'skills');
+    if (!fs.existsSync(squadDir)) {
+        console.error(`Squad "${name}" not found in squads/ directory.`);
+        process.exit(1);
+    }
+    let config;
+    try {
+        config = loadSquad(squadDir);
+    }
+    catch (err) {
+        console.error(`Failed to load squad config: ${err.message}`);
+        process.exit(1);
+    }
+    const skills = loadSkills(skillsDir);
+    const runnerPromptPath = getCoreAsset('runner.pipeline.md');
+    let runnerPrompt = '';
+    if (fs.existsSync(runnerPromptPath)) {
+        runnerPrompt = fs.readFileSync(runnerPromptPath, 'utf-8');
+    }
+    const existingState = readState(squadDir);
+    if (existingState && existingState.status === 'running') {
+        console.error(`Squad "${name}" is already running. Use \`expxagents stop ${name}\` first.`);
+        process.exit(1);
+    }
+    const outputDir = getNextVersionDir(squadDir);
+    const version = path.basename(outputDir).slice(1); // e.g. "v3" -> "3"
+    let state = createInitialState(config);
+    state = setSquadStatus(state, 'running');
+    state = { ...state, startedAt: new Date().toISOString() };
+    writeState(squadDir, state);
+    console.log(`\nRunning squad "${config.squad.name}" (${config.squad.code})`);
+    console.log(`Pipeline: ${config.squad.pipeline.steps.length} steps\n`);
+    const steps = config.squad.pipeline.steps;
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        const stepNumber = i + 1;
+        const agent = config.squad.agents.find(a => a.id === step.agent);
+        console.log(`--- Step ${stepNumber}/${steps.length}: ${step.label} (${agent.name}) ---\n`);
+        state = updateAgentStatus(state, step.agent, 'working');
+        state = updateStep(state, stepNumber, step.label);
+        writeState(squadDir, state);
+        const prompt = buildAgentPrompt(config, step, stepNumber, squadDir, skills, runnerPrompt);
+        let output;
+        try {
+            output = await spawnClaudeCode(prompt, squadDir);
+        }
+        catch (err) {
+            console.error(`\nStep ${stepNumber} failed: ${err.message}`);
+            state = updateAgentStatus(state, step.agent, 'idle');
+            state = setSquadStatus(state, 'idle');
+            writeState(squadDir, state);
+            process.exit(1);
+        }
+        const outputPath = path.join(outputDir, `step-${String(stepNumber).padStart(2, '0')}.md`);
+        fs.writeFileSync(outputPath, output, 'utf-8');
+        const outputLines = output.trim().split('\n').filter(l => l.trim().length > 0);
+        const agentMessage = outputLines[outputLines.length - 1]?.trim() || `Completed ${step.label}`;
+        const agentIdx = state.agents.findIndex(a => a.id === step.agent);
+        state = {
+            ...state,
+            agents: state.agents.map((a, idx) => idx === agentIdx ? { ...a, message: agentMessage } : a),
+        };
+        const nextStep = steps[i + 1];
+        const hasHandoff = nextStep && nextStep.deliverFrom === step.agent;
+        if (hasHandoff) {
+            state = updateAgentStatus(state, step.agent, 'delivering');
+            state = setHandoff(state, step.agent, nextStep.agent, agentMessage);
+            writeState(squadDir, state);
+            console.log(`\nHandoff: ${agent.name} -> ${config.squad.agents.find(a => a.id === nextStep.agent).name}`);
+            console.log(`Message: ${agentMessage}\n`);
+            await delay(HANDOFF_DELAY_MS);
+            state = updateAgentStatus(state, step.agent, 'done');
+            writeState(squadDir, state);
+        }
+        else {
+            state = updateAgentStatus(state, step.agent, 'done');
+            writeState(squadDir, state);
+        }
+        console.log(`\nStep ${stepNumber} completed.\n`);
+    }
+    // Update squad memory after pipeline completion
+    const memoryPath = path.join(squadDir, '_memory', 'memories.md');
+    if (fs.existsSync(path.dirname(memoryPath))) {
+        const timestamp = new Date().toISOString();
+        const entry = `\n## Run ${timestamp}\n\n- Steps completed: ${steps.length}\n- Output: output/v${version}/\n`;
+        fs.appendFileSync(memoryPath, entry, 'utf-8');
+    }
+    state = setSquadStatus(state, 'completed');
+    state = updateStep(state, steps.length, 'Completed');
+    writeState(squadDir, state);
+    console.log(`\nSquad "${config.squad.name}" pipeline completed!`);
+    console.log(`Output files saved to squads/${name}/output/v${version}/`);
+}

package/dist/cli/src/commands/server.d.ts

@@ -0,0 +1 @@
+export declare function serverCommand(): Promise<void>;