@seeka-labs/cli-apps 3.8.6 → 3.8.7

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

@@ -1,56 +1,28 @@
 # AI Summary for Seeka App: Transcend
 
-## 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  
+## Purpose and Functionality
+The "Transcend" app is a Seeka application designed to integrate with the Transcend data privacy platform. Its primary purpose is to manage consent and data rights, ensuring compliance with privacy regulations. It handles webhooks from Seeka, processes data, and interacts with Azure services to manage installations and state.
 
 ## Key Implementation Patterns
-
-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.
+- **Azure Functions**: The app is built using Azure Functions, which allows it to handle HTTP requests, manage queues, and perform scheduled tasks.
+- **Webhook Handling**: The app processes various types of webhooks from Seeka, including installation, settings updates, and activity notifications.
+- **State Management**: Uses Redis for storing the state of app installations and other necessary data.
+- **Logging**: Utilizes Winston for centralized logging, with optional Seq integration for log management.
 
 ## External APIs/Services Integrated
-
-- **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.
+- **Transcend Platform**: Integrates with Transcend for consent and data rights management.
+- **Azure Services**: Uses Azure Storage Queues for managing asynchronous tasks and Azure Functions for serverless execution.
+- **Redis**: Employed for state management, with optional Upstash integration for cloud-based Redis services.
+- **Ngrok**: Used for exposing local development environments to the internet for testing purposes.
 
 ## Important Data Transformations
-
-- **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.
+- **Webhook Payload Processing**: The app parses and validates webhook payloads, ensuring they are correctly formatted and signed before processing.
+- **State Updates**: Transforms webhook data into state updates for installations, managing lifecycle events like installation, updates, and uninstallation.
 
 ## Notable Code Patterns
+- **Function Composition**: The app uses a modular approach, with distinct functions for handling different webhook types, making it easy to extend and maintain.
+- **Error Handling**: Implements robust error handling and logging to ensure any issues are captured and can be diagnosed.
+- **Environment Configuration**: Utilizes environment variables for configuration, supporting both local development and production deployments.
+- **Queue Management**: Demonstrates how to offload long-running tasks to Azure Storage Queues, ensuring compliance with Azure Function execution time limits.
 
-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
-
-- **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 a comprehensive overview of the Transcend app's architecture and implementation, highlighting key patterns and integrations that can be leveraged in similar projects.
+This summary provides a comprehensive overview of the app's architecture and functionality, highlighting its integration with external services and key implementation patterns.

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

@@ -1,38 +1,39 @@
-# AI Summary for Calendly Integration App
+# AI Summary for Seeka Calendly Integration App
 
 ## Overview
 
-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.
+The Seeka Calendly Integration App is designed to facilitate the tracking of meeting bookings and scheduling events through integration with Calendly. It leverages webhooks to interact with Calendly and manage event data, making it a useful tool for CRM and scheduling purposes.
 
 ## Key Implementation Patterns
 
-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.
+1. **Monorepo Structure**: The app uses a monorepo setup with Yarn workspaces to manage multiple components (`browser`, `ui`, `server`) under a single repository. This structure allows for efficient dependency management and modular development.
 
-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.
+2. **Azure Functions**: The server component is built on Azure Functions, enabling serverless execution of code in response to HTTP requests (webhooks).
 
-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.
+3. **Webhooks**: The app extensively uses webhooks to receive and handle events from Calendly. This includes installation, uninstallation, and updates to app settings.
 
-4. **Logging with Winston**: The app employs the Winston logging library to maintain detailed logs of webhook processing, aiding in debugging and monitoring.
+4. **Logging**: The app uses the `winston` library for structured logging, which is crucial for debugging and monitoring the webhook interactions.
 
 ## External APIs/Services Integrated
 
-- **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.
+- **Calendly API**: The app integrates with Calendly to track and manage meeting bookings and scheduling events.
+- **Azure Functions**: Utilized for serverless execution, allowing the app to handle HTTP requests efficiently.
 
 ## Important Data Transformations
 
-- **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.
+- **Webhook Payload Handling**: The app processes incoming webhook payloads to extract relevant data such as installation IDs and event details. This data is then used to update installation states or trigger other actions.
+- **Signature Validation**: Incoming webhook requests are validated using a signature to ensure authenticity and security.
 
 ## Notable Code Patterns
 
-1. **Webhook Signature Validation**: The app includes a robust mechanism for validating webhook signatures using environment secrets, ensuring that only legitimate requests are processed.
+1. **Webhook Signature Validation**: The app includes a robust mechanism to validate webhook signatures, 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.
+2. **Installation Management**: The app maintains a state of installations, allowing it to handle installation, update, and uninstallation events effectively.
 
-3. **Error Handling and Logging**: Comprehensive error handling is implemented with detailed logging using Winston, capturing both successful and failed webhook processing attempts.
+3. **Service Initialization**: The `startServices` function is used to initialize necessary services before processing webhook requests, ensuring that all dependencies are ready for use.
 
-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.
+4. **Error Handling**: The app includes comprehensive error handling to manage exceptions and provide meaningful responses in case of failures.
 
-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.
+5. **Version Management**: The app uses Yarn scripts to automate version bumping and deployment processes, ensuring consistent version control across all components.
+
+This summary provides a high-level understanding of the Seeka Calendly Integration App's architecture and functionality, highlighting key patterns and integrations that could be useful for similar applications.

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

@@ -1,25 +1,36 @@
+```markdown
 # AI Summary for Clarity App
 
+## Overview
+The Clarity app is designed to integrate Microsoft Clarity for session recording and heatmap analytics. It functions as both a browser plugin and a server component, leveraging Azure Functions to handle webhooks for app installation, updates, and uninstallation events.
+
 ## Purpose and Functionality
-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.
+- **Session Recording and Heatmap Analytics**: Integrates Microsoft Clarity to provide insights into user interactions through session recordings and heatmaps.
+- **Webhook Handling**: Manages various webhook events related to app installation, updates, and uninstallation using Azure Functions.
 
 ## Key Implementation Patterns
-- **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.
+- **Monorepo Structure**: Utilizes Yarn workspaces to manage multiple packages (`browser` and `server`) within a single repository.
+- **Azure Functions**: Employs Azure Functions for serverless execution of webhook event handlers.
+- **Logging**: Implements detailed logging using the `winston` library to track webhook processing and errors.
 
 ## External APIs/Services Integrated
-- **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.
+- **Microsoft Clarity**: For session recording and heatmap analytics.
+- **Azure Functions**: Used for handling HTTP requests and executing server-side logic.
+- **Seeka SDK**: Utilizes `@seeka-labs/sdk-apps-server` for webhook payload types and signature validation.
 
 ## Important Data Transformations
-- **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.
+- **Webhook Payload Parsing**: Parses and validates JSON webhook payloads to ensure they are correctly processed.
+- **Installation State Management**: Transforms and manages installation states through functions like `createOrUpdateInstallation` and `deleteInstallation`.
 
 ## Notable Code Patterns
-- **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.
+- **Webhook Signature Validation**: Uses `throwOnInvalidWebhookSignature` to ensure webhook calls are legitimate.
+- **Conditional Logic for Webhook Types**: Implements a switch-case structure to handle different webhook call types (`AppInstalled`, `AppInstallSettingsUpdated`, `AppUninstalled`, `BrowserSdkPlugin`).
+- **Error Handling and Logging**: Comprehensive error handling with logging to capture and report issues during webhook processing.
+
+## Reusable Code Patterns
+- **Webhook Handler Template**: The `seekaAppWebhook` function can be adapted for handling various webhook events in other applications.
+- **Installation Management Utilities**: Functions like `createOrUpdateInstallation` and `deleteInstallation` provide a reusable pattern for managing app installations.
+- **Logging Setup with Winston**: The logging setup using `winston` is a robust pattern for any application requiring detailed logging and error tracking.
 
-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.
+This summary provides a high-level understanding of the Clarity app's architecture and implementation, focusing on its integration with Microsoft Clarity, use of Azure Functions, and robust handling of webhook events.
+```

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

@@ -1,25 +1,37 @@
-# AI Summary for Google BigQuery Seeka App
+```markdown
+# AI-Focused Summary for Google BigQuery Seeka App
+
+## Overview
+The `google-bigquery` Seeka app is designed to integrate with Google BigQuery, enabling the export of Seeka activity data for advanced analytics and reporting. This app is built using the Azure Functions framework, leveraging serverless architecture to handle webhook events from Seeka.
 
 ## 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.
+- **Data Export**: Facilitates the transfer of Seeka activity data to Google BigQuery.
+- **Analytics and Reporting**: Provides a foundation for advanced data analysis by integrating with BigQuery.
+- **Webhook Handling**: Processes various Seeka webhook events such as app installation, uninstallation, and activity acceptance.
 
 ## Key Implementation Patterns
-- **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.
+- **Azure Functions**: Utilizes Azure Functions for serverless execution of webhook handlers.
+- **Modular Code Structure**: Organized into multiple modules for handling different webhook events and BigQuery interactions.
+- **Logging**: Employs `winston` for structured logging and profiling of webhook requests.
 
 ## External APIs/Services Integrated
-- **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.
+- **Google BigQuery**: The app interacts with BigQuery to check dataset and table existence and to push data.
+- **Azure Functions**: Used for deploying and running serverless functions that handle incoming webhooks.
 
 ## Important Data Transformations
-- **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.
+- **Webhook Payload Processing**: Parses and validates incoming webhook payloads to ensure integrity and security.
+- **Data Sanitization**: Utilizes functions like `sanitiseBigQueryRecord` to prepare data for BigQuery ingestion.
+- **Activity Data Transformation**: Converts activity payload fields to JSON strings and removes unnecessary fields before exporting.
 
 ## Notable Code Patterns
-- **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.
+- **Webhook Signature Validation**: Implements a security check to validate webhook signatures using a secret key.
+- **Service Initialization**: Uses `startServices` to initialize necessary services before processing webhook events.
+- **Installation State Management**: Manages app installation states through functions like `createOrUpdateInstallation` and `deleteInstallation`.
+
+## Reusable Code Patterns
+- **Webhook Handling Framework**: The pattern for handling different types of webhooks can be adapted for other integrations.
+- **Logging and Profiling**: The use of `winston` for logging can be reused in other serverless applications for better monitoring.
+- **Data Transformation Utilities**: Functions for sanitizing and transforming data for BigQuery can be reused in other data export scenarios.
 
-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.
+This app is a robust solution for integrating Seeka with Google BigQuery, providing a scalable and secure method for exporting data for analytics purposes.
+```

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

@@ -1,35 +1,28 @@
 # AI Summary for Klaviyo Events App
 
-## 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.
+## Purpose and Functionality
+The **Klaviyo Events App** is designed to integrate with Klaviyo for pushing activity events, facilitating email marketing automation. It handles webhook events from Seeka, processes them, and interacts with Klaviyo to automate marketing activities based on user interactions.
 
 ## Key Implementation Patterns
-
-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.
+- **Azure Functions**: The app uses Azure Functions to handle HTTP requests, specifically webhooks from Seeka.
+- **Webhook Handling**: It processes different types of webhook events such as installation, uninstallation, and activity acceptance.
+- **Logging**: Utilizes `winston` for structured logging, including profiling and verbosity levels for debugging and monitoring.
+- **Background Jobs**: Implements a background job system to handle asynchronous processing of activities using a queue system.
 
 ## External APIs/Services Integrated
-
-- **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.
+- **Klaviyo**: Although not explicitly shown in the code snippet, the app's primary purpose is to push events to Klaviyo for marketing automation.
+- **Azure Functions**: Used for deploying serverless functions to handle HTTP requests.
+- **Seeka SDK**: The app uses `@seeka-labs/sdk-apps-server` for handling Seeka-specific webhook payloads and operations.
 
 ## Important Data Transformations
-
-- **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`.
+- **Webhook Payload Parsing**: The app parses JSON payloads from HTTP requests to handle different webhook types.
+- **Installation State Management**: It manages the state of app installations, including creating, updating, and deleting installation records.
+- **Activity Processing**: Filters and processes activity events, excluding certain types (e.g., `ViewPage`), and queues them for background processing.
 
 ## Notable Code Patterns
+- **Signature Validation**: Implements a security pattern by validating webhook signatures to ensure authenticity.
+- **Error Handling**: Uses try-catch blocks to handle exceptions and return appropriate HTTP status codes.
+- **Modular Service Initialization**: The `startServices` function initializes necessary services before processing webhooks, promoting modularity and separation of concerns.
+- **Conditional Logic for Webhook Types**: Uses a switch-case structure to handle different webhook types, making the code extensible for future webhook types.
 
-- **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.
+This summary provides an overview of the app's architecture, its integration with external services, and the patterns used in its implementation, which can be referenced for understanding or extending the app's functionality.

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

@@ -1,27 +1,41 @@
-```markdown
 # AI Summary for Navitas App
 
 ## 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.
+
+The Navitas app is designed to integrate with the Navitas education group for tracking student inquiries and conversions. It functions as a CRM tool and browser plugin, facilitating the management of educational leads and conversion tracking. The app is structured to handle webhooks from Seeka, process them, and perform actions like installation, settings updates, and uninstallation of the app.
 
 ## Key Implementation Patterns
-- **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.
+
+1. **Monorepo Structure**: The app uses a monorepo setup with Yarn workspaces, organizing the code into `app` and `lib` directories for modular development.
+
+2. **Webhook Handling**: The app is built on Azure Functions, specifically handling HTTP POST requests for various webhook events such as app installation, settings updates, and uninstallation.
+
+3. **Logging**: Utilizes the `winston` library for structured logging, providing detailed logs for webhook processing and error handling.
+
+4. **Continuous Integration**: The app includes scripts for building, cleaning, linting, and deploying, ensuring a streamlined development workflow.
 
 ## External APIs/Services Integrated
-- **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.
+
+1. **Azure Functions**: The app is deployed as an Azure Function, handling HTTP requests for webhook events.
+
+2. **Salesforce**: The app integrates with Salesforce, receiving outbound messages via POST requests with XML content type.
+
+3. **Google BigQuery**: The app interacts with BigQuery for data storage and retrieval, with specific functions and tables maintained by Seeka's continuous delivery pipelines.
 
 ## Important Data Transformations
-- **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.
+
+- **Webhook Payload Processing**: The app processes incoming webhook payloads, validating signatures, and parsing JSON data to determine the type of event and execute corresponding actions.
+
+- **Installation State Management**: The app manages installation states, creating or updating records in response to installation and settings update events.
 
 ## 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.
 
-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.
-```
+1. **Signature Validation**: The app includes a robust mechanism for validating webhook signatures to ensure the authenticity of incoming requests.
+
+2. **Error Handling**: Comprehensive error handling is implemented, with detailed logging of exceptions and graceful degradation in case of failures.
+
+3. **Environment Configuration**: The app uses environment variables for configuration, such as `SEEKA_APP_SECRET` for signature validation, promoting secure and flexible deployments.
+
+4. **Modular Service Initialization**: The `startServices` function initializes necessary services, ensuring that dependencies are ready before processing webhooks.
+
+This summary provides an overview of the Navitas app's architecture and functionality, highlighting its integration with external services and key implementation patterns.

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

@@ -2,33 +2,37 @@
 
 ## Overview
 
-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.
+**App Name**: TrustArc  
+**Template Version**: V2  
+**Template**: azurefunc  
+**Components**: browser, server  
+**Description**: The TrustArc app is designed to integrate consent management functionalities for privacy compliance and consent tracking, particularly in alignment with GDPR requirements. It acts as a browser plugin and server-side application to manage user consent efficiently.
 
 ## Purpose and Functionality
 
-- **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.
+The primary purpose of the TrustArc app is to facilitate privacy compliance by managing user consent through a browser plugin and server-side integration. This is crucial for organizations that need to adhere to data protection regulations such as GDPR. The app provides mechanisms for tracking and managing user consent, ensuring that user data is handled according to legal requirements.
 
 ## Key Implementation Patterns
 
-- **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.
+- **Monorepo Structure**: The app uses a monorepo setup with Yarn workspaces to manage multiple packages (`browser` and `server`) within a single repository.
+- **Azure Functions**: The server-side component is implemented as an Azure Function, which allows for scalable, serverless execution of backend logic.
+- **Build and Deployment Automation**: The app leverages Yarn scripts to automate tasks such as cleaning, building, and deploying the application. This includes specific scripts for development and production environments.
 
 ## External APIs/Services Integrated
 
-- **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.
+- **Azure Functions Core Tools**: This is used for local development and deployment of Azure Functions, providing a seamless development experience for serverless applications.
 
 ## Important Data Transformations
 
-- **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.
+The app likely involves data transformations related to user consent data. While specific transformations are not detailed in the provided code, typical transformations might include:
+
+- **Normalization of Consent Data**: Ensuring that consent information is stored in a consistent format for easy retrieval and processing.
+- **Aggregation of Consent Logs**: Compiling consent actions from multiple users to generate compliance reports.
 
 ## Notable Code Patterns
 
-- **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.
+- **Workspace Management with Yarn**: The use of Yarn workspaces allows for efficient management of dependencies and scripts across multiple packages within the app. This pattern is beneficial for maintaining consistency and reducing redundancy in multi-package projects.
+- **Environment-Specific Builds**: The app differentiates between development and production builds, which is a best practice for optimizing performance and debugging capabilities in different environments.
+- **Automated Dependency Updates**: The use of `npm-check-updates` in the README suggests a proactive approach to keeping dependencies up-to-date, which is crucial for security and compatibility.
 
-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.
+This summary provides a comprehensive understanding of the TrustArc app's implementation, focusing on its architecture, key patterns, and integration points.

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

@@ -1,32 +1,56 @@
-# AI Summary for Seeka Typeform App
+```markdown
+# AI Summary: Typeform Integration 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
-- **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.
+The Typeform integration app is designed to track form submissions and survey responses using Typeform. It leverages webhooks for real-time data capture and integrates with Seeka's platform to manage and respond to form-related events. This app is structured to handle various webhook events, ensuring seamless integration with Typeform for lead capture and survey management.
 
 ## Key Implementation Patterns
-- **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.
+
+### Modular Workspace Structure
+- The app is organized using Yarn workspaces, which allows for modular development across different components: `browser`, `ui`, and `server`.
+- Each component has its own build and development scripts, facilitating isolated development and testing.
+
+### Webhook Handling
+- The server component handles incoming webhooks from Seeka using Azure Functions. The main function `seekaAppWebhook` processes different types of webhook events.
+- Webhook signature validation is implemented to ensure security and authenticity of incoming requests.
+
+### Logging and Monitoring
+- Winston is used for logging, providing detailed logs for webhook events and application state changes.
+- Profiling and verbose logging are utilized for performance monitoring and debugging.
 
 ## External APIs/Services Integrated
-- **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.
+
+### Typeform
+- The app integrates with Typeform to capture form submissions and survey responses through webhooks.
+
+### Seeka Platform
+- Utilizes Seeka's SDK for handling webhook payloads and managing app installation states.
+
+### Azure Functions
+- The server component is deployed as an Azure Function, providing a scalable and reliable execution environment for handling HTTP requests.
 
 ## Important Data Transformations
-- **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.
+
+### Webhook Payload Processing
+- The app processes various webhook payloads, transforming them into actionable events within the Seeka platform.
+- Payloads are parsed and validated, with specific actions triggered based on the webhook type (e.g., `AppInstalled`, `AppUninstalled`).
+
+### Installation State Management
+- The app manages installation states using functions like `createOrUpdateInstallation` and `deleteInstallation`, ensuring the app's state is consistent with Seeka's platform.
 
 ## Notable Code Patterns
-- **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 a high-level understanding of the Seeka Typeform app's architecture and functionality, facilitating AI assistants in referencing and interacting with its implementation.
+### Secure Webhook Validation
+- The function `throwOnInvalidWebhookSignature` is used to validate webhook signatures, ensuring that only legitimate requests are processed.
+
+### Service Initialization
+- The `startServices` function initializes necessary services before processing webhook events, ensuring that all dependencies are ready and available.
+
+### Dynamic Logger Creation
+- The use of `childLogger` allows for dynamic creation of loggers with context-specific information, enhancing the clarity and usefulness of logs.
+
+### Version Management
+- The app includes scripts for version bumping (`bump:patch`, `bump:minor`, `bump:major`) and applies these changes across all workspaces, maintaining consistency in versioning.
+
+This summary provides a comprehensive understanding of the Typeform integration app's architecture, key patterns, and integrations, serving as a reference for AI assistants to understand and interact with the app effectively.
+```

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

@@ -1,28 +1,43 @@
-```markdown
 # AI Summary for Seeka Webhook App
 
+## Overview
+
+The Seeka Webhook app is designed to send Seeka activity data to custom webhook endpoints. It acts as an integration layer, allowing external systems to receive updates about Seeka app activities. The app is built using the Azure Functions template and consists of both server and UI components.
+
 ## Purpose and Functionality
-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.
+
+- **Webhook Handling**: The app processes incoming webhook requests from Seeka, validates them, and performs actions based on the type of webhook event.
+- **Integration**: It integrates with custom endpoints to export data, allowing external systems to react to Seeka app events.
+- **Data Export**: Facilitates the export of activity data to external systems through webhooks.
 
 ## Key Implementation Patterns
-- **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.
+
+- **Azure Functions**: Utilizes Azure Functions to handle HTTP requests, providing a scalable and serverless architecture.
+- **Workspace Management**: Uses Yarn workspaces to manage multiple components (UI and server) within the app.
+- **Logging**: Implements structured logging using Winston to track and debug webhook processing.
+- **Environment Configuration**: Uses environment variables for secure management of sensitive data like webhook secrets.
 
 ## External APIs/Services Integrated
-- **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.
+
+- **Azure Functions**: The app is deployed as an Azure Function, leveraging its capabilities for handling HTTP requests and scaling.
+- **Seeka SDK**: Integrates with the Seeka SDK to handle specific webhook payloads and validate webhook signatures.
 
 ## Important Data Transformations
-- **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`.
+
+- **Payload Parsing**: Converts incoming webhook request bodies from JSON strings to structured payload objects for processing.
+- **Installation State Management**: Transforms webhook payload data into installation state objects, updating or creating records in the app's state management system.
 
 ## Notable Code Patterns
-- **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 app serves as a template for building scalable and maintainable webhook integrations, leveraging serverless architecture and modern development practices.
-```
+
+- **Webhook Signature Validation**: Implements a robust pattern for validating webhook signatures to ensure the authenticity of incoming requests.
+- **Conditional Processing**: Uses a switch-case structure to handle different types of webhook events, allowing for extensible and organized event handling.
+- **Error Handling**: Includes comprehensive error handling and logging to capture and report issues during webhook processing.
+- **Service Initialization**: Uses a service start pattern to initialize necessary services before processing webhook events.
+
+## Reusable Code Patterns
+
+- **Logger Initialization**: The pattern for initializing and using a logger can be reused in other applications requiring structured logging.
+- **Webhook Validation**: The signature validation pattern is a reusable security measure for any application dealing with webhooks.
+- **State Management**: The approach to managing installation states can be adapted for other applications requiring similar state tracking mechanisms.
+
+This summary provides a high-level understanding of the Seeka Webhook app's architecture, functionality, and implementation patterns, serving as a reference for AI assistants.