ebade 0.1.0

package/packages/mcp-server/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@ebade/mcp-server",
+  "version": "0.1.0",
+  "description": "MCP Server for ebade - Enable AI agents to build with the essence of code",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "ebade-mcp": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "ebade",
+    "ai",
+    "agent",
+    "framework"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "yaml": "^2.3.4",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  }
+}

package/packages/mcp-server/src/index.ts

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+
+/**
+ * ebade MCP Server
+ *
+ * This server enables AI agents to use ebade for building web applications.
+ * It exposes tools that allow agents to:
+ * - Scaffold projects from ebade definitions
+ * - Validate ebade files
+ * - Compile ebade to framework-specific code
+ * - Generate components from natural language descriptions
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+import { scaffoldProject } from "./tools/scaffold.js";
+import { validateIntent } from "./tools/validate.js";
+import { compileIntent } from "./tools/compile.js";
+import { generateComponent } from "./tools/generate.js";
+
+// Create the MCP server
+const server = new Server(
+  {
+    name: "ebade",
+    version: "0.1.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {},
+    },
+  }
+);
+
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "ebade_scaffold",
+        description: `Scaffold a new project from an ebade definition. 
+This creates a complete Next.js project structure based on the ebade specification.
+
+Use this when the user wants to:
+- Start a new web project
+- Create an e-commerce site, SaaS dashboard, blog, etc.
+- Generate a full application structure
+
+The ebade file uses YAML format with pages, components, data models, and API definitions.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectName: {
+              type: "string",
+              description: "Name of the project (kebab-case, e.g., 'my-store')",
+            },
+            projectType: {
+              type: "string",
+              enum: [
+                "e-commerce",
+                "saas-dashboard",
+                "blog",
+                "landing-page",
+                "portfolio",
+                "api-only",
+              ],
+              description: "Type of project to scaffold",
+            },
+            features: {
+              type: "array",
+              items: { type: "string" },
+              description:
+                "Features to include (e.g., 'user-auth', 'shopping-cart', 'dark-mode')",
+            },
+            outputDir: {
+              type: "string",
+              description: "Output directory path (absolute)",
+            },
+          },
+          required: ["projectName", "projectType", "outputDir"],
+        },
+      },
+      {
+        name: "ebade_validate",
+        description: `Validate an ebade definition file.
+Checks for:
+- Correct syntax and structure
+- Valid decorator usage
+- Proper data model relationships
+- Missing required fields
+
+Use this before scaffolding to ensure the ebade is valid.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            intentContent: {
+              type: "string",
+              description: "The ebade file content (YAML or TypeScript)",
+            },
+          },
+          required: ["intentContent"],
+        },
+      },
+      {
+        name: "ebade_compile",
+        description: `Compile a specific ebade definition into framework-specific code.
+Returns the generated code for a specific page, component, or API route.
+
+Use this when:
+- User wants to see what code an ebade produces
+- Building a specific component
+- Iterating on a single ebade definition`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            intent: {
+              type: "object",
+              description: "The ebade definition object",
+              properties: {
+                type: {
+                  type: "string",
+                  enum: ["page", "component", "api", "layout"],
+                },
+                name: { type: "string" },
+                path: { type: "string" },
+                components: {
+                  type: "array",
+                  items: { type: "string" },
+                },
+                auth: {
+                  type: "string",
+                  enum: ["none", "required", "optional"],
+                },
+                data: {
+                  type: "array",
+                  items: { type: "string" },
+                },
+                outcomes: {
+                  type: "object",
+                },
+              },
+            },
+            target: {
+              type: "string",
+              enum: ["nextjs", "react", "vue", "svelte"],
+              description: "Target framework (default: nextjs)",
+            },
+          },
+          required: ["intent"],
+        },
+      },
+      {
+        name: "ebade_generate",
+        description: `Generate a component from a natural language description.
+AI-powered ebade inference - describe what you want and get the ebade + code.
+
+Use this when:
+- User describes a component in natural language
+- Quick prototyping
+- Exploring ebade syntax and capabilities`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            description: {
+              type: "string",
+              description:
+                "Natural language description of the component (e.g., 'a product card with image, title, price, and add to cart button')",
+            },
+            style: {
+              type: "string",
+              enum: [
+                "minimal-modern",
+                "bold-vibrant",
+                "dark-premium",
+                "glassmorphism",
+              ],
+              description: "Design style preference",
+            },
+          },
+          required: ["description"],
+        },
+      },
+    ],
+  };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case "ebade_scaffold":
+        return {
+          content: [
+            {
+              type: "text",
+              text: await scaffoldProject(args as any),
+            },
+          ],
+        };
+
+      case "ebade_validate":
+        return await validateIntent({
+          intentContent: args?.intentContent as string,
+        });
+
+      case "ebade_compile":
+        return {
+          content: [
+            {
+              type: "text",
+              text: await compileIntent({
+                intent: args?.intent as any,
+                target:
+                  (args?.target as "nextjs" | "react" | "vue" | "svelte") ||
+                  "nextjs",
+              }),
+            },
+          ],
+        };
+
+      case "ebade_generate":
+        return await generateComponent({
+          description: args?.description as string,
+          style: args?.style as any,
+        });
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+// List available resources (ebade templates, examples)
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  return {
+    resources: [
+      {
+        uri: "ebade://syntax",
+        name: "ebade Syntax Reference",
+        description: "The complete syntax guide for ebade definitions",
+        mimeType: "text/markdown",
+      },
+      {
+        uri: "ebade://examples/ecommerce",
+        name: "E-commerce ebade Example",
+        description: "A comprehensive ebade example for an e-commerce platform",
+        mimeType: "text/x-yaml",
+      },
+      {
+        uri: "ebade://examples/saas",
+        name: "SaaS Dashboard ebade Example",
+        description: "SaaS dashboard with auth, billing, user management",
+        mimeType: "text/x-yaml",
+      },
+    ],
+  };
+});
+
+// Read resources
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const { uri } = request.params;
+
+  const resources: Record<string, string> = {
+    "ebade://syntax": `# ebade Syntax Reference\\n\\n@page, @ebade, @requires, @outcomes, @data, @validate, @style, @compose, @on, @expects\\n\\nCode = f(ebade)`,
+    "ebade://examples/ecommerce": `# E-commerce ebade\nname: my-store\ntype: e-commerce\nfeatures:\n  - product-catalog\n  - shopping-cart\n  - checkout`,
+    "ebade://examples/saas": `# SaaS ebade\nname: my-saas\ntype: saas-dashboard\nfeatures:\n  - user-auth\n  - billing\n  - analytics`,
+  };
+
+  const content = resources[uri];
+  if (!content) {
+    throw new Error(`Resource not found: ${uri}`);
+  }
+
+  return {
+    contents: [
+      {
+        uri,
+        mimeType: "text/markdown",
+        text: content,
+      },
+    ],
+  };
+});
+
+// Start the server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("ebade MCP Server running on stdio");
+}
+
+main().catch((error) => {
+  console.error("Failed to start server:", error);
+  process.exit(1);
+});

package/packages/mcp-server/src/tools/compile.ts

@@ -0,0 +1,269 @@
+/**
+ * Compile Tool
+ *
+ * Compiles a single ebade definition into framework-specific code.
+ */
+
+interface CompileArgs {
+  intent: {
+    type: "page" | "component" | "api" | "layout";
+    name: string;
+    path?: string;
+    components?: string[];
+    auth?: "none" | "required" | "optional";
+    data?: string[];
+    outcomes?: Record<string, any>;
+    style?: string | Record<string, any>;
+  };
+  target?: "nextjs" | "react" | "vue" | "svelte";
+}
+
+// Code generators for different targets
+const generators = {
+  nextjs: {
+    page: (intent: CompileArgs["intent"]) => {
+      const name = intent.name
+        .split("-")
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join("");
+
+      const imports: string[] = [];
+      const bodyParts: string[] = [];
+
+      // Auth handling
+      if (intent.auth === "required") {
+        imports.push(`import { redirect } from "next/navigation";`);
+        imports.push(`import { auth } from "@/lib/auth";`);
+        bodyParts.push(`  const session = await auth();
+  if (!session) {
+    redirect("/login");
+  }`);
+      }
+
+      // Data fetching
+      if (intent.data && intent.data.length > 0) {
+        imports.push(`import { db } from "@/lib/db";`);
+        for (const dataName of intent.data) {
+          const varName = dataName.toLowerCase();
+          bodyParts.push(
+            `  const ${varName} = await db.${varName}.findMany();`
+          );
+        }
+      }
+
+      // Component imports
+      if (intent.components && intent.components.length > 0) {
+        for (const comp of intent.components) {
+          const compName = comp
+            .split("-")
+            .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+            .join("");
+          imports.push(`import { ${compName} } from "@/components/${comp}";`);
+        }
+      }
+
+      // Component usage
+      const componentJSX = (intent.components || [])
+        .map((comp) => {
+          const compName = comp
+            .split("-")
+            .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+            .join("");
+          return `        <${compName} />`;
+        })
+        .join("\n");
+
+      return `/**
+ * @page('${intent.path || "/"}')
+ * @ebade('${intent.name}')
+ * Built with ebade
+ * ${intent.auth ? `@requires({ auth: '${intent.auth}' })` : ""}
+ * ${
+   intent.data ? `@data([${intent.data.map((d) => `'${d}'`).join(", ")}])` : ""
+ }
+ */
+
+${imports.join("\n")}
+
+export default async function ${name}Page() {
+${bodyParts.join("\n\n")}
+
+  return (
+    <main className="page ${intent.name}">
+      <div className="container">
+${componentJSX || "        {/* Page content */}"}
+      </div>
+    </main>
+  );
+}
+
+// Metadata
+export const metadata = {
+  title: "${name}",
+  description: "Page for ${intent.name} (Built with ebade)",
+};
+`;
+    },
+
+    component: (intent: CompileArgs["intent"]) => {
+      const name = intent.name
+        .split("-")
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join("");
+
+      const style =
+        typeof intent.style === "string"
+          ? intent.style
+          : JSON.stringify(intent.style);
+
+      return `/* ebade Generated Component */
+/**
+ * @ebade('${name}')
+ * ${intent.style ? `@style(${style})` : ""}
+ */
+
+import { useState } from "react";
+
+interface ${name}Props {
+  className?: string;
+}
+
+export function ${name}({ className }: ${name}Props) {
+  return (
+    <section className={\`${intent.name} \${className || ""}\`}>
+      <div className="container">
+        <h2>${name}</h2>
+        {/* Component content */}
+      </div>
+    </section>
+  );
+}
+`;
+    },
+
+    api: (intent: CompileArgs["intent"]) => {
+      const authCheck =
+        intent.auth === "required"
+          ? `
+  // Auth check
+  const session = await auth();
+  if (!session) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+`
+          : "";
+
+      return `/**
+ * @api('${intent.path || "/api/" + intent.name}')
+ * @ebade('${intent.name}')
+ * Built with ebade
+ * ${intent.auth ? `@requires({ auth: '${intent.auth}' })` : ""}
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+${intent.auth === "required" ? `import { auth } from "@/lib/auth";` : ""}
+
+export async function GET(request: NextRequest) {
+${authCheck}
+  try {
+    // TODO: Implement GET handler
+    return NextResponse.json({ message: "GET ${intent.name}" });
+  } catch (error) {
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request: NextRequest) {
+${authCheck}
+  try {
+    const body = await request.json();
+    // TODO: Implement POST handler
+    return NextResponse.json({ message: "POST ${intent.name}", data: body });
+  } catch (error) {
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
+`;
+    },
+
+    layout: (intent: CompileArgs["intent"]) => {
+      const name = intent.name
+        .split("-")
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join("");
+
+      return `/**
+ * ${name} Layout
+ * 
+ * @layout('${intent.name}')
+ * ${
+   intent.components
+     ? `@compose([${intent.components.map((c) => `'${c}'`).join(", ")}])`
+     : ""
+ }
+ */
+
+${(intent.components || [])
+  .map((comp) => {
+    const compName = comp
+      .split("-")
+      .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+      .join("");
+    return `import { ${compName} } from "@/components/${comp}";`;
+  })
+  .join("\n")}
+
+export default function ${name}Layout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <div className="layout ${intent.name}">
+      ${intent.components?.includes("header") ? "<Header />" : ""}
+      <main>{children}</main>
+      ${intent.components?.includes("footer") ? "<Footer />" : ""}
+    </div>
+  );
+}
+`;
+    },
+  },
+};
+
+export async function compileIntent(args: CompileArgs) {
+  const { intent, target = "nextjs" } = args;
+
+  if (target !== "nextjs") {
+    return `⚠️ Target "${target}" is not yet supported. Currently only "nextjs" is available.
+
+Coming soon: vue, svelte, react (standalone)`;
+  }
+
+  const generator = generators[target];
+  const typeGenerator = (generator as any)[intent.type];
+
+  if (!typeGenerator) {
+    return `❌ Unknown ebade type: ${intent.type}. Available: page, component, api, layout`;
+  }
+
+  const code = typeGenerator(intent);
+
+  return `✅ Compiled ${intent.type}: ${intent.name}
+
+\`\`\`typescript
+${code}
+\`\`\`
+
+📋 ebade definition used:
+\`\`\`json
+${JSON.stringify(intent, null, 2)}
+\`\`\`
+`;
+}