@agilemonster/mcp-server 1.0.10 → 1.0.12

package/dist/client.d.ts

@@ -1,5 +1,5 @@
 import { AgileMonsterProjectConfig, AutonomousStepResponse, Board, BoardAgentConfig, Card, ContextResponse, DiscoveredProject, PulseResponse } from './types.js';
-export declare const MCP_SERVER_VERSION = "1.0.10";
+export declare const MCP_SERVER_VERSION = "1.0.12";
 export declare class AgileMonsterClient {
     private apiKey;
     private baseUrl;

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.10';
+export const MCP_SERVER_VERSION = '1.0.12';
 export class AgileMonsterClient {
     apiKey = '';
     baseUrl;

package/dist/server.d.ts

@@ -36,6 +36,7 @@ export declare function createServer(client?: AgileMonsterClient): Server<{
     } | undefined;
 }>;
 export declare function executeQueuedCardAutonomously(client: AgileMonsterClient, card: Card, projectPath: string): Promise<boolean>;
+export declare function deployApprovedCardIfNeeded(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

@@ -3,7 +3,8 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import path from 'node:path';
 import fs from 'node:fs';
-import { spawn } from 'node:child_process';
+import os from 'node:os';
+import { spawn, execSync } from 'node:child_process';
 import { AgileMonsterClient, MCP_SERVER_VERSION } from './client.js';
 import { AGENT_GUIDELINES_MARKDOWN } from './guidelines.js';
 export function createServer(client = new AgileMonsterClient()) {
@@ -862,26 +863,41 @@ function collectProjectSourceFiles(projectPath, keywords) {
                     }
                     catch { }
                 }
-                // Bonus score for UI components / screens when task mentions UX or UI
+                // Bonus score for UI components / screens AND backend controllers / models
                 if (ext === '.tsx' || ext === '.jsx' || ext === '.dart' || ext === '.vue') {
-                    if (lowerRel.includes('component') || lowerRel.includes('screen') || lowerRel.includes('widget') || lowerRel.includes('modal')) {
+                    if (lowerRel.includes('component') || lowerRel.includes('screen') || lowerRel.includes('widget') || lowerRel.includes('modal') || lowerRel.includes('model')) {
                         score += 8;
                     }
                 }
+                if (ext === '.php' || ext === '.py' || ext === '.ts') {
+                    if (lowerRel.includes('controller') || lowerRel.includes('service') || lowerRel.includes('route')) {
+                        score += 10;
+                    }
+                }
                 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);
+    return results.slice(0, 250).map((r) => r.rel);
+}
+function getAgileMonsterLocksDir() {
+    const dir = path.join(os.homedir(), '.agilemonster', 'locks');
+    try {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    catch { }
+    return dir;
 }
 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`);
+    const lockFile = path.join(getAgileMonsterLocksDir(), `task-${card.id.slice(0, 8)}.lock`);
     try {
         if (fs.existsSync(lockFile)) {
             const stat = fs.statSync(lockFile);
@@ -947,6 +963,7 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
         });
         const edits = editsRes.edits || [];
         const modifiedFiles = [];
+        const originalContents = new Map();
         for (const edit of edits) {
             const relPath = edit.file || edit.path;
             if (!relPath || !edit.search || typeof edit.replace !== 'string')
@@ -957,10 +974,40 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
             if (!fs.existsSync(fullPath))
                 continue;
             const currentContent = fs.readFileSync(fullPath, 'utf8');
+            if (!originalContents.has(fullPath)) {
+                originalContents.set(fullPath, currentContent);
+            }
             if (currentContent.includes(edit.search)) {
                 const updatedContent = currentContent.replace(edit.search, edit.replace);
                 if (updatedContent !== currentContent) {
+                    // Guard against unbalanced braces/parens/brackets introduced by partial block replacement
+                    const countChar = (s, ch) => s.split(ch).length - 1;
+                    const searchBraceDelta = countChar(edit.search, '{') - countChar(edit.search, '}');
+                    const replaceBraceDelta = countChar(edit.replace, '{') - countChar(edit.replace, '}');
+                    const searchParenDelta = countChar(edit.search, '(') - countChar(edit.search, ')');
+                    const replaceParenDelta = countChar(edit.replace, '(') - countChar(edit.replace, ')');
+                    if (searchBraceDelta !== replaceBraceDelta || searchParenDelta !== replaceParenDelta) {
+                        continue;
+                    }
                     fs.writeFileSync(fullPath, updatedContent, 'utf8');
+                    // Pre-submit static analysis gate for Dart/Flutter files
+                    if (relPath.endsWith('.dart')) {
+                        try {
+                            execSync(`dart analyze "${fullPath}"`, {
+                                cwd: projectPath,
+                                stdio: ['ignore', 'pipe', 'pipe'],
+                                timeout: 25000,
+                            });
+                        }
+                        catch (analyzeErr) {
+                            const out = String(analyzeErr?.stdout || '') + String(analyzeErr?.stderr || '');
+                            if (/\berror\s+[•-]/i.test(out)) {
+                                // Revert broken Dart edit so it never breaks the build
+                                fs.writeFileSync(fullPath, currentContent, 'utf8');
+                                continue;
+                            }
+                        }
+                    }
                     if (!modifiedFiles.includes(relPath)) {
                         modifiedFiles.push(relPath);
                     }
@@ -968,10 +1015,25 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
             }
         }
         if (modifiedFiles.length > 0) {
-            const summary = editsRes.summary ||
+            let diffSnippet = '';
+            try {
+                const quotedFiles = modifiedFiles.map((f) => `"${f.replace(/"/g, '\\"')}"`).join(' ');
+                const rawDiff = execSync(`git diff -- ${quotedFiles}`, {
+                    cwd: projectPath,
+                    encoding: 'utf8',
+                    stdio: ['ignore', 'pipe', 'ignore'],
+                }).trim();
+                if (rawDiff) {
+                    const clipped = rawDiff.length > 2500 ? rawDiff.slice(0, 2500) + '\n... (diff truncated)' : rawDiff;
+                    diffSnippet = `\n\n### Code Changes (\`git diff\`)\n\`\`\`diff\n${clipped}\n\`\`\``;
+                }
+            }
+            catch { }
+            const baseSummary = editsRes.summary ||
                 `Implemented "${card.title}" autonomously across ${modifiedFiles.map((f) => `\`${f}\``).join(', ')}.`;
+            const summary = `${baseSummary}${diffSnippet}`;
             const verificationSteps = editsRes.verification_steps ||
-                `1. Open ${projectPath} and inspect changes in ${modifiedFiles.join(', ')}\n2. Run the app and verify "${card.title}".`;
+                `1. Review the code diff above in ${modifiedFiles.join(', ')}\n2. Click **Approve & Move to Production** (or drag to Production) to automatically commit, push, and deploy!`;
             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;
@@ -994,6 +1056,87 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
         activeAutonomousCards.delete(card.id);
     }
 }
+export async function deployApprovedCardIfNeeded(client, card, projectPath) {
+    if (!projectPath || !fs.existsSync(projectPath))
+        return false;
+    const shortId = card.id.slice(0, 8);
+    const deployLock = path.join(getAgileMonsterLocksDir(), `deployed-${shortId}.json`);
+    if (fs.existsSync(deployLock)) {
+        return false;
+    }
+    const provider = card.agent_provider || 'cursor';
+    const cleanTitle = (card.title || 'update').replace(/["`\r\n]+/g, ' ').trim();
+    try {
+        fs.writeFileSync(deployLock, JSON.stringify({ card_id: card.id, title: card.title, started_at: new Date().toISOString() }), 'utf8');
+        const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+            cwd: projectPath,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        if (!branch || branch === 'HEAD')
+            return false;
+        const statusOut = execSync('git status --porcelain -uno', {
+            cwd: projectPath,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        const rawText = `${card.title || ''} ${card.description || ''}`;
+        const isContainerRestartCard = /\b(restart|redeploy|rebuild)\b.*\b(container|docker|server|prod)/i.test(rawText);
+        if (statusOut.length > 0) {
+            execSync('git add -u', { cwd: projectPath, stdio: 'ignore' });
+            execSync(`git commit -m "feat: ${cleanTitle} [AM-${shortId}]"`, {
+                cwd: projectPath,
+                stdio: 'ignore',
+            });
+            execSync(`git push origin ${branch}`, {
+                cwd: projectPath,
+                stdio: 'ignore',
+            });
+            const commitHash = execSync('git rev-parse --short HEAD', {
+                cwd: projectPath,
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            }).trim();
+            await client.addProgress(card.id, provider, `🚀 **[Auto-Deployed to Production]** Card approved into **${card.list_name || 'Production'}** — automatically committed and pushed \`${commitHash}\` to \`origin/${branch}\` to trigger the production CI/CD & container deployment pipeline!`);
+            sendDesktopNotification(`Agile Monster -> Production Deploy`, `Pushed "${card.title}" (${commitHash}) to origin/${branch}!`);
+            return true;
+        }
+        else if (isContainerRestartCard) {
+            execSync(`git commit --allow-empty -m "chore: trigger container redeploy [AM-${shortId}]"`, {
+                cwd: projectPath,
+                stdio: 'ignore',
+            });
+            execSync(`git push origin ${branch}`, {
+                cwd: projectPath,
+                stdio: 'ignore',
+            });
+            const commitHash = execSync('git rev-parse --short HEAD', {
+                cwd: projectPath,
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            }).trim();
+            await client.addProgress(card.id, provider, `🚀 **[Auto-Deployed to Production]** Triggered production container rebuild & restart via \`${commitHash}\` on \`origin/${branch}\`.`);
+            sendDesktopNotification(`Agile Monster -> Container Redeploy`, `Triggered container restart (${commitHash}) on origin/${branch}!`);
+            return true;
+        }
+        else {
+            const headHash = execSync('git rev-parse --short HEAD', {
+                cwd: projectPath,
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            }).trim();
+            await client.addProgress(card.id, provider, `🚀 **[Auto-Deployed to Production]** Verified latest commit \`${headHash}\` is pushed to \`origin/${branch}\` and live in the production CI/CD pipeline.`);
+            return true;
+        }
+    }
+    catch (err) {
+        try {
+            await client.addProgress(card.id, provider, `⚠️ **[Auto-Deploy Note]** Attempted to auto-push approved changes in \`${projectPath}\`: ${err?.message || String(err)}`);
+        }
+        catch { }
+        return false;
+    }
+}
 export function startBuiltInPullPulse(server, client, intervalMs = 20000) {
     const notifiedCardIds = new Set();
     let updateTriggered = false;
@@ -1098,6 +1241,15 @@ export function startBuiltInPullPulse(server, client, intervalMs = 20000) {
                     await executeQueuedCardAutonomously(client, qCard, targetPath);
                 }
             }
+            // Zero-touch auto-commit & push (deploy to production) for cards approved into Production / Done!
+            const boundDone = res.all_bound_done_cards || [];
+            for (const dCard of boundDone) {
+                const targetPath = (dCard.bound_project_path || '').trim() ||
+                    (dCard.board_id === config.board_id ? config.project_path || process.cwd() : '');
+                if (targetPath && fs.existsSync(targetPath)) {
+                    await deployApprovedCardIfNeeded(client, dCard, targetPath);
+                }
+            }
             if ((res.version?.force_update_requested || res.version?.update_available) &&
                 !updateTriggered) {
                 updateTriggered = true;

package/dist/types.d.ts

@@ -88,6 +88,7 @@ export interface PulseResponse {
     queued_cards: Card[];
     in_progress_cards: Card[];
     all_bound_queued_cards?: Card[];
+    all_bound_done_cards?: Card[];
     version: PulseVersionInfo;
     saved_bindings?: Array<{
         board_id: string;

package/package.json

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