ont-run 0.0.1

package/src/browser/transform.ts

@@ -0,0 +1,473 @@
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import type { OntologyConfig } from "../config/types.js";
+import type { OntologyDiff, FunctionChange } from "../lockfile/types.js";
+import { getFieldFromMetadata } from "../config/categorical.js";
+
+export type NodeType = "entity" | "function" | "accessGroup";
+export type EdgeType = "operates-on" | "requires-access" | "depends-on";
+export type ChangeStatus = "added" | "removed" | "modified" | "unchanged";
+
+export interface GraphNode {
+  id: string;
+  type: NodeType;
+  label: string;
+  description: string;
+  metadata: {
+    inputs?: Record<string, unknown>;
+    outputs?: Record<string, unknown>;
+    resolver?: string;
+    functionCount?: number;
+  };
+}
+
+export interface GraphEdge {
+  id: string;
+  source: string;
+  target: string;
+  type: EdgeType;
+  label?: string;
+}
+
+export interface GraphData {
+  nodes: GraphNode[];
+  edges: GraphEdge[];
+  meta: {
+    ontologyName: string;
+    totalFunctions: number;
+    totalEntities: number;
+    totalAccessGroups: number;
+  };
+}
+
+export interface EnhancedGraphNode extends GraphNode {
+  changeStatus: ChangeStatus;
+  changeDetails?: FunctionChange;
+}
+
+export interface EnhancedGraphData {
+  nodes: EnhancedGraphNode[];
+  edges: GraphEdge[];
+  meta: GraphData["meta"] & {
+    hasChanges: boolean;
+    addedCount: number;
+    removedCount: number;
+    modifiedCount: number;
+  };
+  diff: OntologyDiff | null;
+}
+
+interface FieldReference {
+  path: string;
+  functionName: string;
+}
+
+/**
+ * Recursively extract fieldFrom references from a Zod schema
+ */
+function extractFieldReferences(
+  schema: z.ZodType<unknown>,
+  path: string = ""
+): FieldReference[] {
+  const results: FieldReference[] = [];
+
+  const metadata = getFieldFromMetadata(schema);
+  if (metadata) {
+    results.push({
+      path: path || "(root)",
+      functionName: metadata.functionName,
+    });
+  }
+
+  if (schema instanceof z.ZodObject) {
+    const shape = schema.shape;
+    for (const [key, value] of Object.entries(shape)) {
+      const fieldPath = path ? `${path}.${key}` : key;
+      results.push(
+        ...extractFieldReferences(value as z.ZodType<unknown>, fieldPath)
+      );
+    }
+  }
+
+  if (schema instanceof z.ZodOptional) {
+    results.push(...extractFieldReferences(schema.unwrap(), path));
+  }
+
+  if (schema instanceof z.ZodNullable) {
+    results.push(...extractFieldReferences(schema.unwrap(), path));
+  }
+
+  if (schema instanceof z.ZodArray) {
+    results.push(...extractFieldReferences(schema.element, `${path}[]`));
+  }
+
+  if (schema instanceof z.ZodDefault) {
+    results.push(...extractFieldReferences(schema._def.innerType, path));
+  }
+
+  return results;
+}
+
+/**
+ * Convert Zod schema to JSON Schema safely
+ */
+function safeZodToJsonSchema(schema: z.ZodTypeAny): Record<string, unknown> | undefined {
+  try {
+    const result = zodToJsonSchema(schema, { $refStrategy: "none" }) as Record<string, unknown>;
+    delete result.$schema;
+    return result;
+  } catch {
+    return { type: "unknown" };
+  }
+}
+
+/**
+ * Transform OntologyConfig into graph data for visualization
+ */
+export function transformToGraphData(config: OntologyConfig): GraphData {
+  const nodes: GraphNode[] = [];
+  const edges: GraphEdge[] = [];
+
+  // Track function counts for access groups and entities
+  const accessGroupCounts: Record<string, number> = {};
+  const entityCounts: Record<string, number> = {};
+
+  // Initialize counts
+  for (const groupName of Object.keys(config.accessGroups)) {
+    accessGroupCounts[groupName] = 0;
+  }
+  if (config.entities) {
+    for (const entityName of Object.keys(config.entities)) {
+      entityCounts[entityName] = 0;
+    }
+  }
+
+  // Create function nodes and count relationships
+  for (const [name, fn] of Object.entries(config.functions)) {
+    // Count access group usage
+    for (const group of fn.access) {
+      accessGroupCounts[group] = (accessGroupCounts[group] || 0) + 1;
+    }
+
+    // Count entity usage
+    for (const entity of fn.entities) {
+      entityCounts[entity] = (entityCounts[entity] || 0) + 1;
+    }
+
+    // Create function node
+    nodes.push({
+      id: `function:${name}`,
+      type: "function",
+      label: name,
+      description: fn.description,
+      metadata: {
+        inputs: safeZodToJsonSchema(fn.inputs),
+        outputs: fn.outputs ? safeZodToJsonSchema(fn.outputs) : undefined,
+        resolver: fn.resolver,
+      },
+    });
+
+    // Create edges: function -> access groups
+    for (const group of fn.access) {
+      edges.push({
+        id: `function:${name}->accessGroup:${group}`,
+        source: `function:${name}`,
+        target: `accessGroup:${group}`,
+        type: "requires-access",
+      });
+    }
+
+    // Create edges: function -> entities
+    for (const entity of fn.entities) {
+      edges.push({
+        id: `function:${name}->entity:${entity}`,
+        source: `function:${name}`,
+        target: `entity:${entity}`,
+        type: "operates-on",
+      });
+    }
+
+    // Create edges: function -> function (fieldFrom dependencies)
+    const fieldRefs = extractFieldReferences(fn.inputs);
+    for (const ref of fieldRefs) {
+      edges.push({
+        id: `function:${name}->function:${ref.functionName}:${ref.path}`,
+        source: `function:${name}`,
+        target: `function:${ref.functionName}`,
+        type: "depends-on",
+        label: ref.path,
+      });
+    }
+  }
+
+  // Create access group nodes
+  for (const [name, group] of Object.entries(config.accessGroups)) {
+    nodes.push({
+      id: `accessGroup:${name}`,
+      type: "accessGroup",
+      label: name,
+      description: group.description,
+      metadata: {
+        functionCount: accessGroupCounts[name] || 0,
+      },
+    });
+  }
+
+  // Create entity nodes
+  if (config.entities) {
+    for (const [name, entity] of Object.entries(config.entities)) {
+      nodes.push({
+        id: `entity:${name}`,
+        type: "entity",
+        label: name,
+        description: entity.description,
+        metadata: {
+          functionCount: entityCounts[name] || 0,
+        },
+      });
+    }
+  }
+
+  return {
+    nodes,
+    edges,
+    meta: {
+      ontologyName: config.name,
+      totalFunctions: Object.keys(config.functions).length,
+      totalEntities: config.entities ? Object.keys(config.entities).length : 0,
+      totalAccessGroups: Object.keys(config.accessGroups).length,
+    },
+  };
+}
+
+/**
+ * Search nodes by label or description
+ */
+export function searchNodes(
+  graphData: GraphData,
+  query: string
+): Array<{ id: string; type: NodeType; label: string; matchType: "label" | "description" }> {
+  const lowerQuery = query.toLowerCase();
+  const results: Array<{ id: string; type: NodeType; label: string; matchType: "label" | "description" }> = [];
+
+  for (const node of graphData.nodes) {
+    if (node.label.toLowerCase().includes(lowerQuery)) {
+      results.push({ id: node.id, type: node.type, label: node.label, matchType: "label" });
+    } else if (node.description.toLowerCase().includes(lowerQuery)) {
+      results.push({ id: node.id, type: node.type, label: node.label, matchType: "description" });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Get detailed node information including connections
+ */
+export function getNodeDetails(
+  graphData: GraphData,
+  nodeId: string
+): {
+  node: GraphNode | null;
+  connections: {
+    accessGroups: string[];
+    entities: string[];
+    dependsOn: Array<{ functionName: string; path: string }>;
+    dependedOnBy: string[];
+    functions: Array<{
+      name: string;
+      description: string;
+      inputs?: Record<string, unknown>;
+      outputs?: Record<string, unknown>;
+    }>;
+  };
+} {
+  const node = graphData.nodes.find((n) => n.id === nodeId) || null;
+
+  const connections = {
+    accessGroups: [] as string[],
+    entities: [] as string[],
+    dependsOn: [] as Array<{ functionName: string; path: string }>,
+    dependedOnBy: [] as string[],
+    functions: [] as Array<{
+      name: string;
+      description: string;
+      inputs?: Record<string, unknown>;
+      outputs?: Record<string, unknown>;
+    }>,
+  };
+
+  if (!node) return { node, connections };
+
+  for (const edge of graphData.edges) {
+    if (edge.source === nodeId) {
+      if (edge.type === "requires-access") {
+        connections.accessGroups.push(edge.target.replace("accessGroup:", ""));
+      } else if (edge.type === "operates-on") {
+        connections.entities.push(edge.target.replace("entity:", ""));
+      } else if (edge.type === "depends-on") {
+        connections.dependsOn.push({
+          functionName: edge.target.replace("function:", ""),
+          path: edge.label || "",
+        });
+      }
+    }
+
+    if (edge.target === nodeId) {
+      if (edge.type === "depends-on") {
+        connections.dependedOnBy.push(edge.source.replace("function:", ""));
+      } else if (edge.type === "requires-access" && node.type === "accessGroup") {
+        const funcName = edge.source.replace("function:", "");
+        const funcNode = graphData.nodes.find((n) => n.id === edge.source);
+        if (funcNode) {
+          connections.functions.push({
+            name: funcName,
+            description: funcNode.description,
+            inputs: funcNode.metadata.inputs,
+            outputs: funcNode.metadata.outputs,
+          });
+        }
+      } else if (edge.type === "operates-on" && node.type === "entity") {
+        const funcName = edge.source.replace("function:", "");
+        const funcNode = graphData.nodes.find((n) => n.id === edge.source);
+        if (funcNode) {
+          connections.functions.push({
+            name: funcName,
+            description: funcNode.description,
+            inputs: funcNode.metadata.inputs,
+            outputs: funcNode.metadata.outputs,
+          });
+        }
+      }
+    }
+  }
+
+  return { node, connections };
+}
+
+/**
+ * Enhance graph data with diff information for review mode
+ */
+export function enhanceWithDiff(
+  graphData: GraphData,
+  diff: OntologyDiff | null
+): EnhancedGraphData {
+  if (!diff) {
+    // No diff - all nodes are unchanged
+    return {
+      nodes: graphData.nodes.map((node) => ({
+        ...node,
+        changeStatus: "unchanged" as ChangeStatus,
+      })),
+      edges: graphData.edges,
+      meta: {
+        ...graphData.meta,
+        hasChanges: false,
+        addedCount: 0,
+        removedCount: 0,
+        modifiedCount: 0,
+      },
+      diff: null,
+    };
+  }
+
+  // Build lookup maps for changes
+  const functionChanges = new Map<string, FunctionChange>();
+  for (const fn of diff.functions) {
+    functionChanges.set(fn.name, fn);
+  }
+
+  const addedGroups = new Set(diff.addedGroups);
+  const removedGroups = new Set(diff.removedGroups);
+  const addedEntities = new Set(diff.addedEntities);
+  const removedEntities = new Set(diff.removedEntities);
+
+  // Enhance existing nodes with change status
+  const enhancedNodes: EnhancedGraphNode[] = graphData.nodes.map((node) => {
+    let changeStatus: ChangeStatus = "unchanged";
+    let changeDetails: FunctionChange | undefined;
+
+    if (node.type === "function") {
+      const fnName = node.label;
+      const change = functionChanges.get(fnName);
+      if (change) {
+        changeStatus = change.type;
+        changeDetails = change;
+      }
+    } else if (node.type === "accessGroup") {
+      if (addedGroups.has(node.label)) {
+        changeStatus = "added";
+      }
+    } else if (node.type === "entity") {
+      if (addedEntities.has(node.label)) {
+        changeStatus = "added";
+      }
+    }
+
+    return {
+      ...node,
+      changeStatus,
+      changeDetails,
+    };
+  });
+
+  // Add ghost nodes for removed items
+  for (const group of removedGroups) {
+    enhancedNodes.push({
+      id: `accessGroup:${group}`,
+      type: "accessGroup",
+      label: group,
+      description: "Removed access group",
+      metadata: { functionCount: 0 },
+      changeStatus: "removed",
+    });
+  }
+
+  for (const entity of removedEntities) {
+    enhancedNodes.push({
+      id: `entity:${entity}`,
+      type: "entity",
+      label: entity,
+      description: "Removed entity",
+      metadata: { functionCount: 0 },
+      changeStatus: "removed",
+    });
+  }
+
+  // Add ghost nodes for removed functions
+  for (const fn of diff.functions.filter((f) => f.type === "removed")) {
+    enhancedNodes.push({
+      id: `function:${fn.name}`,
+      type: "function",
+      label: fn.name,
+      description: fn.oldDescription || "Removed function",
+      metadata: {},
+      changeStatus: "removed",
+      changeDetails: fn,
+    });
+  }
+
+  // Count changes
+  const addedCount =
+    diff.addedGroups.length +
+    diff.addedEntities.length +
+    diff.functions.filter((f) => f.type === "added").length;
+  const removedCount =
+    diff.removedGroups.length +
+    diff.removedEntities.length +
+    diff.functions.filter((f) => f.type === "removed").length;
+  const modifiedCount = diff.functions.filter((f) => f.type === "modified").length;
+
+  return {
+    nodes: enhancedNodes,
+    edges: graphData.edges,
+    meta: {
+      ...graphData.meta,
+      hasChanges: diff.hasChanges,
+      addedCount,
+      removedCount,
+      modifiedCount,
+    },
+    diff,
+  };
+}

package/src/cli/commands/init.ts

@@ -0,0 +1,226 @@
+import { defineCommand } from "citty";
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import consola from "consola";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Templates are bundled in the package
+const TEMPLATES_DIR = join(__dirname, "..", "..", "..", "templates");
+
+export const initCommand = defineCommand({
+  meta: {
+    name: "init",
+    description: "Initialize a new Ontology project",
+  },
+  args: {
+    dir: {
+      type: "positional",
+      description: "Directory to initialize (default: current directory)",
+      default: ".",
+    },
+    force: {
+      type: "boolean",
+      description: "Overwrite existing files",
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const targetDir = args.dir === "." ? process.cwd() : join(process.cwd(), args.dir);
+
+    consola.info(`Initializing Ontology project in ${targetDir}`);
+
+    // Create directory if needed
+    if (!existsSync(targetDir)) {
+      mkdirSync(targetDir, { recursive: true });
+    }
+
+    // Check for existing config
+    const configPath = join(targetDir, "ontology.config.ts");
+    if (existsSync(configPath) && !args.force) {
+      consola.error("ontology.config.ts already exists. Use --force to overwrite.");
+      process.exit(1);
+    }
+
+    // Create resolvers directory
+    const resolversDir = join(targetDir, "resolvers");
+    if (!existsSync(resolversDir)) {
+      mkdirSync(resolversDir, { recursive: true });
+    }
+
+    // Write ontology.config.ts
+    const configTemplate = `import { defineOntology } from 'ont-run';
+import { z } from 'zod';
+
+export default defineOntology({
+  name: 'my-api',
+
+  environments: {
+    dev: { debug: true },
+    prod: { debug: false },
+  },
+
+  // Pluggable auth - customize this for your use case
+  auth: async (req) => {
+    const token = req.headers.get('Authorization');
+    // Return access groups based on auth
+    // This is where you'd verify JWTs, API keys, etc.
+    if (!token) return ['public'];
+    if (token === 'admin-secret') return ['admin', 'support', 'public'];
+    return ['support', 'public'];
+  },
+
+  accessGroups: {
+    public: { description: 'Unauthenticated users' },
+    support: { description: 'Support agents' },
+    admin: { description: 'Administrators' },
+  },
+
+  functions: {
+    // Example: Public function
+    healthCheck: {
+      description: 'Check API health status',
+      access: ['public', 'support', 'admin'],
+      inputs: z.object({}),
+      resolver: './resolvers/healthCheck.ts',
+    },
+
+    // Example: Restricted function
+    getUser: {
+      description: 'Get user details by ID',
+      access: ['support', 'admin'],
+      inputs: z.object({
+        userId: z.string().uuid(),
+      }),
+      resolver: './resolvers/getUser.ts',
+    },
+
+    // Example: Admin-only function
+    deleteUser: {
+      description: 'Delete a user account',
+      access: ['admin'],
+      inputs: z.object({
+        userId: z.string().uuid(),
+        reason: z.string().optional(),
+      }),
+      resolver: './resolvers/deleteUser.ts',
+    },
+  },
+});
+`;
+
+    writeFileSync(configPath, configTemplate);
+    consola.success("Created ontology.config.ts");
+
+    // Write example resolvers
+    const healthCheckResolver = `import type { ResolverContext } from 'ont-run';
+
+export default async function healthCheck(ctx: ResolverContext, args: {}) {
+  ctx.logger.info('Health check called');
+
+  return {
+    status: 'ok',
+    env: ctx.env,
+    timestamp: new Date().toISOString(),
+  };
+}
+`;
+
+    const getUserResolver = `import type { ResolverContext } from 'ont-run';
+
+interface GetUserArgs {
+  userId: string;
+}
+
+export default async function getUser(ctx: ResolverContext, args: GetUserArgs) {
+  ctx.logger.info(\`Getting user: \${args.userId}\`);
+
+  // This is where you'd query your database
+  // Example response:
+  return {
+    id: args.userId,
+    name: 'Example User',
+    email: 'user@example.com',
+    createdAt: '2025-01-01T00:00:00Z',
+  };
+}
+`;
+
+    const deleteUserResolver = `import type { ResolverContext } from 'ont-run';
+
+interface DeleteUserArgs {
+  userId: string;
+  reason?: string;
+}
+
+export default async function deleteUser(ctx: ResolverContext, args: DeleteUserArgs) {
+  ctx.logger.warn(\`Deleting user: \${args.userId}, reason: \${args.reason || 'none'}\`);
+
+  // This is where you'd delete from your database
+  // Example response:
+  return {
+    success: true,
+    deletedUserId: args.userId,
+    deletedAt: new Date().toISOString(),
+  };
+}
+`;
+
+    writeFileSync(join(resolversDir, "healthCheck.ts"), healthCheckResolver);
+    writeFileSync(join(resolversDir, "getUser.ts"), getUserResolver);
+    writeFileSync(join(resolversDir, "deleteUser.ts"), deleteUserResolver);
+    consola.success("Created example resolvers in resolvers/");
+
+    // Write server.ts
+    const serverTemplate = `import { startOnt } from 'ont-run';
+
+await startOnt();
+`;
+
+    writeFileSync(join(targetDir, "server.ts"), serverTemplate);
+    consola.success("Created server.ts");
+
+    // Write package.json
+    const packageJsonPath = join(targetDir, "package.json");
+    let packageJson: Record<string, unknown> = {};
+
+    if (existsSync(packageJsonPath)) {
+      try {
+        packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+      } catch {
+        // If parsing fails, start fresh
+      }
+    }
+
+    // Merge in our scripts and dependencies
+    packageJson.type = "module";
+    packageJson.scripts = {
+      ...(packageJson.scripts as Record<string, string> || {}),
+      dev: "bun run server.ts",
+      start: "NODE_ENV=production bun run server.ts",
+      review: "bunx ont-run review",
+    };
+    packageJson.dependencies = {
+      ...(packageJson.dependencies as Record<string, string> || {}),
+      "ont-run": "latest",
+      zod: "^3.24.0",
+    };
+
+    writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    consola.success("Updated package.json with scripts and dependencies");
+
+    // Instructions
+    console.log("\n");
+    consola.box(
+      "Ontology project initialized!\n\n" +
+        "Next steps:\n" +
+        "  1. Run `bun install` to install dependencies\n" +
+        "  2. Review ontology.config.ts and customize\n" +
+        "  3. Run `bun run review` to approve the initial ontology\n" +
+        "  4. Run `bun run dev` to start the servers\n\n" +
+        "Your API will be available at http://localhost:3000"
+    );
+  },
+});