ebade 0.4.6 → 0.4.7

package/.agent/workflows/prompt-to-product.md

@@ -2,39 +2,35 @@
 description: ebade Prompt-to-Product Workflow
 ---
 
-# 🐣 ebade Prompt-to-Product Workflow
+# 🌗 Hybrid Workflow: Architect & Engineer
 
-This workflow describes how an AI Agent should use the ebade framework to transform a user's natural language intent into a production-ready codebase.
+This workflow divides your task into two phases: **Offline Architecture** (Deterministic) and **Online Engineering** (Generative).
 
-## 1. Initial Project Scaffolding
+## 1. Phase I: The Offline Architect (Deterministic)
 When a user asks to "build", "create", or "start" a new web application:
 
 // turbo
-1. Use the `ebade build` command with the user's prompt.
+1. **Execute the Architecture**: Run the `ebade build` command.
    ```bash
    node cli/scaffold.js build "[User's Prompt]"
    ```
-   *This tool will automatically choose the project type, color palette, and initial components.*
+   *ebade will handle the heavy lifting: selecting the project type, generating a design system, and creating the file structure with **0-token cost** and **100% determinism**.*
 
-2. Navigate into the generated project directory.
+2. **Move In**: `cd` into the generated project directory.
 
-## 2. Understanding the Architecture
-ebade generates a `project.ebade.yaml` file in the project root. This is your **Source of Truth**.
-1. Read `project.ebade.yaml` to understand the pages, components, and data models.
-2. Respect the design system tokens in `app/globals.css`.
+## 2. Phase II: The Online Engineer (Generative)
+Now that the foundation is set, you act as the generative engineer to add "The Soul" to the codebase.
 
-## 3. Iterative Development
-Once the scaffold is ready, move from "Architect" to "Engineer":
+1. **Initialize Dependencies**: Run `npm install` to prepare the environment.
+2. **Read the Intent**: Open `project.ebade.yaml`. This is your **Source of Truth**. Your goal is to implement the specific logic requested by the user, while respecting the boundaries set in the YAML.
+3. **Refine Components**: Locate the UI components in `components/`. They are visually premium but contain "Business Logic" placeholders. Replace these with actual logic (API calls, state, conditional rendering).
+4. **API Integration**: Fill the `app/api/` skeletons with real backend code (DB queries, Auth logic).
 
-1. **Refine Components**: Locate generated components in `components/`. They are high-quality visual placeholders. Add the specific business logic, API calls, or complex state management requested by the user.
-2. **Implement API Logic**: Fill the `app/api/` route handlers with real backend logic (database queries, external service integrations).
-3. **Data Schemas**: Use the generated SQL in `database/schema.sql` to set up the actual database.
-
-## 4. Expanding the Project
-To add new features:
-1. Update `project.ebade.yaml` with the new intent.
-2. Run `node cli/scaffold.js scaffold project.ebade.yaml .` to generate the new files while preserving your logic.
-3. Apply the specific implementation details to the new files.
+## 3. Iterative Feedback Loop
+To expand or modify:
+1. Update `project.ebade.yaml` with the new intent (e.g., adding a new page or feature).
+2. Run `node cli/scaffold.js scaffold project.ebade.yaml .` to generate new files without breaking your existing work.
+3. Apply generative logic to the new structures.
 
 ---
-*Built for the Agent-First Era. ebade empowers you to focus on logic, while we handle the architecture.*
+*ebade: Empowering Agents to focus on Logic, while we handle the Architecture.*

package/ARCHITECTURE.md

@@ -43,13 +43,25 @@ Immediately after scaffolding, ebade runs a series of integrity checks:
 - **Intent-Code Mapping:** Verifies that exported component names and routes match the original intent.
 - **Test Coverage:** Confirms that matching unit tests (Vitest) have been generated for every new component.
 
-### 5. AI-Enhanced Scaffolding (The "Online Compiler")
+## 🌗 The Hybrid Workflow Model
 
-This is where the magic happens. ebade uses AI not as a "free-text generator," but as a **Deterministic Compiler Component**.
+ebade operates as a hybrid engine, splitting the lifecycle into two specific environments:
 
-- **Templates:** ebade provides a library of high-quality, pre-tested component templates.
-- **Mapping:** The AI maps the specific fields and logic from the `@intent` into these templates.
-- **Validation:** Every generated file is validated against the intent AST to ensure zero hallucinations.
+### 1. The Offline Architect (Deterministic)
+
+The local CLI acts as the core architect. It performs high-speed, 0-token analysis of the user's intent to establish the foundational structure of the codebase.
+
+- **Rules Engine**: Uses pattern matching and adjacency maps to select components and theme colors.
+- **Scaffold Engine**: Generates 100% of the boilerplate (folders, config files, type definitions).
+- **Zero-Token Hallucination Protection**: Since this runs locally with fixed logic, the structural integrity is guaranteed.
+
+### 2. The Online Engineer (Generative)
+
+Once the "House" (scaffold) is built, the AI Agent (the engineer) moves in to decorate and install the appliances (business logic).
+
+- **Intent Mapping**: The agent maps the specific sub-intents from the `@intent` decorators into the generated templates.
+- **Hallucination Guardrails**: By using the `project.ebade.yaml` as a strict AST-based specification, the agent is restricted from going "off-rails."
+- **Token Efficiency**: The agent only spends compute cycles on the actual business logic, not on imports or layout setup.
 
 ---
 

package/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to **ebade** will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.7] - 2025-01-10
+
+### Added
+
+- **Multi-Target Support**: The ebade CLI is now target-agnostic. Decoupled Next.js logic into adapters.
+- **Vanilla HTML Adapter**: Added support for standard HTML/CSS project generation via `--target html`.
+- **Automated Formatting**: Integrated Prettier into the scaffolding pipeline. Every generated file is now automatically formatted to production standards.
+- **Modular Adapter Architecture**: Introduced `TargetAdapter` base class to easily add new platforms (Flutter, Go, etc.).
+- **Shared CLI Utilities**: Unified common logic into `cli/utils.js` for better maintainability.
+
 ## [0.4.6] - 2025-01-10
 
 ### Added
@@ -24,8 +34,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Improved project naming logic to filter out filler words (e.g., "Can you make a...").
 - Fixed component integrity check to correctly locate test files in `tests/components/`.
 
-## [0.4.5] - 2025-01-10
-...
 ## [0.4.5] - 2025-01-10
 
 ### Added

package/MANIFESTO.md

@@ -128,18 +128,35 @@ Agent: *Next.js docs'ı hatırla*
        *500 satır kod yaz*
 ```
 
-### ebade ile
-```
-User: "Checkout sayfası yap"
-Agent: *intent tanımı yaz*
-       @page('/checkout')
-       @intent('complete-purchase')
-       @requires(['cart', 'user', 'payment'])
-       *bitti*
+### ebade ile (Hybrid Workflow)
+```text
+Phase I: Offline Architect (Deterministic)
+Agent: *node cli/scaffold.js build "A green dashboard"*
+       -> 0 Tokens spent
+       -> Mimar yerel olarak iskeleyi kurar
+
+Phase II: Online Engineer (Generative)
+Agent: *Arayüze özel iş mantığını (Business Logic) yaz*
+       -> Düşük token harcaması
+       -> Sadece yaratıcı işe odaklanma
 ```
 
 ---
 
+## Hibrit Model: Mimar ve Mühendis
+
+ebade, yazılım geliştirme sürecini ikiye böler:
+
+### 1. 🛡️ Offline Mimar (Deterministik)
+
+Yerel CLI, hiç token harcamadan projenin iskeletini, tasarım sistemini ve dosya düzenini kurar. Bu aşamada "halüsinasyon" yoktur, sadece saf mühendislik kuralları vardır.
+
+### 2. 🧠 Online Mühendis (Generatif)
+
+İskelet hazır olduktan sonra AI Ajanı (Cursor/Claude) koltuğa oturur. `project.ebade.yaml` dosyasını "Source of Truth" olarak kullanarak, projenin "ruhunu" (spesifik iş mantığı, API entegrasyonları) kodlar.
+
+---
+
 ## Design Principles
 
 1. **Agent-Native**: AI'ın düşünce yapısına uygun

package/README.md

@@ -9,6 +9,30 @@
 [![Green AI](https://img.shields.io/badge/🌱_Green_AI-70%25_Less_Tokens-brightgreen)](./docs/GREEN-AI.md)
 [![Architecture](https://img.shields.io/badge/Architecture-First_Principles-black)](./ARCHITECTURE.md)
 
+---
+
+## 🌗 Hybrid Workflow: The Best of Both Worlds
+
+ebade splits the development process into two distinct, high-efficiency phases:
+
+### 1. 🛡️ Offline Architect (Deterministic)
+
+The **ebade CLI** runs locally and requires **0 tokens**. It uses pattern matching and predefined architectural rules to scaffold your project's skeleton, design system, and file structure.
+
+- **Speed:** Instant results.
+- **Reliability:** 100% deterministic (no hallucinations).
+- **Cost:** Free.
+
+### 2. 🧠 Online Agent (Generative)
+
+Once the scaffold is ready, your **AI Agent** (Claude, Cursor, etc.) takes over to fill in the complex business logic using the `project.ebade.yaml` as its source of truth.
+
+- **Focus:** AI only works on the "hard parts."
+- **Efficiency:** ~70% token savings by not generating boilerplate.
+- **Alignment:** The agent follows the rules ebade already set in stone.
+
+---
+
 > **"Code is a legacy byproduct. Intent is the source of truth."**
 
 **ebade** is not just another framework. It is a **compilation protocol** designed for an era where AI Agents are the primary developers. It shifts the paradigm from "Human-Centric Coding" to "Agentic Intent Modeling."
@@ -19,7 +43,7 @@
 
 Watch how **ebade** transforms 20 lines of YAML into a production-ready, full-stack Next.js application.
 
-![ebade demo](./assets/demo.gif)
+![ebade demo](./assets/build-demo.gif)
 
 ### ⚔️ The Battle of Entropy
 
@@ -49,9 +73,39 @@ ebade uses a high-density decorator syntax designed to fit within an Agent's con
 
 ---
 
+---
+
+## 🧠 The Architect: Prompt-to-Product
+
+In **v0.4.7**, we introduced **ebade Forge** (Multi-Target Support). Now you can scaffold entire projects using just natural language for Next.js or Vanilla HTML.
+
+```bash
+# One-shot project creation
+npx ebade build "A luxury concierge service with pricing, testimonials and a gold theme"
+```
+
+- **Intent Intelligence**: Automatically detects app type (SaaS, E-commerce, Blog).
+- **Dynamic Design**: Generates a premium HSL color palette from your prompt.
+- **Smart Scaffolding**: Detects needed components (`auth`, `charts`, `forms`) and dynamically creates routes.
+
+---
+
 ## 🚀 Quick Start
 
-### 1. For Agents (MCP)
+### 1. Build from Prompt (One-Shot)
+
+```bash
+npx ebade build "Create a dark themed eco-monitor with real-time stats"
+```
+
+### 2. Scaffold from Intent (Professional)
+
+```bash
+# Generate project from an existing .ebade.yaml
+npx ebade scaffold examples/saas-dashboard.ebade.yaml ./my-app
+```
+
+### 3. For AI Agents (MCP)
 
 Add `ebade` to your AI agent (Claude, Cursor, Windsurf) via the Model Context Protocol:
 
@@ -66,13 +120,6 @@ Add `ebade` to your AI agent (Claude, Cursor, Windsurf) via the Model Context Pr
 }
 ```
 
-### 2. For Humans (CLI)
-
-```bash
-# Scaffold a full project from an intent file
-npx ebade scaffold examples/saas-dashboard.ebade.yaml ./my-app
-```
-
 ---
 
 ## 🏗️ Architecture: First Principles
@@ -101,44 +148,33 @@ ebade operates on the principle of **The Online Compiler**. It treats AI as a de
 
 ## 📦 Project Structure
 
+- **`cli/`**: The core scaffolding engine & EbadeArchitect.
+- **`packages/mcp-server/`**: The bridge for AI agents via MCP.
 - **`www/`**: The [ebade.dev](https://ebade.dev) landing page & playground.
-- **`packages/mcp-server/`**: The bridge for AI agents.
-- **`cli/`**: The core scaffolding engine.
-- **`examples/`**: Real-world intent templates.
-
----
-
-## 🤝 Join the Revolution
-
-1. **Star the repo** to show your support ⭐
-2. **Become a Sponsor** to help us build a Green AI future 💖
-
----
-
-MIT © ebade Contributors — Made with ❤️ in Türkiye 🇹🇷
+- **`examples/`**: Real-world intent templates for various app types.
 
 ---
 
 ## 🤝 Contributing
 
-**ebade** is open source and welcomes contributions!
+**ebade** is open source and welcomes contributions! Whether it's a new adapter, a component template, or a bug fix, we'd love to have you.
 
 1. **Star this repo** ⭐
 2. **Try the MCP server** with your AI agent
 3. **Open issues** with ideas and feedback
 4. **Submit PRs** for new features
 
-See [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for full guidelines.
 
 ---
 
 ## 💎 Support the Movement
 
-**ebade** is an ambitious project aiming to redefine how we build software in the age of AI. Your support helps us move faster, maintain high-quality documentation, and build a more sustainable "Green AI" future.
+**ebade** is an ambitious project aiming to redefine software engineering for the AI age. Your support helps us build a more sustainable "Green AI" future.
 
 - **[Become a GitHub Sponsor](https://github.com/sponsors/hasankemaldemirci)** 💖
 - **Star the repo** to show your support ⭐
-- **Share the project** with other AI enthusiasts 🚀
+- **Share the project** with other enthusiasts 🚀
 
 ---
 

package/cli/adapters/base.js

@@ -0,0 +1,38 @@
+/**
+ * Base TargetAdapter class for ebade.
+ * Each platform (Next.js, HTML, Flutter, etc.) must implement this.
+ */
+export class TargetAdapter {
+  constructor(colors, log) {
+    this.colors = colors;
+    this.log = log;
+  }
+
+  /**
+   * Generates the platform-specific project structure and config files.
+   */
+  generateBoilerplate(config, targetPath) {
+    throw new Error("generateBoilerplate() must be implemented");
+  }
+
+  /**
+   * Generates a page using preferred platform syntax.
+   */
+  generatePage(page, design) {
+    throw new Error("generatePage() must be implemented");
+  }
+
+  /**
+   * Generates a component using preferred platform syntax.
+   */
+  generateComponent(componentName, design) {
+    throw new Error("generateComponent() must be implemented");
+  }
+
+  /**
+   * Generates an API route/handler.
+   */
+  generateApiRoute(endpoint) {
+    throw new Error("generateApiRoute() must be implemented");
+  }
+}

package/cli/adapters/html-vanilla.js

@@ -0,0 +1,73 @@
+import fs from "fs";
+import path from "path";
+import { TargetAdapter } from "./base.js";
+import { ensureDir } from "../utils.js";
+
+export class HtmlVanillaAdapter extends TargetAdapter {
+  generateBoilerplate(config, projectDir) {
+    this.log.section("Creating Vanilla HTML project structure");
+
+    // Simple structure
+    const dirs = ["assets", "css", "js"];
+    dirs.forEach((dir) => {
+      ensureDir(path.join(projectDir, dir));
+      this.log.file(`${dir}/`);
+    });
+
+    // Generate style.css
+    const cssContent = `
+:root {
+  --primary: ${config.design?.colors?.primary || "#6366f1"};
+}
+body { 
+  font-family: sans-serif; 
+  background: #0f172a; 
+  color: white; 
+}
+.container { max-width: 1200px; margin: 0 auto; padding: 2rem; }
+    `.trim();
+
+    fs.writeFileSync(path.join(projectDir, "styles.css"), cssContent);
+    this.log.file("styles.css");
+  }
+
+  generatePage(page, design) {
+    const filename = page.path === "/" ? "index.html" : `${page.intent}.html`;
+    const componentsHtml =
+      page.components
+        ?.map((c) => `<div class="component" id="${c}">${c} Intent</div>`)
+        .join("\n") || "";
+
+    return `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${page.intent}</title>
+    <link rel="stylesheet" href="styles.css">
+</head>
+<body>
+    <div class="container">
+        <h1>${page.intent} Page</h1>
+        <div class="components">
+            ${componentsHtml}
+        </div>
+    </div>
+</body>
+</html>
+    `.trim();
+  }
+
+  generateComponent(componentName, design) {
+    // For Vanilla HTML, components might just be snippets or fragments
+    return {
+      content: `<div class="ebade-component">${componentName}</div>`,
+      testContent: `// No unit test for vanilla HTML component yet`,
+    };
+  }
+
+  generateApiRoute(endpoint) {
+    return `// API Route stub for ${endpoint.path}`;
+  }
+}