agent-enderun 1.1.9 → 1.10.0

package/src/cli/commands/contract.ts

@@ -1,20 +1,24 @@
 import path from "path";
 import fs from "fs";
 import { getConfiguredPaths } from "../utils/memory.js";
-import { computeTypesHash } from "../utils/fs.js";
+import { computeTypesHash, writeJsonFile } from "../utils/fs.js";
+import { ValidationError } from "../../shared/errors.js";
 
 /**
  * Verify type safety between backend and frontend contracts.
  */
-export function verifyApiContractCommand() {
+export async function verifyApiContractCommand() {
     const projectRoot = process.cwd();
     const pathsMap = getConfiguredPaths();
     const sharedDir = path.join(projectRoot, pathsMap.backend, "src/types");
     const contractPath = path.join(projectRoot, pathsMap.backend, "contract.version.json");
 
     if (!fs.existsSync(sharedDir) || !fs.existsSync(contractPath)) {
-        console.error("❌ Error: API types or contract version file missing.");
-        process.exit(1);
+        throw new ValidationError(
+            "API types or contract version file missing.",
+            null,
+            "Ensure you have initialized the project and the backend directory is correctly configured in config.json."
+        );
     }
 
     const currentHash = computeTypesHash(projectRoot, sharedDir);
@@ -23,26 +27,29 @@ export function verifyApiContractCommand() {
     if (contract.contract_hash === currentHash) {
         console.warn("✅ Contract is valid and synchronized.");
     } else {
-        console.error("❌ Error: Contract drift detected!");
-        console.error(`   Stored: ${contract.contract_hash}`);
-        console.error(`   Actual: ${currentHash}`);
-        console.warn("\n👉 Run 'npm run update-contract' to re-sync.");
-        process.exit(1);
+        throw new ValidationError(
+            "Contract drift detected!",
+            { stored: contract.contract_hash, actual: currentHash },
+            "Run 'npx agent-enderun update-contract' to re-synchronize the API contracts."
+        );
     }
 }
 
 /**
  * Update and synchronize type safety between backend and frontend contracts.
  */
-export function updateApiContractCommand() {
+export async function updateApiContractCommand() {
     const projectRoot = process.cwd();
     const pathsMap = getConfiguredPaths();
     const sharedDir = path.join(projectRoot, pathsMap.backend, "src/types");
     const contractPath = path.join(projectRoot, pathsMap.backend, "contract.version.json");
 
     if (!fs.existsSync(sharedDir)) {
-        console.error("❌ Error: API types directory missing.");
-        process.exit(1);
+        throw new ValidationError(
+            "API types directory missing.",
+            null,
+            "The directory specified for backend types does not exist. Check your framework configuration."
+        );
     }
 
     const currentHash = computeTypesHash(projectRoot, sharedDir);
@@ -52,8 +59,7 @@ export function updateApiContractCommand() {
         last_updated: new Date().toISOString()
     };
     
-    fs.mkdirSync(path.dirname(contractPath), { recursive: true });
-    fs.writeFileSync(contractPath, JSON.stringify(contractData, null, 2));
+    writeJsonFile(contractPath, contractData);
     console.warn(`✅ Contract successfully synchronized. New hash: ${currentHash}`);
 }
 

package/src/cli/commands/dashboard/data-service.ts

@@ -0,0 +1,119 @@
+import fs from "fs";
+import path from "path";
+import { getFrameworkDir } from "../../utils/memory.js";
+
+export function parseProjectMemory() {
+    const frameworkDir = getFrameworkDir();
+    if (!frameworkDir) return { error: "No framework directory found. Run init." };
+
+    const memPath = path.join(frameworkDir, "memory/PROJECT_MEMORY.md");
+    if (!fs.existsSync(memPath)) return { error: "PROJECT_MEMORY.md not found" };
+
+    try {
+        const content = fs.readFileSync(memPath, "utf8");
+        
+        // Parse Phase & Trace ID
+        const phaseMatch = content.match(/Phase:\s*([^\n\r]+)/i);
+        const traceMatch = content.match(/Trace ID:\s*([^\n\r]+)/i);
+        const managerMatch = content.match(/@manager state:\s*([^\n\r]+)/i);
+
+        // Parse Active Tasks Table
+        const tasks = [];
+        const lines = content.split("\n");
+        let inTaskTable = false;
+        
+        for (const line of lines) {
+            if (line.includes("| Trace ID | Task |")) {
+                inTaskTable = true;
+                continue;
+            }
+            if (inTaskTable && line.trim() === "") {
+                inTaskTable = false;
+                continue;
+            }
+            if (inTaskTable && line.startsWith("|") && !line.includes(":---")) {
+                const cols = line.split("|").map(c => c.trim()).filter(Boolean);
+                if (cols.length >= 5) {
+                    tasks.push({
+                        traceId: cols[0],
+                        task: cols[1],
+                        agent: cols[2],
+                        priority: cols[3],
+                        status: cols[4]
+                    });
+                }
+            }
+        }
+
+        // Parse History Section
+        const history = [];
+        const historyParts = content.split(/##\s+HISTORY/i);
+        if (historyParts[1]) {
+            const histLines = historyParts[1].split("\n");
+            let currentItem: { title: string, body: string[] } | null = null;
+            for (const line of histLines) {
+                if (line.startsWith("###")) {
+                    if (currentItem) history.push(currentItem);
+                    currentItem = { title: line.replace("###", "").trim(), body: [] };
+                } else if (currentItem && line.trim() !== "") {
+                    currentItem.body.push(line.trim());
+                }
+            }
+            if (currentItem) history.push(currentItem);
+        }
+
+        return {
+            phase: phaseMatch ? phaseMatch[1].trim() : "PHASE_0",
+            traceId: traceMatch ? traceMatch[1].trim() : "N/A",
+            managerState: managerMatch ? managerMatch[1].trim() : "ACTIVE",
+            tasks,
+            history: history.slice(0, 15) // Return last 15 entries
+        };
+    } catch (e: unknown) {
+        return { error: e instanceof Error ? e.message : String(e) };
+    }
+}
+
+export function readManagerLogs() {
+    const frameworkDir = getFrameworkDir();
+    if (!frameworkDir) return [];
+    
+    const logsPath = path.join(frameworkDir, "logs/manager.json");
+    if (!fs.existsSync(logsPath)) return [];
+
+    try {
+        const raw = fs.readFileSync(logsPath, "utf8");
+        // Handle both json array format and jsonl format
+        if (raw.trim().startsWith("[")) {
+            return JSON.parse(raw);
+        } else {
+            return raw.split("\n").filter(Boolean).map(line => JSON.parse(line));
+        }
+    } catch {
+        return [];
+    }
+}
+
+export function listAgents() {
+    const frameworkDir = getFrameworkDir();
+    if (!frameworkDir) return [];
+    const agentsPath = path.join(frameworkDir, "agents");
+    if (!fs.existsSync(agentsPath)) return [];
+
+    try {
+        const files = fs.readdirSync(agentsPath).filter(f => f.endsWith(".json") && f !== "agent_army_schema.json");
+        return files.map(file => {
+            const content = JSON.parse(fs.readFileSync(path.join(agentsPath, file), "utf8"));
+            return {
+                name: content.name,
+                displayName: content.displayName || content.name,
+                description: content.description,
+                role: content.role,
+                capability: content.capability,
+                tags: content.tags || []
+            };
+        });
+    } catch {
+        return [];
+    }
+}