Initial commit: Complete Hive distributed AI orchestration platform

This comprehensive implementation includes:
- FastAPI backend with MCP server integration
- React/TypeScript frontend with Vite
- PostgreSQL database with Redis caching
- Grafana/Prometheus monitoring stack
- Docker Compose orchestration
- Full MCP protocol support for Claude Code integration

Features:
- Agent discovery and management across network
- Visual workflow editor and execution engine
- Real-time task coordination and monitoring
- Multi-model support with specialized agents
- Distributed development task allocation

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

mcp-server/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js

@@ -0,0 +1,87 @@
+import { parseDef } from "./parseDef.js";
+import { getRefs } from "./Refs.js";
+import { parseAnyDef } from "./parsers/any.js";
+const zodToJsonSchema = (schema, options) => {
+    const refs = getRefs(options);
+    let definitions = typeof options === "object" && options.definitions
+        ? Object.entries(options.definitions).reduce((acc, [name, schema]) => ({
+            ...acc,
+            [name]: parseDef(schema._def, {
+                ...refs,
+                currentPath: [...refs.basePath, refs.definitionPath, name],
+            }, true) ?? parseAnyDef(refs),
+        }), {})
+        : undefined;
+    const name = typeof options === "string"
+        ? options
+        : options?.nameStrategy === "title"
+            ? undefined
+            : options?.name;
+    const main = parseDef(schema._def, name === undefined
+        ? refs
+        : {
+            ...refs,
+            currentPath: [...refs.basePath, refs.definitionPath, name],
+        }, false) ?? parseAnyDef(refs);
+    const title = typeof options === "object" &&
+        options.name !== undefined &&
+        options.nameStrategy === "title"
+        ? options.name
+        : undefined;
+    if (title !== undefined) {
+        main.title = title;
+    }
+    if (refs.flags.hasReferencedOpenAiAnyType) {
+        if (!definitions) {
+            definitions = {};
+        }
+        if (!definitions[refs.openAiAnyTypeName]) {
+            definitions[refs.openAiAnyTypeName] = {
+                // Skipping "object" as no properties can be defined and additionalProperties must be "false"
+                type: ["string", "number", "integer", "boolean", "array", "null"],
+                items: {
+                    $ref: refs.$refStrategy === "relative"
+                        ? "1"
+                        : [
+                            ...refs.basePath,
+                            refs.definitionPath,
+                            refs.openAiAnyTypeName,
+                        ].join("/"),
+                },
+            };
+        }
+    }
+    const combined = name === undefined
+        ? definitions
+            ? {
+                ...main,
+                [refs.definitionPath]: definitions,
+            }
+            : main
+        : {
+            $ref: [
+                ...(refs.$refStrategy === "relative" ? [] : refs.basePath),
+                refs.definitionPath,
+                name,
+            ].join("/"),
+            [refs.definitionPath]: {
+                ...definitions,
+                [name]: main,
+            },
+        };
+    if (refs.target === "jsonSchema7") {
+        combined.$schema = "http://json-schema.org/draft-07/schema#";
+    }
+    else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
+        combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+    }
+    if (refs.target === "openAi" &&
+        ("anyOf" in combined ||
+            "oneOf" in combined ||
+            "allOf" in combined ||
+            ("type" in combined && Array.isArray(combined.type)))) {
+        console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
+    }
+    return combined;
+};
+export { zodToJsonSchema };