README

A modern, entity-first, AI-native content management framework built on PHP 8.5+ and Symfony 7.

Waaseyaa replaces Drupal's legacy runtime with a clean, modular architecture organized as independent Composer packages. Every subsystem — entities, fields, config, caching, routing, access control — is a standalone package with explicit interfaces, no global state, and no hidden coupling.

Features

Entity-first architecture — Content types, users, config, and taxonomy are all entities with a unified persistence pipeline
JSON:API + GraphQL — Dual API layer auto-generated from entity type definitions
AI-native — Entity schemas automatically generate MCP tools, enabling AI agents to create, query, and manage content
Modular monorepo — 62 active packages (plus 3 meta-packages: core, cms, full) organized in 7 architectural layers; see CLAUDE.md for the full layer table
Nuxt 3 admin SPA — Vue 3 + TypeScript admin interface with i18n support
In-memory testable — Every subsystem has in-memory implementations for fast, isolated testing
Zero Drupal dependency — Clean-room implementation inspired by Drupal's entity model, built on Symfony components

Requirements

PHP 8.5 or later
Composer 2.x
SQLite 3 (default) or MySQL/PostgreSQL via Doctrine DBAL

Quick Start

The composer create-project target below installs the published Waaseyaa project skeleton package (waaseyaa/waaseyaa). This repository is the waaseyaa/framework monorepo that supplies the underlying framework packages.

composer create-project waaseyaa/waaseyaa my-site
cd my-site
./vendor/bin/phpunit
bin/waaseyaa serve

The scaffold now creates tests/Unit and tests/Integration, so the default PHPUnit command is usable immediately. For static or marketing-style sites, you can start from the clean scaffold, add a SiteServiceProvider, PageController, Twig templates, and a small regression test before wiring deploy infrastructure.

Create your first content:

curl -X POST http://localhost:8080/api/note \
  -H "Content-Type: application/vnd.api+json" \
  -d '{
    "data": {
      "type": "note",
      "attributes": {
        "title": "Hello, Waaseyaa",
        "body": "My first note."
      }
    }
  }'

Waaseyaa ships with a built-in core.note content type that is always available at boot. To define custom content types, see the waaseyaa/node package as a reference.

Fresh App Workflow

Use this minimal sequence for a new public-facing site:

composer create-project waaseyaa/waaseyaa my-site --stability=dev
cd my-site
./vendor/bin/phpunit
php bin/waaseyaa optimize:manifest
bin/waaseyaa serve

When turning the scaffold into a site:

Add a failing integration test for your public routes and rendered HTML.
Register your site provider in composer.json under extra.waaseyaa.providers.
Add your PageController, SiteServiceProvider, shared Twig layout, and site templates.
Re-run PHPUnit and php bin/waaseyaa optimize:manifest.
Add repo-local deployment files (deploy.php, .github/workflows/*) only after the site passes locally.

Architecture

Waaseyaa is structured as 7 architectural layers with strict downward-only dependencies:

Layer 6  Interfaces      cli, admin, admin-surface, graphql, mcp, ssr,
                         telescope, deployer, inertia
Layer 5  AI              ai-schema, ai-agent, ai-vector, ai-pipeline
Layer 4  API             api, routing
Layer 3  Services        workflows, search, notification, billing, github
Layer 2  Content Types   node, taxonomy, media, path, menu, note, relationship
Layer 1  Core Data       entity, entity-storage, access, user, config, field, auth
Layer 0  Foundation      foundation, cache, plugin, typed-data, database-legacy,
                         testing, i18n, queue, scheduler, state, validation,
                         mail, http-client, ingestion

Three meta-packages provide convenient installation:

Meta-package	Includes
`waaseyaa/core`	Foundation + Core Data
`waaseyaa/cms`	Core + Content Types + API + CLI
`waaseyaa/full`	CMS + AI + GraphQL + SSR + Admin

Entity Persistence Pipeline

All content follows a single, consistent pipeline:

Entity (extends EntityBase or ContentEntityBase)
  -> EntityType registered via EntityTypeManager
  -> EntityStorageDriverInterface (SqlStorageDriver)
  -> EntityRepository (hydration, events, validation)
  -> DatabaseInterface (Doctrine DBAL)

CLI

Waaseyaa includes a comprehensive CLI built on Symfony Console:

bin/waaseyaa install              # Set up database and initial config
bin/waaseyaa serve                # Start the dev server
bin/waaseyaa migrate              # Run pending migrations
bin/waaseyaa entity-type:list     # List registered entity types
bin/waaseyaa entity:create node   # Create an entity interactively
bin/waaseyaa schema:check         # Detect schema drift
bin/waaseyaa health:check         # Run diagnostic health checks
bin/waaseyaa optimize:manifest    # Rebuild attribute-discovery manifest
bin/waaseyaa config:export        # Export config to sync directory
bin/waaseyaa config:import        # Import config from sync directory

Code generation scaffolding:

bin/waaseyaa make:entity          # Generate a content entity class
bin/waaseyaa make:entity-type     # Generate an entity type class
bin/waaseyaa make:policy          # Generate an access policy class
bin/waaseyaa make:provider        # Generate a service provider class
bin/waaseyaa make:migration       # Generate a migration file
bin/waaseyaa make:plugin          # Generate a plugin class
bin/waaseyaa make:listener        # Generate an event listener class
bin/waaseyaa make:job             # Generate a queue job class

Testing

# All tests
./vendor/bin/phpunit

# Unit tests only
./vendor/bin/phpunit --testsuite Unit

# Integration tests only
./vendor/bin/phpunit --testsuite Integration

# Single package
./vendor/bin/phpunit packages/entity/tests/

# Pattern matching
./vendor/bin/phpunit --filter EntityRepository

Code quality:

composer cs-check    # Check code style (PHP-CS-Fixer dry-run)
composer cs-fix      # Auto-fix code style
composer phpstan     # Static analysis (level 5, PHPStan 2)

Key Design Principles

No global state. Every service receives its dependencies through constructor injection.
Interface-first. Public APIs are defined as interfaces. Implementations are swappable.
In-memory testable. Every subsystem has in-memory implementations for fast, isolated testing.
Layered architecture. Each layer only depends on layers below it. No circular dependencies.
AI-native. Entity schemas automatically generate MCP tools, enabling AI agents to interact with content through structured tool calls.

Contributing

Contributions and AI coding agents should follow Spec Kitty–first workflow (missions / work packages under .kittify/) with GitHub for PRs, CI, and optional issues. Human-oriented entry points: CLAUDE.md and AGENTS.md.

Spec Kitty: pip install spec-kitty-cli or uv tool install spec-kitty-cli, then spec-kitty init --here (or spec-kitty upgrade) in a clone; use the PR template line Active Spec Kitty mission when the change comes from a mission.
PRs: Fill .github/pull_request_template.md — link a GitHub #N or the mission / WP you used.
GitHub issues: Optional for every change; when you open one, assign a Track milestone (see docs/specs/workflow.md). M11 governed work still uses the governed-change template as the filing front door.

# Clone the repository
git clone https://github.com/waaseyaa/framework.git
cd framework
composer install

# Run the full test suite
./vendor/bin/phpunit

# Check code style
composer cs-check

License

GPL-2.0-or-later. See LICENSE.txt.

waaseyaa / framework

Maintainers

Package info

Statistics

Security