hexdag-forge 0.2.0.dev3__tar.gz → 0.2.0.dev5__tar.gz

{hexdag_forge-0.2.0.dev3 → hexdag_forge-0.2.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexdag-forge
-Version: 0.2.0.dev3
+Version: 0.2.0.dev5
 Summary: Generate operational systems from prompts — code generator powered by hexDAG
 Project-URL: Homepage, https://hexdag.ai
 Project-URL: Repository, https://github.com/omniviser/hexdag

{hexdag_forge-0.2.0.dev3 → hexdag_forge-0.2.0.dev5}/hexdag_forge/cli.py

@@ -51,6 +51,38 @@ def validate(
     typer.echo("All generated files are valid.")
 
 
+@app.command()
+def run(
+    output: Annotated[
+        Path, typer.Option(help="Path to the generated system directory")
+    ] = "./generated",
+) -> None:
+    """Load and run a generated system via hexDAG System API."""
+    import asyncio
+
+    system_path = output / "system.yaml"
+    if not system_path.exists():
+        typer.echo(
+            f"No system.yaml found in {output}/ — run 'hexdag-forge generate' first.",
+            err=True,
+        )
+        raise typer.Exit(1)
+
+    async def _run() -> None:
+        from hexdag.kernel import System
+
+        typer.echo(f"Loading system from {system_path} ...")
+        async with System.from_yaml(str(system_path)) as system:
+            typer.echo(f"System '{system.config.metadata.get('name', '?')}' ready.")
+            typer.echo(f"  Mode: {'lifecycle' if system.is_lifecycle else 'DAG'}")
+            typer.echo(f"  Processes: {', '.join(system.process_names)}")
+            typer.echo("System loaded successfully. Use the Python API to interact:")
+            typer.echo("  await system.transition(entity_type, entity_id, to_state)")
+            typer.echo("  await system.run_process(process_name, input_data)")
+
+    asyncio.run(_run())
+
+
 @mcp_app.command("serve")
 def mcp_serve(
     transport: Annotated[str, typer.Option(help="Transport: stdio or sse")] = "stdio",

{hexdag_forge-0.2.0.dev3 → hexdag_forge-0.2.0.dev5}/hexdag_forge/domain/business_profile.py

@@ -100,6 +100,7 @@ class BusinessProfile(BaseModel):
     workflows: list[str] = []
     modules: list[str] = []
     app_label: str = ""
+    output_module: str = ""
 
     @model_validator(mode="before")
     @classmethod

{hexdag_forge-0.2.0.dev3 → hexdag_forge-0.2.0.dev5}/hexdag_forge/generator/assembler.py

@@ -18,22 +18,44 @@ from hexdag_forge.generator.service_generator import generate_services
 from hexdag_forge.generator.system_generator import generate_system
 
 
-def assemble(profile: BusinessProfile, output_dir: Path) -> GeneratedSystem:
+def _derive_output_module(output_dir: Path) -> str:
+    """Derive a Python module name from the output directory.
+
+    ``Path("./generated")`` → ``"generated"``
+    ``Path("/home/user/my_app")`` → ``"my_app"``
+    """
+    name = output_dir.resolve().name
+    # Sanitise to valid Python identifier
+    import re
+
+    name = re.sub(r"[^a-zA-Z0-9_]", "_", name).strip("_").lower()
+    return name or "generated"
+
+
+def assemble(
+    profile: BusinessProfile,
+    output_dir: Path,
+    *,
+    skip_migration: bool = False,
+) -> GeneratedSystem:
     """Generate all files from a BusinessProfile and write to output_dir.
 
     Args:
         profile: The business profile to generate from.
         output_dir: Directory to write generated files to.
+        skip_migration: If True, skip migration generation (used when the
+            caller has already generated the migration, e.g. ``forge_migrate``).
 
     Returns:
         GeneratedSystem with metadata about what was generated.
     """
     output_dir.mkdir(parents=True, exist_ok=True)
+    output_module = profile.output_module or _derive_output_module(output_dir)
 
     # Generate all artifacts
     pipelines = generate_pipelines(profile)
     services = generate_services(profile)
-    system_yaml = generate_system(profile)
+    system_yaml = generate_system(profile, output_module=output_module)
     django_files = generate_django(profile)
 
     # Write pipelines
@@ -42,9 +64,10 @@ def assemble(profile: BusinessProfile, output_dir: Path) -> GeneratedSystem:
     for filename, content in pipelines.items():
         (pipelines_dir / filename).write_text(content)
 
-    # Write services
+    # Write services as a proper Python package
     services_dir = output_dir / "services"
     services_dir.mkdir(exist_ok=True)
+    (services_dir / "__init__.py").write_text("")
     for filename, content in services.items():
         (services_dir / filename).write_text(content)
 
@@ -67,19 +90,29 @@ def assemble(profile: BusinessProfile, output_dir: Path) -> GeneratedSystem:
     migrations_dir.mkdir(exist_ok=True)
     (migrations_dir / "__init__.py").write_text("")
 
-    from hexdag_forge.generator.migration_generator import generate_migration
-
-    empty_profile = BusinessProfile(
-        business_name=profile.business_name,
-        business_type=profile.business_type,
-        description=profile.description,
-        entities=[],
-        app_label=profile.app_label,
-    )
-    result = generate_migration(empty_profile, profile, migrations_dir)
-    if result is not None:
-        filename, migration_content = result
-        (migrations_dir / filename).write_text(migration_content)
+    if not skip_migration:
+        from hexdag_forge.generator.migration_generator import generate_migration
+
+        # Use existing profile.json (from a previous run) as the old state so
+        # that diff_profiles produces incremental operations (AddField, etc.)
+        # instead of CreateModel for every entity.  On the first run the file
+        # does not exist yet, so we fall back to an empty profile.
+        profile_path = output_dir / "profile.json"
+        if profile_path.exists():
+            old_profile = BusinessProfile.model_validate_json(profile_path.read_text())
+        else:
+            old_profile = BusinessProfile(
+                business_name=profile.business_name,
+                business_type=profile.business_type,
+                description=profile.description,
+                entities=[],
+                app_label=profile.app_label,
+            )
+
+        result = generate_migration(old_profile, profile, migrations_dir)
+        if result is not None:
+            filename, migration_content = result
+            (migrations_dir / filename).write_text(migration_content)
 
     # Write profile.json for refinement
     (output_dir / "profile.json").write_text(profile.model_dump_json(indent=2))

{hexdag_forge-0.2.0.dev3 → hexdag_forge-0.2.0.dev5}/hexdag_forge/generator/django_generator.py

@@ -4,7 +4,13 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from hexdag_forge.generator.template_engine import render_html_template, render_template
+from hexdag_forge.generator.template_engine import (
+    build_badge_map,
+    build_fk_fields,
+    build_list_columns,
+    render_html_template,
+    render_template,
+)
 
 if TYPE_CHECKING:
     from hexdag_forge.domain.business_profile import BusinessProfile
@@ -17,8 +23,13 @@ def generate_django(profile: BusinessProfile) -> dict[str, str]:
         Dict of relative path -> file content.
     """
     app = profile.app_label
+    badge_colors = build_badge_map(profile)
     files: dict[str, str] = {}
 
+    # Pre-compute per-entity context
+    list_columns_map = {e.name: build_list_columns(e) for e in profile.entities}
+    fk_fields_map = {e.name: build_fk_fields(e) for e in profile.entities}
+
     # ── Python files (standard Jinja2 delimiters) ──────────
     files[f"{app}/models.py"] = render_template("django_model.py.j2", profile=profile)
     files[f"{app}/apps.py"] = render_template("django_apps.py.j2", profile=profile)
@@ -29,10 +40,24 @@ def generate_django(profile: BusinessProfile) -> dict[str, str]:
     files["state_machines.py"] = render_template("state_machines.py.j2", profile=profile)
     files["views.py"] = render_template("django_views.py.j2", profile=profile)
     files["forms.py"] = render_template("django_forms.py.j2", profile=profile)
+    files["chat_agent.py"] = render_template("django_chat_agent.py.j2", profile=profile)
+
+    # Templatetags
+    files[f"{app}/templatetags/__init__.py"] = ""
+    files[f"{app}/templatetags/{app}_tags.py"] = render_template(
+        "django_templatetags.py.j2", profile=profile, badge_colors=badge_colors
+    )
 
     # ── HTML templates (alt delimiters — outputs Django template syntax) ──
     files["templates/base.html"] = render_html_template("django_base.html.j2", profile=profile)
 
+    # Dashboard
+    files["templates/dashboard/index.html"] = render_html_template(
+        "django_dashboard.html.j2",
+        profile=profile,
+        list_columns=list_columns_map,
+    )
+
     # Auth
     files["templates/registration/login.html"] = render_html_template(
         "django_login.html.j2", profile=profile
@@ -47,7 +72,14 @@ def generate_django(profile: BusinessProfile) -> dict[str, str]:
     # Per-entity CRUD templates
     for entity in profile.entities:
         prefix = f"templates/{entity.name}"
-        ctx = {"entity": entity, "profile": profile}
+        list_cols = list_columns_map[entity.name]
+        fk_flds = fk_fields_map[entity.name]
+        ctx = {
+            "entity": entity,
+            "profile": profile,
+            "list_columns": list_cols,
+            "fk_fields": fk_flds,
+        }
         files[f"{prefix}/list.html"] = render_html_template("django_entity_list.html.j2", **ctx)
         files[f"{prefix}/_list_rows.html"] = render_html_template(
             "django_entity_list_partial.html.j2", **ctx
@@ -57,6 +89,9 @@ def generate_django(profile: BusinessProfile) -> dict[str, str]:
             "django_entity_detail_partial.html.j2", **ctx
         )
         files[f"{prefix}/form.html"] = render_html_template("django_entity_form.html.j2", **ctx)
+        files[f"{prefix}/_form_modal.html"] = render_html_template(
+            "django_entity_form_modal.html.j2", **ctx
+        )
         files[f"{prefix}/confirm_delete.html"] = render_html_template(
             "django_entity_confirm_delete.html.j2", **ctx
         )

{hexdag_forge-0.2.0.dev3 → hexdag_forge-0.2.0.dev5}/hexdag_forge/generator/migration_generator.py

@@ -48,6 +48,11 @@ def generate_migration(
     number = _next_migration_number(migrations_dir)
     dependency = _latest_migration_name(migrations_dir)
     operations = _build_operations(diff)
+
+    # Include chat infrastructure models in the initial migration
+    if number == 1:
+        operations.extend(_chat_model_operations())
+
     has_fk = any("ForeignKey" in op for op in operations)
 
     migration_name = f"{number:04d}_auto"
@@ -247,3 +252,43 @@ def _render_alter_states(sc: StateChange) -> str:
         f"            ),\n"
         f"        )"
     )
+
+
+def _chat_model_operations() -> list[str]:
+    """CreateModel operations for the built-in Conversation and Message models."""
+    return [
+        (
+            "migrations.CreateModel(\n"
+            '            name="Conversation",\n'
+            "            fields=[\n"
+            '                ("id", models.BigAutoField(auto_created=True, primary_key=True, '
+            'serialize=False, verbose_name="ID")),\n'
+            '                ("user", models.ForeignKey('
+            "on_delete=django.db.models.deletion.CASCADE, "
+            'related_name="conversations", to="auth.user")),\n'
+            '                ("title", models.CharField('
+            'default="New Conversation", max_length=255)),\n'
+            '                ("created_at", models.DateTimeField(auto_now_add=True)),\n'
+            '                ("updated_at", models.DateTimeField(auto_now=True)),\n'
+            "            ],\n"
+            '            options={"ordering": ["-updated_at"]},\n'
+            "        )"
+        ),
+        (
+            "migrations.CreateModel(\n"
+            '            name="Message",\n'
+            "            fields=[\n"
+            '                ("id", models.BigAutoField(auto_created=True, primary_key=True, '
+            'serialize=False, verbose_name="ID")),\n'
+            '                ("conversation", models.ForeignKey('
+            "on_delete=django.db.models.deletion.CASCADE, "
+            'related_name="messages", to="conversation")),\n'
+            '                ("sender", models.CharField('
+            'choices=[("user", "User"), ("system", "System")], max_length=10)),\n'
+            '                ("content", models.TextField()),\n'
+            '                ("created_at", models.DateTimeField(auto_now_add=True)),\n'
+            "            ],\n"
+            '            options={"ordering": ["created_at"]},\n'
+            "        )"
+        ),
+    ]

{hexdag_forge-0.2.0.dev3 → hexdag_forge-0.2.0.dev5}/hexdag_forge/generator/pipeline_generator.py

@@ -21,4 +21,8 @@ def generate_pipelines(profile: BusinessProfile) -> dict[str, str]:
         filename = f"{entity.name}_lifecycle.yaml"
         content = render_template("pipeline.yaml.j2", entity=entity)
         pipelines[filename] = content
+
+    # Chat agent pipeline
+    pipelines["chat_agent.yaml"] = render_template("chat_pipeline.yaml.j2", profile=profile)
+
     return pipelines

{hexdag_forge-0.2.0.dev3 → hexdag_forge-0.2.0.dev5}/hexdag_forge/generator/system_generator.py

@@ -11,11 +11,21 @@ if TYPE_CHECKING:
     from hexdag_forge.domain.business_profile import BusinessProfile
 
 
-def generate_system(profile: BusinessProfile) -> str:
+def generate_system(profile: BusinessProfile, *, output_module: str = "generated") -> str:
     """Generate the kind: System YAML manifest.
 
     Uses LifecycleRunner (because state_machines is declared).
     Each entity state maps to a process pipeline via on_enter.
+
+    Args:
+        profile: The business profile.
+        output_module: Python module name for the generated output directory.
+            Used to build absolute import paths for services.
     """
     terminal_states = generate_terminal_states_map(profile)
-    return render_template("system.yaml.j2", profile=profile, terminal_states=terminal_states)
+    return render_template(
+        "system.yaml.j2",
+        profile=profile,
+        terminal_states=terminal_states,
+        output_module=output_module,
+    )

hexdag_forge-0.2.0.dev5/hexdag_forge/generator/template_engine.py

@@ -0,0 +1,209 @@
+"""Jinja2 template rendering engine for code generation."""
+
+from __future__ import annotations
+
+from pathlib import Path  # noqa: TC003
+from typing import TYPE_CHECKING
+
+from jinja2 import Environment, FileSystemLoader
+
+if TYPE_CHECKING:
+    from hexdag_forge.domain.business_profile import BusinessProfile, EntitySpec
+
+_TEMPLATE_DIR = Path(__file__).parent.parent / "templates"
+
+
+# ── Jinja2 filters ──────────────────────────────────────────
+
+
+def _to_pascal(value: str) -> str:
+    """Convert snake_case to PascalCase: ``freight_brokerage`` → ``FreightBrokerage``."""
+    return "".join(word.capitalize() for word in value.split("_"))
+
+
+def _humanize(value: str) -> str:
+    """Convert snake_case to human-readable: ``company_name`` → ``Company Name``."""
+    return value.replace("_", " ").title()
+
+
+def _status_color(state: str) -> str:
+    """Map a state name to a CSS badge color class using naming heuristics."""
+    s = state.upper()
+    # Exact matches
+    _GREEN = {
+        "COMPLETED",
+        "DELIVERED",
+        "DONE",
+        "APPROVED",
+        "ACTIVE",
+        "PAID",
+        "RESOLVED",
+        "AVAILABLE",
+        "PICKED_UP",
+    }
+    _RED = {
+        "CANCELLED",
+        "REJECTED",
+        "FAILED",
+        "SUSPENDED",
+        "BLOCKED",
+        "EXPIRED",
+        "DELETED",
+        "TERMINATED",
+        "VOID",
+        "RETIRED",
+        "CLOSED",
+    }
+    _BLUE = {
+        "DISPATCHED",
+        "SENT",
+        "ONBOARDING",
+        "CONFIRMED",
+        "ASSIGNED",
+    }
+    _PURPLE = {
+        "IN_TRANSIT",
+        "IN_PROGRESS",
+        "PROCESSING",
+        "ON_TRIP",
+        "IN_USE",
+        "COVERED",
+    }
+    _YELLOW = {
+        "SUSPENDED",
+        "MAINTENANCE",
+        "INVOICED",
+        "OVERDUE",
+        "OFF_DUTY",
+    }
+    _GRAY = {
+        "DRAFT",
+        "PENDING",
+        "NEW",
+        "POSTED",
+        "PROSPECT",
+        "CREATED",
+        "QUEUED",
+    }
+
+    if s in _GREEN:
+        return "badge-green"
+    if s in _RED:
+        return "badge-red"
+    if s in _PURPLE:
+        return "badge-purple"
+    if s in _YELLOW:
+        return "badge-yellow"
+    if s in _BLUE:
+        return "badge-blue"
+    if s in _GRAY:
+        return "badge-gray"
+
+    # Keyword heuristic fallback
+    if any(kw in s for kw in ("COMPLET", "DELIVER", "DONE", "APPROV", "ACTIV", "AVAIL", "PAID")):
+        return "badge-green"
+    if any(kw in s for kw in ("CANCEL", "REJECT", "FAIL", "TERMINAT", "VOID", "RETIR", "CLOSE")):
+        return "badge-red"
+    if any(kw in s for kw in ("TRANSIT", "TRIP", "PROGRESS", "PROCESS", "USE")):
+        return "badge-purple"
+    if any(kw in s for kw in ("SUSPEND", "MAINT", "OVERDUE")):
+        return "badge-yellow"
+    if any(kw in s for kw in ("DISPATCH", "SENT", "ONBOARD", "REVIEW")):
+        return "badge-blue"
+    return "badge-gray"
+
+
+def _transition_color(state: str) -> str:
+    """Map a target state to a button CSS class for transition buttons."""
+    color = _status_color(state)
+    return {
+        "badge-green": "btn-success",
+        "badge-red": "btn-danger",
+        "badge-purple": "btn-primary",
+        "badge-blue": "btn-primary",
+        "badge-yellow": "btn-warning",
+        "badge-gray": "btn-outline",
+    }.get(color, "btn-outline")
+
+
+# ── Context builders ────────────────────────────────────────
+
+
+def build_badge_map(profile: BusinessProfile) -> dict[str, str]:
+    """Build a {state_name: badge_class} map for all states across all entities."""
+    result: dict[str, str] = {}
+    for entity in profile.entities:
+        for state in entity.states:
+            result[state] = _status_color(state)
+    return result
+
+
+def build_list_columns(entity: EntitySpec) -> list[object]:
+    """Select fields suitable for list table display (skip text/json, cap at 5)."""
+    return [f for f in entity.fields if f.type not in ("text", "json")][:5]
+
+
+def build_fk_fields(entity: EntitySpec) -> list[object]:
+    """Return belongs_to relationship specs for select_related."""
+    return [r for r in entity.relationships if r.kind == "belongs_to"]
+
+
+# ── Environments ────────────────────────────────────────────
+
+
+def _register_filters(env: Environment) -> None:
+    """Register all custom filters on a Jinja2 environment."""
+    env.filters["to_pascal"] = _to_pascal
+    env.filters["humanize"] = _humanize
+    env.filters["status_color"] = _status_color
+    env.filters["transition_color"] = _transition_color
+
+
+def create_env() -> Environment:
+    """Create a Jinja2 environment configured for Python code generation."""
+    env = Environment(  # nosec B701 — code generation templates, not HTML
+        loader=FileSystemLoader(str(_TEMPLATE_DIR)),
+        keep_trailing_newline=True,
+        trim_blocks=True,
+        lstrip_blocks=True,
+        autoescape=False,
+    )
+    _register_filters(env)
+    return env
+
+
+def create_html_env() -> Environment:
+    """Create a Jinja2 environment for templates that OUTPUT Django template syntax.
+
+    Uses alternate delimiters to avoid collision with Django's ``{% %}`` and ``{{ }}``.
+    Jinja2 generation uses ``[% %]`` and ``[[ ]]``, Django tags pass through untouched.
+    """
+    env = Environment(  # nosec B701 — code generation templates, not HTML
+        loader=FileSystemLoader(str(_TEMPLATE_DIR)),
+        keep_trailing_newline=True,
+        trim_blocks=True,
+        lstrip_blocks=True,
+        autoescape=False,
+        block_start_string="[%",
+        block_end_string="%]",
+        variable_start_string="[[",
+        variable_end_string="]]",
+        comment_start_string="[#",
+        comment_end_string="#]",
+    )
+    _register_filters(env)
+    return env
+
+
+def render_template(template_name: str, **context: object) -> str:
+    """Render a Jinja2 template with the given context (standard delimiters)."""
+    env = create_env()
+    template = env.get_template(template_name)
+    return template.render(**context)
+
+
+def render_html_template(template_name: str, **context: object) -> str:
+    """Render a Jinja2 template that outputs Django template syntax (alt delimiters)."""
+    env = create_html_env()
+    template = env.get_template(template_name)
+    return template.render(**context)

{hexdag_forge-0.2.0.dev3 → hexdag_forge-0.2.0.dev5}/hexdag_forge/mcp/server.py

@@ -117,7 +117,7 @@ async def forge_migrate(new_profile_json: str, output_dir: str = "./generated")
             migration_info = {"migration": filename, "operations": content.count("migrations.")}
 
     # Regenerate all files with new profile
-    gen_result = assemble(new_profile, output)
+    gen_result = assemble(new_profile, output, skip_migration=True)
 
     return json.dumps(
         {

hexdag_forge-0.2.0.dev5/hexdag_forge/runtime/__init__.py

@@ -0,0 +1 @@
+"""Runtime adapters for forge-generated systems."""

hexdag_forge-0.2.0.dev5/hexdag_forge/runtime/django_store.py

@@ -0,0 +1,124 @@
+"""Django ORM implementation of SupportsEntityStore.
+
+Uses ``django.apps.registry.apps.get_model()`` for dynamic model lookup,
+matching forge's pattern where entity names map directly to Django model names.
+
+Requires Django to be installed and configured (``DJANGO_SETTINGS_MODULE``).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class DjangoEntityStore:
+    """Django ORM adapter for forge-generated entity models.
+
+    Parameters
+    ----------
+    app_label:
+        The Django app label (e.g. ``"freight_brokerage"``).
+        Must match the app_label used by forge during generation.
+    """
+
+    def __init__(self, app_label: str) -> None:
+        self._app_label = app_label
+
+    def _get_model(self, entity_type: str) -> Any:
+        """Resolve a Django model class from entity_type name."""
+        from django.apps import apps  # type: ignore[import-not-found]  # noqa: PLC0415
+
+        return apps.get_model(self._app_label, entity_type)
+
+    @staticmethod
+    def _to_dict(obj: Any) -> dict[str, Any]:
+        """Convert a Django model instance to a dict."""
+        from django.forms.models import (
+            model_to_dict,  # type: ignore[import-not-found]  # noqa: PLC0415
+        )
+
+        d: dict[str, Any] = model_to_dict(obj)
+        d["id"] = str(obj.pk)
+        return d
+
+    async def create(
+        self, entity_type: str, data: dict[str, Any], initial_state: str
+    ) -> dict[str, Any]:
+        """Create a new entity record via Django ORM."""
+        from asgiref.sync import sync_to_async  # type: ignore[import-not-found]  # noqa: PLC0415
+
+        model = self._get_model(entity_type)
+        obj = await sync_to_async(model.objects.create)(**data, status=initial_state)
+        return self._to_dict(obj)
+
+    async def get(self, entity_type: str, entity_id: str) -> dict[str, Any]:
+        """Retrieve a single entity by primary key."""
+        from asgiref.sync import sync_to_async  # type: ignore[import-not-found]  # noqa: PLC0415
+
+        model = self._get_model(entity_type)
+        obj = await sync_to_async(model.objects.get)(pk=entity_id)
+        return self._to_dict(obj)
+
+    async def list_all(
+        self,
+        entity_type: str,
+        status: str | None = None,
+        limit: int = 50,
+    ) -> list[dict[str, Any]]:
+        """List entities, optionally filtered by status field."""
+        from asgiref.sync import sync_to_async  # type: ignore[import-not-found]  # noqa: PLC0415
+
+        model = self._get_model(entity_type)
+        qs = model.objects.all()
+        if status is not None:
+            qs = qs.filter(status=status)
+        qs = qs[:limit]
+        objects = await sync_to_async(list)(qs)
+        return [self._to_dict(obj) for obj in objects]
+
+    async def update(
+        self, entity_type: str, entity_id: str, data: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Update fields on an existing entity."""
+        from asgiref.sync import sync_to_async  # type: ignore[import-not-found]  # noqa: PLC0415
+
+        model = self._get_model(entity_type)
+        obj = await sync_to_async(model.objects.get)(pk=entity_id)
+        for key, value in data.items():
+            setattr(obj, key, value)
+        await sync_to_async(obj.save)()
+        return self._to_dict(obj)
+
+    async def delete(self, entity_type: str, entity_id: str) -> dict[str, Any]:
+        """Delete an entity by primary key."""
+        from asgiref.sync import sync_to_async  # type: ignore[import-not-found]  # noqa: PLC0415
+
+        model = self._get_model(entity_type)
+        obj = await sync_to_async(model.objects.get)(pk=entity_id)
+        result = self._to_dict(obj)
+        await sync_to_async(obj.delete)()
+        return {"deleted": True, **result}
+
+    async def transition(
+        self,
+        entity_type: str,
+        entity_id: str,
+        to_state: str,
+        reason: str = "",
+    ) -> dict[str, Any]:
+        """Transition an entity to a new state by updating the status field."""
+        from asgiref.sync import sync_to_async  # type: ignore[import-not-found]  # noqa: PLC0415
+
+        model = self._get_model(entity_type)
+        obj = await sync_to_async(model.objects.get)(pk=entity_id)
+        from_state = obj.status
+        obj.status = to_state
+        await sync_to_async(obj.save)(update_fields=["status"])
+        return {
+            "id": str(obj.pk),
+            "entity_type": entity_type,
+            "from_state": from_state,
+            "to_state": to_state,
+            "reason": reason,
+            "status": to_state,
+        }