@m6d/cortex-server 1.7.0 → 2.0.0

package/src/graph/expand-domains.ts

@@ -1,276 +0,0 @@
-import type { ConceptDef, DomainDef, EndpointDef, RuleDef, ServiceDef } from "./types.ts";
-
-type DomainCollections = {
-    concepts: ConceptDef[];
-    endpoints: EndpointDef[];
-    services: ServiceDef[];
-    rules: RuleDef[];
-};
-
-type OwnershipMaps = {
-    concepts: WeakMap<ConceptDef, string>;
-    endpoints: WeakMap<EndpointDef, string>;
-    services: WeakMap<ServiceDef, string>;
-    rules: WeakMap<RuleDef, string>;
-};
-
-export function expandDomains(domains: Record<string, DomainDef>) {
-    const ownership = createOwnershipMaps(domains);
-    const expanded: Record<string, DomainDef> = {};
-
-    for (const [domainKey, domain] of Object.entries(domains)) {
-        const collections = cloneCollections(domain);
-        const pendingConcepts = [...collections.concepts];
-        const pendingEndpoints = [...collections.endpoints];
-        const pendingServices = [...collections.services];
-
-        while (
-            pendingConcepts.length > 0 ||
-            pendingEndpoints.length > 0 ||
-            pendingServices.length > 0
-        ) {
-            const concept = pendingConcepts.pop();
-            if (concept) {
-                includeConcept({
-                    domainKey,
-                    concept,
-                    ownership,
-                    collections,
-                    pendingConcepts,
-                    pendingEndpoints,
-                });
-            }
-
-            const endpoint = pendingEndpoints.pop();
-            if (endpoint) {
-                includeEndpoint({
-                    domainKey,
-                    endpoint,
-                    ownership,
-                    collections,
-                    pendingConcepts,
-                    pendingEndpoints,
-                });
-            }
-
-            const service = pendingServices.pop();
-            if (service) {
-                includeService({
-                    domainKey,
-                    service,
-                    ownership,
-                    collections,
-                    pendingConcepts,
-                });
-            }
-        }
-
-        expanded[domainKey] = {
-            ...domain,
-            concepts: collections.concepts,
-            endpoints: collections.endpoints,
-            services: collections.services,
-            rules: collections.rules,
-        };
-    }
-
-    return expanded;
-}
-
-function createOwnershipMaps(domains: Record<string, DomainDef>) {
-    const ownership: OwnershipMaps = {
-        concepts: new WeakMap<ConceptDef, string>(),
-        endpoints: new WeakMap<EndpointDef, string>(),
-        services: new WeakMap<ServiceDef, string>(),
-        rules: new WeakMap<RuleDef, string>(),
-    };
-
-    for (const [domainKey, domain] of Object.entries(domains)) {
-        for (const concept of domain.concepts ?? []) {
-            assignOwner(ownership.concepts, concept, domainKey);
-        }
-
-        for (const endpoint of domain.endpoints ?? []) {
-            assignOwner(ownership.endpoints, endpoint, domainKey);
-        }
-
-        for (const service of domain.services ?? []) {
-            assignOwner(ownership.services, service, domainKey);
-        }
-
-        for (const rule of domain.rules ?? []) {
-            assignOwner(ownership.rules, rule, domainKey);
-        }
-    }
-
-    return ownership;
-}
-
-function assignOwner<T extends object>(owners: WeakMap<T, string>, value: T, domainKey: string) {
-    if (!owners.has(value)) {
-        owners.set(value, domainKey);
-    }
-}
-
-function cloneCollections(domain: DomainDef) {
-    return {
-        concepts: [...(domain.concepts ?? [])],
-        endpoints: [...(domain.endpoints ?? [])],
-        services: [...(domain.services ?? [])],
-        rules: [...(domain.rules ?? [])],
-    } satisfies DomainCollections;
-}
-
-function includeConcept(options: {
-    domainKey: string;
-    concept: ConceptDef;
-    ownership: OwnershipMaps;
-    collections: DomainCollections;
-    pendingConcepts: ConceptDef[];
-    pendingEndpoints: EndpointDef[];
-}) {
-    const { domainKey, concept, ownership, collections, pendingConcepts, pendingEndpoints } =
-        options;
-
-    includeRule(domainKey, concept.governedBy ?? [], ownership, collections);
-
-    if (shouldAttach(ownership.concepts, concept, domainKey)) {
-        pushUnique(collections.concepts, concept);
-    }
-
-    if (
-        concept.parentConcept &&
-        shouldAttach(ownership.concepts, concept.parentConcept, domainKey)
-    ) {
-        if (pushUnique(collections.concepts, concept.parentConcept)) {
-            pendingConcepts.push(concept.parentConcept);
-        }
-    }
-
-    for (const endpoint of collections.endpoints) {
-        if (referencesConcept(endpoint, concept)) {
-            includeEndpoint({
-                domainKey,
-                endpoint,
-                ownership,
-                collections,
-                pendingConcepts,
-                pendingEndpoints,
-            });
-        }
-    }
-}
-
-function includeEndpoint(options: {
-    domainKey: string;
-    endpoint: EndpointDef;
-    ownership: OwnershipMaps;
-    collections: DomainCollections;
-    pendingConcepts: ConceptDef[];
-    pendingEndpoints: EndpointDef[];
-}) {
-    const { domainKey, endpoint, ownership, collections, pendingConcepts, pendingEndpoints } =
-        options;
-
-    if (shouldAttach(ownership.endpoints, endpoint, domainKey)) {
-        pushUnique(collections.endpoints, endpoint);
-    }
-
-    includeRule(domainKey, endpoint.governedBy ?? [], ownership, collections);
-
-    for (const concept of endpoint.queries ?? []) {
-        if (
-            shouldAttach(ownership.concepts, concept, domainKey) &&
-            pushUnique(collections.concepts, concept)
-        ) {
-            pendingConcepts.push(concept);
-        }
-    }
-
-    for (const concept of endpoint.mutates ?? []) {
-        if (
-            shouldAttach(ownership.concepts, concept, domainKey) &&
-            pushUnique(collections.concepts, concept)
-        ) {
-            pendingConcepts.push(concept);
-        }
-    }
-
-    for (const returned of endpoint.returns ?? []) {
-        if (
-            shouldAttach(ownership.concepts, returned.concept, domainKey) &&
-            pushUnique(collections.concepts, returned.concept)
-        ) {
-            pendingConcepts.push(returned.concept);
-        }
-    }
-
-    for (const dependency of endpoint.dependsOn ?? []) {
-        if (
-            shouldAttach(ownership.endpoints, dependency.endpoint, domainKey) &&
-            pushUnique(collections.endpoints, dependency.endpoint)
-        ) {
-            pendingEndpoints.push(dependency.endpoint);
-        }
-    }
-}
-
-function includeService(options: {
-    domainKey: string;
-    service: ServiceDef;
-    ownership: OwnershipMaps;
-    collections: DomainCollections;
-    pendingConcepts: ConceptDef[];
-}) {
-    const { domainKey, service, ownership, collections, pendingConcepts } = options;
-
-    if (shouldAttach(ownership.services, service, domainKey)) {
-        pushUnique(collections.services, service);
-    }
-
-    includeRule(domainKey, service.governedBy ?? [], ownership, collections);
-
-    if (
-        shouldAttach(ownership.concepts, service.belongsTo, domainKey) &&
-        pushUnique(collections.concepts, service.belongsTo)
-    ) {
-        pendingConcepts.push(service.belongsTo);
-    }
-}
-
-function includeRule(
-    domainKey: string,
-    rules: readonly RuleDef[],
-    ownership: OwnershipMaps,
-    collections: DomainCollections,
-) {
-    for (const rule of rules) {
-        if (shouldAttach(ownership.rules, rule, domainKey)) {
-            pushUnique(collections.rules, rule);
-        }
-    }
-}
-
-function shouldAttach<T extends object>(owners: WeakMap<T, string>, value: T, domainKey: string) {
-    const owner = owners.get(value);
-    return owner == null || owner === domainKey;
-}
-
-function pushUnique<T extends object>(values: T[], value: T) {
-    if (values.includes(value)) {
-        return false;
-    }
-
-    values.push(value);
-    return true;
-}
-
-function referencesConcept(endpoint: EndpointDef, concept: ConceptDef) {
-    return (
-        endpoint.queries?.includes(concept) ||
-        endpoint.mutates?.includes(concept) ||
-        endpoint.returns?.some(function (returned) {
-            return returned.concept === concept;
-        })
-    );
-}

package/src/graph/generate-cypher.ts

@@ -1,192 +0,0 @@
-/**
- * Transforms declarative DomainDef into idempotent MERGE-based Cypher.
- *
- * Returns two phases:
- *   - `nodes`  -- MERGE statements that create/update Domain, Concept, Endpoint,
- *                 Service, and Rule nodes.
- *   - `edges`  -- MATCH+MERGE statements that wire up relationships between nodes.
- *
- * The caller MUST run all `nodes` from every module before running any `edges`,
- * because edges may reference nodes defined in a different module (e.g. a Rule
- * in the leaves module that GOVERNS a Concept created by the servicing module).
- */
-
-import type { DomainDef } from "./types.ts";
-
-export type GeneratedCypher = {
-    nodes: string[];
-    edges: string[];
-};
-
-function esc(s: string) {
-    return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n");
-}
-
-function jsonStr(value: unknown) {
-    return esc(JSON.stringify(value));
-}
-
-export function generateCypher(data: DomainDef) {
-    const nodes: string[] = [];
-    const edges: string[] = [];
-
-    // -- Domain node --
-    const domainMeta = data.metadata
-        ? `,\n            d.metadata = '${jsonStr(data.metadata)}'`
-        : "";
-    nodes.push(
-        `MERGE (d:Domain {name: '${esc(data.name)}'})
-        SET d.description = '${esc(data.description)}'${domainMeta}`,
-    );
-
-    // -- 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(", ")}]`
-                : "";
-        const conceptMeta = c.metadata ? `, c.metadata = '${jsonStr(c.metadata)}'` : "";
-
-        nodes.push(
-            `MERGE (c:Concept {name: '${esc(c.name)}'})
-            SET c.description = '${esc(c.description)}'${aliasClause}${conceptMeta}`,
-        );
-
-        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)}'})
-                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)}'})
-                MATCH (t:Concept {name: '${esc(c.name)}'})
-                MERGE (r)-[:GOVERNS]->(t)`,
-            );
-        });
-    }
-
-    // -- Endpoint nodes --
-    for (const ep of data.endpoints ?? []) {
-        const endpointMeta = ep.metadata
-            ? `,\n                e.metadata = '${jsonStr(ep.metadata)}'`
-            : "";
-        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)}',
-                e.body = '${jsonStr(ep.body)}',
-                e.response = '${jsonStr(ep.response)}',
-                e.propertiesDescriptions = '${jsonStr(ep.propertiesDescriptions)}',
-                e.successStatus = ${ep.successStatus},
-                e.errorStatuses = [${ep.errorStatuses.join(", ")}]${endpointMeta}`,
-        );
-
-        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)}'})
-                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)}'` : "";
-
-            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)}'})
-                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}'})
-                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 ?? []) {
-        const serviceMeta = svc.metadata
-            ? `,\n            s.metadata = '${jsonStr(svc.metadata)}'`
-            : "";
-        nodes.push(
-            `MERGE (s:Service {builtInId: '${esc(svc.builtInId)}'})
-            SET s.name = '${esc(svc.name)}',
-            s.description = '${esc(svc.description)}'${serviceMeta}`,
-        );
-
-        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)}'})
-                MATCH (t:Service {builtInId: '${esc(svc.builtInId)}'})
-                MERGE (r)-[:GOVERNS]->(t)`,
-            );
-        });
-    }
-
-    // -- Rule nodes --
-    for (const rule of data.rules ?? []) {
-        const ruleMeta = rule.metadata
-            ? `,\n            r.metadata = '${jsonStr(rule.metadata)}'`
-            : "";
-        nodes.push(
-            `MERGE (r:Rule {name: '${esc(rule.name)}'})
-            SET r.description = '${esc(rule.description)}'${ruleMeta}`,
-        );
-    }
-
-    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"
-    );
-}

package/src/graph/index.ts

@@ -1,47 +0,0 @@
-// Types
-export type {
-    EndpointScalarType,
-    EndpointProperty,
-    ResponseKind,
-    AutoGenerated,
-    ConceptDef,
-    EndpointDef,
-    EndpointInput,
-    ServiceDef,
-    RuleDef,
-    DomainDef,
-} from "./types.ts";
-
-// Helpers
-export {
-    defineConcept,
-    defineRule,
-    defineService,
-    defineDomain,
-    defineEndpoint,
-} from "./helpers.ts";
-
-// Cypher generation
-export type { GeneratedCypher } from "./generate-cypher.ts";
-export { generateCypher, toCypherScript } from "./generate-cypher.ts";
-
-// Validation
-export { validateDomain } from "./validate.ts";
-
-// Neo4j client
-export type { Neo4jConfig, Neo4jClient } from "./neo4j.ts";
-export { createNeo4jClient } from "./neo4j.ts";
-
-// Seed orchestrator
-export type { EmbeddingConfig, SeedGraphConfig } from "./seed.ts";
-export { seedGraph } from "./seed.ts";
-
-// Graph resolver
-export type {
-    RerankerConfig,
-    ResolverConfig,
-    ResolvedEndpoint,
-    ResolvedService,
-    ResolvedContext,
-} from "./resolver.ts";
-export { resolveFromGraph } from "./resolver.ts";