ont-run 0.0.3 → 0.0.5

package/dist/index.js

@@ -4017,8 +4017,9 @@ function hasUserContextMetadata(schema) {
 }
 function getUserContextFields(schema) {
   const fields = [];
-  if (schema instanceof exports_external.ZodObject) {
-    const shape = schema.shape;
+  const def = schema._def;
+  if (def?.typeName === "ZodObject" && typeof def.shape === "function") {
+    const shape = def.shape();
     for (const [key, value] of Object.entries(shape)) {
       if (hasUserContextMetadata(value)) {
         fields.push(key);
@@ -13488,7 +13489,7 @@ var FunctionDefinitionSchema = exports_external.object({
   outputs: exports_external.custom(isZodSchema, {
     message: "outputs must be a Zod schema"
   }).optional(),
-  resolver: exports_external.string()
+  resolver: exports_external.function()
 });
 var AuthFunctionSchema = exports_external.function().args(exports_external.custom()).returns(exports_external.union([exports_external.array(exports_external.string()), exports_external.promise(exports_external.array(exports_external.string()))]));
 var OntologyConfigSchema = exports_external.object({
@@ -13605,6 +13606,13 @@ function defineOntology(config) {
   validateFieldFromReferences(parsed);
   return config;
 }
+function defineFunction(config) {
+  return {
+    ...config,
+    access: [...config.access],
+    entities: [...config.entities]
+  };
+}
 
 // src/index.ts
 init_categorical();
@@ -16300,39 +16308,6 @@ var Factory = class {
 var createMiddleware = (middleware) => middleware;
 
 // src/server/resolver.ts
-import { join as join3, isAbsolute } from "path";
-import { existsSync as existsSync3 } from "fs";
-var resolverCache = new Map;
-async function loadResolver(resolverPath, configDir) {
-  const fullPath = isAbsolute(resolverPath) ? resolverPath : join3(configDir, resolverPath);
-  if (resolverCache.has(fullPath)) {
-    return resolverCache.get(fullPath);
-  }
-  try {
-    const module = await import(fullPath);
-    const resolver = module.default;
-    if (typeof resolver !== "function") {
-      throw new Error(`Resolver at ${resolverPath} must export a default function`);
-    }
-    resolverCache.set(fullPath, resolver);
-    return resolver;
-  } catch (error) {
-    if (error.code === "ERR_MODULE_NOT_FOUND") {
-      throw new Error(`Resolver not found: ${resolverPath}`);
-    }
-    throw error;
-  }
-}
-function findMissingResolvers(config, configDir) {
-  const missing = [];
-  for (const [name, fn] of Object.entries(config.functions)) {
-    const fullPath = isAbsolute(fn.resolver) ? fn.resolver : join3(configDir, fn.resolver);
-    if (!existsSync3(fullPath)) {
-      missing.push(fn.resolver);
-    }
-  }
-  return missing;
-}
 function createLogger(debug = false) {
   return {
     info: (message, ...args) => {
@@ -16421,7 +16396,7 @@ function errorHandler2() {
 
 // src/server/api/router.ts
 init_categorical();
-function createApiRoutes(config, configDir) {
+function createApiRoutes(config) {
   const router = new Hono2;
   for (const [name, fn] of Object.entries(config.functions)) {
     const path = `/${name}`;
@@ -16464,8 +16439,7 @@ function createApiRoutes(config, configDir) {
         args = parsed.data;
       }
       try {
-        const resolver = await loadResolver(fn.resolver, configDir);
-        const result = await resolver(resolverContext, args);
+        const result = await fn.resolver(resolverContext, args);
         return c3.json(result);
       } catch (error) {
         console.error(`Error in resolver ${name}:`, error);
@@ -16489,18 +16463,11 @@ function getFunctionsInfo(config) {
 
 // src/server/api/index.ts
 function createApiApp(options) {
-  const { config, configDir, env: env2, cors: enableCors = true } = options;
+  const { config, env: env2, cors: enableCors = true } = options;
   const envConfig = config.environments[env2];
   if (!envConfig) {
     throw new Error(`Unknown environment "${env2}". Available: ${Object.keys(config.environments).join(", ")}`);
   }
-  const missingResolvers = findMissingResolvers(config, configDir);
-  if (missingResolvers.length > 0) {
-    consola.warn(`Missing resolvers (${missingResolvers.length}):`);
-    for (const resolver of missingResolvers) {
-      consola.warn(`  - ${resolver}`);
-    }
-  }
   const app = new Hono2;
   if (enableCors) {
     app.use("*", cors());
@@ -16526,7 +16493,7 @@ function createApiApp(options) {
       functions: accessibleFunctions
     });
   });
-  const apiRoutes = createApiRoutes(config, configDir);
+  const apiRoutes = createApiRoutes(config);
   app.route("/api", apiRoutes);
   return app;
 }
@@ -23016,7 +22983,7 @@ function generateMcpTools(config2) {
 function filterToolsByAccess(tools, accessGroups) {
   return tools.filter((tool) => tool.access.some((group) => accessGroups.includes(group)));
 }
-function createToolExecutor(config2, configDir, env2, envConfig, logger) {
+function createToolExecutor(config2, env2, envConfig, logger) {
   const userContextFieldsCache = new Map;
   for (const [name, fn] of Object.entries(config2.functions)) {
     userContextFieldsCache.set(name, getUserContextFields(fn.inputs));
@@ -23048,8 +23015,7 @@ function createToolExecutor(config2, configDir, env2, envConfig, logger) {
       logger,
       accessGroups: authResult.groups
     };
-    const resolver = await loadResolver(fn.resolver, configDir);
-    return resolver(resolverContext, parsed.data);
+    return fn.resolver(resolverContext, parsed.data);
   };
 }
 
@@ -23102,14 +23068,14 @@ function getAuthResult(authInfo) {
   return authInfo.extra.authResult;
 }
 function createMcpServer(options) {
-  const { config: config2, configDir, env: env2 } = options;
+  const { config: config2, env: env2 } = options;
   const envConfig = config2.environments[env2];
   if (!envConfig) {
     throw new Error(`Unknown environment "${env2}". Available: ${Object.keys(config2.environments).join(", ")}`);
   }
   const logger = createLogger(envConfig.debug);
   const allTools = generateMcpTools(config2);
-  const executeToolWithAccess = createToolExecutor(config2, configDir, env2, envConfig, logger);
+  const executeToolWithAccess = createToolExecutor(config2, env2, envConfig, logger);
   const server = new Server({
     name: config2.name,
     version: "1.0.0"
@@ -23266,7 +23232,6 @@ Run \`bun run review\` to approve the changes.`;
   if (!mcpOnly) {
     const api2 = createApiApp({
       config: config2,
-      configDir,
       env: env2
     });
     const server = await serve2(api2, port);
@@ -23285,7 +23250,6 @@ Run \`bun run review\` to approve the changes.`;
   if (!apiOnly) {
     const mcpServer = await startMcpServer({
       config: config2,
-      configDir,
       env: env2,
       port: mcpPort
     });
@@ -23304,5 +23268,6 @@ export {
   userContext,
   startOnt,
   fieldFrom,
-  defineOntology
+  defineOntology,
+  defineFunction
 };

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

@@ -6,6 +6,8 @@ export interface BrowserServerOptions {
     diff?: OntologyDiff | null;
     /** Directory to write the lockfile to on approval */
     configDir?: string;
+    /** Path to the ontology.config.ts file */
+    configPath?: string;
     port?: number;
     openBrowser?: boolean;
 }

package/dist/src/browser/transform.d.ts

@@ -11,7 +11,6 @@ export interface GraphNode {
     metadata: {
         inputs?: Record<string, unknown>;
         outputs?: Record<string, unknown>;
-        resolver?: string;
         functionCount?: number;
         usesUserContext?: boolean;
     };
@@ -31,6 +30,7 @@ export interface GraphData {
         totalFunctions: number;
         totalEntities: number;
         totalAccessGroups: number;
+        totalUserContextFunctions: number;
     };
 }
 export interface EnhancedGraphNode extends GraphNode {

package/dist/src/config/categorical.d.ts

@@ -131,5 +131,8 @@ export declare function userContext<T extends z.ZodType>(schema: T): UserContext
 export declare function hasUserContextMetadata(schema: unknown): schema is UserContextSchema<z.ZodType>;
 /**
  * Get all userContext field names from a Zod object schema
+ *
+ * Note: Uses _def.typeName check instead of instanceof to work across
+ * module boundaries in bundled CLI.
  */
 export declare function getUserContextFields(schema: z.ZodType): string[];

package/dist/src/config/define.d.ts

@@ -1,4 +1,5 @@
-import type { OntologyConfig, FunctionDefinition, AccessGroupConfig, EnvironmentConfig, EntityDefinition, AuthFunction } from "./types.js";
+import { z } from "zod";
+import type { OntologyConfig, FunctionDefinition, AccessGroupConfig, EnvironmentConfig, EntityDefinition, AuthFunction, ResolverFunction } from "./types.js";
 /**
  * Define an Ontology configuration with full type inference.
  *
@@ -6,6 +7,7 @@ import type { OntologyConfig, FunctionDefinition, AccessGroupConfig, Environment
  * ```ts
  * import { defineOntology, fieldFrom } from 'ont-run';
  * import { z } from 'zod';
+ * import { getUser } from './resolvers/getUser.js';
  *
  * export default defineOntology({
  *   name: 'my-api',
@@ -30,7 +32,7 @@ import type { OntologyConfig, FunctionDefinition, AccessGroupConfig, Environment
  *       access: ['public', 'admin'],
  *       entities: ['User'],
  *       inputs: z.object({ id: z.string() }),
- *       resolver: './resolvers/getUser.ts',
+ *       resolver: getUser,  // Direct function reference for type safety
  *     },
  *   },
  * });
@@ -44,3 +46,36 @@ export declare function defineOntology<TGroups extends string, TEntities extends
     entities?: Record<TEntities, EntityDefinition>;
     functions: TFunctions;
 }): OntologyConfig<TGroups, TEntities, TFunctions>;
+/**
+ * Define a function with full type inference for resolver type safety.
+ *
+ * This helper ensures that the resolver function's return type matches
+ * the outputs Zod schema at compile time.
+ *
+ * @example
+ * ```ts
+ * import { defineFunction, z } from 'ont-run';
+ * import type { ResolverContext } from 'ont-run';
+ *
+ * const getUser = defineFunction({
+ *   description: 'Get a user by ID',
+ *   access: ['public', 'admin'] as const,
+ *   entities: ['User'] as const,
+ *   inputs: z.object({ id: z.string() }),
+ *   outputs: z.object({ id: z.string(), name: z.string() }),
+ *   resolver: async (ctx, args) => {
+ *     // TypeScript knows args is { id: string }
+ *     // TypeScript enforces return type is { id: string, name: string }
+ *     return { id: args.id, name: 'Example User' };
+ *   },
+ * });
+ * ```
+ */
+export declare function defineFunction<TGroups extends string, TEntities extends string, TInputs extends z.ZodType, TOutputs extends z.ZodType>(config: {
+    description: string;
+    access: readonly TGroups[];
+    entities: readonly TEntities[];
+    inputs: TInputs;
+    outputs?: TOutputs;
+    resolver: ResolverFunction<z.infer<TInputs>, z.infer<TOutputs>>;
+}): FunctionDefinition<TGroups, TEntities, TInputs, TOutputs>;

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

@@ -39,20 +39,20 @@ export declare const FunctionDefinitionSchema: z.ZodObject<{
     entities: z.ZodArray<z.ZodString, "many">;
     inputs: z.ZodType<z.ZodType<any, z.ZodTypeDef, any>, z.ZodTypeDef, z.ZodType<any, z.ZodTypeDef, any>>;
     outputs: z.ZodOptional<z.ZodType<z.ZodType<any, z.ZodTypeDef, any>, z.ZodTypeDef, z.ZodType<any, z.ZodTypeDef, any>>>;
-    resolver: z.ZodString;
+    resolver: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
 }, "strip", z.ZodTypeAny, {
     description: string;
     access: string[];
     entities: string[];
     inputs: z.ZodType<any, z.ZodTypeDef, any>;
-    resolver: string;
+    resolver: (...args: unknown[]) => unknown;
     outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
 }, {
     description: string;
     access: string[];
     entities: string[];
     inputs: z.ZodType<any, z.ZodTypeDef, any>;
-    resolver: string;
+    resolver: (...args: unknown[]) => unknown;
     outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
 }>;
 /**
@@ -92,20 +92,20 @@ export declare const OntologyConfigSchema: z.ZodObject<{
         entities: z.ZodArray<z.ZodString, "many">;
         inputs: z.ZodType<z.ZodType<any, z.ZodTypeDef, any>, z.ZodTypeDef, z.ZodType<any, z.ZodTypeDef, any>>;
         outputs: z.ZodOptional<z.ZodType<z.ZodType<any, z.ZodTypeDef, any>, z.ZodTypeDef, z.ZodType<any, z.ZodTypeDef, any>>>;
-        resolver: z.ZodString;
+        resolver: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
     }, "strip", z.ZodTypeAny, {
         description: string;
         access: string[];
         entities: string[];
         inputs: z.ZodType<any, z.ZodTypeDef, any>;
-        resolver: string;
+        resolver: (...args: unknown[]) => unknown;
         outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
     }, {
         description: string;
         access: string[];
         entities: string[];
         inputs: z.ZodType<any, z.ZodTypeDef, any>;
-        resolver: string;
+        resolver: (...args: unknown[]) => unknown;
         outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
@@ -122,7 +122,7 @@ export declare const OntologyConfigSchema: z.ZodObject<{
         access: string[];
         entities: string[];
         inputs: z.ZodType<any, z.ZodTypeDef, any>;
-        resolver: string;
+        resolver: (...args: unknown[]) => unknown;
         outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
     }>;
     entities?: Record<string, {
@@ -142,7 +142,7 @@ export declare const OntologyConfigSchema: z.ZodObject<{
         access: string[];
         entities: string[];
         inputs: z.ZodType<any, z.ZodTypeDef, any>;
-        resolver: string;
+        resolver: (...args: unknown[]) => unknown;
         outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
     }>;
     entities?: Record<string, {

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

@@ -32,10 +32,32 @@ export interface FieldOption {
     /** Human-readable label for display */
     label: string;
 }
+/**
+ * Context passed to resolvers
+ */
+export interface ResolverContext {
+    /** Current environment name */
+    env: string;
+    /** Environment configuration */
+    envConfig: EnvironmentConfig;
+    /** Logger instance */
+    logger: {
+        info: (message: string, ...args: unknown[]) => void;
+        warn: (message: string, ...args: unknown[]) => void;
+        error: (message: string, ...args: unknown[]) => void;
+        debug: (message: string, ...args: unknown[]) => void;
+    };
+    /** Access groups for the current request */
+    accessGroups: string[];
+}
+/**
+ * Resolver function signature
+ */
+export type ResolverFunction<TArgs = unknown, TResult = unknown> = (ctx: ResolverContext, args: TArgs) => Promise<TResult> | TResult;
 /**
  * Definition of a function in the ontology
  */
-export interface FunctionDefinition<TGroups extends string = string, TEntities extends string = string> {
+export interface FunctionDefinition<TGroups extends string = string, TEntities extends string = string, TInputs extends z.ZodType = z.ZodType<unknown>, TOutputs extends z.ZodType = z.ZodType<unknown>> {
     /** Human-readable description of what this function does */
     description: string;
     /** Which access groups can call this function */
@@ -43,11 +65,11 @@ export interface FunctionDefinition<TGroups extends string = string, TEntities e
     /** Which entities this function relates to (use empty array [] if none) */
     entities: TEntities[];
     /** Zod schema for input validation */
-    inputs: z.ZodType<unknown>;
+    inputs: TInputs;
     /** Zod schema for output validation/documentation */
-    outputs?: z.ZodType<unknown>;
-    /** Path to the resolver file (relative to ontology.config.ts) */
-    resolver: string;
+    outputs?: TOutputs;
+    /** Resolver function that handles this function's logic */
+    resolver: ResolverFunction<z.infer<TInputs>, z.infer<TOutputs>>;
 }
 /**
  * Result returned by the auth function
@@ -82,25 +104,3 @@ export interface OntologyConfig<TGroups extends string = string, TEntities exten
     /** Function definitions */
     functions: TFunctions;
 }
-/**
- * Context passed to resolvers
- */
-export interface ResolverContext {
-    /** Current environment name */
-    env: string;
-    /** Environment configuration */
-    envConfig: EnvironmentConfig;
-    /** Logger instance */
-    logger: {
-        info: (message: string, ...args: unknown[]) => void;
-        warn: (message: string, ...args: unknown[]) => void;
-        error: (message: string, ...args: unknown[]) => void;
-        debug: (message: string, ...args: unknown[]) => void;
-    };
-    /** Access groups for the current request */
-    accessGroups: string[];
-}
-/**
- * Resolver function signature
- */
-export type ResolverFunction<TArgs = unknown, TResult = unknown> = (ctx: ResolverContext, args: TArgs) => Promise<TResult> | TResult;

package/dist/src/index.d.ts

@@ -5,6 +5,7 @@
  * ```ts
  * import { defineOntology, fieldFrom } from 'ont-run';
  * import { z } from 'zod';
+ * import { hello } from './resolvers/hello.js';
  *
  * export default defineOntology({
  *   name: 'my-api',
@@ -23,13 +24,13 @@
  *       access: ['public'],
  *       entities: [],
  *       inputs: z.object({ name: z.string() }),
- *       resolver: './resolvers/hello.ts',
+ *       resolver: hello,  // Direct function reference for type safety
  *     },
  *   },
  * });
  * ```
  */
-export { defineOntology } from "./config/define.js";
+export { defineOntology, defineFunction } from "./config/define.js";
 export { fieldFrom, userContext } from "./config/categorical.js";
 export { startOnt } from "./server/start.js";
 export type { StartOntOptions, StartOntResult } from "./server/start.js";

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

@@ -4,8 +4,6 @@ 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) */

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

@@ -4,7 +4,7 @@ import { type OntologyVariables } from "./middleware.js";
 /**
  * Create API routes from function definitions
  */
-export declare function createApiRoutes(config: OntologyConfig, configDir: string): Hono<{
+export declare function createApiRoutes(config: OntologyConfig): Hono<{
     Variables: OntologyVariables;
 }>;
 /**

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

@@ -3,8 +3,6 @@ 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 */

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

@@ -1,5 +1,5 @@
 import type { OntologyConfig, EnvironmentConfig, AuthResult } from "../../config/types.js";
-import { type Logger } from "../resolver.js";
+import type { Logger } from "../resolver.js";
 /**
  * Field reference info for MCP tools
  */
@@ -32,4 +32,4 @@ export declare function filterToolsByAccess(tools: McpTool[], accessGroups: stri
 /**
  * Create a tool executor function that accepts per-request auth result
  */
-export declare function createToolExecutor(config: OntologyConfig, configDir: string, env: string, envConfig: EnvironmentConfig, logger: Logger): (toolName: string, args: unknown, authResult: AuthResult) => Promise<unknown>;
+export declare function createToolExecutor(config: OntologyConfig, env: string, envConfig: EnvironmentConfig, logger: Logger): (toolName: string, args: unknown, authResult: AuthResult) => Promise<unknown>;

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

@@ -1,20 +1,9 @@
-import type { ResolverFunction, OntologyConfig } from "../config/types.js";
+import type { ResolverFunction } 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
+ * Get a resolver function. Since resolvers are now passed directly as functions,
+ * this is a simple passthrough that could be removed in the future.
  */
-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[];
+export declare function loadResolver(resolver: ResolverFunction): ResolverFunction;
 /**
  * Logger type returned by createLogger
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ont-run",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Ontology-enforced API framework for AI coding agents",
   "type": "module",
   "bin": {