expxagents 0.5.0 → 0.7.0

package/dist/__tests__/cli.test.d.ts

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

package/dist/__tests__/cli.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { execSync } from 'child_process';
+import path from 'path';
+describe('CLI', () => {
+    const cliPath = path.resolve(__dirname, '../../bin/expxagents.js');
+    it('shows help output with all commands', () => {
+        execSync('npm run build', { cwd: path.resolve(__dirname, '../..') });
+        const output = execSync(`node ${cliPath} --help`, { encoding: 'utf-8' });
+        expect(output).toContain('expxagents');
+        expect(output).toContain('init');
+        expect(output).toContain('create');
+        expect(output).toContain('run');
+        expect(output).toContain('stop');
+        expect(output).toContain('list');
+        expect(output).toContain('install');
+        expect(output).toContain('uninstall');
+        expect(output).toContain('server');
+    });
+    it('shows version', () => {
+        const output = execSync(`node ${cliPath} --version`, { encoding: 'utf-8' });
+        expect(output.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+    });
+});

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

@@ -139,10 +139,20 @@ Present using AskUserQuestion with 2-4 options:
 | \`/expxagents install <name>\` | Install skill from catalog |
 | \`/expxagents uninstall <name>\` | Remove installed skill |
 | \`/expxagents delete <name>\` | Confirm and delete squad |
-| \`/expxagents dashboard\` | Start server + open dashboard |
-| \`/expxagents virtual-office\` | Start server + open virtual office in browser |
+| \`/expxagents dashboard\` | Run CLI to start server + open dashboard |
+| \`/expxagents virtual-office\` | Run CLI to start server + open virtual office in browser |
 | \`/expxagents help\` | Show help text |
 
+## Virtual Office / Dashboard
+
+When the user requests \`/expxagents virtual-office\` or \`/expxagents dashboard\`:
+
+1. **ALWAYS run the CLI command** — do NOT generate HTML files or static pages
+2. Execute: \`npx expxagents virtual-office\` via the Bash tool
+3. This starts the Fastify server with the Pixi.js animated office dashboard and opens the browser
+4. The server runs on port 3001 (or PORT env var) and serves the React SPA with WebSocket support
+5. NEVER create static HTML files for the virtual office — the office is a full server-side application
+
 ## Loading Agents
 
 When a core agent needs to be activated:

package/dist/cli/src/commands/virtual-office.js

@@ -1,5 +1,33 @@
 import { spawn, execSync } from 'child_process';
+import fs from 'fs';
 import path from 'path';
+import { findPackageRoot } from '../utils/config.js';
+/**
+ * Resolve the server entry point and dashboard dist directory.
+ * Prefers bundled server from the npm package; falls back to monorepo paths.
+ */
+function resolveServerPaths() {
+    // 1. Bundled package paths (npm / npx usage)
+    const pkgRoot = findPackageRoot();
+    const bundledServer = path.join(pkgRoot, 'dist', 'server', 'index.js');
+    const bundledDashboard = path.join(pkgRoot, 'dist', 'dashboard');
+    if (fs.existsSync(bundledServer) && fs.existsSync(bundledDashboard)) {
+        return {
+            serverEntry: bundledServer,
+            dashboardDist: bundledDashboard,
+            cwd: pkgRoot,
+        };
+    }
+    // 2. Monorepo development fallback
+    const projectRoot = process.cwd();
+    const monoServer = path.join(projectRoot, 'server', 'dist', 'index.js');
+    const monoDashboard = path.join(projectRoot, 'dashboard', 'dist');
+    return {
+        serverEntry: monoServer,
+        dashboardDist: monoDashboard,
+        cwd: path.join(projectRoot, 'server'),
+    };
+}
 export async function virtualOfficeCommand() {
     const port = process.env.PORT ?? '3001';
     const url = `http://localhost:${port}/office`;
@@ -13,13 +41,22 @@ export async function virtualOfficeCommand() {
         serverRunning = false;
     }
     if (!serverRunning) {
+        const { serverEntry, dashboardDist, cwd } = resolveServerPaths();
+        if (!fs.existsSync(serverEntry)) {
+            console.error(`Server not found at ${serverEntry}`);
+            console.error('Run "npm run build" first, or install the latest expxagents package.');
+            process.exit(1);
+        }
         console.log('Starting ExpxAgents server...');
-        const cwd = process.cwd();
-        const serverDir = path.join(cwd, 'server');
-        const child = spawn('node', ['dist/index.js'], {
-            cwd: serverDir,
+        const child = spawn('node', [serverEntry], {
+            cwd,
             stdio: 'inherit',
-            env: { ...process.env },
+            env: {
+                ...process.env,
+                NODE_ENV: 'production',
+                DASHBOARD_DIST: dashboardDist,
+                PORT: port,
+            },
             detached: true,
         });
         child.on('error', (err) => {

package/dist/cli/src/utils/config.d.ts

@@ -13,6 +13,11 @@ export declare function resolveConfig(): CliConfig;
  * Check if current directory is an initialized ExpxAgents project.
  */
 export declare function isInitialized(): boolean;
+/**
+ * Find the package root by walking up from the compiled file's location
+ * until we find a package.json. Works regardless of dist/ nesting depth.
+ */
+export declare function findPackageRoot(): string;
 /**
  * Get the directory where package assets are stored.
  * Resolves to <package-root>/assets/ regardless of compiled file nesting.

package/dist/cli/src/utils/config.js

@@ -26,7 +26,7 @@ export function isInitialized() {
  * Find the package root by walking up from the compiled file's location
  * until we find a package.json. Works regardless of dist/ nesting depth.
  */
-function findPackageRoot() {
+export function findPackageRoot() {
     let dir = path.dirname(fileURLToPath(import.meta.url));
     while (dir !== path.dirname(dir)) {
         if (fs.existsSync(path.join(dir, 'package.json')))

package/dist/commands/create.d.ts

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

package/dist/commands/create.js

@@ -0,0 +1,34 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+export async function createCommand() {
+    const cwd = process.cwd();
+    const architectPrompt = path.join(cwd, 'core', 'architect.md');
+    if (!fs.existsSync(architectPrompt)) {
+        console.error('Architect prompt not found. Run `expxagents init` first.');
+        process.exit(1);
+    }
+    const prompt = fs.readFileSync(architectPrompt, 'utf-8');
+    const squadsDir = path.join(cwd, 'squads');
+    if (!fs.existsSync(squadsDir)) {
+        fs.mkdirSync(squadsDir, { recursive: true });
+    }
+    console.log('Starting Architect agent to design your squad...\n');
+    const child = spawn('claude', ['-p', prompt], {
+        cwd: squadsDir,
+        stdio: 'inherit',
+    });
+    child.on('error', (err) => {
+        console.error(`Failed to start Claude Code: ${err.message}`);
+        console.error('Make sure Claude Code CLI is installed.');
+        process.exit(1);
+    });
+    child.on('exit', (code) => {
+        if (code === 0) {
+            console.log('\nSquad created successfully! Run `expxagents list` to see it.');
+        }
+        else {
+            console.error(`\nArchitect exited with code ${code}`);
+        }
+    });
+}

package/dist/commands/init.d.ts

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

package/dist/commands/init.js

@@ -0,0 +1,58 @@
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+export async function initCommand() {
+    const cwd = process.cwd();
+    console.log('Initializing ExpxAgents project...\n');
+    // Create directories
+    const dirs = ['squads', 'skills', 'templates'];
+    for (const dir of dirs) {
+        const dirPath = path.join(cwd, dir);
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+            console.log(`  Created ${dir}/`);
+        }
+        else {
+            console.log(`  ${dir}/ already exists`);
+        }
+    }
+    // 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 server` to start.');
+}

package/dist/commands/install.d.ts

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

package/dist/commands/install.js

@@ -0,0 +1,16 @@
+import fs from 'fs';
+import path from 'path';
+export async function installCommand(skill) {
+    const cwd = process.cwd();
+    const skillsDir = path.join(cwd, 'skills');
+    if (!fs.existsSync(skillsDir)) {
+        fs.mkdirSync(skillsDir, { recursive: true });
+    }
+    const skillDir = path.join(skillsDir, skill);
+    if (fs.existsSync(skillDir)) {
+        console.log(`Skill "${skill}" is already installed.`);
+        return;
+    }
+    console.log(`Installing skill "${skill}"...`);
+    console.log('Skill registry not yet implemented. Place skill files manually in skills/ directory.');
+}

package/dist/commands/list.d.ts

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

package/dist/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/commands/run.d.ts

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

package/dist/commands/run.js

@@ -0,0 +1,173 @@
+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';
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function buildAgentPrompt(config, step, stepIndex, squadDir, skills, runnerPrompt) {
+    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, '');
+    }
+    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');
+    const coreDir = path.join(cwd, 'core');
+    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 = path.join(coreDir, 'runner.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 = path.join(squadDir, 'output');
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    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`);
+    }
+    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/`);
+}

package/dist/commands/server.d.ts

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

package/dist/commands/server.js

@@ -0,0 +1,22 @@
+import { spawn } from 'child_process';
+import path from 'path';
+export async function serverCommand() {
+    const cwd = process.cwd();
+    const serverDir = path.join(cwd, 'server');
+    console.log('Starting ExpxAgents server...');
+    const child = spawn('node', ['dist/index.js'], {
+        cwd: serverDir,
+        stdio: 'inherit',
+        env: { ...process.env },
+    });
+    child.on('error', (err) => {
+        console.error(`Failed to start server: ${err.message}`);
+        console.error('Make sure you have built the server: cd server && npm run build');
+        process.exit(1);
+    });
+    child.on('exit', (code) => {
+        process.exit(code ?? 0);
+    });
+    process.on('SIGINT', () => child.kill('SIGINT'));
+    process.on('SIGTERM', () => child.kill('SIGTERM'));
+}

package/dist/commands/stop.d.ts

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

package/dist/commands/stop.js

@@ -0,0 +1,23 @@
+import fs from 'fs';
+import path from 'path';
+import { readState, writeState, setSquadStatus } from '../../../core/state-manager.js';
+export async function stopCommand(name) {
+    const cwd = process.cwd();
+    const squadDir = path.join(cwd, 'squads', name);
+    if (!fs.existsSync(squadDir)) {
+        console.error(`Squad "${name}" not found.`);
+        process.exit(1);
+    }
+    const state = readState(squadDir);
+    if (!state) {
+        console.log(`Squad "${name}" is not running (no state.json).`);
+        return;
+    }
+    if (state.status === 'idle' || state.status === 'completed') {
+        console.log(`Squad "${name}" is already ${state.status}.`);
+        return;
+    }
+    const updated = setSquadStatus(state, 'idle');
+    writeState(squadDir, updated);
+    console.log(`Squad "${name}" stopped.`);
+}

package/dist/commands/uninstall.d.ts

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

package/dist/commands/uninstall.js

@@ -0,0 +1,12 @@
+import fs from 'fs';
+import path from 'path';
+export async function uninstallCommand(skill) {
+    const cwd = process.cwd();
+    const skillDir = path.join(cwd, 'skills', skill);
+    if (!fs.existsSync(skillDir)) {
+        console.error(`Skill "${skill}" is not installed.`);
+        process.exit(1);
+    }
+    fs.rmSync(skillDir, { recursive: true, force: true });
+    console.log(`Skill "${skill}" uninstalled.`);
+}