agent-enderun 0.7.1 → 0.7.5

package/framework-mcp/dist/tools/index.js

@@ -3,26 +3,27 @@ import { frameworkTools, frameworkHandlers } from "./framework.js";
 import { securityTools, securityHandlers } from "./security.js";
 import { memoryTools, memoryHandlers } from "./memory.js";
 import { contractTools, contractHandlers } from "./contract.js";
-import { academyTools, academyHandlers } from "./academy.js";
 import { messageTools, messageHandlers } from "./messages.js";
 import { gitTools, gitHandlers } from "./git.js";
-import { databaseTools, databaseHandlers } from "./database.js";
 import { knowledgeTools, knowledgeHandlers } from "./knowledge.js";
-import { repositoryTools, repositoryHandlers } from "./repository.js";
-import { scaffoldTools, scaffoldHandlers } from "./scaffold.js";
+import { governanceTools, governanceHandlers } from "./governance.js";
+import { orchestrationTools, orchestrationHandlers } from "./orchestration.js";
+import { monitoringTools, monitoringHandlers } from "./monitoring.js";
+import { pipelineTools, pipelineHandlers } from "./pipeline.js";
 export const allTools = [
     ...codebaseTools,
     ...frameworkTools,
     ...securityTools,
     ...memoryTools,
     ...contractTools,
-    ...academyTools,
     ...messageTools,
     ...gitTools,
-    ...databaseTools,
     ...knowledgeTools,
-    ...repositoryTools,
-    ...scaffoldTools,
+    ...governanceTools,
+    // v1.0 Army Core
+    ...orchestrationTools,
+    ...monitoringTools,
+    ...pipelineTools,
 ];
 export const allHandlers = {
     ...codebaseHandlers,
@@ -30,13 +31,14 @@ export const allHandlers = {
     ...securityHandlers,
     ...memoryHandlers,
     ...contractHandlers,
-    ...academyHandlers,
     ...messageHandlers,
     ...gitHandlers,
-    ...databaseHandlers,
     ...knowledgeHandlers,
-    ...repositoryHandlers,
-    ...scaffoldHandlers,
+    ...governanceHandlers,
+    // v1.0 Army Core
+    ...orchestrationHandlers,
+    ...monitoringHandlers,
+    ...pipelineHandlers,
 };
 // Add compatibility aliases
 allHandlers.codebase_search = allHandlers.search_codebase;

package/framework-mcp/dist/tools/memory.js

@@ -27,6 +27,45 @@ export const memoryTools = [
         description: "Read the entire content of PROJECT_MEMORY.md safely. Use this instead of direct ReadFile tools to ensure framework compatibility.",
         inputSchema: { type: "object", properties: {} },
     },
+    {
+        name: "get_army_graph",
+        description: "Read the current Agent Army interaction graph (memory-graph/graph.json). Useful for @orchestrator and @manager to see relationships and health.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "get_agent_context",
+        description: "Read the private persistent context for a specific agent from memory-graph/agent-contexts/{agent}.json (without the @ prefix).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agent: { type: "string", description: "Agent name without @ (e.g. manager, orchestrator, backend)" }
+            },
+            required: ["agent"]
+        },
+    },
+    {
+        name: "update_shared_facts",
+        description: "Update the shared facts file used by the entire Agent Army (memory-graph/shared-facts.json).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                facts: { type: "object", description: "Partial or full facts object to merge into shared-facts.json" }
+            },
+            required: ["facts"]
+        },
+    },
+    {
+        name: "update_agent_context",
+        description: "Update the private context for a specific agent in memory-graph/agent-contexts/.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agent: { type: "string", description: "Agent name without @" },
+                context: { type: "object", description: "Data to write/merge for this agent" }
+            },
+            required: ["agent", "context"]
+        },
+    },
 ];
 export const memoryHandlers = {
     update_project_memory: async (args, projectRoot) => {
@@ -91,4 +130,71 @@ export const memoryHandlers = {
             return { content: [{ type: "text", text: "Failed to read project memory." }] };
         }
     },
+    get_army_graph: async (args, projectRoot) => {
+        try {
+            const frameworkDir = getFrameworkDir(projectRoot);
+            const graphPath = path.join(projectRoot, frameworkDir, "memory-graph", "graph.json");
+            if (!fs.existsSync(graphPath))
+                return { content: [{ type: "text", text: "Army graph not found. Run army initialization first." }] };
+            const graph = JSON.parse(fs.readFileSync(graphPath, "utf-8"));
+            return { content: [{ type: "text", text: JSON.stringify(graph, null, 2) }] };
+        }
+        catch {
+            return { content: [{ type: "text", text: "Failed to read army graph." }] };
+        }
+    },
+    get_agent_context: async (args, projectRoot) => {
+        try {
+            const { agent } = args;
+            if (!agent)
+                return { content: [{ type: "text", text: "Agent name required." }] };
+            const frameworkDir = getFrameworkDir(projectRoot);
+            const contextPath = path.join(projectRoot, frameworkDir, "memory-graph", "agent-contexts", `${agent.replace(/^@/, "")}.json`);
+            if (!fs.existsSync(contextPath))
+                return { content: [{ type: "text", text: `No private context found for @${agent}.` }] };
+            const ctx = JSON.parse(fs.readFileSync(contextPath, "utf-8"));
+            return { content: [{ type: "text", text: JSON.stringify(ctx, null, 2) }] };
+        }
+        catch {
+            return { content: [{ type: "text", text: "Failed to read agent context." }] };
+        }
+    },
+    update_shared_facts: async (args, projectRoot) => {
+        try {
+            const { facts } = args;
+            if (!facts)
+                return { content: [{ type: "text", text: "facts object required." }] };
+            const frameworkDir = getFrameworkDir(projectRoot);
+            const factsPath = path.join(projectRoot, frameworkDir, "memory-graph", "shared-facts.json");
+            let existing = {};
+            if (fs.existsSync(factsPath)) {
+                existing = JSON.parse(fs.readFileSync(factsPath, "utf-8"));
+            }
+            const merged = { ...existing, ...facts, updatedAt: new Date().toISOString() };
+            fs.writeFileSync(factsPath, JSON.stringify(merged, null, 2));
+            return { content: [{ type: "text", text: "Shared facts updated successfully." }] };
+        }
+        catch {
+            return { content: [{ type: "text", text: "Failed to update shared facts." }] };
+        }
+    },
+    update_agent_context: async (args, projectRoot) => {
+        try {
+            const { agent, context } = args;
+            if (!agent || !context)
+                return { content: [{ type: "text", text: "agent and context required." }] };
+            const frameworkDir = getFrameworkDir(projectRoot);
+            const ctxPath = path.join(projectRoot, frameworkDir, "memory-graph", "agent-contexts", `${agent.replace(/^@/, "")}.json`);
+            let existing = {};
+            if (fs.existsSync(ctxPath)) {
+                existing = JSON.parse(fs.readFileSync(ctxPath, "utf-8"));
+            }
+            const merged = { ...existing, ...context, updatedAt: new Date().toISOString() };
+            fs.writeFileSync(ctxPath, JSON.stringify(merged, null, 2));
+            return { content: [{ type: "text", text: `Context for @${agent} updated successfully.` }] };
+        }
+        catch {
+            return { content: [{ type: "text", text: "Failed to update agent context." }] };
+        }
+    },
 };

package/framework-mcp/dist/tools/monitoring.js

@@ -0,0 +1,294 @@
+import { promises as fs } from "fs";
+import path from "path";
+import { getFrameworkDir } from "../utils.js";
+// ─── Tool Definitions ─────────────────────────────────────────────────────────
+export const monitoringTools = [
+    {
+        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 = {
+    async get_army_health_dashboard(_args, projectRoot) {
+        const results = {
+            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, ".enderun", "queue");
+        for (const subdir of ["pending", "processing", "completed", "failed"]) {
+            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, ".enderun", "logs", "orchestrator.json");
+        try {
+            const logContent = await fs.readFile(logPath, "utf-8");
+            const log = JSON.parse(logContent);
+            results.recentBlockages = (log.blockages ?? []).slice(-5);
+            results.recentBroadcasts = (log.broadcasts ?? []).slice(-3);
+        }
+        catch {
+            // No log yet
+        }
+        // Calculate overall health
+        const blockedCount = results.agents.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;
+        const n = lastN ?? 20;
+        const logName = agentName.replace("@", "") + ".json";
+        const logPath = path.join(projectRoot, ".enderun", "logs", logName);
+        try {
+            const content = await fs.readFile(logPath, "utf-8");
+            const log = JSON.parse(content);
+            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;
+        const threshold = thresholdMinutes ?? 30;
+        const statusPath = path.join(projectRoot, ".enderun", "STATUS.md");
+        const bottlenecks = [];
+        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;
+        // Gather all data for the war room report
+        const report = {
+            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, ".enderun", "queue");
+        const snapshot = {};
+        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, ".enderun", "logs", "orchestrator.json");
+        try {
+            const logContent = await fs.readFile(logPath, "utf-8");
+            const log = JSON.parse(logContent);
+            report.recentBlockages = (log.blockages ?? []).slice(-10);
+        }
+        catch {
+            report.recentBlockages = [];
+        }
+        // Generate recommended immediate actions
+        const blockedAgents = report.agentStatuses.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) }] };
+    },
+};