@m6d/cortex-server 1.1.1 → 1.1.2

package/src/graph/generate-cypher.ts

@@ -14,67 +14,67 @@
 import type { DomainDef } from "./types.ts";
 
 export type GeneratedCypher = {
-  nodes: string[];
-  edges: string[];
+    nodes: string[];
+    edges: string[];
 };
 
 function esc(s: string) {
-  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n");
+    return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n");
 }
 
 function jsonStr(value: unknown) {
-  return esc(JSON.stringify(value));
+    return esc(JSON.stringify(value));
 }
 
 export function generateCypher(data: DomainDef) {
-  const nodes: string[] = [];
-  const edges: string[] = [];
+    const nodes: string[] = [];
+    const edges: string[] = [];
 
-  // -- Domain node --
-  nodes.push(
-    `MERGE (d:Domain {name: '${esc(data.name)}'})
+    // -- Domain node --
+    nodes.push(
+        `MERGE (d:Domain {name: '${esc(data.name)}'})
         SET d.description = '${esc(data.description)}'`,
-  );
+    );
 
-  // -- Concept nodes --
-  for (const c of data.concepts ?? []) {
-    const aliasClause =
-      c.aliases && c.aliases.length > 0
-        ? `, c.aliases = [${c.aliases.map((a) => `'${esc(a)}'`).join(", ")}]`
-        : "";
+    // -- Concept nodes --
+    for (const c of data.concepts ?? []) {
+        const aliasClause =
+            c.aliases && c.aliases.length > 0
+                ? `, c.aliases = [${c.aliases.map((a) => `'${esc(a)}'`).join(", ")}]`
+                : "";
 
-    nodes.push(
-      `MERGE (c:Concept {name: '${esc(c.name)}'})
+        nodes.push(
+            `MERGE (c:Concept {name: '${esc(c.name)}'})
             SET c.description = '${esc(c.description)}'${aliasClause}`,
-    );
+        );
 
-    edges.push(
-      `MATCH (c:Concept {name: '${esc(c.name)}'})
+        edges.push(
+            `MATCH (c:Concept {name: '${esc(c.name)}'})
             MATCH (d:Domain {name: '${esc(data.name)}'})
             MERGE (c)-[:BELONGS_TO]->(d)`,
-    );
+        );
 
-    if (c.parentConcept) {
-      edges.push(
-        `MATCH (child:Concept {name: '${esc(c.name)}'})
+        if (c.parentConcept) {
+            edges.push(
+                `MATCH (child:Concept {name: '${esc(c.name)}'})
                 MATCH (parent:Concept {name: '${esc(c.parentConcept.name)}'})
                 MERGE (child)-[:SPECIALIZES]->(parent)`,
-      );
-    }
+            );
+        }
 
-    c.governedBy?.forEach((rule) => {
-      edges.push(
-        `MATCH (r:Rule {name: '${esc(rule.name)}'})
+        c.governedBy?.forEach((rule) => {
+            edges.push(
+                `MATCH (r:Rule {name: '${esc(rule.name)}'})
                 MATCH (t:Concept {name: '${esc(c.name)}'})
                 MERGE (r)-[:GOVERNS]->(t)`,
-      );
-    });
-  }
+            );
+        });
+    }
 
-  // -- Endpoint nodes --
-  for (const ep of data.endpoints ?? []) {
-    nodes.push(
-      `MERGE (e:Endpoint {path: '${esc(ep.path)}', method: '${ep.method}'})
+    // -- Endpoint nodes --
+    for (const ep of data.endpoints ?? []) {
+        nodes.push(
+            `MERGE (e:Endpoint {path: '${esc(ep.path)}', method: '${ep.method}'})
             SET e.name = '${esc(ep.name)}',
                 e.description = '${esc(ep.description)}',
                 e.params = '${jsonStr(ep.params)}',
@@ -83,97 +83,97 @@ export function generateCypher(data: DomainDef) {
                 e.propertiesDescriptions = '${jsonStr(ep.propertiesDescriptions)}',
                 e.successStatus = ${ep.successStatus},
                 e.errorStatuses = [${ep.errorStatuses.join(", ")}]`,
-    );
+        );
 
-    for (const concept of ep.queries ?? []) {
-      edges.push(
-        `MATCH (c:Concept {name: '${esc(concept.name)}'})
+        for (const concept of ep.queries ?? []) {
+            edges.push(
+                `MATCH (c:Concept {name: '${esc(concept.name)}'})
                 MATCH (e:Endpoint {path: '${esc(ep.path)}', method: '${ep.method}'})
                 MERGE (c)-[:QUERIED_VIA]->(e)`,
-      );
-    }
+            );
+        }
 
-    for (const concept of ep.mutates ?? []) {
-      edges.push(
-        `MATCH (c:Concept {name: '${esc(concept.name)}'})
+        for (const concept of ep.mutates ?? []) {
+            edges.push(
+                `MATCH (c:Concept {name: '${esc(concept.name)}'})
                 MATCH (e:Endpoint {path: '${esc(ep.path)}', method: '${ep.method}'})
                 MERGE (c)-[:MUTATED_VIA]->(e)`,
-      );
-    }
+            );
+        }
 
-    for (const ret of ep.returns ?? []) {
-      const fieldClause = ret.field ? ` SET r.field = '${esc(ret.field)}'` : "";
+        for (const ret of ep.returns ?? []) {
+            const fieldClause = ret.field ? ` SET r.field = '${esc(ret.field)}'` : "";
 
-      edges.push(
-        `MATCH (e:Endpoint {path: '${esc(ep.path)}', method: '${ep.method}'})
+            edges.push(
+                `MATCH (e:Endpoint {path: '${esc(ep.path)}', method: '${ep.method}'})
                 MATCH (c:Concept {name: '${esc(ret.concept.name)}'})
                 MERGE (e)-[r:RETURNS]->(c)${fieldClause}`,
-      );
-    }
+            );
+        }
 
-    for (const rule of ep.governedBy ?? []) {
-      edges.push(
-        `MATCH (r:Rule {name: '${esc(rule.name)}'})
+        for (const rule of ep.governedBy ?? []) {
+            edges.push(
+                `MATCH (r:Rule {name: '${esc(rule.name)}'})
                 MATCH (t:Endpoint {path: '${esc(ep.path)}', method: '${ep.method}'})
                 MERGE (r)-[:GOVERNS]->(t)`,
-      );
-    }
+            );
+        }
 
-    for (const dep of ep.dependsOn ?? []) {
-      edges.push(
-        `MATCH (e:Endpoint {path: '${esc(ep.path)}', method: '${ep.method}'})
+        for (const dep of ep.dependsOn ?? []) {
+            edges.push(
+                `MATCH (e:Endpoint {path: '${esc(ep.path)}', method: '${ep.method}'})
                 MATCH (dep:Endpoint {path: '${esc(dep.endpoint.path)}', method: '${dep.endpoint.method}'})
                 MERGE (e)-[d:DEPENDS_ON]->(dep)
                 SET d.paramName = '${esc(dep.paramName)}', d.fromField = '${esc(dep.fromField)}'`,
-      );
+            );
+        }
     }
-  }
 
-  // -- Service nodes --
-  for (const svc of data.services ?? []) {
-    nodes.push(
-      `MERGE (s:Service {builtInId: '${esc(svc.builtInId)}'})
+    // -- Service nodes --
+    for (const svc of data.services ?? []) {
+        nodes.push(
+            `MERGE (s:Service {builtInId: '${esc(svc.builtInId)}'})
             SET s.name = '${esc(svc.name)}',
             s.description = '${esc(svc.description)}'`,
-    );
+        );
 
-    edges.push(
-      `MATCH (c:Concept {name: '${esc(svc.belongsTo.name)}'})
+        edges.push(
+            `MATCH (c:Concept {name: '${esc(svc.belongsTo.name)}'})
             MATCH (s:Service {builtInId: '${esc(svc.builtInId)}'})
             MERGE (c)-[:REQUESTED_VIA]->(s)`,
-    );
+        );
 
-    svc.governedBy?.forEach((rule) => {
-      edges.push(
-        `MATCH (r:Rule {name: '${esc(rule.name)}'})
+        svc.governedBy?.forEach((rule) => {
+            edges.push(
+                `MATCH (r:Rule {name: '${esc(rule.name)}'})
                 MATCH (t:Service {builtInId: '${esc(svc.builtInId)}'})
                 MERGE (r)-[:GOVERNS]->(t)`,
-      );
-    });
-  }
+            );
+        });
+    }
 
-  // -- Rule nodes --
-  for (const rule of data.rules ?? []) {
-    nodes.push(
-      `MERGE (r:Rule {name: '${esc(rule.name)}'})
+    // -- Rule nodes --
+    for (const rule of data.rules ?? []) {
+        nodes.push(
+            `MERGE (r:Rule {name: '${esc(rule.name)}'})
             SET r.description = '${esc(rule.description)}'`,
-    );
-  }
+        );
+    }
 
-  return { nodes, edges } satisfies GeneratedCypher;
+    return { nodes, edges } satisfies GeneratedCypher;
 }
 
 export function toCypherScript(data: DomainDef) {
-  const { nodes, edges } = generateCypher(data);
-  return (
-    `// Auto-generated seed script for module: ${data.name}\n` +
-    `// Generated at: ${new Date().toISOString()}\n` +
-    `// Safe to re-run (uses MERGE)\n\n` +
-    `// --- Nodes ---\n` +
-    nodes.join(";\n\n") +
-    ";\n\n" +
-    `// --- Edges ---\n` +
-    edges.join(";\n\n") +
-    ";\n"
-  );
+    const { nodes, edges } = generateCypher(data);
+    return (
+        `// Auto-generated seed script for module: ${data.name}\n` +
+        `// Generated at: ${new Date().toISOString()}\n` +
+        `// Safe to re-run (uses MERGE)\n\n` +
+        `// --- Nodes ---\n` +
+        nodes.join(";\n\n") +
+        ";\n\n" +
+        `// --- Edges ---\n` +
+        edges.join(";\n\n") +
+        ";\n"
+    );
 }

package/src/graph/helpers.ts

@@ -3,12 +3,12 @@
  */
 
 import type {
-  ConceptDef,
-  DomainDef,
-  EndpointDef,
-  EndpointInput,
-  RuleDef,
-  ServiceDef,
+    ConceptDef,
+    DomainDef,
+    EndpointDef,
+    EndpointInput,
+    RuleDef,
+    ServiceDef,
 } from "./types.ts";
 
 // ---------------------------------------------------------------------------
@@ -16,19 +16,19 @@ import type {
 // ---------------------------------------------------------------------------
 
 export function defineConcept(def: Omit<ConceptDef, "__brand">) {
-  return { __brand: "concept" as const, ...def };
+    return { __brand: "concept" as const, ...def };
 }
 
 export function defineRule(def: Omit<RuleDef, "__brand">) {
-  return { __brand: "rule" as const, ...def };
+    return { __brand: "rule" as const, ...def };
 }
 
 export function defineService(def: Omit<ServiceDef, "__brand">) {
-  return { __brand: "service" as const, ...def };
+    return { __brand: "service" as const, ...def };
 }
 
 export function defineDomain(def: Omit<DomainDef, "__brand">) {
-  return { __brand: "domain" as const, ...def };
+    return { __brand: "domain" as const, ...def };
 }
 
 // ---------------------------------------------------------------------------
@@ -36,33 +36,33 @@ export function defineDomain(def: Omit<DomainDef, "__brand">) {
 // ---------------------------------------------------------------------------
 
 export function defineEndpoint(input: EndpointInput) {
-  const propertiesDescriptions = Object.fromEntries(
-    Object.entries({
-      ...(input.propertiesDescriptions ?? {}),
-      ...(input.paramDescriptions ?? {}),
-      ...(input.responseDescriptions ?? {}),
-    }).filter(([, value]) => value != null),
-  ) as Record<string, string>;
+    const propertiesDescriptions = Object.fromEntries(
+        Object.entries({
+            ...(input.propertiesDescriptions ?? {}),
+            ...(input.paramDescriptions ?? {}),
+            ...(input.responseDescriptions ?? {}),
+        }).filter(([, value]) => value != null),
+    ) as Record<string, string>;
 
-  const normalized = input.autoGenerated;
+    const normalized = input.autoGenerated;
 
-  return {
-    __brand: "endpoint" as const,
-    name: input.name,
-    description: input.description ?? input.name,
-    path: input.path,
-    method: input.method,
-    propertiesDescriptions,
-    params: normalized ? [...normalized.params] : [],
-    body: normalized ? [...normalized.body] : [],
-    response: normalized ? [...normalized.response] : [],
-    successStatus: normalized?.successStatus ?? 200,
-    errorStatuses: normalized ? [...normalized.errorStatuses] : [],
-    responseKind: normalized?.responseKind ?? "object",
-    queries: input.queries,
-    mutates: input.mutates,
-    returns: input.returns,
-    dependsOn: input.dependsOn,
-    governedBy: input.governedBy,
-  } satisfies EndpointDef;
+    return {
+        __brand: "endpoint" as const,
+        name: input.name,
+        description: input.description ?? input.name,
+        path: input.path,
+        method: input.method,
+        propertiesDescriptions,
+        params: normalized ? [...normalized.params] : [],
+        body: normalized ? [...normalized.body] : [],
+        response: normalized ? [...normalized.response] : [],
+        successStatus: normalized?.successStatus ?? 200,
+        errorStatuses: normalized ? [...normalized.errorStatuses] : [],
+        responseKind: normalized?.responseKind ?? "object",
+        queries: input.queries,
+        mutates: input.mutates,
+        returns: input.returns,
+        dependsOn: input.dependsOn,
+        governedBy: input.governedBy,
+    } satisfies EndpointDef;
 }

package/src/graph/index.ts

@@ -1,24 +1,24 @@
 // Types
 export type {
-  EndpointScalarType,
-  EndpointProperty,
-  ResponseKind,
-  AutoGenerated,
-  ConceptDef,
-  EndpointDef,
-  EndpointInput,
-  ServiceDef,
-  RuleDef,
-  DomainDef,
+    EndpointScalarType,
+    EndpointProperty,
+    ResponseKind,
+    AutoGenerated,
+    ConceptDef,
+    EndpointDef,
+    EndpointInput,
+    ServiceDef,
+    RuleDef,
+    DomainDef,
 } from "./types.ts";
 
 // Helpers
 export {
-  defineConcept,
-  defineRule,
-  defineService,
-  defineDomain,
-  defineEndpoint,
+    defineConcept,
+    defineRule,
+    defineService,
+    defineDomain,
+    defineEndpoint,
 } from "./helpers.ts";
 
 // Cypher generation
@@ -38,10 +38,10 @@ export { seedGraph } from "./seed.ts";
 
 // Graph resolver
 export type {
-  RerankerConfig,
-  ResolverConfig,
-  ResolvedEndpoint,
-  ResolvedService,
-  ResolvedContext,
+    RerankerConfig,
+    ResolverConfig,
+    ResolvedEndpoint,
+    ResolvedService,
+    ResolvedContext,
 } from "./resolver.ts";
 export { resolveFromGraph } from "./resolver.ts";

package/src/graph/neo4j.ts

@@ -13,105 +13,98 @@ import { embed } from "ai";
 // ---------------------------------------------------------------------------
 
 export type Neo4jConfig = {
-  url: string;
-  user: string;
-  password: string;
+    url: string;
+    user: string;
+    password: string;
 };
 
 export type Neo4jClient = {
-  query(cypher: string, parameters?: Record<string, unknown>): Promise<string>;
+    query(cypher: string, parameters?: Record<string, unknown>): Promise<string>;
 };
 
 // ---------------------------------------------------------------------------
 // Client factory
 // ---------------------------------------------------------------------------
 
-export function createNeo4jClient(
-  config: Neo4jConfig,
-  embeddingModel?: EmbeddingModel,
-) {
-  async function query(cypher: string, parameters?: Record<string, unknown>) {
-    // Auto-embed parameters whose keys start with '#'
-    const embeddedParams = Object.keys(parameters ?? {}).filter((x) =>
-      x.startsWith("#"),
-    );
-
-    if (embeddedParams.length) {
-      if (!embeddingModel) {
-        throw new Error(
-          "An embedding model is required when using # parameters",
-        );
-      }
-
-      const embeddingResults = await Promise.all(
-        embeddedParams.map(
-          async (x) =>
-            await embed({
-              model: embeddingModel,
-              value: parameters![x] as string,
+export function createNeo4jClient(config: Neo4jConfig, embeddingModel?: EmbeddingModel) {
+    async function query(cypher: string, parameters?: Record<string, unknown>) {
+        // Auto-embed parameters whose keys start with '#'
+        const embeddedParams = Object.keys(parameters ?? {}).filter((x) => x.startsWith("#"));
+
+        if (embeddedParams.length) {
+            if (!embeddingModel) {
+                throw new Error("An embedding model is required when using # parameters");
+            }
+
+            const embeddingResults = await Promise.all(
+                embeddedParams.map(
+                    async (x) =>
+                        await embed({
+                            model: embeddingModel,
+                            value: parameters![x] as string,
+                        }),
+                ),
+            );
+
+            embeddedParams.forEach((k, idx) => {
+                delete parameters![k];
+                parameters![k.slice(1)] = embeddingResults[idx]!.embedding;
+            });
+        }
+
+        const response = await fetch(`${config.url}/db/neo4j/tx/commit`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Basic ${btoa(`${config.user}:${config.password}`)}`,
+            },
+            body: JSON.stringify({
+                statements: [
+                    {
+                        statement: cypher,
+                        parameters: parameters ?? {},
+                    },
+                ],
             }),
-        ),
-      );
-
-      embeddedParams.forEach((k, idx) => {
-        delete parameters![k];
-        parameters![k.slice(1)] = embeddingResults[idx]!.embedding;
-      });
-    }
-
-    const response = await fetch(`${config.url}/db/neo4j/tx/commit`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Basic ${btoa(`${config.user}:${config.password}`)}`,
-      },
-      body: JSON.stringify({
-        statements: [
-          {
-            statement: cypher,
-            parameters: parameters ?? {},
-          },
-        ],
-      }),
-    });
-
-    if (!response.ok) {
-      return JSON.stringify({
-        error: true,
-        status: response.status,
-        message: `Neo4j request failed with status ${response.status}`,
-      });
-    }
-
-    const result = (await response.json()) as {
-      errors?: { message: string }[];
-      results: { columns: string[]; data: { row: unknown[] }[] }[];
-    };
-
-    if (result.errors && result.errors.length > 0) {
-      return JSON.stringify({
-        error: true,
-        message: result.errors.map((e) => e.message).join("; "),
-      });
-    }
-
-    // Transform Neo4j response into a clean array of objects
-    const queryResult = result.results[0];
-    if (!queryResult) {
-      return JSON.stringify([]);
+        });
+
+        if (!response.ok) {
+            return JSON.stringify({
+                error: true,
+                status: response.status,
+                message: `Neo4j request failed with status ${response.status}`,
+            });
+        }
+
+        const result = (await response.json()) as {
+            errors?: { message: string }[];
+            results: { columns: string[]; data: { row: unknown[] }[] }[];
+        };
+
+        if (result.errors && result.errors.length > 0) {
+            return JSON.stringify({
+                error: true,
+                message: result.errors.map((e) => e.message).join("; "),
+            });
+        }
+
+        // Transform Neo4j response into a clean array of objects
+        const queryResult = result.results[0];
+        if (!queryResult) {
+            return JSON.stringify([]);
+        }
+
+        const { columns, data } = queryResult;
+        const rows = data.map((entry) => {
+            const obj: Record<string, unknown> = {};
+            columns.forEach((col, i) => {
+                obj[col] = entry.row[i];
+            });
+            return obj;
+        });
+
+        return JSON.stringify(rows);
     }
 
-    const { columns, data } = queryResult;
-    const rows = data.map((entry) => {
-      const obj: Record<string, unknown> = {};
-      columns.forEach((col, i) => {
-        obj[col] = entry.row[i];
-      });
-      return obj;
-    });
-
-    return JSON.stringify(rows);
-  }
-
-  return { query } satisfies Neo4jClient;
+    return { query } satisfies Neo4jClient;
 }