@agilemonster/mcp-server 1.0.8 → 1.0.10

package/bin/mcp.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { runStdioServer } from '../dist/server.js';
+import { runStdioServer, runBackgroundPulseDaemon } from '../dist/server.js';
 import { MCP_SERVER_VERSION } from '../dist/client.js';
 
 const cliCommands = new Set([
@@ -23,6 +23,11 @@ const firstArg = process.argv[2];
 if (firstArg === '--version' || firstArg === '-v' || firstArg === 'version') {
   console.log(MCP_SERVER_VERSION);
   process.exit(0);
+} else if (firstArg === 'pulse-daemon' || firstArg === '--pulse-daemon') {
+  runBackgroundPulseDaemon(20000).catch((err) => {
+    console.error('Fatal Pulse Daemon Error:', err);
+    process.exit(1);
+  });
 } else if (firstArg && cliCommands.has(firstArg)) {
   // Delegate to orchestrator CLI
   await import('./orchestrator.js');

package/dist/client.d.ts

@@ -1,5 +1,5 @@
-import { AgileMonsterProjectConfig, Board, BoardAgentConfig, Card, ContextResponse, DiscoveredProject, PulseResponse } from './types.js';
-export declare const MCP_SERVER_VERSION = "1.0.8";
+import { AgileMonsterProjectConfig, AutonomousStepResponse, Board, BoardAgentConfig, Card, ContextResponse, DiscoveredProject, PulseResponse } from './types.js';
+export declare const MCP_SERVER_VERSION = "1.0.10";
 export declare class AgileMonsterClient {
     private apiKey;
     private baseUrl;
@@ -62,4 +62,10 @@ export declare class AgileMonsterClient {
     }>): Promise<{
         tasks: Card[];
     }>;
+    autonomousStep(payload: {
+        card_id: string;
+        action: 'select_files' | 'generate_edits';
+        file_index?: string[];
+        files?: Record<string, string>;
+    }): Promise<AutonomousStepResponse>;
 }

package/dist/client.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execSync } from 'node:child_process';
-export const MCP_SERVER_VERSION = '1.0.8';
+export const MCP_SERVER_VERSION = '1.0.10';
 export class AgileMonsterClient {
     apiKey = '';
     baseUrl;
@@ -376,4 +376,10 @@ export class AgileMonsterClient {
             body: JSON.stringify({ provider, tasks }),
         });
     }
+    async autonomousStep(payload) {
+        return this.request('/api/agent/autonomous-step', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
 }

package/dist/server.d.ts

@@ -1,5 +1,6 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { AgileMonsterClient } from './client.js';
+import { Card } from './types.js';
 export declare function createServer(client?: AgileMonsterClient): Server<{
     method: string;
     params?: {
@@ -34,5 +35,7 @@ export declare function createServer(client?: AgileMonsterClient): Server<{
         } | undefined;
     } | undefined;
 }>;
-export declare function startBuiltInPullPulse(server: Server, client: AgileMonsterClient, intervalMs?: number): NodeJS.Timeout;
+export declare function executeQueuedCardAutonomously(client: AgileMonsterClient, card: Card, projectPath: string): Promise<boolean>;
+export declare function startBuiltInPullPulse(server: Server | null, client: AgileMonsterClient, intervalMs?: number): NodeJS.Timeout;
 export declare function runStdioServer(): Promise<void>;
+export declare function runBackgroundPulseDaemon(intervalMs?: number): Promise<void>;

package/dist/server.js

@@ -786,6 +786,214 @@ function triggerBackgroundSelfUpdate() {
     }
     catch { }
 }
+const activeAutonomousCards = new Set();
+function collectProjectSourceFiles(projectPath, keywords) {
+    const skipDirs = new Set([
+        'node_modules',
+        '.git',
+        'dist',
+        'build',
+        '.next',
+        '.nuxt',
+        '.dart_tool',
+        'vendor',
+        'coverage',
+        'ios',
+        'android',
+        'macos',
+        'linux',
+        'windows',
+        'web',
+        'public',
+        'assets',
+        'archive',
+        'backups',
+    ]);
+    const validExts = new Set(['.tsx', '.ts', '.jsx', '.js', '.dart', '.php', '.py', '.css', '.scss', '.html', '.vue']);
+    const results = [];
+    const walk = (dir, depth) => {
+        if (depth > 6 || results.length > 600)
+            return;
+        let entries = [];
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const name = entry.name;
+            if (name.startsWith('.'))
+                continue;
+            if (/backup|copy|\s\d+/i.test(name))
+                continue;
+            const full = path.join(dir, name);
+            if (entry.isDirectory()) {
+                if (skipDirs.has(name.toLowerCase()))
+                    continue;
+                walk(full, depth + 1);
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(name).toLowerCase();
+                if (!validExts.has(ext))
+                    continue;
+                if (/\.(test|spec|min|d)\./i.test(name))
+                    continue;
+                const rel = path.relative(projectPath, full).replace(/\\/g, '/');
+                const lowerRel = rel.toLowerCase();
+                let score = 0;
+                for (const kw of keywords) {
+                    if (kw.length >= 3 && lowerRel.includes(kw)) {
+                        score += 25;
+                    }
+                }
+                // Check file content for keyword hits on promising source files
+                if (ext === '.tsx' || ext === '.ts' || ext === '.dart' || ext === '.php' || ext === '.jsx') {
+                    try {
+                        const stat = fs.statSync(full);
+                        if (stat.size < 120000) {
+                            const contentLower = fs.readFileSync(full, 'utf8').toLowerCase();
+                            for (const kw of keywords) {
+                                if (kw.length >= 4 && contentLower.includes(kw)) {
+                                    score += 10;
+                                }
+                            }
+                        }
+                    }
+                    catch { }
+                }
+                // Bonus score for UI components / screens when task mentions UX or UI
+                if (ext === '.tsx' || ext === '.jsx' || ext === '.dart' || ext === '.vue') {
+                    if (lowerRel.includes('component') || lowerRel.includes('screen') || lowerRel.includes('widget') || lowerRel.includes('modal')) {
+                        score += 8;
+                    }
+                }
+                results.push({ rel, score });
+            }
+        }
+    };
+    walk(projectPath, 0);
+    results.sort((a, b) => b.score - a.score || a.rel.localeCompare(b.rel));
+    return results.slice(0, 220).map((r) => r.rel);
+}
+export async function executeQueuedCardAutonomously(client, card, projectPath) {
+    if (!projectPath || !fs.existsSync(projectPath))
+        return false;
+    if (activeAutonomousCards.has(card.id))
+        return false;
+    const lockFile = path.join(projectPath, `.agilemonster-task-${card.id.slice(0, 8)}.lock`);
+    try {
+        if (fs.existsSync(lockFile)) {
+            const stat = fs.statSync(lockFile);
+            if (Date.now() - stat.mtimeMs < 10 * 60 * 1000) {
+                return false; // Already running or recently processed
+            }
+        }
+        fs.writeFileSync(lockFile, JSON.stringify({ card_id: card.id, started_at: new Date().toISOString() }), 'utf8');
+    }
+    catch {
+        return false;
+    }
+    activeAutonomousCards.add(card.id);
+    const provider = card.agent_provider || 'cursor';
+    const workerLabel = card.agent_display_name || provider;
+    try {
+        // 1. Claim the card (automatically moves it from ToDo -> In Progress on the board!)
+        await client.claimTask(card.id, provider, `auto-pulse-${Date.now()}`, card.board_id);
+        sendDesktopNotification(`Agile Monster -> ${workerLabel}`, `Claimed & moved to In Progress: "${card.title}"`);
+        await client.addProgress(card.id, provider, `Autonomous background runner claimed task in \`${projectPath}\` and moved card to **In Progress**. Scanning repository files...`);
+        // 2. Build keyword list from card title + description and collect project source files
+        const rawText = `${card.title || ''} ${card.description || ''}`.toLowerCase();
+        const stopWords = new Set(['the', 'and', 'for', 'with', 'that', 'this', 'from', 'need', 'make', 'user', 'use', 'into', 'when', 'through']);
+        const keywords = Array.from(new Set(rawText
+            .split(/[^a-z0-9]+/)
+            .filter((w) => w.length >= 3 && !stopWords.has(w))));
+        const fileIndex = collectProjectSourceFiles(projectPath, keywords);
+        if (fileIndex.length === 0) {
+            await client.addProgress(card.id, provider, `Card is now **In Progress**, but no matching source files were found in \`${projectPath}\`.`);
+            return false;
+        }
+        // 3. Ask Agile Monster Autonomous Step to pick the 1-4 most relevant files
+        const selectionRes = await client.autonomousStep({
+            card_id: card.id,
+            action: 'select_files',
+            file_index: fileIndex,
+        });
+        const selectedFiles = (selectionRes.target_files || selectionRes.selected_files || []).slice(0, 4);
+        if (selectedFiles.length === 0) {
+            selectedFiles.push(...fileIndex.slice(0, 3));
+        }
+        const filesPayload = {};
+        for (const rel of selectedFiles) {
+            const full = path.join(projectPath, rel);
+            if (fs.existsSync(full)) {
+                try {
+                    filesPayload[rel] = fs.readFileSync(full, 'utf8');
+                }
+                catch { }
+            }
+        }
+        if (Object.keys(filesPayload).length === 0) {
+            return false;
+        }
+        await client.addProgress(card.id, provider, `Selected target files for implementation: ${Object.keys(filesPayload)
+            .map((f) => `\`${f}\``)
+            .join(', ')}. Generating code changes...`);
+        // 4. Generate surgical code edits
+        const editsRes = await client.autonomousStep({
+            card_id: card.id,
+            action: 'generate_edits',
+            files: filesPayload,
+        });
+        const edits = editsRes.edits || [];
+        const modifiedFiles = [];
+        for (const edit of edits) {
+            const relPath = edit.file || edit.path;
+            if (!relPath || !edit.search || typeof edit.replace !== 'string')
+                continue;
+            const fullPath = path.resolve(projectPath, relPath);
+            if (!fullPath.startsWith(path.resolve(projectPath)))
+                continue;
+            if (!fs.existsSync(fullPath))
+                continue;
+            const currentContent = fs.readFileSync(fullPath, 'utf8');
+            if (currentContent.includes(edit.search)) {
+                const updatedContent = currentContent.replace(edit.search, edit.replace);
+                if (updatedContent !== currentContent) {
+                    fs.writeFileSync(fullPath, updatedContent, 'utf8');
+                    if (!modifiedFiles.includes(relPath)) {
+                        modifiedFiles.push(relPath);
+                    }
+                }
+            }
+        }
+        if (modifiedFiles.length > 0) {
+            const summary = editsRes.summary ||
+                `Implemented "${card.title}" autonomously across ${modifiedFiles.map((f) => `\`${f}\``).join(', ')}.`;
+            const verificationSteps = editsRes.verification_steps ||
+                `1. Open ${projectPath} and inspect changes in ${modifiedFiles.join(', ')}\n2. Run the app and verify "${card.title}".`;
+            await client.submitReview(card.id, provider, summary, verificationSteps);
+            sendDesktopNotification(`Agile Monster -> Ready for Review`, `Completed "${card.title}" (${modifiedFiles.length} file(s) updated) and moved to Testing / Review!`);
+            return true;
+        }
+        else {
+            await client.addProgress(card.id, provider, `Task claimed and moved to **In Progress**. Inspected ${Object.keys(filesPayload)
+                .map((f) => `\`${f}\``)
+                .join(', ')}. Ready for final IDE review.`);
+            return false;
+        }
+    }
+    catch (err) {
+        try {
+            await client.addProgress(card.id, provider, `Autonomous runner note: ${err?.message || String(err)}`);
+        }
+        catch { }
+        return false;
+    }
+    finally {
+        activeAutonomousCards.delete(card.id);
+    }
+}
 export function startBuiltInPullPulse(server, client, intervalMs = 20000) {
     const notifiedCardIds = new Set();
     let updateTriggered = false;
@@ -874,11 +1082,22 @@ export function startBuiltInPullPulse(server, client, intervalMs = 20000) {
                     const modelTag = card.agent_model && card.agent_model !== 'auto' ? ` [${card.agent_model}]` : '';
                     sendDesktopNotification(`Agile Monster -> ${worker}${modelTag}`, `New task queued on ${config.board_name || 'Board'}: "${card.title}"`);
                     try {
-                        await server.sendResourceUpdated({ uri: 'agilemonster://project/context' });
+                        if (server) {
+                            await server.sendResourceUpdated({ uri: 'agilemonster://project/context' });
+                        }
                     }
                     catch { }
                 }
             }
+            // Zero-touch autonomous execution for any queued cards bound to local folders on this machine
+            const boundQueued = res.all_bound_queued_cards || [];
+            for (const qCard of boundQueued) {
+                const targetPath = (qCard.bound_project_path || '').trim() ||
+                    (qCard.board_id === config.board_id ? config.project_path || process.cwd() : '');
+                if (targetPath && fs.existsSync(targetPath)) {
+                    await executeQueuedCardAutonomously(client, qCard, targetPath);
+                }
+            }
             if ((res.version?.force_update_requested || res.version?.update_available) &&
                 !updateTriggered) {
                 updateTriggered = true;
@@ -901,3 +1120,10 @@ export async function runStdioServer() {
     await server.connect(transport);
     startBuiltInPullPulse(server, client, 20000);
 }
+export async function runBackgroundPulseDaemon(intervalMs = 20000) {
+    const client = new AgileMonsterClient();
+    console.log(`[Agile Monster Pulse Daemon v${MCP_SERVER_VERSION}] Listening for queued agent tasks across all bound repositories (interval: ${intervalMs / 1000}s)...`);
+    startBuiltInPullPulse(null, client, intervalMs);
+    // Keep process alive
+    setInterval(() => { }, 60000);
+}

package/dist/types.d.ts

@@ -30,6 +30,8 @@ export interface Card {
     board_name?: string;
     list_name?: string;
     created_by?: string;
+    bound_project_path?: string | null;
+    bound_project_name?: string | null;
 }
 export interface Board {
     id: string;
@@ -85,6 +87,7 @@ export interface PulseResponse {
     pulsed_at: string;
     queued_cards: Card[];
     in_progress_cards: Card[];
+    all_bound_queued_cards?: Card[];
     version: PulseVersionInfo;
     saved_bindings?: Array<{
         board_id: string;
@@ -95,6 +98,22 @@ export interface PulseResponse {
         project_path?: string | null;
     }>;
 }
+export interface AutonomousEdit {
+    path?: string;
+    file?: string;
+    search: string;
+    replace: string;
+    explanation?: string;
+}
+export interface AutonomousStepResponse {
+    card_id: string;
+    action?: 'select_files' | 'generate_edits';
+    selected_files?: string[];
+    target_files?: string[];
+    edits?: AutonomousEdit[];
+    summary?: string;
+    verification_steps?: string;
+}
 export interface ContextResponse {
     matched_board: Board | null;
     ai_match?: AiBoardMatch | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilemonster/mcp-server",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "type": "module",
   "description": "Official Model Context Protocol (MCP) server & Orchestrator for Agile Monster (Cursor, Claude Code, Antigravity, Codex, Hermes, Windsurf)",
   "main": "dist/server.js",