ont-run 0.0.1

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

@@ -0,0 +1,90 @@
+/**
+ * A field that references another function for its options
+ */
+export interface FieldReference {
+    /** Path to the field in the schema, e.g., "status" or "filters.country" */
+    path: string;
+    /** Name of the function that provides options for this field */
+    functionName: string;
+}
+/**
+ * Snapshot of a function's shape (what matters for security review)
+ */
+export interface FunctionShape {
+    /** Description of the function */
+    description: string;
+    /** Sorted list of access groups */
+    access: string[];
+    /** Sorted list of entities this function relates to */
+    entities: string[];
+    /** JSON Schema representation of the input schema */
+    inputsSchema: Record<string, unknown>;
+    /** JSON Schema representation of the output schema */
+    outputsSchema?: Record<string, unknown>;
+    /** Fields that reference other functions for their options */
+    fieldReferences?: FieldReference[];
+}
+/**
+ * Complete snapshot of the ontology
+ */
+export interface OntologySnapshot {
+    /** Name of the ontology */
+    name: string;
+    /** Sorted list of access group names */
+    accessGroups: string[];
+    /** Sorted list of entity names */
+    entities?: string[];
+    /** Function shapes keyed by name */
+    functions: Record<string, FunctionShape>;
+}
+/**
+ * The ont.lock file structure
+ */
+export interface Lockfile {
+    /** Lockfile format version */
+    version: number;
+    /** SHA256 hash of the ontology */
+    hash: string;
+    /** When this was approved */
+    approvedAt: string;
+    /** The full ontology snapshot */
+    ontology: OntologySnapshot;
+}
+/**
+ * A single change in a function
+ */
+export interface FunctionChange {
+    name: string;
+    type: "added" | "removed" | "modified";
+    oldAccess?: string[];
+    newAccess?: string[];
+    oldDescription?: string;
+    newDescription?: string;
+    inputsChanged?: boolean;
+    outputsChanged?: boolean;
+    entitiesChanged?: boolean;
+    oldEntities?: string[];
+    newEntities?: string[];
+    fieldReferencesChanged?: boolean;
+}
+/**
+ * Diff between old and new ontology
+ */
+export interface OntologyDiff {
+    /** Whether there are any changes */
+    hasChanges: boolean;
+    /** Added access groups */
+    addedGroups: string[];
+    /** Removed access groups */
+    removedGroups: string[];
+    /** Added entities */
+    addedEntities: string[];
+    /** Removed entities */
+    removedEntities: string[];
+    /** Function changes */
+    functions: FunctionChange[];
+    /** The new ontology (for writing to lockfile on approve) */
+    newOntology: OntologySnapshot;
+    /** The new hash */
+    newHash: string;
+}

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

@@ -0,0 +1,28 @@
+type AnyHono = {
+    fetch: (request: Request, ...args: any[]) => Response | Promise<Response>;
+};
+/**
+ * Check if we're running in Bun
+ */
+export declare function isBun(): boolean;
+/**
+ * Check if we're running in Node.js
+ */
+export declare function isNode(): boolean;
+/**
+ * Get the current runtime name
+ */
+export declare function getRuntime(): "bun" | "node" | "unknown";
+export interface ServerHandle {
+    port: number;
+    stop: () => void | Promise<void>;
+}
+/**
+ * Start an HTTP server using the appropriate runtime
+ */
+export declare function serve(app: AnyHono, port: number): Promise<ServerHandle>;
+/**
+ * Find an available port starting from the given port
+ */
+export declare function findAvailablePort(startPort?: number): Promise<number>;
+export {};

package/dist/src/server/api/index.d.ts

@@ -0,0 +1,20 @@
+import { Hono } from "hono";
+import type { OntologyConfig } from "../../config/types.js";
+import { type OntologyVariables } from "./middleware.js";
+export interface ApiServerOptions {
+    /** The ontology configuration */
+    config: OntologyConfig;
+    /** Directory containing the ontology.config.ts (for resolving resolver paths) */
+    configDir: string;
+    /** Environment to use (e.g., 'dev', 'prod') */
+    env: string;
+    /** Enable CORS (default: true) */
+    cors?: boolean;
+}
+/**
+ * Create the Hono API app from an OntologyConfig
+ */
+export declare function createApiApp(options: ApiServerOptions): Hono<{
+    Variables: OntologyVariables;
+}>;
+export { getFunctionsInfo } from "./router.js";

package/dist/src/server/api/middleware.d.ts

@@ -0,0 +1,34 @@
+import type { OntologyConfig, ResolverContext, EnvironmentConfig } from "../../config/types.js";
+/**
+ * Context variables added by middleware
+ */
+export interface OntologyVariables {
+    resolverContext: ResolverContext;
+    accessGroups: string[];
+}
+/**
+ * Create auth middleware that calls the user's auth function
+ * and sets the access groups on the context
+ */
+export declare function createAuthMiddleware(config: OntologyConfig): import("hono").MiddlewareHandler<{
+    Variables: OntologyVariables;
+}, string, {}, Response>;
+/**
+ * Create context middleware that builds the ResolverContext
+ */
+export declare function createContextMiddleware(env: string, envConfig: EnvironmentConfig): import("hono").MiddlewareHandler<{
+    Variables: OntologyVariables;
+}, string, {}, Response>;
+/**
+ * Create access control middleware for a specific function
+ */
+export declare function createAccessControlMiddleware(requiredAccess: string[]): import("hono").MiddlewareHandler<{
+    Variables: OntologyVariables;
+}, string, {}, Response>;
+/**
+ * Error handling middleware
+ */
+export declare function errorHandler(): import("hono").MiddlewareHandler<any, any, {}, Response | (Response & import("hono").TypedResponse<{
+    error: string;
+    message: string;
+}, 401 | 100 | 102 | 103 | 200 | 201 | 202 | 203 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 305 | 306 | 307 | 308 | 400 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | -1, "json">)>;

package/dist/src/server/api/router.d.ts

@@ -0,0 +1,18 @@
+import { Hono } from "hono";
+import type { OntologyConfig } from "../../config/types.js";
+import { type OntologyVariables } from "./middleware.js";
+/**
+ * Create API routes from function definitions
+ */
+export declare function createApiRoutes(config: OntologyConfig, configDir: string): Hono<{
+    Variables: OntologyVariables;
+}>;
+/**
+ * Get info about all available functions (for introspection)
+ */
+export declare function getFunctionsInfo(config: OntologyConfig): Array<{
+    name: string;
+    description: string;
+    access: string[];
+    path: string;
+}>;

package/dist/src/server/mcp/index.d.ts

@@ -0,0 +1,23 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import type { OntologyConfig } from "../../config/types.js";
+export interface McpServerOptions {
+    /** The ontology configuration */
+    config: OntologyConfig;
+    /** Directory containing the ontology.config.ts */
+    configDir: string;
+    /** Environment to use */
+    env: string;
+    /** Port for the MCP HTTP server */
+    port?: number;
+}
+/**
+ * Create the MCP server instance with per-request authentication
+ */
+export declare function createMcpServer(options: McpServerOptions): Server;
+/**
+ * Start the MCP server as an HTTP server with Streamable HTTP transport
+ */
+export declare function startMcpServer(options: McpServerOptions): Promise<{
+    port: number;
+}>;
+export { generateMcpTools, filterToolsByAccess } from "./tools.js";

package/dist/src/server/mcp/tools.d.ts

@@ -0,0 +1,35 @@
+import type { OntologyConfig, EnvironmentConfig } from "../../config/types.js";
+import { type Logger } from "../resolver.js";
+/**
+ * Field reference info for MCP tools
+ */
+export interface McpFieldReference {
+    /** Path to the field in the schema */
+    path: string;
+    /** Name of the function that provides options */
+    functionName: string;
+}
+/**
+ * MCP Tool definition
+ */
+export interface McpTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    access: string[];
+    entities: string[];
+    fieldReferences?: McpFieldReference[];
+}
+/**
+ * Generate MCP tool definitions from ontology config
+ */
+export declare function generateMcpTools(config: OntologyConfig): McpTool[];
+/**
+ * Filter tools by access groups
+ */
+export declare function filterToolsByAccess(tools: McpTool[], accessGroups: string[]): McpTool[];
+/**
+ * Create a tool executor function that accepts per-request access groups
+ */
+export declare function createToolExecutor(config: OntologyConfig, configDir: string, env: string, envConfig: EnvironmentConfig, logger: Logger): (toolName: string, args: unknown, accessGroups: string[]) => Promise<unknown>;

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

@@ -0,0 +1,30 @@
+import type { ResolverFunction, OntologyConfig } from "../config/types.js";
+/**
+ * Load a resolver from a file path.
+ * The path is relative to the config file location.
+ *
+ * @param resolverPath - Path to the resolver file (relative to configDir)
+ * @param configDir - Directory containing the ontology.config.ts
+ */
+export declare function loadResolver(resolverPath: string, configDir: string): Promise<ResolverFunction>;
+/**
+ * Clear the resolver cache (useful for hot reloading)
+ */
+export declare function clearResolverCache(): void;
+/**
+ * Check which resolvers are missing and return their paths
+ */
+export declare function findMissingResolvers(config: OntologyConfig, configDir: string): string[];
+/**
+ * Logger type returned by createLogger
+ */
+export type Logger = ReturnType<typeof createLogger>;
+/**
+ * Create a logger for a resolver context
+ */
+export declare function createLogger(debug?: boolean): {
+    info: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+    debug: (message: string, ...args: unknown[]) => void;
+};

package/dist/src/server/start.d.ts

@@ -0,0 +1,37 @@
+import { type ServerHandle } from "../runtime/index.js";
+export interface StartOntOptions {
+    /** Port for API server (default: 3000) */
+    port?: number;
+    /** Port for MCP server (default: 3001) */
+    mcpPort?: number;
+    /** Environment to use (default: 'dev') */
+    env?: string;
+    /** Mode: 'development' warns on lockfile issues, 'production' fails. Auto-detected from NODE_ENV if not set. */
+    mode?: "development" | "production";
+    /** Set to true to only start the API server */
+    apiOnly?: boolean;
+    /** Set to true to only start the MCP server */
+    mcpOnly?: boolean;
+}
+export interface StartOntResult {
+    api?: ServerHandle;
+    mcp?: {
+        port: number;
+    };
+}
+/**
+ * Start the ont API and MCP servers.
+ *
+ * Automatically discovers ontology.config.ts and handles lockfile validation.
+ *
+ * @example
+ * ```ts
+ * import { startOnt } from 'ont-run';
+ *
+ * await startOnt({
+ *   port: 3000,
+ *   mcpPort: 3001,
+ * });
+ * ```
+ */
+export declare function startOnt(options?: StartOntOptions): Promise<StartOntResult>;

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "ont-run",
+  "version": "0.0.1",
+  "description": "Ontology-enforced API framework for AI coding agents",
+  "type": "module",
+  "bin": {
+    "ont": "./dist/bin/ont.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "bin"
+  ],
+  "scripts": {
+    "dev": "bun run bin/ont.ts",
+    "build": "bun build ./src/index.ts --outdir ./dist --target node",
+    "build:cli": "bun build ./bin/ont.ts --outfile ./dist/bin/ont.js --target node --external @modelcontextprotocol/sdk",
+    "build:types": "tsc --declaration --emitDeclarationOnly",
+    "prepublishOnly": "bun run build && bun run build:cli && bun run build:types",
+    "docs": "cd docs && bun run dev",
+    "docs:build": "cd docs && bun run build",
+    "docs:preview": "cd docs && bun run preview"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.19.8",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "citty": "^0.1.6",
+    "consola": "^3.2.0",
+    "hono": "^4.6.0",
+    "open": "^10.0.0",
+    "zod": "^3.24.0",
+    "zod-to-json-schema": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.5.0"
+  },
+  "peerDependencies": {
+    "bun": ">=1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "bun": {
+      "optional": true
+    }
+  },
+  "keywords": [
+    "api",
+    "framework",
+    "access-control",
+    "ai-agents",
+    "hono",
+    "zod",
+    "typescript"
+  ],
+  "license": "MIT"
+}