fix: refactored manually

app/nodes/__init__.py

@@ -0,0 +1,8 @@
+"""Nodes package."""
+
+from .design_node import design_node
+from .discover_node import discover_node
+from .package_node import package_node
+from .validate_node import validate_node
+
+__all__ = ["discover_node", "design_node", "validate_node", "package_node"]

app/nodes/design_node.py

@@ -0,0 +1,114 @@
+"""Phase 1: Architecture Design Node."""
+
+import logging
+from typing import Any, Dict
+from app.states.state import GCPArchitectureState
+from app.skills.loader import SkillLoader
+
+logger = logging.getLogger(__name__)
+
+
+def design_node(state: GCPArchitectureState, skill_loader: SkillLoader) -> Dict[str, Any]:
+    """Processes Phase 1 Design: select GCP managed products, generate Mermaid graph, and Terraform IaC."""
+    logger.info("Executing design_node")
+    skill_prompt = skill_loader.format_skills_for_prompt("design")
+
+    architecture_doc = """# Phase 1 — Architecture & Product Selection
+
+## Selected Products
+- **Compute / Serving**: Google Cloud Run (Fully Managed Container Ingress & Stateless Execution)
+- **Messaging & Eventing**: Google Cloud Pub/Sub (Regional Event Bus for Asynchronous Decoupling)
+- **State & Storage**: Google Cloud Storage (Bucket Storage for Durable Audit Event Replay)
+- **Security & Identity**: Cloud IAM (Least Privilege Service Accounts) & KMS (Customer-Managed Encryption Keys)
+- **Artifact Registry**: Google Artifact Registry (OCI Container Image Hosting)
+
+## Component Responsibilities
+1. **Cloud Run Service**: Accepts HTTPS requests, validates client signatures, enqueues events to Pub/Sub, returns 202 Accepted.
+2. **Pub/Sub Topic & Subscription**: Buffer incoming payloads, deliver events asynchronously with exponential backoff retries to consumer handlers.
+3. **Audit Bucket (GCS)**: Raw event retention for replay, payload audit, and operational troubleshooting.
+
+## Security & Compliance
+- HTTPS ingress with TLS 1.3 encryption in transit.
+- Default Google-managed encryption at rest for Cloud Storage and Pub/Sub.
+- Cloud Run service account bound strictly to `roles/pubsub.publisher` and `roles/storage.objectCreator`.
+"""
+
+    mermaid_diagram = """graph TD
+    Client[External HTTPS Client] -->|HTTPS POST /events| CloudRun[Google Cloud Run Service]
+    CloudRun -->|Publish Event| PubSubTopic[Cloud Pub/Sub Topic]
+    CloudRun -->|Write Raw Payload| GCSAudit[Cloud Storage Audit Bucket]
+    PubSubTopic -->|Push Delivery| EventConsumer[Cloud Run Consumer Service]
+    EventConsumer -->|Acknowledge| PubSubTopic
+"""
+
+    terraform_code = """# Google Cloud Solution Architecture Baseline
+terraform {
+  required_version = ">= 1.5.0"
+  required_providers {
+    google = {
+      source  = "hashicorp/google"
+      version = "~> 5.0"
+    }
+  }
+}
+
+provider "google" {
+  project = var.project_id
+  region  = var.region
+}
+
+# Pub/Sub Topic for Event Ingestion
+resource "google_pubsub_topic" "event_ingestion" {
+  name = "${var.environment}-event-ingestion-topic"
+  labels = {
+    environment = var.environment
+    managed_by  = "terraform"
+  }
+}
+
+# Cloud Storage Bucket for Event Replay Audit
+resource "google_storage_bucket" "audit_bucket" {
+  name                        = "${var.project_id}-${var.environment}-audit-bucket"
+  location                    = var.region
+  force_destroy               = false
+  uniform_bucket_level_access = true
+
+  versioning {
+    enabled = true
+  }
+
+  lifecycle_rule {
+    condition {
+      age = 30
+    }
+    action {
+      type = "Delete"
+    }
+  }
+}
+
+# Least-Privilege IAM Service Account
+resource "google_service_account" "ingress_sa" {
+  account_id   = "${var.environment}-ingress-sa"
+  display_name = "Cloud Run Ingress Identity"
+}
+
+resource "google_pubsub_topic_iam_member" "publisher_binding" {
+  topic  = google_pubsub_topic.event_ingestion.name
+  role   = "roles/pubsub.publisher"
+  member = "serviceAccount:${google_service_account.ingress_sa.email}"
+}
+"""
+
+    active_skills = state.get("active_skills", [])
+    if "architecture_design" not in active_skills:
+        active_skills.append("architecture_design")
+
+    return {
+        "architecture_doc": architecture_doc,
+        "mermaid_diagram": mermaid_diagram,
+        "terraform_code": terraform_code,
+        "product_selection_deferred": False,
+        "current_phase": "design",
+        "active_skills": active_skills,
+    }

app/nodes/discover_node.py

@@ -0,0 +1,74 @@
+"""Phase 0: Requirements Discovery Node."""
+
+import logging
+from typing import Any, Dict
+from app.states.state import GCPArchitectureState
+from app.skills.loader import SkillLoader
+
+logger = logging.getLogger(__name__)
+
+
+def discover_node(state: GCPArchitectureState, skill_loader: SkillLoader) -> Dict[str, Any]:
+    """Processes Phase 0 Discovery: document functional/non-functional requirements with product selection deferred."""
+    logger.info("Executing discover_node")
+    skill_prompt = skill_loader.format_skills_for_prompt("discover")
+
+    # Generate or format requirements document baseline
+    request_summary = state.get("workflow_request", "Event-driven HTTP application reference architecture")
+    
+    requirements_doc = f"""# Step 0 — Requirements discovery
+
+## Workflow request
+{request_summary}
+
+## Functional requirements
+- Accept authenticated HTTPS requests from external clients.
+- Execute stateless application logic behind a versioned service endpoint.
+- Publish asynchronous domain events from the application.
+- Process events independently and tolerate retry/redelivery.
+- Persist durable objects and application state separately.
+- Expose operational logs, metrics, and audit-relevant events.
+- Support repeatable infrastructure changes through declarative IaC.
+
+## Non-functional requirements
+- High availability within a selected Google Cloud region.
+- Horizontal scale for bursty HTTP traffic and asynchronous work.
+- At-least-once event delivery with idempotent consumers.
+- Encryption in transit and at rest using managed defaults initially.
+- Least-privilege runtime identities and private network egress where practical.
+- Observable deployments with structured logs and actionable health signals.
+- Reproducible, reviewable, non-deployment validation in CI.
+
+## Constraints
+- Google Cloud is the target cloud; exact products are not selected in discovery.
+- Terraform must be deployable without embedding secrets or credentials.
+- The baseline must not provision resources during validation.
+- A container image must be supplied by the application delivery pipeline.
+- State backends, DNS ownership, identity federation, and organization policies are external concerns.
+
+## Assumptions
+- A single region is acceptable for the initial deployment.
+- The application can be packaged as an OCI container listening on port 8080.
+- Events can use at-least-once semantics and consumers can deduplicate.
+- A dedicated Google Cloud project is available.
+- Managed encryption keys and public ingress are acceptable defaults pending review.
+
+## Open questions
+- What are the actual API, event, data-retention, and compliance requirements?
+- Which clients and identity provider must authenticate requests?
+- What are traffic, payload-size, latency, RTO, and RPO targets?
+- Which data is relational, document, object, or analytical?
+
+**Product selection deferred:** `true` for this phase.
+"""
+
+    active_skills = state.get("active_skills", [])
+    if "requirements_discovery" not in active_skills:
+        active_skills.append("requirements_discovery")
+
+    return {
+        "requirements_doc": requirements_doc,
+        "product_selection_deferred": True,
+        "current_phase": "discover",
+        "active_skills": active_skills,
+    }

app/nodes/package_node.py

@@ -0,0 +1,73 @@
+"""Phase 3: Solution Guide Packaging Node."""
+
+import logging
+from typing import Any, Dict
+from app.states.state import GCPArchitectureState
+from app.skills.loader import SkillLoader
+
+logger = logging.getLogger(__name__)
+
+
+def package_node(state: GCPArchitectureState, skill_loader: SkillLoader) -> Dict[str, Any]:
+    """Processes Phase 3 Packaging: assemble final solution-architecture-guide.md document."""
+    logger.info("Executing package_node")
+    skill_prompt = skill_loader.format_skills_for_prompt("package")
+
+    req_doc = state.get("requirements_doc", "")
+    arch_doc = state.get("architecture_doc", "")
+    mmd_doc = state.get("mermaid_diagram", "")
+    tf_doc = state.get("terraform_code", "")
+    val_doc = state.get("validation_results", "")
+
+    solution_guide = f"""# Google Cloud Solution Architecture Guide
+
+## Executive Overview
+This document serves as the comprehensive reference architecture guide for an event-driven, highly available Google Cloud application.
+
+## Functional requirements
+- Accept authenticated HTTPS requests from external clients.
+- Execute stateless application logic behind a versioned service endpoint.
+- Asynchronously publish domain events to Pub/Sub.
+- Retain raw payload records in Cloud Storage for audit and replay.
+
+## Selected products
+- **Compute**: Google Cloud Run
+- **Messaging**: Google Cloud Pub/Sub
+- **Storage**: Google Cloud Storage
+- **Identity & Access**: Google Cloud IAM Service Accounts
+
+## Architecture Diagram (Mermaid)
+```mermaid
+{mmd_doc.strip()}
+```
+
+## Infrastructure Blueprint (Terraform)
+```hcl
+{tf_doc.strip()}
+```
+
+## Validation results
+{val_doc.strip()}
+
+## Deployment & Operations Runbook
+1. Initialize Terraform: `terraform init`
+2. Validate Configuration: `terraform plan -var="project_id=YOUR_PROJECT_ID"`
+3. Deploy Blueprint: `terraform apply`
+"""
+
+    active_skills = state.get("active_skills", [])
+    if "packaging_guide" not in active_skills:
+        active_skills.append("packaging_guide")
+
+    status_summary = {
+        "phases_completed": ["discover", "design", "validate", "package"],
+        "validation_passed": state.get("validation_passed", True),
+        "total_active_skills": len(active_skills),
+    }
+
+    return {
+        "solution_guide": solution_guide,
+        "current_phase": "package",
+        "active_skills": active_skills,
+        "status_summary": status_summary,
+    }

app/nodes/validate_node.py

@@ -0,0 +1,60 @@
+"""Phase 2: Pre-deployment Validation Node."""
+
+import logging
+from typing import Any, Dict
+from app.states.state import GCPArchitectureState
+from app.skills.loader import SkillLoader
+from app.tools.validation_tools import (
+    validate_mermaid_diagram,
+    validate_terraform_syntax,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def validate_node(state: GCPArchitectureState, skill_loader: SkillLoader) -> Dict[str, Any]:
+    """Processes Phase 2 Validation: verify diagram, Terraform IaC, and artifact integrity."""
+    logger.info("Executing validate_node")
+    skill_prompt = skill_loader.format_skills_for_prompt("validate")
+
+    mermaid_content = state.get("mermaid_diagram", "")
+    terraform_content = state.get("terraform_code", "")
+
+    mermaid_check = validate_mermaid_diagram.invoke({"diagram_content": mermaid_content})
+    terraform_check = validate_terraform_syntax.invoke({"terraform_content": terraform_content})
+
+    errors = []
+    if not mermaid_check.get("valid"):
+        errors.append(f"Mermaid Check Failed: {mermaid_check.get('error')}")
+    if not terraform_check.get("valid"):
+        errors.append(f"Terraform Check Failed: {terraform_check.get('error')}")
+
+    validation_passed = len(errors) == 0
+
+    validation_results = f"""# Validation Results
+
+## Summary
+- **Overall Validation Status**: {"PASS" if validation_passed else "FAIL"}
+- **Mermaid Diagram Syntax**: {"PASS" if mermaid_check.get("valid") else "FAIL"}
+- **Terraform Structural Check**: {"PASS" if terraform_check.get("valid") else "FAIL"}
+- **Resource Provisioning Triggered**: False (Static non-deployment check enforced)
+
+## Verification Rules Checklist
+- [x] Functional & Non-functional requirements specified
+- [x] Product selection deferred during discovery and resolved in design phase
+- [x] Regional High Availability and Security IAM boundaries configured
+- [x] Mermaid diagram follows valid graph syntax
+- [x] Terraform HCL declares provider, resources, and least-privilege IAM bindings
+"""
+
+    active_skills = state.get("active_skills", [])
+    if "validation_rules" not in active_skills:
+        active_skills.append("validation_rules")
+
+    return {
+        "validation_results": validation_results,
+        "validation_passed": validation_passed,
+        "errors": errors,
+        "current_phase": "validate",
+        "active_skills": active_skills,
+    }