@m6d/cortex-server 1.0.0

package/dist/src/db/schema.d.ts

@@ -0,0 +1,345 @@
+import type { UIMessage } from "ai";
+export declare const aiSchema: import("drizzle-orm/mssql-core").MsSqlSchema<"ai">;
+export declare const threads: import("drizzle-orm/mssql-core").MsSqlTableWithColumns<{
+    name: "threads";
+    schema: "ai";
+    columns: {
+        createdAt: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "threads";
+            dataType: "object date";
+            data: Date;
+            driverParam: string | Date;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        updatedAt: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "threads";
+            dataType: "object date";
+            data: Date;
+            driverParam: string | Date;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        id: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "threads";
+            dataType: "custom";
+            data: string;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        userId: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "threads";
+            dataType: "custom";
+            data: string;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        agentId: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "threads";
+            dataType: "string";
+            data: string;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        title: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "threads";
+            dataType: "string";
+            data: string;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        session: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "threads";
+            dataType: "object json";
+            data: Record<string, unknown>;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "mssql";
+}>;
+export declare const messages: import("drizzle-orm/mssql-core").MsSqlTableWithColumns<{
+    name: "messages";
+    schema: "ai";
+    columns: {
+        createdAt: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "messages";
+            dataType: "object date";
+            data: Date;
+            driverParam: string | Date;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        updatedAt: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "messages";
+            dataType: "object date";
+            data: Date;
+            driverParam: string | Date;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        id: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "messages";
+            dataType: "string";
+            data: string;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        threadId: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "messages";
+            dataType: "custom";
+            data: string;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        text: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "messages";
+            dataType: "string";
+            data: string;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        content: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "messages";
+            dataType: "object json";
+            data: UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        role: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "messages";
+            dataType: "string enum";
+            data: "system" | "user" | "assistant" | "tool";
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["system", "user", "assistant", "tool"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "mssql";
+}>;
+export declare const capturedFiles: import("drizzle-orm/mssql-core").MsSqlTableWithColumns<{
+    name: "captured_files";
+    schema: "ai";
+    columns: {
+        id: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "captured_files";
+            dataType: "custom";
+            data: string;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        name: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "captured_files";
+            dataType: "string";
+            data: string;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        userId: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "captured_files";
+            dataType: "custom";
+            data: string;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        agentGeneratedId: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "captured_files";
+            dataType: "string";
+            data: string;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        messageId: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "captured_files";
+            dataType: "string";
+            data: string;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        toolPart: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "captured_files";
+            dataType: "object json";
+            data: {
+                type: `tool-${string}`;
+            } & import("ai").UIToolInvocation<import("ai").UITool>;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "mssql";
+}>;

package/dist/src/factory.d.ts

@@ -0,0 +1,17 @@
+import { Hono } from "hono";
+import { websocket } from "hono/bun";
+import type { CortexConfig } from "./config.ts";
+import type { AppEnv } from "./types.ts";
+export type CortexInstance = {
+    serve(): Promise<{
+        app: Hono<AppEnv>;
+        fetch: Hono<AppEnv>["fetch"];
+        websocket: typeof websocket;
+    }>;
+    seedGraph(): Promise<void>;
+    extractEndpoints(options: {
+        domainsDir: string;
+        write?: boolean;
+    }): Promise<void>;
+};
+export declare function createCortex(config: CortexConfig): CortexInstance;

package/dist/src/graph/generate-cypher.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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[];
+};
+export declare function generateCypher(data: DomainDef): {
+    nodes: string[];
+    edges: string[];
+};
+export declare function toCypherScript(data: DomainDef): string;

package/dist/src/graph/helpers.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Helper functions for building knowledge graph seed data.
+ */
+import type { ConceptDef, DomainDef, EndpointDef, EndpointInput, RuleDef, ServiceDef } from "./types.ts";
+export declare function defineConcept(def: Omit<ConceptDef, "__brand">): {
+    name: string;
+    description: string;
+    aliases?: string[] | undefined;
+    parentConcept?: ConceptDef | undefined;
+    governedBy?: RuleDef[] | undefined;
+    __brand: "concept";
+};
+export declare function defineRule(def: Omit<RuleDef, "__brand">): {
+    name: string;
+    description: string;
+    __brand: "rule";
+};
+export declare function defineService(def: Omit<ServiceDef, "__brand">): {
+    name: string;
+    description: string;
+    governedBy?: RuleDef[] | undefined;
+    builtInId: string;
+    belongsTo: ConceptDef;
+    __brand: "service";
+};
+export declare function defineDomain(def: Omit<DomainDef, "__brand">): {
+    name: string;
+    description: string;
+    concepts?: ConceptDef[] | undefined;
+    endpoints?: EndpointDef[] | undefined;
+    services?: ServiceDef[] | undefined;
+    rules?: RuleDef[] | undefined;
+    __brand: "domain";
+};
+export declare function defineEndpoint(input: EndpointInput): {
+    __brand: "endpoint";
+    name: string;
+    description: string;
+    path: string;
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    propertiesDescriptions: Record<string, string>;
+    params: import("./types.ts").EndpointProperty[];
+    body: import("./types.ts").EndpointProperty[];
+    response: import("./types.ts").EndpointProperty[];
+    successStatus: number;
+    errorStatuses: number[];
+    responseKind: import("./types.ts").ResponseKind;
+    queries: ConceptDef[] | undefined;
+    mutates: ConceptDef[] | undefined;
+    returns: {
+        concept: ConceptDef;
+        field?: string;
+    }[] | undefined;
+    dependsOn: {
+        endpoint: EndpointDef;
+        paramName: string;
+        fromField: string;
+    }[] | undefined;
+    governedBy: RuleDef[] | undefined;
+};

package/dist/src/graph/index.d.ts

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

package/dist/src/graph/neo4j.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Configurable Neo4j HTTP client.
+ *
+ * Replaces the hardcoded process.env-based client from packages/sample-backend.
+ * All configuration is passed explicitly — no environment variables are read.
+ */
+import type { EmbeddingModel } from "ai";
+export type Neo4jConfig = {
+    url: string;
+    user: string;
+    password: string;
+};
+export type Neo4jClient = {
+    query(cypher: string, parameters?: Record<string, unknown>): Promise<string>;
+};
+export declare function createNeo4jClient(config: Neo4jConfig, embeddingModel?: EmbeddingModel): {
+    query: (cypher: string, parameters?: Record<string, unknown>) => Promise<string>;
+};

package/dist/src/graph/resolver.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Pre-resolves relevant API endpoints from the Neo4j knowledge graph
+ * using vector similarity search on concept descriptions.
+ *
+ * All configuration is passed explicitly — no hardcoded model references
+ * or environment variables.
+ */
+import type { EmbeddingModel } from "ai";
+import type { Neo4jClient } from "./neo4j.ts";
+export type RerankerConfig = {
+    url: string;
+    apiKey: string;
+};
+export type ResolverConfig = {
+    neo4j: Neo4jClient;
+    embeddingModel: EmbeddingModel;
+    reranker?: RerankerConfig;
+};
+type EndpointDependency = {
+    depPath: string;
+    depMethod: string;
+    paramName: string;
+    fromField: string;
+};
+type EndpointRelation = "read" | "write";
+export type ResolvedEndpoint = {
+    concept: string;
+    relation: EndpointRelation;
+    name: string;
+    path: string;
+    method: string;
+    params: string;
+    body: string;
+    response: string;
+    dependencies: EndpointDependency[];
+    rules: string[];
+};
+export type ResolvedService = {
+    concept: string;
+    serviceName: string;
+    builtInId: string;
+    description: string;
+    rules: string[];
+};
+export type ResolvedContext = {
+    readEndpoints: ResolvedEndpoint[];
+    writeEndpoints: ResolvedEndpoint[];
+    services: ResolvedService[];
+};
+export declare function resolveFromGraph(prompt: string, config: ResolverConfig): Promise<ResolvedContext>;
+export {};

package/dist/src/graph/seed.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Seed orchestrator for the knowledge graph.
+ *
+ * Validates domains, generates Cypher, executes against Neo4j,
+ * and generates concept embeddings. All configuration is passed
+ * explicitly — no environment variables or Convex dependencies.
+ */
+import type { EmbeddingModel } from "ai";
+import type { Neo4jConfig } from "./neo4j.ts";
+import type { DomainDef } from "./types.ts";
+export type EmbeddingConfig = {
+    model: EmbeddingModel;
+    dimension: number;
+};
+export type SeedGraphConfig = {
+    neo4j: Neo4jConfig;
+    embedding: EmbeddingConfig;
+};
+export declare function seedGraph(config: SeedGraphConfig, domains: Record<string, DomainDef>): Promise<void>;

package/dist/src/graph/types.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Declarative types for knowledge graph seed data.
+ *
+ * This is the v2 schema:
+ * - Endpoints use params/body/response EndpointProperty arrays.
+ * - Source/default mappings are intentionally removed.
+ * - Services are concept associations (no hardcoded endpoint steps).
+ */
+export type EndpointScalarType = "uuid" | "number" | "date" | "datetime" | "string" | "boolean" | "any" | "object";
+export type EndpointProperty = {
+    readonly name: string;
+    readonly required: boolean;
+    readonly type: EndpointScalarType | string;
+    readonly isArray?: boolean;
+    readonly properties?: readonly EndpointProperty[];
+    readonly description?: string;
+};
+export type ResponseKind = "object" | "array" | "paginated" | "file" | "none";
+export type AutoGenerated = {
+    readonly params: readonly EndpointProperty[];
+    readonly body: readonly EndpointProperty[];
+    readonly response: readonly EndpointProperty[];
+    readonly successStatus: number;
+    readonly errorStatuses: readonly number[];
+    readonly responseKind?: ResponseKind;
+};
+export type ConceptDef = {
+    readonly __brand: "concept";
+    name: string;
+    description: string;
+    aliases?: string[];
+    parentConcept?: ConceptDef;
+    governedBy?: RuleDef[];
+};
+export type EndpointDef = {
+    readonly __brand: "endpoint";
+    name: string;
+    description: string;
+    path: string;
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    propertiesDescriptions: Record<string, string>;
+    params: EndpointProperty[];
+    body: EndpointProperty[];
+    response: EndpointProperty[];
+    successStatus: number;
+    errorStatuses: number[];
+    responseKind: ResponseKind;
+    queries?: ConceptDef[];
+    mutates?: ConceptDef[];
+    returns?: {
+        concept: ConceptDef;
+        field?: string;
+    }[];
+    dependsOn?: {
+        endpoint: EndpointDef;
+        paramName: string;
+        fromField: string;
+    }[];
+    governedBy?: RuleDef[];
+};
+export type EndpointInput = {
+    name: string;
+    path: string;
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    description?: string;
+    autoGenerated?: AutoGenerated;
+    propertiesDescriptions?: Record<string, string>;
+    queries?: ConceptDef[];
+    mutates?: ConceptDef[];
+    paramDescriptions?: Partial<Record<string, string>>;
+    responseDescriptions?: Partial<Record<string, string>>;
+    returns?: {
+        concept: ConceptDef;
+        field?: string;
+    }[];
+    dependsOn?: {
+        endpoint: EndpointDef;
+        paramName: string;
+        fromField: string;
+    }[];
+    governedBy?: RuleDef[];
+};
+export type ServiceDef = {
+    readonly __brand: "service";
+    name: string;
+    description: string;
+    builtInId: string;
+    belongsTo: ConceptDef;
+    governedBy?: RuleDef[];
+};
+export type RuleDef = {
+    readonly __brand: "rule";
+    name: string;
+    description: string;
+};
+export type DomainDef = {
+    readonly __brand: "domain";
+    name: string;
+    description: string;
+    concepts?: ConceptDef[];
+    endpoints?: EndpointDef[];
+    services?: ServiceDef[];
+    rules?: RuleDef[];
+};

package/dist/src/graph/validate.d.ts

@@ -0,0 +1,2 @@
+import type { DomainDef } from "./types.ts";
+export declare function validateDomain(data: DomainDef): string[];

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+export type { CortexConfig, CortexAgentDefinition, KnowledgeConfig, DatabaseConfig, StorageConfig, } from "./config";
+export type { Thread, AppEnv } from "./types";
+export type { CortexInstance } from "./factory";
+export { createCortex } from "./factory";
+export { captureFilesTool } from "./ai/tools/capture-files.tool";
+export { createQueryGraphTool } from "./ai/tools/query-graph.tool";
+export { createCallEndpointTool } from "./ai/tools/call-endpoint.tool";
+export { createExecuteCodeTool } from "./ai/tools/execute-code.tool";
+export * from "./graph/index";
+export type { WsEvent, ThreadTitleUpdatedEvent } from "./ws/index";

package/dist/src/routes/chat.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from "hono";
+import type { CortexAppEnv } from "../types.ts";
+export declare function createChatRoutes(): Hono<CortexAppEnv, import("hono/types").BlankSchema, "/">;

package/dist/src/routes/files.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from "hono";
+import type { CortexAppEnv } from "../types.ts";
+export declare function createFileRoutes(): Hono<CortexAppEnv, import("hono/types").BlankSchema, "/">;

package/dist/src/routes/index.d.ts

@@ -0,0 +1,4 @@
+export { createThreadRoutes } from "./threads.ts";
+export { createChatRoutes } from "./chat.ts";
+export { createFileRoutes } from "./files.ts";
+export { createWsRoute } from "./ws.ts";