jfl 0.2.5 → 0.4.2

package/dist/commands/context-hub.js

@@ -415,11 +415,89 @@ function getUnifiedContext(projectRoot, query, taskType) {
         taskType
     };
 }
+function getChildHubs(projectRoot) {
+    const configPath = path.join(projectRoot, ".jfl", "config.json");
+    if (!fs.existsSync(configPath))
+        return [];
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        if (config.type !== "portfolio")
+            return [];
+        const children = [];
+        for (const service of config.registered_services || []) {
+            if (service.type === "gtm" && service.path) {
+                const childPort = getProjectPort(service.path);
+                const tokenPath = path.join(service.path, ".jfl", "context-hub.token");
+                const token = fs.existsSync(tokenPath)
+                    ? fs.readFileSync(tokenPath, "utf-8").trim()
+                    : undefined;
+                children.push({ name: service.name, path: service.path, port: childPort, token });
+            }
+        }
+        return children;
+    }
+    catch {
+        return [];
+    }
+}
+async function fetchChildContext(child, endpoint, body) {
+    try {
+        const headers = { "Content-Type": "application/json" };
+        if (child.token)
+            headers["Authorization"] = `Bearer ${child.token}`;
+        const response = await fetch(`http://localhost:${child.port}${endpoint}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok)
+            return [];
+        const data = (await response.json());
+        return (data.items || []).map((item) => ({
+            ...item,
+            title: `[${child.name}] ${item.title}`,
+        }));
+    }
+    catch {
+        return readJournalEntries(child.path, 10).map((item) => ({
+            ...item,
+            title: `[${child.name}] ${item.title}`,
+        }));
+    }
+}
+async function getPortfolioContext(projectRoot, query, taskType, maxItems) {
+    const local = getUnifiedContext(projectRoot, query, taskType);
+    const children = getChildHubs(projectRoot);
+    if (children.length === 0)
+        return local;
+    const endpoint = query ? "/api/context/search" : "/api/context";
+    const body = { maxItems: maxItems || 20 };
+    if (query)
+        body.query = query;
+    if (taskType)
+        body.taskType = taskType;
+    const childResults = await Promise.all(children.map((child) => fetchChildContext(child, endpoint, body)));
+    let merged = [...local.items, ...childResults.flat()];
+    if (query) {
+        merged = semanticSearch(merged, query);
+    }
+    return {
+        items: maxItems ? merged.slice(0, maxItems) : merged,
+        sources: {
+            ...local.sources,
+            journal: true,
+            knowledge: true,
+        },
+        query,
+        taskType,
+    };
+}
 // ============================================================================
 // HTTP Server
 // ============================================================================
-function createServer(projectRoot, port, eventBus) {
-    const server = http.createServer((req, res) => {
+function createServer(projectRoot, port, eventBus, flowEngine) {
+    const server = http.createServer(async (req, res) => {
         const requestStart = Date.now();
         const pathname = new URL(req.url || "/", `http://localhost:${port}`).pathname;
         // Intercept writeHead to capture status code for telemetry
@@ -533,29 +611,74 @@ function createServer(projectRoot, port, eventBus) {
             }));
             return;
         }
-        // Status
+        // Status (includes child hub health for portfolio)
         if (url.pathname === "/api/context/status" && req.method === "GET") {
             const context = getUnifiedContext(projectRoot);
+            const children = getChildHubs(projectRoot);
+            // Read actual workspace type from config
+            let workspaceType = "standalone";
+            let workspaceConfig = {};
+            const configPath = path.join(projectRoot, ".jfl", "config.json");
+            if (fs.existsSync(configPath)) {
+                try {
+                    const cfg = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+                    if (cfg.type === "portfolio" || cfg.type === "gtm" || cfg.type === "service") {
+                        workspaceType = cfg.type;
+                    }
+                    workspaceConfig = {
+                        name: cfg.name,
+                        type: cfg.type,
+                        description: cfg.description,
+                        scope: cfg.context_scope || null,
+                        registered_services: (cfg.registered_services || []).map((s) => ({
+                            name: s.name,
+                            path: s.path,
+                            type: s.type,
+                            status: s.status,
+                            context_scope: s.context_scope || null,
+                        })),
+                        openclaw_agents: (cfg.openclaw_agents || []).map((a) => ({
+                            id: a.id,
+                            runtime: a.runtime,
+                            registered_at: a.registered_at,
+                        })),
+                        gtm_parent: cfg.gtm_parent || null,
+                        portfolio_parent: cfg.portfolio_parent || null,
+                    };
+                }
+                catch { }
+            }
+            const childStatus = await Promise.all(children.map(async (child) => {
+                try {
+                    const resp = await fetch(`http://localhost:${child.port}/health`, {
+                        signal: AbortSignal.timeout(2000),
+                    });
+                    return { name: child.name, port: child.port, status: resp.ok ? "ok" : "error" };
+                }
+                catch {
+                    return { name: child.name, port: child.port, status: "down" };
+                }
+            }));
             res.writeHead(200, { "Content-Type": "application/json" });
             res.end(JSON.stringify({
                 status: "running",
                 port,
+                type: workspaceType,
+                config: workspaceConfig,
                 sources: context.sources,
-                itemCount: context.items.length
+                itemCount: context.items.length,
+                ...(children.length > 0 ? { children: childStatus } : {}),
             }));
             return;
         }
-        // Get context
+        // Get context (portfolio-aware: fans out to child hubs)
         if (url.pathname === "/api/context" && req.method === "POST") {
             let body = "";
             req.on("data", chunk => body += chunk);
-            req.on("end", () => {
+            req.on("end", async () => {
                 try {
                     const { query, taskType, maxItems } = JSON.parse(body || "{}");
-                    const context = getUnifiedContext(projectRoot, query, taskType);
-                    if (maxItems && context.items.length > maxItems) {
-                        context.items = context.items.slice(0, maxItems);
-                    }
+                    const context = await getPortfolioContext(projectRoot, query, taskType, maxItems);
                     telemetry.track({
                         category: 'context_hub',
                         event: 'context_hub:context_loaded',
@@ -575,11 +698,11 @@ function createServer(projectRoot, port, eventBus) {
             });
             return;
         }
-        // Search
+        // Search (portfolio-aware: fans out to child hubs)
         if (url.pathname === "/api/context/search" && req.method === "POST") {
             let body = "";
             req.on("data", chunk => body += chunk);
-            req.on("end", () => {
+            req.on("end", async () => {
                 try {
                     const { query, maxItems = 20 } = JSON.parse(body || "{}");
                     if (!query) {
@@ -588,7 +711,7 @@ function createServer(projectRoot, port, eventBus) {
                         return;
                     }
                     const searchStart = Date.now();
-                    const context = getUnifiedContext(projectRoot, query);
+                    const context = await getPortfolioContext(projectRoot, query, undefined, maxItems);
                     context.items = context.items
                         .filter(item => item.relevance && item.relevance > 0)
                         .slice(0, maxItems);
@@ -707,6 +830,90 @@ function createServer(projectRoot, port, eventBus) {
             });
             return;
         }
+        // Eval trajectory
+        if (url.pathname === "/api/eval/trajectory" && req.method === "GET") {
+            try {
+                const { getTrajectory } = await import("../lib/eval-store.js");
+                const agent = url.searchParams.get("agent") || "";
+                const metric = url.searchParams.get("metric") || "composite";
+                if (!agent) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "agent query param required" }));
+                    return;
+                }
+                const points = getTrajectory(agent, metric, projectRoot);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ agent, metric, points }));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Eval leaderboard
+        if (url.pathname === "/api/eval/leaderboard" && req.method === "GET") {
+            try {
+                const { readEvals, listAgents, getLatestEval, getTrajectory } = await import("../lib/eval-store.js");
+                const agents = listAgents(projectRoot);
+                const leaderboard = agents.map(agent => {
+                    const latest = getLatestEval(agent, projectRoot);
+                    const trajectory = getTrajectory(agent, "composite", projectRoot);
+                    const prevPoint = trajectory.length >= 2 ? trajectory[trajectory.length - 2] : null;
+                    const delta = latest?.composite != null && prevPoint
+                        ? latest.composite - prevPoint.value
+                        : null;
+                    return {
+                        agent,
+                        composite: latest?.composite ?? null,
+                        metrics: latest?.metrics ?? {},
+                        delta,
+                        model_version: latest?.model_version ?? null,
+                        lastTs: latest?.ts ?? null,
+                        trajectory: trajectory.slice(-20).map(p => p.value),
+                    };
+                }).sort((a, b) => (b.composite ?? 0) - (a.composite ?? 0));
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(leaderboard));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Synopsis (work summary)
+        if (url.pathname === "/api/synopsis" && req.method === "GET") {
+            try {
+                const hours = parseInt(url.searchParams.get("hours") || "24", 10);
+                const author = url.searchParams.get("author") || undefined;
+                const { generateSynopsis } = await import("./synopsis.js");
+                const synopsis = generateSynopsis(projectRoot, hours, author);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(synopsis));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Prediction accuracy (Stratus)
+        if (url.pathname === "/api/eval/predictions" && req.method === "GET") {
+            try {
+                const { Predictor } = await import("../lib/predictor.js");
+                const predictor = new Predictor({ projectRoot });
+                const accuracy = predictor.getAccuracy();
+                const recent = predictor.getHistory(20).reverse();
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ accuracy, recent }));
+            }
+            catch (err) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ accuracy: { total: 0, resolved: 0, direction_accuracy: 0, mean_delta_error: 0, calibration: 0 }, recent: [] }));
+            }
+            return;
+        }
         // Cross-project health
         if (url.pathname === "/api/projects" && req.method === "GET") {
             const tracked = getTrackedProjects();
@@ -820,6 +1027,177 @@ function createServer(projectRoot, port, eventBus) {
             });
             return;
         }
+        // Telemetry digest
+        if (url.pathname === "/api/telemetry/digest" && req.method === "GET") {
+            try {
+                const { loadLocalEvents, analyzeEvents } = await import("../lib/telemetry-digest.js");
+                const hours = parseInt(url.searchParams.get("hours") || "168", 10);
+                const events = loadLocalEvents();
+                const digest = analyzeEvents(events, hours);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(digest));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Telemetry agent status
+        if (url.pathname === "/api/telemetry/agent" && req.method === "GET") {
+            const agent = server.__telemetryAgent;
+            if (agent) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(agent.getStatus()));
+            }
+            else {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ running: false, lastRun: '', runCount: 0, lastInsights: [] }));
+            }
+            return;
+        }
+        // Telemetry agent: trigger manual run
+        if (url.pathname === "/api/telemetry/agent/run" && req.method === "POST") {
+            const agent = server.__telemetryAgent;
+            if (agent) {
+                try {
+                    const insights = await agent.run();
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true, insights }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            }
+            else {
+                res.writeHead(503, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Telemetry agent not running" }));
+            }
+            return;
+        }
+        // Flow definitions
+        if (url.pathname === "/api/flows" && req.method === "GET") {
+            if (!flowEngine) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify([]));
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(flowEngine.getFlows()));
+            return;
+        }
+        // Flow executions
+        if (url.pathname === "/api/flows/executions" && req.method === "GET") {
+            if (!flowEngine) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ executions: [] }));
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ executions: flowEngine.getExecutions() }));
+            return;
+        }
+        // Flow approval
+        if (url.pathname.match(/^\/api\/flows\/[^/]+\/approve$/) && req.method === "POST") {
+            if (!flowEngine) {
+                res.writeHead(503, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Flow engine not initialized" }));
+                return;
+            }
+            const flowName = decodeURIComponent(url.pathname.split("/")[3]);
+            let body = "";
+            req.on("data", chunk => body += chunk);
+            req.on("end", async () => {
+                try {
+                    const { trigger_event_id } = JSON.parse(body || "{}");
+                    if (!trigger_event_id) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "trigger_event_id required" }));
+                        return;
+                    }
+                    const result = await flowEngine.approveGated(flowName, trigger_event_id);
+                    if (!result) {
+                        res.writeHead(404, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Gated execution not found" }));
+                        return;
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify(result));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        if (url.pathname.match(/^\/api\/flows\/[^/]+\/toggle$/) && req.method === "POST") {
+            if (!flowEngine) {
+                res.writeHead(503, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Flow engine not initialized" }));
+                return;
+            }
+            const flowName = decodeURIComponent(url.pathname.split("/")[3]);
+            let body = "";
+            req.on("data", chunk => body += chunk);
+            req.on("end", () => {
+                try {
+                    const { enabled } = JSON.parse(body || "{}");
+                    const result = flowEngine.toggleFlow(flowName, enabled);
+                    if (!result) {
+                        res.writeHead(404, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Flow not found" }));
+                        return;
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true, flow: flowName, enabled: result.enabled }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        if (url.pathname === "/api/actions/spawn" && req.method === "POST") {
+            let body = "";
+            req.on("data", chunk => body += chunk);
+            req.on("end", () => {
+                try {
+                    const { command, args, cwd, event_type, event_data } = JSON.parse(body || "{}");
+                    if (!command) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "command required" }));
+                        return;
+                    }
+                    const env = { ...process.env };
+                    delete env.ANTHROPIC_API_KEY;
+                    delete env.CLAUDE_CODE_ENTRYPOINT;
+                    const child = spawn(command, args || [], {
+                        cwd: cwd || projectRoot,
+                        detached: true,
+                        stdio: "ignore",
+                        env,
+                    });
+                    child.unref();
+                    if (event_type && eventBus) {
+                        eventBus.emit({
+                            type: event_type,
+                            source: "dashboard:action",
+                            data: event_data || { command, args, pid: child.pid },
+                        });
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true, pid: child.pid }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
         // 404
         res.writeHead(404, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: "Not found" }));
@@ -1187,17 +1565,18 @@ export async function contextHubCommand(action, options = {}) {
     const isGlobal = options.global || false;
     const projectRoot = isGlobal ? homedir() : process.cwd();
     const port = options.port || getProjectPort(projectRoot);
-    // Ensure directories exist
-    if (isGlobal) {
-        // Global mode: use XDG directories
-        const { JFL_PATHS, ensureJflDirs } = await import("../utils/jfl-paths.js");
-        ensureJflDirs();
-    }
-    else {
-        // Project mode: use .jfl/
-        const jflDir = path.join(projectRoot, ".jfl");
-        if (!fs.existsSync(jflDir)) {
-            fs.mkdirSync(jflDir, { recursive: true });
+    // Ensure directories exist (skip for actions that don't need local project root)
+    const globalActions = ["ensure-all", "doctor", "install-daemon", "uninstall-daemon"];
+    if (!globalActions.includes(action || "")) {
+        if (isGlobal) {
+            const { JFL_PATHS, ensureJflDirs } = await import("../utils/jfl-paths.js");
+            ensureJflDirs();
+        }
+        else {
+            const jflDir = path.join(projectRoot, ".jfl");
+            if (!fs.existsSync(jflDir)) {
+                fs.mkdirSync(jflDir, { recursive: true });
+            }
         }
     }
     switch (action) {
@@ -1397,7 +1776,8 @@ export async function contextHubCommand(action, options = {}) {
                 serviceEventsPath,
                 journalDir: fs.existsSync(journalDir) ? journalDir : null,
             });
-            const server = createServer(projectRoot, port, eventBus);
+            const flowEngine = new FlowEngine(eventBus, projectRoot);
+            const server = createServer(projectRoot, port, eventBus, flowEngine);
             let isListening = false;
             // When spawned as daemon, ignore SIGTERM during startup grace period.
             // The parent process (hook runner) may exit and send SIGTERM to the
@@ -1470,9 +1850,13 @@ export async function contextHubCommand(action, options = {}) {
                     console.error(`[${timestamp}] Failed to initialize memory system:`, err.message);
                     // Don't exit - memory is optional
                 }
-                // Start flow engine
+                // Start flow engine (with child hub connections for portfolio mode)
                 try {
-                    const flowEngine = new FlowEngine(eventBus, projectRoot);
+                    const children = getChildHubs(projectRoot);
+                    if (children.length > 0) {
+                        flowEngine.setChildren(children);
+                        console.log(`[${timestamp}] Portfolio mode: connecting to ${children.length} child hub(s)`);
+                    }
                     const flowCount = await flowEngine.start();
                     if (flowCount > 0) {
                         console.log(`[${timestamp}] Flow engine started with ${flowCount} active flow(s)`);
@@ -1481,6 +1865,23 @@ export async function contextHubCommand(action, options = {}) {
                 catch (err) {
                     console.error(`[${timestamp}] Failed to start flow engine:`, err.message);
                 }
+                // Start telemetry agent (periodic pattern detection)
+                try {
+                    const { TelemetryAgent } = await import("../lib/telemetry-agent.js");
+                    const telemetryAgent = new TelemetryAgent({
+                        projectRoot,
+                        intervalMs: 30 * 60 * 1000,
+                        emitEvent: (type, data, source) => {
+                            eventBus.emit({ type: type, data, source: source || 'telemetry-agent' });
+                        },
+                    });
+                    telemetryAgent.start();
+                    server.__telemetryAgent = telemetryAgent;
+                    console.log(`[${timestamp}] Telemetry agent started (interval: 30m)`);
+                }
+                catch (err) {
+                    console.error(`[${timestamp}] Failed to start telemetry agent:`, err.message);
+                }
                 console.log(`[${timestamp}] MAP event bus initialized (buffer: 1000, subscribers: ${eventBus.getSubscriberCount()})`);
                 console.log(`[${timestamp}] Ready to serve requests`);
             });