@seeka-labs/cli-apps 3.8.2 → 3.8.6

package/dist/ai-context/internal/examples/v1/transcend/_ai-summary.md

@@ -1,36 +1,56 @@
 # AI Summary for Seeka App: Transcend
 
-## Purpose and Functionality
-The Transcend app integrates with the Transcend data privacy platform to manage consent and data rights, ensuring compliance with privacy regulations. It facilitates the handling of webhooks from Seeka, processes data rights requests, and manages installations and settings updates.
+## Overview
+
+**App Name:** Transcend  
+**Purpose:** The Transcend app integrates with the Transcend data privacy platform to manage consent and data rights, ensuring compliance with privacy regulations.  
+**Template Version:** V1  
+**Template:** azurefunc  
+**Components:** Server  
+**Tags:** Privacy, Consent Management, Data Rights, Compliance  
 
 ## Key Implementation Patterns
-- **Azure Functions**: The app is built using Azure Functions, allowing it to handle HTTP requests, manage queues, and perform scheduled tasks.
-- **Webhook Handling**: The app processes various webhook events from Seeka, such as app installations, settings updates, and activity acceptance.
-- **State Management**: Redis is used for storing app installation states, with the option to swap for another state provider.
-- **Centralized Logging**: Utilizes Winston for logging, with optional integration with Seq for structured log management.
+
+1. **Azure Functions:** The app is built using Azure Functions, allowing it to handle serverless operations efficiently. It includes HTTP-triggered functions for webhook handling and health checks.
+
+2. **Webhook Handling:** The app processes various webhook events from Seeka, such as app installations, updates, and uninstalls. It validates webhook signatures to ensure security.
+
+3. **State Management:** The app uses Redis for managing the state of installations, allowing for efficient retrieval and update operations.
+
+4. **Queue Processing:** Azure Storage Queues are utilized for offloading long-running operations, ensuring that Azure Function execution time limits are respected.
+
+5. **Logging:** Centralized logging is implemented using Winston, with optional integration with Seq for advanced log management.
 
 ## External APIs/Services Integrated
-- **Transcend**: Integrates with Transcend for consent and data rights management.
-- **Azure Storage**: Uses Azure Storage Queues for managing asynchronous operations.
-- **Redis**: Employed for state management, with optional integration with Upstash.
-- **Ngrok**: Used for exposing local development environments to the internet for testing.
+
+- **Azure Functions:** For serverless function execution.
+- **Azure Storage Queue:** For message queuing and processing.
+- **Redis:** For state management.
+- **Ngrok:** For exposing local development environments to the internet.
+- **Seq (optional):** For advanced logging and monitoring.
 
 ## Important Data Transformations
-- **Webhook Payload Processing**: Parses and validates webhook payloads, ensuring the integrity and authenticity of incoming data.
-- **Installation State Management**: Handles the creation, update, and deletion of app installation states based on webhook events.
+
+- **Webhook Payload Processing:** The app parses and processes JSON payloads from incoming webhooks, validating signatures and handling various event types.
+- **State Management:** Transforms installation data for storage and retrieval in Redis.
+- **Queue Message Handling:** Transforms data into queue messages for deferred processing.
 
 ## Notable Code Patterns
-- **Webhook Signature Validation**: Ensures security by validating webhook signatures before processing.
-- **Queue Management**: Demonstrates how to offload long-running operations to Azure Storage Queues to respect Azure Function execution limits.
-- **Modular Service Initialization**: Uses a `startServices` function to initialize necessary services, promoting modularity and separation of concerns.
-- **Browser SDK Plugin Handling**: Integrates browser-specific plugins conditionally, showcasing a pattern for component-based architecture.
 
-## Development and Deployment
-- **Local Development**: Supports local development with Docker for Azure Storage emulation and Ngrok for exposing local servers.
-- **Deployment**: Provides scripts for deploying the app to Azure, ensuring a streamlined deployment process.
+1. **Webhook Signature Validation:** Ensures that incoming webhooks are authenticated using a secret key, enhancing security.
+
+2. **Centralized Logging with Winston:** Provides structured logging across the app, with optional Seq integration for enhanced log management.
+
+3. **Azure Function Triggers:** Utilizes HTTP triggers for webhooks and health checks, and timer triggers for scheduled operations.
+
+4. **State Management Abstraction:** Abstracts state management operations, allowing for easy replacement of Redis with another provider if needed.
+
+5. **Development Environment Configuration:** Provides comprehensive setup instructions for local development, including emulation of Azure services and use of Ngrok for testing.
+
+## Additional Information
 
-## Debugging and Testing
-- **VSCode Debugging**: Configured for debugging with VSCode, supporting breakpoints and step-through debugging.
-- **Testing**: Uses Jest for testing, ensuring code reliability and robustness.
+- **Development Setup:** Detailed instructions are provided for setting up the development environment, including dependencies, local storage emulation, and debugging configurations.
+- **Live URL Exposure:** Ngrok is used to expose the app locally for testing purposes, with instructions for configuration and use.
+- **Sample Functions:** Includes examples of webhook handling, queue processing, and polling to demonstrate common patterns and use cases.
 
-This summary provides an overview of the Transcend app's architecture, integration points, and implementation patterns, offering a comprehensive understanding for AI assistants and developers.
+This summary provides a comprehensive overview of the Transcend app's architecture and implementation, highlighting key patterns and integrations that can be leveraged in similar projects.

package/dist/ai-context/internal/examples/v2/calendly/_ai-summary.md

@@ -2,34 +2,37 @@
 
 ## Overview
 
-The Calendly integration app is designed to facilitate the tracking of meeting bookings and scheduling events from Calendly. It integrates with Calendly to manage scheduling and is built using Azure Functions as its serverless backend. The app is structured with components for the browser, UI, and server, and it leverages webhooks to interact with the Calendly API and other services.
+The Calendly integration app is designed to track meeting bookings and schedule events from Calendly. It serves as a bridge between Calendly and Seeka's ecosystem, enabling seamless integration of scheduling functionalities into CRM workflows. The app leverages webhooks to handle various events related to app installation, updates, and uninstallation.
 
 ## Key Implementation Patterns
 
-- **Monorepo Structure**: The app uses a monorepo setup managed by Yarn workspaces, allowing for organized development and deployment of multiple components (`lib`, `browser`, `ui`, `server`).
-- **Azure Functions**: The server-side logic is implemented using Azure Functions, providing a scalable and efficient way to handle HTTP requests and webhooks.
-- **Webhook Handling**: The app processes various webhook events from Seeka and Calendly, including installation, uninstallation, and settings updates.
-- **Logging**: Utilizes the `winston` library for structured logging, which is crucial for debugging and monitoring webhook interactions.
+1. **Monorepo Structure with Yarn Workspaces**: The app is organized using Yarn workspaces, allowing for modular development across different components like `browser`, `ui`, and `server`. This structure facilitates efficient dependency management and streamlined build processes.
+
+2. **Azure Functions**: The app uses Azure Functions as its serverless backend, providing scalable and event-driven execution of server-side logic. This is evident from the use of `@azure/functions` for HTTP request handling.
+
+3. **Webhook Handling**: The app extensively uses webhooks to receive and process events from Seeka and Calendly. It validates webhook signatures to ensure secure communication and processes different webhook types to update installation states or trigger browser SDK plugins.
+
+4. **Logging with Winston**: The app employs the Winston logging library to maintain detailed logs of webhook processing, aiding in debugging and monitoring.
 
 ## External APIs/Services Integrated
 
-- **Calendly API**: The app integrates with Calendly to manage scheduling and event tracking.
-- **Seeka SDK**: Utilizes the Seeka SDK for handling webhook payloads and managing app installations.
+- **Calendly**: The app integrates with Calendly to track and manage event bookings.
+- **Azure Functions**: Used for deploying serverless functions that handle HTTP requests and process webhooks.
+- **Seeka SDK**: The app utilizes Seeka's SDK for handling webhook payloads and managing app installation states.
 
 ## Important Data Transformations
 
-- **Webhook Payload Parsing**: The app parses JSON payloads from incoming webhooks to extract necessary information for processing events.
-- **Installation State Management**: Transforms webhook payloads into installation states, updating or deleting installations as necessary.
+- **Webhook Payload Parsing**: Incoming webhook payloads are parsed and validated to ensure they are correctly formatted and signed. This involves converting JSON strings into structured objects and verifying signatures.
+- **Installation State Management**: The app manages the state of installations by creating, updating, or deleting records based on webhook events. This involves transforming webhook payloads into installation state objects.
 
 ## Notable Code Patterns
 
-- **Webhook Signature Validation**: Implements a security pattern to validate webhook signatures, ensuring that requests are authentic.
-- **Conditional Logic for Webhook Types**: Uses a switch-case structure to handle different types of webhook events, providing a clear and maintainable approach to event processing.
-- **Error Handling**: Comprehensive error handling is implemented to catch and log exceptions during webhook processing, enhancing reliability.
+1. **Webhook Signature Validation**: The app includes a robust mechanism for validating webhook signatures using environment secrets, ensuring that only legitimate requests are processed.
+
+2. **Service Initialization**: The `startServices` function is used to initialize necessary services before processing webhooks, ensuring that all dependencies are ready for use.
 
-## Development and Deployment
+3. **Error Handling and Logging**: Comprehensive error handling is implemented with detailed logging using Winston, capturing both successful and failed webhook processing attempts.
 
-- **Scripts for Development**: The `package.json` includes scripts for building, cleaning, linting, and deploying the app, as well as for version management using semantic versioning.
-- **Local Development Setup**: Instructions for setting up a local development environment are provided, including commands for running the server, UI, and tunneling services.
+4. **Modular Development with TypeScript Interfaces**: The use of TypeScript interfaces for defining data structures (e.g., `ICalendlyBrowserSdkPluginConfig`, `EnrichSeekaProfileFromCalendlyRequest`) promotes type safety and reusability across the codebase.
 
-This summary provides an overview of the app's architecture, key features, and implementation details, which can be useful for AI systems to understand and reference the app's functionality and design patterns.
+This summary provides a high-level understanding of the Calendly integration app's architecture and implementation, highlighting its use of modern development practices and integration with external services.

package/dist/ai-context/internal/examples/v2/clarity/_ai-summary.md

@@ -1,32 +1,25 @@
-# AI Summary: Clarity App
-
-## Overview
-The Clarity app is designed to integrate Microsoft Clarity for session recording and heatmap analytics. It serves as a browser plugin and server component within the Seeka app ecosystem, facilitating analytics through session recording and heatmaps.
+# AI Summary for Clarity App
 
 ## Purpose and Functionality
-- **Session Recording**: Captures user interactions within the browser for analysis.
-- **Heatmap Analytics**: Provides visual representations of user engagement on web pages.
-- **Webhook Handling**: Manages installation, update, and uninstallation events via webhooks.
+The Clarity app is designed to integrate Microsoft Clarity for session recording and heatmap analytics. It serves as a browser plugin and server component to capture user interactions and visualize them for analytics purposes. This app is particularly useful for understanding user behavior on websites and improving user experience through detailed session data and heatmaps.
 
 ## Key Implementation Patterns
-- **Monorepo Structure**: Utilizes Yarn workspaces to manage both browser and server components.
-- **Azure Functions**: Implements serverless functions for handling HTTP requests and webhooks.
-- **Webhook Validation**: Ensures secure communication by validating webhook signatures.
-- **Logging**: Uses Winston for structured logging and profiling of webhook events.
+- **Monorepo Structure**: The app uses a monorepo managed by Yarn workspaces, allowing for organized management of both browser and server components.
+- **Azure Functions**: The server component is implemented using Azure Functions, providing a scalable and serverless architecture for handling HTTP requests.
+- **Webhook Handling**: The app processes various webhook events related to app installation, updates, and uninstallation. This is crucial for maintaining the app's state and ensuring proper integration with Seeka's platform.
 
 ## External APIs/Services Integrated
-- **Microsoft Clarity**: For session recording and heatmap analytics.
-- **Azure Functions**: Provides the serverless environment for executing webhook handlers.
-- **Seeka SDK**: Utilizes Seeka's server SDK for handling app-specific webhook payloads.
+- **Microsoft Clarity**: The primary integration is with Microsoft Clarity for capturing session data and generating heatmaps.
+- **Azure Functions**: Utilized for server-side logic, enabling the app to handle HTTP requests and process webhooks efficiently.
+- **Seeka SDK**: The app leverages the Seeka SDK for handling webhook payloads and managing app installation states.
 
 ## Important Data Transformations
-- **Webhook Payload Processing**: Parses and processes JSON payloads from incoming webhooks to trigger appropriate actions.
-- **Installation State Management**: Manages installation states through create, update, and delete operations.
+- **Webhook Payload Parsing**: The app parses incoming webhook payloads to extract relevant information for processing installation, update, and uninstallation events.
+- **Installation State Management**: Transforms webhook data into installation state objects, which are used to track the app's current state and permissions granted by users.
 
 ## Notable Code Patterns
-- **Webhook Handler**: A reusable pattern for handling different types of webhook events (`AppInstalled`, `AppInstallSettingsUpdated`, `AppUninstalled`, `BrowserSdkPlugin`).
-- **Signature Validation**: A robust mechanism for ensuring the authenticity of incoming webhook requests.
-- **Service Initialization**: A pattern for starting necessary services before processing webhook events.
+- **Error Handling with Logging**: The app uses the Winston logging library to log detailed information about webhook processing, including errors and performance profiling.
+- **Signature Validation**: Implements a security pattern to validate webhook signatures, ensuring that requests are authentic and have not been tampered with.
+- **Conditional Logic for Webhook Types**: Uses a switch-case structure to handle different types of webhook events, allowing for clear and organized processing logic.
 
-## Conclusion
-The Clarity app effectively integrates Microsoft Clarity's session recording and heatmap analytics into the Seeka ecosystem, leveraging Azure Functions for serverless execution and employing secure, structured webhook handling. Its implementation patterns, such as monorepo management and robust logging, offer reusable solutions for similar analytics integrations.
+This summary provides a high-level overview of the Clarity app's architecture and implementation, highlighting its use of modern development practices and integration with external services for enhanced analytics capabilities.

package/dist/ai-context/internal/examples/v2/google-bigquery/_ai-summary.md

@@ -1,24 +1,25 @@
-# AI Summary for Seeka App: Google BigQuery Integration
+# AI Summary for Google BigQuery Seeka App
 
-## Overview
-The `google-bigquery` app is designed to integrate Seeka activity data with Google BigQuery, enabling advanced analytics and reporting capabilities. It facilitates the export of Seeka activity data to BigQuery, allowing users to leverage BigQuery's powerful data processing and querying features.
+## Purpose and Functionality
+The Google BigQuery Seeka app is designed to integrate with Google BigQuery to export Seeka activity data for advanced analytics and reporting. It processes webhooks from Seeka, validates them, and manages the installation state of the app. The app primarily handles data export tasks to Google BigQuery, ensuring that the necessary datasets and tables exist before pushing data.
 
 ## Key Implementation Patterns
-- **Azure Functions**: The app is structured as an Azure Function, providing a serverless environment to handle HTTP requests and process webhooks.
-- **Webhook Handling**: The app processes various types of Seeka webhooks, such as installation, uninstallation, and activity updates, to manage the integration with BigQuery.
-- **Service Initialization**: The app initializes necessary services upon receiving webhooks to ensure the environment is correctly set up for data processing.
+- **Webhook Handling**: The app listens for HTTP POST requests on the `/webhook/seeka/app` route, processing different types of webhook payloads such as `AppInstalled`, `AppInstallSettingsUpdated`, `AppUninstalled`, and `ActivityAccepted`.
+- **Signature Validation**: Webhook requests are validated using a signature to ensure authenticity, with an option to disable this validation for testing purposes.
+- **State Management**: The app manages installation states using functions like `createOrUpdateInstallation`, `deleteInstallation`, and `tryGetInstallation`.
+- **Service Initialization**: Services are started using `startServices` to prepare the app for processing webhook calls.
 
 ## External APIs/Services Integrated
-- **Google BigQuery**: The app directly interacts with Google BigQuery to check dataset and table existence and to push data for analytics.
-- **Azure Functions**: Utilized for hosting the serverless function that handles incoming HTTP requests and processes them accordingly.
+- **Google BigQuery**: The app integrates with Google BigQuery to check for the existence of datasets and tables and to export data.
+- **Azure Functions**: The app is built using Azure Functions, enabling serverless execution of the webhook handler.
 
 ## Important Data Transformations
-- **Webhook Payload Processing**: The app parses and validates incoming webhook payloads, ensuring data integrity and security through signature validation.
-- **Data Sanitization**: Before pushing data to BigQuery, the app sanitizes records to match the expected schema, ensuring compatibility and preventing errors.
+- **Payload Sanitization**: The app sanitizes BigQuery records using `sanitiseBigQueryRecord` to ensure data integrity before export.
+- **Activity Payload Processing**: Specific fields in activity payloads are transformed using functions like `activityPayloadFieldsToJsonStringify` and `activityPayloadFieldsToRemove` to prepare them for BigQuery.
 
 ## Notable Code Patterns
-- **Modular Service Design**: The app uses a modular design, separating concerns into different modules for logging, state management, and BigQuery interactions.
-- **Error Handling and Logging**: Utilizes the `winston` library for structured logging, providing detailed insights into the app's operations and facilitating debugging.
-- **Version Management**: The app leverages Yarn workspaces and scripts for version management, ensuring consistent updates across all components.
+- **Logging with Winston**: The app uses the Winston library for structured logging, providing detailed logs for webhook processing and error handling.
+- **Environment Variable Usage**: The app relies on environment variables for configuration, such as `SEEKA_APP_SECRET` for signature validation.
+- **Yarn Workspaces**: The project uses Yarn workspaces to manage dependencies and scripts across multiple packages, facilitating organized development and deployment processes.
 
-This summary provides a high-level understanding of the Seeka app's purpose, structure, and integration points, aiding AI systems in referencing and interacting with the app effectively.
+This summary provides an overview of the app's purpose, key patterns, integrations, and notable code practices, offering a reference for AI assistants to understand and interact with the app's implementation.

package/dist/ai-context/internal/examples/v2/klaviyo-events/_ai-summary.md

@@ -1,26 +1,35 @@
 # AI Summary for Klaviyo Events App
 
-## Purpose and Functionality
-The **Klaviyo Events App** is designed to integrate with Klaviyo for pushing activity events to facilitate email marketing automation. It acts as a bridge between Seeka apps and Klaviyo, enabling the automation of marketing tasks based on user activities captured by Seeka.
+## Overview
+
+The **Klaviyo Events App** is designed to integrate with Klaviyo for pushing activity events to facilitate email marketing automation. It leverages Azure Functions to handle webhooks from Seeka, processing various types of events related to app installation and user activities, and subsequently interacts with Klaviyo for marketing automation.
 
 ## Key Implementation Patterns
-- **Azure Functions**: The app is structured as an Azure Function, which provides a serverless environment to handle HTTP requests, specifically webhooks from Seeka.
-- **Webhook Handling**: The app listens for various types of webhook events from Seeka, such as app installations, updates, and activity acceptance, and processes them accordingly.
-- **Logging**: Uses the `winston` library for logging, providing detailed logs for each webhook event processed.
-- **Background Jobs**: Implements a queuing system to handle certain tasks asynchronously, such as processing accepted activities.
+
+1. **Azure Functions**: The app utilizes Azure Functions to handle HTTP requests, specifically webhooks from Seeka. It defines a function `seekaAppWebhook` to process incoming webhook requests.
+
+2. **Webhook Handling**: The app processes different types of webhook payloads, including installation, uninstallation, and activity events. It validates webhook signatures to ensure authenticity.
+
+3. **Asynchronous Job Processing**: The app triggers background jobs for processing certain activities using a queue system, ensuring that activity handling does not block the main execution flow.
+
+4. **Logging**: The app employs the `winston` library for logging, providing detailed logs for debugging and monitoring purposes.
 
 ## External APIs/Services Integrated
-- **Klaviyo**: The app integrates with Klaviyo to push events for email marketing automation.
-- **Azure Functions**: Utilizes Azure's serverless computing to handle HTTP requests and execute code in response to webhook events.
+
+- **Klaviyo**: The app integrates with Klaviyo to push activity events for email marketing automation.
+- **Azure Functions**: Used for serverless execution of webhook handling logic.
+- **Seeka SDK**: Utilized for handling Seeka-specific webhook payloads and operations.
 
 ## Important Data Transformations
-- **Webhook Payload Processing**: The app parses and validates incoming webhook payloads, ensuring they are correctly formatted and signed before processing.
-- **Installation State Management**: Manages the state of app installations, updating or deleting records based on webhook events.
+
+- **Webhook Payload Parsing**: The app parses JSON payloads from incoming HTTP requests to extract relevant event data.
+- **Installation State Management**: It manages the state of app installations, updating or deleting records based on webhook events.
+- **Activity Filtering**: Filters activities to determine which should be processed further, specifically excluding certain activity types like `ViewPage`.
 
 ## Notable Code Patterns
-- **Webhook Signature Validation**: Implements a security measure to validate the signature of incoming webhooks, ensuring that only legitimate requests are processed.
-- **Error Handling**: Utilizes try-catch blocks to handle errors gracefully, logging detailed error information and returning appropriate HTTP status codes.
-- **Modular Services**: Uses a modular approach to start services and manage installations, allowing for easy maintenance and scalability.
-- **Conditional Processing**: Differentiates between test and production webhook calls, ensuring that test data does not affect live operations.
 
-This summary provides an overview of the app's purpose, key patterns, integrations, and notable code practices, offering a comprehensive understanding for AI systems analyzing or interacting with the app.
+- **Signature Validation**: Implements a robust mechanism to validate webhook signatures, ensuring that only legitimate requests are processed.
+- **Background Job Triggering**: Uses a pattern to offload intensive tasks to background processing, improving response times and reliability.
+- **Modular Logging**: Utilizes a structured logging approach with `winston`, allowing for detailed and context-aware logging.
+
+This summary provides a high-level understanding of the Klaviyo Events App's architecture and implementation, highlighting its integration with external services, key patterns, and data handling strategies.

package/dist/ai-context/internal/examples/v2/navitas/_ai-summary.md

@@ -1,39 +1,27 @@
+```markdown
 # AI Summary for Navitas App
 
-## Overview
-
-The Navitas app is designed to integrate with the Navitas education group, focusing on tracking student inquiries and conversions. It serves as a bridge between educational lead tracking and CRM systems, providing a seamless way to manage student data and interactions. The app includes both browser and server components, leveraging Azure Functions for server-side operations.
+## Purpose and Functionality
+The Navitas app integrates with the Navitas education group to track student inquiries and conversions. It acts as a bridge between Navitas and CRM systems like Salesforce, facilitating lead tracking and management. The app is designed to handle webhooks for various events such as app installation, settings updates, and uninstallation, ensuring seamless integration and data flow between systems.
 
 ## Key Implementation Patterns
-
-1. **Monorepo Structure**: The app uses a monorepo setup with Yarn workspaces, organizing code into separate packages for the browser and server components, as well as a shared library for Google BigQuery interactions.
-
-2. **Webhook Handling**: The app extensively uses webhooks to manage events such as app installation, settings updates, and uninstallation. The webhook handler validates incoming requests, processes them based on their type, and logs the operations for auditing and debugging.
-
-3. **Continuous Delivery**: The app employs continuous delivery pipelines to automatically maintain certain BigQuery functions, views, and tables, ensuring that the data infrastructure remains consistent and up-to-date.
+- **Monorepo Structure**: The app uses a monorepo setup managed by Yarn workspaces, organizing code into `app` and `lib` directories for modular development.
+- **Azure Functions**: The server component is implemented as an Azure Function, providing a scalable and event-driven architecture for handling HTTP requests.
+- **Webhook Handling**: The app processes incoming webhooks from Seeka, validating signatures and managing installations based on event types.
+- **Logging**: Utilizes Winston for structured logging, enhancing traceability and debugging capabilities.
 
 ## External APIs/Services Integrated
-
-1. **Azure Functions**: The server component is built using Azure Functions, providing a scalable and efficient way to handle HTTP requests and background tasks.
-
-2. **Salesforce**: The app integrates with Salesforce via outbound messages, requiring specific headers and XML content types for communication.
-
-3. **Google BigQuery**: The app interacts with BigQuery for data storage and analysis, with specific instructions to avoid modifying certain auto-managed resources.
+- **Salesforce**: The app integrates with Salesforce via outbound messages, using specific endpoints for different environments (ACAP and SAE).
+- **Google BigQuery**: Although not directly modified by the app, it interfaces with BigQuery for data management, with specific tables and functions maintained by Seeka's continuous delivery pipelines.
 
 ## Important Data Transformations
-
-- **Webhook Payload Processing**: Incoming webhook payloads are parsed and validated to ensure authenticity and integrity. The app processes different types of webhook calls, transforming them into actions such as creating or updating installations, or handling browser SDK plugin requests.
-
-- **Installation State Management**: The app manages installation states by creating or updating records with details such as granted permissions, installation IDs, and organizational information.
+- **Webhook Payload Processing**: The app parses and validates JSON payloads from webhooks, transforming them into actionable data for installation management.
+- **Installation State Management**: It updates or creates installation records based on webhook events, maintaining state consistency across different app installations.
 
 ## Notable Code Patterns
+- **Signature Validation**: Implements a robust mechanism to validate webhook signatures, ensuring secure communication between systems.
+- **Service Initialization**: Uses a `startServices` function to initialize necessary services before processing webhook events.
+- **Error Handling**: Comprehensive error handling and logging are in place to manage exceptions and provide detailed error information for troubleshooting.
 
-1. **Logger Utilization**: The app uses the `winston` library for logging, providing detailed insights into webhook handling and error management. This pattern can be reused for robust logging in other applications.
-
-2. **Environment Variable Usage**: Secure handling of sensitive information, such as webhook secrets, is achieved through environment variables, ensuring that these details are not hardcoded into the source code.
-
-3. **Error Handling and Profiling**: The app includes comprehensive error handling and profiling for webhook requests, allowing for efficient debugging and performance monitoring.
-
-4. **Version Management**: The app includes scripts for managing version bumps (patch, minor, major) across all workspaces, ensuring consistent versioning and deployment practices.
-
-This summary provides a high-level understanding of the Navitas app's architecture, integrations, and key implementation details, which can be referenced for developing similar applications or enhancing existing ones.
+This summary provides an overview of the Navitas app's architecture and functionality, highlighting its integration with external systems and the implementation patterns that ensure robust and scalable operations.
+```

package/dist/ai-context/internal/examples/v2/trustarc/_ai-summary.md

@@ -2,35 +2,33 @@
 
 ## Overview
 
-**App Name:** TrustArc  
-**Template Version:** V2  
-**Template:** azurefunc  
-**Components:** browser, server  
-**Description:** The TrustArc app is designed for integrating consent management functionalities to ensure privacy compliance and consent tracking. It is particularly relevant for organizations needing to adhere to privacy regulations such as GDPR. The app functions as a browser plugin and includes server-side components to manage and track user consent.
+The **TrustArc** app is designed to integrate consent management functionalities into applications, ensuring privacy compliance and consent tracking. It is particularly focused on adhering to regulations such as GDPR. The app is structured as a browser plugin and a server component, leveraging Azure Functions to handle server-side operations.
 
 ## Purpose and Functionality
 
-The TrustArc app provides a comprehensive solution for managing user consent in compliance with privacy regulations. It integrates with TrustArc's consent management platform to track and manage user consent efficiently. The app is structured to operate both in the browser and on the server, ensuring a seamless experience across different platforms.
+- **Consent Management**: The app provides tools to manage user consent, crucial for compliance with privacy laws like GDPR.
+- **Privacy Compliance**: It helps applications adhere to privacy regulations by integrating TrustArc's consent management solutions.
+- **Tracking**: The app tracks user consent status and updates, ensuring that applications remain compliant over time.
 
 ## Key Implementation Patterns
 
-- **Monorepo Structure:** The app uses a monorepo structure managed by Yarn workspaces, allowing for organized development and deployment of both browser and server components.
-- **Azure Functions:** The server component is implemented as an Azure Function, leveraging serverless architecture for scalability and efficient resource management.
-- **Development Workflow:** The app includes scripts for cleaning, linting, building, and deploying, ensuring a streamlined development process. The use of `yarn workspaces` commands facilitates operations across all components.
+- **Monorepo Structure**: The app uses a monorepo setup with Yarn workspaces, managing both the browser and server components under a single repository.
+- **Azure Functions**: The server-side logic is implemented as an Azure Function, which allows for scalable and event-driven execution.
+- **Development Scripts**: The app uses a series of Yarn scripts to automate tasks such as cleaning, building, and deploying the application.
 
 ## External APIs/Services Integrated
 
-- **TrustArc API:** The app integrates with TrustArc's consent management platform to handle privacy compliance and consent tracking.
-- **Azure Functions Core Tools:** Utilized for local development and testing of Azure Functions, enabling developers to simulate the Azure environment on their local machines.
+- **Azure Functions**: Utilized for server-side processing, providing a serverless architecture that scales with demand.
+- **TrustArc API**: Although not explicitly mentioned in the code snippet, the app likely integrates with TrustArc's API for consent management functionalities.
 
 ## Important Data Transformations
 
-The app likely includes data transformations related to user consent data, ensuring that it is formatted and stored in compliance with privacy regulations. These transformations would typically involve normalizing consent data and securely transmitting it between the browser and server components.
+- **Consent Data Handling**: The app likely transforms and manages consent data to ensure it is stored and retrieved in compliance with privacy regulations. This includes tracking consent status and changes over time.
 
 ## Notable Code Patterns
 
-- **Workspace Commands:** The use of `yarn workspaces foreach` allows for executing commands across multiple packages, promoting efficient management of the monorepo.
-- **Environment-Specific Builds:** Separate build scripts for development and production environments ensure that the app is optimized for different stages of deployment.
-- **Serverless Deployment:** The deployment script for Azure Functions highlights a pattern for deploying serverless applications, which can be reused for similar projects requiring scalable backend solutions.
+- **Workspace Automation**: The use of Yarn workspaces and scripts for automating tasks across multiple components is a reusable pattern for managing complex applications.
+- **Serverless Architecture**: Implementing server-side logic as Azure Functions is a pattern that can be reused for other applications requiring scalable, event-driven processing.
+- **Dependency Management**: The app includes a script for updating dependencies across all workspaces, ensuring that the application remains up-to-date with the latest library versions.
 
-This summary provides an AI assistant with a comprehensive understanding of the TrustArc app's architecture, implementation patterns, and integration points, facilitating better support and enhancements.
+This summary provides an overview of the TrustArc app's purpose, implementation, and key features, aiding AI systems in understanding and referencing its design and functionality.

package/dist/ai-context/internal/examples/v2/typeform/_ai-summary.md

@@ -1,31 +1,32 @@
-```markdown
 # AI Summary for Seeka Typeform App
 
+## Overview
+The Seeka Typeform app is designed to integrate with Typeform to track form submissions and survey responses. It leverages webhooks to capture and process data from Typeform, facilitating lead capture and survey analytics.
+
 ## Purpose and Functionality
-The Seeka Typeform app is designed to integrate with Typeform for tracking form submissions and survey responses. It leverages webhooks to capture lead data and survey responses, facilitating real-time data processing and integration with other systems.
+- **Integration with Typeform**: The app connects with Typeform to monitor form submissions and survey responses.
+- **Webhook Handling**: It processes various webhook events such as app installation, uninstallation, and activity acceptance.
+- **Lead Capture**: Captures data from Typeform submissions for further processing and analysis.
 
 ## Key Implementation Patterns
-- **Monorepo Structure**: The app uses a monorepo setup managed by Yarn workspaces, allowing for organized development across multiple components (`browser`, `ui`, `server`).
-- **Azure Functions**: The server-side logic is implemented using Azure Functions, providing a scalable and efficient way to handle HTTP requests and webhook events.
-- **Webhook Handling**: The app processes various webhook events such as `AppInstalled`, `AppUninstalled`, and `ActivityAccepted`, ensuring that the app's state is updated accordingly.
+- **Monorepo Structure**: Utilizes Yarn workspaces to manage multiple components (`browser`, `ui`, `server`) within a single repository.
+- **Azure Functions**: The server-side logic is implemented using Azure Functions, allowing for scalable and event-driven execution.
+- **Webhook Validation**: Implements security by validating webhook signatures to ensure authenticity.
+- **Service Initialization**: Services are started asynchronously to handle incoming webhook requests efficiently.
 
 ## External APIs/Services Integrated
-- **Typeform**: The app integrates with Typeform to receive form submissions and survey responses.
-- **Seeka SDK**: Utilizes the `@seeka-labs/sdk-apps-server` for handling Seeka-specific webhook payloads and validation.
+- **Typeform**: The app integrates with Typeform to receive data from form submissions.
+- **Azure Functions**: Used for deploying server-side logic and handling HTTP requests.
+- **Seeka SDK**: Utilizes Seeka's SDK for handling webhook payloads and managing app installations.
 
 ## Important Data Transformations
-- **Webhook Payload Parsing**: Incoming webhook payloads are parsed and validated to ensure they are from trusted sources, using signature validation.
-- **Installation State Management**: The app maintains the state of installations, updating or deleting records based on webhook events.
+- **Webhook Payload Parsing**: Converts incoming webhook payloads into structured data for processing.
+- **Installation State Management**: Manages the state of app installations, ensuring that only known installations are processed.
 
 ## Notable Code Patterns
-- **Logging**: Uses Winston for structured logging, providing detailed insights into webhook processing and app state changes.
-- **Service Initialization**: The `startServices` function is invoked to initialize necessary services before processing webhook events.
-- **Error Handling**: Implements robust error handling and logging to manage invalid webhook signatures and unknown installation IDs.
-
-## Reusable Code Patterns
-- **Webhook Signature Validation**: The `throwOnInvalidWebhookSignature` function provides a reusable pattern for validating webhook signatures across different applications.
-- **State Management**: Functions like `createOrUpdateInstallation` and `deleteInstallation` offer a template for managing application state in response to external events.
-- **Logging**: The use of `childLogger` and `webhookLogger` demonstrates a reusable pattern for context-specific logging.
+- **Logging with Winston**: Uses the Winston library for structured logging, providing detailed logs for debugging and monitoring.
+- **Environment-Based Configuration**: Uses environment variables for configuration, allowing for flexible deployment across different environments.
+- **Error Handling**: Implements robust error handling to manage invalid webhook signatures and unknown installations gracefully.
+- **Version Management**: Provides scripts for version bumping and deployment, ensuring consistent versioning across all components.
 
-This summary provides an overview of the Seeka Typeform app's architecture and implementation, highlighting its integration with Typeform and the use of Azure Functions for server-side processing. The app's design patterns and external integrations make it a robust solution for managing form submissions and survey responses.
-```
+This summary provides a high-level understanding of the Seeka Typeform app's architecture and functionality, facilitating AI assistants in referencing and interacting with its implementation.

package/dist/ai-context/internal/examples/v2/webhook/_ai-summary.md

@@ -1,26 +1,28 @@
+```markdown
 # AI Summary for Seeka Webhook App
 
 ## Purpose and Functionality
-The Seeka Webhook app is designed to send Seeka activity data to custom webhook endpoints. It facilitates the integration of Seeka's platform with external systems by exporting data through webhooks. The app supports various webhook call types, including app installation, settings updates, and uninstallation.
+The Seeka Webhook app is designed to send Seeka activity data to custom webhook endpoints. It facilitates integration with external systems by exporting data through webhooks, allowing for real-time data synchronization and event-driven architectures.
 
 ## Key Implementation Patterns
-- **Azure Functions**: The app is implemented using Azure Functions, which handle HTTP requests for webhook events.
-- **Modular Architecture**: The app is divided into `ui` and `server` components, managed using Yarn workspaces for efficient dependency management and build processes.
-- **Logging**: Utilizes Winston for structured logging, providing detailed logs for debugging and monitoring webhook processing.
-- **Error Handling**: Implements robust error handling with try-catch blocks to manage exceptions during webhook processing.
+- **Azure Functions**: The app is built using Azure Functions, providing a scalable and serverless environment for handling HTTP requests.
+- **Modular Code Structure**: The app is organized into `ui` and `server` components, with a clear separation of concerns.
+- **Workspace Management**: Utilizes Yarn workspaces for managing dependencies and scripts across multiple packages within the project.
 
 ## External APIs/Services Integrated
-- **Azure Functions**: The app is hosted on Azure Functions, leveraging its serverless capabilities for scalability and ease of deployment.
-- **Seeka SDK**: Integrates with the `@seeka-labs/sdk-apps-server` to handle Seeka-specific webhook payloads and validate webhook signatures.
+- **Azure Functions**: The app leverages Azure's serverless computing service to handle HTTP requests and process webhook events.
+- **Seeka SDK**: Integrates with the `@seeka-labs/sdk-apps-server` to handle specific webhook payloads and validate signatures.
 
 ## Important Data Transformations
-- **Webhook Payload Parsing**: The app parses incoming webhook payloads from JSON strings into structured objects for processing.
-- **Installation Management**: Transforms installation-related data into a consistent format for storage and retrieval, including handling installation state and settings updates.
+- **Webhook Payload Processing**: The app processes incoming webhook payloads, validating signatures and parsing JSON data to ensure integrity and security.
+- **Installation Management**: Handles the creation, update, and deletion of installation states based on webhook events like `AppInstalled`, `AppInstallSettingsUpdated`, and `AppUninstalled`.
 
 ## Notable Code Patterns
-- **Webhook Signature Validation**: Ensures security by validating webhook signatures using a secret key, preventing unauthorized requests.
-- **Service Initialization**: Uses a `startServices` function to initialize necessary services before processing webhooks, ensuring all dependencies are ready.
-- **Conditional Processing**: Handles different webhook call types using a switch-case pattern, allowing for specific logic execution based on the event type.
-- **Profile Logging**: Utilizes logger profiling to measure execution time for specific operations, aiding in performance monitoring and optimization.
+- **Logging with Winston**: Implements structured logging using the Winston library, providing detailed logs for debugging and monitoring.
+- **Error Handling**: Includes robust error handling mechanisms to manage invalid webhook signatures and unknown installation IDs.
+- **Environment Configuration**: Utilizes environment variables for sensitive data like `SEEKA_APP_SECRET`, ensuring secure configuration management.
+- **Version Management**: Automates version bumping and git tagging through custom scripts, streamlining the release process.
+- **Service Initialization**: Uses a `startServices` function to initialize necessary services before processing webhook events.
 
-This summary provides an overview of the Seeka Webhook app's architecture, key functionalities, and implementation details, facilitating AI understanding and reference for further development or integration tasks.
+This app serves as a template for building scalable and maintainable webhook integrations, leveraging serverless architecture and modern development practices.
+```