Describe your app idea in plain English
+Describe your app idea - watch it come to life
+Welcome to your new page!
" + + # Use Rails runner for direct model access (DHH-approved) + success, result = rails_create_page(subdomain, title, slug, generated_content) + + if success: + return f"""✓ Page '{title}' created successfully! + +**Page URL:** http://{subdomain}.{APP_HOST}/{slug} +**Admin Panel:** http://{subdomain}.{APP_HOST}/admin/cms + +{result} +""" + else: + if "doesn't exist" in result.lower() or "not found" in result.lower(): + return f"Error: Subdomain '{subdomain}' not found." + if "No CMS site found" in result: + return f"Error: CMS not initialized for subdomain '{subdomain}'." + return f"Error creating page: {result}" diff --git a/violet-app-agent/apps/agent/src/violet_app_agent/tools/diagnostic.py b/violet-app-agent/apps/agent/src/violet_app_agent/tools/diagnostic.py new file mode 100644 index 000000000..b91f83a48 --- /dev/null +++ b/violet-app-agent/apps/agent/src/violet_app_agent/tools/diagnostic.py @@ -0,0 +1,64 @@ +"""Diagnostic tools for understanding app requirements.""" + +from typing import Literal + +from langchain_core.tools import tool + + +@tool +def diagnose_requirements( + app_description: str, + complexity_estimate: Literal["simple", "medium", "complex"] = "medium", +) -> str: + """ + Analyze an app description and extract key requirements. + + Use this to structure your thinking about what the user wants to build. + It helps identify entities, relationships, and clarifying questions. + + Args: + app_description: User's natural language description of their app idea + complexity_estimate: Your estimate of app complexity based on description + + Returns: + Structured analysis with suggested questions and initial entity detection + """ + # Complexity scoring + complexity_hints = { + "simple": "1-2 data models, basic CRUD, no complex relationships", + "medium": "3-5 data models, some relationships, standard pages", + "complex": "6+ data models, complex relationships, custom workflows", + } + + return f"""## Requirements Analysis + +**User Description:** {app_description} + +**Estimated Complexity:** {complexity_estimate} +_{complexity_hints[complexity_estimate]}_ + +### Suggested Clarifying Questions + +Based on the description, consider asking about: + +1. **Core entities** - What are the main things this app tracks? +2. **Relationships** - How do these things connect to each other? +3. **Users** - Who uses this app and what can they do? +4. **Key pages** - Any specific views beyond standard CRUD? + +### Initial Entity Detection + +From the description, potential entities might include: +- [Analyze the description for nouns that could be data models] +- [Look for relationships indicated by verbs like "has", "belongs to", "contains"] + +### Recommended Approach + +For a {complexity_estimate} app: +- Start with the core entity first +- Add relationships one at a time +- Keep properties minimal initially +- User can always add more later + +Use this analysis to guide your clarifying questions before generating a specification. +""" diff --git a/violet-app-agent/apps/agent/src/violet_app_agent/tools/github.py b/violet-app-agent/apps/agent/src/violet_app_agent/tools/github.py new file mode 100644 index 000000000..76494436d --- /dev/null +++ b/violet-app-agent/apps/agent/src/violet_app_agent/tools/github.py @@ -0,0 +1,118 @@ +"""GitHub integration tools for deployment.""" + +import os +from typing import Literal + +from langchain_core.tools import tool + +GITHUB_TOKEN = os.getenv("GITHUB_TOKEN", "") + + +@tool +def trigger_deployment( + subdomain: str, + target: Literal["local", "heroku", "ec2", "review-app"] = "local", + repo: str = "", + branch: str = "main", +) -> str: + """ + Trigger deployment of a subdomain via GitHub Actions. + + For now, this provides deployment instructions. Future versions + will integrate directly with the GitHub API. + + Args: + subdomain: The subdomain to deploy + target: Deployment target: + - "local": Already deployed to local development + - "heroku": Deploy to Heroku + - "ec2": Deploy to AWS EC2 via Capistrano + - "review-app": Create a GitHub review app + repo: GitHub repository (owner/repo format). Required for non-local. + branch: Branch to deploy from + + Returns: + Deployment status or instructions + """ + if target == "local": + return f"""✓ Your app is running locally! + +**Local URLs:** +- App: http://{subdomain}.localhost:5250 +- Admin: http://{subdomain}.localhost:5250/admin + +No additional deployment needed for local development. +""" + + if not repo: + return "Error: GitHub repository (owner/repo) is required for cloud deployment." + + if not GITHUB_TOKEN: + return """Error: GitHub token not configured. + +To enable deployment, set the GITHUB_TOKEN environment variable +with a token that has workflow permissions. +""" + + # For MVP, provide manual instructions + # TODO: Implement GitHub API integration with Octokit + if target == "heroku": + return f"""## Deploy to Heroku + +Your app configuration is ready. To deploy: + +1. Push your changes to the `{branch}` branch: + ```bash + git push origin {branch} + ``` + +2. The GitHub Action at `.github/workflows/heroku-deploy.yml` will: + - Build the application + - Run database migrations + - Deploy to Heroku + +**Monitor deployment:** +https://github.com/{repo}/actions + +**After deployment:** +Your app will be available at your Heroku app URL. +""" + elif target == "ec2": + return f"""## Deploy to AWS EC2 + +Your app configuration is ready. To deploy: + +1. Push your changes to the `{branch}` branch: + ```bash + git push origin {branch} + ``` + +2. The GitHub Action at `.github/workflows/deploy.yml` will: + - Connect to your EC2 instance via SSH + - Run Capistrano deployment + - Restart application services + +**Monitor deployment:** +https://github.com/{repo}/actions + +**Note:** Ensure your EC2 instance and deployment keys are configured. +""" + elif target == "review-app": + return f"""## Create Review App + +To create a review app for testing: + +1. Create a pull request with your changes +2. Add the `deploy-review-app` label to the PR +3. GitHub Actions will automatically: + - Create an isolated review environment + - Deploy your changes + - Comment on the PR with the review app URL + +**Monitor:** +https://github.com/{repo}/pulls + +The review app will be automatically destroyed when the PR is closed. +""" + else: + return f"Error: Unknown deployment target '{target}'." diff --git a/violet-app-agent/apps/agent/src/violet_app_agent/tools/namespace.py b/violet-app-agent/apps/agent/src/violet_app_agent/tools/namespace.py new file mode 100644 index 000000000..ad14c7a82 --- /dev/null +++ b/violet-app-agent/apps/agent/src/violet_app_agent/tools/namespace.py @@ -0,0 +1,101 @@ +"""API Namespace creation tools - uses direct Rails model access. + +DHH-approved pattern: Direct model access via rails runner instead of +non-existent API endpoints. This is the Rails way. +""" + +import json +import os + +from langchain_core.tools import tool + +from violet_app_agent.tools.rails_runner import create_api_namespace as rails_create_namespace + +APP_HOST = os.getenv("APP_HOST", "localhost:5250") + +# Valid property types in Violet Rails +VALID_PROPERTY_TYPES = { + "String", + "Text", + "Integer", + "Float", + "Boolean", + "Date", + "DateTime", + "Array", +} + + +@tool +def create_namespace( + subdomain: str, + name: str, + slug: str, + properties_json: str, + is_renderable: bool = True, +) -> str: + """ + Create an API namespace in a subdomain. + + An API namespace is a data model with properties. It automatically gets: + - CRUD API endpoints + - Admin interface + - Optional form generation (if is_renderable=True) + + Args: + subdomain: Target subdomain name (must exist) + name: Human-readable namespace name (e.g., 'Pet', 'Booking') + slug: URL-safe slug (e.g., 'pets', 'bookings') + properties_json: JSON object mapping property names to types. + Valid types: String, Text, Integer, Float, Boolean, Date, DateTime, Array + Example: '{"name": "String", "age": "Integer", "active": "Boolean"}' + is_renderable: If true, auto-generates forms for this namespace + + Returns: + Success message with property count, or error message + """ + # Parse properties + try: + properties = json.loads(properties_json) + except json.JSONDecodeError as e: + return f"Error parsing properties JSON: {e}" + + # Validate properties + if not isinstance(properties, dict): + return "Error: properties_json must be a JSON object (dict), not an array." + + if not properties: + return "Error: At least one property is required." + + # Validate property types + invalid_types = [] + for prop_name, prop_type in properties.items(): + if prop_type not in VALID_PROPERTY_TYPES: + invalid_types.append(f" - {prop_name}: '{prop_type}' (not valid)") + + if invalid_types: + valid_list = ", ".join(sorted(VALID_PROPERTY_TYPES)) + return ( + f"Error: Invalid property types found:\n" + + "\n".join(invalid_types) + + f"\n\nValid types are: {valid_list}" + ) + + # Use Rails runner for direct model access (DHH-approved) + success, result = rails_create_namespace(subdomain, name, slug, properties) + + if success: + form_note = " (form auto-generated)" if is_renderable else "" + return f"""✓ API namespace '{name}' created with {len(properties)} properties{form_note} + +**API Endpoint:** http://{subdomain}.{APP_HOST}/api/v1/{slug}/ +**Admin Panel:** http://{subdomain}.{APP_HOST}/api_namespaces + +{result} +""" + else: + if "doesn't exist" in result.lower() or "not found" in result.lower(): + return f"Error: Subdomain '{subdomain}' not found. Create it first." + if "already been taken" in result.lower(): + return f"Error: API namespace '{slug}' already exists in subdomain '{subdomain}'." + return f"Error creating namespace: {result}" diff --git a/violet-app-agent/apps/agent/src/violet_app_agent/tools/rails_runner.py b/violet-app-agent/apps/agent/src/violet_app_agent/tools/rails_runner.py new file mode 100644 index 000000000..b7ac745ed --- /dev/null +++ b/violet-app-agent/apps/agent/src/violet_app_agent/tools/rails_runner.py @@ -0,0 +1,228 @@ +"""Rails Runner utility for direct model access. + +DHH-approved pattern: Instead of hitting non-existent API endpoints, +execute Ruby code directly via `rails runner`. + +This is the Rails way - direct model access is simpler and more reliable +than building API wrappers for admin operations. +""" + +import os +import subprocess +import json +from typing import Optional, Tuple + +RAILS_ROOT = os.getenv("RAILS_ROOT", "/Users/shambhavi/Documents/projects/violet_rails") + +# Database configuration for local development +# DISABLE_SPRING=1 prevents fork() issues on macOS (INC-20251208-003) +RAILS_ENV = { + "DISABLE_SPRING": "1", + "OBJC_DISABLE_INITIALIZE_FORK_SAFETY": "YES", + "DATABASE_HOST": os.getenv("DATABASE_HOST", "localhost"), + "DATABASE_PORT": os.getenv("DATABASE_PORT", "6000"), + "DATABASE_USERNAME": os.getenv("DATABASE_USERNAME", "postgres"), + "DATABASE_PASSWORD": os.getenv("DATABASE_PASSWORD", "password"), + "DATABASE_NAME": os.getenv("DATABASE_NAME", "r_solutions_development"), + "REDIS_URL": os.getenv("REDIS_URL", "redis://localhost:6380/0"), +} + + +def run_rails_code(ruby_code: str, timeout: int = 30) -> Tuple[bool, str]: + """ + Execute Ruby code via `rails runner`. + + Args: + ruby_code: Ruby code to execute + timeout: Timeout in seconds + + Returns: + Tuple of (success: bool, output: str) + """ + env = os.environ.copy() + env.update(RAILS_ENV) + + try: + result = subprocess.run( + ["bin/rails", "runner", ruby_code], + cwd=RAILS_ROOT, + env=env, + capture_output=True, + text=True, + timeout=timeout, + ) + + if result.returncode == 0: + return True, result.stdout.strip() + else: + return False, result.stderr.strip() or result.stdout.strip() + + except subprocess.TimeoutExpired: + return False, f"Rails runner timed out after {timeout}s" + except FileNotFoundError: + return False, f"Rails not found. Set RAILS_ROOT env var (current: {RAILS_ROOT})" + except Exception as e: + return False, f"Rails runner error: {str(e)}" + + +def check_db_health() -> Tuple[bool, str]: + """ + Check database connectivity at agent startup. + Call this before processing requests to fail fast if DB is unavailable. + + Returns: + Tuple of (healthy: bool, message: str with JSON status) + """ + health_check_code = ''' +begin + ActiveRecord::Base.connection.execute("SELECT 1") + subdomain_count = Subdomain.count + puts JSON.generate({ + status: "healthy", + database: ActiveRecord::Base.connection.current_database, + subdomain_count: subdomain_count, + rails_env: Rails.env + }) +rescue => e + puts JSON.generate({ + status: "unhealthy", + error: e.message, + error_class: e.class.name + }) + exit 1 +end +''' + success, output = run_rails_code(health_check_code) + if success: + return True, output + else: + return False, f"DB Health Check Failed: {output}" + + +def create_subdomain(name: str) -> Tuple[bool, str]: + """Create a subdomain using direct model access with verification.""" + # Step 1: Create the subdomain + create_code = f''' +subdomain = Subdomain.find_or_create_by!(name: "{name}") +puts subdomain.id +''' + success, output = run_rails_code(create_code) + if not success: + return False, f"Failed to create subdomain: {output}" + + subdomain_id = output.strip() + + # Step 2: Verify it exists (separate query to confirm persistence) + verify_code = f''' +subdomain = Subdomain.find_by(id: {subdomain_id}) +if subdomain.nil? + puts JSON.generate({{ error: "VERIFICATION FAILED: Subdomain {subdomain_id} not found after create" }}) + exit 1 +end +puts JSON.generate({{ + id: subdomain.id, + name: subdomain.name, + created_at: subdomain.created_at, + verified: true +}}) +''' + return run_rails_code(verify_code) + + +def create_api_namespace(subdomain_name: str, name: str, slug: str, properties: dict) -> Tuple[bool, str]: + """Create an API namespace using direct model access with verification.""" + properties_ruby = ", ".join([f'"{k}" => "{v}"' for k, v in properties.items()]) + + # Step 1: Create the namespace + create_code = f''' +Apartment::Tenant.switch("{subdomain_name}") do + namespace = ApiNamespace.find_or_create_by!(slug: "{slug}") do |ns| + ns.name = "{name}" + ns.version = 1 + ns.properties = {{ {properties_ruby} }} + ns.requires_authentication = true + end + puts namespace.id +end +''' + success, output = run_rails_code(create_code) + if not success: + return False, f"Failed to create namespace: {output}" + + namespace_id = output.strip() + + # Step 2: Verify it exists (separate query to confirm persistence) + verify_code = f''' +Apartment::Tenant.switch("{subdomain_name}") do + namespace = ApiNamespace.find_by(id: {namespace_id}) + if namespace.nil? + puts JSON.generate({{ error: "VERIFICATION FAILED: Namespace {namespace_id} not found after create" }}) + exit 1 + end + puts JSON.generate({{ + id: namespace.id, + name: namespace.name, + slug: namespace.slug, + properties: namespace.properties, + verified: true + }}) +end +''' + return run_rails_code(verify_code) + + +def create_cms_page(subdomain_name: str, title: str, slug: str, content: str) -> Tuple[bool, str]: + """Create a CMS page using direct model access with verification.""" + # Escape content for Ruby string + escaped_content = content.replace('"', '\\"').replace('\n', '\\n') + + # Step 1: Create the page + create_code = f''' +Apartment::Tenant.switch("{subdomain_name}") do + site = Comfy::Cms::Site.first + if site.nil? + puts JSON.generate({{ error: "No CMS site found" }}) + exit 1 + end + + layout = site.layouts.first || site.layouts.create!( + identifier: "default", + content: "{{{{ cms:wysiwyg content }}}}" + ) + + page = site.pages.find_or_create_by!(slug: "{slug}") do |p| + p.label = "{title}" + p.layout = layout + end + + # Update or create fragment + fragment = page.fragments.find_or_create_by!(identifier: "content") + fragment.update!(content: "{escaped_content}") + + puts page.id +end +''' + success, output = run_rails_code(create_code) + if not success: + return False, f"Failed to create page: {output}" + + page_id = output.strip() + + # Step 2: Verify it exists (separate query to confirm persistence) + verify_code = f''' +Apartment::Tenant.switch("{subdomain_name}") do + page = Comfy::Cms::Page.find_by(id: {page_id}) + if page.nil? + puts JSON.generate({{ error: "VERIFICATION FAILED: Page {page_id} not found after create" }}) + exit 1 + end + puts JSON.generate({{ + id: page.id, + label: page.label, + slug: page.slug, + full_path: page.full_path, + verified: true + }}) +end +''' + return run_rails_code(verify_code) diff --git a/violet-app-agent/apps/agent/src/violet_app_agent/tools/specification.py b/violet-app-agent/apps/agent/src/violet_app_agent/tools/specification.py new file mode 100644 index 000000000..47ed8f36c --- /dev/null +++ b/violet-app-agent/apps/agent/src/violet_app_agent/tools/specification.py @@ -0,0 +1,107 @@ +"""Specification generation tools.""" + +import json +from typing import Optional + +import yaml +from langchain_core.tools import tool +from pydantic import BaseModel, Field + + +class NamespaceSpec(BaseModel): + """Specification for an API namespace.""" + + name: str = Field(description="Human-readable name, e.g., 'Pet'") + slug: str = Field(description="URL-safe slug, e.g., 'pets'") + properties: dict[str, str] = Field(description="Property name to type mapping") + relationships: list[dict] = Field(default_factory=list) + + +class AppSpec(BaseModel): + """Complete application specification.""" + + subdomain_name: str = Field(description="Lowercase subdomain, e.g., 'pet-adoption'") + app_title: str = Field(description="Human-readable title") + description: Optional[str] = None + namespaces: list[NamespaceSpec] + pages: list[dict] = Field(default_factory=list) + + +@tool +def generate_specification( + subdomain_name: str, + app_title: str, + description: str, + namespaces_json: str, + pages_json: str = "[]", +) -> str: + """ + Generate a complete app specification in YAML format. + + Use this after gathering requirements to create a structured spec + that can be presented to the user for approval. + + Args: + subdomain_name: Lowercase subdomain name (e.g., 'pet-adoption') + app_title: Human-readable app title (e.g., 'Pet Adoption Platform') + description: Brief description of what the app does + namespaces_json: JSON array of namespace definitions, each with: + - name: String (e.g., "Pet") + - slug: String (e.g., "pets") + - properties: Object of property_name: type + - relationships: Array of relationship definitions (optional) + pages_json: JSON array of page definitions (optional), each with: + - type: "index" | "show" | "form" + - namespace: slug of the namespace + - title: page title (optional) + + Returns: + Formatted YAML specification ready for user review + """ + # Validate and clean subdomain name + clean_subdomain = subdomain_name.lower().replace(" ", "-").replace("_", "-") + # Remove any characters that aren't alphanumeric or hyphens + clean_subdomain = "".join(c for c in clean_subdomain if c.isalnum() or c == "-") + # Ensure it starts with a letter + if clean_subdomain and not clean_subdomain[0].isalpha(): + clean_subdomain = "app-" + clean_subdomain + + try: + namespaces = json.loads(namespaces_json) + pages = json.loads(pages_json) + except json.JSONDecodeError as e: + return f"Error parsing JSON: {e}\n\nPlease check your namespace and page definitions." + + # Build the specification + spec = { + "subdomain_name": clean_subdomain, + "app_title": app_title, + "description": description, + "namespaces": namespaces, + "pages": pages, + } + + # Format as YAML + yaml_output = yaml.dump(spec, default_flow_style=False, sort_keys=False, allow_unicode=True) + + # Count entities for summary + num_namespaces = len(namespaces) + num_properties = sum(len(ns.get("properties", {})) for ns in namespaces) + num_pages = len(pages) + + return f"""## Generated App Specification + +```yaml +{yaml_output}``` + +### Summary +- **{num_namespaces}** data model{"s" if num_namespaces != 1 else ""} +- **{num_properties}** total properties +- **{num_pages}** page{"s" if num_pages != 1 else ""} + +--- + +**Review this specification.** Reply with: +- **"create"** or **"yes"** to build this app +- **"adjust [your changes]"** to modify the spec +""" diff --git a/violet-app-agent/apps/agent/src/violet_app_agent/tools/subdomain.py b/violet-app-agent/apps/agent/src/violet_app_agent/tools/subdomain.py new file mode 100644 index 000000000..63d7b2edd --- /dev/null +++ b/violet-app-agent/apps/agent/src/violet_app_agent/tools/subdomain.py @@ -0,0 +1,68 @@ +"""Subdomain creation tools - uses direct Rails model access. + +DHH-approved pattern: Direct model access via rails runner instead of +non-existent API endpoints. This is the Rails way. +""" + +import os +import re + +from langchain_core.tools import tool + +from violet_app_agent.tools.rails_runner import create_subdomain as rails_create_subdomain + +APP_HOST = os.getenv("APP_HOST", "localhost:5250") + + +@tool +def create_subdomain(subdomain_name: str) -> str: + """ + Create a new subdomain on Violet Rails. + + This creates an isolated app environment with its own: + - Database schema + - CMS pages and layouts + - Users and permissions + - API endpoints + + Args: + subdomain_name: Lowercase subdomain name (1-63 chars). + Must start with a letter, contain only lowercase letters, + numbers, and hyphens. No trailing hyphens. + + Returns: + Success message with subdomain URL, or error message + """ + # Validate name format + if not re.match(r"^[a-z](?:[a-z0-9-]*[a-z0-9])?$", subdomain_name): + return ( + f"Error: Invalid subdomain name '{subdomain_name}'.\n\n" + "Requirements:\n" + "- Must start with a lowercase letter\n" + "- Can contain lowercase letters, numbers, and hyphens\n" + "- Cannot end with a hyphen\n" + "- No spaces or special characters\n\n" + "Example: 'my-cool-app' or 'petshop'" + ) + + if len(subdomain_name) > 63: + return f"Error: Subdomain name too long ({len(subdomain_name)} chars). Maximum is 63." + + if len(subdomain_name) < 1: + return "Error: Subdomain name cannot be empty." + + # Use Rails runner for direct model access (DHH-approved) + success, result = rails_create_subdomain(subdomain_name) + + if success: + return f"""✓ Subdomain created successfully! + +**App URL:** http://{subdomain_name}.{APP_HOST} +**Admin Panel:** http://{subdomain_name}.{APP_HOST}/admin + +{result} +""" + else: + if "already been taken" in result.lower(): + return f"Error: Subdomain '{subdomain_name}' already exists." + return f"Error creating subdomain: {result}" diff --git a/violet-app-agent/apps/agent/tests/__init__.py b/violet-app-agent/apps/agent/tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/violet-app-agent/apps/agent/tests/conftest.py b/violet-app-agent/apps/agent/tests/conftest.py new file mode 100644 index 000000000..a2076789c --- /dev/null +++ b/violet-app-agent/apps/agent/tests/conftest.py @@ -0,0 +1,86 @@ +"""Pytest configuration for Violet App Agent tests.""" + +import os +import sys + +import pytest + + +# Add the src directory to the path +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src")) + + +@pytest.fixture(autouse=True) +def set_test_env(monkeypatch): + """Set test environment variables.""" + monkeypatch.setenv("VIOLET_API_URL", "http://localhost:5250") + monkeypatch.setenv("VIOLET_API_KEY", "test-key") + monkeypatch.setenv("APP_HOST", "localhost:5250") + monkeypatch.setenv("GITHUB_TOKEN", "") + + +@pytest.fixture +def sample_pet_app_spec(): + """Sample pet adoption app specification.""" + return { + "subdomain_name": "pet-adoption", + "app_title": "Pet Adoption Platform", + "description": "Connect shelters with adopters", + "namespaces": [ + { + "name": "Shelter", + "slug": "shelters", + "properties": { + "name": "String", + "address": "String", + "phone": "String" + } + }, + { + "name": "Pet", + "slug": "pets", + "properties": { + "name": "String", + "species": "String", + "breed": "String", + "age": "Integer", + "shelter_id": "Integer" + } + } + ], + "pages": [ + {"type": "index", "namespace": "pets", "title": "Available Pets"}, + {"type": "form", "namespace": "applications", "title": "Apply to Adopt"} + ] + } + + +@pytest.fixture +def sample_blog_spec(): + """Sample blog app specification.""" + return { + "subdomain_name": "my-blog", + "app_title": "My Blog", + "description": "Personal blog with posts and comments", + "namespaces": [ + { + "name": "Post", + "slug": "posts", + "properties": { + "title": "String", + "content": "Text", + "published": "Boolean" + } + }, + { + "name": "Comment", + "slug": "comments", + "properties": { + "author": "String", + "content": "Text", + "post_id": "Integer" + } + } + ], + "pages": [] + } diff --git a/violet-app-agent/apps/agent/tests/test_e2e_jtbd.py b/violet-app-agent/apps/agent/tests/test_e2e_jtbd.py new file mode 100644 index 000000000..0ccd3f786 --- /dev/null +++ b/violet-app-agent/apps/agent/tests/test_e2e_jtbd.py @@ -0,0 +1,431 @@ +"""End-to-end test for the Jobs-to-be-Done flow. + +This test simulates the core JTBD: +"When I describe my app idea, I want a working app deployed" + +The test verifies: +1. Natural language input is understood +2. Specification is generated correctly +3. API calls create the subdomain and namespaces +4. CMS pages are created +5. Deployment instructions are provided + +Run with: pytest tests/test_e2e_jtbd.py -v +""" + +import json +import os +from unittest.mock import MagicMock, patch + +import pytest + + +class TestJTBD: + """Test the core Jobs-to-be-Done flow.""" + + @pytest.fixture + def mock_violet_api(self): + """Mock the Violet Rails API responses.""" + with patch("httpx.post") as mock_post: + # Configure successful responses + mock_post.return_value = MagicMock( + status_code=201, + json=lambda: {"id": 1, "url": "/test"} + ) + yield mock_post + + def test_diagnose_requirements_parses_pet_adoption_app(self): + """Test that diagnose_requirements correctly parses a pet adoption app description.""" + from violet_app_agent.tools.diagnostic import diagnose_requirements + + result = diagnose_requirements.invoke({ + "app_description": "I want to build a pet adoption app where shelters can list pets and people can apply to adopt", + "complexity_estimate": "medium" + }) + + # Should identify key entities + assert "Pet" in result or "pet" in result.lower() + assert "Shelter" in result or "shelter" in result.lower() + # Should identify relationships + assert "belong" in result.lower() or "relationship" in result.lower() + + def test_generate_specification_creates_valid_yaml(self): + """Test that generate_specification creates valid YAML output.""" + from violet_app_agent.tools.specification import generate_specification + + result = generate_specification.invoke({ + "subdomain_name": "pet-adoption", + "app_title": "Pet Adoption Platform", + "description": "Connect shelters with adopters", + "namespaces_json": json.dumps([ + { + "name": "Pet", + "slug": "pets", + "properties": { + "name": "String", + "species": "String", + "age": "Integer" + } + } + ]), + "pages_json": json.dumps([ + {"type": "index", "namespace": "pets", "title": "Available Pets"} + ]) + }) + + # Should contain YAML block + assert "```yaml" in result + assert "pet-adoption" in result + assert "Pet Adoption Platform" in result + # Should have summary + assert "data model" in result.lower() or "properties" in result.lower() + + def test_create_subdomain_validates_name(self): + """Test that create_subdomain validates subdomain names.""" + from violet_app_agent.tools.subdomain import create_subdomain + + # Test invalid name (starts with number) + result = create_subdomain.invoke({ + "subdomain_name": "123invalid" + }) + assert "Error" in result or "Invalid" in result + + # Test invalid name (contains uppercase) + result = create_subdomain.invoke({ + "subdomain_name": "InvalidName" + }) + assert "Error" in result or "Invalid" in result + + def test_create_namespace_validates_properties(self): + """Test that create_namespace validates property types.""" + from violet_app_agent.tools.namespace import create_namespace + + # Test invalid property type + result = create_namespace.invoke({ + "subdomain": "test-app", + "name": "Pet", + "slug": "pets", + "properties_json": json.dumps({"name": "InvalidType"}) + }) + assert "Error" in result or "Invalid" in result + + def test_create_page_requires_namespace_for_typed_pages(self): + """Test that create_page requires namespace_slug for index/show/form pages.""" + from violet_app_agent.tools.cms import create_page + + # Test index page without namespace + result = create_page.invoke({ + "subdomain": "test-app", + "title": "Pets List", + "slug": "pets", + "page_type": "index", + "namespace_slug": "" # Missing required namespace + }) + assert "Error" in result or "required" in result.lower() + + def test_trigger_deployment_local_needs_no_repo(self): + """Test that local deployment works without GitHub repo.""" + from violet_app_agent.tools.github import trigger_deployment + + result = trigger_deployment.invoke({ + "subdomain": "test-app", + "target": "local" + }) + + # Should succeed for local + assert "localhost" in result.lower() + assert "Error" not in result + + def test_trigger_deployment_heroku_requires_repo(self): + """Test that Heroku deployment requires GitHub repo.""" + from violet_app_agent.tools.github import trigger_deployment + + result = trigger_deployment.invoke({ + "subdomain": "test-app", + "target": "heroku", + "repo": "" # Missing required repo + }) + + assert "Error" in result or "required" in result.lower() + + @pytest.mark.integration + def test_full_jtbd_flow_pet_adoption(self, mock_violet_api): + """ + Full JTBD flow test: User describes pet adoption app, agent creates it. + + This is the core user story: + 1. User says "I want a pet adoption app" + 2. Agent diagnoses requirements + 3. Agent generates specification + 4. User approves + 5. Agent creates subdomain, namespaces, pages + 6. Agent provides deployment instructions + """ + from violet_app_agent.tools import ( + create_namespace, + create_page, + create_subdomain, + diagnose_requirements, + generate_specification, + trigger_deployment, + ) + + # Step 1: Diagnose requirements + diagnosis = diagnose_requirements.invoke({ + "app_description": "Build me a pet adoption platform where animal shelters can list pets and people can submit adoption applications", + "complexity_estimate": "medium" + }) + assert "Pet" in diagnosis or "pet" in diagnosis.lower() + + # Step 2: Generate specification + spec = generate_specification.invoke({ + "subdomain_name": "pet-adoption", + "app_title": "Pet Adoption Platform", + "description": "Connect shelters with adopters", + "namespaces_json": json.dumps([ + { + "name": "Shelter", + "slug": "shelters", + "properties": {"name": "String", "address": "String", "phone": "String"} + }, + { + "name": "Pet", + "slug": "pets", + "properties": {"name": "String", "species": "String", "breed": "String", "age": "Integer", "shelter_id": "Integer"} + }, + { + "name": "Application", + "slug": "applications", + "properties": {"applicant_name": "String", "email": "String", "pet_id": "Integer", "message": "Text"} + } + ]), + "pages_json": json.dumps([ + {"type": "index", "namespace": "pets", "title": "Available Pets"}, + {"type": "form", "namespace": "applications", "title": "Apply to Adopt"} + ]) + }) + assert "pet-adoption" in spec + assert "3" in spec # 3 namespaces + + # Step 3: Create subdomain (mocked) + subdomain_result = create_subdomain.invoke({"subdomain_name": "pet-adoption"}) + # Will fail without real API, but validates the call was made + + # Step 4: Deployment instructions + deploy_result = trigger_deployment.invoke({ + "subdomain": "pet-adoption", + "target": "local" + }) + assert "localhost" in deploy_result.lower() + assert "5250" in deploy_result + + +class TestSpecificationGeneration: + """Test specification generation for various app types.""" + + def test_blog_app_spec(self): + """Test generating a blog app specification.""" + from violet_app_agent.tools.specification import generate_specification + + result = generate_specification.invoke({ + "subdomain_name": "my-blog", + "app_title": "My Personal Blog", + "description": "A simple blog with posts and comments", + "namespaces_json": json.dumps([ + { + "name": "Post", + "slug": "posts", + "properties": {"title": "String", "content": "Text", "published": "Boolean"} + }, + { + "name": "Comment", + "slug": "comments", + "properties": {"author": "String", "content": "Text", "post_id": "Integer"} + } + ]), + "pages_json": "[]" + }) + + assert "my-blog" in result + assert "Post" in result + assert "Comment" in result + + def test_inventory_app_spec(self): + """Test generating an inventory management specification.""" + from violet_app_agent.tools.specification import generate_specification + + result = generate_specification.invoke({ + "subdomain_name": "inventory-tracker", + "app_title": "Inventory Tracker", + "description": "Track items in stock", + "namespaces_json": json.dumps([ + { + "name": "Item", + "slug": "items", + "properties": { + "name": "String", + "sku": "String", + "quantity": "Integer", + "price": "Float" + } + } + ]), + "pages_json": "[]" + }) + + assert "inventory-tracker" in result + assert "Item" in result + assert "4" in result # 4 properties + + +class TestSubdomainValidation: + """Test subdomain name validation edge cases.""" + + def test_valid_subdomain_names(self): + """Test that valid subdomain names pass validation.""" + from violet_app_agent.tools.subdomain import create_subdomain + + valid_names = [ + "my-app", + "petshop", + "test123", + "a", # Single char is valid + "my-cool-app-2024", + ] + + for name in valid_names: + result = create_subdomain.invoke({"subdomain_name": name}) + # Should not contain validation error (may have connection error) + assert "Invalid subdomain name" not in result, f"Failed for: {name}" + + def test_invalid_subdomain_names(self): + """Test that invalid subdomain names are rejected.""" + from violet_app_agent.tools.subdomain import create_subdomain + + invalid_names = [ + "My-App", # Uppercase + "123app", # Starts with number + "-myapp", # Starts with hyphen + "myapp-", # Ends with hyphen + "my app", # Contains space + "my_app", # Contains underscore + "my.app", # Contains dot + ] + + for name in invalid_names: + result = create_subdomain.invoke({"subdomain_name": name}) + assert "Error" in result or "Invalid" in result, f"Should reject: {name}" + + +class TestDatabaseVerification: + """ + Test database persistence verification (INC-20251208-003 remediation). + + These tests ensure that: + 1. Database health check works + 2. Create operations verify data exists after creation + 3. Verification failures are properly reported + """ + + @pytest.mark.integration + def test_db_health_check(self): + """Test that database health check works and returns expected format.""" + from violet_app_agent.tools.rails_runner import check_db_health + + healthy, result = check_db_health() + + if healthy: + # Verify the output is valid JSON with expected fields + status = json.loads(result) + assert status.get("status") == "healthy" + assert "database" in status + assert "subdomain_count" in status + assert "rails_env" in status + else: + # If unhealthy, should contain meaningful error + assert "Failed" in result or "error" in result.lower() + + @pytest.mark.integration + def test_create_subdomain_returns_verified_true(self): + """Test that create_subdomain includes 'verified: true' in response.""" + from violet_app_agent.tools.rails_runner import create_subdomain + import uuid + + # Create a unique subdomain name for testing + test_name = f"test-{uuid.uuid4().hex[:8]}" + + success, result = create_subdomain(test_name) + + if success: + data = json.loads(result) + # Verification should be explicit in response + assert data.get("verified") is True, "Response must include verified: true" + assert data.get("name") == test_name + assert "id" in data + + @pytest.mark.integration + def test_create_namespace_returns_verified_true(self): + """Test that create_namespace includes 'verified: true' in response.""" + from violet_app_agent.tools.rails_runner import create_subdomain, create_api_namespace + import uuid + + # First create a subdomain + subdomain_name = f"test-{uuid.uuid4().hex[:8]}" + success, _ = create_subdomain(subdomain_name) + if not success: + pytest.skip("Could not create test subdomain") + + # Create namespace + namespace_name = "TestEntity" + namespace_slug = f"test-entities-{uuid.uuid4().hex[:4]}" + properties = {"name": "String", "value": "Integer"} + + success, result = create_api_namespace( + subdomain_name, namespace_name, namespace_slug, properties + ) + + if success: + data = json.loads(result) + assert data.get("verified") is True, "Response must include verified: true" + assert data.get("slug") == namespace_slug + assert "id" in data + + @pytest.mark.integration + def test_create_page_returns_verified_true(self): + """Test that create_page includes 'verified: true' in response.""" + from violet_app_agent.tools.rails_runner import create_subdomain, create_cms_page + import uuid + + # First create a subdomain + subdomain_name = f"test-{uuid.uuid4().hex[:8]}" + success, _ = create_subdomain(subdomain_name) + if not success: + pytest.skip("Could not create test subdomain") + + # Create page + page_title = "Test Page" + page_slug = f"test-page-{uuid.uuid4().hex[:4]}" + page_content = "