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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexdag-forge
-Version: 0.2.0.dev4
+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.dev4 → 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.dev4 → 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.dev4 → hexdag_forge-0.2.0.dev5}/hexdag_forge/generator/assembler.py

@@ -18,6 +18,20 @@ from hexdag_forge.generator.service_generator import generate_services
 from hexdag_forge.generator.system_generator import generate_system
 
 
+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,
@@ -36,11 +50,12 @@ def assemble(
         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
@@ -49,9 +64,10 @@ def assemble(
     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)
 

{hexdag_forge-0.2.0.dev4 → 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.dev4 → 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/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,
+        }

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

@@ -0,0 +1,59 @@
+"""SupportsEntityStore — port protocol for forge-generated services.
+
+Forge-generated services call ``self._db.create()``, ``.get()``,
+``.list_all()``, ``.update()``, ``.delete()``, and ``.transition()``.
+This protocol formalises that interface so adapters can be swapped
+(Django ORM, in-memory, SQLAlchemy, etc.).
+"""
+
+from __future__ import annotations
+
+from typing import Any, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class SupportsEntityStore(Protocol):
+    """CRUD + state-transition storage for forge-generated entities."""
+
+    async def create(
+        self, entity_type: str, data: dict[str, Any], initial_state: str
+    ) -> dict[str, Any]:
+        """Create a new entity record.
+
+        Returns:
+            Dict with at least ``id`` and ``status`` keys.
+        """
+        ...
+
+    async def get(self, entity_type: str, entity_id: str) -> dict[str, Any]:
+        """Retrieve a single entity by ID."""
+        ...
+
+    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."""
+        ...
+
+    async def update(
+        self, entity_type: str, entity_id: str, data: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Update fields on an existing entity."""
+        ...
+
+    async def delete(self, entity_type: str, entity_id: str) -> dict[str, Any]:
+        """Delete an entity. Returns metadata about the deletion."""
+        ...
+
+    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."""
+        ...

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

@@ -0,0 +1,95 @@
+"""In-memory implementation of SupportsEntityStore.
+
+No external dependencies — useful for testing, demos, and quick iteration.
+"""
+
+from __future__ import annotations
+
+import uuid
+from typing import Any
+
+
+class InMemoryEntityStore:
+    """Dict-backed entity store for testing and demos.
+
+    Data is lost when the process exits. Each entity type is stored in
+    a separate dict keyed by entity ID.
+    """
+
+    def __init__(self) -> None:
+        self._data: dict[str, dict[str, dict[str, Any]]] = {}
+
+    async def create(
+        self, entity_type: str, data: dict[str, Any], initial_state: str
+    ) -> dict[str, Any]:
+        """Create a new entity with a generated UUID."""
+        store = self._data.setdefault(entity_type, {})
+        entity_id = str(uuid.uuid4())
+        record = {"id": entity_id, "status": initial_state, **data}
+        store[entity_id] = record
+        return dict(record)
+
+    async def get(self, entity_type: str, entity_id: str) -> dict[str, Any]:
+        """Retrieve an entity by ID. Raises KeyError if not found."""
+        store = self._data.get(entity_type, {})
+        if entity_id not in store:
+            msg = f"{entity_type} with id {entity_id!r} not found"
+            raise KeyError(msg)
+        return dict(store[entity_id])
+
+    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."""
+        store = self._data.get(entity_type, {})
+        records = list(store.values())
+        if status is not None:
+            records = [r for r in records if r.get("status") == status]
+        return [dict(r) for r in records[:limit]]
+
+    async def update(
+        self, entity_type: str, entity_id: str, data: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Update fields on an existing entity."""
+        store = self._data.get(entity_type, {})
+        if entity_id not in store:
+            msg = f"{entity_type} with id {entity_id!r} not found"
+            raise KeyError(msg)
+        store[entity_id].update(data)
+        return dict(store[entity_id])
+
+    async def delete(self, entity_type: str, entity_id: str) -> dict[str, Any]:
+        """Delete an entity. Raises KeyError if not found."""
+        store = self._data.get(entity_type, {})
+        if entity_id not in store:
+            msg = f"{entity_type} with id {entity_id!r} not found"
+            raise KeyError(msg)
+        record = store.pop(entity_id)
+        return {"deleted": True, "id": entity_id, "entity_type": entity_type, **record}
+
+    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."""
+        store = self._data.get(entity_type, {})
+        if entity_id not in store:
+            msg = f"{entity_type} with id {entity_id!r} not found"
+            raise KeyError(msg)
+        record = store[entity_id]
+        from_state = record["status"]
+        record["status"] = to_state
+        return {
+            "id": entity_id,
+            "entity_type": entity_type,
+            "from_state": from_state,
+            "to_state": to_state,
+            "reason": reason,
+            **record,
+        }

{hexdag_forge-0.2.0.dev4 → hexdag_forge-0.2.0.dev5}/hexdag_forge/templates/chat_pipeline.yaml.j2

@@ -4,6 +4,12 @@ metadata:
   name: chat_agent
   description: "Chat agent for {{ profile.business_name }} — routes user messages to entity services"
 spec:
+  services:
+{% for entity in profile.entities %}
+    {{ entity.name }}_svc:
+      class: "services.{{ entity.name | capitalize }}Service"
+{% endfor %}
+
   nodes:
     - kind: agent_node
       metadata:
@@ -27,7 +33,7 @@ spec:
           Always confirm destructive actions before executing them.
           When listing results, format them clearly.
 
-          User message: {% raw %}{{message}}{% endraw %}
+          User message: {{ '{{message}}' }}
         config:
           max_steps: 10
       dependencies: []

{hexdag_forge-0.2.0.dev4 → hexdag_forge-0.2.0.dev5}/hexdag_forge/templates/django_base.html.j2

@@ -107,14 +107,18 @@
             <li><a href="/">&#9632; Dashboard</a></li>
         </ul>
 [% if profile.modules %]
+        <div class="sidebar-section">Modules</div>
+        <ul>
 [% for module in profile.modules %]
-        <div class="sidebar-section">[[ module | humanize ]]</div>
+            <li><small>[[ module | humanize ]]</small></li>
+[% endfor %]
+        </ul>
+        <div class="sidebar-section">Entities</div>
         <ul>
 [% for entity in profile.entities %]
             <li><a href="/[[ entity.name ]]/">[[ entity.display_name ]]</a></li>
 [% endfor %]
         </ul>
-[% endfor %]
 [% else %]
         <div class="sidebar-section">Entities</div>
         <ul>

hexdag_forge-0.2.0.dev5/hexdag_forge/templates/django_chat.html.j2

@@ -0,0 +1,119 @@
+{% extends "base.html" %}
+{% block title %}Chat — [[ profile.business_name ]]{% endblock %}
+{% block heading %}<h2>Chat</h2>{% endblock %}
+{% block content %}
+<div class="chat-layout">
+    <aside class="chat-sidebar">
+        <form method="post" action="/chat/new/">
+            {% csrf_token %}
+            <button type="submit" class="btn btn-primary" style="width: 100%; margin-bottom: 0.75rem;">+ New Chat</button>
+        </form>
+        <ul class="chat-conv-list">
+            {% for conv in conversations %}
+            <li>
+                <a href="/chat/{{ conv.pk }}/"
+                   class="chat-conv-item{% if conversation and conversation.pk == conv.pk %} active{% endif %}">
+                    <span class="chat-conv-title">{{ conv.title|truncatechars:30 }}</span>
+                    <span class="chat-conv-time">{{ conv.updated_at|date:"M d" }}</span>
+                </a>
+            </li>
+            {% empty %}
+            <li class="empty-state" style="padding: 1rem;"><small>No conversations yet</small></li>
+            {% endfor %}
+        </ul>
+    </aside>
+    <div class="chat-main">
+        {% if conversation %}
+        <div class="chat-header">
+            <strong>{{ conversation.title|truncatechars:50 }}</strong>
+            <small style="color: #6b7280;">{{ conversation.messages.count }} messages</small>
+        </div>
+        <div id="messages" class="chat-messages">
+            {% include "chat/_messages.html" %}
+        </div>
+        <form class="chat-input"
+              hx-post="/chat/send/"
+              hx-target="#messages"
+              hx-swap="innerHTML"
+              hx-on::after-request="this.querySelector('textarea').value = ''; document.getElementById('messages').scrollTop = document.getElementById('messages').scrollHeight;"
+              hx-indicator="#send-indicator">
+            {% csrf_token %}
+            <input type="hidden" name="conversation_id" value="{{ conversation.pk }}">
+            <textarea name="content"
+                      rows="1"
+                      placeholder="Type a message..."
+                      onkeydown="if(event.key==='Enter'&&!event.shiftKey){event.preventDefault();this.closest('form').requestSubmit();}"></textarea>
+            <button type="submit" class="btn btn-primary">
+                <span id="send-indicator" class="htmx-indicator" style="display:none;">
+                    <span class="spinner"></span>
+                </span>
+                <span class="send-label">Send</span>
+            </button>
+        </form>
+        {% else %}
+        <div class="chat-empty">
+            <div class="chat-empty-icon">&#9993;</div>
+            <h3>Start a conversation</h3>
+            <p>Create a new chat or select one from the sidebar.</p>
+            <form method="post" action="/chat/new/" style="margin-top: 1rem;">
+                {% csrf_token %}
+                <button type="submit" class="btn btn-primary">+ New Chat</button>
+            </form>
+        </div>
+        {% endif %}
+    </div>
+</div>
+
+<style>
+    /* ── Chat Layout ───────────────────────── */
+    .chat-layout { display: flex; height: calc(100vh - 120px); background: #fff; border-radius: 8px; box-shadow: 0 1px 3px rgba(0,0,0,0.05); overflow: hidden; }
+
+    /* ── Sidebar ────────────────────────────── */
+    .chat-sidebar { width: 240px; border-right: 1px solid #e5e7eb; padding: 1rem; overflow-y: auto; background: #f9fafb; flex-shrink: 0; }
+    .chat-conv-list { list-style: none; }
+    .chat-conv-item { display: flex; flex-direction: column; padding: 0.5rem 0.75rem; border-radius: 6px; color: #374151; font-size: 0.85rem; transition: background 0.15s; }
+    .chat-conv-item:hover { background: #e5e7eb; text-decoration: none; }
+    .chat-conv-item.active { background: #dbeafe; color: #1e40af; }
+    .chat-conv-title { font-weight: 500; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+    .chat-conv-time { font-size: 0.7rem; color: #9ca3af; margin-top: 0.15rem; }
+
+    /* ── Main Area ──────────────────────────── */
+    .chat-main { flex: 1; display: flex; flex-direction: column; min-width: 0; }
+    .chat-header { padding: 0.75rem 1.25rem; border-bottom: 1px solid #e5e7eb; display: flex; justify-content: space-between; align-items: center; background: #fff; }
+    .chat-messages { flex: 1; overflow-y: auto; padding: 1.25rem; display: flex; flex-direction: column; gap: 0.75rem; }
+
+    /* ── Message Bubbles ────────────────────── */
+    .msg { max-width: 75%; padding: 0.6rem 0.9rem; border-radius: 12px; font-size: 0.85rem; line-height: 1.5; word-wrap: break-word; }
+    .msg-user { align-self: flex-end; background: #2563eb; color: #fff; border-bottom-right-radius: 4px; }
+    .msg-system { align-self: flex-start; background: #f3f4f6; color: #1f2937; border-bottom-left-radius: 4px; }
+    .msg-meta { font-size: 0.65rem; margin-top: 0.25rem; opacity: 0.7; }
+    .msg-user .msg-meta { text-align: right; }
+    .msg-content { white-space: pre-wrap; }
+
+    /* ── Input Bar ──────────────────────────── */
+    .chat-input { display: flex; gap: 0.5rem; padding: 0.75rem 1.25rem; border-top: 1px solid #e5e7eb; background: #fff; align-items: flex-end; }
+    .chat-input textarea { flex: 1; padding: 0.5rem 0.75rem; border: 1px solid #d1d5db; border-radius: 8px; font-size: 0.85rem; font-family: inherit; resize: none; max-height: 120px; line-height: 1.4; }
+    .chat-input textarea:focus { outline: none; border-color: #2563eb; box-shadow: 0 0 0 2px rgba(37,99,235,0.15); }
+    .chat-input button { flex-shrink: 0; height: 36px; min-width: 64px; }
+
+    /* ── Empty State ────────────────────────── */
+    .chat-empty { display: flex; flex-direction: column; align-items: center; justify-content: center; flex: 1; color: #6b7280; }
+    .chat-empty-icon { font-size: 2.5rem; margin-bottom: 0.75rem; }
+    .chat-empty h3 { color: #374151; margin-bottom: 0.35rem; }
+    .chat-empty p { font-size: 0.85rem; }
+
+    /* ── Spinner ─────────────────────────────── */
+    .spinner { display: inline-block; width: 14px; height: 14px; border: 2px solid #fff; border-top-color: transparent; border-radius: 50%; animation: spin 0.6s linear infinite; }
+    @keyframes spin { to { transform: rotate(360deg); } }
+    .htmx-request .send-label { display: none; }
+    .htmx-request .htmx-indicator { display: inline-block !important; }
+</style>
+
+<script>
+    // Auto-scroll to bottom on page load
+    document.addEventListener("DOMContentLoaded", function() {
+        var el = document.getElementById("messages");
+        if (el) el.scrollTop = el.scrollHeight;
+    });
+</script>
+{% endblock %}

hexdag_forge-0.2.0.dev5/hexdag_forge/templates/django_chat_conversations.html.j2

@@ -0,0 +1,27 @@
+{% extends "base.html" %}
+{% block title %}Chat — [[ profile.business_name ]]{% endblock %}
+{% block heading %}<h2>Chat</h2>{% endblock %}
+{% block content %}
+<div class="toolbar">
+    <div></div>
+    <form method="post" action="/chat/new/">
+        {% csrf_token %}
+        <button type="submit" class="btn btn-primary">+ New Conversation</button>
+    </form>
+</div>
+{% if conversations %}
+<div style="display: grid; grid-template-columns: repeat(auto-fill, minmax(280px, 1fr)); gap: 1rem;">
+    {% for conv in conversations %}
+    <a href="/chat/{{ conv.pk }}/" class="card" style="text-decoration: none; color: inherit; transition: box-shadow 0.15s;">
+        <div style="font-weight: 600; color: #111827; margin-bottom: 0.35rem;">{{ conv.title|truncatechars:40 }}</div>
+        <div style="font-size: 0.78rem; color: #6b7280;">{{ conv.updated_at|date:"M d, H:i" }}</div>
+    </a>
+    {% endfor %}
+</div>
+{% else %}
+<div class="empty-state" style="padding: 3rem;">
+    <p style="font-size: 1rem; margin-bottom: 0.5rem;">No conversations yet</p>
+    <p style="font-size: 0.85rem;">Start a new conversation to chat with the AI assistant.</p>
+</div>
+{% endif %}
+{% endblock %}

hexdag_forge-0.2.0.dev5/hexdag_forge/templates/django_chat_messages_partial.html.j2

@@ -0,0 +1,10 @@
+{% for msg in messages %}
+<div class="msg msg-{{ msg.sender }}">
+    <div class="msg-content">{{ msg.content }}</div>
+    <div class="msg-meta">{{ msg.created_at|date:"H:i" }}</div>
+</div>
+{% empty %}
+<div class="chat-empty" style="padding: 2rem;">
+    <p><small>No messages yet. Send one to get started.</small></p>
+</div>
+{% endfor %}

{hexdag_forge-0.2.0.dev4 → hexdag_forge-0.2.0.dev5}/hexdag_forge/templates/pipeline.yaml.j2

@@ -5,19 +5,15 @@ metadata:
   description: "Lifecycle pipeline for {{ entity.display_name }}"
 
 spec:
-  services:
-    db:
-      class: "services.{{ entity.name | capitalize }}Service"
-
   nodes:
     - kind: service_call_node
       metadata:
         name: get_{{ entity.name }}
       spec:
-        service: db
+        service: {{ entity.name }}_svc
         method: get_{{ entity.name }}
         input_mapping:
-          {{ entity.name }}_id: "$input.{{ entity.name }}_id"
+          {{ entity.name }}_id: "$input.entity_id"
 
     - kind: expression_node
       metadata:
@@ -25,16 +21,16 @@ spec:
       spec:
         expressions:
           current_state: "get_{{ entity.name }}.status"
-          target_state: "$input.target_state"
+          target_state: "$input.to_state"
         output_fields: [current_state, target_state]
 
     - kind: service_call_node
       metadata:
         name: do_transition
       spec:
-        service: db
+        service: {{ entity.name }}_svc
         method: transition_{{ entity.name }}
         input_mapping:
-          {{ entity.name }}_id: "$input.{{ entity.name }}_id"
-          to_state: "validate_transition.target_state"
+          {{ entity.name }}_id: "$input.entity_id"
+          to_state: "$input.to_state"
           reason: "$input.reason"

{hexdag_forge-0.2.0.dev4 → hexdag_forge-0.2.0.dev5}/hexdag_forge/templates/system.yaml.j2

@@ -5,6 +5,12 @@ metadata:
   description: "{{ profile.description | truncate(200) }}"
 
 spec:
+  ports:
+    entity_store:
+      adapter: "hexdag_forge.runtime.django_store.DjangoEntityStore"
+      config:
+        app_label: "{{ profile.app_label }}"
+
   state_machines:
 {% for entity in profile.entities %}
     {{ entity.name }}:
@@ -41,5 +47,7 @@ spec:
   services:
 {% for entity in profile.entities %}
     {{ entity.name }}_svc:
-      class: "services.{{ entity.name | capitalize }}Service"
+      class: "{{ output_module }}.services.{{ entity.name }}_service.{{ entity.name | capitalize }}Service"
+      config:
+        db: "entity_store"
 {% endfor %}

{hexdag_forge-0.2.0.dev4 → hexdag_forge-0.2.0.dev5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hexdag-forge"
-version = "0.2.0.dev4"
+version = "0.2.0.dev5"
 description = "Generate operational systems from prompts — code generator powered by hexDAG"
 readme = "README.md"
 requires-python = ">=3.12"

{hexdag_forge-0.2.0.dev4 → hexdag_forge-0.2.0.dev5}/tests/test_generator/test_assembler.py

@@ -94,11 +94,14 @@ class TestAssemble:
 
     def test_generates_services(self, tmp_path: Path):
         assemble(_freight_profile(), tmp_path)
-        services = list((tmp_path / "services").glob("*.py"))
-        assert len(services) == 2
-        names = {s.name for s in services}
+        services_dir = tmp_path / "services"
+        service_files = [f for f in services_dir.glob("*.py") if f.name != "__init__.py"]
+        assert len(service_files) == 2
+        names = {s.name for s in service_files}
         assert "load_service.py" in names
         assert "carrier_service.py" in names
+        # Services dir is a proper Python package
+        assert (services_dir / "__init__.py").exists()
 
     def test_services_have_valid_python(self, tmp_path: Path):
         assemble(_freight_profile(), tmp_path)
@@ -211,6 +214,48 @@ class TestAssemble:
         migrations = list(migrations_dir.glob("0001_*.py"))
         assert len(migrations) == 1
 
+    def test_system_yaml_has_ports(self, tmp_path: Path):
+        assemble(_freight_profile(), tmp_path)
+        content = (tmp_path / "system.yaml").read_text()
+        assert "ports:" in content
+        assert "entity_store:" in content
+        assert "hexdag_forge.runtime.django_store.DjangoEntityStore" in content
+        assert "app_label:" in content
+
+    def test_system_yaml_services_reference_entity_store(self, tmp_path: Path):
+        assemble(_freight_profile(), tmp_path)
+        content = (tmp_path / "system.yaml").read_text()
+        assert 'db: "entity_store"' in content
+
+    def test_system_yaml_service_paths_contain_output_module(self, tmp_path: Path):
+        output = tmp_path / "my_app"
+        assemble(_freight_profile(), output)
+        content = (output / "system.yaml").read_text()
+        # Service class paths should be absolute: output_module.services.entity_service.Class
+        assert "my_app.services.load_service.LoadService" in content
+        assert "my_app.services.carrier_service.CarrierService" in content
+
+    def test_pipeline_uses_lifecycle_input(self, tmp_path: Path):
+        assemble(_freight_profile(), tmp_path)
+        content = (tmp_path / "pipelines" / "load_lifecycle.yaml").read_text()
+        # Should reference $input.entity_id (from lifecycle runner), not $input.load_id
+        assert "$input.entity_id" in content
+        assert "$input.to_state" in content
+        assert "$input.reason" in content
+
+    def test_pipeline_references_system_service(self, tmp_path: Path):
+        assemble(_freight_profile(), tmp_path)
+        content = (tmp_path / "pipelines" / "load_lifecycle.yaml").read_text()
+        # Pipeline should reference load_svc (matching system.yaml service name)
+        assert "load_svc" in content
+
+    def test_output_module_override(self, tmp_path: Path):
+        profile = _freight_profile()
+        profile = profile.model_copy(update={"output_module": "custom_module"})
+        assemble(profile, tmp_path)
+        content = (tmp_path / "system.yaml").read_text()
+        assert "custom_module.services.load_service.LoadService" in content
+
 
 class TestIncrementalMigration:
     """Verify that calling assemble() twice produces incremental migrations."""

hexdag_forge-0.2.0.dev5/tests/test_runtime/test_memory_store.py

@@ -0,0 +1,129 @@
+"""Tests for InMemoryEntityStore."""
+
+import pytest
+
+from hexdag_forge.runtime.memory_store import InMemoryEntityStore
+
+
+@pytest.fixture
+def store() -> InMemoryEntityStore:
+    return InMemoryEntityStore()
+
+
+class TestCreate:
+    async def test_returns_record_with_id_and_status(self, store: InMemoryEntityStore):
+        record = await store.create("load", {"origin": "NYC", "destination": "LA"}, "POSTED")
+        assert "id" in record
+        assert record["status"] == "POSTED"
+        assert record["origin"] == "NYC"
+
+    async def test_generates_unique_ids(self, store: InMemoryEntityStore):
+        r1 = await store.create("load", {}, "POSTED")
+        r2 = await store.create("load", {}, "POSTED")
+        assert r1["id"] != r2["id"]
+
+    async def test_separate_entity_types(self, store: InMemoryEntityStore):
+        await store.create("load", {"x": 1}, "POSTED")
+        await store.create("carrier", {"y": 2}, "PENDING")
+        loads = await store.list_all("load")
+        carriers = await store.list_all("carrier")
+        assert len(loads) == 1
+        assert len(carriers) == 1
+
+
+class TestGet:
+    async def test_retrieves_existing_record(self, store: InMemoryEntityStore):
+        created = await store.create("load", {"origin": "NYC"}, "POSTED")
+        fetched = await store.get("load", created["id"])
+        assert fetched["origin"] == "NYC"
+        assert fetched["id"] == created["id"]
+
+    async def test_raises_key_error_for_missing(self, store: InMemoryEntityStore):
+        with pytest.raises(KeyError, match="not found"):
+            await store.get("load", "nonexistent")
+
+    async def test_returns_copy(self, store: InMemoryEntityStore):
+        created = await store.create("load", {"origin": "NYC"}, "POSTED")
+        fetched = await store.get("load", created["id"])
+        fetched["origin"] = "MUTATED"
+        refetched = await store.get("load", created["id"])
+        assert refetched["origin"] == "NYC"
+
+
+class TestListAll:
+    async def test_lists_all_entities(self, store: InMemoryEntityStore):
+        await store.create("load", {}, "POSTED")
+        await store.create("load", {}, "COVERED")
+        results = await store.list_all("load")
+        assert len(results) == 2
+
+    async def test_filters_by_status(self, store: InMemoryEntityStore):
+        await store.create("load", {}, "POSTED")
+        await store.create("load", {}, "COVERED")
+        await store.create("load", {}, "POSTED")
+        results = await store.list_all("load", status="POSTED")
+        assert len(results) == 2
+        assert all(r["status"] == "POSTED" for r in results)
+
+    async def test_respects_limit(self, store: InMemoryEntityStore):
+        for _ in range(10):
+            await store.create("load", {}, "POSTED")
+        results = await store.list_all("load", limit=3)
+        assert len(results) == 3
+
+    async def test_empty_entity_type(self, store: InMemoryEntityStore):
+        results = await store.list_all("nonexistent")
+        assert results == []
+
+
+class TestUpdate:
+    async def test_updates_fields(self, store: InMemoryEntityStore):
+        created = await store.create("load", {"origin": "NYC", "weight": 100}, "POSTED")
+        updated = await store.update("load", created["id"], {"weight": 200})
+        assert updated["weight"] == 200
+        assert updated["origin"] == "NYC"
+
+    async def test_raises_for_missing(self, store: InMemoryEntityStore):
+        with pytest.raises(KeyError, match="not found"):
+            await store.update("load", "nonexistent", {"x": 1})
+
+
+class TestDelete:
+    async def test_deletes_record(self, store: InMemoryEntityStore):
+        created = await store.create("load", {}, "POSTED")
+        result = await store.delete("load", created["id"])
+        assert result["deleted"] is True
+        with pytest.raises(KeyError):
+            await store.get("load", created["id"])
+
+    async def test_raises_for_missing(self, store: InMemoryEntityStore):
+        with pytest.raises(KeyError, match="not found"):
+            await store.delete("load", "nonexistent")
+
+
+class TestTransition:
+    async def test_transitions_state(self, store: InMemoryEntityStore):
+        created = await store.create("load", {}, "POSTED")
+        result = await store.transition("load", created["id"], "COVERED", reason="matched")
+        assert result["from_state"] == "POSTED"
+        assert result["to_state"] == "COVERED"
+        assert result["reason"] == "matched"
+        assert result["status"] == "COVERED"
+
+    async def test_persists_transition(self, store: InMemoryEntityStore):
+        created = await store.create("load", {}, "POSTED")
+        await store.transition("load", created["id"], "COVERED")
+        fetched = await store.get("load", created["id"])
+        assert fetched["status"] == "COVERED"
+
+    async def test_raises_for_missing(self, store: InMemoryEntityStore):
+        with pytest.raises(KeyError, match="not found"):
+            await store.transition("load", "nonexistent", "COVERED")
+
+
+class TestProtocolCompliance:
+    def test_implements_supports_entity_store(self):
+        from hexdag_forge.runtime.entity_store import SupportsEntityStore
+
+        store = InMemoryEntityStore()
+        assert isinstance(store, SupportsEntityStore)

hexdag_forge-0.2.0.dev4/hexdag_forge/templates/django_chat.html.j2

@@ -1,43 +0,0 @@
-{% extends "base.html" %}
-{% block title %}Chat — [[ profile.business_name ]]{% endblock %}
-{% block heading %}<h2>Chat</h2>{% endblock %}
-{% block content %}
-<div style="display: flex; gap: 1rem; height: 70vh;">
-    <aside style="width: 200px; overflow-y: auto; border-right: 1px solid var(--pico-muted-border-color); padding-right: 1rem;">
-        <form method="post" action="/chat/new/">
-            {% csrf_token %}
-            <button type="submit" style="width: 100%; margin-bottom: 0.5rem;">+ New Chat</button>
-        </form>
-        <ul style="list-style: none; padding: 0;">
-            {% for conv in conversations %}
-            <li style="margin-bottom: 0.25rem;">
-                <a href="/chat/{{ conv.pk }}/"
-                   {% if conversation and conversation.pk == conv.pk %}style="font-weight: bold;"{% endif %}>
-                    {{ conv.title|truncatechars:30 }}
-                </a>
-            </li>
-            {% empty %}
-            <li><small>No conversations yet</small></li>
-            {% endfor %}
-        </ul>
-    </aside>
-    <div style="flex: 1; display: flex; flex-direction: column;">
-        {% if conversation %}
-        <div id="messages" style="flex: 1; overflow-y: auto; padding: 0.5rem;">
-            {% include "chat/_messages.html" %}
-        </div>
-        <form hx-post="/chat/send/"
-              hx-target="#messages"
-              hx-swap="innerHTML"
-              style="display: flex; gap: 0.5rem; margin-top: 0.5rem;">
-            {% csrf_token %}
-            <input type="hidden" name="conversation_id" value="{{ conversation.pk }}">
-            <textarea name="content" rows="1" placeholder="Type a message..." style="flex: 1;"></textarea>
-            <button type="submit">Send</button>
-        </form>
-        {% else %}
-        <p>Select a conversation or start a new one.</p>
-        {% endif %}
-    </div>
-</div>
-{% endblock %}

hexdag_forge-0.2.0.dev4/hexdag_forge/templates/django_chat_conversations.html.j2

@@ -1,29 +0,0 @@
-{% extends "base.html" %}
-{% block title %}Chat — [[ profile.business_name ]]{% endblock %}
-{% block heading %}<h2>Chat</h2>{% endblock %}
-{% block content %}
-<form method="post" action="/chat/new/" style="margin-bottom: 1rem;">
-    {% csrf_token %}
-    <button type="submit">+ New Conversation</button>
-</form>
-{% if conversations %}
-<table>
-    <thead>
-        <tr>
-            <th>Conversation</th>
-            <th>Updated</th>
-        </tr>
-    </thead>
-    <tbody>
-        {% for conv in conversations %}
-        <tr>
-            <td><a href="/chat/{{ conv.pk }}/">{{ conv.title }}</a></td>
-            <td>{{ conv.updated_at|date:"M d, H:i" }}</td>
-        </tr>
-        {% endfor %}
-    </tbody>
-</table>
-{% else %}
-<p>No conversations yet. Start a new one!</p>
-{% endif %}
-{% endblock %}

hexdag_forge-0.2.0.dev4/hexdag_forge/templates/django_chat_messages_partial.html.j2

@@ -1,8 +0,0 @@
-{% for msg in messages %}
-<div style="margin-bottom: 0.5rem; padding: 0.5rem; border-radius: 8px; {% if msg.sender == 'user' %}background: var(--pico-primary-focus); text-align: right;{% else %}background: var(--pico-muted-border-color);{% endif %}">
-    <small><strong>{{ msg.sender|title }}</strong> &middot; {{ msg.created_at|date:"H:i" }}</small>
-    <p style="margin: 0.25rem 0 0;">{{ msg.content }}</p>
-</div>
-{% empty %}
-<p><small>No messages yet. Send one to get started.</small></p>
-{% endfor %}