@agilemonster/mcp-server 0.0.0-stage → 1.0.1

package/dist/types.d.ts

@@ -0,0 +1,47 @@
+export interface AgileMonsterProjectConfig {
+    workspace_id?: string;
+    board_id?: string;
+    board_name?: string;
+    provider?: string;
+    review_list?: string;
+    done_list?: string;
+    api_key?: string;
+}
+export interface Card {
+    id: string;
+    title: string;
+    description?: string | null;
+    list_id: string;
+    board_id: string;
+    position?: number;
+    due_date?: string | null;
+    agent_provider?: string | null;
+    agent_status?: string | null;
+    agent_run_ref?: string | null;
+    max_budget_usd?: number | null;
+    max_tokens?: number | null;
+    spent_tokens?: number;
+    spent_cost_usd?: number;
+    board_name?: string;
+    list_name?: string;
+    created_by?: string;
+}
+export interface Board {
+    id: string;
+    name: string;
+    description?: string | null;
+    workspace_id: string;
+    workspace_name?: string;
+}
+export interface ColumnList {
+    id: string;
+    name: string;
+    position: number;
+}
+export interface ContextResponse {
+    matched_board: Board | null;
+    available_boards: Board[];
+    lists: ColumnList[];
+    active_agent_tasks: Card[];
+    supported_providers: string[];
+}

package/dist/types.js

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

package/dist/worker.d.ts

@@ -0,0 +1,40 @@
+import { AgileMonsterClient } from './client.js';
+import { Card } from './types.js';
+export interface WorkerOptions {
+    intervalMs?: number;
+    heartbeatMs?: number;
+    provider?: string;
+    boardId?: string;
+    runner?: 'aider' | 'claude' | 'custom' | 'shell' | 'simulated';
+    customCommand?: string;
+    gitBranch?: boolean;
+    maxBudgetUsd?: number;
+    maxTokens?: number;
+    once?: boolean;
+}
+export declare class AgileMonsterWorker {
+    private client;
+    private isRunning;
+    private activeCardId;
+    private heartbeatTimer;
+    constructor(client?: AgileMonsterClient);
+    /**
+     * Run one iteration or continuous daemon loop.
+     */
+    start(options?: WorkerOptions): Promise<void>;
+    /**
+     * Check for queued tasks and process the first available card.
+     */
+    pollAndExecute(options: WorkerOptions): Promise<void>;
+    /**
+     * Execute one assigned task autonomously.
+     */
+    executeTask(task: Card, options: WorkerOptions): Promise<void>;
+    private startHeartbeat;
+    private stopHeartbeat;
+    /**
+     * Run the configured agent execution engine.
+     */
+    private runExecutionEngine;
+    private execCommand;
+}

package/dist/worker.js

@@ -0,0 +1,227 @@
+import { spawn } from 'node:child_process';
+import { AgileMonsterClient } from './client.js';
+export class AgileMonsterWorker {
+    client;
+    isRunning = false;
+    activeCardId = null;
+    heartbeatTimer = null;
+    constructor(client = new AgileMonsterClient()) {
+        this.client = client;
+    }
+    /**
+     * Run one iteration or continuous daemon loop.
+     */
+    async start(options = {}) {
+        const projectConfig = this.client.loadProjectConfig();
+        const provider = options.provider || projectConfig?.provider || 'antigravity';
+        const interval = options.intervalMs || 15000;
+        const runner = options.runner || 'simulated';
+        console.log('\n======================================================');
+        console.log('       👾 AGILE MONSTER AUTONOMOUS AGENT WORKER       ');
+        console.log('======================================================\n');
+        console.log(`🤖 Agent Provider:  ${provider.toUpperCase()}`);
+        console.log(`⚙️  Execution Engine: ${runner}`);
+        console.log(`🛡️  Circuit-Breaker:  Max Budget: $${options.maxBudgetUsd || 5.0}, Max Tokens: ${options.maxTokens || 200000}`);
+        console.log(`⏱️  Polling Interval: ${interval / 1000}s`);
+        console.log(`🔒 Human Gate:       Autonomous tasks are submitted to Review (never self-closed to Done)\n`);
+        this.isRunning = true;
+        const tick = async () => {
+            if (!this.isRunning)
+                return;
+            try {
+                await this.pollAndExecute(options);
+            }
+            catch (err) {
+                console.error(`[Worker Error]: ${err.message || err}`);
+            }
+        };
+        await tick();
+        if (options.once) {
+            return;
+        }
+        const timer = setInterval(tick, interval);
+        process.on('SIGINT', () => {
+            console.log('\n🛑 Stopping Agile Monster Worker daemon...');
+            this.isRunning = false;
+            clearInterval(timer);
+            this.stopHeartbeat();
+            process.exit(0);
+        });
+    }
+    /**
+     * Check for queued tasks and process the first available card.
+     */
+    async pollAndExecute(options) {
+        if (this.activeCardId) {
+            // Already running a task
+            return;
+        }
+        const projectConfig = this.client.loadProjectConfig();
+        const provider = options.provider || projectConfig?.provider || 'antigravity';
+        const boardId = options.boardId || projectConfig?.board_id;
+        const res = await this.client.listAssigned(provider, 'queued', boardId);
+        const tasks = res.cards || [];
+        if (tasks.length === 0) {
+            return;
+        }
+        const task = tasks[0];
+        await this.executeTask(task, options);
+    }
+    /**
+     * Execute one assigned task autonomously.
+     */
+    async executeTask(task, options) {
+        this.activeCardId = task.id;
+        const provider = task.agent_provider || options.provider || 'antigravity';
+        const startTime = Date.now();
+        console.log(`\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        console.log(`🚀 Claiming Task: "${task.title}" (ID: ${task.id})`);
+        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        try {
+            // 1. Claim task on board
+            const runRef = `worker-${process.pid}-${Date.now().toString(36)}`;
+            await this.client.claimTask(task.id, provider, runRef);
+            // 2. Configure circuit breaker budget on card if specified
+            if (options.maxBudgetUsd || options.maxTokens) {
+                await this.client.setBudget(task.id, options.maxBudgetUsd, options.maxTokens);
+            }
+            // 3. Optional Git Branch isolation
+            let previousBranch = '';
+            const branchName = `agilemonster/task-${task.id.slice(0, 8)}`;
+            if (options.gitBranch !== false) {
+                try {
+                    previousBranch = await this.execCommand('git', ['rev-parse', '--abbrev-ref', 'HEAD']);
+                    previousBranch = previousBranch.trim();
+                    await this.execCommand('git', ['checkout', '-B', branchName]);
+                    console.log(`🌿 Switched to isolated git branch: ${branchName}`);
+                }
+                catch (e) {
+                    console.warn(`Git branch switch warning: ${e.message}`);
+                }
+            }
+            // 4. Start progress heartbeat
+            await this.client.addProgress(task.id, provider, `🚀 Autonomous agent worker started on host. Created isolated branch \`${branchName}\`. Beginning execution.`);
+            this.startHeartbeat(task.id, provider, options.heartbeatMs || 30000);
+            // 5. Execute runner engine
+            console.log(`⚡ Dispatching task to runner: ${options.runner || 'simulated'}`);
+            const executionResult = await this.runExecutionEngine(task, options);
+            this.stopHeartbeat();
+            // 6. Inspect git diff and test output
+            let gitDiffSummary = '';
+            try {
+                const diffStat = await this.execCommand('git', ['diff', '--stat']);
+                gitDiffSummary = diffStat.trim();
+            }
+            catch { }
+            const durationSec = Math.round((Date.now() - startTime) / 1000);
+            const summary = executionResult.summary ||
+                `Autonomous implementation finished in ${durationSec}s.\n\n### Changed Files\n${gitDiffSummary || 'Code modifications applied.'}`;
+            const verificationInstructions = executionResult.verificationSteps ||
+                `1. Review git branch: \`git checkout ${branchName}\`\n2. Run automated test suite: \`npm test\` or \`flutter test\`\n3. Verify implementation matches acceptance criteria.`;
+            // 7. Enforce Human Verification Gate: Submit for Review
+            console.log(`\n📋 Submitting task for Human Verification & Testing...`);
+            await this.client.submitReview(task.id, provider, summary, verificationInstructions);
+            console.log(`✅ Task "${task.title}" successfully moved to Review/Testing list!`);
+            console.log(`   Reassigned to human requester with verification steps.\n`);
+        }
+        catch (err) {
+            console.error(`❌ Autonomous Worker failed on task ${task.id}:`, err.message || err);
+            try {
+                await this.client.addProgress(task.id, provider, `⚠️ Autonomous worker encountered an error: ${err.message || err}`);
+            }
+            catch { }
+        }
+        finally {
+            this.stopHeartbeat();
+            this.activeCardId = null;
+        }
+    }
+    startHeartbeat(cardId, provider, intervalMs) {
+        let tickCount = 0;
+        this.heartbeatTimer = setInterval(async () => {
+            tickCount++;
+            const elapsedMins = Math.round((tickCount * intervalMs) / 60000);
+            try {
+                await this.client.addProgress(cardId, provider, `💓 [Worker Heartbeat] Task running autonomously (~${elapsedMins || 1} min elapsed)...`);
+            }
+            catch (e) {
+                console.warn(`Heartbeat update error: ${e.message}`);
+            }
+        }, intervalMs);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    /**
+     * Run the configured agent execution engine.
+     */
+    async runExecutionEngine(task, options) {
+        const runner = options.runner || 'simulated';
+        switch (runner) {
+            case 'aider': {
+                const msg = `Implement task: ${task.title}\n\n${task.description || ''}`;
+                await this.execCommand('aider', ['--yes', '--message', msg]);
+                return {
+                    summary: `Implemented via headless Aider: ${task.title}`,
+                };
+            }
+            case 'claude': {
+                const prompt = `Implement task: ${task.title}\n\n${task.description || ''}`;
+                await this.execCommand('claude', ['-p', prompt]);
+                return {
+                    summary: `Implemented via Claude Code headless CLI: ${task.title}`,
+                };
+            }
+            case 'shell':
+            case 'custom': {
+                if (!options.customCommand) {
+                    throw new Error('customCommand must be specified when using shell/custom runner');
+                }
+                const [cmd, ...cmdArgs] = options.customCommand.split(' ');
+                await this.execCommand(cmd, cmdArgs);
+                return {
+                    summary: `Executed custom command: ${options.customCommand}`,
+                };
+            }
+            case 'simulated':
+            default: {
+                // Safe simulated execution for testing worker daemon lifecycle
+                console.log(`   [Simulated Runner] Analyzing task requirements...`);
+                await new Promise((r) => setTimeout(r, 2000));
+                console.log(`   [Simulated Runner] Applying code modifications...`);
+                await new Promise((r) => setTimeout(r, 2000));
+                return {
+                    summary: `Automated agent pass completed for "${task.title}".\nAll requirements processed.`,
+                    verificationSteps: `1. Run project test suite.\n2. Confirm acceptance criteria for "${task.title}".\n3. Mark Done once verified.`,
+                };
+            }
+        }
+    }
+    execCommand(command, args) {
+        return new Promise((resolve, reject) => {
+            const proc = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout.on('data', (d) => {
+                stdout += d.toString();
+            });
+            proc.stderr.on('data', (d) => {
+                stderr += d.toString();
+            });
+            proc.on('close', (code) => {
+                if (code === 0) {
+                    resolve(stdout);
+                }
+                else {
+                    reject(new Error(`Command "${command} ${args.join(' ')}" failed with code ${code}: ${stderr || stdout}`));
+                }
+            });
+            proc.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+}

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "@agilemonster/mcp-server",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "type": "module",
+  "description": "Official Model Context Protocol (MCP) server & Orchestrator for Agile Monster (Cursor, Claude Code, Antigravity, Codex, Hermes, Windsurf)",
+  "main": "dist/server.js",
+  "types": "dist/server.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "agilemonster": "bin/mcp.js",
+    "agilemonster-mcp": "bin/mcp.js",
+    "agilemonster-orchestrator": "bin/orchestrator.js",
+    "agilemonster-worker": "bin/worker.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "start": "node bin/mcp.js",
+    "orchestrator": "node bin/orchestrator.js",
+    "worker": "node bin/worker.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "agilemonster",
+    "ai-agent",
+    "cursor",
+    "claude-code",
+    "antigravity",
+    "codex",
+    "hermes-agent"
+  ],
+  "author": "Agile Monster",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.6.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.0",
+    "typescript": "^5.7.0"
+  }
+}