@atmem/architect 0.0.0-stage → 0.2.0-alpha.4.1

package/src/upstream/openarchflow/import/mermaid.ts

@@ -0,0 +1,205 @@
+// Derived from OpenArchFlow. Copyright (c) 2026 Rafael Sales. MIT.
+// AtForma: type-only imports and rendering-independent integration; see THIRD_PARTY_NOTICES.md.
+import type { AppNode, AppEdge } from '@/lib/store';
+
+interface ParseResult {
+    nodes: AppNode[];
+    edges: AppEdge[];
+}
+
+// Minimal Mermaid text parser — avoids the heavy mermaid render pipeline
+// Supports flowchart/graph, sequenceDiagram, classDiagram
+
+function sanitizeId(raw: string): string {
+    return raw.replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+
+function makeNode(id: string, label: string, x = 0, y = 0): AppNode {
+    return {
+        id,
+        type: 'generic',
+        position: { x, y },
+        data: { label, service: 'Generic', type: 'generic' },
+    };
+}
+
+function makeEdge(id: string, source: string, target: string, label = ''): AppEdge {
+    return {
+        id,
+        source,
+        target,
+        label: label || undefined,
+        type: 'smoothstep',
+    } as AppEdge;
+}
+
+// ── Flowchart / Graph ─────────────────────────────────────────────────────────
+
+function parseFlowchart(lines: string[]): ParseResult {
+    const nodes = new Map<string, AppNode>();
+    const edges: AppEdge[] = [];
+
+    // Patterns
+    const nodePattern = /^\s*([A-Za-z0-9_]+)(?:\[([^\]]*)\]|\(([^)]*)\)|\{([^}]*)\}|>"([^"]*)"|\("([^"]*)"\))?/;
+    const edgePattern = /([A-Za-z0-9_]+)\s*(?:-->|->|===|==|--)\s*(?:\|([^|]*)\|)?\s*([A-Za-z0-9_]+)/g;
+
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('%%') || /^(flowchart|graph)\s/i.test(trimmed)) continue;
+
+        // AtForma: preserve inline labels and parse wires after removing node shapes.
+        const wireText = trimmed.replace(/\b([A-Za-z0-9_]+)\[([^\]]*)\]/g, (_, rawId, label) => {
+            const id = sanitizeId(rawId);
+            if (!nodes.has(id)) nodes.set(id, makeNode(id, label));
+            else nodes.get(id)!.data.label = label;
+            return rawId;
+        });
+        // Extract edges
+        let em: RegExpExecArray | null;
+        edgePattern.lastIndex = 0;
+        while ((em = edgePattern.exec(wireText)) !== null) {
+            const src = sanitizeId(em[1]);
+            const edgeLabel = em[2] ?? '';
+            const tgt = sanitizeId(em[3]);
+            if (!nodes.has(src)) nodes.set(src, makeNode(src, src));
+            if (!nodes.has(tgt)) nodes.set(tgt, makeNode(tgt, tgt));
+            edges.push(makeEdge(`${src}-${tgt}-${edges.length}`, src, tgt, edgeLabel));
+        }
+
+        // Extract node definitions (label overrides)
+        const nm = nodePattern.exec(trimmed);
+        if (nm) {
+            const id = sanitizeId(nm[1]);
+            const label = nm[2] ?? nm[3] ?? nm[4] ?? nm[5] ?? nm[6] ?? id;
+            if (id && id !== 'end' && id !== 'style' && id !== 'subgraph') {
+                if (!nodes.has(id)) nodes.set(id, makeNode(id, label));
+                else if (nm.slice(2).some(value => value !== undefined)) nodes.get(id)!.data.label = label;
+            }
+        }
+    }
+
+    // Auto position in a grid
+    const nodeArr = [...nodes.values()];
+    const cols = Math.ceil(Math.sqrt(nodeArr.length));
+    nodeArr.forEach((n, i) => {
+        n.position = { x: (i % cols) * 220, y: Math.floor(i / cols) * 120 };
+    });
+
+    return { nodes: nodeArr, edges };
+}
+
+const LIFELINE_SLOT_HEIGHT = 50;
+
+function makeSequenceActor(id: string, label: string, x = 0): AppNode {
+    return {
+        id,
+        type: 'sequence-actor',
+        position: { x, y: 0 },
+        data: { label, service: 'Actor', type: 'sequence-actor' },
+    };
+}
+
+// ── Sequence Diagram ──────────────────────────────────────────────────────────
+
+function parseSequence(lines: string[]): ParseResult {
+    const participants = new Map<string, AppNode>();
+    const edges: AppEdge[] = [];
+    let msgIndex = 0;
+
+    const participantRe = /^participant\s+(.+)/i;
+    const actorRe = /^actor\s+(.+)/i;
+    const msgRe = /^([A-Za-z0-9_]+)\s*(->>|-->|-x|->)\s*([A-Za-z0-9_]+)\s*:\s*(.*)/;
+
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || /^sequenceDiagram/i.test(trimmed)) continue;
+
+        const pm = participantRe.exec(trimmed) ?? actorRe.exec(trimmed);
+        if (pm) {
+            const name = pm[1].split(' as ').pop()!.trim();
+            const id = sanitizeId(name);
+            if (!participants.has(id)) {
+                participants.set(id, makeSequenceActor(id, name, participants.size * 200));
+            }
+            continue;
+        }
+
+        const mm = msgRe.exec(trimmed);
+        if (mm) {
+            const src = sanitizeId(mm[1]);
+            const tgt = sanitizeId(mm[3]);
+            const label = mm[4]?.trim() ?? '';
+            if (!participants.has(src)) participants.set(src, makeSequenceActor(src, src, participants.size * 200));
+            if (!participants.has(tgt)) participants.set(tgt, makeSequenceActor(tgt, tgt, participants.size * 200));
+            const slotIdx = msgIndex % 16;
+            edges.push({
+                ...makeEdge(`seq-${msgIndex}`, src, tgt, label),
+                sourceHandle: `lifeline-src-${slotIdx}`,
+                targetHandle: `lifeline-tgt-${slotIdx}`,
+                data: { sequenceIndex: msgIndex },
+            } as AppEdge);
+            msgIndex++;
+        }
+    }
+
+    // Reposition participants in a horizontal row, spaced wider for lifeline handles
+    let x = 0;
+    for (const n of participants.values()) {
+        n.position = { x, y: 0 };
+        x += 240;
+    }
+
+    return { nodes: [...participants.values()], edges };
+}
+
+// ── Class Diagram ─────────────────────────────────────────────────────────────
+
+function parseClass(lines: string[]): ParseResult {
+    const classes = new Map<string, AppNode>();
+    const edges: AppEdge[] = [];
+
+    const classRe = /^class\s+([A-Za-z0-9_]+)/;
+    const relationRe = /([A-Za-z0-9_]+)\s*(<\|--|<\|\.\.|\*--|o--|-->|\.\.>|--)\s*([A-Za-z0-9_]+)\s*(?::\s*(.+))?/;
+
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || /^classDiagram/i.test(trimmed)) continue;
+
+        const cm = classRe.exec(trimmed);
+        if (cm) {
+            const id = sanitizeId(cm[1]);
+            if (!classes.has(id)) classes.set(id, makeNode(id, cm[1]));
+            continue;
+        }
+
+        const rm = relationRe.exec(trimmed);
+        if (rm) {
+            const src = sanitizeId(rm[1]);
+            const tgt = sanitizeId(rm[3]);
+            const label = rm[4]?.trim() ?? '';
+            if (!classes.has(src)) classes.set(src, makeNode(src, rm[1]));
+            if (!classes.has(tgt)) classes.set(tgt, makeNode(tgt, rm[3]));
+            edges.push(makeEdge(`cls-${edges.length}`, src, tgt, label));
+        }
+    }
+
+    const classArr = [...classes.values()];
+    const cols = Math.ceil(Math.sqrt(classArr.length));
+    classArr.forEach((n, i) => {
+        n.position = { x: (i % cols) * 220, y: Math.floor(i / cols) * 150 };
+    });
+
+    return { nodes: classArr, edges };
+}
+
+// ── Public entry point ────────────────────────────────────────────────────────
+
+export function parseMermaid(code: string): ParseResult {
+    const lines = code.split('\n');
+    const first = lines.find((l) => l.trim())?.trim().toLowerCase() ?? '';
+
+    if (first.startsWith('sequencediagram')) return parseSequence(lines);
+    if (first.startsWith('classdiagram')) return parseClass(lines);
+    // flowchart / graph / default
+    return parseFlowchart(lines);
+}

package/src/upstream/openarchflow/import/sql-ddl.ts

@@ -0,0 +1,109 @@
+// Derived from OpenArchFlow. Copyright (c) 2026 Rafael Sales. MIT.
+// AtForma: type-only imports and rendering-independent integration; see THIRD_PARTY_NOTICES.md.
+import type { AppNode, AppEdge } from '@/lib/store';
+import type { TableColumn } from '@/components/diagram/TableNode';
+
+interface ParseResult {
+    nodes: AppNode[];
+    edges: AppEdge[];
+}
+
+function sanitizeId(name: string) {
+    return name.replace(/[`"[\]\s]/g, '').toLowerCase();
+}
+
+export function parseSqlDdl(sql: string): ParseResult {
+    const nodes: AppNode[] = [];
+    const edges: AppEdge[] = [];
+
+    // Split into CREATE TABLE blocks
+    const tableRe = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?[`"[]?(\w+)[`"\]]?\s*\(([^;]+)\)/gi;
+    let match: RegExpExecArray | null;
+    let col = 0;
+    let row = 0;
+
+    while ((match = tableRe.exec(sql)) !== null) {
+        const tableName = match[1];
+        const body = match[2];
+        const tableId = `tbl-${sanitizeId(tableName)}`;
+
+        const columns: TableColumn[] = [];
+        const fkRefs: { colId: string; refTable: string }[] = [];
+
+        // Parse column / constraint lines
+        const lines = body.split(',').map(l => l.trim()).filter(Boolean);
+        for (const line of lines) {
+            const upper = line.toUpperCase();
+
+            // FOREIGN KEY constraint
+            const fkMatch = /FOREIGN\s+KEY\s*\([`"[\s]?(\w+)/i.exec(line);
+            const refMatch = /REFERENCES\s+[`"[]?(\w+)/i.exec(line);
+            if (fkMatch && refMatch) {
+                const fkColId = `${tableId}-${sanitizeId(fkMatch[1])}`;
+                fkRefs.push({ colId: fkColId, refTable: sanitizeId(refMatch[1]) });
+                // Mark the column as FK
+                const existing = columns.find(c => c.id === fkColId);
+                if (existing) existing.isForeignKey = true;
+                continue;
+            }
+
+            // PRIMARY KEY standalone
+            if (/^PRIMARY\s+KEY/i.test(line)) {
+                const pkCols = line.match(/\(([^)]+)\)/);
+                if (pkCols) {
+                    pkCols[1].split(',').forEach(c => {
+                        const id = `${tableId}-${sanitizeId(c.trim())}`;
+                        const col = columns.find(x => x.id === id);
+                        if (col) col.isPrimaryKey = true;
+                    });
+                }
+                continue;
+            }
+
+            // Column definition: name type [constraints]
+            const colMatch = /^[`"[]?(\w+)[`"\]]?\s+(\w+(?:\([^)]*\))?)/i.exec(line);
+            if (!colMatch) continue;
+            const colName = colMatch[1];
+            if (['INDEX', 'KEY', 'CONSTRAINT', 'UNIQUE', 'CHECK'].includes(colName.toUpperCase())) continue;
+
+            const colType = colMatch[2];
+            const isPK = /PRIMARY\s+KEY/i.test(line);
+            const isFK = /REFERENCES/i.test(line);
+            const nullable = !/NOT\s+NULL/i.test(line) && !isPK;
+
+            if (isFK) {
+                const ref = /REFERENCES\s+[`"[]?(\w+)/i.exec(line);
+                if (ref) fkRefs.push({ colId: `${tableId}-${sanitizeId(colName)}`, refTable: sanitizeId(ref[1]) });
+            }
+
+            columns.push({ id: `${tableId}-${sanitizeId(colName)}`, name: colName, type: colType, isPrimaryKey: isPK, isForeignKey: isFK, nullable });
+        }
+
+        // Position tables in a grid (3 per row)
+        const x = (col % 3) * 260;
+        const y = row * 220;
+        if (++col % 3 === 0) row++;
+
+        nodes.push({
+            id: tableId,
+            type: 'table',
+            position: { x, y },
+            data: { label: tableName, service: 'Table', type: 'table', metadata: { columns } },
+        } as AppNode);
+
+        // Resolve FK edges
+        for (const fk of fkRefs) {
+            const targetId = `tbl-${fk.refTable}`;
+            edges.push({
+                id: `fk-${fk.colId}-${targetId}`,
+                source: tableId,
+                target: targetId,
+                sourceHandle: `col-src-${fk.colId}`,
+                label: 'FK',
+                type: 'smoothstep',
+            } as AppEdge);
+        }
+    }
+
+    return { nodes, edges };
+}

package/src/upstream/openarchflow/layout.ts

@@ -0,0 +1,54 @@
+// Derived from OpenArchFlow. Copyright (c) 2026 Rafael Sales. MIT.
+// AtForma: type-only imports and rendering-independent integration; see THIRD_PARTY_NOTICES.md.
+import dagre from 'dagre';
+import type { Node, Edge } from '@xyflow/react';
+
+export type LayoutDirection = 'TB' | 'LR';
+
+export function getLayoutedElements(
+    nodes: Node[],
+    edges: Edge[],
+    direction: LayoutDirection = 'TB'
+) {
+    const dagreGraph = new dagre.graphlib.Graph();
+    dagreGraph.setDefaultEdgeLabel(() => ({}));
+
+    // Configure graph layout
+    const nodeWidth = 270;  // Width of AWS nodes
+    const nodeHeight = 180; // Height of AWS nodes
+
+    dagreGraph.setGraph({
+        rankdir: direction,
+        nodesep: 100,  // Horizontal spacing between nodes
+        ranksep: 150,  // Vertical spacing between ranks
+        marginx: 50,
+        marginy: 50,
+    });
+
+    // Add nodes to the graph
+    nodes.forEach((node) => {
+        dagreGraph.setNode(node.id, { width: nodeWidth, height: nodeHeight });
+    });
+
+    // Add edges to the graph
+    edges.forEach((edge) => {
+        dagreGraph.setEdge(edge.source, edge.target);
+    });
+
+    // Calculate layout
+    dagre.layout(dagreGraph);
+
+    // Apply new positions to nodes
+    const layoutedNodes = nodes.map((node) => {
+        const nodeWithPosition = dagreGraph.node(node.id);
+        return {
+            ...node,
+            position: {
+                x: nodeWithPosition.x - nodeWidth / 2,
+                y: nodeWithPosition.y - nodeHeight / 2,
+            },
+        };
+    });
+
+    return { nodes: layoutedNodes, edges };
+}

package/src/upstream/openarchflow/providers/aws.ts

@@ -0,0 +1,196 @@
+// Derived from OpenArchFlow. Copyright (c) 2026 Rafael Sales. MIT.
+// AtForma: type-only imports and rendering-independent integration; see THIRD_PARTY_NOTICES.md.
+import type { ServiceCategory } from './types';
+
+export const AWS_SERVICES: ServiceCategory[] = [
+    {
+        category: "Compute",
+        items: [
+            { name: "EC2", service: "ec2", type: "aws-compute", description: "Secure and resizable compute capacity in the cloud." },
+            { name: "Lambda", service: "lambda", type: "aws-compute", description: "Run code without thinking about servers. Pay only for the compute time you consume." },
+            { name: "EKS", service: "eks", type: "aws-compute", description: "Managed Kubernetes service to run Kubernetes on AWS." },
+            { name: "ECS", service: "ecs", type: "aws-compute", description: "Highly secure, reliable, and scalable way to run containers." },
+            { name: "Fargate", service: "fargate", type: "aws-compute", description: "Serverless compute for containers. Works with both ECS and EKS." },
+            { name: "App Runner", service: "apprunner", type: "aws-compute", description: "Fully managed service that makes it easy for developers to quickly deploy containerized web applications." },
+            { name: "Batch", service: "batch", description: "Fully managed batch processing at any scale." },
+            { name: "Elastic Beanstalk", service: "elasticbeanstalk", description: "Easy-to-use service for deploying and scaling web applications and services." },
+            { name: "Lightsail", service: "lightsail", description: "Easy-to-use virtual private server (VPS) instances, containers, storage, and more." },
+            { name: "Amplify", service: "amplify", type: "aws-compute", description: "Fastest, easiest way to build mobile and web apps that scale — includes hosting, CI/CD, and backend services." },
+        ]
+    },
+    {
+        category: "Containers",
+        items: [
+            { name: "ECR", service: "ecr", type: "aws-containers", description: "Fully managed container registry that makes it easy to store, manage, share, and deploy container images." },
+            { name: "ECS", service: "ecs", type: "aws-containers", description: "Highly secure, reliable, and scalable way to run containers." },
+            { name: "EKS", service: "eks", type: "aws-containers", description: "Managed Kubernetes service to run Kubernetes on AWS." },
+            { name: "Fargate", service: "fargate", type: "aws-containers", description: "Serverless compute for containers. Works with both ECS and EKS." },
+            { name: "EKS Anywhere", service: "eksanywhere", description: "Create and operate Kubernetes clusters on your own infrastructure." },
+            { name: "ECS Anywhere", service: "ecsanywhere", description: "Run and manage container workloads on-premises using the same APIs as ECS." },
+        ]
+    },
+    {
+        category: "Database",
+        items: [
+            { name: "RDS", service: "rds", type: "aws-database", description: "Managed Relational Database Service for MySQL, PostgreSQL, SQL Server, etc." },
+            { name: "DynamoDB", service: "dynamodb", type: "aws-database", description: "Fast, flexible NoSQL database service for single-digit millisecond performance at any scale." },
+            { name: "ElastiCache", service: "elasticache", type: "aws-database", description: "In-memory data store and cache service, supporting Redis and Memcached." },
+            { name: "Aurora", service: "rds", type: "aws-database", description: "MySQL and PostgreSQL-compatible relational database built for the cloud." },
+            { name: "Neptune", service: "neptune", type: "aws-database", description: "Fast, reliable, fully managed graph database service." },
+            { name: "DocumentDB", service: "documentdb", type: "aws-database", description: "Fast, scalable, highly available, and fully managed MongoDB-compatible database service." },
+            { name: "Timestream", service: "timestream", description: "Fast, scalable, and serverless time series database service." },
+            { name: "Keyspaces", service: "keyspaces", description: "Scalable, highly available, and managed Apache Cassandra-compatible database service." },
+            { name: "MemoryDB", service: "memorydb", description: "Redis-compatible, durable, in-memory database service." },
+            { name: "QLDB", service: "qldb", description: "Fully managed ledger database that provides a transparent, immutable, and cryptographically verifiable transaction log." },
+        ]
+    },
+    {
+        category: "Storage",
+        items: [
+            { name: "S3", service: "s3", type: "aws-storage", description: "Object storage built to retrieve any amount of data from anywhere." },
+            { name: "EFS", service: "efs", type: "aws-storage", description: "Scalable, fully managed elastic NFS file system." },
+            { name: "EBS", service: "ebs", type: "aws-storage", description: "Easy to use, high performance block storage at any scale." },
+            { name: "Glacier", service: "glacier", type: "aws-storage", description: "Long-term, secure, durable S3 storage classes for data archiving." },
+            { name: "FSx", service: "fsx", description: "Fully managed file systems for Windows File Server, Lustre, NetApp ONTAP, and OpenZFS." },
+            { name: "Backup", service: "backup", description: "Fully managed backup service that makes it easy to centralize and automate data protection." },
+            { name: "Storage Gateway", service: "storagegateway", description: "Hybrid cloud storage service that provides on-premises access to virtually unlimited cloud storage." },
+            { name: "Snow Family", service: "snowfamily", type: "aws-storage", description: "Physical devices to migrate data into and out of AWS at petabyte scale — Snowcone, Snowball, and Snowmobile." },
+            { name: "S3 Transfer Acceleration", service: "s3transferacceleration", type: "aws-storage", description: "Fast, easy, and secure transfer of files over long distances between your client and an S3 bucket." },
+        ]
+    },
+    {
+        category: "Networking",
+        items: [
+            { name: "VPC", service: "vpc", type: "aws-network", description: "Provision a logically isolated section of the AWS Cloud." },
+            { name: "Direct Connect", service: "directconnect", type: "aws-network", description: "Establish a dedicated network connection from your premises to AWS." },
+            { name: "Client VPN", service: "clientvpn", type: "aws-network", description: "Securely access your AWS resources and on-premises network from any device, anywhere." },
+            { name: "Site-to-Site VPN", service: "sitetositevpn", type: "aws-network", description: "Securely connect your on-premises network or branch office site to your VPC." },
+            { name: "CloudFront", service: "cloudfront", type: "aws-network", description: "Fast, highly secure and programmable content delivery network (CDN)." },
+            { name: "Route 53", service: "route53", type: "aws-network", description: "Highly available and scalable cloud Domain Name System (DNS) web service." },
+            { name: "API Gateway", service: "apigateway", type: "aws-network", description: "Fully managed service that makes it easy for developers to create, publish, maintain, monitor, and secure APIs." },
+            { name: "ELB", service: "elb", type: "aws-network", description: "Automatically distributes incoming application traffic across multiple targets." },
+            { name: "ALB", service: "alb", type: "aws-network", description: "Application Load Balancer: Operates at the application layer." },
+            { name: "Nat Gateway", service: "natgateway", type: "aws-network", description: "Enables instances in a private subnet to connect to the internet or other AWS services." },
+            { name: "Internet Gateway", service: "internetgateway", type: "aws-network", description: "Horizontally scaled, redundant, and highly available VPC component that allows communication between your VPC and the internet." },
+            { name: "Transit Gateway", service: "transitgateway", type: "aws-network", description: "Connects VPCs and on-premises networks through a central hub." },
+            { name: "Private Subnet", service: "privatesubnet", type: "aws-network", description: "Subnet within a VPC that does not have a direct route to the internet." },
+            { name: "Network Firewall", service: "networkfirewall", type: "aws-network", description: "Managed stateful network firewall and intrusion detection and prevention service for VPCs." },
+            { name: "AWS PrivateLink", service: "privatelink", type: "aws-network", description: "Provides private connectivity between VPCs, AWS services, and on-premises networks without exposing traffic to the internet." },
+            { name: "Global Accelerator", service: "globalaccelerator", type: "aws-network", description: "Networking service that improves availability and performance of applications using the AWS global network." },
+            { name: "VPC Endpoint", service: "vpcendpoint", type: "aws-network", description: "Enables private connections from your VPC to supported AWS services without requiring an internet gateway." },
+            { name: "Elastic IP", service: "elasticip", type: "aws-network", description: "Static public IPv4 address designed for dynamic cloud computing." },
+            { name: "Customer Gateway", service: "customergateway", type: "aws-network", description: "AWS resource that provides information about your customer gateway device for a Site-to-Site VPN connection." },
+            { name: "VPN Gateway", service: "vpngateway", type: "aws-network", description: "The VPC side of a VPN connection that terminates Site-to-Site VPN connections." },
+            { name: "Network ACL", service: "networkacl", type: "aws-network", description: "Optional stateless layer of security for your VPC that acts as a firewall for controlling traffic at the subnet level." },
+            { name: "NLB", service: "nlb", type: "aws-network", description: "Network Load Balancer: Routes connections based on IP protocol data, operating at the transport layer (Layer 4)." },
+        ]
+    },
+    {
+        category: "AI & Machine Learning",
+        items: [
+            { name: "Bedrock", service: "bedrock", type: "aws-ai", description: "The easiest way to build and scale generative AI applications with foundation models." },
+            { name: "SageMaker", service: "sagemaker", type: "aws-ai", description: "Build, train, and deploy machine learning models for any use case." },
+            { name: "Rekognition", service: "rekognition", type: "aws-ai", description: "Automate your image and video analysis with machine learning." },
+            { name: "Comprehend", service: "comprehend", type: "aws-ai", description: "Derive and understand insights and relationships in text." },
+            { name: "Textract", service: "textract", type: "aws-ai", description: "Automatically extract printed text, handwriting, and data from any document." },
+            { name: "Translate", service: "translate", description: "Fluent and accurate neural machine translation." },
+            { name: "Transcribe", service: "transcribe", description: "Automatic speech recognition (ASR) service that makes it easy for developers to add speech-to-text capability." },
+            { name: "Polly", service: "polly", description: "Turn text into lifelike speech." },
+            { name: "Lex", service: "lex", description: "Build chatbots and conversational interfaces." },
+            { name: "Personalize", service: "personalize", description: "Create real-time personalized recommendations." },
+            { name: "Forecast", service: "forecast", description: "Build accurate forecasting models based on machine learning." },
+            { name: "Kendra", service: "kendra", description: "Highly accurate and easy-to-use enterprise search service powered by machine learning." },
+            { name: "Amazon Q", service: "q", type: "aws-ai", description: "Generative AI-powered assistant for business — accelerate software development and gain insights from enterprise data." },
+            { name: "HealthLake", service: "healthlake", type: "aws-ai", description: "Store, transform, query, and analyze health data at scale in the FHIR standard." },
+        ]
+    },
+    {
+        category: "Application Integration",
+        items: [
+            { name: "SQS", service: "sqs", type: "aws-integration", description: "Fully managed message queuing service that enables you to decouple and scale microservices." },
+            { name: "SNS", service: "sns", type: "aws-integration", description: "Fully managed pub/sub messaging, SMS, email, and mobile push notifications." },
+            { name: "Step Functions", service: "stepfunctions", type: "aws-integration", description: "Visual workflow service that helps developers use AWS services to build distributed applications." },
+            { name: "EventBridge", service: "eventbridge", type: "aws-integration", description: "Serverless event bus that helps you receive, filter, transform, route, and deliver events." },
+            { name: "AppSync", service: "appsync", description: "Build serverless GraphQL and Pub/Sub APIs that simplify application development." },
+            { name: "MQ", service: "mq", description: "Managed message broker service for Apache ActiveMQ and RabbitMQ." },
+            { name: "AppFlow", service: "appflow", type: "aws-integration", description: "Fully managed integration service to securely transfer data between AWS services and third-party SaaS apps." },
+            { name: "MWAA", service: "mwaa", type: "aws-integration", description: "Managed Workflows for Apache Airflow — orchestrate your workflows at scale using directed acyclic graphs (DAGs)." },
+        ]
+    },
+    {
+        category: "Security",
+        items: [
+            { name: "IAM", service: "iam", type: "aws-security", description: "Securely manage identities and access to AWS services and resources." },
+            { name: "Cognito", service: "cognito", type: "aws-security", description: "Customer identity and access management (CIAM) for web and mobile apps." },
+            { name: "Secrets Manager", service: "secretsmanager", type: "aws-security", description: "Rotate, manage, and retrieve database credentials, API keys, and other secrets." },
+            { name: "KMS", service: "kms", type: "aws-security", description: "Create and control the keys used to encrypt or digitally sign your data." },
+            { name: "WAF", service: "waf", type: "aws-security", description: "Protect your web applications from common web exploits." },
+            { name: "GuardDuty", service: "guardduty", description: "Intelligent threat detection and continuous monitoring to protect your AWS accounts." },
+            { name: "Inspector", service: "inspector", description: "Automate vulnerability management at scale." },
+            { name: "Macie", service: "macie", description: "Discover and protect sensitive data at scale." },
+            { name: "Security Hub", service: "securityhub", description: "Cloud security posture management service that performs security best practice checks." },
+            { name: "Certificate Manager", service: "certificatemanager", description: "Provision, manage, and deploy public and private SSL/TLS certificates." },
+            { name: "CloudHSM", service: "cloudhsm", description: "Managed hardware security module (HSM) on the AWS Cloud." },
+            { name: "Shield", service: "shield", description: "Managed Distributed Denial of Service (DDoS) protection service." },
+            { name: "Firewall Manager", service: "firewallmanager", type: "aws-security", description: "Centrally configure and manage firewall rules across your accounts and applications in AWS Organizations." },
+            { name: "Detective", service: "detective", type: "aws-security", description: "Analyze and investigate security findings to identify the root cause of potential security issues." },
+            { name: "IAM Identity Center", service: "sso", type: "aws-security", description: "Centrally manage workforce access to multiple AWS accounts and cloud applications with single sign-on." },
+            { name: "Verified Access", service: "verifiedaccess", type: "aws-security", description: "Securely provide access to corporate applications without a VPN, using Zero Trust principles." },
+        ]
+    },
+    {
+        category: "Developer Tools",
+        items: [
+            { name: "CodePipeline", service: "codepipeline", type: "aws-devtools", description: "Fully managed continuous delivery service that helps you automate your release pipelines." },
+            { name: "CodeBuild", service: "codebuild", type: "aws-devtools", description: "Fully managed continuous integration service that compiles source code, runs tests, and produces software packages." },
+            { name: "CodeDeploy", service: "codedeploy", type: "aws-devtools", description: "Fully managed deployment service that automates software deployments." },
+            { name: "CodeCommit", service: "codecommit", type: "aws-devtools", description: "Secure, highly scalable, managed source control service." },
+            { name: "CodeArtifact", service: "codeartifact", description: "Secure, scalable, and cost-effective artifact management for software development." },
+            { name: "Cloud9", service: "cloud9", description: "Cloud-based integrated development environment (IDE) for writing, running, and debugging code." },
+            { name: "X-Ray", service: "xray", description: "Analyze and debug production, distributed applications." },
+            { name: "CodeGuru", service: "codeguru", type: "aws-devtools", description: "Intelligent recommendations for improving application performance, efficiency, and code quality." },
+        ]
+    },
+    {
+        category: "Management & Governance",
+        items: [
+            { name: "CloudWatch", service: "cloudwatch", type: "aws-management", description: "Observability of your AWS resources and applications on AWS and on-premises." },
+            { name: "CloudFormation", service: "cloudformation", type: "aws-management", description: "Model, provision, and manage AWS and third-party resources by treating infrastructure as code." },
+            { name: "Systems Manager", service: "systemsmanager", type: "aws-management", description: "Operational center for your AWS resources." },
+            { name: "Config", service: "config", description: "Assess, audit, and evaluate the configurations of your AWS resources." },
+            { name: "CloudTrail", service: "cloudtrail", description: "Track user activity and API usage." },
+            { name: "Organizations", service: "organizations", description: "Central governance and management across your AWS accounts." },
+            { name: "Control Tower", service: "controltower", description: "Establish and govern a secure, multi-account AWS environment." },
+            { name: "Service Catalog", service: "servicecatalog", description: "Create, manage, and govern a catalog of IT services." },
+            { name: "Trusted Advisor", service: "trustedadvisor", description: "Reduce costs, increase performance, and improve security." },
+            { name: "Compute Optimizer", service: "computeoptimizer", type: "aws-management", description: "Recommends optimal AWS resources to reduce costs and improve performance using machine learning." },
+            { name: "Health Dashboard", service: "health", type: "aws-management", description: "Provides visibility into the health of AWS services and personalized alerts for your account." },
+            { name: "Well-Architected Tool", service: "wellarchitected", type: "aws-management", description: "Review workloads against AWS best practices across the six pillars of the Well-Architected Framework." },
+            { name: "Resource Groups", service: "resourcegroups", type: "aws-management", description: "Organize and manage AWS resources by application, environment, or any criteria using tags." },
+        ]
+    },
+    {
+        category: "Analytics",
+        items: [
+            { name: "Kinesis", service: "kinesis", type: "aws-analytics", description: "Easily collect, process, and analyze video and data streams in real time." },
+            { name: "Glue", service: "glue", type: "aws-analytics", description: "Scalable, serverless data integration service that makes it easy to discover, prepare, and combine data." },
+            { name: "Athena", service: "athena", type: "aws-analytics", description: "Interactive query service that makes it easy to analyze data in Amazon S3 using standard SQL." },
+            { name: "EMR", service: "emr", type: "aws-analytics", description: "Industry-leading cloud big data platform for processing vast amounts of data." },
+            { name: "Redshift", service: "redshift", description: "Fast, fully managed, and cost-effective data warehouse." },
+            { name: "QuickSight", service: "quicksight", description: "Fast, cloud-powered business intelligence (BI) service." },
+            { name: "OpenSearch", service: "opensearch", description: "Search, visualize, and analyze data." },
+            { name: "MSK", service: "msk", description: "Fully managed service that makes it easy for you to build and run applications that use Apache Kafka." },
+            { name: "Data Firehose", service: "firehose", type: "aws-analytics", description: "Fully managed service for delivering real-time streaming data to data lakes, warehouses, and analytics services." },
+            { name: "Lake Formation", service: "lakeformation", type: "aws-analytics", description: "Makes it easy to build, secure, and manage data lakes by automating many of the complex manual steps." },
+        ]
+    },
+    {
+        category: "Migration & Transfer",
+        items: [
+            { name: "Database Migration Service", service: "dms", type: "aws-migration", description: "Migrate your databases to AWS with minimal downtime." },
+            { name: "DataSync", service: "datasync", description: "Simple, fast, and secure online data transfer." },
+            { name: "Transfer Family", service: "transferfamily", description: "Fully managed support for SFTP, FTPS, and FTP." },
+            { name: "Migration Hub", service: "migrationhub", description: "Simplify and accelerate the migration of your data centers to AWS." },
+        ]
+    }
+];