agent-enderun 0.8.8 → 0.9.0

package/framework-mcp/src/tools/monitoring.ts

@@ -1,351 +0,0 @@
-import { Tool } from "@modelcontextprotocol/sdk/types.js";
-import { promises as fs } from "fs";
-import path from "path";
-import { getFrameworkDir } from "../utils.js";
-
-// ─── Tool Definitions ─────────────────────────────────────────────────────────
-
-export const monitoringTools: Tool[] = [
-  {
-    name: "get_army_health_dashboard",
-    description:
-      "Returns a comprehensive health dashboard for the entire Agent Enderun Army. Includes agent states, active tasks, health scores, queue depth, and recent blockages. Single call for full army situational awareness.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        projectRoot: { type: "string", description: "Root directory of the project" },
-      },
-      required: [],
-    },
-  },
-  {
-    name: "calculate_agent_performance_score",
-    description:
-      "Calculates a dynamic performance score for a specific agent based on their last N actions from the audit log. Returns success rate, average execution time, and blockage frequency.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        agentName: { type: "string", description: "Agent identifier (e.g. @backend)" },
-        lastN: { type: "number", description: "Number of recent actions to analyze", default: 20 },
-      },
-      required: ["agentName"],
-    },
-  },
-  {
-    name: "detect_bottleneck_agents",
-    description:
-      "Scans all agent logs and STATUS.md to identify agents that are causing delays — either by being BLOCKED, exceeding execution timeout, or having a high blockage frequency. Returns a prioritized list of bottlenecks.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        thresholdMinutes: {
-          type: "number",
-          description: "Minutes after which an EXECUTING agent is considered a bottleneck",
-          default: 30,
-        },
-      },
-      required: [],
-    },
-  },
-  {
-    name: "generate_war_room_report",
-    description:
-      "Generates a crisis-mode summary report for @manager. Includes: all BLOCKED/ERROR agents, unresolved dependencies, critical path analysis, and recommended immediate actions. Designed for high-urgency situations.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        traceId: { type: "string", description: "Active Trace ID for the crisis" },
-        crisisDescription: { type: "string", description: "Brief description of the crisis or incident" },
-      },
-      required: ["traceId", "crisisDescription"],
-    },
-  },
-];
-
-// ─── Handlers ─────────────────────────────────────────────────────────────────
-
-export const monitoringHandlers: Record<
-  string,
-  (args: unknown, projectRoot: string) => Promise<{ content: Array<{ type: string; text: string }> }>
-> = {
-  async get_army_health_dashboard(_args, projectRoot) {
-    const results: {
-      generatedAt: string;
-      agents: unknown[];
-      queueDepth: { pending: number; processing: number; completed: number; failed: number };
-      recentBlockages: unknown[];
-      recentBroadcasts: unknown[];
-      overallHealth: string;
-    } = {
-      generatedAt: new Date().toISOString(),
-      agents: [],
-      queueDepth: { pending: 0, processing: 0, completed: 0, failed: 0 },
-      recentBlockages: [],
-      recentBroadcasts: [],
-      overallHealth: "GREEN",
-    };
-
-    // Read STATUS.md
-    const frameworkDir = getFrameworkDir(projectRoot);
-    const statusPath = path.join(projectRoot, frameworkDir, "STATUS.md");
-    try {
-      const statusContent = await fs.readFile(statusPath, "utf-8");
-      const lines = statusContent
-        .split("\n")
-        .filter((l) => l.includes("|") && !l.includes("---") && !l.includes("Agent"));
-      results.agents = lines
-        .map((line) => {
-          const cells = line.split("|").map((c) => c.trim()).filter(Boolean);
-          return cells.length >= 4
-            ? {
-                agent: cells[0],
-                state: cells[1],
-                currentTask: cells[2],
-                blockedBy: cells[3],
-                healthScore: cells[4] ?? "—",
-                lastAction: cells[5] ?? "—",
-              }
-            : null;
-        })
-        .filter(Boolean);
-    } catch {
-      results.agents = [{ error: "STATUS.md not found or unreadable" }];
-    }
-
-    // Read queue depths
-    const queueBase = path.join(projectRoot, getFrameworkDir(projectRoot), "queue");
-    for (const subdir of ["pending", "processing", "completed", "failed"] as const) {
-      try {
-        const files = await fs.readdir(path.join(queueBase, subdir));
-        results.queueDepth[subdir] = files.filter((f) => f.endsWith(".json")).length;
-      } catch {
-        results.queueDepth[subdir] = 0;
-      }
-    }
-
-    // Read orchestrator log for recent blockages and broadcasts
-    const logPath = path.join(projectRoot, getFrameworkDir(projectRoot), "logs", "orchestrator.json");
-    try {
-      const logContent = await fs.readFile(logPath, "utf-8");
-      const log = JSON.parse(logContent) as {
-        blockages?: unknown[];
-        broadcasts?: unknown[];
-      };
-      results.recentBlockages = (log.blockages ?? []).slice(-5);
-      results.recentBroadcasts = (log.broadcasts ?? []).slice(-3);
-    } catch {
-      // No log yet
-    }
-
-    // Calculate overall health
-    const blockedCount = (results.agents as Array<{ state?: string }>).filter(
-      (a) => a?.state?.includes("BLOCKED") || a?.state?.includes("ERROR")
-    ).length;
-    if (blockedCount >= 3) results.overallHealth = "RED";
-    else if (blockedCount >= 1) results.overallHealth = "YELLOW";
-    else results.overallHealth = "GREEN";
-
-    return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
-  },
-
-  async calculate_agent_performance_score(args, projectRoot) {
-    const { agentName, lastN } = args as { agentName: string; lastN?: number };
-    const n = lastN ?? 20;
-    const logName = agentName.replace("@", "") + ".json";
-    const logPath = path.join(projectRoot, getFrameworkDir(projectRoot), "logs", logName);
-
-    try {
-      const content = await fs.readFile(logPath, "utf-8");
-      const log = JSON.parse(content) as { actions?: Array<{ status?: string; durationMs?: number }> };
-      const actions = (log.actions ?? []).slice(-n);
-      const total = actions.length;
-      const successful = actions.filter((a) => a.status === "SUCCESS" || a.status === "DONE").length;
-      const successRate = total > 0 ? ((successful / total) * 100).toFixed(1) + "%" : "N/A";
-      const avgDuration =
-        total > 0
-          ? (
-              actions.reduce((sum, a) => sum + (a.durationMs ?? 0), 0) / total
-            ).toFixed(0) + "ms"
-          : "N/A";
-
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              {
-                agent: agentName,
-                analyzedActions: total,
-                successRate,
-                averageExecutionTime: avgDuration,
-                generatedAt: new Date().toISOString(),
-              },
-              null,
-              2
-            ),
-          },
-        ],
-      };
-    } catch {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              agent: agentName,
-              error: "No log found or log is empty",
-              analyzedActions: 0,
-            }),
-          },
-        ],
-      };
-    }
-  },
-
-  async detect_bottleneck_agents(args, projectRoot) {
-    const { thresholdMinutes } = args as { thresholdMinutes?: number };
-    const threshold = thresholdMinutes ?? 30;
-
-    const statusPath = path.join(projectRoot, getFrameworkDir(projectRoot), "STATUS.md");
-    const bottlenecks: Array<{ agent: string; reason: string; state: string; severity: string }> = [];
-
-    try {
-      const content = await fs.readFile(statusPath, "utf-8");
-      const lines = content
-        .split("\n")
-        .filter((l) => l.includes("|") && !l.includes("---") && !l.includes("Agent"));
-
-      for (const line of lines) {
-        const cells = line.split("|").map((c) => c.trim()).filter(Boolean);
-        if (cells.length < 2) continue;
-        const [agent, state] = cells;
-        if (state.includes("BLOCKED")) {
-          bottlenecks.push({ agent, state, reason: "Agent is in BLOCKED state", severity: "CRITICAL" });
-        } else if (state.includes("ERROR")) {
-          bottlenecks.push({ agent, state, reason: "Agent is in ERROR state", severity: "CRITICAL" });
-        } else if (state.includes("EXECUTING")) {
-          bottlenecks.push({
-            agent,
-            state,
-            reason: `Agent has been EXECUTING for more than ${threshold} minutes (verify manually)`,
-            severity: "HIGH",
-          });
-        }
-      }
-    } catch {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({ error: "Could not read STATUS.md" }),
-          },
-        ],
-      };
-    }
-
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(
-            {
-              bottlenecks,
-              total: bottlenecks.length,
-              analysisThresholdMinutes: threshold,
-              generatedAt: new Date().toISOString(),
-            },
-            null,
-            2
-          ),
-        },
-      ],
-    };
-  },
-
-  async generate_war_room_report(args, projectRoot) {
-    const { traceId, crisisDescription } = args as {
-      traceId: string;
-      crisisDescription: string;
-    };
-
-    // Gather all data for the war room report
-    const report: {
-      warRoomReport: boolean;
-      traceId: string;
-      crisisDescription: string;
-      generatedAt: string;
-      agentStatuses: unknown[];
-      queueSnapshot: unknown;
-      recentBlockages: unknown[];
-      immediateActions: string[];
-    } = {
-      warRoomReport: true,
-      traceId,
-      crisisDescription,
-      generatedAt: new Date().toISOString(),
-      agentStatuses: [],
-      queueSnapshot: {},
-      recentBlockages: [],
-      immediateActions: [],
-    };
-
-    // Agent statuses
-    const frameworkDir = getFrameworkDir(projectRoot);
-    const statusPath = path.join(projectRoot, frameworkDir, "STATUS.md");
-    try {
-      const content = await fs.readFile(statusPath, "utf-8");
-      const lines = content
-        .split("\n")
-        .filter((l) => l.includes("|") && !l.includes("---") && !l.includes("Agent"));
-      report.agentStatuses = lines
-        .map((l) => {
-          const cells = l.split("|").map((c) => c.trim()).filter(Boolean);
-          return cells.length >= 2 ? { agent: cells[0], state: cells[1] } : null;
-        })
-        .filter(Boolean);
-    } catch {
-      report.agentStatuses = [];
-    }
-
-    // Queue snapshot
-    const queueBase = path.join(projectRoot, getFrameworkDir(projectRoot), "queue");
-    const snapshot: Record<string, number> = {};
-    for (const dir of ["pending", "processing", "completed", "failed"]) {
-      try {
-        const files = await fs.readdir(path.join(queueBase, dir));
-        snapshot[dir] = files.length;
-      } catch {
-        snapshot[dir] = 0;
-      }
-    }
-    report.queueSnapshot = snapshot;
-
-    // Recent blockages
-    const logPath = path.join(projectRoot, getFrameworkDir(projectRoot), "logs", "orchestrator.json");
-    try {
-      const logContent = await fs.readFile(logPath, "utf-8");
-      const log = JSON.parse(logContent) as { blockages?: unknown[] };
-      report.recentBlockages = (log.blockages ?? []).slice(-10);
-    } catch {
-      report.recentBlockages = [];
-    }
-
-    // Generate recommended immediate actions
-    const blockedAgents = (report.agentStatuses as Array<{ agent: string; state: string }>).filter(
-      (a) => a.state.includes("BLOCKED") || a.state.includes("ERROR")
-    );
-    if (blockedAgents.length > 0) {
-      report.immediateActions.push(
-        `IMMEDIATE: Resolve ${blockedAgents.map((a) => a.agent).join(", ")} blockages — these are on the critical path`
-      );
-    }
-    if ((snapshot["pending"] ?? 0) > 5) {
-      report.immediateActions.push("HIGH: Queue has excessive pending tasks — consider deploying additional agents");
-    }
-    if (report.immediateActions.length === 0) {
-      report.immediateActions.push("No critical immediate actions required — monitor agent states");
-    }
-
-    return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
-  },
-};