@cortexa/core 1.0.1 → 1.1.0

package/dist/index.cjs

@@ -847,6 +847,7 @@ var init_mongodb_stream = __esm({
 var index_exports = {};
 __export(index_exports, {
   Cortexa: () => Cortexa,
+  CortexaServer: () => CortexaServer,
   KnowledgeGraph: () => KnowledgeGraph,
   defineConfig: () => defineConfig
 });
@@ -5423,6 +5424,290 @@ function defineConfig(config) {
   return config;
 }
 
+// src/server/index.ts
+init_cjs_shims();
+
+// src/server/server.ts
+init_cjs_shims();
+var import_node_http = require("http");
+
+// src/server/router.ts
+init_cjs_shims();
+var Router = class {
+  routes = [];
+  get(path3, handler) {
+    this.addRoute("GET", path3, handler);
+  }
+  post(path3, handler) {
+    this.addRoute("POST", path3, handler);
+  }
+  addRoute(method, path3, handler) {
+    const paramNames = [];
+    const patternStr = path3.replace(/:(\w+)/g, (_match, name) => {
+      paramNames.push(name);
+      return "([^/]+)";
+    });
+    this.routes.push({
+      method,
+      pattern: new RegExp(`^${patternStr}$`),
+      paramNames,
+      handler
+    });
+  }
+  async handle(req, res, cors) {
+    if (cors) {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    }
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    const path3 = url.pathname;
+    const method = req.method ?? "GET";
+    const query = {};
+    url.searchParams.forEach((value, key) => {
+      query[key] = value;
+    });
+    for (const route of this.routes) {
+      if (route.method !== method) continue;
+      const match = route.pattern.exec(path3);
+      if (!match) continue;
+      const pathParams = {};
+      for (let i = 0; i < route.paramNames.length; i++) {
+        pathParams[route.paramNames[i]] = match[i + 1];
+      }
+      let body = void 0;
+      if (method === "POST") {
+        body = await readBody(req);
+      }
+      const params = { path: path3, method, query, body, pathParams };
+      try {
+        const result = await route.handler(params);
+        sendJson(res, result.ok ? 200 : 400, result);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Internal server error";
+        sendJson(res, 500, { ok: false, error: message });
+      }
+      return;
+    }
+    sendJson(res, 404, { ok: false, error: `Not found: ${method} ${path3}` });
+  }
+};
+function sendJson(res, statusCode, data) {
+  res.writeHead(statusCode, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString();
+      if (!raw) {
+        resolve(void 0);
+        return;
+      }
+      try {
+        resolve(JSON.parse(raw));
+      } catch {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+// src/server/handlers.ts
+init_cjs_shims();
+function registerHandlers(router, cortexa) {
+  router.get("/api/status", async () => {
+    return { ok: true, data: cortexa.status };
+  });
+  router.get("/api/entities", async () => {
+    const { entities } = cortexa.exportGraph();
+    return { ok: true, data: entities };
+  });
+  router.get("/api/relationships", async () => {
+    const { relationships } = cortexa.exportGraph();
+    return { ok: true, data: relationships };
+  });
+  router.post("/api/discover", async (params) => {
+    const body = params.body ?? {};
+    const result = await cortexa.discover({
+      includeSampleData: body.includeSampleData !== false,
+      excludeTables: body.excludeTables,
+      excludeColumns: body.excludeColumns
+    });
+    return {
+      ok: true,
+      data: {
+        tables: result.raw.tables.length,
+        entities: result.entities.length,
+        relationships: result.relationships.length
+      }
+    };
+  });
+  router.get("/api/events", async (params) => {
+    const filter = {};
+    if (params.query.entity) filter.entity = params.query.entity;
+    if (params.query.last) filter.last = parseInt(params.query.last, 10);
+    if (params.query.operation) filter.operation = params.query.operation;
+    return { ok: true, data: cortexa.getEvents(filter) };
+  });
+  router.get("/api/baselines", async () => {
+    return { ok: true, data: cortexa.getBaselines() };
+  });
+  router.get("/api/anomalies", async (params) => {
+    const filter = {};
+    if (params.query.entity) filter.entity = params.query.entity;
+    if (params.query.last) filter.last = parseInt(params.query.last, 10);
+    if (params.query.severity) filter.severity = params.query.severity;
+    return { ok: true, data: cortexa.getAnomalies(filter) };
+  });
+  router.get("/api/insights", async (params) => {
+    const filter = {};
+    if (params.query.entity) filter.entity = params.query.entity;
+    if (params.query.last) filter.last = parseInt(params.query.last, 10);
+    if (params.query.severity) filter.severity = params.query.severity;
+    return { ok: true, data: cortexa.getInsights(filter) };
+  });
+  router.get("/api/transitions", async (params) => {
+    return { ok: true, data: cortexa.getTransitions(params.query.entity) };
+  });
+  router.get("/api/correlations", async () => {
+    return { ok: true, data: cortexa.getCorrelations() };
+  });
+  router.get("/api/distributions", async (params) => {
+    return { ok: true, data: cortexa.getDistributions(params.query.entity) };
+  });
+  router.get("/api/graph", async () => {
+    return { ok: true, data: cortexa.graph().getSummary() };
+  });
+  router.get("/api/graph/export", async () => {
+    return { ok: true, data: cortexa.graph().export() };
+  });
+  router.get("/api/graph/entity/:name", async (params) => {
+    const intel = cortexa.graph().entity(params.pathParams.name).intelligence();
+    if (!intel) {
+      return { ok: false, error: `Entity "${params.pathParams.name}" not found in knowledge graph` };
+    }
+    return { ok: true, data: intel };
+  });
+  router.get("/api/actions", async (params) => {
+    const filter = {};
+    if (params.query.status) filter.status = params.query.status;
+    if (params.query.action) filter.action = params.query.action;
+    return { ok: true, data: cortexa.getRecommendations(filter) };
+  });
+  router.post("/api/actions/:id/approve", async (params) => {
+    const id = parseInt(params.pathParams.id, 10);
+    if (isNaN(id)) return { ok: false, error: "Invalid id" };
+    cortexa.approveRecommendation(id);
+    return { ok: true, data: { id, status: "approved" } };
+  });
+  router.post("/api/actions/:id/reject", async (params) => {
+    const id = parseInt(params.pathParams.id, 10);
+    if (isNaN(id)) return { ok: false, error: "Invalid id" };
+    cortexa.rejectRecommendation(id);
+    return { ok: true, data: { id, status: "rejected" } };
+  });
+  router.post("/api/explain", async (params) => {
+    const body = params.body;
+    if (!body?.type || !body?.id) {
+      return { ok: false, error: 'Required: { type: "anomaly"|"insight"|"event"|"entity", id: number }' };
+    }
+    const target = {
+      type: body.type,
+      id: body.id
+    };
+    const result = await cortexa.explain(target);
+    return { ok: true, data: result };
+  });
+  router.post("/api/ask", async (params) => {
+    const body = params.body;
+    if (!body?.question || typeof body.question !== "string") {
+      return { ok: false, error: "Required: { question: string }" };
+    }
+    const result = await cortexa.ask(body.question, {
+      entityHint: body.entity
+    });
+    return { ok: true, data: result };
+  });
+  router.post("/api/watch", async (params) => {
+    const body = params.body ?? {};
+    await cortexa.watch({
+      interval: body.interval,
+      once: body.once
+    });
+    return { ok: true, data: { watching: true } };
+  });
+  router.post("/api/unwatch", async () => {
+    cortexa.unwatch();
+    return { ok: true, data: { watching: false } };
+  });
+}
+
+// src/server/server.ts
+init_logger();
+var CortexaServer = class {
+  cortexa;
+  serverConfig;
+  logger;
+  httpServer = null;
+  constructor(cortexaConfig, serverConfig) {
+    this.cortexa = new Cortexa(cortexaConfig);
+    this.serverConfig = {
+      port: serverConfig?.port ?? 3210,
+      host: serverConfig?.host ?? "127.0.0.1",
+      cors: serverConfig?.cors ?? true
+    };
+    this.logger = createLogger();
+  }
+  async start() {
+    await this.cortexa.connect();
+    const router = new Router();
+    registerHandlers(router, this.cortexa);
+    const cors = this.serverConfig.cors ?? true;
+    this.httpServer = (0, import_node_http.createServer)((req, res) => {
+      router.handle(req, res, cors).catch((err) => {
+        this.logger.error({ err }, "Unhandled request error");
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: "Internal server error" }));
+      });
+    });
+    const { port, host } = this.serverConfig;
+    await new Promise((resolve) => {
+      this.httpServer.listen(port, host, () => {
+        this.logger.info({ port, host }, "Cortexa REST API server started");
+        resolve();
+      });
+    });
+  }
+  async stop() {
+    if (this.httpServer) {
+      await new Promise((resolve, reject) => {
+        this.httpServer.close((err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+      this.httpServer = null;
+    }
+    await this.cortexa.disconnect();
+    this.logger.info("Cortexa REST API server stopped");
+  }
+  get address() {
+    return {
+      port: this.serverConfig.port ?? 3210,
+      host: this.serverConfig.host ?? "127.0.0.1"
+    };
+  }
+};
+
 // src/index.ts
 var KnowledgeGraph = class {
   store;
@@ -5727,6 +6012,7 @@ var Cortexa = class extends import_node_events2.EventEmitter {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Cortexa,
+  CortexaServer,
   KnowledgeGraph,
   defineConfig
 });