@kage-core/kage-graph-mcp 1.0.0 → 1.1.0

package/dist/daemon.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDaemonStatus = readDaemonStatus;
+exports.daemonDoctor = daemonDoctor;
+exports.stopDaemon = stopDaemon;
+exports.startDaemon = startDaemon;
+exports.startViewer = startViewer;
+const node_http_1 = require("node:http");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const kernel_js_1 = require("./kernel.js");
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_REST_PORT = 3111;
+const DEFAULT_VIEWER_PORT = 3113;
+function daemonDir(projectDir) {
+    return (0, node_path_1.join)(projectDir, ".agent_memory", "daemon");
+}
+function isInside(parent, child) {
+    const a = (0, node_path_1.resolve)(parent);
+    const b = (0, node_path_1.resolve)(child);
+    return b === a || b.startsWith(`${a}/`);
+}
+function contentType(filePath) {
+    const ext = (0, node_path_1.extname)(filePath);
+    if (ext === ".html")
+        return "text/html; charset=utf-8";
+    if (ext === ".js")
+        return "application/javascript; charset=utf-8";
+    if (ext === ".css")
+        return "text/css; charset=utf-8";
+    if (ext === ".json")
+        return "application/json; charset=utf-8";
+    if (ext === ".md")
+        return "text/markdown; charset=utf-8";
+    return "application/octet-stream";
+}
+function statusPath(projectDir) {
+    return (0, node_path_1.join)(daemonDir(projectDir), "status.json");
+}
+function json(res, status, value) {
+    res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify(value, null, 2));
+}
+function notFound(res) {
+    json(res, 404, { ok: false, error: "not_found" });
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+        req.on("end", () => {
+            const text = Buffer.concat(chunks).toString("utf8").trim();
+            if (!text) {
+                resolve({});
+                return;
+            }
+            try {
+                resolve(JSON.parse(text));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        req.on("error", reject);
+    });
+}
+function readDaemonStatus(projectDir) {
+    const path = statusPath(projectDir);
+    if (!(0, node_fs_1.existsSync)(path))
+        return null;
+    return JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
+}
+function daemonDoctor(projectDir) {
+    const status = readDaemonStatus(projectDir) ?? undefined;
+    let running = false;
+    if (status) {
+        try {
+            process.kill(status.pid, 0);
+            running = true;
+        }
+        catch {
+            running = false;
+        }
+    }
+    const restPort = status?.rest_port ?? DEFAULT_REST_PORT;
+    return {
+        configured: Boolean(status),
+        running,
+        status,
+        endpoints: [
+            `GET http://${DEFAULT_HOST}:${restPort}/health`,
+            `POST http://${DEFAULT_HOST}:${restPort}/kage/recall`,
+            `POST http://${DEFAULT_HOST}:${restPort}/kage/observe`,
+            `POST http://${DEFAULT_HOST}:${restPort}/kage/distill`,
+            `GET http://${DEFAULT_HOST}:${restPort}/kage/metrics`,
+            `GET http://${DEFAULT_HOST}:${restPort}/kage/quality`,
+            `GET http://${DEFAULT_HOST}:${restPort}/kage/benchmark`,
+        ],
+        warnings: running ? [] : ["Daemon is not running. Start it with `kage daemon start --project <repo>`."],
+    };
+}
+function stopDaemon(projectDir) {
+    const status = readDaemonStatus(projectDir);
+    if (!status)
+        return { ok: false, message: "No daemon status file found." };
+    try {
+        process.kill(status.pid, "SIGTERM");
+        return { ok: true, message: `Sent SIGTERM to Kage daemon pid ${status.pid}.`, status };
+    }
+    catch (error) {
+        return { ok: false, message: error instanceof Error ? error.message : String(error), status };
+    }
+}
+async function startDaemon(projectDir, options = {}) {
+    const host = options.host ?? DEFAULT_HOST;
+    const restPort = options.restPort ?? DEFAULT_REST_PORT;
+    const viewerPort = options.viewerPort ?? DEFAULT_VIEWER_PORT;
+    (0, node_fs_1.mkdirSync)(daemonDir(projectDir), { recursive: true });
+    const status = {
+        ok: true,
+        project_dir: projectDir,
+        pid: process.pid,
+        host,
+        rest_port: restPort,
+        viewer_port: viewerPort,
+        started_at: new Date().toISOString(),
+        status_path: statusPath(projectDir),
+    };
+    (0, node_fs_1.writeFileSync)(status.status_path, JSON.stringify(status, null, 2), "utf8");
+    const server = (0, node_http_1.createServer)(async (req, res) => {
+        const url = new URL(req.url ?? "/", `http://${host}:${restPort}`);
+        try {
+            if (req.method === "GET" && url.pathname === "/health") {
+                json(res, 200, { ok: true, name: "kage-daemon", project_dir: projectDir, pid: process.pid });
+                return;
+            }
+            if (req.method === "GET" && url.pathname === "/kage/status") {
+                json(res, 200, status);
+                return;
+            }
+            if (req.method === "GET" && url.pathname === "/kage/metrics") {
+                json(res, 200, (0, kernel_js_1.kageMetrics)(projectDir));
+                return;
+            }
+            if (req.method === "GET" && url.pathname === "/kage/quality") {
+                json(res, 200, (0, kernel_js_1.qualityReport)(projectDir));
+                return;
+            }
+            if (req.method === "GET" && url.pathname === "/kage/benchmark") {
+                json(res, 200, (0, kernel_js_1.benchmarkProject)(projectDir));
+                return;
+            }
+            if (req.method === "POST" && url.pathname === "/kage/recall") {
+                const body = await readBody(req);
+                json(res, 200, (0, kernel_js_1.recall)(projectDir, String(body.query ?? ""), Number(body.limit ?? 5), Boolean(body.explain)));
+                return;
+            }
+            if (req.method === "POST" && url.pathname === "/kage/observe") {
+                const body = await readBody(req);
+                json(res, 200, (0, kernel_js_1.observe)(projectDir, body));
+                return;
+            }
+            if (req.method === "POST" && url.pathname === "/kage/distill") {
+                const body = await readBody(req);
+                json(res, 200, (0, kernel_js_1.distillSession)(projectDir, String(body.session_id ?? body.session ?? "default")));
+                return;
+            }
+            notFound(res);
+        }
+        catch (error) {
+            json(res, 500, { ok: false, error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+    await new Promise((resolve) => server.listen(restPort, host, resolve));
+    console.log(`Kage daemon listening on http://${host}:${restPort}`);
+    console.log(`Project: ${projectDir}`);
+    console.log(`Status: ${status.status_path}`);
+    process.on("SIGTERM", () => {
+        server.close(() => process.exit(0));
+    });
+}
+async function startViewer(projectDir, options = {}) {
+    const host = options.host ?? DEFAULT_HOST;
+    const port = options.port ?? DEFAULT_VIEWER_PORT;
+    const viewerDir = (0, node_path_1.resolve)(__dirname, "..", "viewer");
+    const projectRoot = (0, node_path_1.resolve)(projectDir);
+    const graphPath = (0, node_path_1.join)(projectRoot, ".agent_memory", "graph", "graph.json");
+    const codePath = (0, node_path_1.join)(projectRoot, ".agent_memory", "code_graph", "graph.json");
+    const metricsPath = (0, node_path_1.join)(projectRoot, ".agent_memory", "metrics.json");
+    const reviewPath = (0, node_path_1.join)(projectRoot, ".agent_memory", "review", "memory-review.md");
+    const pendingDir = (0, node_path_1.join)(projectRoot, ".agent_memory", "pending");
+    const url = `http://${host}:${port}/viewer/index.html?graph=${encodeURIComponent(graphPath)}&code=${encodeURIComponent(codePath)}&metrics=${encodeURIComponent(metricsPath)}&review=${encodeURIComponent(reviewPath)}&pending=${encodeURIComponent(pendingDir)}`;
+    const server = (0, node_http_1.createServer)((req, res) => {
+        const requestUrl = new URL(req.url ?? "/", `http://${host}:${port}`);
+        let filePath = null;
+        if (requestUrl.pathname === "/" || requestUrl.pathname === "/viewer") {
+            filePath = (0, node_path_1.join)(viewerDir, "index.html");
+        }
+        else if (requestUrl.pathname.startsWith("/viewer/")) {
+            filePath = (0, node_path_1.join)(viewerDir, (0, node_path_1.normalize)(requestUrl.pathname.replace(/^\/viewer\//, "")));
+        }
+        else {
+            const decoded = decodeURIComponent(requestUrl.pathname);
+            filePath = (0, node_path_1.resolve)(decoded);
+            if (!isInside(projectRoot, filePath))
+                filePath = null;
+        }
+        if (!filePath || (!isInside(viewerDir, filePath) && !isInside(projectRoot, filePath)) || !(0, node_fs_1.existsSync)(filePath)) {
+            json(res, 404, { ok: false, error: "not_found" });
+            return;
+        }
+        const stat = (0, node_fs_1.statSync)(filePath);
+        if (stat.isDirectory()) {
+            const files = (0, node_fs_1.readdirSync)(filePath)
+                .filter((name) => name.endsWith(".json") || name.endsWith(".md"))
+                .sort()
+                .map((name) => ({ name, path: (0, node_path_1.join)(filePath, name) }));
+            json(res, 200, { ok: true, files });
+            return;
+        }
+        res.writeHead(200, { "content-type": contentType(filePath) });
+        res.end((0, node_fs_1.readFileSync)(filePath));
+    });
+    await new Promise((resolveListen) => server.listen(port, host, resolveListen));
+    console.log(`Kage viewer listening on ${url}`);
+    process.on("SIGTERM", () => {
+        server.close(() => process.exit(0));
+    });
+    return { ok: true, project_dir: projectRoot, host, port, url };
+}