Project-design.json

{
  "project_name": "NetAI - Enterprise Network Automation Platform",
  "version": "1.0.0",
  "description": "AI-powered network automation platform with visual topology discovery, natural language configuration, and real-time monitoring",
  
  "core_requirements": {
    "network_discovery": {
      "description": "Automatic network topology discovery via LLDP and Telnet",
      "features": [
        "User enters access switch IP",
        "System recursively discovers all connected devices via LLDP",
        "Builds complete network hierarchy (switches, routers, relationships)",
        "Supports multi-vendor environments (Cisco, Arista, Juniper)",
        "Caches topology data for performance",
        "Auto-refresh topology on schedule or manual trigger",
        "Detects device roles (core, distribution, access)",
        "Maps VLAN trunks and access ports"
      ],
      "protocols": ["LLDP", "CDP", "Telnet", "SSH"],
      "implementation": "Python with Netmiko, TextFSM parsers"
    },
    
    "ai_configuration_engine": {
      "description": "Natural language to network configuration translation",
      "workflow": [
        "1. User enters natural language command or selects devices",
        "2. AI (Groq) extracts device IPs and operations",
        "3. System connects to devices and retrieves current config + version",
        "4. AI generates configuration playbook with context awareness",
        "5. System validates playbook syntax and logic",
        "6. Creates dynamic Ansible/Netmiko inventory",
        "7. Executes configuration with rollback capability",
        "8. Returns results with before/after diffs"
      ],
      "ai_models": {
        "primary": "llama-3.1-70b-versatile",
        "fallback": "mixtral-8x7b-32768",
        "specialized": {
          "device_extraction": "Temperature: 0.1, Max tokens: 500",
          "playbook_generation": "Temperature: 0.3, Max tokens: 3000",
          "validation": "Temperature: 0.2, Max tokens: 1000",
          "explanation": "Temperature: 0.5, Max tokens: 1500"
        }
      },
      "features": [
        "Context-aware configuration (considers device type, IOS version)",
        "Multi-device batch operations",
        "Configuration validation before apply",
        "Dry-run mode (check mode)",
        "Automatic backup before changes",
        "Rollback capability on failure",
        "Change tracking and audit logs",
        "Configuration diff visualization",
        "Best practice recommendations",
        "Syntax error detection and suggestions"
      ]
    },
    
    "visual_topology": {
      "description": "Interactive network topology visualization",
      "library": "React Flow or D3.js with custom styling",
      "features": [
        "Hierarchical layout (core → distribution → access)",
        "Real-time device status indicators (up/down/degraded)",
        "Link utilization visualization",
        "Device type icons (router, switch, firewall)",
        "Zoom, pan, and fit-to-screen controls",
        "Click device to view details",
        "Select single or multiple devices",
        "Visual path highlighting",
        "Export topology as PNG/SVG",
        "Collapsible device groups",
        "Search and filter devices",
        "Port-level details on hover",
        "VLAN overlay visualization",
        "Spanning tree topology view"
      ],
      "mobile_responsive": true,
      "touch_gestures": ["pinch-zoom", "two-finger-pan", "tap-select"]
    },
    
    "ai_chat_interface": {
      "description": "Windsurf-style AI agent interface",
      "design_inspiration": "Windsurf AI, Claude.ai, ChatGPT",
      "features": [
        "Split-screen: topology (left) + chat (right)",
        "Natural language and CLI mode toggle",
        "Command history and favorites",
        "Multi-turn conversations with context",
        "Code block syntax highlighting",
        "Copy/paste configuration snippets",
        "Voice input support",
        "Command suggestions and autocomplete",
        "Template library (common tasks)",
        "Batch command queue",
        "Schedule commands for later execution",
        "Command approval workflow"
      ],
      "ui_components": [
        "Message bubbles with timestamps",
        "Device selector dropdown/chips",
        "Command preview modal",
        "Edit configuration inline",
        "Confirm/Cancel buttons",
        "Progress indicators",
        "Success/Error toast notifications",
        "Collapsible result panels"
      ]
    },
    
    "authentication_rbac": {
      "description": "Role-Based Access Control with JWT",
      "roles": [
        {
          "name": "Super Admin",
          "permissions": ["*"],
          "description": "Full system access"
        },
        {
          "name": "Network Admin",
          "permissions": [
            "view_topology",
            "execute_commands",
            "modify_config",
            "view_logs",
            "manage_devices",
            "approve_changes"
          ]
        },
        {
          "name": "Network Engineer",
          "permissions": [
            "view_topology",
            "execute_commands_readonly",
            "view_logs",
            "request_changes"
          ]
        },
        {
          "name": "NOC Operator",
          "permissions": [
            "view_topology",
            "view_logs",
            "execute_show_commands"
          ]
        },
        {
          "name": "Auditor",
          "permissions": [
            "view_topology",
            "view_logs",
            "export_reports"
          ]
        }
      ],
      "features": [
        "JWT token authentication",
        "Refresh token mechanism",
        "Password hashing (bcrypt)",
        "Multi-factor authentication (TOTP)",
        "Session management",
        "IP whitelist/blacklist",
        "Audit trail for all actions",
        "Failed login attempt tracking",
        "Password complexity requirements",
        "SSO integration (SAML, OAuth2)"
      ]
    },
    
    "database_schema": {
      "orm": "Prisma",
      "database": "Microsoft SQL Server",
      "schemas": {
        "users": {
          "fields": [
            "id (UUID)",
            "username (unique)",
            "email (unique)",
            "password_hash",
            "role_id (FK)",
            "mfa_secret",
            "is_active",
            "last_login",
            "created_at",
            "updated_at"
          ]
        },
        "roles": {
          "fields": [
            "id (UUID)",
            "name",
            "permissions (JSON)",
            "description",
            "created_at"
          ]
        },
        "devices": {
          "fields": [
            "id (UUID)",
            "hostname",
            "ip_address (unique)",
            "device_type (router/switch/firewall)",
            "vendor",
            "model",
            "ios_version",
            "serial_number",
            "location",
            "site_id (FK)",
            "status (up/down/maintenance)",
            "last_seen",
            "management_ip",
            "credentials_id (FK)",
            "discovered_at",
            "created_at",
            "updated_at"
          ],
          "indexes": ["ip_address", "hostname", "status"]
        },
        "network_topology": {
          "fields": [
            "id (UUID)",
            "source_device_id (FK)",
            "source_interface",
            "destination_device_id (FK)",
            "destination_interface",
            "link_type (physical/logical)",
            "bandwidth",
            "discovered_at",
            "updated_at"
          ]
        },
        "configuration_backups": {
          "fields": [
            "id (UUID)",
            "device_id (FK)",
            "configuration_text (TEXT)",
            "backup_type (auto/manual/pre-change)",
            "created_by (FK)",
            "created_at",
            "file_size",
            "checksum (SHA256)"
          ]
        },
        "change_requests": {
          "fields": [
            "id (UUID)",
            "title",
            "description",
            "requested_by (FK)",
            "devices (JSON array of IDs)",
            "commands (TEXT)",
            "playbook_generated (TEXT)",
            "status (pending/approved/rejected/completed/failed)",
            "approved_by (FK)",
            "executed_at",
            "execution_result (JSON)",
            "rollback_available (boolean)",
            "created_at",
            "updated_at"
          ]
        },
        "audit_logs": {
          "fields": [
            "id (UUID)",
            "user_id (FK)",
            "action",
            "target_device_id (FK)",
            "target_resource",
            "command_executed",
            "result (success/failed)",
            "ip_address",
            "user_agent",
            "duration_ms",
            "created_at"
          ],
          "indexes": ["user_id", "created_at", "action"]
        },
        "ai_conversations": {
          "fields": [
            "id (UUID)",
            "user_id (FK)",
            "session_id",
            "message_role (user/assistant)",
            "message_content (TEXT)",
            "device_context (JSON)",
            "tokens_used",
            "model_used",
            "created_at"
          ]
        },
        "network_assurance": {
          "description": "Future feature schema",
          "fields": [
            "id (UUID)",
            "device_id (FK)",
            "check_type (connectivity/config_drift/compliance)",
            "status (pass/fail/warning)",
            "details (JSON)",
            "remediation_steps (TEXT)",
            "created_at"
          ]
        },
        "sites": {
          "fields": [
            "id (UUID)",
            "name",
            "address",
            "city",
            "country",
            "timezone",
            "contact_email",
            "created_at"
          ]
        },
        "credentials": {
          "fields": [
            "id (UUID)",
            "name",
            "username",
            "password_encrypted",
            "enable_password_encrypted",
            "encryption_key_id",
            "credential_type (ssh/telnet/snmp)",
            "created_at",
            "updated_at"
          ]
        }
      }
    }
  },
  
  "technical_stack": {
    "frontend": {
      "framework": "React 18+ with TypeScript",
      "styling": "Tailwind CSS + shadcn/ui",
      "state_management": "Zustand or Redux Toolkit",
      "routing": "React Router v6",
      "http_client": "Axios with interceptors",
      "websockets": "Socket.IO client",
      "visualization": "React Flow + D3.js",
      "forms": "React Hook Form + Zod validation",
      "ui_components": [
        "@shadcn/ui (button, dialog, dropdown, etc.)",
        "Lucide React (icons)",
        "React Flow (topology)",
        "Monaco Editor (code editing)",
        "React Syntax Highlighter",
        "React Toastify (notifications)",
        "Framer Motion (animations)"
      ]
    },
    
    "backend": {
      "framework": "FastAPI (Python 3.11+)",
      "async": "asyncio + aiohttp",
      "networking": "Netmiko, NAPALM, Paramiko",
      "ai": "Groq Python SDK",
      "validation": "Pydantic v2",
      "orm": "Prisma (Python client)",
      "task_queue": "Celery + Redis",
      "websockets": "FastAPI WebSockets + Socket.IO",
      "authentication": "JWT (python-jose, passlib)",
      "api_docs": "OpenAPI/Swagger (auto-generated)",
      "logging": "Loguru",
      "monitoring": "Prometheus + Grafana"
    },
    
    "database": {
      "primary": "Microsoft SQL Server 2022",
      "cache": "Redis 7.0",
      "search": "Elasticsearch (optional for log search)",
      "backup": "Automated daily backups with retention policy"
    },
    
    "infrastructure": {
      "containerization": "Docker + Docker Compose",
      "reverse_proxy": "Nginx",
      "ssl": "Let's Encrypt (certbot)",
      "ci_cd": "GitHub Actions or GitLab CI",
      "secrets_management": "Docker secrets + environment variables"
    }
  },
  
  "ai_prompt_engineering": {
    "device_extraction_prompt": {
      "system": "You are a network device information extractor. Your job is to parse natural language commands and extract device IP addresses, device types, and operations. Return ONLY valid JSON with no additional text.\n\nRules:\n1. Extract ALL IP addresses mentioned\n2. Identify device type (router, switch, firewall, etc.)\n3. List all operations to perform\n4. If multiple devices, group by operation\n5. Return structured JSON only\n\nOutput format:\n{\n  \"devices\": [\n    {\"ip\": \"10.0.20.3\", \"type\": \"switch\", \"role\": \"access\"},\n    {\"ip\": \"10.0.20.1\", \"type\": \"router\", \"role\": \"gateway\"}\n  ],\n  \"operations\": [\n    {\"action\": \"create_vlan\", \"parameters\": {\"vlan_ids\": [10, 20, 30]}},\n    {\"action\": \"configure_interface\", \"parameters\": {\"interface\": \"g0/1\", \"ip\": \"192.168.1.1/24\"}}\n  ]\n}",
      "temperature": 0.1,
      "max_tokens": 1000,
      "examples": [
        {
          "input": "create vlans 10, 20, 30 on switches 10.0.20.3 and 10.0.20.4",
          "output": "{\"devices\": [{\"ip\": \"10.0.20.3\", \"type\": \"switch\"}, {\"ip\": \"10.0.20.4\", \"type\": \"switch\"}], \"operations\": [{\"action\": \"create_vlan\", \"parameters\": {\"vlan_ids\": [10, 20, 30]}}]}"
        }
      ]
    },
    
    "playbook_generation_prompt": {
      "system": "You are an expert network automation engineer specializing in Cisco IOS. Generate production-ready configuration commands based on user requests.\n\nContext provided:\n- Device hostname: {hostname}\n- Device type: {device_type}\n- IOS version: {ios_version}\n- Current configuration: {current_config_snippet}\n- Management IP: {management_ip}\n\nRules:\n1. Generate ONLY valid Cisco IOS commands\n2. Consider device type and IOS version compatibility\n3. Include configuration verification commands\n4. Add comments explaining each section\n5. Include rollback commands if applicable\n6. Follow Cisco best practices\n7. Validate VLAN IDs, IP addresses, interface names\n8. Use 'do show' commands for verification\n9. Return structured JSON with commands array\n\nOutput format:\n{\n  \"commands\": [\n    \"configure terminal\",\n    \"vlan 10\",\n    \"name SALES\",\n    \"exit\"\n  ],\n  \"verification_commands\": [\"show vlan id 10\"],\n  \"rollback_commands\": [\"no vlan 10\"],\n  \"explanation\": \"Creating VLAN 10 with name SALES\",\n  \"estimated_duration\": \"5 seconds\",\n  \"risk_level\": \"low\"\n}",
      "temperature": 0.3,
      "max_tokens": 3000
    },
    
    "validation_prompt": {
      "system": "You are a network configuration validator. Review the generated commands for syntax errors, logical issues, and best practice violations.\n\nValidation checklist:\n1. Syntax correctness for device type and IOS version\n2. Logical sequence (no dependencies on non-existent config)\n3. No duplicate configurations\n4. Valid IP addresses and subnet masks\n5. Valid VLAN IDs (1-4094, avoid reserved VLANs)\n6. Valid interface names\n7. No security vulnerabilities\n8. Best practice compliance\n\nReturn:\n{\n  \"valid\": true/false,\n  \"errors\": [{\"line\": 5, \"error\": \"Invalid VLAN ID 5000\", \"severity\": \"error\"}],\n  \"warnings\": [{\"line\": 3, \"warning\": \"Consider using description\", \"severity\": \"warning\"}],\n  \"suggestions\": [\"Add 'no shutdown' to interface configuration\"]\n}",
      "temperature": 0.2,
      "max_tokens": 1500
    },
    
    "explanation_prompt": {
      "system": "You are a friendly network assistant. Explain the configuration changes in simple terms for network engineers.\n\nGuidelines:\n1. Use clear, concise language\n2. Explain the purpose of each major configuration block\n3. Highlight potential impacts\n4. Mention any caveats or prerequisites\n5. Keep it under 200 words\n\nFormat: Plain text explanation",
      "temperature": 0.5,
      "max_tokens": 800
    }
  },
  
  "docker_architecture": {
    "services": [
      {
        "name": "frontend",
        "image": "node:20-alpine",
        "build": "./frontend",
        "ports": ["3000:3000"],
        "environment": [
          "REACT_APP_API_URL=http://backend:8000",
          "REACT_APP_WS_URL=ws://backend:8000/ws"
        ],
        "depends_on": ["backend"]
      },
      {
        "name": "backend",
        "image": "python:3.11-slim",
        "build": "./backend",
        "ports": ["8000:8000"],
        "environment": [
          "DATABASE_URL=sqlserver://user:pass@mssql:1433/netai",
          "REDIS_URL=redis://redis:6379",
          "GROQ_API_KEY=${GROQ_API_KEY}",
          "JWT_SECRET=${JWT_SECRET}"
        ],
        "depends_on": ["mssql", "redis"],
        "volumes": [
          "./backend:/app",
          "device_configs:/app/configs"
        ]
      },
      {
        "name": "mssql",
        "image": "mcr.microsoft.com/mssql/server:2022-latest",
        "ports": ["1433:1433"],
        "environment": [
          "ACCEPT_EULA=Y",
          "SA_PASSWORD=${DB_PASSWORD}",
          "MSSQL_PID=Developer"
        ],
        "volumes": ["mssql_data:/var/opt/mssql"]
      },
      {
        "name": "redis",
        "image": "redis:7-alpine",
        "ports": ["6379:6379"],
        "volumes": ["redis_data:/data"]
      },
      {
        "name": "celery",
        "build": "./backend",
        "command": "celery -A app.tasks worker --loglevel=info",
        "depends_on": ["redis", "mssql"],
        "environment": [
          "DATABASE_URL=sqlserver://user:pass@mssql:1433/netai",
          "REDIS_URL=redis://redis:6379"
        ]
      },
      {
        "name": "nginx",
        "image": "nginx:alpine",
        "ports": ["80:80", "443:443"],
        "volumes": [
          "./nginx/nginx.conf:/etc/nginx/nginx.conf",
          "./nginx/ssl:/etc/nginx/ssl"
        ],
        "depends_on": ["frontend", "backend"]
      }
    ],
    "volumes": [
      "mssql_data",
      "redis_data",
      "device_configs"
    ],
    "networks": ["netai_network"]
  },
  
  "project_structure": {
    "root": {
      "files": [
        "docker-compose.yml",
        "docker-compose.prod.yml",
        ".env.example",
        ".gitignore",
        "README.md",
        "DEPLOYMENT.md",
        "CONTRIBUTING.md",
        "LICENSE"
      ],
      "directories": {
        "frontend": {
          "subdirs": [
            "src/components",
            "src/pages",
            "src/hooks",
            "src/services",
            "src/stores",
            "src/utils",
            "src/types",
            "src/assets",
            "public"
          ],
          "key_files": [
            "package.json",
            "tsconfig.json",
            "tailwind.config.js",
            "vite.config.ts"
          ]
        },
        "backend": {
          "subdirs": [
            "app/api",
            "app/core",
            "app/db",
            "app/models",
            "app/schemas",
            "app/services",
            "app/tasks",
            "app/utils",
            "app/middleware",
            "tests"
          ],
          "key_files": [
            "main.py",
            "requirements.txt",
            "pyproject.toml",
            "Dockerfile",
            "prisma/schema.prisma"
          ]
        },
        "nginx": {
          "files": [
            "nginx.conf",
            "ssl/cert.pem",
            "ssl/key.pem"
          ]
        },
        "scripts": {
          "files": [
            "init_db.sh",
            "backup.sh",
            "restore.sh",
            "deploy.sh"
          ]
        },
        "docs": {
          "files": [
            "API.md",
            "ARCHITECTURE.md",
            "USER_GUIDE.md",
            "TROUBLESHOOTING.md"
          ]
        }
      }
    }
  },
  
  "key_features_implementation": {
    "network_discovery": {
      "algorithm": "Breadth-First Search (BFS)",
      "steps": [
        "1. Connect to access switch via Telnet/SSH",
        "2. Execute 'show lldp neighbors detail'",
        "3. Parse neighbors (device ID, IP, interface, capabilities)",
        "4. Add discovered devices to queue",
        "5. For each device in queue, repeat steps 2-4",
        "6. Build adjacency graph",
        "7. Calculate device hierarchy (core/distribution/access)",
        "8. Store in database with timestamps"
      ],
      "optimization": [
        "Parallel device connections (asyncio)",
        "Cache device info (Redis) with TTL",
        "Skip already discovered devices",
        "Timeout handling (30s per device)",
        "Retry logic (3 attempts)"
      ]
    },
    
    "command_execution_flow": {
      "steps": [
        "1. User types command or selects devices + enters CLI",
        "2. Frontend sends to backend via WebSocket",
        "3. Backend validates user permissions",
        "4. If natural language: Call Groq AI for extraction",
        "5. Connect to devices and fetch current config",
        "6. AI generates playbook with device context",
        "7. Validate playbook (syntax, logic, best practices)",
        "8. Show preview to user in modal",
        "9. User can edit playbook inline",
        "10. On confirm: Create backup, execute commands",
        "11. Stream results back via WebSocket",
        "12. Log to audit trail",
        "13. Update device status in topology"
      ]
    },
    
    "rollback_mechanism": {
      "strategy": "Configuration checkpoint + automatic restore",
      "implementation": [
        "Before changes: 'configure replace flash:backup.cfg'",
        "Archive config: 'archive config'",
        "On failure: Restore from checkpoint",
        "Keep last 5 backups per device",
        "Manual rollback from UI"
      ]
    },
    
    "real_time_updates": {
      "technology": "WebSockets (Socket.IO)",
      "events": [
        "device.status.changed",
        "command.execution.progress",
        "command.execution.completed",
        "topology.updated",
        "user.notification",
        "config.change.applied"
      ]
    }
  },
  
  "security_best_practices": {
    "authentication": [
      "Bcrypt password hashing (cost factor 12)",
      "JWT with short expiry (15 min access, 7 day refresh)",
      "MFA with TOTP (Google Authenticator)",
      "Account lockout after 5 failed attempts",
      "Password complexity requirements"
    ],
    "authorization": [
      "Role-based access control (RBAC)",
      "Permission checks on every API call",
      "Device-level access control",
      "Audit all privileged operations"
    ],
    "network": [
      "HTTPS only (TLS 1.3)",
      "Secure WebSocket (WSS)",
      "CORS configuration",
      "Rate limiting (100 req/min per user)",
      "IP whitelisting option"
    ],
    "data": [
      "Encrypt credentials at rest (AES-256)",
      "Encrypt backups",
      "Secure environment variables",
      "No secrets in code or logs",
      "SQL injection prevention (Prisma ORM)"
    ],
    "device_connections": [
      "SSH key authentication preferred",
      "Credential vault integration",
      "Connection timeout (30s)",
      "Secure credential storage",
      "Rotate passwords regularly"
    ]
  },
  
  "error_handling_strategy": {
    "backend": [
      "Try-except blocks around network operations",
      "Structured error responses (HTTP status codes)",
      "Detailed error logging (Loguru)",
      "User-friendly error messages",
      "Automatic retry with exponential backoff",
      "Circuit breaker for failing devices"
    ],
    "frontend": [
      "Error boundaries (React)",
      "Toast notifications for errors",
      "Form validation with helpful messages",
      "Loading states for async operations",
      "Fallback UI for failed components"
    ]
  },
  
  "performance_optimization": {
    "frontend": [
      "Code splitting (React.lazy)",
      "Virtual scrolling for large lists",
      "Memoization (React.memo, useMemo)",
      "Debounce user inputs",
      "Lazy load topology on demand",
      "Service worker for offline capability"
    ],
    "backend": [
      "Async operations (asyncio)",
      "Database connection pooling",
      "Redis caching (device info, topology)",
      "Celery for long-running tasks",
      "Batch database operations",
      "Pagination for large datasets"
    ],
    "database": [
      "Indexes on frequently queried fields",
      "Partitioning for large tables (audit_logs)",
      "Query optimization",
      "Regular maintenance (DBCC CHECKDB)"
    ]
  },
  
  "testing_strategy": {
    "frontend": {
      "unit": "Vitest + React Testing Library",
      "integration": "Playwright",
      "e2e": "Cypress",
      "coverage_target": "80%"
    },
    "backend": {
      "unit": "Pytest",
      "integration": "Pytest with test database",
      "load": "Locust",
      "coverage_target": "85%"
    }
  },
  
  "deployment_checklist": [
    "1. Clone repository",
    "2. Copy .env.example to .env and configure",
    "3. Generate JWT secret: openssl rand -hex 32",
    "4. Configure SQL Server connection",
    "5. Set Groq API key",
    "6. Run: docker-compose up -d",
    "7. Wait for services to start (30s)",
    "8. Run migrations: docker-compose exec backend prisma migrate deploy",
    "9. Create admin user: docker-compose exec backend python scripts/create_admin.py",
    "10. Access UI: https://localhost (or configured domain)",
    "11. Login with admin credentials",
    "12. Configure network discovery settings",
    "13. Add device credentials",
    "14. Test network discovery with access switch IP"
  ],
  
  "monitoring_observability": {
    "metrics": [
      "API response times",
      "Database query duration",
      "Network device connection success rate",
      "AI API latency and token usage",
      "Active user sessions",
      "Command execution success/failure rate"
    ],
    "logging": [
      "All API requests",
      "Authentication events",
      "Configuration changes",
      "Errors and exceptions",
      "Performance bottlenecks"
    ],
    "alerting": [
      "Device down alerts",
      "Failed authentication attempts",
      "High error rates",
      "Database connection issues",
      "Low disk space"
    ]
  },
  
  "future_roadmap": [
    {
      "feature": "Network Assurance",
      "description": "Automated compliance checking and drift detection",
      "priority": "High"
    },
    {
      "feature": "Intent-Based Networking",
      "description": "Define network intent, system auto-configures",
      "priority": "High"
    },
    {
      "feature": "Predictive Analytics",
      "description": "ML-based anomaly detection and capacity planning",
      "priority": "Medium"
    },
    {
      "feature": "Multi-Vendor Support",
      "description": "Expand beyond Cisco (Arista, Juniper, HPE)",
      "priority": "High"
    },
    {
      "feature": "Configuration Templates",
      "description": "Pre-built templates for common scenarios",
      "priority": "Medium"
    },
    {
      "feature": "Workflow Automation",
      "description": "Multi-step workflows with approval chains",
      "priority": "Medium"
    },
    {
      "feature": "Report Generation",
      "description": "Automated compliance and health reports",
      "priority": "Low"
    },
    {
      "feature": "Mobile App",
      "description": "Native iOS/Android app",
      "priority": "Low"
    }
  ],
  
  "mobile_responsiveness": {
    "breakpoints": {
      "sm": "640px",
      "md": "768px",
      "lg": "1024px",
      "xl": "1280px"
    },
    "mobile_features": [
      "Hamburger menu for navigation",
      "Bottom sheet for device details",
      "Swipe gestures for actions",
      "Touch-optimized topology controls",
      "Responsive tables (horizontal scroll or cards)",
      "Collapsible sections",
      "Floating action button for quick commands"
    ]
  },
  
  "accessibility": {
    "standards": "WCAG 2.1 Level AA",
    "features": [
      "Keyboard navigation",
      "Screen reader support (ARIA labels)",
      "High contrast mode",
      "Focus indicators",
      "Alt text for images/icons",
      "Semantic HTML"
    ]
  }
}